re2js 2.2.0 → 2.2.1

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.2.0
+ * @version v2.2.1
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -78,6 +78,8 @@ const PublicFlags = {
 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
@@ -101,11 +103,13 @@ class Codepoint {
   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);
@@ -116,11 +120,13 @@ class Codepoint {
   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);
@@ -222,7 +228,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+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;
   }
@@ -594,11 +600,16 @@ class Unicode {
   // 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) {
@@ -851,7 +862,7 @@ class Utils {
 // 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;
@@ -993,6 +1004,9 @@ class MachineInputBase {
   hasString() {
     return false;
   }
+  hasAnyString() {
+    return false;
+  }
 
   // Helper for the exact-literal fast-path execution router
   prefixLength() {
@@ -1018,6 +1032,13 @@ class MachineUTF8Input extends MachineInputBase {
     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
@@ -1036,17 +1057,23 @@ class MachineUTF8Input extends MachineInputBase {
       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 {
@@ -1125,6 +1152,13 @@ class MachineUTF16Input extends MachineInputBase {
     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
@@ -1570,7 +1604,15 @@ class Matcher {
     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);
@@ -1709,6 +1751,8 @@ class Matcher {
           const groupName = replacement.substring(i + 1, j);
           res += this.group(groupName);
           last = j + 1;
+          i = j;
+          continue;
         }
       }
     }
@@ -1788,6 +1832,7 @@ class Matcher {
           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);
@@ -1797,6 +1842,8 @@ class Matcher {
             res += `$<${groupName}>`;
           }
           last = j + 1;
+          i = j;
+          continue;
         }
       }
     }
@@ -1921,6 +1968,8 @@ class Inst {
       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) {
@@ -1934,22 +1983,19 @@ class Inst {
       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.
@@ -1964,6 +2010,7 @@ class Inst {
       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;
@@ -1971,19 +2018,18 @@ class Inst {
       }
       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;
   }
   /**
    *
@@ -2082,6 +2128,7 @@ class Queue {
 //
 // Called by RE2.doExecute.
 class Machine {
+  static THREADS_CHUNK_SIZE = 128;
   static fromRE2(re2) {
     const m = new Machine();
     m.prog = re2.prog;
@@ -2122,15 +2169,15 @@ class Machine {
   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) {
@@ -2143,14 +2190,21 @@ class Machine {
   // 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;
   }
@@ -2203,6 +2257,9 @@ class Machine {
         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;
         }
@@ -2280,6 +2337,9 @@ class Machine {
     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
@@ -2395,78 +2455,83 @@ class Machine {
     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;
   }
 }
 
@@ -2494,8 +2559,15 @@ class DFAState {
     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 {
@@ -2508,6 +2580,7 @@ class DFA {
     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
@@ -2567,6 +2640,7 @@ class DFA {
       for (let i = 0; i < bucket.length; i++) {
         const state = bucket[i];
         if (arraysEqual(state.nfaStates, sortedPCs)) {
+          state.lastSeen = ++this.clock;
           return state;
         }
       }
@@ -2579,40 +2653,99 @@ class DFA {
     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 = [];
@@ -2629,11 +2762,17 @@ class DFA {
     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;
   }
@@ -2666,10 +2805,11 @@ class DFA {
       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;
@@ -2717,9 +2857,10 @@ class DFA {
       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) {
@@ -2757,7 +2898,7 @@ class BitState {
     // 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);
     }
@@ -2843,11 +2984,12 @@ class BitState {
               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:
@@ -2928,6 +3070,11 @@ class BitState {
               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');
@@ -3364,6 +3511,10 @@ class OnePass {
       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;
@@ -3794,6 +3945,88 @@ class Regexp {
   }
 }
 
+// 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,
@@ -3806,6 +4039,8 @@ class Prefilter {
     this.subs = [];
     this.str = '';
     this.bytes = null;
+    this.ac16 = null;
+    this.ac8 = null;
   }
   eval(input, pos) {
     switch (this.type) {
@@ -3819,6 +4054,10 @@ class Prefilter {
         }
         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;
         }
@@ -3909,7 +4148,9 @@ class PrefilterTree {
         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);
           }
@@ -3951,6 +4192,27 @@ class PrefilterTree {
         }
       }
       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;
@@ -4477,7 +4739,9 @@ class Simplify {
               // 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) {
@@ -4489,7 +4753,9 @@ class Simplify {
               // 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;
               }
             }
@@ -5499,7 +5765,10 @@ class Parser {
     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;
@@ -5535,8 +5804,8 @@ class Parser {
     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;
@@ -5568,20 +5837,20 @@ class Parser {
         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);
       }
@@ -5592,8 +5861,8 @@ class Parser {
   }
   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;
@@ -5653,9 +5922,9 @@ class Parser {
     }
     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) {
@@ -5663,7 +5932,7 @@ class Parser {
       return;
     }
     if (this.height === null) {
-      this.height = Object.create(null);
+      this.height = new Map();
       for (let reEx of this.stack) {
         this.checkHeight(reEx);
       }
@@ -5674,8 +5943,8 @@ class Parser {
   }
   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;
@@ -5686,9 +5955,9 @@ class Parser {
       }
     }
     if (this.height === null) {
-      this.height = Object.create(null);
+      this.height = new Map();
     }
-    this.height[re] = h;
+    this.height.set(re, h);
     return h;
   }
 
@@ -7810,7 +8079,7 @@ class TranslateRegExpString {
         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;