re2js 1.2.3 → 1.3.1

package/build/index.esm.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
@@ -841,6 +841,181 @@ class MatcherInput {
   }
 }
 
+/**
+ * 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) {
@@ -1477,181 +1652,6 @@ class Matcher {
   }
 }
 
-/**
- * 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.
  *
@@ -2110,6 +2110,204 @@ class Machine {
   }
 }
 
+// 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
@@ -5242,6 +5440,22 @@ class RE2 {
     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);
   }
 
   /**
@@ -5326,10 +5540,10 @@ class RE2 {
     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).
@@ -5347,7 +5561,7 @@ class RE2 {
     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;
   }
 
   /**
@@ -5375,7 +5589,7 @@ class RE2 {
       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];
     }
@@ -5387,7 +5601,7 @@ class RE2 {
    */
   // 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;
   }
 
   /**
@@ -5424,7 +5638,7 @@ class RE2 {
     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;
       }
@@ -5482,7 +5696,7 @@ class RE2 {
     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;
       }
@@ -5553,7 +5767,7 @@ class RE2 {
    */
   // 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;
     }
@@ -5568,7 +5782,7 @@ class RE2 {
    */
   // 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;
     }
@@ -5585,7 +5799,7 @@ class RE2 {
    */
   // 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 '';
     }
@@ -5601,7 +5815,7 @@ class RE2 {
    */
   // 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);
   }
 
   /**
@@ -5613,7 +5827,7 @@ class RE2 {
    */
   // 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;
     }
@@ -5635,7 +5849,7 @@ class RE2 {
    */
   // 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));
   }
 
   /**
@@ -5647,7 +5861,7 @@ class RE2 {
    */
   // 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;
     }
@@ -5669,7 +5883,7 @@ class RE2 {
    */
   // 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));
   }
 
   /**
@@ -6121,6 +6335,39 @@ class RE2JS {
     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.