re2js 2.3.1 → 2.4.0

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.4.0
  * @author Oleksii Vasyliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -228,7 +228,7 @@
     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;
     }
@@ -523,7 +523,7 @@
     // 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) {
@@ -540,24 +540,24 @@
       }
 
       // 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
@@ -612,11 +612,13 @@
 
       // 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;
@@ -624,7 +626,7 @@
 
       // 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;
         }
@@ -633,6 +635,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.
    */
@@ -678,7 +705,7 @@
     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);
@@ -731,12 +758,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 +781,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 +794,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;
     }
@@ -787,7 +826,7 @@
     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;
@@ -796,9 +835,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 +881,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 +1180,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 +1279,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 +2289,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 +3251,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 +3627,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 +3676,7 @@
         }
       }
       if (!matched) return null;
-      return ncap === 0 ? [] : Array.from(matchcap);
+      return ncap === 0 ? [] : Utils.toArray(matchcap);
     }
   }
 
@@ -5354,7 +5430,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.