re2js 2.6.1 → 2.7.0

package/README.md

@@ -733,7 +733,7 @@ negative.test('foobar'); // false
 
 1. **Performance Overhead:** If a regex contains a lookbehind, the engine is forced to safely bypass the ultra-fast Lazy DFA and OnePass engines. It evaluates the lookbehinds using parallel automata running on the NFA (Pike VM). While execution remains mathematically safe and linear $O(n)$, the NFA engine is generally slower than the DFA fast-paths. Use lookbehinds only when necessary.
 2. **Prefix Acceleration is Disabled:** To ensure the parallel tracking automata initialize correctly, high-speed string prefix skipping (e.g., using `indexOf` to jump to a starting literal) is disabled when lookbehinds are present.
-3. **Captureless Guarantee:** To prevent state-explosion vulnerabilities, lookbehinds are strictly evaluated as *captureless*. If you include a capturing group inside a lookbehind (e.g., `(?<=(foo))bar`), the engine will match successfully, but `group(1)` will safely return `null`.
+3. **Captureless Guarantee:** To prevent state-explosion vulnerabilities and maintain strict safety invariants, lookbehinds are strictly evaluated as *captureless*. If you attempt to include a capturing group inside a lookbehind (e.g., `(?<=(foo))bar`), the engine will proactively throw a `SyntaxError` at compile time. Use non-capturing groups `(?:...)` instead.
 
 
 ## Development

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 v2.6.1
+ * @version v2.7.0
  * @author Oleksii Vasyliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -2155,9 +2155,9 @@ class Inst {
       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>';
@@ -2596,17 +2596,17 @@ class Machine {
             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;
@@ -4686,7 +4686,7 @@ class Compiler {
   }
   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);
@@ -4694,7 +4694,7 @@ class Compiler {
     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);
@@ -5469,6 +5469,7 @@ class Parser {
   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
@@ -5872,6 +5873,18 @@ class Parser {
     }
     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
@@ -6555,7 +6568,7 @@ class Parser {
           case 1:
             // Impossible but handle.
             re.op = Regexp.Op.EMPTY_MATCH;
-            re.subs = null;
+            re.subs = Regexp.emptySubs();
             break;
           case 2:
             {
@@ -7006,6 +7019,9 @@ class Parser {
 
     // 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 {