Use const/let instead of var

As mentioned in slevithan/xregexp#108 (comment)

This was done with the help of [lebab], using `lebeb --replace src --transform let`.

[lebab]: https://github.com/lebab/lebab

src/addons/build.js

@@ -7,9 +7,9 @@
 module.exports = function(XRegExp) {
     'use strict';
 
-    var REGEX_DATA = 'xregexp';
-    var subParts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g;
-    var parts = XRegExp.union([/\({{([\w$]+)}}\)|{{([\w$]+)}}/, subParts], 'g', {
+    const REGEX_DATA = 'xregexp';
+    const subParts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g;
+    const parts = XRegExp.union([/\({{([\w$]+)}}\)|{{([\w$]+)}}/, subParts], 'g', {
         conjunction: 'or'
     });
 
@@ -23,8 +23,8 @@ module.exports = function(XRegExp) {
     function deanchor(pattern) {
         // Allow any number of empty noncapturing groups before/after anchors, because regexes
         // built/generated by XRegExp sometimes include them
-        var leadingAnchor = /^(?:\(\?:\))*\^/;
-        var trailingAnchor = /\$(?:\(\?:\))*$/;
+        const leadingAnchor = /^(?:\(\?:\))*\^/;
+        const trailingAnchor = /\$(?:\(\?:\))*$/;
 
         if (
             leadingAnchor.test(pattern) &&
@@ -48,7 +48,7 @@ module.exports = function(XRegExp) {
      * @returns {RegExp} XRegExp object with XRegExp syntax applied.
      */
     function asXRegExp(value, addFlagX) {
-        var flags = addFlagX ? 'x' : '';
+        const flags = addFlagX ? 'x' : '';
         return XRegExp.isRegExp(value) ?
             (value[REGEX_DATA] && value[REGEX_DATA].captureNames ?
                 // Don't recompile, to preserve capture names
@@ -70,7 +70,7 @@ module.exports = function(XRegExp) {
     }
 
     function embedSubpatternAfter(raw, subpatternIndex, rawLiterals) {
-        var hasSubpattern = subpatternIndex < rawLiterals.length - 1;
+        const hasSubpattern = subpatternIndex < rawLiterals.length - 1;
         return raw + (hasSubpattern ? '{{subpattern' + subpatternIndex + '}}' : '');
     }
 
@@ -89,19 +89,19 @@ module.exports = function(XRegExp) {
      * @returns {Function} Handler for template literals that construct regexes with XRegExp syntax.
      * @example
      *
-     * var h12 = /1[0-2]|0?[1-9]/;
-     * var h24 = /2[0-3]|[01][0-9]/;
-     * var hours = XRegExp.tag('x')`${h12} : | ${h24}`;
-     * var minutes = /^[0-5][0-9]$/;
+     * const h12 = /1[0-2]|0?[1-9]/;
+     * const h24 = /2[0-3]|[01][0-9]/;
+     * const hours = XRegExp.tag('x')`${h12} : | ${h24}`;
+     * const minutes = /^[0-5][0-9]$/;
      * // Note that explicitly naming the 'minutes' group is required for named backreferences
-     * var time = XRegExp.tag('x')`^ ${hours} (?<minutes>${minutes}) $`;
+     * const time = XRegExp.tag('x')`^ ${hours} (?<minutes>${minutes}) $`;
      * time.test('10:59'); // -> true
      * XRegExp.exec('10:59', time).minutes; // -> '59'
      */
     XRegExp.tag = function(flags) {
         return function(literals, ...substitutions) {
-            var subpatterns = substitutions.map(interpolate).reduce(reduceToSubpatternsObject, {});
-            var pattern = literals.raw.map(embedSubpatternAfter).join('');
+            const subpatterns = substitutions.map(interpolate).reduce(reduceToSubpatternsObject, {});
+            const pattern = literals.raw.map(embedSubpatternAfter).join('');
             return XRegExp.build(pattern, subpatterns, flags);
         };
     };
@@ -121,7 +121,7 @@ module.exports = function(XRegExp) {
      * @returns {RegExp} Regex with interpolated subpatterns.
      * @example
      *
-     * var time = XRegExp.build('(?x)^ {{hours}} ({{minutes}}) $', {
+     * const time = XRegExp.build('(?x)^ {{hours}} ({{minutes}}) $', {
      *   hours: XRegExp.build('{{h12}} : | {{h24}}', {
      *     h12: /1[0-2]|0?[1-9]/,
      *     h24: /2[0-3]|[01][0-9]/
@@ -136,21 +136,21 @@ module.exports = function(XRegExp) {
         // Used with `asXRegExp` calls for `pattern` and subpatterns in `subs`, to work around how
         // some browsers convert `RegExp('\n')` to a regex that contains the literal characters `\`
         // and `n`. See more details at <https://github.com/slevithan/xregexp/pull/163>.
-        var addFlagX = flags.indexOf('x') > -1;
-        var inlineFlags = /^\(\?([\w$]+)\)/.exec(pattern);
+        const addFlagX = flags.indexOf('x') > -1;
+        const inlineFlags = /^\(\?([\w$]+)\)/.exec(pattern);
         // Add flags within a leading mode modifier to the overall pattern's flags
         if (inlineFlags) {
             flags = XRegExp._clipDuplicates(flags + inlineFlags[1]);
         }
 
-        var data = {};
-        for (var p in subs) {
+        const data = {};
+        for (const p in subs) {
             if (subs.hasOwnProperty(p)) {
                 // Passing to XRegExp enables extended syntax and ensures independent validity,
                 // lest an unescaped `(`, `)`, `[`, or trailing `\` breaks the `(?:)` wrapper. For
                 // subpatterns provided as native regexes, it dies on octals and adds the property
                 // used to hold extended regex instance data, for simplicity.
-                var sub = asXRegExp(subs[p], addFlagX);
+                const sub = asXRegExp(subs[p], addFlagX);
                 data[p] = {
                     // Deanchoring allows embedding independently useful anchored regexes. If you
                     // really need to keep your anchors, double them (i.e., `^^...$$`).
@@ -162,19 +162,19 @@ module.exports = function(XRegExp) {
 
         // Passing to XRegExp dies on octals and ensures the outer pattern is independently valid;
         // helps keep this simple. Named captures will be put back.
-        var patternAsRegex = asXRegExp(pattern, addFlagX);
+        const patternAsRegex = asXRegExp(pattern, addFlagX);
 
         // 'Caps' is short for 'captures'
-        var numCaps = 0;
-        var numPriorCaps;
-        var numOuterCaps = 0;
-        var outerCapsMap = [0];
-        var outerCapNames = patternAsRegex[REGEX_DATA].captureNames || [];
-        var output = patternAsRegex.source.replace(parts, function($0, $1, $2, $3, $4) {
-            var subName = $1 || $2;
-            var capName;
-            var intro;
-            var localCapIndex;
+        let numCaps = 0;
+        let numPriorCaps;
+        let numOuterCaps = 0;
+        const outerCapsMap = [0];
+        const outerCapNames = patternAsRegex[REGEX_DATA].captureNames || [];
+        const output = patternAsRegex.source.replace(parts, function($0, $1, $2, $3, $4) {
+            const subName = $1 || $2;
+            let capName;
+            let intro;
+            let localCapIndex;
             // Named subpattern
             if (subName) {
                 if (!data.hasOwnProperty(subName)) {

src/addons/matchrecursive.js

@@ -36,7 +36,7 @@ module.exports = function(XRegExp) {
      * @example
      *
      * // Basic usage
-     * var str = '(t((e))s)t()(ing)';
+     * let str = '(t((e))s)t()(ing)';
      * XRegExp.matchRecursive(str, '\\(', '\\)', 'g');
      * // -> ['t((e))s', '', 'ing']
      *
@@ -74,22 +74,22 @@ module.exports = function(XRegExp) {
     XRegExp.matchRecursive = function(str, left, right, flags, options) {
         flags = flags || '';
         options = options || {};
-        var global = flags.indexOf('g') > -1;
-        var sticky = flags.indexOf('y') > -1;
+        const global = flags.indexOf('g') > -1;
+        const sticky = flags.indexOf('y') > -1;
         // Flag `y` is controlled internally
-        var basicFlags = flags.replace(/y/g, '');
-        var escapeChar = options.escapeChar;
-        var vN = options.valueNames;
-        var output = [];
-        var openTokens = 0;
-        var delimStart = 0;
-        var delimEnd = 0;
-        var lastOuterEnd = 0;
-        var outerStart;
-        var innerStart;
-        var leftMatch;
-        var rightMatch;
-        var esc;
+        const basicFlags = flags.replace(/y/g, '');
+        let escapeChar = options.escapeChar;
+        const vN = options.valueNames;
+        const output = [];
+        let openTokens = 0;
+        let delimStart = 0;
+        let delimEnd = 0;
+        let lastOuterEnd = 0;
+        let outerStart;
+        let innerStart;
+        let leftMatch;
+        let rightMatch;
+        let esc;
         left = XRegExp(left, basicFlags);
         right = XRegExp(right, basicFlags);
 

src/addons/unicode-base.js

@@ -26,12 +26,12 @@ module.exports = function(XRegExp) {
     // ==--------------------------==
 
     // Storage for Unicode data
-    var unicode = {};
+    const unicode = {};
 
     // Reuse utils
-    var dec = XRegExp._dec;
-    var hex = XRegExp._hex;
-    var pad4 = XRegExp._pad4;
+    const dec = XRegExp._dec;
+    const hex = XRegExp._hex;
+    const pad4 = XRegExp._pad4;
 
     // Generates a token lookup name: lowercase, with hyphens, spaces, and underscores removed
     function normalize(name) {
@@ -40,22 +40,22 @@ module.exports = function(XRegExp) {
 
     // Gets the decimal code of a literal code unit, \xHH, \uHHHH, or a backslash-escaped literal
     function charCode(chr) {
-        var esc = /^\\[xu](.+)/.exec(chr);
+        const esc = /^\\[xu](.+)/.exec(chr);
         return esc ?
             dec(esc[1]) :
             chr.charCodeAt(chr.charAt(0) === '\\' ? 1 : 0);
     }
 
     // Inverts a list of ordered BMP characters and ranges
     function invertBmp(range) {
-        var output = '';
-        var lastEnd = -1;
+        let output = '';
+        let lastEnd = -1;
 
         XRegExp.forEach(
             range,
             /(\\x..|\\u....|\\?[\s\S])(?:-(\\x..|\\u....|\\?[\s\S]))?/,
             function(m) {
-                var start = charCode(m[1]);
+                const start = charCode(m[1]);
                 if (start > (lastEnd + 1)) {
                     output += '\\u' + pad4(hex(lastEnd + 1));
                     if (start > (lastEnd + 2)) {
@@ -78,7 +78,7 @@ module.exports = function(XRegExp) {
 
     // Generates an inverted BMP range on first use
     function cacheInvertedBmp(slug) {
-        var prop = 'b!';
+        const prop = 'b!';
         return (
             unicode[slug][prop] ||
             (unicode[slug][prop] = invertBmp(unicode[slug].bmp))
@@ -87,8 +87,8 @@ module.exports = function(XRegExp) {
 
     // Combines and optionally negates BMP and astral data
     function buildAstral(slug, isNegated) {
-        var item = unicode[slug];
-        var combined = '';
+        const item = unicode[slug];
+        let combined = '';
 
         if (item.bmp && !item.isBmpLast) {
             combined = '[' + item.bmp + ']' + (item.astral ? '|' : '');
@@ -108,7 +108,7 @@ module.exports = function(XRegExp) {
 
     // Builds a complete astral pattern on first use
     function cacheAstral(slug, isNegated) {
-        var prop = isNegated ? 'a!' : 'a=';
+        const prop = isNegated ? 'a!' : 'a=';
         return (
             unicode[slug][prop] ||
             (unicode[slug][prop] = buildAstral(slug, isNegated))
@@ -126,19 +126,19 @@ module.exports = function(XRegExp) {
         // Use `*` instead of `+` to avoid capturing `^` as the token name in `\p{^}`
         /\\([pP])(?:{(\^?)([^}]*)}|([A-Za-z]))/,
         function(match, scope, flags) {
-            var ERR_DOUBLE_NEG = 'Invalid double negation ';
-            var ERR_UNKNOWN_NAME = 'Unknown Unicode token ';
-            var ERR_UNKNOWN_REF = 'Unicode token missing data ';
-            var ERR_ASTRAL_ONLY = 'Astral mode required for Unicode token ';
-            var ERR_ASTRAL_IN_CLASS = 'Astral mode does not support Unicode tokens within character classes';
+            const ERR_DOUBLE_NEG = 'Invalid double negation ';
+            const ERR_UNKNOWN_NAME = 'Unknown Unicode token ';
+            const ERR_UNKNOWN_REF = 'Unicode token missing data ';
+            const ERR_ASTRAL_ONLY = 'Astral mode required for Unicode token ';
+            const ERR_ASTRAL_IN_CLASS = 'Astral mode does not support Unicode tokens within character classes';
             // Negated via \P{..} or \p{^..}
-            var isNegated = match[1] === 'P' || !!match[2];
+            let isNegated = match[1] === 'P' || !!match[2];
             // Switch from BMP (0-FFFF) to astral (0-10FFFF) mode via flag A
-            var isAstralMode = flags.indexOf('A') > -1;
+            const isAstralMode = flags.indexOf('A') > -1;
             // Token lookup name. Check `[4]` first to avoid passing `undefined` via `\p{}`
-            var slug = normalize(match[4] || match[3]);
+            let slug = normalize(match[4] || match[3]);
             // Token data object
-            var item = unicode[slug];
+            let item = unicode[slug];
 
             if (match[1] === 'P' && match[2]) {
                 throw new SyntaxError(ERR_DOUBLE_NEG + match[0]);
@@ -208,11 +208,11 @@ module.exports = function(XRegExp) {
      * XRegExp('\\p{XDigit}:\\p{Hexadecimal}+').test('0:3D'); // -> true
      */
     XRegExp.addUnicodeData = function(data) {
-        var ERR_NO_NAME = 'Unicode token requires name';
-        var ERR_NO_DATA = 'Unicode token has no character data ';
-        var item;
+        const ERR_NO_NAME = 'Unicode token requires name';
+        const ERR_NO_DATA = 'Unicode token has no character data ';
+        let item;
 
-        for (var i = 0; i < data.length; ++i) {
+        for (let i = 0; i < data.length; ++i) {
             item = data[i];
             if (!item.name) {
                 throw new Error(ERR_NO_NAME);
@@ -253,7 +253,7 @@ module.exports = function(XRegExp) {
      * structures set up by XRegExp.
      */
     XRegExp._getUnicodeProperty = function(name) {
-        var slug = normalize(name);
+        const slug = normalize(name);
         return unicode[slug];
     };
 

src/index.js

@@ -1,4 +1,4 @@
-var XRegExp = require('./xregexp');
+const XRegExp = require('./xregexp');
 
 require('./addons/build')(XRegExp);
 require('./addons/matchrecursive')(XRegExp);