re2js 2.6.1 → 2.7.1

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 v2.6.1
+ * @version v2.7.1
  * @author Oleksii Vasyliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -2159,9 +2159,9 @@
         case Inst.NOP:
           return `nop -> ${this.out}`;
         case Inst.LB_WRITE:
-          return `lbwrite ${this.lb} -> ${this.out}`;
+          return `lbwrite ${this.arg} -> ${this.out}`;
         case Inst.LB_CHECK:
-          return `lbcheck ${this.lb} -> ${this.out}, ${this.arg}`;
+          return `lbcheck ${this.arg} -> ${this.out}`;
         case Inst.RUNE:
           if (this.runes === null) {
             return 'rune <null>';
@@ -2341,30 +2341,35 @@
       }
       this.matched = false;
       this.matchcap.fill(-1);
+
+      // Lookbehinds must scan from the beginning of the string to build their state table,
+      // even if the main pattern search is requested to start mid-string.
+      let currentPos = this.prog.numLb > 0 ? 0 : pos;
+      let matchStartPos = pos;
       let runq = this.q0;
       let nextq = this.q1;
-      let r = input.step(pos);
+      let r = input.step(currentPos);
       let rune = r >> 3;
       let width = r & 7;
       let rune1 = -1;
       let width1 = 0;
       if (r !== MachineInputBase.EOF()) {
-        r = input.step(pos + width);
+        r = input.step(currentPos + width);
         rune1 = r >> 3;
         width1 = r & 7;
       }
       let flag;
-      if (pos === 0) {
+      if (currentPos === 0) {
         flag = Utils.emptyOpContext(-1, rune);
       } else {
-        flag = input.context(pos);
+        flag = input.context(currentPos);
       }
       while (true) {
         if (runq.isEmpty()) {
-          if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && pos !== 0) {
+          if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && currentPos !== 0) {
             break;
           }
-          if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+          if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && currentPos !== 0) {
             break;
           }
           if (this.matched) {
@@ -2374,43 +2379,50 @@
           // Fast-forwarding the string pointer will skip over the positions where
           // the parallel lookbehind automata need to be spawned.
           if (this.prog.numLb === 0 && !(this.re2.prefix.length === 0) && rune1 !== this.re2.prefixRune && input.canCheckPrefix()) {
-            const advance = input.index(this.re2, pos);
+            const advance = input.index(this.re2, currentPos);
             if (advance < 0) {
               break;
             }
-            pos += advance;
-            r = input.step(pos);
+            currentPos += advance;
+            r = input.step(currentPos);
             rune = r >> 3;
             width = r & 7;
-            r = input.step(pos + width);
+            r = input.step(currentPos + width);
             rune1 = r >> 3;
             width1 = r & 7;
           }
         }
-        if (!this.matched && (pos === 0 || anchor === RE2Flags.UNANCHORED)) {
-          if (this.ncap > 0) {
-            this.matchcap[0] = pos;
-          }
-          // Spawn Lookbehind threads BEFORE the main pattern
+
+        // Optimize lookbehind spawning. Because lookbehinds are prefixed with `.*` by the compiler,
+        // they only need to be spawned exactly once at the beginning of the string (currentPos === 0).
+        if (currentPos === 0 && this.prog.numLb > 0) {
           for (let i = 0; i < this.prog.lbStarts.length; i++) {
-            this.add(runq, this.prog.lbStarts[i], pos, this.matchcap, flag, null);
+            this.add(runq, this.prog.lbStarts[i], currentPos, this.matchcap, flag, null);
+          }
+        }
+        if (!this.matched && (currentPos === 0 || anchor === RE2Flags.UNANCHORED)) {
+          // ONLY spawn the main pattern if we have reached the requested search start boundary
+          if (currentPos >= matchStartPos) {
+            if (this.ncap > 0) {
+              this.matchcap[0] = currentPos;
+            }
+            this.add(runq, this.prog.start, currentPos, this.matchcap, flag, null);
           }
-          this.add(runq, this.prog.start, pos, this.matchcap, flag, null);
         }
-        const nextPos = pos + width;
+        const nextPos = currentPos + width;
         flag = input.context(nextPos);
-        this.step(runq, nextq, pos, nextPos, rune, flag, anchor, pos === input.endPos());
+        this.step(runq, nextq, currentPos, nextPos, rune, flag, anchor, currentPos === input.endPos());
         if (width === 0) {
           break;
         }
         if (this.ncap === 0 && this.matched) {
           break;
         }
-        pos += width;
+        currentPos += width;
         rune = rune1;
         width = width1;
         if (rune !== -1) {
-          r = input.step(pos + width);
+          r = input.step(currentPos + width);
           rune1 = r >> 3;
           width1 = r & 7;
         }
@@ -2427,35 +2439,46 @@
       if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
         return [];
       }
+
+      // Lookbehinds must scan from the beginning of the string to build their state table,
+      // even if the main pattern search is requested to start mid-string.
+      let currentPos = this.prog.numLb > 0 ? 0 : pos;
+      let matchStartPos = pos;
       let runq = this.q0;
       let nextq = this.q1;
-      let r = input.step(pos);
+      let r = input.step(currentPos);
       let rune = r >> 3;
       let width = r & 7;
       let rune1 = -1;
       let width1 = 0;
       if (r !== MachineInputBase.EOF()) {
-        r = input.step(pos + width);
+        r = input.step(currentPos + width);
         rune1 = r >> 3;
         width1 = r & 7;
       }
-      let flag = pos === 0 ? Utils.emptyOpContext(-1, rune) : input.context(pos);
+      let flag = currentPos === 0 ? Utils.emptyOpContext(-1, rune) : input.context(currentPos);
       const matches = new Set();
       while (true) {
         if (runq.isEmpty()) {
-          if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && pos !== 0) break;
-          if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+          if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && currentPos !== 0) break;
+          if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && currentPos !== 0) {
             break;
           }
         }
-        if (pos === 0 || anchor === RE2Flags.UNANCHORED) {
-          // Spawn Lookbehind threads BEFORE the main pattern
+
+        // Optimize lookbehind spawning to exactly once at BOF
+        if (currentPos === 0 && this.prog.numLb > 0) {
           for (let i = 0; i < this.prog.lbStarts.length; i++) {
-            this.add(runq, this.prog.lbStarts[i], pos, this.matchcap, flag, null);
+            this.add(runq, this.prog.lbStarts[i], currentPos, this.matchcap, flag, null);
+          }
+        }
+        if (currentPos === 0 || anchor === RE2Flags.UNANCHORED) {
+          // ONLY spawn the main pattern if we have reached the requested search start boundary
+          if (currentPos >= matchStartPos) {
+            this.add(runq, this.prog.start, currentPos, this.matchcap, flag, null);
           }
-          this.add(runq, this.prog.start, pos, this.matchcap, flag, null);
         }
-        const nextPos = pos + width;
+        const nextPos = currentPos + width;
         flag = input.context(nextPos);
         for (let j = 0; j < runq.size; j++) {
           let t = runq.denseThreads[j];
@@ -2464,7 +2487,7 @@
           let add = false;
           switch (i.op) {
             case Inst.MATCH:
-              if (anchor === RE2Flags.ANCHOR_BOTH && pos !== input.endPos()) break;
+              if (anchor === RE2Flags.ANCHOR_BOTH && currentPos !== input.endPos()) break;
               matches.add(i.arg); // Record the matched Set ID
               break;
             case Inst.RUNE:
@@ -2492,11 +2515,11 @@
         }
         runq.clear();
         if (width === 0) break;
-        pos += width;
+        currentPos += width;
         rune = rune1;
         width = width1;
         if (rune !== -1) {
-          r = input.step(pos + width);
+          r = input.step(currentPos + width);
           rune1 = r >> 3;
           width1 = r & 7;
         }
@@ -2600,17 +2623,17 @@
               continue;
             }
           case Inst.LB_WRITE:
-            this.lbTable[Math.abs(inst.lb)] = pos;
+            this.lbTable[Math.abs(inst.arg)] = pos;
             pc = inst.out;
             continue;
           case Inst.LB_CHECK:
-            if (inst.lb > 0) {
+            if (inst.arg > 0) {
               // Positive Lookbehind
-              if (this.lbTable[inst.lb] === pos) {
+              if (this.lbTable[inst.arg] === pos) {
                 pc = inst.out; // Flattened tail recursion
                 continue;
               }
-            } else if (this.lbTable[-inst.lb] !== pos) {
+            } else if (this.lbTable[-inst.arg] !== pos) {
               // Negative Lookbehind
               pc = inst.out; // Flattened tail recursion
               continue;
@@ -4690,7 +4713,7 @@
     }
     lookBehind(a, lb) {
       const id = this.newInst(Inst.LB_WRITE);
-      this.prog.getInst(id.i).lb = lb;
+      this.prog.getInst(id.i).arg = lb;
 
       // Create the prefix wildcard `.*` for the lookbehind automaton
       const any = this.rune(Compiler.ANY_RUNE(), 0);
@@ -4698,7 +4721,7 @@
       const lbAutomaton = this.cat(dotStar, a);
       this.prog.patch(lbAutomaton.out, id.i);
       const checkId = this.newInst(Inst.LB_CHECK);
-      this.prog.getInst(checkId.i).lb = lb;
+      this.prog.getInst(checkId.i).arg = lb;
 
       // Save the starting point of this lookbehind automaton
       this.prog.lbStarts.push(lbAutomaton.i);
@@ -5473,6 +5496,7 @@
     static ERR_UNEXPECTED_PAREN = 'unexpected )';
     static ERR_NESTING_DEPTH = 'expression nests too deeply';
     static ERR_LARGE = 'expression too large';
+    static ERR_INVALID_CAPTURE_IN_LOOKBEHIND = 'invalid capture in lookbehind';
 
     // maxHeight is the maximum height of a regexp parse tree.
     // It is somewhat arbitrarily chosen, but the idea is to be large enough
@@ -5876,6 +5900,18 @@
       }
       return x;
     }
+
+    // recursively check for captures
+    static hasCapture(re) {
+      if (re === null) return false;
+      if (re.op === Regexp.Op.CAPTURE) return true;
+      if (re.subs) {
+        for (let sub of re.subs) {
+          if (Parser.hasCapture(sub)) return true;
+        }
+      }
+      return false;
+    }
     constructor(wholeRegexp, flags = 0) {
       this.wholeRegexp = wholeRegexp;
       // Flags control the behavior of the parser and record information about
@@ -6559,7 +6595,7 @@
             case 1:
               // Impossible but handle.
               re.op = Regexp.Op.EMPTY_MATCH;
-              re.subs = null;
+              re.subs = Regexp.emptySubs();
               break;
             case 2:
               {
@@ -7010,6 +7046,9 @@
 
       // Handle lookbehinds
       if (re2.lb !== 0) {
+        if (Parser.hasCapture(re1)) {
+          throw new RE2JSSyntaxException(Parser.ERR_INVALID_CAPTURE_IN_LOOKBEHIND, this.wholeRegexp);
+        }
         if (re2.lb > 0) {
           re2.op = Regexp.Op.PLB;
         } else {