re2js 0.4.2 → 1.0.0

package/build/index.umd.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.2
+ * @version v1.0.0
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -328,7 +328,7 @@
     // 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.
@@ -932,6 +932,7 @@
       // 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)) {
@@ -1018,6 +1019,20 @@
       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]
@@ -1658,7 +1673,7 @@
       // 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
@@ -1668,7 +1683,7 @@
     reinit() {
       this.flags = 0;
       this.subs = Regexp.emptySubs();
-      this.runes = null;
+      this.runes = [];
       this.cap = 0;
       this.min = 0;
       this.max = 0;
@@ -1969,7 +1984,7 @@
       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.
@@ -2363,7 +2378,7 @@
       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;
@@ -2480,7 +2495,7 @@
               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) {
@@ -2621,7 +2636,7 @@
   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];
@@ -2636,7 +2651,7 @@
   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
@@ -2675,7 +2690,7 @@
     // 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;
@@ -3060,6 +3075,48 @@
     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).
@@ -3358,7 +3415,7 @@
         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;
@@ -3392,6 +3449,12 @@
       // 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.
@@ -3403,15 +3466,159 @@
         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.
 
@@ -3432,13 +3639,14 @@
     // 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)) {
@@ -3453,6 +3661,7 @@
         this.maybeConcat(-1, 0);
       }
       this.stack.push(re);
+      this.checkLimits(re);
       return re;
     }
 
@@ -3546,6 +3755,43 @@
       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
@@ -3583,10 +3829,10 @@
       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;
         }
       }
@@ -3721,6 +3967,7 @@
           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);
@@ -3770,6 +4017,7 @@
           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);
@@ -4153,7 +4401,7 @@
       t.skip(2); // "(?"
 
       let flags = this.flags;
-      let sign = +1;
+      let sign = 1;
       let sawFlag = false;
       loop: while (t.more()) {
         {
@@ -4164,7 +4412,7 @@
               sawFlag = true;
               break;
             case Codepoint.CODES.get('m'):
-              flags &= ~RE2Flags.ONE_LINE;
+              flags &= -17;
               sawFlag = true;
               break;
             case Codepoint.CODES.get('s'):
@@ -4270,12 +4518,12 @@
       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;
@@ -4345,7 +4593,7 @@
       }
       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;
@@ -4409,7 +4657,7 @@
       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); // '^'
@@ -4952,6 +5200,13 @@
       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() {
@@ -5584,7 +5839,7 @@
       }
       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.
@@ -5752,6 +6007,20 @@
       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.