re2js 1.3.0 → 1.3.1

package/build/index.esm.d.ts

@@ -56,19 +56,19 @@ export class Matcher {
      */
     reset(): Matcher;
     /** @type {number} */
-    matcherInputLength: number;
+    matcherInputLength: number | undefined;
     /** @type {number} */
-    appendPos: number;
-    hasMatch: boolean;
-    hasGroups: boolean;
-    anchorFlag: number;
+    appendPos: number | undefined;
+    hasMatch: boolean | undefined;
+    hasGroups: boolean | undefined;
+    anchorFlag: number | undefined;
     /**
      * Resets the {@code Matcher} and changes the input.
      * @param {Utf8MatcherInput|Utf16MatcherInput} input
      * @returns {Matcher} the {@code Matcher} itself, for chained method calls
      */
     resetMatcherInput(input: Utf8MatcherInput | Utf16MatcherInput): Matcher;
-    matcherInput: Utf8MatcherInput | Utf16MatcherInput;
+    matcherInput: Utf8MatcherInput | Utf16MatcherInput | undefined;
     /**
      * Returns the start of the named group of the most recent match, or -1 if the group was not
      * matched.
@@ -340,6 +340,26 @@ export class RE2JS {
      * @returns {Matcher}
      */
     matcher(input: string | number[]): Matcher;
+    /**
+     * 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: string | number[]): boolean;
+    /**
+     * 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: string | number[]): boolean;
     /**
      * 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.
@@ -395,11 +415,6 @@ export class RE2JS {
  */
 export class RE2JSCompileException extends RE2JSException {
 }
-/**
- * An exception thrown by DFA
- */
-export class RE2JSDfaMemoryException extends RE2JSException {
-}
 export class RE2JSException extends Error {
     /** @param {string} message */
     constructor(message: string);
@@ -439,7 +454,7 @@ export class RE2JSSyntaxException extends RE2JSException {
     getPattern(): string | null;
 }
 declare class Utf8MatcherInput extends MatcherInputBase {
-    constructor(bytes?: any);
+    constructor(bytes?: null);
     bytes: any;
     getEncoding(): any;
     /**
@@ -459,7 +474,7 @@ declare class Utf8MatcherInput extends MatcherInputBase {
     length(): number;
 }
 declare class Utf16MatcherInput extends MatcherInputBase {
-    constructor(charSequence?: any);
+    constructor(charSequence?: null);
     charSequence: any;
     getEncoding(): any;
     /**

package/build/index.esm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"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"}

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.3.0
+ * @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) {
@@ -921,17 +1096,6 @@ class RE2JSFlagsException extends RE2JSException {
   }
 }
 
-/**
- * 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.
  *
@@ -1488,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.
  *
@@ -2121,21 +2110,40 @@ 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(id, nfaStates, isMatch) {
-    this.id = id; // Stringified NFA state list (e.g., "1,4,7")
-    this.nfaStates = nfaStates; // Array of Instruction PCs
+  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 (unanchored)
+    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(); // id -> DFAState
+    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), like RE2 max_mem
+    this.stateLimit = 10000; // Prevent memory explosion (ReDoS protection)
   }
 
   // Follows epsilon (empty) transitions to find all reachable states without consuming a char
@@ -2179,17 +2187,37 @@ class DFA {
     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);
+    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
-    if (this.stateCache.size > this.stateLimit) {
-      throw new RE2JSDfaMemoryException('dfa error: Out of memory exception');
+    // 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;
     }
-    const state = new DFAState(id, closureResult.pcs, closureResult.isMatch);
-    this.stateCache.set(id, state);
+
+    // State not found, create it and add to bucket
+    const state = new DFAState(sortedPCs, closureResult.isMatch);
+    bucket.push(state);
+    this.stateCount++;
     return state;
   }
 
@@ -2253,6 +2281,11 @@ class DFA {
       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
@@ -5415,18 +5448,10 @@ class RE2 {
     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;
-      }
+    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
@@ -6310,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.
@@ -6428,5 +6486,5 @@ class RE2JS {
   }
 }
 
-export { Matcher, RE2JS, RE2JSCompileException, RE2JSDfaMemoryException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSSyntaxException };
+export { Matcher, RE2JS, RE2JSCompileException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSSyntaxException };
 //# sourceMappingURL=index.esm.js.map