re2js 1.2.3 → 1.3.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 v1.2.3
+ * @version v1.3.1
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -847,6 +847,181 @@
     }
   }
 
+  /**
+   * MachineInput abstracts different representations of the input text supplied to the Machine. It
+   * provides one-character lookahead.
+   */
+  class MachineInputBase {
+    static EOF() {
+      return -1 << 3;
+    }
+
+    // can we look ahead without losing info?
+    canCheckPrefix() {
+      return true;
+    }
+
+    // Returns the end position in the same units as step().
+    endPos() {
+      return this.end;
+    }
+  }
+
+  // An implementation of MachineInput for UTF-8 byte arrays.
+  // |pos| and |width| are byte indices.
+  class MachineUTF8Input extends MachineInputBase {
+    constructor(bytes, start = 0, end = bytes.length) {
+      super();
+      this.bytes = bytes;
+      this.start = start;
+      this.end = end;
+    }
+
+    // Returns the rune at the specified index; the units are
+    // unspecified, but could be UTF-8 byte, UTF-16 char, or rune
+    // indices.  Returns the width (in the same units) of the rune in
+    // the lower 3 bits, and the rune (Unicode code point) in the high
+    // bits.  Never negative, except for EOF which is represented as -1
+    // << 3 | 0.
+    step(i) {
+      i += this.start;
+      if (i >= this.end) {
+        return MachineInputBase.EOF();
+      }
+      let x = this.bytes[i++] & 255;
+      if ((x & 128) === 0) {
+        return x << 3 | 1;
+      } else if ((x & 224) === 192) {
+        x = x & 31;
+        if (i >= this.end) {
+          return MachineInputBase.EOF();
+        }
+        x = x << 6 | this.bytes[i++] & 63;
+        return x << 3 | 2;
+      } else if ((x & 240) === 224) {
+        x = x & 15;
+        if (i + 1 >= this.end) {
+          return MachineInputBase.EOF();
+        }
+        x = x << 6 | this.bytes[i++] & 63;
+        x = x << 6 | this.bytes[i++] & 63;
+        return x << 3 | 3;
+      } else {
+        x = x & 7;
+        if (i + 2 >= this.end) {
+          return MachineInputBase.EOF();
+        }
+        x = x << 6 | this.bytes[i++] & 63;
+        x = x << 6 | this.bytes[i++] & 63;
+        x = x << 6 | this.bytes[i++] & 63;
+        return x << 3 | 4;
+      }
+    }
+
+    // Returns the index relative to |pos| at which |re2.prefix| is found
+    // in this input stream, or a negative value if not found.
+    index(re2, pos) {
+      pos += this.start;
+      const i = this.indexOf(this.bytes, re2.prefixUTF8, pos);
+      return i < 0 ? i : i - pos;
+    }
+
+    // Returns a bitmask of EMPTY_* flags.
+    context(pos) {
+      pos += this.start;
+      let r1 = -1;
+      if (pos > this.start && pos <= this.end) {
+        let start = pos - 1;
+        r1 = this.bytes[start--];
+        if (r1 >= 128) {
+          let lim = pos - 4;
+          if (lim < this.start) {
+            lim = this.start;
+          }
+          while (start >= lim && (this.bytes[start] & 192) === 128) {
+            start--;
+          }
+          if (start < this.start) {
+            start = this.start;
+          }
+          r1 = this.step(start) >> 3;
+        }
+      }
+      const r2 = pos < this.end ? this.step(pos) >> 3 : -1;
+      return Utils.emptyOpContext(r1, r2);
+    }
+
+    // Returns the index of the first occurrence of array |target| within
+    // array |source| after |fromIndex|, or -1 if not found.
+    indexOf(source, target, fromIndex = 0) {
+      let targetLength = target.length;
+      if (targetLength === 0) {
+        return -1;
+      }
+      let sourceLength = source.length;
+      for (let i = fromIndex; i <= sourceLength - targetLength; i++) {
+        for (let j = 0; j < targetLength; j++) {
+          if (source[i + j] !== target[j]) {
+            break;
+          } else if (j === targetLength - 1) {
+            return i;
+          }
+        }
+      }
+      return -1;
+    }
+  }
+
+  // |pos| and |width| are in JS "char" units.
+  class MachineUTF16Input extends MachineInputBase {
+    constructor(charSequence, start = 0, end = charSequence.length) {
+      super();
+      this.charSequence = charSequence;
+      this.start = start;
+      this.end = end;
+    }
+
+    // Returns the rune at the specified index; the units are
+    // unspecified, but could be UTF-8 byte, UTF-16 char, or rune
+    // indices.  Returns the width (in the same units) of the rune in
+    // the lower 3 bits, and the rune (Unicode code point) in the high
+    // bits.  Never negative, except for EOF which is represented as -1
+    // << 3 | 0.
+    step(pos) {
+      pos += this.start;
+      if (pos < this.end) {
+        const rune = this.charSequence.codePointAt(pos);
+        return rune << 3 | Utils.charCount(rune);
+      } else {
+        return MachineInputBase.EOF();
+      }
+    }
+
+    // Returns the index relative to |pos| at which |re2.prefix| is found
+    // in this input stream, or a negative value if not found.
+    index(re2, pos) {
+      pos += this.start;
+      const i = this.charSequence.indexOf(re2.prefix, pos);
+      return i < 0 ? i : i - pos;
+    }
+
+    // Returns a bitmask of EMPTY_* flags.
+    context(pos) {
+      pos += this.start;
+      const r1 = pos > 0 && pos <= this.charSequence.length ? this.charSequence.codePointAt(pos - 1) : -1;
+      const r2 = pos < this.charSequence.length ? this.charSequence.codePointAt(pos) : -1;
+      return Utils.emptyOpContext(r1, r2);
+    }
+  }
+  class MachineInput {
+    static fromUTF8(bytes, start = 0, end = bytes.length) {
+      return new MachineUTF8Input(bytes, start, end);
+    }
+    static fromUTF16(charSequence, start = 0, end = charSequence.length) {
+      return new MachineUTF16Input(charSequence, start, end);
+    }
+  }
+
   class RE2JSException extends Error {
     /** @param {string} message */
     constructor(message) {
@@ -1483,181 +1658,6 @@
     }
   }
 
-  /**
-   * MachineInput abstracts different representations of the input text supplied to the Machine. It
-   * provides one-character lookahead.
-   */
-  class MachineInputBase {
-    static EOF() {
-      return -1 << 3;
-    }
-
-    // can we look ahead without losing info?
-    canCheckPrefix() {
-      return true;
-    }
-
-    // Returns the end position in the same units as step().
-    endPos() {
-      return this.end;
-    }
-  }
-
-  // An implementation of MachineInput for UTF-8 byte arrays.
-  // |pos| and |width| are byte indices.
-  class MachineUTF8Input extends MachineInputBase {
-    constructor(bytes, start = 0, end = bytes.length) {
-      super();
-      this.bytes = bytes;
-      this.start = start;
-      this.end = end;
-    }
-
-    // Returns the rune at the specified index; the units are
-    // unspecified, but could be UTF-8 byte, UTF-16 char, or rune
-    // indices.  Returns the width (in the same units) of the rune in
-    // the lower 3 bits, and the rune (Unicode code point) in the high
-    // bits.  Never negative, except for EOF which is represented as -1
-    // << 3 | 0.
-    step(i) {
-      i += this.start;
-      if (i >= this.end) {
-        return MachineInputBase.EOF();
-      }
-      let x = this.bytes[i++] & 255;
-      if ((x & 128) === 0) {
-        return x << 3 | 1;
-      } else if ((x & 224) === 192) {
-        x = x & 31;
-        if (i >= this.end) {
-          return MachineInputBase.EOF();
-        }
-        x = x << 6 | this.bytes[i++] & 63;
-        return x << 3 | 2;
-      } else if ((x & 240) === 224) {
-        x = x & 15;
-        if (i + 1 >= this.end) {
-          return MachineInputBase.EOF();
-        }
-        x = x << 6 | this.bytes[i++] & 63;
-        x = x << 6 | this.bytes[i++] & 63;
-        return x << 3 | 3;
-      } else {
-        x = x & 7;
-        if (i + 2 >= this.end) {
-          return MachineInputBase.EOF();
-        }
-        x = x << 6 | this.bytes[i++] & 63;
-        x = x << 6 | this.bytes[i++] & 63;
-        x = x << 6 | this.bytes[i++] & 63;
-        return x << 3 | 4;
-      }
-    }
-
-    // Returns the index relative to |pos| at which |re2.prefix| is found
-    // in this input stream, or a negative value if not found.
-    index(re2, pos) {
-      pos += this.start;
-      const i = this.indexOf(this.bytes, re2.prefixUTF8, pos);
-      return i < 0 ? i : i - pos;
-    }
-
-    // Returns a bitmask of EMPTY_* flags.
-    context(pos) {
-      pos += this.start;
-      let r1 = -1;
-      if (pos > this.start && pos <= this.end) {
-        let start = pos - 1;
-        r1 = this.bytes[start--];
-        if (r1 >= 128) {
-          let lim = pos - 4;
-          if (lim < this.start) {
-            lim = this.start;
-          }
-          while (start >= lim && (this.bytes[start] & 192) === 128) {
-            start--;
-          }
-          if (start < this.start) {
-            start = this.start;
-          }
-          r1 = this.step(start) >> 3;
-        }
-      }
-      const r2 = pos < this.end ? this.step(pos) >> 3 : -1;
-      return Utils.emptyOpContext(r1, r2);
-    }
-
-    // Returns the index of the first occurrence of array |target| within
-    // array |source| after |fromIndex|, or -1 if not found.
-    indexOf(source, target, fromIndex = 0) {
-      let targetLength = target.length;
-      if (targetLength === 0) {
-        return -1;
-      }
-      let sourceLength = source.length;
-      for (let i = fromIndex; i <= sourceLength - targetLength; i++) {
-        for (let j = 0; j < targetLength; j++) {
-          if (source[i + j] !== target[j]) {
-            break;
-          } else if (j === targetLength - 1) {
-            return i;
-          }
-        }
-      }
-      return -1;
-    }
-  }
-
-  // |pos| and |width| are in JS "char" units.
-  class MachineUTF16Input extends MachineInputBase {
-    constructor(charSequence, start = 0, end = charSequence.length) {
-      super();
-      this.charSequence = charSequence;
-      this.start = start;
-      this.end = end;
-    }
-
-    // Returns the rune at the specified index; the units are
-    // unspecified, but could be UTF-8 byte, UTF-16 char, or rune
-    // indices.  Returns the width (in the same units) of the rune in
-    // the lower 3 bits, and the rune (Unicode code point) in the high
-    // bits.  Never negative, except for EOF which is represented as -1
-    // << 3 | 0.
-    step(pos) {
-      pos += this.start;
-      if (pos < this.end) {
-        const rune = this.charSequence.codePointAt(pos);
-        return rune << 3 | Utils.charCount(rune);
-      } else {
-        return MachineInputBase.EOF();
-      }
-    }
-
-    // Returns the index relative to |pos| at which |re2.prefix| is found
-    // in this input stream, or a negative value if not found.
-    index(re2, pos) {
-      pos += this.start;
-      const i = this.charSequence.indexOf(re2.prefix, pos);
-      return i < 0 ? i : i - pos;
-    }
-
-    // Returns a bitmask of EMPTY_* flags.
-    context(pos) {
-      pos += this.start;
-      const r1 = pos > 0 && pos <= this.charSequence.length ? this.charSequence.codePointAt(pos - 1) : -1;
-      const r2 = pos < this.charSequence.length ? this.charSequence.codePointAt(pos) : -1;
-      return Utils.emptyOpContext(r1, r2);
-    }
-  }
-  class MachineInput {
-    static fromUTF8(bytes, start = 0, end = bytes.length) {
-      return new MachineUTF8Input(bytes, start, end);
-    }
-    static fromUTF16(charSequence, start = 0, end = charSequence.length) {
-      return new MachineUTF16Input(charSequence, start, end);
-    }
-  }
-
   /**
    * A single instruction in the regular expression virtual machine.
    *
@@ -2116,6 +2116,204 @@
     }
   }
 
+  // FNV-1a 32-bit hash for an array of integers.
+  // Extremely fast, allocates no memory, and produces good distribution.
+  const hashPCs = pcs => {
+    let h = -2128831035; // 0x811c9dc5 (32-bit signed offset basis)
+    for (let i = 0; i < pcs.length; i++) {
+      h ^= pcs[i];
+      h = Math.imul(h, 16777619); // 0x01000193 (FNV prime)
+    }
+    return h;
+  };
+
+  // Zero-allocation array comparison for hash collision resolution
+  const arraysEqual = (a, b) => {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  };
+  class DFAState {
+    constructor(nfaStates, isMatch) {
+      this.nfaStates = nfaStates; // Int32Array of Instruction PCs
+      this.isMatch = isMatch; // Boolean
+      this.nextAscii = new Array(Unicode.MAX_ASCII + 1).fill(null); // Flat array for blisteringly fast ASCII lookups
+      this.nextMap = new Map(); // Cache of Char -> DFAState
+    }
+  }
+  class DFA {
+    constructor(prog) {
+      this.prog = prog;
+      this.stateCache = new Map(); // hash(number) -> DFAState[]
+      this.stateCount = 0; // Tracks total states for memory limits
+      this.startState = null;
+      this.stateLimit = 10000; // Prevent memory explosion (ReDoS protection)
+    }
+
+    // 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 sortedPCs = closureResult.pcs;
+      const hash = hashPCs(sortedPCs);
+
+      // Lookup hash bucket
+      let bucket = this.stateCache.get(hash);
+      if (bucket) {
+        // Resolve potential hash collisions
+        for (let i = 0; i < bucket.length; i++) {
+          const state = bucket[i];
+          if (arraysEqual(state.nfaStates, sortedPCs)) {
+            return state;
+          }
+        }
+      } else {
+        bucket = [];
+        this.stateCache.set(hash, bucket);
+      }
+
+      // Safety: prevent memory exhaustion from state explosion
+      // We flush the cache and return null, which seamlessly routes execution to the NFA
+      if (this.stateCount >= this.stateLimit) {
+        this.stateCache.clear();
+        this.stateCount = 0;
+        this.startState = null;
+        return null;
+      }
+
+      // State not found, create it and add to bucket
+      const state = new DFAState(sortedPCs, closureResult.isMatch);
+      bucket.push(state);
+      this.stateCount++;
+      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;
+
+        // prevent infinite loop on EOF
+        if (width === 0) {
+          break;
+        }
+        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 +5446,22 @@
       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);
+      }
+      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"
+      }
+
+      // Fallback to NFA
+      return this.doExecuteNFA(input, pos, anchor, ncap);
     }
 
     /**
@@ -5332,10 +5546,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 +5567,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 +5595,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 +5607,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 +5644,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 +5702,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 +5773,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 +5788,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 +5805,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 +5821,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 +5833,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 +5855,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 +5867,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 +5889,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));
     }
 
     /**
@@ -6127,6 +6341,39 @@
       return new Matcher(this, input);
     }
 
+    /**
+     * Tests whether the regular expression matches any part of the input string.
+     * Performance Note: This method is highly optimized. Because it only returns
+     * a boolean and does not extract capture groups, it bypasses the `Matcher` overhead
+     * and guarantees execution on the high-speed DFA engine whenever possible.
+     *
+     * @param {string|number[]} input - The input string or UTF-8 byte array to test against.
+     * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise.
+     */
+    test(input) {
+      if (Array.isArray(input)) {
+        // Reuse the existing UTF-8 fast-path method
+        return this.re2Input.matchUTF8(input);
+      }
+
+      // Reuse the existing UTF-16 fast-path method
+      return this.re2Input.match(input);
+    }
+
+    /**
+     * Tests whether the regular expression matches the ENTIRE input string.
+     * * **Performance Note:** This operates identically to `.matches()`, but is significantly
+     * faster because it does not request capture group data. By requesting 0 capture groups,
+     * it securely routes execution through the DFA fast-path.
+     *
+     * @param {string|number[]} input - The input string or UTF-8 byte array to test against.
+     * @returns {boolean} `true` if the exact input string fully matches the pattern, `false` otherwise.
+     */
+    testExact(input) {
+      const machineInput = Array.isArray(input) ? MachineInput.fromUTF8(input) : MachineInput.fromUTF16(input);
+      return this.re2Input.executeEngine(machineInput, 0, RE2Flags.ANCHOR_BOTH, 0) !== null;
+    }
+
     /**
      * Splits input around instances of the regular expression. It returns an array giving the strings
      * that occur before, between, and after instances of the regular expression.