re2js 0.4.3 → 1.0.1

package/build/index.esm.d.ts

@@ -120,6 +120,17 @@ export class RE2JS {
      * @returns {string}
      */
     toString(): string;
+    /**
+     * Returns the program size of this pattern.
+     *
+     * <p>
+     * Similar to the C++ implementation, the program size is a very approximate measure of a regexp's
+     * "cost". Larger numbers are more expensive than smaller numbers.
+     * </p>
+     *
+     * @returns {number} the program size of this pattern
+     */
+    programSize(): number;
     /**
      * Returns the number of capturing groups in this matcher's pattern. Group zero denotes the entire
      * pattern and is excluded from this count.
@@ -215,6 +226,7 @@ declare class Matcher {
     patternGroupCount: any;
     groups: any[];
     namedGroups: any;
+    numberOfInstructions: any;
     /**
      * Returns the {@code RE2JS} associated with this {@code Matcher}.
      * @returns {RE2JS}
@@ -251,6 +263,17 @@ declare class Matcher {
      * @returns {string}
      */
     end(group?: string | number): string;
+    /**
+     * Returns the program size of this pattern.
+     *
+     * <p>
+     * Similar to the C++ implementation, the program size is a very approximate measure of a regexp's
+     * "cost". Larger numbers are more expensive than smaller numbers.
+     * </p>
+     *
+     * @return the program size of this pattern
+     */
+    programSize(): any;
     /**
      * Returns the named group of the most recent match, or {@code null} if the group was not matched.
      * @param {string|number} [group=0]

package/build/index.esm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"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"}

package/build/index.esm.js

@@ -2,7 +2,7 @@
  * re2js
  * RE2JS is the JavaScript port of RE2, a regular expression engine that provides linear time matching
  *
- * @version v0.4.3
+ * @version v1.0.1
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -926,6 +926,7 @@ class Matcher {
     // The group indexes, in [start, end) pairs.  Zeroth pair is overall match.
     this.groups = [];
     this.namedGroups = re2.namedGroups;
+    this.numberOfInstructions = re2.numberOfInstructions();
     if (input instanceof MatcherInputBase) {
       this.resetMatcherInput(input);
     } else if (Array.isArray(input)) {
@@ -1012,6 +1013,20 @@ class Matcher {
     return this.groups[2 * group + 1];
   }
 
+  /**
+   * Returns the program size of this pattern.
+   *
+   * <p>
+   * Similar to the C++ implementation, the program size is a very approximate measure of a regexp's
+   * "cost". Larger numbers are more expensive than smaller numbers.
+   * </p>
+   *
+   * @return the program size of this pattern
+   */
+  programSize() {
+    return this.numberOfInstructions;
+  }
+
   /**
    * Returns the named group of the most recent match, or {@code null} if the group was not matched.
    * @param {string|number} [group=0]
@@ -1652,7 +1667,7 @@ class Regexp {
     // subexpressions, if any.  Never null.
     // subs[0] is used as the freelist.
     this.subs = Regexp.emptySubs();
-    this.runes = null; // matched runes, for LITERAL, CHAR_CLASS
+    this.runes = []; // matched runes, for LITERAL, CHAR_CLASS
     this.min = 0; // min for REPEAT
     this.max = 0; // max for REPEAT
     this.cap = 0; // capturing index, for CAPTURE
@@ -1662,7 +1677,7 @@ class Regexp {
   reinit() {
     this.flags = 0;
     this.subs = Regexp.emptySubs();
-    this.runes = null;
+    this.runes = [];
     this.cap = 0;
     this.min = 0;
     this.max = 0;
@@ -1963,7 +1978,7 @@ class Inst {
     this.arg = 0; // ALT, ALT_MATCH, CAPTURE, EMPTY_WIDTH
     // length==1 => exact match
     // otherwise a list of [lo,hi] pairs.  hi is *inclusive*.
-    this.runes = null;
+    this.runes = [];
   }
 
   // MatchRune returns true if the instruction matches (and consumes) r.
@@ -2357,7 +2372,7 @@ class Compiler {
     i.runes = runes;
     flags &= RE2Flags.FOLD_CASE;
     if (runes.length !== 1 || Unicode.simpleFold(runes[0]) === runes[0]) {
-      flags &= ~RE2Flags.FOLD_CASE;
+      flags &= -2;
     }
     i.arg = flags;
     f.out = f.i << 1;
@@ -2474,7 +2489,7 @@ class Simplify {
             const nsub = Simplify.simplify(sub);
             if (nre === re && nsub !== sub) {
               nre = Regexp.fromRegexp(re);
-              nre.runes = null;
+              nre.runes = [];
               nre.subs = re.subs.slice(0, re.subs.length);
             }
             if (nre !== re) {
@@ -2615,7 +2630,7 @@ class CharGroup {
 const code1 = [0x30, 0x39];
 const code2 = [0x9, 0xa, 0xc, 0xd, 0x20, 0x20];
 const code3 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a];
-const PERL_GROUPS = new Map([['\\d', new CharGroup(+1, code1)], ['\\D', new CharGroup(-1, code1)], ['\\s', new CharGroup(+1, code2)], ['\\S', new CharGroup(-1, code2)], ['\\w', new CharGroup(+1, code3)], ['\\W', new CharGroup(-1, code3)]]);
+const PERL_GROUPS = new Map([['\\d', new CharGroup(1, code1)], ['\\D', new CharGroup(-1, code1)], ['\\s', new CharGroup(1, code2)], ['\\S', new CharGroup(-1, code2)], ['\\w', new CharGroup(1, code3)], ['\\W', new CharGroup(-1, code3)]]);
 const code4 = [0x30, 0x39, 0x41, 0x5a, 0x61, 0x7a];
 const code5 = [0x41, 0x5a, 0x61, 0x7a];
 const code6 = [0x0, 0x7f];
@@ -2630,7 +2645,7 @@ const code14 = [0x9, 0xd, 0x20, 0x20];
 const code15 = [0x41, 0x5a];
 const code16 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a];
 const code17 = [0x30, 0x39, 0x41, 0x46, 0x61, 0x66];
-const POSIX_GROUPS = new Map([['[:alnum:]', new CharGroup(+1, code4)], ['[:^alnum:]', new CharGroup(-1, code4)], ['[:alpha:]', new CharGroup(+1, code5)], ['[:^alpha:]', new CharGroup(-1, code5)], ['[:ascii:]', new CharGroup(+1, code6)], ['[:^ascii:]', new CharGroup(-1, code6)], ['[:blank:]', new CharGroup(+1, code7)], ['[:^blank:]', new CharGroup(-1, code7)], ['[:cntrl:]', new CharGroup(+1, code8)], ['[:^cntrl:]', new CharGroup(-1, code8)], ['[:digit:]', new CharGroup(+1, code9)], ['[:^digit:]', new CharGroup(-1, code9)], ['[:graph:]', new CharGroup(+1, code10)], ['[:^graph:]', new CharGroup(-1, code10)], ['[:lower:]', new CharGroup(+1, code11)], ['[:^lower:]', new CharGroup(-1, code11)], ['[:print:]', new CharGroup(+1, code12)], ['[:^print:]', new CharGroup(-1, code12)], ['[:punct:]', new CharGroup(+1, code13)], ['[:^punct:]', new CharGroup(-1, code13)], ['[:space:]', new CharGroup(+1, code14)], ['[:^space:]', new CharGroup(-1, code14)], ['[:upper:]', new CharGroup(+1, code15)], ['[:^upper:]', new CharGroup(-1, code15)], ['[:word:]', new CharGroup(+1, code16)], ['[:^word:]', new CharGroup(-1, code16)], ['[:xdigit:]', new CharGroup(+1, code17)], ['[:^xdigit:]', new CharGroup(-1, code17)]]);
+const POSIX_GROUPS = new Map([['[:alnum:]', new CharGroup(1, code4)], ['[:^alnum:]', new CharGroup(-1, code4)], ['[:alpha:]', new CharGroup(1, code5)], ['[:^alpha:]', new CharGroup(-1, code5)], ['[:ascii:]', new CharGroup(1, code6)], ['[:^ascii:]', new CharGroup(-1, code6)], ['[:blank:]', new CharGroup(1, code7)], ['[:^blank:]', new CharGroup(-1, code7)], ['[:cntrl:]', new CharGroup(1, code8)], ['[:^cntrl:]', new CharGroup(-1, code8)], ['[:digit:]', new CharGroup(1, code9)], ['[:^digit:]', new CharGroup(-1, code9)], ['[:graph:]', new CharGroup(1, code10)], ['[:^graph:]', new CharGroup(-1, code10)], ['[:lower:]', new CharGroup(1, code11)], ['[:^lower:]', new CharGroup(-1, code11)], ['[:print:]', new CharGroup(1, code12)], ['[:^print:]', new CharGroup(-1, code12)], ['[:punct:]', new CharGroup(1, code13)], ['[:^punct:]', new CharGroup(-1, code13)], ['[:space:]', new CharGroup(1, code14)], ['[:^space:]', new CharGroup(-1, code14)], ['[:upper:]', new CharGroup(1, code15)], ['[:^upper:]', new CharGroup(-1, code15)], ['[:word:]', new CharGroup(1, code16)], ['[:^word:]', new CharGroup(-1, code16)], ['[:xdigit:]', new CharGroup(1, code17)], ['[:^xdigit:]', new CharGroup(-1, code17)]]);
 
 /**
  * A "builder"-style helper class for manipulating character classes represented as an array of
@@ -2669,7 +2684,7 @@ class CharClass {
   // qsortIntPair() quicksorts pairs of ints in |array| according to lt().
   // Precondition: |left|, |right|, |this.len| must all be even; |this.len > 1|.
   static qsortIntPair(array, left, right) {
-    const pivotIndex = ((left + right) / 2 | 0) & ~1;
+    const pivotIndex = ((left + right) / 2 | 0) & -2;
     const pivotFrom = array[pivotIndex];
     const pivotTo = array[pivotIndex + 1];
     let i = left;
@@ -3054,6 +3069,48 @@ class Parser {
   static ERR_MISSING_REPEAT_ARGUMENT = 'missing argument to repetition operator';
   static ERR_TRAILING_BACKSLASH = 'trailing backslash at end of expression';
   static ERR_DUPLICATE_NAMED_CAPTURE = 'duplicate capture group name';
+  static ERR_UNEXPECTED_PAREN = 'unexpected )';
+  static ERR_NESTING_DEPTH = 'expression nests too deeply';
+  static ERR_LARGE = 'expression too large';
+
+  // maxHeight is the maximum height of a regexp parse tree.
+  // It is somewhat arbitrarily chosen, but the idea is to be large enough
+  // that no one will actually hit in real use but at the same time small enough
+  // that recursion on the Regexp tree will not hit the 1GB Go stack limit.
+  // The maximum amount of stack for a single recursive frame is probably
+  // closer to 1kB, so this could potentially be raised, but it seems unlikely
+  // that people have regexps nested even this deeply.
+  // We ran a test on Google's C++ code base and turned up only
+  // a single use case with depth > 100; it had depth 128.
+  // Using depth 1000 should be plenty of margin.
+  // As an optimization, we don't even bother calculating heights
+  // until we've allocated at least maxHeight Regexp structures.
+  static MAX_HEIGHT = 1000;
+
+  // maxSize is the maximum size of a compiled regexp in Insts.
+  // It too is somewhat arbitrarily chosen, but the idea is to be large enough
+  // to allow significant regexps while at the same time small enough that
+  // the compiled form will not take up too much memory.
+  // 128 MB is enough for a 3.3 million Inst structures, which roughly
+  // corresponds to a 3.3 MB regexp.
+  static MAX_SIZE = 3355443; // 128 << 20 / (5 * 8) (instSize = byte, 2 uint32, slice is 5 64-bit words)
+
+  // maxRunes is the maximum number of runes allowed in a regexp tree
+  // counting the runes in all the nodes.
+  // Ignoring character classes p.numRunes is always less than the length of the regexp.
+  // Character classes can make it much larger: each \pL adds 1292 runes.
+  // 128 MB is enough for 32M runes, which is over 26k \pL instances.
+  // Note that repetitions do not make copies of the rune slices,
+  // so \pL{1000} is only one rune slice, not 1000.
+  // We could keep a cache of character classes we've seen,
+  // so that all the \pL we see use the same rune list,
+  // but that doesn't remove the problem entirely:
+  // consider something like [\pL01234][\pL01235][\pL01236]...[\pL^&*()].
+  // And because the Rune slice is exposed directly in the Regexp,
+  // there is not an opportunity to change the representation to allow
+  // partial sharing between different character classes.
+  // So the limit is the best we can do.
+  static MAX_RUNES = 33554432; // 128 << 20 / 4 (runeSize, int32 is 4 bytes)
 
   // RangeTables are represented as int[][], a list of triples (start, end,
   // stride).
@@ -3352,7 +3409,7 @@ class Parser {
       case Codepoint.CODES.get('v'):
         return Codepoint.CODES.get('\v');
       default:
-        if (!Utils.isalnum(c)) {
+        if (c <= Unicode.MAX_ASCII && !Utils.isalnum(c)) {
           return c;
         }
         break;
@@ -3386,6 +3443,12 @@ class Parser {
     // Stack of parsed expressions.
     this.stack = [];
     this.free = null;
+    // checks
+    this.numRegexp = 0; // number of regexps allocated
+    this.numRunes = 0; // number of runes in char classes
+    this.repeats = 0; // product of all repetitions seen
+    this.height = null; // regexp height, for height limit check
+    this.size = null; // regexp compiled size, for size limit check
   }
 
   // Allocate a Regexp, from the free list if possible.
@@ -3397,15 +3460,159 @@ class Parser {
       re.op = op;
     } else {
       re = new Regexp(op);
+      this.numRegexp += 1;
     }
     return re;
   }
   reuse(re) {
+    if (this.height !== null && Object.prototype.hasOwnProperty.call(this.height, re)) {
+      delete this.height[re];
+    }
     if (re.subs !== null && re.subs.length > 0) {
       re.subs[0] = this.free;
     }
     this.free = re;
   }
+  checkLimits(re) {
+    if (this.numRunes > Parser.MAX_RUNES) {
+      throw new RE2JSSyntaxException(Parser.ERR_LARGE);
+    }
+    this.checkSize(re);
+    this.checkHeight(re);
+  }
+  checkSize(re) {
+    if (this.size === null) {
+      // We haven't started tracking size yet.
+      // Do a relatively cheap check to see if we need to start.
+      // Maintain the product of all the repeats we've seen
+      // and don't track if the total number of regexp nodes
+      // we've seen times the repeat product is in budget.
+      if (this.repeats === 0) {
+        this.repeats = 1;
+      }
+      if (re.op === Regexp.Op.REPEAT) {
+        let n = re.max;
+        if (n === -1) {
+          n = re.min;
+        }
+        if (n <= 0) {
+          n = 1;
+        }
+        if (n > Parser.MAX_SIZE / this.repeats) {
+          this.repeats = Parser.MAX_SIZE;
+        } else {
+          this.repeats *= n;
+        }
+      }
+      if (this.numRegexp < Parser.MAX_SIZE / this.repeats) {
+        return;
+      }
+
+      // We need to start tracking size.
+      // Make the map and belatedly populate it
+      // with info about everything we've constructed so far.
+      this.size = {};
+      for (let reEx of this.stack) {
+        this.checkSize(reEx);
+      }
+    }
+    if (this.calcSize(re, true) > Parser.MAX_SIZE) {
+      throw new RE2JSSyntaxException(Parser.ERR_LARGE);
+    }
+  }
+  calcSize(re, force = false) {
+    if (!force) {
+      if (Object.prototype.hasOwnProperty.call(this.size, re)) {
+        return this.size[re];
+      }
+    }
+    let size = 0;
+    switch (re.op) {
+      case Regexp.Op.LITERAL:
+        {
+          size = re.runes.length;
+          break;
+        }
+      case Regexp.Op.CAPTURE:
+      case Regexp.Op.STAR:
+        {
+          // star can be 1+ or 2+; assume 2 pessimistically
+          size = 2 + this.calcSize(re.subs[0]);
+          break;
+        }
+      case Regexp.Op.PLUS:
+      case Regexp.Op.QUEST:
+        {
+          size = 1 + this.calcSize(re.subs[0]);
+          break;
+        }
+      case Regexp.Op.CONCAT:
+        {
+          for (let sub of re.subs) {
+            size = size + this.calcSize(sub);
+          }
+          break;
+        }
+      case Regexp.Op.ALTERNATE:
+        {
+          for (let sub of re.subs) {
+            size = size + this.calcSize(sub);
+          }
+          if (re.subs.length > 1) {
+            size = size + re.subs.length - 1;
+          }
+          break;
+        }
+      case Regexp.Op.REPEAT:
+        {
+          let sub = this.calcSize(re.subs[0]);
+          if (re.max === -1) {
+            if (re.min === 0) {
+              size = 2 + sub; // x*
+            } else {
+              size = 1 + re.min * sub; // xxx+
+            }
+            break;
+          }
+          // x{2,5} = xx(x(x(x)?)?)?
+          size = re.max * sub + (re.max - re.min);
+          break;
+        }
+    }
+    size = Math.max(1, size);
+    this.size[re] = size;
+    return size;
+  }
+  checkHeight(re) {
+    if (this.numRegexp < Parser.MAX_HEIGHT) {
+      return;
+    }
+    if (this.height === null) {
+      this.height = {};
+      for (let reEx of this.stack) {
+        this.checkHeight(reEx);
+      }
+    }
+    if (this.calcHeight(re, true) > Parser.MAX_HEIGHT) {
+      throw new RE2JSSyntaxException(Parser.ERR_NESTING_DEPTH);
+    }
+  }
+  calcHeight(re, force = false) {
+    if (!force) {
+      if (Object.prototype.hasOwnProperty.call(this.height, re)) {
+        return this.height[re];
+      }
+    }
+    let h = 1;
+    for (let sub of re.subs) {
+      const hsub = this.calcHeight(sub);
+      if (h < 1 + hsub) {
+        h = 1 + hsub;
+      }
+    }
+    this.height[re] = h;
+    return h;
+  }
 
   // Parse stack manipulation.
 
@@ -3426,13 +3633,14 @@ class Parser {
   // push pushes the regexp re onto the parse stack and returns the regexp.
   // Returns null for a CHAR_CLASS that can be merged with the top-of-stack.
   push(re) {
+    this.numRunes += re.runes.length;
     if (re.op === Regexp.Op.CHAR_CLASS && re.runes.length === 2 && re.runes[0] === re.runes[1]) {
-      if (this.maybeConcat(re.runes[0], this.flags & ~RE2Flags.FOLD_CASE)) {
+      if (this.maybeConcat(re.runes[0], this.flags & -2)) {
         return null;
       }
       re.op = Regexp.Op.LITERAL;
       re.runes = [re.runes[0]];
-      re.flags = this.flags & ~RE2Flags.FOLD_CASE;
+      re.flags = this.flags & -2;
     } else if (re.op === Regexp.Op.CHAR_CLASS && re.runes.length === 4 && re.runes[0] === re.runes[1] && re.runes[2] === re.runes[3] && Unicode.simpleFold(re.runes[0]) === re.runes[2] && Unicode.simpleFold(re.runes[2]) === re.runes[0] || re.op === Regexp.Op.CHAR_CLASS && re.runes.length === 2 && re.runes[0] + 1 === re.runes[1] && Unicode.simpleFold(re.runes[0]) === re.runes[1] && Unicode.simpleFold(re.runes[1]) === re.runes[0]) {
       // Case-insensitive rune like [Aa] or [Δδ].
       if (this.maybeConcat(re.runes[0], this.flags | RE2Flags.FOLD_CASE)) {
@@ -3447,6 +3655,7 @@ class Parser {
       this.maybeConcat(-1, 0);
     }
     this.stack.push(re);
+    this.checkLimits(re);
     return re;
   }
 
@@ -3540,6 +3749,43 @@ class Parser {
     re.flags = flags;
     re.subs = [sub];
     this.stack[n - 1] = re;
+    this.checkLimits(re);
+    if (op === Regexp.Op.REPEAT && (min >= 2 || max >= 2) && !this.repeatIsValid(re, 1000)) {
+      throw new RE2JSSyntaxException(Parser.ERR_INVALID_REPEAT_SIZE, t.from(beforePos));
+    }
+  }
+
+  // repeatIsValid reports whether the repetition re is valid.
+  // Valid means that the combination of the top-level repetition
+  // and any inner repetitions does not exceed n copies of the
+  // innermost thing.
+  // This function rewalks the regexp tree and is called for every repetition,
+  // so we have to worry about inducing quadratic behavior in the parser.
+  // We avoid this by only calling repeatIsValid when min or max >= 2.
+  // In that case the depth of any >= 2 nesting can only get to 9 without
+  // triggering a parse error, so each subtree can only be rewalked 9 times.
+  repeatIsValid(re, n) {
+    if (re.op === Regexp.Op.REPEAT) {
+      let m = re.max;
+      if (m === 0) {
+        return true;
+      }
+      if (m < 0) {
+        m = re.min;
+      }
+      if (m > n) {
+        return false;
+      }
+      if (m > 0) {
+        n = Math.trunc(n / m);
+      }
+    }
+    for (let sub of re.subs) {
+      if (!this.repeatIsValid(sub, n)) {
+        return false;
+      }
+    }
+    return true;
   }
 
   // concat replaces the top of the stack (above the topmost '|' or '(') with
@@ -3577,10 +3823,10 @@ class Parser {
     if (re.op === Regexp.Op.CHAR_CLASS) {
       re.runes = new CharClass(re.runes).cleanClass().toArray();
       if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) {
-        re.runes = null;
+        re.runes = [];
         re.op = Regexp.Op.ANY_CHAR;
       } else if (re.runes.length === 4 && re.runes[0] === 0 && re.runes[1] === Codepoint.CODES.get('\n') - 1 && re.runes[2] === Codepoint.CODES.get('\n') + 1 && re.runes[3] === Unicode.MAX_RUNE) {
-        re.runes = null;
+        re.runes = [];
         re.op = Regexp.Op.ANY_CHAR_NOT_NL;
       }
     }
@@ -3715,6 +3961,7 @@ class Parser {
         prefix.runes = str.slice(0, strlen);
         for (let j = start; j < i; j++) {
           array[s + j] = this.removeLeadingString(array[s + j], strlen);
+          this.checkLimits(array[s + j]);
         }
         // Recurse.
         const suffix = this.collapse(array.slice(s + start, s + i), Regexp.Op.ALTERNATE);
@@ -3764,6 +4011,7 @@ class Parser {
         for (let j = start; j < i; j++) {
           const reuse = j !== start; // prefix came from sub[start]
           array[s + j] = this.removeLeadingRegexp(array[s + j], reuse);
+          this.checkLimits(array[s + j]);
         }
         // recurse
         const suffix = this.collapse(array.slice(s + start, s + i), Regexp.Op.ALTERNATE);
@@ -4147,7 +4395,7 @@ class Parser {
     t.skip(2); // "(?"
 
     let flags = this.flags;
-    let sign = +1;
+    let sign = 1;
     let sawFlag = false;
     loop: while (t.more()) {
       {
@@ -4158,7 +4406,7 @@ class Parser {
             sawFlag = true;
             break;
           case Codepoint.CODES.get('m'):
-            flags &= ~RE2Flags.ONE_LINE;
+            flags &= -17;
             sawFlag = true;
             break;
           case Codepoint.CODES.get('s'):
@@ -4264,12 +4512,12 @@ class Parser {
     this.alternate();
     const n = this.stack.length;
     if (n < 2) {
-      throw new RE2JSSyntaxException(Parser.ERR_INTERNAL_ERROR, 'stack underflow');
+      throw new RE2JSSyntaxException(Parser.ERR_UNEXPECTED_PAREN, this.wholeRegexp);
     }
     const re1 = this.pop();
     const re2 = this.pop();
     if (re2.op !== Regexp.Op.LEFT_PAREN) {
-      throw new RE2JSSyntaxException(Parser.ERR_MISSING_PAREN, this.wholeRegexp);
+      throw new RE2JSSyntaxException(Parser.ERR_UNEXPECTED_PAREN, this.wholeRegexp);
     }
     // Restore flags at time of paren.
     this.flags = re2.flags;
@@ -4339,7 +4587,7 @@ class Parser {
     }
     t.skip(1); // '\\'
     // Committed to parse or throw exception.
-    let sign = +1;
+    let sign = 1;
     let c = t.pop(); // 'p' or 'P'
     if (c === Codepoint.CODES.get('P')) {
       sign = -1;
@@ -4403,7 +4651,7 @@ class Parser {
     const re = this.newRegexp(Regexp.Op.CHAR_CLASS);
     re.flags = this.flags;
     const cc = new CharClass();
-    let sign = +1;
+    let sign = 1;
     if (t.more() && t.lookingAt('^')) {
       sign = -1;
       t.skip(1); // '^'
@@ -4946,6 +5194,13 @@ class RE2 {
     return this.numSubexp;
   }
 
+  /**
+   * Returns the number of instructions in this compiled regular expression program.
+   */
+  numberOfInstructions() {
+    return this.prog.numInst();
+  }
+
   // get() returns a machine to use for matching |this|.  It uses |this|'s
   // machine cache if possible, to avoid unnecessary allocation.
   get() {
@@ -5578,7 +5833,7 @@ class RE2JS {
     }
     let re2Flags = RE2Flags.PERL;
     if ((flags & RE2JS.DISABLE_UNICODE_GROUPS) !== 0) {
-      re2Flags &= ~RE2Flags.UNICODE_GROUPS;
+      re2Flags &= -129;
     }
     const p = new RE2JS(regex, flags);
     // The compiled RE2 regexp.
@@ -5746,6 +6001,20 @@ class RE2JS {
     return this.patternInput;
   }
 
+  /**
+   * Returns the program size of this pattern.
+   *
+   * <p>
+   * Similar to the C++ implementation, the program size is a very approximate measure of a regexp's
+   * "cost". Larger numbers are more expensive than smaller numbers.
+   * </p>
+   *
+   * @returns {number} the program size of this pattern
+   */
+  programSize() {
+    return this.re2Input.numberOfInstructions();
+  }
+
   /**
    * Returns the number of capturing groups in this matcher's pattern. Group zero denotes the entire
    * pattern and is excluded from this count.