re2js 1.2.3 → 1.3.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 v1.2.3
+ * @version v1.3.0
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -927,6 +927,17 @@
     }
   }
 
+  /**
+   * An exception thrown by DFA
+   */
+  class RE2JSDfaMemoryException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+      super(message);
+      this.name = 'RE2JSDfaMemoryException';
+    }
+  }
+
   /**
    * A stateful iterator that interprets a regex {@code RE2JS} on a specific input.
    *
@@ -2116,6 +2127,160 @@
     }
   }
 
+  class DFAState {
+    constructor(id, nfaStates, isMatch) {
+      this.id = id; // Stringified NFA state list (e.g., "1,4,7")
+      this.nfaStates = nfaStates; // Array of Instruction PCs
+      this.isMatch = isMatch; // Boolean
+      this.nextAscii = new Array(Unicode.MAX_ASCII + 1).fill(null); // Flat array for blisteringly fast ASCII lookups (unanchored)
+      this.nextMap = new Map(); // Cache of Char -> DFAState
+    }
+  }
+  class DFA {
+    constructor(prog) {
+      this.prog = prog;
+      this.stateCache = new Map(); // id -> DFAState
+      this.startState = null;
+      this.stateLimit = 10000; // Prevent memory explosion (ReDoS protection), like RE2 max_mem
+    }
+
+    // Follows epsilon (empty) transitions to find all reachable states without consuming a char
+    computeClosure(pcs) {
+      const closure = new Set();
+      const stack = [...pcs];
+      let isMatch = false;
+      while (stack.length > 0) {
+        const pc = stack.pop();
+        if (closure.has(pc)) continue;
+        closure.add(pc);
+        const inst = this.prog.getInst(pc);
+        switch (inst.op) {
+          case Inst.MATCH:
+            isMatch = true;
+            break;
+          case Inst.ALT:
+          case Inst.ALT_MATCH:
+            stack.push(inst.out);
+            stack.push(inst.arg);
+            break;
+          case Inst.NOP:
+          case Inst.CAPTURE:
+            stack.push(inst.out);
+            break;
+          // Bailing out on complex empty-width assertions to keep DFA fast.
+          // Engine will seamlessly fall back to the NFA.
+          case Inst.EMPTY_WIDTH:
+            return null;
+        }
+      }
+      const sortedPCs = Int32Array.from(closure).sort();
+      return {
+        pcs: sortedPCs,
+        isMatch
+      };
+    }
+
+    // Get or create a DFA state from a list of NFA PCs
+    getState(pcs) {
+      const closureResult = this.computeClosure(pcs);
+      if (!closureResult) return null; // Bailout to NFA required
+
+      const id = closureResult.pcs.join(',');
+      if (this.stateCache.has(id)) {
+        return this.stateCache.get(id);
+      }
+
+      // Safety: prevent memory exhaustion from state explosion
+      if (this.stateCache.size > this.stateLimit) {
+        throw new RE2JSDfaMemoryException('dfa error: Out of memory exception');
+      }
+      const state = new DFAState(id, closureResult.pcs, closureResult.isMatch);
+      this.stateCache.set(id, state);
+      return state;
+    }
+
+    // Compute the next DFA state given a current state and a character
+    step(state, charCode, anchor) {
+      // OPTIMIZATION: ASCII Fast-Path
+      if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) {
+        const next = state.nextAscii[charCode];
+        if (next !== null) {
+          return next;
+        }
+      } else {
+        const key = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1);
+        if (state.nextMap.has(key)) {
+          return state.nextMap.get(key);
+        }
+      }
+      const nextPCs = [];
+      for (let i = 0; i < state.nfaStates.length; i++) {
+        const pc = state.nfaStates[i];
+        const inst = this.prog.getInst(pc);
+        if (Inst.isRuneOp(inst.op) && inst.matchRune(charCode)) {
+          nextPCs.push(inst.out);
+        }
+      }
+      if (anchor === RE2Flags.UNANCHORED) {
+        nextPCs.push(this.prog.start);
+      }
+      const nextState = this.getState(nextPCs);
+
+      // Cache the result
+      if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) {
+        state.nextAscii[charCode] = nextState;
+      } else {
+        const key = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1);
+        state.nextMap.set(key, nextState);
+      }
+      return nextState;
+    }
+
+    // The hot loop: Execute the Lazy DFA
+    match(input, pos, anchor) {
+      if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+        return false;
+      }
+      if (!this.startState) {
+        this.startState = this.getState([this.prog.start]);
+        if (!this.startState) return null; // Fallback to NFA
+      }
+      let endPos = input.endPos();
+      let currentState = this.startState;
+      if (currentState.isMatch) {
+        if (anchor === RE2Flags.ANCHOR_BOTH) {
+          if (pos === endPos) return true;
+        } else {
+          return true;
+        }
+      }
+      let i = pos;
+      while (i < endPos) {
+        const r = input.step(i);
+        const rune = r >> 3;
+        const width = r & 7;
+        currentState = this.step(currentState, rune, anchor);
+
+        // If we hit an unrecoverable DFA error or bailout, signal fallback
+        if (currentState === null) return null;
+        if (currentState.isMatch) {
+          if (anchor === RE2Flags.ANCHOR_BOTH) {
+            if (i + width === endPos) return true;
+          } else {
+            return true;
+          }
+        }
+
+        // If we hit a dead end, and anchored, fail early
+        if (currentState.nfaStates.length === 0) {
+          if (anchor !== RE2Flags.UNANCHORED) return false;
+        }
+        i += width;
+      }
+      return false;
+    }
+  }
+
   /**
    * Regular expression abstract syntax tree. Produced by parser, used by compiler. NB, this
    * corresponds to {@code syntax.regexp} in the Go implementation; Go's {@code regexp} is called
@@ -5248,6 +5413,30 @@
       this.prefixComplete = false; // true if prefix is the entire regexp
       this.prefixRune = 0; // first rune in prefix
       this.pooled = new AtomicReference(); // Cache of machines for running regexp. Forms a Treiber stack.
+      this.dfa = new DFA(prog); // Initialize the Lazy DFA
+    }
+    executeEngine(input, pos, anchor, ncap) {
+      // If the user wants capturing groups (ncap > 0), the DFA mathematically CANNOT do it.
+      // We must use the NFA.
+      if (ncap > 0) {
+        return this.doExecuteNFA(input, pos, anchor, ncap);
+      }
+      try {
+        const dfaResult = this.dfa.match(input, pos, anchor);
+        if (dfaResult !== null) {
+          // DFA succeeded (returned true or false)
+          return dfaResult ? [] : null; // Return empty array to signify "matched but no captures"
+        }
+      } catch (e) {
+        if (e instanceof RE2JSDfaMemoryException) {
+          this.dfa = new DFA(this.prog); // flush cache
+        } else {
+          throw e;
+        }
+      }
+
+      // Fallback to NFA
+      return this.doExecuteNFA(input, pos, anchor, ncap);
     }
 
     /**
@@ -5332,10 +5521,10 @@
       return this.expr;
     }
 
-    // doExecute() finds the leftmost match in the input and returns
+    // doExecuteNFA() finds the leftmost match in the input and returns
     // the position of its subexpressions.
     // Derived from exec.go.
-    doExecute(input, pos, anchor, ncap) {
+    doExecuteNFA(input, pos, anchor, ncap) {
       let m = this.get();
       // The Treiber stack cannot reuse nodes, unless the node to be reused has only ever been at
       // the bottom of the stack (i.e., next == null).
@@ -5353,7 +5542,7 @@
       return cap;
     }
     match(s) {
-      return this.doExecute(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, 0) !== null;
+      return this.executeEngine(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, 0) !== null;
     }
 
     /**
@@ -5381,7 +5570,7 @@
         return [false, null];
       }
       const machineInput = input.isUTF16Encoding() ? MachineInput.fromUTF16(input.asCharSequence(), 0, end) : MachineInput.fromUTF8(input.asBytes(), 0, end);
-      const groupMatch = this.doExecute(machineInput, start, anchor, 2 * ngroup);
+      const groupMatch = this.executeEngine(machineInput, start, anchor, 2 * ngroup);
       if (groupMatch === null) {
         return [false, null];
       }
@@ -5393,7 +5582,7 @@
      */
     // This is visible for testing.
     matchUTF8(b) {
-      return this.doExecute(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, 0) !== null;
+      return this.executeEngine(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, 0) !== null;
     }
 
     /**
@@ -5430,7 +5619,7 @@
       const input = MachineInput.fromUTF16(src);
       let numReplaces = 0;
       while (searchPos <= src.length) {
-        const a = this.doExecute(input, searchPos, RE2Flags.UNANCHORED, 2);
+        const a = this.executeEngine(input, searchPos, RE2Flags.UNANCHORED, 2);
         if (a === null || a.length === 0) {
           break;
         }
@@ -5488,7 +5677,7 @@
       let i = 0;
       let prevMatchEnd = -1;
       while (i < n && pos <= end) {
-        const matches = this.doExecute(input, pos, RE2Flags.UNANCHORED, this.prog.numCap);
+        const matches = this.executeEngine(input, pos, RE2Flags.UNANCHORED, this.prog.numCap);
         if (matches === null || matches.length === 0) {
           break;
         }
@@ -5559,7 +5748,7 @@
      */
     // This is visible for testing.
     findUTF8(b) {
-      const a = this.doExecute(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, 2);
+      const a = this.executeEngine(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, 2);
       if (a === null) {
         return null;
       }
@@ -5574,7 +5763,7 @@
      */
     // This is visible for testing.
     findUTF8Index(b) {
-      const a = this.doExecute(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, 2);
+      const a = this.executeEngine(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, 2);
       if (a === null) {
         return null;
       }
@@ -5591,7 +5780,7 @@
      */
     // This is visible for testing.
     find(s) {
-      const a = this.doExecute(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, 2);
+      const a = this.executeEngine(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, 2);
       if (a === null) {
         return '';
       }
@@ -5607,7 +5796,7 @@
      */
     // This is visible for testing.
     findIndex(s) {
-      return this.doExecute(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, 2);
+      return this.executeEngine(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, 2);
     }
 
     /**
@@ -5619,7 +5808,7 @@
      */
     // This is visible for testing.
     findUTF8Submatch(b) {
-      const a = this.doExecute(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, this.prog.numCap);
+      const a = this.executeEngine(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, this.prog.numCap);
       if (a === null) {
         return null;
       }
@@ -5641,7 +5830,7 @@
      */
     // This is visible for testing.
     findUTF8SubmatchIndex(b) {
-      return this.pad(this.doExecute(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, this.prog.numCap));
+      return this.pad(this.executeEngine(MachineInput.fromUTF8(b), 0, RE2Flags.UNANCHORED, this.prog.numCap));
     }
 
     /**
@@ -5653,7 +5842,7 @@
      */
     // This is visible for testing.
     findSubmatch(s) {
-      const a = this.doExecute(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, this.prog.numCap);
+      const a = this.executeEngine(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, this.prog.numCap);
       if (a === null) {
         return null;
       }
@@ -5675,7 +5864,7 @@
      */
     // This is visible for testing.
     findSubmatchIndex(s) {
-      return this.pad(this.doExecute(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, this.prog.numCap));
+      return this.pad(this.executeEngine(MachineInput.fromUTF16(s), 0, RE2Flags.UNANCHORED, this.prog.numCap));
     }
 
     /**
@@ -6248,6 +6437,7 @@
   exports.Matcher = Matcher;
   exports.RE2JS = RE2JS;
   exports.RE2JSCompileException = RE2JSCompileException;
+  exports.RE2JSDfaMemoryException = RE2JSDfaMemoryException;
   exports.RE2JSException = RE2JSException;
   exports.RE2JSFlagsException = RE2JSFlagsException;
   exports.RE2JSGroupException = RE2JSGroupException;