re2js 2.2.0 → 2.2.2

package/build/index.umd.js

@@ -2,8 +2,8 @@
  * re2js
  * RE2JS is the JavaScript port of RE2, a regular expression engine that provides linear time matching
  *
- * @version v2.2.0
- * @author Alexey Vasiliev
+ * @version v2.2.2
+ * @author Oleksii Vasyliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
  * @license MIT
@@ -82,6 +82,8 @@
   const ASCII_SIZE = 128;
   const ASCII_TO_UPPER = new Int32Array(ASCII_SIZE);
   const ASCII_TO_LOWER = new Int32Array(ASCII_SIZE);
+  // The highest legal Basic Multilingual Plane (BMP) value.
+  const MAX_BMP = 0xffff;
   for (let i = 0; i < ASCII_SIZE; i++) {
     if (i >= 97 && i <= 122) {
       // a-z
@@ -105,11 +107,13 @@
     static toUpperCase(codepoint) {
       if (codepoint < ASCII_SIZE) return ASCII_TO_UPPER[codepoint];
       const s = String.fromCodePoint(codepoint).toUpperCase();
-      if (s.length > 1) {
+      const expectedLen = s.codePointAt(0) > MAX_BMP ? 2 : 1;
+      if (s.length > expectedLen) {
         return codepoint;
       }
       const sOrigin = String.fromCodePoint(s.codePointAt(0)).toLowerCase();
-      if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) {
+      const originExpectedLen = sOrigin.codePointAt(0) > MAX_BMP ? 2 : 1;
+      if (sOrigin.length > originExpectedLen || sOrigin.codePointAt(0) !== codepoint) {
         return codepoint;
       }
       return s.codePointAt(0);
@@ -120,11 +124,13 @@
     static toLowerCase(codepoint) {
       if (codepoint < ASCII_SIZE) return ASCII_TO_LOWER[codepoint];
       const s = String.fromCodePoint(codepoint).toLowerCase();
-      if (s.length > 1) {
+      const expectedLen = s.codePointAt(0) > MAX_BMP ? 2 : 1;
+      if (s.length > expectedLen) {
         return codepoint;
       }
       const sOrigin = String.fromCodePoint(s.codePointAt(0)).toUpperCase();
-      if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) {
+      const originExpectedLen = sOrigin.codePointAt(0) > MAX_BMP ? 2 : 1;
+      if (sOrigin.length > originExpectedLen || sOrigin.codePointAt(0) !== codepoint) {
         return codepoint;
       }
       return s.codePointAt(0);
@@ -226,7 +232,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+B6nCohhCBphhCBqhhCBrhhCBshhCBthhCBuhhCBvhhCBwhhCBxhhCByhhCBzhhCB0hhCB1hhCB2hhCB3hhCB4hhCB5hhCB6hhCB7hhCB8hhCB9hhCB+hhCB-hhCBgihCBhihCBiihCBjihCBkihCBlihCBmihCBnihCBoihCBpihCBqihCBrihCBsihCBtihCBuihCBvihCBgghCBhghCBighCBjghCBkghCBlghCBmghCBnghCBoghCBpghCBqghCBrghCBsghCBtghCBughCBvghCBwghCBxghCByghCBzghCB0ghCB1ghCB2ghCB3ghCB4ghCB5ghCB6ghCB7ghCB8ghCB9ghCB+ghCB-ghCBghhCBhhhCBihhCBjhhCBkhhCBlhhCBmhhCBnhhChD4mhCB5mhCB6mhCB7mhCB8mhCB9mhCB+mhCB-mhCBgnhCBhnhCBinhCBjnhCBknhCBlnhCBmnhCBnnhCBonhCBpnhCBqnhCBrnhCBsnhCBtnhCBunhCBvnhCBwnhCBxnhCBynhCBznhCB0nhCB1nhCB2nhCB3nhCB4nhCB5nhCB6nhCB7nhCFwlhCBxlhCBylhCBzlhCB0lhCB1lhCB2lhCB3lhCB4lhCB5lhCB6lhCB7lhCB8lhCB9lhCB+lhCB-lhCBgmhCBhmhCBimhCBjmhCBkmhCBlmhCBmmhCBnmhCBomhCBpmhCBqmhCBrmhCBsmhCBtmhCBumhCBvmhCBwmhCBxmhCBymhCBzmhC1D3shCB4shCB5shCB6shCB7shCB8shCB9shCB+shCB-shCBgthCBhthCCjthCBkthCBlthCBmthCBnthCBothCBpthCBqthCBrthCBsthCBtthCButhCBvthCBwthCBxthCCzthCB0thCB1thCB2thCB3thCB4thCB5thCC7thCB8thCCwrhCBxrhCByrhCBzrhCB0rhCB1rhCB2rhCB3rhCB4rhCB5rhCB6rhCC8rhCB9rhCB+rhCB-rhCBgshCBhshCBishCBjshCBkshCBlshCBmshCBnshCBoshCBpshCBqshCCsshCBtshCBushCBvshCBwshCBxshCByshCC0shCB1shCk2BgmjCBhmjCBimjCBjmjCBkmjCBlmjCBmmjCBnmjCBomjCBpmjCBqmjCBrmjCBsmjCBtmjCBumjCBvmjCBwmjCBxmjCBymjCBzmjCB0mjCB1mjCB2mjCB3mjCB4mjCB5mjCB6mjCB7mjCB8mjCB9mjCB+mjCB-mjCBgnjCBhnjCBinjCBjnjCBknjCBlnjCBmnjCBnnjCBonjCBpnjCBqnjCBrnjCBsnjCBtnjCBunjCBvnjCBwnjCBxnjCBynjCOgkjCBhkjCBikjCBjkjCBkkjCBlkjCBmkjCBnkjCBokjCBpkjCBqkjCBrkjCBskjCBtkjCBukjCBvkjCBwkjCBxkjCBykjCBzkjCB0kjCB1kjCB2kjCB3kjCB4kjCB5kjCB6kjCB7kjCB8kjCB9kjCB+kjCB-kjCBgljCBhljCBiljCBjljCBkljCBlljCBmljCBnljCBoljCBpljCBqljCBrljCBsljCBtljCBuljCBvljCBwljCBxljCByljC+CwrjCBxrjCByrjCBzrjCB0rjCB1rjCB2rjCB3rjCB4rjCB5rjCB6rjCB7rjCB8rjCB9rjCB+rjCB-rjCBgsjCBhsjCBisjCBjsjCBksjCBlsjCLwqjCBxqjCByqjCBzqjCB0qjCB1qjCB2qjCB3qjCB4qjCB5qjCB6qjCB7qjCB8qjCB9qjCB+qjCB-qjCBgrjCBhrjCBirjCBjrjCBkrjCBlrjC74CgmmCBhmmCBimmCBjmmCBkmmCBlmmCBmmmCBnmmCBommCBpmmCBqmmCBrmmCBsmmCBtmmCBummCBvmmCBwmmCBxmmCBymmCBzmmCB0mmCB1mmCB2mmCB3mmCB4mmCB5mmCB6mmCB7mmCB8mmCB9mmCB+mmCB-mmCBglmCBhlmCBilmCBjlmCBklmCBllmCBmlmCBnlmCBolmCBplmCBqlmCBrlmCBslmCBtlmCBulmCBvlmCBwlmCBxlmCBylmCBzlmCB0lmCB1lmCB2lmCB3lmCB4lmCB5lmCB6lmCB7lmCB8lmCB9lmCB+lmCB-lmChrVgz7CBhz7CBiz7CBjz7CBkz7CBlz7CBmz7CBnz7CBoz7CBpz7CBqz7CBrz7CBsz7CBtz7CBuz7CBvz7CBwz7CBxz7CByz7CBzz7CB0z7CB1z7CB2z7CB3z7CB4z7CB5z7CB6z7CB7z7CB8z7CB9z7CB+z7CB-z7CBgy7CBhy7CBiy7CBjy7CBky7CBly7CBmy7CBny7CBoy7CBpy7CBqy7CBry7CBsy7CBty7CBuy7CBvy7CBwy7CBxy7CByy7CBzy7CB0y7CB1y7CB2y7CB3y7CB4y7CB5y7CB6y7CB7y7CB8y7CB9y7CB+y7CB-y7ChB717CB817CB917CB+17CB-17CBg27CBh27CBi27CBj27CBk27CBl27CBm27CBn27CBo27CBp27CBq27CBr27CBs27CBt27CBu27CBv27CBw27CBx27CBy27CBz27CDg17CBh17CBi17CBj17CBk17CBl17CBm17CBn17CBo17CBp17CBq17CBr17CBs17CBt17CBu17CBv17CBw17CBx17CBy17CBz17CB017CB117CB217CB317CB417Ctxeip6DBjp6DBkp6DBlp6DBmp6DBnp6DBop6DBpp6DBqp6DBrp6DBsp6DBtp6DBup6DBvp6DBwp6DBxp6DByp6DBzp6DB0p6DB1p6DB2p6DB3p6DB4p6DB5p6DB6p6DB7p6DB8p6DB9p6DB+p6DB-p6DBgq6DBhq6DBiq6DBjq6DBgo6DBho6DBio6DBjo6DBko6DBlo6DBmo6DBno6DBoo6DBpo6DBqo6DBro6DBso6DBto6DBuo6DBvo6DBwo6DBxo6DByo6DBzo6DB0o6DB1o6DB2o6DB3o6DB4o6DB5o6DB6o6DB7o6DB8o6DB9o6DB+o6DB-o6DBgp6DBhp6D');
+        this._CASE_ORBIT = decodeOrbit('rCrDIzDYqpII-LiC8cQlHa+0HGrpI6EzClClOBmOBkOBoOBpOBnOBrOBsOBqOlByPBzPBxPyK5crCz+HCydD1dD4dB5dB6dC8dEgeBheCieDmeDpeHj-HCweD1fDxeB+9HBwfC1FE2eBxfBjeBjdD1eDmpIHycB0fEmdBgda6cBhdD4cB1cdyhBC0hBK+hBDhiBBiiBIqiBIgkHChkHKikHDjkHBkkHImkHYjjBBnkH9gGygBB0gBB+gBBhhBBlkHBihBBqhBBijBBqypB4OhzHB70H6BgzHD-GiHo8HBp8HBq8HBr8HBs8HBt8HBu8HBv8HBg8HBh8HBi8HBj8HBk8HBl8HBm8HBn8HB48HB58HB68HB78HB88HB98HB+8HB-8HBw8HBx8HBy8HBz8HB08HB18HB28HB38HBo9HBp9HBq9HBr9HBs9HBt9HBu9HBv9HBg9HBh9HBi9HBj9HBk9HBl9HBm9HBn9HE89HJz9HClaFs+HJj+HHwcQwdQ8-HJz-HqJpdErCBlG-ohBrypBBokH6lVm4+BBl4+B');
       }
       return this._CASE_ORBIT;
     }
@@ -598,11 +604,16 @@
     // to compare it to |r2|.
     // -1 is interpreted as the end-of-file mark.
     static equalsIgnoreCase(r1, r2) {
-      // Runes already match, or one of them is EOF
-      if (r1 < 0 || r2 < 0 || r1 === r2) {
+      // Runes already match
+      if (r1 === r2) {
         return true;
       }
 
+      // Safely fail if either is EOF (and they didn't explicitly match above)
+      if (r1 < 0 || r2 < 0) {
+        return false;
+      }
+
       // 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) {
@@ -855,7 +866,7 @@
   // Encoding[(Encoding['UTF_16'] = 0)] = 'UTF_16'
   // Encoding[(Encoding['UTF_8'] = 1)] = 'UTF_8'
   const createEnum = (values = [], initNum = 0) => {
-    const enumObject = {};
+    const enumObject = Object.create(null);
     for (let i = 0; i < values.length; i++) {
       const val = values[i];
       const keyVal = initNum + i;
@@ -997,6 +1008,9 @@
     hasString() {
       return false;
     }
+    hasAnyString() {
+      return false;
+    }
 
     // Helper for the exact-literal fast-path execution router
     prefixLength() {
@@ -1022,6 +1036,13 @@
       return idx !== -1 && idx <= this.end - target.length;
     }
 
+    // Executes a high-speed, single - pass search for multiple literal strings
+    // simultaneously using an Aho-Corasick automaton.
+    hasAnyString(prefilter, pos) {
+      if (!prefilter.ac8) return false;
+      return prefilter.ac8.searchUTF8(this.bytes, this.start + pos, this.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
@@ -1040,17 +1061,23 @@
         return c << 3 | 1;
       } else if (c >= 0xc2 && c <= 0xdf && pos + 1 < this.end) {
         const c1 = this.bytes[pos + 1] & 0xff;
+        if ((c1 & 0xc0) !== 0x80) return c << 3 | 1;
         const rune = (c & 0x1f) << 6 | c1 & 0x3f;
         return rune << 3 | 2;
       } else if (c >= 0xe0 && c <= 0xef && pos + 2 < this.end) {
         const c1 = this.bytes[pos + 1] & 0xff;
+        if ((c1 & 0xc0) !== 0x80) return c << 3 | 1;
         const c2 = this.bytes[pos + 2] & 0xff;
+        if ((c2 & 0xc0) !== 0x80) return c << 3 | 1;
         const rune = (c & 0x0f) << 12 | (c1 & 0x3f) << 6 | c2 & 0x3f;
         return rune << 3 | 3;
       } else if (c >= 0xf0 && c <= 0xf4 && pos + 3 < this.end) {
         const c1 = this.bytes[pos + 1] & 0xff;
+        if ((c1 & 0xc0) !== 0x80) return c << 3 | 1;
         const c2 = this.bytes[pos + 2] & 0xff;
+        if ((c2 & 0xc0) !== 0x80) return c << 3 | 1;
         const c3 = this.bytes[pos + 3] & 0xff;
+        if ((c3 & 0xc0) !== 0x80) return c << 3 | 1;
         const rune = (c & 0x07) << 18 | (c1 & 0x3f) << 12 | (c2 & 0x3f) << 6 | c3 & 0x3f;
         return rune << 3 | 4;
       } else {
@@ -1129,6 +1156,13 @@
       return idx !== -1 && idx <= this.end - prefilter.str.length;
     }
 
+    // Executes a high-speed, single - pass search for multiple literal strings
+    // simultaneously using an Aho-Corasick automaton.
+    hasAnyString(prefilter, pos) {
+      if (!prefilter.ac16) return false;
+      return prefilter.ac16.searchUTF16(this.charSequence, this.start + pos, this.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
@@ -1574,7 +1608,15 @@
       if (this.hasMatch) {
         start = this.groups[1];
         if (this.groups[0] === this.groups[1]) {
-          start++;
+          // Safely calculate structural encoding width to avoid sequence corruption
+          const machineInput = this.matcherInput.isUTF16Encoding() ? MachineInput.fromUTF16(this.matcherInput.asCharSequence(), 0, this.matcherInputLength) : MachineInput.fromUTF8(this.matcherInput.asBytes(), 0, this.matcherInputLength);
+          const r = machineInput.step(start);
+          if (r < 0) {
+            // EOF
+            start++; // Advance past length to force loop exit
+          } else {
+            start += r & 7; // Advance by safely decoded width
+          }
         }
       }
       return this.genMatch(start, RE2Flags.UNANCHORED);
@@ -1713,6 +1755,8 @@
             const groupName = replacement.substring(i + 1, j);
             res += this.group(groupName);
             last = j + 1;
+            i = j;
+            continue;
           }
         }
       }
@@ -1792,6 +1836,7 @@
             if (j === replacement.length || replacement.codePointAt(j) !== Codepoint.CODES.get('>')) {
               res += replacement.substring(i - 1, j + 1);
               last = j + 1;
+              i = j;
               continue;
             }
             const groupName = replacement.substring(i + 1, j);
@@ -1801,6 +1846,8 @@
               res += `$<${groupName}>`;
             }
             last = j + 1;
+            i = j;
+            continue;
           }
         }
       }
@@ -1925,6 +1972,8 @@
         return r === r0;
       }
       const len = this.runes.length;
+      if (len === 0) return false;
+
       // If the array is exactly 2, 4, 6, or 8 items, DO NOT fall through to binary search
       if (len === 2 || len === 4 || len === 6 || len === 8) {
         for (let j = 0; j < len; j += 2) {
@@ -1938,22 +1987,19 @@
         return false; // Stop here
       }
 
-      // Otherwise binary search.
-      let lo = 0;
-      let hi = this.runes.length / 2 | 0;
-      while (lo < hi) {
-        const m = lo + hi >> 1; // native cpu instruction for "lo + (((hi - lo) / 2) | 0)"
-        const c = this.runes[2 * m];
-        if (c <= r) {
-          if (r <= this.runes[2 * m + 1]) {
-            return true;
-          }
-          lo = m + 1;
-        } else {
-          hi = m;
-        }
+      // Branchless Binary Search (Lower Bound)
+      // Compiles to optimal conditional move (cmov) machine code, preventing
+      // branch mispredictions on large, chaotic Unicode arrays
+      let base = 0;
+      let n = len >> 1;
+      while (n > 1) {
+        const half = n >> 1;
+        base += this.runes[base + half << 1] <= r ? half : 0;
+        n -= half;
       }
-      return false;
+      base += this.runes[base << 1] <= r ? 1 : 0;
+      const m = base - 1;
+      return m >= 0 && r <= this.runes[m << 1 | 1];
     }
 
     // matchRunePos checks whether the instruction matches (and consumes) r.
@@ -1968,6 +2014,7 @@
         return r === r0 ? 0 : -1;
       }
       const len = this.runes.length;
+      if (len === 0) return -1;
       if (len === 2 || len === 4 || len === 6 || len === 8) {
         for (let j = 0; j < len; j += 2) {
           if (r < this.runes[j]) return -1;
@@ -1975,19 +2022,18 @@
         }
         return -1;
       }
-      let lo = 0;
-      let hi = Math.floor(len / 2);
-      while (lo < hi) {
-        const m = lo + hi >> 1;
-        const c = this.runes[2 * m];
-        if (c <= r) {
-          if (r <= this.runes[2 * m + 1]) return m;
-          lo = m + 1;
-        } else {
-          hi = m;
-        }
+
+      // Branchless Binary Search (Lower Bound)
+      let base = 0;
+      let n = len >> 1;
+      while (n > 1) {
+        const half = n >> 1;
+        base += this.runes[base + half << 1] <= r ? half : 0;
+        n -= half;
       }
-      return -1;
+      base += this.runes[base << 1] <= r ? 1 : 0;
+      const m = base - 1;
+      return m >= 0 && r <= this.runes[m << 1 | 1] ? m : -1;
     }
     /**
      *
@@ -2086,6 +2132,7 @@
   //
   // Called by RE2.doExecute.
   class Machine {
+    static THREADS_CHUNK_SIZE = 128;
     static fromRE2(re2) {
       const m = new Machine();
       m.prog = re2.prog;
@@ -2126,15 +2173,15 @@
     resetCap() {
       for (let i = 0; i < this.poolSize; i++) {
         const t = this.pool[i];
-        t.cap.fill(0);
+        t.cap.fill(-1);
       }
     }
     initNewCap(ncap) {
       for (let i = 0; i < this.poolSize; i++) {
         const t = this.pool[i];
-        t.cap = new Int32Array(ncap);
+        t.cap = new Int32Array(ncap).fill(-1);
       }
-      this.matchcap = new Int32Array(ncap);
+      this.matchcap = new Int32Array(ncap).fill(-1);
     }
     submatches() {
       if (this.ncap === 0) {
@@ -2147,14 +2194,21 @@
     // alloc() allocates a new thread with the given instruction.
     // It uses the free pool if possible.
     alloc(inst) {
-      let t;
-      if (this.poolSize > 0) {
-        this.poolSize--;
-        t = this.pool[this.poolSize];
-      } else {
-        t = new Thread();
-        t.cap = new Int32Array(this.matchcap.length);
+      if (this.poolSize === 0) {
+        const capLen = this.matchcap.length;
+
+        // Bulk allocate threads in a tight loop so the V8 engine
+        // places them adjacently in the young generation heap
+        for (let i = 0; i < Machine.THREADS_CHUNK_SIZE; i++) {
+          const t = new Thread();
+          t.cap = new Int32Array(capLen);
+          this.pool[this.poolSize++] = t;
+        }
       }
+
+      // Pop a thread from the top of the pool stack
+      this.poolSize--;
+      const t = this.pool[this.poolSize];
       t.inst = inst;
       return t;
     }
@@ -2207,6 +2261,9 @@
           if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && pos !== 0) {
             break;
           }
+          if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+            break;
+          }
           if (this.matched) {
             break;
           }
@@ -2284,6 +2341,9 @@
       while (true) {
         if (runq.isEmpty()) {
           if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && pos !== 0) break;
+          if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+            break;
+          }
         }
         if (pos === 0 || anchor === RE2Flags.UNANCHORED) {
           // Spawn Lookbehind threads BEFORE the main pattern
@@ -2399,78 +2459,83 @@
       runq.clear();
     }
     add(q, pc, pos, cap, cond, t) {
-      if (pc === 0) {
-        return t;
-      }
-      if (q.contains(pc)) {
-        return t;
-      }
-      const d = q.add(pc);
-      const inst = this.prog.inst[pc];
-      switch (inst.op) {
-        case Inst.FAIL:
-          break;
-        case Inst.ALT:
-        case Inst.ALT_MATCH:
-          t = this.add(q, inst.out, pos, cap, cond, t);
-          t = this.add(q, inst.arg, pos, cap, cond, t);
-          break;
-        case Inst.EMPTY_WIDTH:
-          if ((inst.arg & ~cond) === 0) {
-            t = this.add(q, inst.out, pos, cap, cond, t);
-          }
-          break;
-        case Inst.NOP:
-          t = this.add(q, inst.out, pos, cap, cond, t);
-          break;
-        case Inst.CAPTURE:
-          if (inst.arg < this.ncap) {
-            const opos = cap[inst.arg];
-            cap[inst.arg] = pos;
-            this.add(q, inst.out, pos, cap, cond, null);
-            cap[inst.arg] = opos;
-          } else {
+      while (true) {
+        if (pc === 0) {
+          return t;
+        }
+        if (q.contains(pc)) {
+          return t;
+        }
+        const d = q.add(pc);
+        const inst = this.prog.inst[pc];
+        switch (inst.op) {
+          case Inst.FAIL:
+            return t;
+          case Inst.ALT:
+          case Inst.ALT_MATCH:
             t = this.add(q, inst.out, pos, cap, cond, t);
-          }
-          break;
-        case Inst.LB_WRITE:
-          this.lbTable[Math.abs(inst.lb)] = pos;
-          t = this.add(q, inst.out, pos, cap, cond, t);
-          break;
-        case Inst.LB_CHECK:
-          if (inst.lb > 0) {
-            // Positive Lookbehind
-            if (this.lbTable[inst.lb] === pos) {
-              t = this.add(q, inst.out, pos, cap, cond, t);
+            pc = inst.arg; // Flattened tail recursion
+            continue;
+          case Inst.EMPTY_WIDTH:
+            if ((inst.arg & ~cond) === 0) {
+              pc = inst.out; // Flattened tail recursion
+              continue;
             }
-          } else if (this.lbTable[-inst.lb] !== pos) {
-            // Negative Lookbehind
-            t = this.add(q, inst.out, pos, cap, cond, t);
-          }
-          break;
-        case Inst.MATCH:
-        case Inst.RUNE:
-        case Inst.RUNE1:
-        case Inst.RUNE_ANY:
-        case Inst.RUNE_ANY_NOT_NL:
-          if (t === null) {
-            t = this.alloc(inst);
-          } else {
-            t.inst = inst;
-          }
-          if (this.ncap > 0 && t.cap !== cap) {
-            // Direct assignment utilizing Typed Array performance
-            for (let c = 0; c < this.ncap; c++) {
-              t.cap[c] = cap[c];
+            return t;
+          case Inst.NOP:
+            pc = inst.out; // Flattened tail recursion
+            continue;
+          case Inst.CAPTURE:
+            if (inst.arg < this.ncap) {
+              const opos = cap[inst.arg];
+              cap[inst.arg] = pos;
+              this.add(q, inst.out, pos, cap, cond, null);
+              cap[inst.arg] = opos;
+              return t;
+            } else {
+              pc = inst.out; // Flattened tail recursion
+              continue;
             }
-          }
-          q.denseThreads[d] = t;
-          t = null;
-          break;
-        default:
-          throw new Error('unhandled');
+          case Inst.LB_WRITE:
+            this.lbTable[Math.abs(inst.lb)] = pos;
+            pc = inst.out;
+            continue;
+          case Inst.LB_CHECK:
+            if (inst.lb > 0) {
+              // Positive Lookbehind
+              if (this.lbTable[inst.lb] === pos) {
+                pc = inst.out; // Flattened tail recursion
+                continue;
+              }
+            } else if (this.lbTable[-inst.lb] !== pos) {
+              // Negative Lookbehind
+              pc = inst.out; // Flattened tail recursion
+              continue;
+            }
+            return t;
+          case Inst.MATCH:
+          case Inst.RUNE:
+          case Inst.RUNE1:
+          case Inst.RUNE_ANY:
+          case Inst.RUNE_ANY_NOT_NL:
+            if (t === null) {
+              t = this.alloc(inst);
+            } else {
+              t.inst = inst;
+            }
+            if (this.ncap > 0 && t.cap !== cap) {
+              // Direct assignment utilizing Typed Array performance
+              for (let c = 0; c < this.ncap; c++) {
+                t.cap[c] = cap[c];
+              }
+            }
+            q.denseThreads[d] = t;
+            t = null;
+            return t;
+          default:
+            throw new Error('unhandled');
+        }
       }
-      return t;
     }
   }
 
@@ -2498,8 +2563,15 @@
       this.nfaStates = nfaStates; // Int32Array of Instruction PCs
       this.isMatch = isMatch; // Boolean
       this.matchIDs = matchIDs; // Array of integers indicating which Set patterns matched
-      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
+
+      // Latin-1 (Unicode.MAX_LATIN1 + 1) flat arrays for blisteringly fast O(1) lookups
+      // completely covering standard English, European languages, and 1-byte encodings.
+      this.nextLatin1 = new Array(Unicode.MAX_LATIN1 + 1).fill(null); // Flat array for blisteringly fast ASCII lookups
+      this.nextLatin1Anchored = new Array(Unicode.MAX_LATIN1 + 1).fill(null); // Flat array for blisteringly fast ASCII lookups
+      // 2 arrays used as hash map for V8 optimization (N is small number, so O(n) faster than Map O(1))
+      this.transKeys = [];
+      this.transVals = [];
+      this.lastSeen = 0; // Track when this state was last used for LRU eviction
     }
   }
   class DFA {
@@ -2512,6 +2584,7 @@
       this.stateLimit = 10000; // Prevent memory explosion (ReDoS protection)
       this.cacheClears = 0; // Track thrashing
       this.failed = false; // mark if DFA cannot work with provided prog
+      this.clock = 0; // Global clock for LRU eviction
     }
 
     // Follows epsilon (empty) transitions to find all reachable states without consuming a char
@@ -2571,6 +2644,7 @@
         for (let i = 0; i < bucket.length; i++) {
           const state = bucket[i];
           if (arraysEqual(state.nfaStates, sortedPCs)) {
+            state.lastSeen = ++this.clock;
             return state;
           }
         }
@@ -2583,40 +2657,99 @@
       if (this.failed) return null;
 
       // Safety: prevent memory exhaustion from state explosion
-      // We flush the cache and return null, which seamlessly routes execution to the NFA
+      // We prune the cache to keep the newest 50%
       if (this.stateCount >= this.stateLimit) {
-        this.stateCache.clear();
-        this.stateCount = 0;
-        this.startState = null;
         this.cacheClears++;
 
         // If this regex causes continuous cache thrashing, permanently fall back to NFA
         // to avoid spending CPU cycles constantly rebuilding the DFA tree.
         if (this.cacheClears >= DFA.MAX_CACHE_CLEARS) {
           this.failed = true;
+          this.stateCache.clear();
+          this.stateCount = 0;
+          this.startState = null;
+          return null;
+        }
+        this.evictCache();
+
+        // After eviction, the bucket reference might be stale or empty.
+        // We must re-fetch or re-create the bucket.
+        bucket = this.stateCache.get(hash);
+        if (!bucket) {
+          bucket = [];
+          this.stateCache.set(hash, bucket);
         }
-        return null;
       }
 
       // State not found, create it and add to bucket
       const state = new DFAState(sortedPCs, closureResult.isMatch, closureResult.matchIDs);
+      state.lastSeen = ++this.clock;
       bucket.push(state);
       this.stateCount++;
       return state;
     }
+    evictCache() {
+      const allStates = [];
+      for (const bucket of this.stateCache.values()) {
+        for (let i = 0; i < bucket.length; i++) {
+          allStates.push(bucket[i]);
+        }
+      }
+
+      // Sort ascending by lastSeen (oldest first)
+      allStates.sort((a, b) => a.lastSeen - b.lastSeen);
+
+      // Keep the newest 50%
+      const keepCount = Math.max(1, Math.floor(this.stateLimit / 2));
+      const startIndex = allStates.length - keepCount;
+      const survivorsArray = allStates.slice(startIndex);
+      const survivors = new Set(survivorsArray);
+      this.stateCache.clear();
+      this.stateCount = 0;
+      for (let i = 0; i < survivorsArray.length; i++) {
+        const state = survivorsArray[i];
+
+        // Sever ties to all states to prevent memory leaks and dangling pointers
+        state.nextLatin1.fill(null);
+        state.nextLatin1Anchored.fill(null);
+        // zero-allocation cleanup
+        state.transKeys.length = 0;
+        state.transVals.length = 0;
+        const hash = hashPCs(state.nfaStates);
+        let bucket = this.stateCache.get(hash);
+        if (!bucket) {
+          bucket = [];
+          this.stateCache.set(hash, bucket);
+        }
+        bucket.push(state);
+        this.stateCount++;
+      }
+
+      // Start state must either be preserved or nullified so it gets re-created
+      if (this.startState && !survivors.has(this.startState)) {
+        this.startState = null;
+      }
+    }
 
     // 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;
+      // OPTIMIZATION: Latin-1 Array Fast-Path
+      if (charCode <= Unicode.MAX_LATIN1) {
+        if (anchor === RE2Flags.UNANCHORED) {
+          const next = state.nextLatin1[charCode];
+          if (next !== null) return next;
+        } else {
+          const next = state.nextLatin1Anchored[charCode];
+          if (next !== null) return next;
         }
       } else {
+        // Dense Array Linear Search fallback for Runes > 255
         const key = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1);
-        if (state.nextMap.has(key)) {
-          return state.nextMap.get(key);
+        // get [key] -> nextState
+        const keys = state.transKeys;
+        const len = keys.length;
+        for (let i = 0; i < len; i++) {
+          if (keys[i] === key) return state.transVals[i];
         }
       }
       const nextPCs = [];
@@ -2633,11 +2766,17 @@
       const nextState = this.getState(nextPCs);
 
       // Cache the result
-      if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) {
-        state.nextAscii[charCode] = nextState;
+      if (charCode <= Unicode.MAX_LATIN1) {
+        if (anchor === RE2Flags.UNANCHORED) {
+          state.nextLatin1[charCode] = nextState;
+        } else {
+          state.nextLatin1Anchored[charCode] = nextState;
+        }
       } else {
         const key = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1);
-        state.nextMap.set(key, nextState);
+        // store key -> nextState
+        state.transKeys.push(key);
+        state.transVals.push(nextState);
       }
       return nextState;
     }
@@ -2670,10 +2809,11 @@
         if (width === 0) {
           break;
         }
-        currentState = anchor === RE2Flags.UNANCHORED && rune <= Unicode.MAX_ASCII && currentState.nextAscii[rune] || this.step(currentState, rune, anchor);
+        currentState = anchor === RE2Flags.UNANCHORED && rune <= Unicode.MAX_LATIN1 && currentState.nextLatin1[rune] || this.step(currentState, rune, anchor);
 
         // If we hit an unrecoverable DFA error or bailout, signal fallback
         if (currentState === null) return null;
+        currentState.lastSeen = ++this.clock;
         if (currentState.isMatch) {
           if (anchor === RE2Flags.ANCHOR_BOTH) {
             if (i + width === endPos) return true;
@@ -2721,9 +2861,10 @@
         const rune = r >> 3;
         const width = r & 7;
         if (width === 0) break;
-        currentState = anchor === RE2Flags.UNANCHORED && rune <= Unicode.MAX_ASCII && currentState.nextAscii[rune] || this.step(currentState, rune, anchor);
+        currentState = anchor === RE2Flags.UNANCHORED && rune <= Unicode.MAX_LATIN1 && currentState.nextLatin1[rune] || this.step(currentState, rune, anchor);
         if (currentState === null) return null; // Bailout to NFA
 
+        currentState.lastSeen = ++this.clock;
         i += width;
         checkMatch(currentState, i);
         if (currentState.nfaStates.length === 0) {
@@ -2761,7 +2902,7 @@
       // Bitwise shift (>>> 5) instead of Math.floor( / 32)
       const visitedSize = prog.numInst() * (end + 1) + VISITED_BITS - 1 >>> 5;
       if (this.visited.length < visitedSize) {
-        this.visited = new Uint32Array(Math.floor(MAX_BACKTRACK_VECTOR / VISITED_BITS));
+        this.visited = new Uint32Array(visitedSize);
       } else {
         this.visited.fill(0, 0, visitedSize);
       }
@@ -2847,11 +2988,12 @@
                 const outInst = re2.prog.getInst(inst.out);
                 if (Inst.isRuneOp(outInst.op)) {
                   this.push(re2, inst.arg, currentPos, false);
-                  currentPc = inst.out;
+                  currentPc = inst.arg;
+                  currentPos = this.end;
                   continue;
                 }
                 this.push(re2, inst.out, this.end, false);
-                currentPc = inst.arg;
+                currentPc = inst.out;
                 continue;
               }
             case Inst.RUNE:
@@ -2932,6 +3074,11 @@
                 if (currentPos === this.end) return true;
                 break;
               }
+            case Inst.LB_WRITE:
+            case Inst.LB_CHECK:
+              {
+                throw new RE2JSInternalException('Backtracker cannot evaluate Lookbehind instructions');
+              }
             default:
               {
                 throw new RE2JSInternalException('bad inst');
@@ -3200,7 +3347,9 @@
               }
               runes.sort((a, b) => a - b);
             } else {
-              runes.push(...inst.runes);
+              for (let j = 0; j < inst.runes.length; j++) {
+                runes.push(inst.runes[j]);
+              }
             }
             onePassRunes[pc] = runes;
             inst.next = new Uint32Array(Math.floor(runes.length / 2) + 1).fill(inst.out);
@@ -3368,6 +3517,10 @@
         switch (inst.op) {
           case Inst.MATCH:
             {
+              // Verify ANCHOR_BOTH constraint before accepting the match
+              if (anchor === RE2Flags.ANCHOR_BOTH && pos !== input.endPos()) {
+                return null;
+              }
               matched = true;
               if (matchcap.length > 0) {
                 matchcap[0] = 0;
@@ -3798,6 +3951,88 @@
     }
   }
 
+  // High-speed, single-pass Aho-Corasick string matcher optimized for V8.
+  // Builds a trie with failure links to search for multiple prefixes simultaneously.
+  class AhoCorasick {
+    constructor(wordArrays) {
+      this.next = [Object.create(null)];
+      this.fail = [0];
+      this.match = [false];
+
+      // Build Trie
+      for (const word of wordArrays) {
+        let node = 0;
+        for (let i = 0; i < word.length; i++) {
+          const val = word[i];
+          if (!(val in this.next[node])) {
+            this.next.push(Object.create(null));
+            this.fail.push(0);
+            this.match.push(false);
+            this.next[node][val] = this.next.length - 1;
+          }
+          node = this.next[node][val];
+        }
+        this.match[node] = true;
+      }
+
+      // Build Failure Links (BFS)
+      const queue = [];
+      for (const val in this.next[0]) {
+        if (Object.prototype.hasOwnProperty.call(this.next[0], val)) {
+          const child = this.next[0][val];
+          this.fail[child] = 0;
+          queue.push(child);
+        }
+      }
+      while (queue.length > 0) {
+        const curr = queue.shift();
+        for (const val in this.next[curr]) {
+          if (Object.prototype.hasOwnProperty.call(this.next[curr], val)) {
+            const child = this.next[curr][val];
+            let failNode = this.fail[curr];
+            while (failNode !== 0 && !(val in this.next[failNode])) {
+              failNode = this.fail[failNode];
+            }
+            if (val in this.next[failNode]) {
+              this.fail[child] = this.next[failNode][val];
+            } else {
+              this.fail[child] = 0;
+            }
+            this.match[child] = this.match[child] || this.match[this.fail[child]];
+            queue.push(child);
+          }
+        }
+      }
+    }
+    searchUTF16(charSeq, start, end) {
+      let node = 0;
+      for (let i = start; i < end; i++) {
+        const val = charSeq.charCodeAt(i);
+        while (node !== 0 && !(val in this.next[node])) {
+          node = this.fail[node];
+        }
+        if (val in this.next[node]) {
+          node = this.next[node][val];
+        }
+        if (this.match[node]) return true;
+      }
+      return false;
+    }
+    searchUTF8(bytes, start, end) {
+      let node = 0;
+      for (let i = start; i < end; i++) {
+        const val = bytes[i];
+        while (node !== 0 && !(val in this.next[node])) {
+          node = this.fail[node];
+        }
+        if (val in this.next[node]) {
+          node = this.next[node][val];
+        }
+        if (this.match[node]) return true;
+      }
+      return false;
+    }
+  }
   class Prefilter {
     static Type = {
       NONE: 0,
@@ -3810,6 +4045,8 @@
       this.subs = [];
       this.str = '';
       this.bytes = null;
+      this.ac16 = null;
+      this.ac8 = null;
     }
     eval(input, pos) {
       switch (this.type) {
@@ -3823,6 +4060,10 @@
           }
           return true;
         case Prefilter.Type.OR:
+          // Exploit Aho-Corasick if it was successfully built
+          if (this.ac16 && this.ac8) {
+            return input.hasAnyString(this, pos);
+          }
           for (let i = 0; i < this.subs.length; i++) {
             if (this.subs[i].eval(input, pos)) return true;
           }
@@ -3913,7 +4154,9 @@
           const s = PrefilterTree.simplify(sub);
           if (s.type !== Prefilter.Type.NONE) {
             if (s.type === Prefilter.Type.AND) {
-              newSubs.push(...s.subs);
+              for (let j = 0; j < s.subs.length; j++) {
+                newSubs.push(s.subs[j]);
+              }
             } else {
               newSubs.push(s);
             }
@@ -3933,7 +4176,9 @@
             return new Prefilter(Prefilter.Type.NONE);
           }
           if (s.type === Prefilter.Type.OR) {
-            newSubs.push(...s.subs);
+            for (let j = 0; j < s.subs.length; j++) {
+              newSubs.push(s.subs[j]);
+            }
           } else {
             newSubs.push(s);
           }
@@ -3955,6 +4200,27 @@
           }
         }
         pf.subs = uniqueSubs;
+
+        // Build an Aho-Corasick automaton if all children are exact matches
+        let allExact = true;
+        for (const sub of uniqueSubs) {
+          if (sub.type !== Prefilter.Type.EXACT) {
+            allExact = false;
+            break;
+          }
+        }
+        if (allExact && uniqueSubs.length > 1) {
+          const words16 = uniqueSubs.map(s => {
+            const arr = [];
+            for (let i = 0; i < s.str.length; i++) {
+              arr.push(s.str.charCodeAt(i));
+            }
+            return arr;
+          });
+          pf.ac16 = new AhoCorasick(words16);
+          const words8 = uniqueSubs.map(s => s.bytes);
+          pf.ac8 = new AhoCorasick(words8);
+        }
         return pf;
       }
       return pf;
@@ -4481,7 +4747,9 @@
                 // Flatten nested concatenations
                 if (nsub.op === Regexp.Op.CONCAT) {
                   changed = true;
-                  newSubs.push(...nsub.subs);
+                  for (let j = 0; j < nsub.subs.length; j++) {
+                    newSubs.push(nsub.subs[j]);
+                  }
                   continue;
                 }
               } else if (re.op === Regexp.Op.ALTERNATE) {
@@ -4493,7 +4761,9 @@
                 // Flatten nested alternations
                 if (nsub.op === Regexp.Op.ALTERNATE) {
                   changed = true;
-                  newSubs.push(...nsub.subs);
+                  for (let j = 0; j < nsub.subs.length; j++) {
+                    newSubs.push(nsub.subs[j]);
+                  }
                   continue;
                 }
               }
@@ -5503,7 +5773,10 @@
       return t.pop();
     }
     static concatRunes(x, y) {
-      return [...x, ...y];
+      for (let i = 0; i < y.length; i++) {
+        x.push(y[i]);
+      }
+      return x;
     }
     constructor(wholeRegexp, flags = 0) {
       this.wholeRegexp = wholeRegexp;
@@ -5539,8 +5812,8 @@
       return re;
     }
     reuse(re) {
-      if (this.height !== null && Object.prototype.hasOwnProperty.call(this.height, re)) {
-        delete this.height[re];
+      if (this.height !== null && this.height.has(re)) {
+        this.height.delete(re);
       }
       if (re.subs !== null && re.subs.length > 0) {
         re.subs[0] = this.free;
@@ -5572,20 +5845,20 @@
           if (n <= 0) {
             n = 1;
           }
-          if (n > Parser.MAX_SIZE / this.repeats) {
+          if (n > Math.floor(Parser.MAX_SIZE / this.repeats)) {
             this.repeats = Parser.MAX_SIZE;
           } else {
             this.repeats *= n;
           }
         }
-        if (this.numRegexp < Parser.MAX_SIZE / this.repeats) {
+        if (this.numRegexp < Math.floor(Parser.MAX_SIZE / this.repeats)) {
           return;
         }
 
         // We need to start tracking size.
         // Make the map and belatedly populate it
         // with info about everything we've constructed so far.
-        this.size = Object.create(null);
+        this.size = new Map();
         for (let reEx of this.stack) {
           this.checkSize(reEx);
         }
@@ -5596,8 +5869,8 @@
     }
     calcSize(re, force = false) {
       if (!force && this.size !== null) {
-        if (Object.prototype.hasOwnProperty.call(this.size, re)) {
-          return this.size[re];
+        if (this.size.has(re)) {
+          return this.size.get(re);
         }
       }
       let size = 0;
@@ -5657,9 +5930,9 @@
       }
       size = Math.max(1, size);
       if (this.size === null) {
-        this.size = Object.create(null);
+        this.size = new Map();
       }
-      this.size[re] = size;
+      this.size.set(re, size);
       return size;
     }
     checkHeight(re) {
@@ -5667,7 +5940,7 @@
         return;
       }
       if (this.height === null) {
-        this.height = Object.create(null);
+        this.height = new Map();
         for (let reEx of this.stack) {
           this.checkHeight(reEx);
         }
@@ -5678,8 +5951,8 @@
     }
     calcHeight(re, force = false) {
       if (!force && this.height !== null) {
-        if (Object.prototype.hasOwnProperty.call(this.height, re)) {
-          return this.height[re];
+        if (this.height.has(re)) {
+          return this.height.get(re);
         }
       }
       let h = 1;
@@ -5690,9 +5963,9 @@
         }
       }
       if (this.height === null) {
-        this.height = Object.create(null);
+        this.height = new Map();
       }
-      this.height[re] = h;
+      this.height.set(re, h);
       return h;
     }
 
@@ -7814,7 +8087,7 @@
           changed = true;
           continue;
         } else if (ch === '(' && i + 2 < size && data[i + 1] === '?' && data[i + 2] === '<') {
-          if (i + 3 >= size || data[i + 3] !== '=' && data[i + 3] !== '!') {
+          if (i + 3 < size && !'=!>)'.includes(data[i + 3])) {
             result += '(?P<';
             i += 3;
             changed = true;