re2js 0.4.2 → 1.0.0

package/README.md

@@ -98,6 +98,18 @@ RE2JS.DISABLE_UNICODE_GROUPS
 RE2JS.LONGEST_MATCH
 ```
 
+### Program size
+
+The program size represents a very approximate measure of a regexp's "cost". Larger numbers are more expensive than smaller numbers.
+
+```js
+import { RE2JS } from 're2js'
+
+console.log(RE2JS.compile('^').programSize()); // Outputs: 3
+console.log(RE2JS.compile('a+b').programSize()); // Outputs: 5
+console.log(RE2JS.compile('(a+b?)').programSize()); // Outputs: 8
+```
+
 ### Checking for Matches
 
 RE2JS allows you to check if a string matches a given regex pattern using the `matches()` function
@@ -131,6 +143,20 @@ RE2JS.compile('ab+c').matcher('cbbba').find() // false
 RE2JS.compile('ab+c', RE2JS.CASE_INSENSITIVE).matcher('abBBc').find() // true
 ```
 
+Example to collect all matches in string
+
+```js
+import { RE2JS } from 're2js'
+
+const p = RE2JS.compile('abc+')
+const matchString = p.matcher('abc abcccc abcc')
+const results = []
+while (matchString.find()) {
+  results.push(matchString.group())
+}
+results // ['abc', 'abcccc', 'abcc']
+```
+
 The `find()` method searches for a pattern match in a string starting from a specific index
 
 ```js

package/build/index.cjs.cjs

@@ -2,7 +2,7 @@
  * re2js
  * RE2JS is the JavaScript port of RE2, a regular expression engine that provides linear time matching
  *
- * @version v0.4.2
+ * @version v1.0.0
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -324,7 +324,7 @@ class Unicode {
   // Minimum and maximum runes involved in folding.
   // Checked during test.
   static MIN_FOLD = 0x0041;
-  static MAX_FOLD = 0x1044f;
+  static MAX_FOLD = 0x1e943;
 
   // is32 uses binary search to test whether rune is in the specified
   // slice of 32-bit ranges.
@@ -928,6 +928,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)) {
@@ -1014,6 +1015,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]
@@ -1654,7 +1669,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
@@ -1664,7 +1679,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;
@@ -1965,7 +1980,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.
@@ -2359,7 +2374,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;
@@ -2476,7 +2491,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) {
@@ -2617,7 +2632,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];
@@ -2632,7 +2647,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
@@ -2671,7 +2686,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;
@@ -3056,6 +3071,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).
@@ -3354,7 +3411,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;
@@ -3388,6 +3445,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.
@@ -3399,15 +3462,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.
 
@@ -3428,13 +3635,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)) {
@@ -3449,6 +3657,7 @@ class Parser {
       this.maybeConcat(-1, 0);
     }
     this.stack.push(re);
+    this.checkLimits(re);
     return re;
   }
 
@@ -3542,6 +3751,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
@@ -3579,10 +3825,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;
       }
     }
@@ -3717,6 +3963,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);
@@ -3766,6 +4013,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);
@@ -4149,7 +4397,7 @@ class Parser {
     t.skip(2); // "(?"
 
     let flags = this.flags;
-    let sign = +1;
+    let sign = 1;
     let sawFlag = false;
     loop: while (t.more()) {
       {
@@ -4160,7 +4408,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'):
@@ -4266,12 +4514,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;
@@ -4341,7 +4589,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;
@@ -4405,7 +4653,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); // '^'
@@ -4948,6 +5196,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() {
@@ -5580,7 +5835,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.
@@ -5748,6 +6003,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>
+   *
+   * @return 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.