re2js 2.3.1 → 2.3.2

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 v2.3.1
+ * @version v2.3.2
  * @author Oleksii Vasyliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -633,6 +633,31 @@
     }
   }
 
+  /**
+   * 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.
    */
@@ -731,12 +756,21 @@
       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);
     }
@@ -745,7 +779,7 @@
     // 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
@@ -758,21 +792,24 @@
     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;
     }
@@ -796,9 +833,23 @@
     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 = [],
@@ -828,7 +879,9 @@
     }
     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 = [],
@@ -1125,15 +1178,34 @@
       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;
     }
@@ -1205,8 +1277,10 @@
     // 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) {
@@ -2213,7 +2287,7 @@
         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.
@@ -3175,7 +3249,7 @@
       }
 
       // 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;
     }
@@ -3551,7 +3625,7 @@
                 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;
@@ -3600,7 +3674,7 @@
         }
       }
       if (!matched) return null;
-      return ncap === 0 ? [] : Array.from(matchcap);
+      return ncap === 0 ? [] : Utils.toArray(matchcap);
     }
   }
 
@@ -5354,7 +5428,7 @@
       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.