Rewrite createRegExpRestore for shorter expressions

Previously createRegExpRestore build a regex with the exact characters for each part of the expression (either capturing group, or segment between capturing groups).  The new solution begins with this approach, and then shortens the resulting expression by replacing each segment with a match for character count only, then setting lastIndex on the resultant RegExp to ensure that the match occurs at the expected location in the input.

Author: Mike Lewis

package.json

@@ -72,7 +72,7 @@
     "build:dist": "npm run build:dist:dev && npm run build:dist:prod",
     "build": "npm run build:data && npm run build:lib && npm run build:dist",
     "lint": "eslint .",
-    "test": "cd tests && node polyfilling.js && node sanity.js && node noderunner.js && node saucelabs.js && node disableregexprestore.js",
+    "test": "cd tests && node polyfilling.js && node sanity.js && node disableregexprestore.js && node noderunner.js && node saucelabs.js",
     "pretest": "npm run lint",
     "preversion": "npm run clean && npm run build && npm run test",
     "prepublish": "npm run clean && npm run build"

src/util.js

@@ -133,49 +133,68 @@ List.prototype = objCreate(null);
  */
 export function createRegExpRestore () {
     if (internals.disableRegExpRestore) {
-        return { exp: /a/, input: 'a' };
+        return function() { /* no-op */ };
     }
 
-    let esc = /[.?*+^$[\]\\(){}|-]/g,
-        lm  = RegExp.lastMatch || '',
-        ml  = RegExp.multiline ? 'm' : '',
-        ret = { input: RegExp.input },
-        reg = new List(),
-        has = false,
-        cap = {};
+    let regExpCache = {
+            lastMatch: RegExp.lastMatch || '',
+            leftContext: RegExp.leftContext,
+            multiline: RegExp.multiline,
+            input: RegExp.input
+        },
+        has = false;
 
     // Create a snapshot of all the 'captured' properties
     for (let i = 1; i <= 9; i++)
-        has = (cap['$'+i] = RegExp['$'+i]) || has;
-
-    // Now we've snapshotted some properties, escape the lastMatch string
-    lm = lm.replace(esc, '\\$&');
+        has = (regExpCache['$'+i] = RegExp['$'+i]) || has;
+
+    return function() {
+        // Now we've snapshotted some properties, escape the lastMatch string
+        let esc = /[.?*+^$[\]\\(){}|-]/g,
+            lm = regExpCache.lastMatch.replace(esc, '\\$&'),
+            reg = new List();
+
+        // If any of the captured strings were non-empty, iterate over them all
+        if (has) {
+            for (let i = 1; i <= 9; i++) {
+                let m = regExpCache['$'+i];
+
+                // If it's empty, add an empty capturing group
+                if (!m)
+                    lm = '()' + lm;
+
+                // Else find the string in lm and escape & wrap it to capture it
+                else {
+                    m = m.replace(esc, '\\$&');
+                    lm = lm.replace(m, '(' + m + ')');
+                }
 
-    // If any of the captured strings were non-empty, iterate over them all
-    if (has) {
-        for (let i = 1; i <= 9; i++) {
-            let m = cap['$'+i];
+                // Push it to the reg and chop lm to make sure further groups come after
+                arrPush.call(reg, lm.slice(0, lm.indexOf('(') + 1));
+                lm = lm.slice(lm.indexOf('(') + 1);
+            }
+        }
 
-            // If it's empty, add an empty capturing group
-            if (!m)
-                lm = '()' + lm;
+        let exprStr = arrJoin.call(reg, '') + lm;
 
-            // Else find the string in lm and escape & wrap it to capture it
-            else {
-                m = m.replace(esc, '\\$&');
-                lm = lm.replace(m, '(' + m + ')');
-            }
+        // Shorten the regex by replacing each part of the expression with a match
+        // for a string of that exact length.  This is safe for the type of
+        // expressions generated above, because the expression matches the whole
+        // match string, so we know each group and each segment between capturing
+        // groups can be matched by its length alone.
+        exprStr = exprStr.replace(/(\\\(|\\\)|[^()])+/g, (match) => {
+            return `[\\s\\S]{${match.replace('\\','').length}}`;
+        });
 
-            // Push it to the reg and chop lm to make sure further groups come after
-            arrPush.call(reg, lm.slice(0, lm.indexOf('(') + 1));
-            lm = lm.slice(lm.indexOf('(') + 1);
-        }
-    }
+        // Create the regular expression that will reconstruct the RegExp properties
+        let expr = new RegExp(exprStr, regExpCache.multiline ? 'gm' : 'g');
 
-    // Create the regular expression that will reconstruct the RegExp properties
-    ret.exp = new RegExp(arrJoin.call(reg, '') + lm, ml);
+        // Set the lastIndex of the generated expression to ensure that the match
+        // is found in the correct index.
+        expr.lastIndex = regExpCache.leftContext.length;
 
-    return ret;
+        expr.exec(regExpCache.input);
+    };
 }
 
 /**

tests/sanity.js

@@ -57,3 +57,11 @@ assert(new IntlPolyfill.DateTimeFormat('en', {
 assert(new IntlPolyfill.DateTimeFormat('en-us', {
     month:'long',
 }).format(new Date(2016, 0, 1)), 'January', 'month should be long');
+
+// issue #196
+(new Array(32768 + 1)).join('a').match(/^a*$/);
+assert(new IntlPolyfill.NumberFormat('de-DE', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+}).format(0.015), "0,02", 'RegExp too big warning');
+'a'.match(/a/);