re2js 2.3.1 → 2.4.0

package/README.md

@@ -615,23 +615,23 @@ Because RE2JS's Lazy DFA, Prefilter, and OnePass engines operate efficiently wit
 
 Here is a benchmark running 30,000 items through both engines using their respective `.test()` fast-paths (averages of multiple runs):
 
-| Benchmark Scenario        | Pattern Example            | RE2JS (Pure JS) | RE2-Node (C++) | Result                       |
-|:--------------------------|:---------------------------|:----------------|:---------------|:-----------------------------|
-| **Simple Literal**        | `/damage/`                 | **~5.82 ms**    | ~14.08 ms      | `re2js` is **~2.42x faster** |
-| **Greedy Wildcard**       | `/enters.*battlefield/`    | **~8.44 ms**    | ~13.32 ms      | `re2js` is **~1.58x faster** |
-| **Lazy Wildcard**         | `/enters.*?battlefield/`   | **~8.43 ms**    | ~13.33 ms      | `re2js` is **~1.58x faster** |
-| **Deep State Machine**    | `/([0-9]+(/[0-9]+)+)/`     | **~7.71 ms**    | ~16.08 ms      | `re2js` is **~2.09x faster** |
-| **Massive Alternation**   | `/White\|Blue\|Black.../`  | **~11.62 ms**   | ~14.99 ms      | `re2js` is **~1.29x faster** |
-| **Bounded Repetition**    | `/[A-Z][a-z]{5,15}/`       | **~12.20 ms**   | ~13.77 ms      | `re2js` is **~1.13x faster** |
-| **ReDoS Attempt**         | `/(a+)+!/`                 | **~5.68 ms**    | ~16.25 ms      | `re2js` is **~2.86x faster** |
-| **Case Insensitive**      | `/(?i)swamp/`              | ~18.71 ms       | **~16.22 ms**  | `re2-node` is ~1.15x faster  |
-| **Word Boundaries (NFA)** | `/\b(Flying\|First...)\b/` | ~57.24 ms       | **~15.66 ms**  | `re2-node` is ~3.66x faster  |
+| Benchmark Scenario        | Pattern Example            | RE2JS (Pure JS) | RE2-Node (C++) | Result                      |
+|:--------------------------|:---------------------------|:----------------|:---------------|:----------------------------|
+| **ReDoS Attempt**         | `/(a+)+!/`                 | **7.28 ms**     | 12.74 ms       | `re2js` is **1.75x** faster |
+| **Deep State Machine**    | `/([0-9]+(/[0-9]+)+)/`     | **8.78 ms**     | 12.56 ms       | `re2js` is **1.43x** faster |
+| **Simple Literal**        | `/damage/`                 | **7.04 ms**     | 9.59 ms        | `re2js` is **1.36x** faster |
+| **Lazy Wildcard**         | `/enters.*?battlefield/`   | **9.36 ms**     | 10.27 ms       | `re2js` is **1.10x** faster |
+| **Greedy Wildcard**       | `/enters.*battlefield/`    | **9.47 ms**     | 10.03 ms       | `re2js` is **1.06x** faster |
+| **Massive Alternation**   | `/White\|Blue\|Black.../`  | 11.69 ms        | **11.28 ms**   | `re2-node` is 1.04x faster  |
+| **Bounded Repetition**    | `/[A-Z][a-z]{5,15}/`       | 12.68 ms        | **10.64 ms**   | `re2-node` is 1.19x faster  |
+| **Case Insensitive**      | `/(?i)swamp/`              | 18.58 ms        | **12.64 ms**   | `re2-node` is 1.47x faster  |
+| **Word Boundaries (NFA)** | `/\b(Flying\|First...)\b/` | 30.45 ms        | **12.22 ms**   | `re2-node` is 2.49x faster  |
 
 **Takeaways:**
-* **The Literal & Prefilter Advantage (JS wins):** For simple text searches like literals and wildcards, RE2JS's Literal Fast-Path and Prefilter Engine leverage highly optimized native JavaScript `indexOf` string scanning. By bypassing the regex state machines completely, pure JavaScript now outperforms native C++ bindings by **~1.5x to 2.4x**.
-* **State-Heavy Tasks (JS wins):** For complex state machines, massive alternations, and catastrophic backtracking (ReDoS) attempts, RE2JS operates entirely within V8's highly optimized JIT. Avoiding the JS-to-C++ N-API bridge overhead allows pure JavaScript to beat native bindings by **~1.1x to 2.8x**.
-* **Case Insensitivity (C++ wins):** Case-folded literal matching currently skips the prefilter and requires full DFA state-machine evaluation, giving C++ a slight ~1.15x edge due to raw memory scanning speeds.
-* **The Fallback Engines (C++ wins):** Pure DFA engines mathematically cannot track look-behind context like Word Boundaries (`\b`). When RE2JS encounters these, it safely bails out to its NFA engine. As shown in the benchmarks, the pure JS NFA fallback is slower than the C++ NFA. **For maximum performance in RE2JS, avoid `\b` when doing bulk boolean `.test()` matching.**
+* **Pure JS Strengths:** For complex state tracking (nested groups, wildcards) and literal string scanning, `re2js` actually beats the native C++ bindings. V8's Turbofan JIT compiler is able to heavily optimize the Pure JS DFA loop, bypassing the C++ boundary entirely.
+* **C++ Strengths:** For character class evaluations (Case Insensitivity, Bounded Repetitions, Alternations), `re2-node` has a slight edge thanks to highly optimized, hardware-level memory tables.
+* **The NFA Fallback:** Pure DFA engines mathematically cannot track look-behind context like Word Boundaries (`\b`). When RE2JS encounters these, it safely bails out to its NFA engine. As shown in the benchmarks, the pure JS NFA is significantly slower than the C++ NFA. **For maximum performance in RE2JS, avoid `\b` when doing bulk boolean `.test()` matching.**
+
 
 ### RE2JS vs JavaScript's native RegExp
 

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.3.1
+ * @version v2.4.0
  * @author Oleksii Vasyliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -224,7 +224,7 @@ class UnicodeTables {
   static _CASE_ORBIT = null;
   static get CASE_ORBIT() {
     if (!this._CASE_ORBIT) {
-      this._CASE_ORBIT = decodeOrbit('rCrDIzDYqpII-LiC8cQlHa+0HGrpI6EzClClOBmOBkOBoOBpOBnOBrOBsOBqOlByPBzPBxPyK5crCz+HCydD1dD4dB5dB6dC8dEgeBheCieDmeDpeHj-HCweD1fDxeB+9HBwfC1FE2eBxfBjeBjdD1eDmpIHycB0fEmdBgda6cBhdD4cB1cdyhBC0hBK+hBDhiBBiiBIqiBIgkHChkHKikHDjkHBkkHImkHYjjBBnkH9gGygBB0gBB+gBBhhBBlkHBihBBqhBBijBBqypB4OhzHB70H6BgzHD-GiHo8HBp8HBq8HBr8HBs8HBt8HBu8HBv8HBg8HBh8HBi8HBj8HBk8HBl8HBm8HBn8HB48HB58HB68HB78HB88HB98HB+8HB-8HBw8HBx8HBy8HBz8HB08HB18HB28HB38HBo9HBp9HBq9HBr9HBs9HBt9HBu9HBv9HBg9HBh9HBi9HBj9HBk9HBl9HBm9HBn9HE89HJz9HClaFs+HJj+HHwcQwdQ8-HJz-HqJpdErCBlG-ohBrypBBokH6lVm4+BBl4+B');
+      this._CASE_ORBIT = decodeOrbit('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');
     }
     return this._CASE_ORBIT;
   }
@@ -519,7 +519,7 @@ class Unicode {
   // is tests whether rune is in the specified table of ranges.
   static is(ranges, r) {
     // Fast path for Latin-1 characters using linear search.
-    if (r <= this.MAX_LATIN1) {
+    if (r <= Unicode.MAX_LATIN1) {
       for (let i = 0; i < ranges.length; i++) {
         const rhi = ranges.getHi(i);
         if (r > rhi) {
@@ -536,24 +536,24 @@ class Unicode {
     }
 
     // Fallback to binary search for runes outside Latin-1
-    return ranges.length > 0 && r >= ranges.getLo(0) && this.is32(ranges, r);
+    return ranges.length > 0 && r >= ranges.getLo(0) && Unicode.is32(ranges, r);
   }
 
   // isUpper reports whether the rune is an upper case letter.
   static isUpper(r) {
-    if (r <= this.MAX_LATIN1) {
+    if (r <= Unicode.MAX_LATIN1) {
       const s = String.fromCodePoint(r);
       return s.toUpperCase() === s && s.toLowerCase() !== s;
     }
-    return this.is(UnicodeTables.Upper, r);
+    return Unicode.is(UnicodeTables.Upper, r);
   }
 
   // isPrint reports whether the rune is printable (Unicode L/M/N/P/S or ' ').
   static isPrint(r) {
-    if (r <= this.MAX_LATIN1) {
-      return r >= 0x20 && r < this.MAX_ASCII || r >= 0xa1 && r !== 0xad;
+    if (r <= Unicode.MAX_LATIN1) {
+      return r >= 0x20 && r < Unicode.MAX_ASCII || r >= 0xa1 && r !== 0xad;
     }
-    return this.is(UnicodeTables.Print, r);
+    return Unicode.is(UnicodeTables.Print, r);
   }
 
   // simpleFold iterates over Unicode code points equivalent under
@@ -608,11 +608,13 @@ class Unicode {
 
     // Fast path for the common case where both runes are ASCII characters.
     // Coerces both runes to lowercase if applicable.
-    if (r1 <= this.MAX_ASCII && r2 <= this.MAX_ASCII) {
-      if (Codepoint.CODES.get('A') <= r1 && r1 <= Codepoint.CODES.get('Z')) {
+    if (r1 <= Unicode.MAX_ASCII && r2 <= Unicode.MAX_ASCII) {
+      // 65 is 'A', 90 is 'Z'
+      if (65 <= r1 && r1 <= 90) {
         r1 |= 0x20;
       }
-      if (Codepoint.CODES.get('A') <= r2 && r2 <= Codepoint.CODES.get('Z')) {
+      // 65 is 'A', 90 is 'Z'
+      if (65 <= r2 && r2 <= 90) {
         r2 |= 0x20;
       }
       return r1 === r2;
@@ -620,7 +622,7 @@ class Unicode {
 
     // Fall back to full Unicode case folding otherwise.
     // Invariant: r1 must be non-negative
-    for (let r = this.simpleFold(r1); r !== r1; r = this.simpleFold(r)) {
+    for (let r = Unicode.simpleFold(r1); r !== r1; r = Unicode.simpleFold(r)) {
       if (r === r2) {
         return true;
       }
@@ -629,6 +631,31 @@ class Unicode {
   }
 }
 
+/**
+ * Size of the precomputed single-byte lookup table.
+ * Covers standard ASCII and Latin-1 characters for fast-path execution.
+ */
+const FAST_PATH_TABLE_SIZE = 256;
+/**
+ * Precomputed lookup table for Word Boundary (\b, \B) assertions.
+ * * By precomputing the boolean results for standard ASCII word ranges
+ * ('a'-'z', 'A'-'Z', '0'-'9', '_'), we completely eliminate 4 logical
+ * branches from the NFA's hot execution loop. This prevents costly
+ * CPU branch mispredictions when scanning large strings.
+ */
+const WORD_RUNE_TABLE = new Uint8Array(FAST_PATH_TABLE_SIZE);
+for (let i = 0; i < FAST_PATH_TABLE_SIZE; i++) {
+  WORD_RUNE_TABLE[i] = 97 <= i && i <= 122 ||
+  // 'a' - 'z'
+  65 <= i && i <= 90 ||
+  // 'A' - 'Z'
+  48 <= i && i <= 57 ||
+  // '0' - '9'
+  i === 95 // '_'
+  ? 1 : 0;
+}
+let cachedNativeEncoder = null;
+let cachedNativeDecoder = null;
 /**
  * Various constants and helper utilities.
  */
@@ -674,7 +701,7 @@ class Utils {
   static escapeRune(rune) {
     let out = '';
     if (Unicode.isPrint(rune)) {
-      if (this.METACHARACTERS.indexOf(String.fromCodePoint(rune)) >= 0) {
+      if (Utils.METACHARACTERS.indexOf(String.fromCodePoint(rune)) >= 0) {
         out += '\\';
       }
       out += String.fromCodePoint(rune);
@@ -727,12 +754,21 @@ class Utils {
     return out;
   }
 
-  // Returns the array of runes in the specified Java UTF-16 string.
+  // Returns the array of runes in the specified JS UTF-16 string.
   static stringToRunes(str) {
-    return Array.from(String(str)).map(s => s.codePointAt(0));
+    const string = String(str);
+    const runes = [];
+    let i = 0;
+    while (i < string.length) {
+      const cp = string.codePointAt(i);
+      runes.push(cp);
+      // Surrogate pairs (Emojis, etc.) are > 0xFFFF
+      i += cp > Unicode.MAX_BMP ? 2 : 1;
+    }
+    return runes;
   }
 
-  // Returns the Java UTF-16 string containing the single rune |r|.
+  // Returns the JS UTF-16 string containing the single rune |r|.
   static runeToString(r) {
     return String.fromCodePoint(r);
   }
@@ -741,7 +777,7 @@ class Utils {
   // during the evaluation of the \b and \B zero-width assertions.
   // These assertions are ASCII-only: the word characters are [A-Za-z0-9_].
   static isWordRune(r) {
-    return Codepoint.CODES.get('a') <= r && r <= Codepoint.CODES.get('z') || Codepoint.CODES.get('A') <= r && r <= Codepoint.CODES.get('Z') || Codepoint.CODES.get('0') <= r && r <= Codepoint.CODES.get('9') || r === Codepoint.CODES.get('_');
+    return r < FAST_PATH_TABLE_SIZE ? WORD_RUNE_TABLE[r] === 1 : false;
   }
 
   // emptyOpContext returns the zero-width assertions satisfied at the position
@@ -754,21 +790,24 @@ class Utils {
   static emptyOpContext(r1, r2) {
     let op = 0;
     if (r1 < 0) {
-      op |= this.EMPTY_BEGIN_TEXT | this.EMPTY_BEGIN_LINE;
+      op |= Utils.EMPTY_BEGIN_TEXT | Utils.EMPTY_BEGIN_LINE;
     }
-    if (r1 === Codepoint.CODES.get('\n')) {
-      op |= this.EMPTY_BEGIN_LINE;
+    // Hardcode 10 for '\n'
+    if (r1 === 10) {
+      op |= Utils.EMPTY_BEGIN_LINE;
     }
     if (r2 < 0) {
-      op |= this.EMPTY_END_TEXT | this.EMPTY_END_LINE;
+      op |= Utils.EMPTY_END_TEXT | Utils.EMPTY_END_LINE;
     }
-    if (r2 === Codepoint.CODES.get('\n')) {
-      op |= this.EMPTY_END_LINE;
+
+    // Hardcode 10 for '\n'
+    if (r2 === 10) {
+      op |= Utils.EMPTY_END_LINE;
     }
-    if (this.isWordRune(r1) !== this.isWordRune(r2)) {
-      op |= this.EMPTY_WORD_BOUNDARY;
+    if (Utils.isWordRune(r1) !== Utils.isWordRune(r2)) {
+      op |= Utils.EMPTY_WORD_BOUNDARY;
     } else {
-      op |= this.EMPTY_NO_WORD_BOUNDARY;
+      op |= Utils.EMPTY_NO_WORD_BOUNDARY;
     }
     return op;
   }
@@ -783,7 +822,7 @@ class Utils {
   static quoteMeta(str) {
     return str.split('') // A char loop is correct because all metacharacters fit in one UTF-16 code.
     .map(s => {
-      if (this.METACHARACTERS.indexOf(s) >= 0) {
+      if (Utils.METACHARACTERS.indexOf(s) >= 0) {
         return `\\${s}`;
       }
       return s;
@@ -792,9 +831,23 @@ class Utils {
   static charCount(codePoint) {
     return codePoint > Unicode.MAX_BMP ? 2 : 1;
   }
+
+  /**
+   * High-speed conversion from TypedArrays to standard JS Arrays.
+   * Bypasses the expensive Symbol.iterator overhead of Array.from()
+   */
+  static toArray(typedArray) {
+    const len = typedArray.length;
+    const res = new Array(len);
+    for (let i = 0; i < len; i++) {
+      res[i] = typedArray[i];
+    }
+    return res;
+  }
   static stringToUtf8ByteArray(str) {
     if (globalThis.TextEncoder) {
-      return Array.from(new TextEncoder().encode(str));
+      if (!cachedNativeEncoder) cachedNativeEncoder = new TextEncoder();
+      return Utils.toArray(cachedNativeEncoder.encode(str));
     } else {
       // fallback, if no TextEncoder
       let out = [],
@@ -824,7 +877,9 @@ class Utils {
   }
   static utf8ByteArrayToString(bytes) {
     if (globalThis.TextDecoder) {
-      return new TextDecoder('utf-8').decode(new Uint8Array(bytes));
+      if (!cachedNativeDecoder) cachedNativeDecoder = new TextDecoder('utf-8');
+      const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+      return cachedNativeDecoder.decode(view);
     } else {
       // fallback, if no TextDecoder
       let out = [],
@@ -1121,15 +1176,34 @@ class MachineUTF8Input extends MachineInputBase {
     if (targetLength === 0) {
       return fromIndex <= this.end ? fromIndex : -1;
     }
+    const firstByte = target[0];
     let limit = this.end - targetLength;
-    for (let i = fromIndex; i <= limit; i++) {
-      for (let j = 0; j < targetLength; j++) {
+    // Feature detection: Native TypedArray indexOf (ES2015)
+    const hasNativeIndexOf = typeof source.indexOf === 'function';
+    let i = fromIndex;
+    while (i <= limit) {
+      // Fast-forward to the first matching byte using C++ bindings if available
+      if (hasNativeIndexOf) {
+        i = source.indexOf(firstByte, i);
+        if (i === -1 || i > limit) return -1;
+      } else {
+        // Fallback: Manual loop
+        while (i <= limit && source[i] !== firstByte) i++;
+        if (i > limit) return -1;
+      }
+
+      // First byte matches, verify the rest of the target sequence
+      let match = true;
+      for (let j = 1; j < targetLength; j++) {
         if (source[i + j] !== target[j]) {
+          match = false;
           break;
-        } else if (j === targetLength - 1) {
-          return i;
         }
       }
+      if (match) {
+        return i;
+      }
+      i++;
     }
     return -1;
   }
@@ -1201,8 +1275,10 @@ class MachineUTF16Input extends MachineInputBase {
   // Returns a bitmask of EMPTY_* flags.
   context(pos) {
     pos += this.start;
-    const r1 = pos > this.start && pos <= this.end ? this.charSequence.codePointAt(pos - 1) : -1;
-    const r2 = pos < this.end ? this.charSequence.codePointAt(pos) : -1;
+
+    // We only care about ASCII word runes and newlines for context boundaries
+    const r1 = pos > this.start && pos <= this.end ? this.charSequence.charCodeAt(pos - 1) : -1;
+    const r2 = pos < this.end ? this.charSequence.charCodeAt(pos) : -1;
     return Utils.emptyOpContext(r1, r2);
   }
   prefixLength(re2) {
@@ -2209,7 +2285,7 @@ class Machine {
       return Utils.emptyInts();
     }
     // Use subarray() to create a zero-allocation view before converting
-    return Array.from(this.matchcap.subarray(0, this.ncap));
+    return Utils.toArray(this.matchcap.subarray(0, this.ncap));
   }
 
   // alloc() allocates a new thread with the given instruction.
@@ -3171,7 +3247,7 @@ class Backtracker {
     }
 
     // Must slice so we don't accidentally leak trailing arrays from previously recycled typed arrays
-    const result = ncap === 0 ? [] : Array.from(b.matchcap.subarray(0, ncap));
+    const result = ncap === 0 ? [] : Utils.toArray(b.matchcap.subarray(0, ncap));
     bitStatePool.push(b);
     return result;
   }
@@ -3547,7 +3623,7 @@ class OnePass {
               matchcap[0] = 0;
               matchcap[1] = pos;
             }
-            return ncap === 0 ? [] : Array.from(matchcap);
+            return ncap === 0 ? [] : Utils.toArray(matchcap);
           }
         case Inst.RUNE:
           if (!inst.matchRune(rune)) return null;
@@ -3596,7 +3672,7 @@ class OnePass {
       }
     }
     if (!matched) return null;
-    return ncap === 0 ? [] : Array.from(matchcap);
+    return ncap === 0 ? [] : Utils.toArray(matchcap);
   }
 }
 
@@ -5350,7 +5426,7 @@ class StringIterator {
     return r;
   }
   lookingAt(s) {
-    return this.rest().startsWith(s);
+    return this.str.startsWith(s, this.position);
   }
 
   // Returns the rest of the pattern as a Java UTF-16 string.