@heroiclands/package-build 25.5.5 → 25.6.0

package/vendor/markdownlint.mjs

@@ -876,7 +876,7 @@
  *   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  *   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
- * re2js@2.8.6 (MIT)
+ * re2js@2.8.7 (MIT)
  *
  *   MIT License
  *
@@ -2148,6 +2148,10 @@ var UnicodeTables = class {
 };
 var Unicode = class Unicode2 {
   static MAX_RUNE = 1114111;
+  static RUNE_ERROR = 65533;
+  static isUnsearchable(r) {
+    return r === Unicode2.RUNE_ERROR || r >= Unicode2.MIN_HIGH_SURROGATE && r <= Unicode2.MAX_LOW_SURROGATE;
+  }
   static MAX_ASCII = 127;
   static MAX_LATIN1 = 255;
   static MAX_BMP = 65535;
@@ -2234,7 +2238,7 @@ var Utils = class Utils2 {
     return [];
   }
   static isByteArray(input) {
-    return Array.isArray(input) || input instanceof Uint8Array;
+    return Array.isArray(input) || Object.prototype.toString.call(input) === "[object Uint8Array]";
   }
   static isalnum(c) {
     return Codepoint.CODES.get("0") <= c && c <= Codepoint.CODES.get("9") || Codepoint.CODES.get("a") <= c && c <= Codepoint.CODES.get("z") || Codepoint.CODES.get("A") <= c && c <= Codepoint.CODES.get("Z");
@@ -2293,7 +2297,7 @@ var Utils = class Utils2 {
       runes.push(cp);
       i += cp > Unicode.MAX_BMP ? 2 : 1;
     }
-    return runes;
+    return new Int32Array(runes);
   }
   static runeToString(r) {
     return String.fromCodePoint(r);
@@ -2413,7 +2417,7 @@ var MatcherInputBase = class MatcherInputBase2 {
   asCharSequence() {
     throw Error("not implemented");
   }
-  /** @returns {Uint8Array|number[]} */
+  /** @returns {Uint8Array|number[]|null} */
   asBytes() {
     throw Error("not implemented");
   }
@@ -2538,7 +2542,8 @@ var MachineInputBase = class {
     return 0;
   }
 };
-var MachineUTF8Input = class extends MachineInputBase {
+var MachineUTF8Input = class MachineUTF8Input2 extends MachineInputBase {
+  static RUNE_ERROR_STEP = Unicode.RUNE_ERROR << 3 | 1;
   constructor(bytes, start = 0, end = bytes.length) {
     super();
     this.bytes = bytes;
@@ -2552,33 +2557,46 @@ var MachineUTF8Input = class extends MachineInputBase {
     return idx !== -1 && idx <= this.end - target.length;
   }
   hasAnyString(prefilter, pos) {
-    if (!prefilter.ac8) return false;
-    return prefilter.ac8.searchUTF8(this.bytes, this.start + pos, this.end);
+    return prefilter.automaton8().searchUTF8(this.bytes, this.start + pos, this.end);
   }
   step(pos) {
     pos += this.start;
     if (pos >= this.end) return MachineInputBase.EOF();
     const c = this.bytes[pos] & 255;
     if (c < 128) return c << 3 | 1;
-    else if (c >= 194 && c <= 223 && pos + 1 < this.end) {
-      const c1 = this.bytes[pos + 1] & 255;
-      if ((c1 & 192) !== 128) return c << 3 | 1;
-      return ((c & 31) << 6 | c1 & 63) << 3 | 2;
-    } else if (c >= 224 && c <= 239 && pos + 2 < this.end) {
-      const c1 = this.bytes[pos + 1] & 255;
-      if ((c1 & 192) !== 128) return c << 3 | 1;
-      const c2 = this.bytes[pos + 2] & 255;
-      if ((c2 & 192) !== 128) return c << 3 | 1;
-      return ((c & 15) << 12 | (c1 & 63) << 6 | c2 & 63) << 3 | 3;
-    } else if (c >= 240 && c <= 244 && pos + 3 < this.end) {
-      const c1 = this.bytes[pos + 1] & 255;
-      if ((c1 & 192) !== 128) return c << 3 | 1;
+    let size;
+    let rune;
+    let lo = 128;
+    let hi = 191;
+    if (c >= 194 && c <= 223) {
+      size = 2;
+      rune = c & 31;
+    } else if (c >= 224 && c <= 239) {
+      size = 3;
+      rune = c & 15;
+      if (c === 224) lo = 160;
+      else if (c === 237) hi = 159;
+    } else if (c >= 240 && c <= 244) {
+      size = 4;
+      rune = c & 7;
+      if (c === 240) lo = 144;
+      else if (c === 244) hi = 143;
+    } else return MachineUTF8Input2.RUNE_ERROR_STEP;
+    if (pos + size > this.end) return MachineUTF8Input2.RUNE_ERROR_STEP;
+    const c1 = this.bytes[pos + 1] & 255;
+    if (c1 < lo || c1 > hi) return MachineUTF8Input2.RUNE_ERROR_STEP;
+    rune = rune << 6 | c1 & 63;
+    if (size > 2) {
       const c2 = this.bytes[pos + 2] & 255;
-      if ((c2 & 192) !== 128) return c << 3 | 1;
-      const c3 = this.bytes[pos + 3] & 255;
-      if ((c3 & 192) !== 128) return c << 3 | 1;
-      return ((c & 7) << 18 | (c1 & 63) << 12 | (c2 & 63) << 6 | c3 & 63) << 3 | 4;
-    } else return c << 3 | 1;
+      if ((c2 & 192) !== 128) return MachineUTF8Input2.RUNE_ERROR_STEP;
+      rune = rune << 6 | c2 & 63;
+      if (size > 3) {
+        const c3 = this.bytes[pos + 3] & 255;
+        if ((c3 & 192) !== 128) return MachineUTF8Input2.RUNE_ERROR_STEP;
+        rune = rune << 6 | c3 & 63;
+      }
+    }
+    return rune << 3 | size;
   }
   index(re2, pos) {
     pos += this.start;
@@ -2643,8 +2661,7 @@ var MachineUTF16Input = class extends MachineInputBase {
     return idx !== -1 && idx <= this.end - prefilter.str.length;
   }
   hasAnyString(prefilter, pos) {
-    if (!prefilter.ac16) return false;
-    return prefilter.ac16.searchUTF16(this.charSequence, this.start + pos, this.end);
+    return prefilter.automaton16().searchUTF16(this.charSequence, this.start + pos, this.end);
   }
   step(pos) {
     pos += this.start;
@@ -2786,6 +2803,7 @@ var Matcher = class Matcher2 {
     this.groups = [];
     this.namedGroups = re2.namedGroups;
     this.numberOfInstructions = re2.numberOfInstructions();
+    this.lookbehindState = null;
     if (input instanceof MatcherInputBase) this.resetMatcherInput(input);
     else if (Utils.isByteArray(input)) this.resetMatcherInput(MatcherInput.utf8(input));
     else this.resetMatcherInput(MatcherInput.utf16(input));
@@ -2817,9 +2835,13 @@ var Matcher = class Matcher2 {
   */
   resetMatcherInput(input) {
     if (input === null) throw new Error("input is null");
-    if (!(input instanceof MatcherInputBase)) if (Utils.isByteArray(input)) input = MatcherInput.utf8(input);
-    else input = MatcherInput.utf16(input);
+    if (!(input instanceof MatcherInputBase)) {
+      if (Utils.isByteArray(input)) input = MatcherInput.utf8(input);
+      else input = MatcherInput.utf16(input);
+    }
     this.matcherInput = input;
+    if (this.lookbehindState !== null) this.lookbehindState.reset();
+    else this.lookbehindState = this.patternInput.re2().createLookbehindState();
     this.reset();
     return this;
   }
@@ -2907,11 +2929,11 @@ var Matcher = class Matcher2 {
   * @private
   */
   loadGroup(group) {
-    if (group < 0 || group > this.patternGroupCount) throw new RE2JSGroupException(`Group index out of bounds: ${group}`);
+    if (!Number.isInteger(group) || group < 0 || group > this.patternGroupCount) throw new RE2JSGroupException(`Group index out of bounds: ${group}`);
     if (!this.hasMatch) throw new RE2JSGroupException("perhaps no match attempted");
     if (group === 0 || this.hasGroups) return;
     const end = this.matcherInputLength;
-    const res = this.patternInput.re2().matchMachineInput(this.matcherInput, this.groups[0], end, this.anchorFlag, 1 + this.patternGroupCount);
+    const res = this.patternInput.re2().matchMachineInput(this.matcherInput, this.groups[0], end, this.anchorFlag, 1 + this.patternGroupCount, this.lookbehindState);
     if (!res[0]) throw new RE2JSGroupException("inconsistency in matching group data");
     this.groups = res[1];
     this.hasGroups = true;
@@ -2944,7 +2966,7 @@ var Matcher = class Matcher2 {
   */
   find(start = null) {
     if (start !== null) {
-      if (start < 0 || start > this.matcherInputLength) throw new RE2JSGroupException(`start index out of bounds: ${start}`);
+      if (!Number.isInteger(start) || start < 0 || start > this.matcherInputLength) throw new RE2JSGroupException(`start index out of bounds: ${start}`);
       this.reset();
       return this.genMatch(start, 0);
     }
@@ -2967,7 +2989,7 @@ var Matcher = class Matcher2 {
   * @private
   */
   genMatch(startByte, anchor) {
-    const res = this.patternInput.re2().matchMachineInput(this.matcherInput, startByte, this.matcherInputLength, anchor, 1);
+    const res = this.patternInput.re2().matchMachineInput(this.matcherInput, startByte, this.matcherInputLength, anchor, 1, this.lookbehindState);
     if (!res[0]) {
       this.hasMatch = false;
       return false;
@@ -3289,7 +3311,7 @@ var Inst = class Inst2 {
     this.op = op;
     this.out = 0;
     this.arg = 0;
-    this.runes = [];
+    this.runes = /* @__PURE__ */ new Int32Array(0);
     this.next = null;
   }
   matchRune(r) {
@@ -3388,19 +3410,27 @@ var Inst = class Inst2 {
     }
   }
 };
-var Queue = class {
+var Queue = class Queue2 {
   constructor(numInst) {
     this.sparse = new Int32Array(numInst);
     this.densePcs = new Int32Array(numInst);
     this.denseCaps = null;
     this.size = 0;
     this.ncap = 0;
+    this.mainThreads = 0;
   }
+  static INITIAL_THREADS = 32;
   init(ncap) {
     this.ncap = ncap;
-    const needed = this.densePcs.length * ncap;
+    const needed = Math.min(this.densePcs.length, Queue2.INITIAL_THREADS) * ncap;
     if (!this.denseCaps || this.denseCaps.length < needed) this.denseCaps = new Int32Array(needed);
   }
+  growCaps(needed) {
+    const limit = this.densePcs.length * this.ncap;
+    const grown = new Int32Array(Math.min(limit, Math.max(needed, 2 * this.denseCaps.length)));
+    grown.set(this.denseCaps);
+    this.denseCaps = grown;
+  }
   contains(pc) {
     const j = this.sparse[pc];
     return j < this.size && this.densePcs[j] === pc;
@@ -3416,6 +3446,7 @@ var Queue = class {
   }
   clear() {
     this.size = 0;
+    this.mainThreads = 0;
   }
   toString() {
     let out = "{";
@@ -3427,6 +3458,18 @@ var Queue = class {
     return out;
   }
 };
+var LookbehindState = class {
+  constructor(prog) {
+    this.pos = -1;
+    this.pcs = new Int32Array(prog.numInst());
+    this.size = 0;
+    this.lbTable = new Int32Array(prog.numLb + 1);
+  }
+  reset() {
+    this.pos = -1;
+    this.size = 0;
+  }
+};
 var Machine = class Machine2 {
   static fromRE2(re2) {
     const m = new Machine2();
@@ -3434,19 +3477,18 @@ var Machine = class Machine2 {
     m.re2 = re2;
     m.q0 = new Queue(m.prog.numInst());
     m.q1 = new Queue(m.prog.numInst());
+    m.addStack = new Int32Array(2 * (m.prog.numInst() + 1));
     m.matched = false;
     m.matchcap = new Int32Array(m.prog.numCap < 2 ? 2 : m.prog.numCap);
     m.ncap = 0;
     return m;
   }
-  static fromMachine(machine) {
-    return Machine2.fromRE2(machine.re2);
-  }
   constructor() {
     this.prog = null;
     this.re2 = null;
     this.q0 = null;
     this.q1 = null;
+    this.addStack = null;
     this.matched = false;
     this.matchcap = null;
     this.ncap = 0;
@@ -3467,14 +3509,23 @@ var Machine = class Machine2 {
     if (this.ncap === 0) return Utils.emptyInts();
     return Utils.toArray(this.matchcap.subarray(0, this.ncap));
   }
-  match(input, pos, anchor) {
+  match(input, pos, anchor, lbState = null) {
     const startCond = this.re2.cond;
     if (startCond === Utils.EMPTY_ALL) return false;
     if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) return false;
     this.matched = false;
     this.matchcap.fill(-1);
-    let currentPos = this.prog.numLb > 0 ? 0 : pos;
-    let matchStartPos = pos;
+    const hasLookbehinds = this.prog.numLb > 0;
+    const matchStartPos = pos;
+    let currentPos = pos;
+    let resumeLookbehinds = false;
+    if (hasLookbehinds) {
+      if (lbState !== null && lbState.pos >= 0 && lbState.pos <= pos) {
+        currentPos = lbState.pos;
+        resumeLookbehinds = true;
+      } else currentPos = 0;
+    }
+    let saveLookbehinds = hasLookbehinds && lbState !== null;
     let runq = this.q0;
     let nextq = this.q1;
     let r = input.step(currentPos);
@@ -3490,12 +3541,16 @@ var Machine = class Machine2 {
     let flag;
     if (currentPos === 0) flag = Utils.emptyOpContext(-1, rune);
     else flag = input.context(currentPos);
+    if (hasLookbehinds) {
+      if (resumeLookbehinds) this.restoreLookbehinds(lbState, runq, flag);
+      else this.spawnLookbehinds(runq, currentPos, flag);
+    }
     while (true) {
-      if (runq.isEmpty()) {
+      if (runq.mainThreads === 0) {
         if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && currentPos !== 0) break;
         if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && currentPos !== 0) break;
         if (this.matched) break;
-        if (this.prog.numLb === 0 && !(this.re2.prefix.length === 0) && rune1 !== this.re2.prefixRune && input.canCheckPrefix()) {
+        if (this.prog.numLb === 0 && runq.isEmpty() && !(this.re2.prefix.length === 0) && rune1 !== this.re2.prefixRune && input.canCheckPrefix()) {
           const advance = input.index(this.re2, currentPos);
           if (advance < 0) break;
           currentPos += advance;
@@ -3508,9 +3563,12 @@ var Machine = class Machine2 {
           flag = input.context(currentPos);
         }
       }
-      if (currentPos === 0 && this.prog.numLb > 0) for (let i = 0; i < this.prog.lbStarts.length; i++) this.add(runq, this.prog.lbStarts[i], currentPos, this.matchcap, 0, flag);
-      if (!this.matched && (currentPos === 0 || anchor === RE2Flags.UNANCHORED)) {
-        if (currentPos >= matchStartPos) {
+      if (currentPos >= matchStartPos) {
+        if (saveLookbehinds) {
+          this.saveLookbehinds(lbState, runq, currentPos);
+          saveLookbehinds = false;
+        }
+        if (!this.matched && (currentPos === 0 || anchor === RE2Flags.UNANCHORED)) {
           if (this.ncap > 0) this.matchcap[0] = currentPos;
           this.add(runq, this.prog.start, currentPos, this.matchcap, 0, flag);
         }
@@ -3532,6 +3590,7 @@ var Machine = class Machine2 {
       runq = nextq;
       nextq = tmpq;
     }
+    runq.clear();
     nextq.clear();
     return this.matched;
   }
@@ -3555,12 +3614,12 @@ var Machine = class Machine2 {
     }
     let flag = currentPos === 0 ? Utils.emptyOpContext(-1, rune) : input.context(currentPos);
     const matches = /* @__PURE__ */ new Set();
+    if (this.prog.numLb > 0) this.spawnLookbehinds(runq, currentPos, flag);
     while (true) {
-      if (runq.isEmpty()) {
+      if (runq.mainThreads === 0) {
         if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && currentPos !== 0) break;
         if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && currentPos !== 0) break;
       }
-      if (currentPos === 0 && this.prog.numLb > 0) for (let i = 0; i < this.prog.lbStarts.length; i++) this.add(runq, this.prog.lbStarts[i], currentPos, this.matchcap, 0, flag);
       if (currentPos === 0 || anchor === RE2Flags.UNANCHORED) {
         if (currentPos >= matchStartPos) this.add(runq, this.prog.start, currentPos, this.matchcap, 0, flag);
       }
@@ -3647,68 +3706,86 @@ var Machine = class Machine2 {
     }
     runq.clear();
   }
+  spawnLookbehinds(q, pos, flag) {
+    for (let i = 0; i < this.prog.lbStarts.length; i++) this.add(q, this.prog.lbStarts[i], pos, this.matchcap, 0, flag);
+  }
+  restoreLookbehinds(lbState, q, flag) {
+    this.lbTable.set(lbState.lbTable);
+    for (let j = 0; j < lbState.size; j++) this.add(q, lbState.pcs[j], lbState.pos, this.matchcap, 0, flag);
+  }
+  saveLookbehinds(lbState, q, pos) {
+    let size = 0;
+    for (let j = 0; j < q.size; j++) {
+      const pc = q.densePcs[j];
+      if (this.prog.lbInst[pc] === 1 && Inst.isRuneOp(this.prog.inst[pc].op)) lbState.pcs[size++] = pc;
+    }
+    lbState.size = size;
+    lbState.pos = pos;
+    lbState.lbTable.set(this.lbTable);
+  }
   add(q, pc, pos, capArray, capOffset, cond) {
-    while (true) {
-      if (pc === 0) return;
-      if (q.contains(pc)) return;
-      const d = q.add(pc);
-      const inst = this.prog.inst[pc];
-      switch (inst.op) {
-        case Inst.FAIL:
-          return;
-        case Inst.ALT:
-        case Inst.ALT_MATCH:
-          this.add(q, inst.out, pos, capArray, capOffset, cond);
-          pc = inst.arg;
-          continue;
-        case Inst.EMPTY_WIDTH:
-          if ((inst.arg & ~cond) === 0) {
+    const stk = this.addStack;
+    let nstk = 0;
+    for (; ; ) {
+      while (pc !== 0 && !q.contains(pc)) {
+        const d = q.add(pc);
+        const inst = this.prog.inst[pc];
+        switch (inst.op) {
+          case Inst.FAIL:
+            pc = 0;
+            break;
+          case Inst.ALT:
+          case Inst.ALT_MATCH:
+            stk[nstk++] = inst.arg;
+            stk[nstk++] = 0;
             pc = inst.out;
-            continue;
-          }
-          return;
-        case Inst.NOP:
-          pc = inst.out;
-          continue;
-        case Inst.CAPTURE:
-          if (inst.arg < this.ncap) {
-            const opos = capArray[capOffset + inst.arg];
-            capArray[capOffset + inst.arg] = pos;
-            this.add(q, inst.out, pos, capArray, capOffset, cond);
-            capArray[capOffset + inst.arg] = opos;
-            return;
-          } else {
+            break;
+          case Inst.EMPTY_WIDTH:
+            pc = (inst.arg & ~cond) === 0 ? inst.out : 0;
+            break;
+          case Inst.NOP:
             pc = inst.out;
-            continue;
-          }
-        case Inst.LB_WRITE:
-          this.lbTable[Math.abs(inst.arg)] = pos;
-          pc = inst.out;
-          continue;
-        case Inst.LB_CHECK:
-          if (inst.arg > 0) {
-            if (this.lbTable[inst.arg] === pos) {
-              pc = inst.out;
-              continue;
+            break;
+          case Inst.CAPTURE:
+            if (inst.arg < this.ncap) {
+              stk[nstk++] = -inst.arg - 1;
+              stk[nstk++] = capArray[capOffset + inst.arg];
+              capArray[capOffset + inst.arg] = pos;
             }
-          } else if (this.lbTable[-inst.arg] !== pos) {
             pc = inst.out;
-            continue;
-          }
-          return;
-        case Inst.MATCH:
-        case Inst.RUNE:
-        case Inst.RUNE1:
-        case Inst.RUNE_ANY:
-        case Inst.RUNE_ANY_NOT_NL:
-          if (this.ncap > 0) {
-            const destOffset = d * this.ncap;
-            for (let c = 0; c < this.ncap; c++) q.denseCaps[destOffset + c] = capArray[capOffset + c];
-          }
-          return;
-        default:
-          throw new RE2JSInternalException("unhandled");
+            break;
+          case Inst.LB_WRITE:
+            this.lbTable[Math.abs(inst.arg)] = pos;
+            pc = inst.out;
+            break;
+          case Inst.LB_CHECK:
+            if (inst.arg > 0) pc = this.lbTable[inst.arg] === pos ? inst.out : 0;
+            else pc = this.lbTable[-inst.arg] !== pos ? inst.out : 0;
+            break;
+          case Inst.MATCH:
+          case Inst.RUNE:
+          case Inst.RUNE1:
+          case Inst.RUNE_ANY:
+          case Inst.RUNE_ANY_NOT_NL:
+            if (this.prog.lbInst[pc] === 0) q.mainThreads++;
+            if (this.ncap > 0) {
+              const destOffset = d * this.ncap;
+              if (destOffset + this.ncap > q.denseCaps.length) q.growCaps(destOffset + this.ncap);
+              for (let c = 0; c < this.ncap; c++) q.denseCaps[destOffset + c] = capArray[capOffset + c];
+            }
+            pc = 0;
+            break;
+          default:
+            throw new RE2JSInternalException("unhandled");
+        }
       }
+      if (nstk === 0) return;
+      nstk -= 2;
+      const entry = stk[nstk];
+      if (entry < 0) {
+        capArray[capOffset - entry - 1] = stk[nstk + 1];
+        pc = 0;
+      } else pc = entry;
     }
   }
 };
@@ -3726,35 +3803,86 @@ var arraysEqual = (a, b) => {
   return true;
 };
 var DFAState = class {
-  constructor(nfaStates, isMatch, matchIDs = []) {
+  constructor(nfaStates, isMatch, matchIDs) {
     this.nfaStates = nfaStates;
     this.isMatch = isMatch;
     this.matchIDs = matchIDs;
-    this.nextLatin1 = new Array(Unicode.MAX_LATIN1 + 1).fill(null);
-    this.nextLatin1Anchored = new Array(Unicode.MAX_LATIN1 + 1).fill(null);
-    this.transKeys = [];
-    this.transVals = [];
-    this.lastSeen = 0;
+    this.next = null;
+    this.nextAnchored = null;
   }
 };
 var DFA = class DFA2 {
-  static MAX_CACHE_CLEARS = 5;
-  static STATE_MEMORY_ESTIMATE = 838;
+  static STATE_OVERHEAD = 160;
+  static TABLE_OVERHEAD = 16;
+  static PROGRESS_PER_STATE = 10;
   constructor(prog, maxMem = 8388608) {
     this.prog = prog;
+    this.maxMem = maxMem;
     this.stateCache = /* @__PURE__ */ new Map();
     this.stateCount = 0;
     this.startState = null;
-    this.stateLimit = Math.max(1, Math.floor(maxMem / DFA2.STATE_MEMORY_ESTIMATE));
-    this.cacheClears = 0;
     this.failed = false;
-    this.clock = 0;
+    for (let pc = 0; pc < prog.numInst(); pc++) {
+      const op = prog.getInst(pc).op;
+      if (op === Inst.EMPTY_WIDTH || op === Inst.LB_WRITE || op === Inst.LB_CHECK) {
+        this.failed = true;
+        break;
+      }
+    }
+    this.computeRuneClasses();
+    this.stateBudget = maxMem;
+    this.memBudget = maxMem;
+  }
+  computeRuneClasses() {
+    const bounds = /* @__PURE__ */ new Set();
+    const addRune = (r) => {
+      bounds.add(r);
+      bounds.add(r + 1);
+    };
+    for (let pc = 0; pc < this.prog.numInst(); pc++) {
+      const inst = this.prog.getInst(pc);
+      switch (inst.op) {
+        case Inst.RUNE:
+        case Inst.RUNE1:
+          if (inst.runes.length === 1) {
+            addRune(inst.runes[0]);
+            if ((inst.arg & RE2Flags.FOLD_CASE) !== 0) for (let f = Unicode.simpleFold(inst.runes[0]); f !== inst.runes[0]; f = Unicode.simpleFold(f)) addRune(f);
+          } else for (let j = 0; j < inst.runes.length; j += 2) {
+            bounds.add(inst.runes[j]);
+            bounds.add(inst.runes[j + 1] + 1);
+          }
+          break;
+        case Inst.RUNE_ANY_NOT_NL:
+          addRune(10);
+      }
+    }
+    bounds.delete(0);
+    this.classBounds = Int32Array.from(bounds).sort();
+    this.numClasses = this.classBounds.length + 1;
+    const latin1Class = new Int32Array(Unicode.MAX_LATIN1 + 1);
+    for (let r = 0; r <= Unicode.MAX_LATIN1; r++) latin1Class[r] = this.searchClass(r);
+    this.latin1Class = latin1Class;
+  }
+  runeClass(r) {
+    if (r <= Unicode.MAX_LATIN1) return this.latin1Class[r];
+    return this.searchClass(r);
+  }
+  searchClass(r) {
+    const bounds = this.classBounds;
+    let lo = 0;
+    let hi = bounds.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (bounds[mid] <= r) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
   }
   computeClosure(pcs) {
     const closure = /* @__PURE__ */ new Set();
     const stack = [...pcs];
     let isMatch = false;
-    const matchIDs = [];
+    const matchIDs = /* @__PURE__ */ new Set();
     while (stack.length > 0) {
       const pc = stack.pop();
       if (closure.has(pc)) continue;
@@ -3763,7 +3891,7 @@ var DFA = class DFA2 {
       switch (inst.op) {
         case Inst.MATCH:
           isMatch = true;
-          if (!matchIDs.includes(inst.arg)) matchIDs.push(inst.arg);
+          matchIDs.add(inst.arg);
           break;
         case Inst.ALT:
         case Inst.ALT_MATCH:
@@ -3781,11 +3909,11 @@ var DFA = class DFA2 {
       }
     }
     const sortedPCs = Int32Array.from(closure).sort();
-    matchIDs.sort((a, b) => a - b);
+    const ids = Array.from(matchIDs).sort((a, b) => a - b);
     return {
       pcs: sortedPCs,
       isMatch,
-      matchIDs
+      matchIDs: ids
     };
   }
   getState(pcs) {
@@ -3796,163 +3924,133 @@ var DFA = class DFA2 {
     let bucket = this.stateCache.get(hash);
     if (bucket) for (let i = 0; i < bucket.length; i++) {
       const state2 = bucket[i];
-      if (arraysEqual(state2.nfaStates, sortedPCs)) {
-        state2.lastSeen = ++this.clock;
-        return state2;
-      }
+      if (arraysEqual(state2.nfaStates, sortedPCs)) return state2;
     }
-    else {
+    const cost = DFA2.STATE_OVERHEAD + 4 * sortedPCs.length + 8 * closureResult.matchIDs.length;
+    if (this.memBudget < cost) return null;
+    this.memBudget -= cost;
+    if (!bucket) {
       bucket = [];
       this.stateCache.set(hash, bucket);
     }
-    if (this.failed) return null;
-    if (this.stateCount >= this.stateLimit) {
-      this.cacheClears++;
-      if (this.cacheClears >= DFA2.MAX_CACHE_CLEARS) {
-        this.failed = true;
-        this.stateCache.clear();
-        this.stateCount = 0;
-        this.startState = null;
-        return null;
-      }
-      this.evictCache();
-      bucket = this.stateCache.get(hash);
-      if (!bucket) {
-        bucket = [];
-        this.stateCache.set(hash, 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]);
-    allStates.sort((a, b) => a.lastSeen - b.lastSeen);
-    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);
+  allocTable(state, anchor) {
+    const cost = DFA2.TABLE_OVERHEAD + 8 * this.numClasses;
+    if (this.memBudget < cost) return null;
+    this.memBudget -= cost;
+    const table = new Array(this.numClasses).fill(null);
+    if (anchor === RE2Flags.UNANCHORED) state.next = table;
+    else state.nextAnchored = table;
+    return table;
+  }
+  clearCache() {
     this.stateCache.clear();
     this.stateCount = 0;
-    for (let i = 0; i < survivorsArray.length; i++) {
-      const state = survivorsArray[i];
-      state.nextLatin1.fill(null);
-      state.nextLatin1Anchored.fill(null);
-      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++;
-    }
-    if (this.startState && !survivors.has(this.startState)) this.startState = null;
-  }
-  step(state, charCode, anchor) {
-    if (charCode <= Unicode.MAX_LATIN1) if (anchor === RE2Flags.UNANCHORED) {
-      const next = state.nextLatin1[charCode];
-      if (next !== null) return next;
+    this.startState = null;
+    this.memBudget = this.stateBudget;
+  }
+  resetCache(current) {
+    this.clearCache();
+    return this.getState(current.nfaStates);
+  }
+  step(state, cls, rune, anchor) {
+    let table = anchor === RE2Flags.UNANCHORED ? state.next : state.nextAnchored;
+    if (table !== null) {
+      const cached = table[cls];
+      if (cached !== null) return cached;
     } else {
-      const next = state.nextLatin1Anchored[charCode];
-      if (next !== null) return next;
-    }
-    else {
-      const key = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1);
-      const keys = state.transKeys;
-      const len = keys.length;
-      for (let i = 0; i < len; i++) if (keys[i] === key) return state.transVals[i];
+      table = this.allocTable(state, anchor);
+      if (table === null) return null;
     }
     const nextPCs = [];
     for (let i = 0; i < state.nfaStates.length; i++) {
       const pc = state.nfaStates[i];
       const inst = this.prog.getInst(pc);
-      if (Inst.isRuneOp(inst.op) && inst.matchRune(charCode)) nextPCs.push(inst.out);
+      if (Inst.isRuneOp(inst.op) && inst.matchRune(rune)) nextPCs.push(inst.out);
     }
     if (anchor === RE2Flags.UNANCHORED) nextPCs.push(this.prog.start);
     const nextState = this.getState(nextPCs);
-    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.transKeys.push(key);
-      state.transVals.push(nextState);
-    }
+    if (nextState === null) return null;
+    table[cls] = nextState;
     return nextState;
   }
-  match(input, pos, anchor) {
-    if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) return false;
-    if (!this.startState) {
+  start() {
+    if (this.startState === null) {
       this.startState = this.getState([this.prog.start]);
-      if (!this.startState) return null;
+      if (this.startState === null && !this.failed) {
+        this.clearCache();
+        this.startState = this.getState([this.prog.start]);
+      }
     }
-    let endPos = input.endPos();
-    let currentState = this.startState;
-    if (currentState.isMatch) if (anchor === RE2Flags.ANCHOR_BOTH) {
-      if (pos === endPos) return true;
-    } else return true;
+    return this.startState;
+  }
+  run(input, pos, anchor, state, onState, noMatch) {
+    const endPos = input.endPos();
+    const latin1Class = this.latin1Class;
+    let resetPos = -1;
     let i = pos;
     while (i < endPos) {
       const r = input.step(i);
       const rune = r >> 3;
       const width = r & 7;
       if (width === 0) break;
-      currentState = anchor === RE2Flags.UNANCHORED && rune <= Unicode.MAX_LATIN1 && currentState.nextLatin1[rune] || this.step(currentState, rune, anchor);
-      if (currentState === null) return null;
-      currentState.lastSeen = ++this.clock;
-      if (currentState.isMatch) if (anchor === RE2Flags.ANCHOR_BOTH) {
-        if (i + width === endPos) return true;
-      } else return true;
-      if (currentState.nfaStates.length === 0) {
-        if (anchor !== RE2Flags.UNANCHORED) return false;
+      const cls = rune <= Unicode.MAX_LATIN1 ? latin1Class[rune] : this.runeClass(rune);
+      let next = anchor === RE2Flags.UNANCHORED && state.next !== null ? state.next[cls] : null;
+      if (next === null) {
+        next = this.step(state, cls, rune, anchor);
+        if (next === null) {
+          if (resetPos >= 0 && i - resetPos < DFA2.PROGRESS_PER_STATE * this.stateCount) return null;
+          resetPos = i;
+          state = this.resetCache(state);
+          if (state === null) return null;
+          next = this.step(state, cls, rune, anchor);
+          if (next === null) return null;
+        }
       }
+      state = next;
       i += width;
+      const result = onState(state, i);
+      if (result !== null) return result;
+      if (state.nfaStates.length === 0 && anchor !== RE2Flags.UNANCHORED) return noMatch;
     }
-    return false;
+    return noMatch;
+  }
+  match(input, pos, anchor) {
+    if (this.failed) return null;
+    if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) return false;
+    const startState = this.start();
+    if (startState === null) return null;
+    const endPos = input.endPos();
+    if (startState.isMatch && (anchor !== RE2Flags.ANCHOR_BOTH || pos === endPos)) return true;
+    return this.run(input, pos, anchor, startState, (state, nextPos) => {
+      if (state.isMatch && (anchor !== RE2Flags.ANCHOR_BOTH || nextPos === endPos)) return true;
+      return null;
+    }, false);
   }
   matchSet(input, pos, anchor) {
+    if (this.failed) return null;
     if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) return [];
-    if (!this.startState) {
-      this.startState = this.getState([this.prog.start]);
-      if (!this.startState) return null;
-    }
-    let endPos = input.endPos();
-    let currentState = this.startState;
+    const startState = this.start();
+    if (startState === null) return null;
+    const endPos = input.endPos();
     const matches = /* @__PURE__ */ new Set();
-    const checkMatch = (state, currentPos) => {
-      if (state.isMatch) if (anchor === RE2Flags.ANCHOR_BOTH) {
-        if (currentPos === endPos) state.matchIDs.forEach((id) => matches.add(id));
-      } else state.matchIDs.forEach((id) => matches.add(id));
+    const collect = (state, currentPos) => {
+      if (state.isMatch && (anchor !== RE2Flags.ANCHOR_BOTH || currentPos === endPos)) for (let k = 0; k < state.matchIDs.length; k++) matches.add(state.matchIDs[k]);
+      return null;
     };
-    checkMatch(currentState, pos);
-    let i = pos;
-    while (i < endPos) {
-      const r = input.step(i);
-      const rune = r >> 3;
-      const width = r & 7;
-      if (width === 0) break;
-      currentState = anchor === RE2Flags.UNANCHORED && rune <= Unicode.MAX_LATIN1 && currentState.nextLatin1[rune] || this.step(currentState, rune, anchor);
-      if (currentState === null) return null;
-      currentState.lastSeen = ++this.clock;
-      i += width;
-      checkMatch(currentState, i);
-      if (currentState.nfaStates.length === 0) {
-        if (anchor !== RE2Flags.UNANCHORED) break;
-      }
-    }
+    collect(startState, pos);
+    if (this.run(input, pos, anchor, startState, collect, false) === null) return null;
     return Array.from(matches).sort((a, b) => a - b);
   }
 };
 var VISITED_BITS = 32;
 var MAX_BACKTRACK_PROG = 500;
 var INITIAL_JOB_CAPACITY = 256;
-var MAX_BACKTRACK_VECTOR = 256 * 1024;
+var MAX_BACKTRACK_VECTOR = 262144;
 var BitState = class {
   constructor() {
     this.end = 0;
@@ -4238,7 +4336,7 @@ var OnePassProg = class {
       const inst = new Inst(orig.op);
       inst.out = orig.out;
       inst.arg = orig.arg;
-      inst.runes = orig.runes ? orig.runes.slice() : [];
+      inst.runes = orig.runes ? new Int32Array(orig.runes) : /* @__PURE__ */ new Int32Array(0);
       inst.next = null;
       this.inst[i] = inst;
     }
@@ -4308,7 +4406,7 @@ var makeOnePass = (p) => {
         const rightRunes = onePassRunes[inst.arg] || [];
         const mergeRes = mergeRuneSets(leftRunes, rightRunes, inst.out, inst.arg);
         if (!mergeRes) return false;
-        onePassRunes[pc] = mergeRes.merged;
+        onePassRunes[pc] = new Int32Array(mergeRes.merged);
         inst.next = new Uint32Array(mergeRes.next);
         break;
       }
@@ -4317,7 +4415,7 @@ var makeOnePass = (p) => {
       case Inst.NOP:
         ok = check(inst.out);
         m[pc] = m[inst.out];
-        onePassRunes[pc] = onePassRunes[inst.out] ? onePassRunes[inst.out].slice() : [];
+        onePassRunes[pc] = onePassRunes[inst.out] ? new Int32Array(onePassRunes[inst.out]) : /* @__PURE__ */ new Int32Array(0);
         inst.next = new Uint32Array(Math.floor(onePassRunes[pc].length / 2) + 1).fill(inst.out);
         break;
       case Inst.MATCH:
@@ -4329,7 +4427,7 @@ var makeOnePass = (p) => {
         if (inst.next && inst.next.length > 0) break;
         instQueue.insert(inst.out);
         if (!inst.runes || inst.runes.length === 0) {
-          onePassRunes[pc] = [];
+          onePassRunes[pc] = /* @__PURE__ */ new Int32Array(0);
           inst.next = new Uint32Array([inst.out]);
           break;
         }
@@ -4340,7 +4438,7 @@ var makeOnePass = (p) => {
           for (let r1 = Unicode.simpleFold(r0); r1 !== r0; r1 = Unicode.simpleFold(r1)) runes.push(r1, r1);
           runes.sort((a, b) => a - b);
         } else for (let j = 0; j < inst.runes.length; j++) runes.push(inst.runes[j]);
-        onePassRunes[pc] = runes;
+        onePassRunes[pc] = new Int32Array(runes);
         inst.next = new Uint32Array(Math.floor(runes.length / 2) + 1).fill(inst.out);
         inst.op = Inst.RUNE;
         break;
@@ -4356,7 +4454,7 @@ var makeOnePass = (p) => {
           for (let r1 = Unicode.simpleFold(r0); r1 !== r0; r1 = Unicode.simpleFold(r1)) runes.push(r1, r1);
           runes.sort((a, b) => a - b);
         } else runes.push(inst.runes[0], inst.runes[0]);
-        onePassRunes[pc] = runes;
+        onePassRunes[pc] = new Int32Array(runes);
         inst.next = new Uint32Array(Math.floor(runes.length / 2) + 1).fill(inst.out);
         inst.op = Inst.RUNE;
         break;
@@ -4365,21 +4463,20 @@ var makeOnePass = (p) => {
         m[pc] = false;
         if (inst.next && inst.next.length > 0) break;
         instQueue.insert(inst.out);
-        onePassRunes[pc] = [0, Unicode.MAX_RUNE];
+        onePassRunes[pc] = new Int32Array([0, Unicode.MAX_RUNE]);
         inst.next = new Uint32Array([inst.out]);
         break;
       case Inst.RUNE_ANY_NOT_NL:
         m[pc] = false;
         if (inst.next && inst.next.length > 0) break;
         instQueue.insert(inst.out);
-        onePassRunes[pc] = [
+        onePassRunes[pc] = new Int32Array([
           0,
           9,
           11,
           Unicode.MAX_RUNE
-        ];
+        ]);
         inst.next = new Uint32Array(Math.floor(onePassRunes[pc].length / 2) + 1).fill(inst.out);
-        break;
     }
     return ok;
   };
@@ -4412,8 +4509,7 @@ var cleanupOnePass = (p, original) => {
       case Inst.RUNE_ANY_NOT_NL:
         p.inst[ix].next = null;
         p.inst[ix].op = instOriginal.op;
-        p.inst[ix].runes = instOriginal.runes ? instOriginal.runes.slice() : [];
-        break;
+        p.inst[ix].runes = instOriginal.runes ? new Int32Array(instOriginal.runes) : /* @__PURE__ */ new Int32Array(0);
     }
   }
 };
@@ -4444,7 +4540,6 @@ var OnePass = class OnePass2 {
           break;
         default:
           if (opOut === Inst.MATCH && hasAlt) return null;
-          break;
       }
     }
     let p = onePassCopy(prog);
@@ -4592,7 +4687,7 @@ var Regexp = class Regexp2 {
     this.op = op;
     this.flags = 0;
     this.subs = Regexp2.emptySubs();
-    this.runes = [];
+    this.runes = /* @__PURE__ */ new Int32Array(0);
     this.min = 0;
     this.max = 0;
     this.cap = 0;
@@ -4603,7 +4698,7 @@ var Regexp = class Regexp2 {
   reinit() {
     this.flags = 0;
     this.subs = Regexp2.emptySubs();
-    this.runes = [];
+    this.runes = /* @__PURE__ */ new Int32Array(0);
     this.cap = 0;
     this.min = 0;
     this.max = 0;
@@ -4647,7 +4742,6 @@ var Regexp = class Regexp2 {
               if (this.max >= 0) out += this.max;
             }
             out += "}";
-            break;
         }
         if ((this.flags & RE2Flags.NON_GREEDY) !== 0) out += "?";
         break;
@@ -4742,7 +4836,6 @@ var Regexp = class Regexp2 {
         break;
       default:
         out += this.op;
-        break;
     }
     return out;
   }
@@ -4788,66 +4881,137 @@ var Regexp = class Regexp2 {
       case Regexp2.Op.PLB:
       case Regexp2.Op.NLB:
         if (this.lb !== that.lb || !this.subs[0].equals(that.subs[0])) return false;
-        break;
     }
     return true;
   }
 };
+var RegexpWalker = class {
+  static walk(root, handler) {
+    const stack = [];
+    let re2 = root;
+    let result;
+    for (; ; ) {
+      if (re2.subs.length === 0) result = handler.leaf(re2);
+      else {
+        const state = handler.enter(re2);
+        if (state.result === void 0) {
+          stack.push({
+            re: re2,
+            state,
+            i: 0
+          });
+          re2 = re2.subs[0];
+          continue;
+        }
+        result = state.result;
+      }
+      for (; ; ) {
+        if (stack.length === 0) return result;
+        const frame = stack[stack.length - 1];
+        handler.child(frame.re, frame.state, result, frame.i);
+        frame.i++;
+        if (frame.state.result === void 0 && frame.i < frame.re.subs.length) {
+          re2 = frame.re.subs[frame.i];
+          break;
+        }
+        stack.pop();
+        result = frame.state.result !== void 0 ? frame.state.result : handler.leave(frame.re, frame.state);
+      }
+    }
+  }
+};
 var AhoCorasick = class {
-  constructor(wordArrays) {
-    this.next = [/* @__PURE__ */ Object.create(null)];
-    this.fail = [0];
-    this.match = [false];
-    for (const word of wordArrays) {
+  constructor(words, alphabetSize) {
+    const edges = /* @__PURE__ */ new Map();
+    const parent = [0];
+    const unit = [0];
+    const depth = [0];
+    const terminal = [0];
+    for (const word of words) {
       let node = 0;
       for (let i = 0; i < word.length; i++) {
-        const val = word[i];
-        if (!(val in this.next[node])) {
-          this.next.push(/* @__PURE__ */ Object.create(null));
-          this.fail.push(0);
-          this.match.push(false);
-          this.next[node][val] = this.next.length - 1;
+        const key = node * alphabetSize + word[i];
+        let child = edges.get(key);
+        if (child === void 0) {
+          child = parent.length;
+          edges.set(key, child);
+          parent.push(node);
+          unit.push(word[i]);
+          depth.push(depth[node] + 1);
+          terminal.push(0);
+        }
+        node = child;
+      }
+      terminal[node] = 1;
+    }
+    const numNodes = parent.length;
+    const children = new Int32Array(numNodes - 1);
+    for (let c = 1; c < numNodes; c++) children[c - 1] = c;
+    children.sort((a, b) => parent[a] - parent[b] || unit[a] - unit[b]);
+    const childStart = new Int32Array(numNodes + 1);
+    for (let c = 1; c < numNodes; c++) childStart[parent[c] + 1]++;
+    for (let n = 0; n < numNodes; n++) childStart[n + 1] += childStart[n];
+    const childUnit = new Int32Array(numNodes - 1);
+    for (let k = 0; k < children.length; k++) childUnit[k] = unit[children[k]];
+    this.childStart = childStart;
+    this.childUnit = childUnit;
+    this.childNode = children;
+    const byDepth = new Int32Array(numNodes);
+    for (let n = 0; n < numNodes; n++) byDepth[n] = n;
+    byDepth.sort((a, b) => depth[a] - depth[b]);
+    const fail = new Int32Array(numNodes);
+    const match = Uint8Array.from(terminal);
+    for (let k = 1; k < numNodes; k++) {
+      const c = byDepth[k];
+      const p = parent[c];
+      if (p !== 0) {
+        let f = fail[p];
+        let next = this.next(f, unit[c]);
+        while (next < 0 && f !== 0) {
+          f = fail[f];
+          next = this.next(f, unit[c]);
         }
-        node = this.next[node][val];
+        fail[c] = next >= 0 ? next : 0;
       }
-      this.match[node] = true;
+      match[c] |= match[fail[c]];
     }
-    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);
+    this.fail = fail;
+    this.match = match;
+  }
+  next(node, u) {
+    let lo = this.childStart[node];
+    let hi = this.childStart[node + 1];
+    const units = this.childUnit;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      const m = units[mid];
+      if (m === u) return this.childNode[mid];
+      if (m < u) lo = mid + 1;
+      else hi = mid;
     }
-    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);
-      }
+    return -1;
+  }
+  advance(node, u) {
+    for (; ; ) {
+      const next = this.next(node, u);
+      if (next >= 0) return next;
+      if (node === 0) return 0;
+      node = this.fail[node];
     }
   }
   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;
+      node = this.advance(node, charSeq.charCodeAt(i));
+      if (this.match[node] === 1) 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;
+      node = this.advance(node, bytes[i]);
+      if (this.match[node] === 1) return true;
     }
     return false;
   }
@@ -4859,14 +5023,33 @@ var Prefilter = class Prefilter2 {
     AND: 2,
     OR: 3
   };
+  static MAX_SCANS = 32;
+  static MAX_AC_UNITS = 1 << 18;
   constructor(type) {
     this.type = type;
     this.subs = [];
     this.str = "";
     this.bytes = null;
+    this.cost = type === Prefilter2.Type.EXACT ? 1 : 0;
+    this.allExact = false;
     this.ac16 = null;
     this.ac8 = null;
   }
+  automaton16() {
+    if (this.ac16 === null) {
+      const words = this.subs.map((s) => {
+        const arr = new Array(s.str.length);
+        for (let i = 0; i < s.str.length; i++) arr[i] = s.str.charCodeAt(i);
+        return arr;
+      });
+      this.ac16 = new AhoCorasick(words, 65536);
+    }
+    return this.ac16;
+  }
+  automaton8() {
+    if (this.ac8 === null) this.ac8 = new AhoCorasick(this.subs.map((s) => s.bytes), 256);
+    return this.ac8;
+  }
   eval(input, pos) {
     switch (this.type) {
       case Prefilter2.Type.NONE:
@@ -4877,7 +5060,7 @@ var Prefilter = class Prefilter2 {
         for (let i = 0; i < this.subs.length; i++) if (!this.subs[i].eval(input, pos)) return false;
         return true;
       case Prefilter2.Type.OR:
-        if (this.ac16 && this.ac8) return input.hasAnyString(this, pos);
+        if (this.allExact) return input.hasAnyString(this, pos);
         for (let i = 0; i < this.subs.length; i++) if (this.subs[i].eval(input, pos)) return true;
         return false;
       default:
@@ -4887,103 +5070,119 @@ var Prefilter = class Prefilter2 {
 };
 var PrefilterTree = class PrefilterTree2 {
   static build(re2) {
-    const pf = PrefilterTree2.fromRegexp(re2);
-    return PrefilterTree2.simplify(pf);
-  }
-  static fromRegexp(re2) {
     if (!re2) return new Prefilter(Prefilter.Type.NONE);
+    return RegexpWalker.walk(re2, PrefilterTree2.WALKER);
+  }
+  static WALKER = {
+    leaf: (re2) => PrefilterTree2.leaf(re2),
+    enter: (re2) => PrefilterTree2.enter(re2),
+    child: (re2, state, result) => PrefilterTree2.child(re2, state, result),
+    leave: (re2, state) => PrefilterTree2.leave(re2, state)
+  };
+  static leaf(re2) {
+    if (re2.op !== Regexp.Op.LITERAL) return new Prefilter(Prefilter.Type.NONE);
+    if (re2.runes.length === 0 || (re2.flags & RE2Flags.FOLD_CASE) !== 0) return new Prefilter(Prefilter.Type.NONE);
+    let str = "";
+    for (let i = 0; i < re2.runes.length; i++) {
+      if (Unicode.isUnsearchable(re2.runes[i])) return new Prefilter(Prefilter.Type.NONE);
+      str += String.fromCodePoint(re2.runes[i]);
+    }
+    const pf = new Prefilter(Prefilter.Type.EXACT);
+    pf.str = str;
+    pf.bytes = Utils.stringToUtf8ByteArray(pf.str);
+    return pf;
+  }
+  static enter(re2) {
     switch (re2.op) {
-      case Regexp.Op.PLB:
-      case Regexp.Op.NLB:
-      case Regexp.Op.NO_MATCH:
-      case Regexp.Op.EMPTY_MATCH:
-      case Regexp.Op.BEGIN_LINE:
-      case Regexp.Op.END_LINE:
-      case Regexp.Op.BEGIN_TEXT:
-      case Regexp.Op.END_TEXT:
-      case Regexp.Op.WORD_BOUNDARY:
-      case Regexp.Op.NO_WORD_BOUNDARY:
-      case Regexp.Op.CHAR_CLASS:
-      case Regexp.Op.ANY_CHAR_NOT_NL:
-      case Regexp.Op.ANY_CHAR:
-        return new Prefilter(Prefilter.Type.NONE);
-      case Regexp.Op.LITERAL: {
-        if (re2.runes.length === 0 || (re2.flags & RE2Flags.FOLD_CASE) !== 0) return new Prefilter(Prefilter.Type.NONE);
-        const pf = new Prefilter(Prefilter.Type.EXACT);
-        let str = "";
-        for (let i = 0; i < re2.runes.length; i++) str += String.fromCodePoint(re2.runes[i]);
-        pf.str = str;
-        pf.bytes = Utils.stringToUtf8ByteArray(pf.str);
-        return pf;
-      }
       case Regexp.Op.CAPTURE:
       case Regexp.Op.PLUS:
-        return PrefilterTree2.fromRegexp(re2.subs[0]);
+        return { sub: null };
       case Regexp.Op.REPEAT:
-        if (re2.min >= 1) return PrefilterTree2.fromRegexp(re2.subs[0]);
-        return new Prefilter(Prefilter.Type.NONE);
-      case Regexp.Op.CONCAT: {
-        const pf = new Prefilter(Prefilter.Type.AND);
-        for (const sub of re2.subs) pf.subs.push(PrefilterTree2.fromRegexp(sub));
-        return pf;
-      }
-      case Regexp.Op.ALTERNATE: {
-        const pf = new Prefilter(Prefilter.Type.OR);
-        for (const sub of re2.subs) pf.subs.push(PrefilterTree2.fromRegexp(sub));
-        return pf;
-      }
+        if (re2.min >= 1) return { sub: null };
+        return { result: new Prefilter(Prefilter.Type.NONE) };
+      case Regexp.Op.CONCAT:
+        return {
+          pf: new Prefilter(Prefilter.Type.AND),
+          subs: []
+        };
+      case Regexp.Op.ALTERNATE:
+        return {
+          pf: new Prefilter(Prefilter.Type.OR),
+          subs: []
+        };
       default:
-        return new Prefilter(Prefilter.Type.NONE);
+        return { result: new Prefilter(Prefilter.Type.NONE) };
     }
   }
-  static simplify(pf) {
-    if (pf.type === Prefilter.Type.EXACT || pf.type === Prefilter.Type.NONE) return pf;
-    if (pf.type === Prefilter.Type.AND) {
-      const newSubs = [];
-      for (const sub of pf.subs) {
-        const s = PrefilterTree2.simplify(sub);
-        if (s.type !== Prefilter.Type.NONE) if (s.type === Prefilter.Type.AND) for (let j = 0; j < s.subs.length; j++) newSubs.push(s.subs[j]);
-        else newSubs.push(s);
-      }
-      if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE);
-      if (newSubs.length === 1) return newSubs[0];
-      pf.subs = newSubs;
-      return pf;
+  static child(re2, state, s) {
+    if (state.subs === void 0) {
+      state.sub = s;
+      return;
     }
-    if (pf.type === Prefilter.Type.OR) {
-      const newSubs = [];
-      for (const sub of pf.subs) {
-        const s = PrefilterTree2.simplify(sub);
-        if (s.type === Prefilter.Type.NONE) return new Prefilter(Prefilter.Type.NONE);
-        if (s.type === Prefilter.Type.OR) for (let j = 0; j < s.subs.length; j++) newSubs.push(s.subs[j]);
-        else newSubs.push(s);
-      }
-      if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE);
-      if (newSubs.length === 1) return newSubs[0];
-      const seen = /* @__PURE__ */ new Set();
-      const uniqueSubs = [];
-      for (const sub of newSubs) if (sub.type === Prefilter.Type.EXACT) {
-        if (!seen.has(sub.str)) {
-          seen.add(sub.str);
-          uniqueSubs.push(sub);
-        }
-      } else uniqueSubs.push(sub);
-      pf.subs = uniqueSubs;
-      let allExact = true;
-      for (const sub of uniqueSubs) if (sub.type !== Prefilter.Type.EXACT) {
-        allExact = false;
-        break;
+    if (state.pf.type === Prefilter.Type.AND) {
+      if (s.type === Prefilter.Type.NONE) return;
+      if (s.type === Prefilter.Type.AND) {
+        for (let j = 0; j < s.subs.length; j++) state.subs.push(s.subs[j]);
+        return;
       }
-      if (allExact && uniqueSubs.length > 1) {
-        pf.ac16 = new AhoCorasick(uniqueSubs.map((s) => {
-          const arr = [];
-          for (let i = 0; i < s.str.length; i++) arr.push(s.str.charCodeAt(i));
-          return arr;
-        }));
-        pf.ac8 = new AhoCorasick(uniqueSubs.map((s) => s.bytes));
+      state.subs.push(s);
+      return;
+    }
+    if (s.type === Prefilter.Type.NONE) {
+      state.result = new Prefilter(Prefilter.Type.NONE);
+      return;
+    }
+    if (s.type === Prefilter.Type.OR) {
+      for (let j = 0; j < s.subs.length; j++) state.subs.push(s.subs[j]);
+      return;
+    }
+    state.subs.push(s);
+  }
+  static leave(re2, state) {
+    if (state.subs === void 0) return state.sub;
+    const pf = state.pf;
+    const seen = /* @__PURE__ */ new Set();
+    const subs = [];
+    for (const sub of state.subs) {
+      if (sub.type === Prefilter.Type.EXACT) {
+        if (seen.has(sub.str)) continue;
+        seen.add(sub.str);
       }
+      subs.push(sub);
+    }
+    if (pf.type === Prefilter.Type.AND) {
+      const kept = [];
+      let cost2 = 0;
+      for (const sub of subs) {
+        if (cost2 + sub.cost > Prefilter.MAX_SCANS) continue;
+        kept.push(sub);
+        cost2 += sub.cost;
+      }
+      if (kept.length === 0) return new Prefilter(Prefilter.Type.NONE);
+      if (kept.length === 1) return kept[0];
+      pf.subs = kept;
+      pf.cost = cost2;
+      return pf;
+    }
+    if (subs.length === 0) return new Prefilter(Prefilter.Type.NONE);
+    if (subs.length === 1) return subs[0];
+    pf.subs = subs;
+    let allExact = true;
+    let cost = 0;
+    let units = 0;
+    for (const sub of subs) {
+      if (sub.type !== Prefilter.Type.EXACT) allExact = false;
+      else units += sub.bytes.length;
+      cost += sub.cost;
+    }
+    if (allExact) {
+      if (units > Prefilter.MAX_AC_UNITS) return new Prefilter(Prefilter.Type.NONE);
+      pf.allExact = true;
+      pf.cost = 1;
       return pf;
     }
+    if (cost > Prefilter.MAX_SCANS) return new Prefilter(Prefilter.Type.NONE);
+    pf.cost = cost;
     return pf;
   }
 };
@@ -5004,6 +5203,7 @@ var Prog = class {
     this.numCap = 2;
     this.lbStarts = [];
     this.numLb = 0;
+    this.lbInst = null;
   }
   getInst(pc) {
     return this.inst[pc];
@@ -5014,6 +5214,28 @@ var Prog = class {
   addInst(op) {
     this.inst.push(new Inst(op));
   }
+  markLookbehindInsts() {
+    const lbInst = new Uint8Array(this.inst.length);
+    const pending = this.lbStarts.slice();
+    while (pending.length > 0) {
+      const pc = pending.pop();
+      if (pc === 0 || lbInst[pc] === 1) continue;
+      lbInst[pc] = 1;
+      const i = this.inst[pc];
+      switch (i.op) {
+        case Inst.ALT:
+        case Inst.ALT_MATCH:
+          pending.push(i.out, i.arg);
+          break;
+        case Inst.MATCH:
+        case Inst.FAIL:
+          break;
+        default:
+          pending.push(i.out);
+      }
+    }
+    this.lbInst = lbInst;
+  }
   skipNop(pc) {
     let i = this.inst[pc];
     while (i.op === Inst.NOP || i.op === Inst.CAPTURE) {
@@ -5026,7 +5248,7 @@ var Prog = class {
     let prefix = "";
     let i = this.skipNop(this.start);
     if (!Inst.isRuneOp(i.op) || i.runes.length !== 1) return [i.op === Inst.MATCH, prefix];
-    while (Inst.isRuneOp(i.op) && i.runes.length === 1 && (i.arg & RE2Flags.FOLD_CASE) === 0) {
+    while (Inst.isRuneOp(i.op) && i.runes.length === 1 && (i.arg & RE2Flags.FOLD_CASE) === 0 && !Unicode.isUnsearchable(i.runes[0])) {
       prefix += String.fromCodePoint(i.runes[0]);
       i = this.skipNop(i.out);
     }
@@ -5091,6 +5313,13 @@ var Prog = class {
     return out;
   }
 };
+var ANY_RUNE_NOT_NL = new Int32Array([
+  0,
+  Codepoint.CODES.get("\n") - 1,
+  Codepoint.CODES.get("\n") + 1,
+  Unicode.MAX_RUNE
+]);
+var ANY_RUNE = new Int32Array([0, Unicode.MAX_RUNE]);
 var Frag = class {
   constructor(i = 0, out = new PatchList(), nullable = false) {
     this.i = i;
@@ -5099,28 +5328,19 @@ var Frag = class {
   }
 };
 var Compiler = class Compiler2 {
-  static ANY_RUNE_NOT_NL() {
-    return [
-      0,
-      Codepoint.CODES.get("\n") - 1,
-      Codepoint.CODES.get("\n") + 1,
-      Unicode.MAX_RUNE
-    ];
-  }
-  static ANY_RUNE() {
-    return [0, Unicode.MAX_RUNE];
-  }
   static compileRegexp(re2) {
     const c = new Compiler2();
     const f = c.compile(re2);
     c.prog.patch(f.out, c.newInst(Inst.MATCH).i);
     c.prog.start = f.i;
+    c.prog.markLookbehindInsts();
     return c.prog;
   }
   static compileSet(regexps) {
     const c = new Compiler2();
     if (regexps.length === 0) {
       c.prog.start = c.newInst(Inst.FAIL).i;
+      c.prog.markLookbehindInsts();
       return c.prog;
     }
     let starts = [];
@@ -5140,11 +5360,19 @@ var Compiler = class Compiler2 {
       start = f.i;
     }
     c.prog.start = start;
+    c.prog.markLookbehindInsts();
     return c.prog;
   }
   constructor() {
     this.prog = new Prog();
     this.newInst(Inst.FAIL);
+    this.runeCache = /* @__PURE__ */ new Map();
+    this.walker = {
+      leaf: (re2) => this.leaf(re2),
+      enter: (re2) => this.enter(re2),
+      child: (re2, state, result) => this.child(re2, state, result),
+      leave: (re2, state) => this.leave(re2, state)
+    };
   }
   newInst(op) {
     this.prog.addInst(op);
@@ -5237,7 +5465,7 @@ var Compiler = class Compiler2 {
   lookBehind(a, lb) {
     const id = this.newInst(Inst.LB_WRITE);
     this.prog.getInst(id.i).arg = lb;
-    const any = this.rune(Compiler2.ANY_RUNE(), 0);
+    const any = this.rune(ANY_RUNE, 0);
     const dotStar = this.star(any, true);
     const lbAutomaton = this.cat(dotStar, a);
     this.prog.patch(lbAutomaton.out, id.i);
@@ -5249,27 +5477,34 @@ var Compiler = class Compiler2 {
     return checkId;
   }
   compile(re2) {
+    return RegexpWalker.walk(re2, this.walker);
+  }
+  leaf(re2) {
     switch (re2.op) {
       case Regexp.Op.NO_MATCH:
         return this.fail();
       case Regexp.Op.EMPTY_MATCH:
         return this.nop();
-      case Regexp.Op.LITERAL:
+      case Regexp.Op.LITERAL: {
         if (re2.runes.length === 0) return this.nop();
-        else {
-          let f = null;
-          for (let r of re2.runes) {
-            const f1 = this.rune([r], re2.flags);
-            f = f === null ? f1 : this.cat(f, f1);
+        let f = null;
+        for (let r of re2.runes) {
+          let singleRune = this.runeCache.get(r);
+          if (singleRune === void 0) {
+            singleRune = new Int32Array([r]);
+            this.runeCache.set(r, singleRune);
           }
-          return f;
+          const f1 = this.rune(singleRune, re2.flags);
+          f = f === null ? f1 : this.cat(f, f1);
         }
+        return f;
+      }
       case Regexp.Op.CHAR_CLASS:
         return this.rune(re2.runes, re2.flags);
       case Regexp.Op.ANY_CHAR_NOT_NL:
-        return this.rune(Compiler2.ANY_RUNE_NOT_NL(), 0);
+        return this.rune(ANY_RUNE_NOT_NL, 0);
       case Regexp.Op.ANY_CHAR:
-        return this.rune(Compiler2.ANY_RUNE(), 0);
+        return this.rune(ANY_RUNE, 0);
       case Regexp.Op.BEGIN_LINE:
         return this.empty(Utils.EMPTY_BEGIN_LINE);
       case Regexp.Op.END_LINE:
@@ -5282,41 +5517,56 @@ var Compiler = class Compiler2 {
         return this.empty(Utils.EMPTY_WORD_BOUNDARY);
       case Regexp.Op.NO_WORD_BOUNDARY:
         return this.empty(Utils.EMPTY_NO_WORD_BOUNDARY);
+      case Regexp.Op.CONCAT:
+      case Regexp.Op.ALTERNATE:
+        return this.nop();
+      default:
+        throw new RE2JSCompileException("regexp: unhandled case in compile");
+    }
+  }
+  enter(re2) {
+    switch (re2.op) {
+      case Regexp.Op.PLB:
+      case Regexp.Op.NLB:
+      case Regexp.Op.STAR:
+      case Regexp.Op.PLUS:
+      case Regexp.Op.QUEST:
+        return { sub: null };
+      case Regexp.Op.CAPTURE:
+        return {
+          bra: this.cap(re2.cap << 1),
+          sub: null
+        };
+      case Regexp.Op.CONCAT:
+      case Regexp.Op.ALTERNATE:
+        return { f: null };
+      default:
+        throw new RE2JSCompileException("regexp: unhandled case in compile");
+    }
+  }
+  child(re2, state, f1) {
+    if (re2.op === Regexp.Op.CONCAT) state.f = state.f === null ? f1 : this.cat(state.f, f1);
+    else if (re2.op === Regexp.Op.ALTERNATE) state.f = state.f === null ? f1 : this.alt(state.f, f1);
+    else state.sub = f1;
+  }
+  leave(re2, state) {
+    switch (re2.op) {
       case Regexp.Op.PLB:
       case Regexp.Op.NLB:
-        return this.lookBehind(this.compile(re2.subs[0]), re2.lb);
+        return this.lookBehind(state.sub, re2.lb);
       case Regexp.Op.CAPTURE: {
-        const bra = this.cap(re2.cap << 1);
-        const sub = this.compile(re2.subs[0]);
         const ket = this.cap(re2.cap << 1 | 1);
-        return this.cat(this.cat(bra, sub), ket);
+        return this.cat(this.cat(state.bra, state.sub), ket);
       }
       case Regexp.Op.STAR:
-        return this.star(this.compile(re2.subs[0]), (re2.flags & RE2Flags.NON_GREEDY) !== 0);
+        return this.star(state.sub, (re2.flags & RE2Flags.NON_GREEDY) !== 0);
       case Regexp.Op.PLUS:
-        return this.plus(this.compile(re2.subs[0]), (re2.flags & RE2Flags.NON_GREEDY) !== 0);
+        return this.plus(state.sub, (re2.flags & RE2Flags.NON_GREEDY) !== 0);
       case Regexp.Op.QUEST:
-        return this.quest(this.compile(re2.subs[0]), (re2.flags & RE2Flags.NON_GREEDY) !== 0);
+        return this.quest(state.sub, (re2.flags & RE2Flags.NON_GREEDY) !== 0);
       case Regexp.Op.CONCAT:
-        if (re2.subs.length === 0) return this.nop();
-        else {
-          let f = null;
-          for (let sub of re2.subs) {
-            const f1 = this.compile(sub);
-            f = f === null ? f1 : this.cat(f, f1);
-          }
-          return f;
-        }
       case Regexp.Op.ALTERNATE:
-        if (re2.subs.length === 0) return this.nop();
-        else {
-          let f = null;
-          for (let sub of re2.subs) {
-            const f1 = this.compile(sub);
-            f = f === null ? f1 : this.alt(f, f1);
-          }
-          return f;
-        }
+        return state.f;
       default:
         throw new RE2JSCompileException("regexp: unhandled case in compile");
     }
@@ -5325,111 +5575,155 @@ var Compiler = class Compiler2 {
 var Simplify = class Simplify2 {
   static simplify(re2) {
     if (re2 === null) return null;
+    return RegexpWalker.walk(re2, Simplify2.WALKER);
+  }
+  static WALKER = {
+    leaf: (re2) => Simplify2.leaf(re2),
+    enter: (re2) => Simplify2.enter(re2),
+    child: (re2, state, result, i) => Simplify2.child(re2, state, result, i),
+    leave: (re2, state) => Simplify2.leave(re2, state)
+  };
+  static leaf(re2) {
+    if (re2.op === Regexp.Op.CHAR_CLASS) {
+      if (re2.runes === null) return re2;
+      if (re2.runes.length === 0) return new Regexp(Regexp.Op.NO_MATCH);
+      if (re2.runes.length === 2 && re2.runes[0] === 0 && re2.runes[1] === Unicode.MAX_RUNE) return new Regexp(Regexp.Op.ANY_CHAR);
+      if (re2.runes.length === 4 && re2.runes[0] === 0 && re2.runes[1] === Codepoint.CODES.get("\n") - 1 && re2.runes[2] === Codepoint.CODES.get("\n") + 1 && re2.runes[3] === Unicode.MAX_RUNE) return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL);
+    }
+    return re2;
+  }
+  static enter(re2) {
+    switch (re2.op) {
+      case Regexp.Op.PLB:
+      case Regexp.Op.NLB:
+      case Regexp.Op.CAPTURE:
+      case Regexp.Op.STAR:
+      case Regexp.Op.PLUS:
+      case Regexp.Op.QUEST:
+        return { sub: null };
+      case Regexp.Op.CONCAT:
+      case Regexp.Op.ALTERNATE:
+        return {
+          subs: [],
+          changed: false
+        };
+      case Regexp.Op.REPEAT:
+        if (re2.min === 0 && re2.max === 0) return { result: new Regexp(Regexp.Op.EMPTY_MATCH) };
+        return { sub: null };
+      default:
+        return { result: re2 };
+    }
+  }
+  static child(re2, state, nsub, i) {
+    if (state.subs === void 0) {
+      state.sub = nsub;
+      return;
+    }
+    if (nsub !== re2.subs[i]) state.changed = true;
+    if (re2.op === Regexp.Op.CONCAT) {
+      if (nsub.op === Regexp.Op.NO_MATCH) {
+        state.result = new Regexp(Regexp.Op.NO_MATCH);
+        return;
+      }
+      if (nsub.op === Regexp.Op.EMPTY_MATCH) {
+        state.changed = true;
+        return;
+      }
+      if (nsub.op === Regexp.Op.CONCAT) {
+        state.changed = true;
+        for (let j = 0; j < nsub.subs.length; j++) state.subs.push(nsub.subs[j]);
+        return;
+      }
+    } else {
+      if (nsub.op === Regexp.Op.NO_MATCH) {
+        state.changed = true;
+        return;
+      }
+      if (nsub.op === Regexp.Op.ALTERNATE) {
+        state.changed = true;
+        for (let j = 0; j < nsub.subs.length; j++) state.subs.push(nsub.subs[j]);
+        return;
+      }
+    }
+    state.subs.push(nsub);
+  }
+  static leave(re2, state) {
     switch (re2.op) {
       case Regexp.Op.PLB:
       case Regexp.Op.NLB:
       case Regexp.Op.CAPTURE: {
-        const sub = Simplify2.simplify(re2.subs[0]);
+        const sub = state.sub;
         if (sub !== re2.subs[0]) {
           const nre = Regexp.fromRegexp(re2);
-          nre.runes = [];
+          nre.runes = /* @__PURE__ */ new Int32Array(0);
           nre.subs = [sub];
           return nre;
         }
         return re2;
       }
       case Regexp.Op.CONCAT:
-      case Regexp.Op.ALTERNATE: {
-        const newSubs = [];
-        let changed = false;
-        for (let i = 0; i < re2.subs.length; i++) {
-          const sub = re2.subs[i];
-          const nsub = Simplify2.simplify(sub);
-          if (nsub !== sub) changed = true;
-          if (re2.op === Regexp.Op.CONCAT) {
-            if (nsub.op === Regexp.Op.NO_MATCH) return new Regexp(Regexp.Op.NO_MATCH);
-            if (nsub.op === Regexp.Op.EMPTY_MATCH) {
-              changed = true;
-              continue;
-            }
-            if (nsub.op === Regexp.Op.CONCAT) {
-              changed = true;
-              for (let j = 0; j < nsub.subs.length; j++) newSubs.push(nsub.subs[j]);
-              continue;
-            }
-          } else if (re2.op === Regexp.Op.ALTERNATE) {
-            if (nsub.op === Regexp.Op.NO_MATCH) {
-              changed = true;
-              continue;
-            }
-            if (nsub.op === Regexp.Op.ALTERNATE) {
-              changed = true;
-              for (let j = 0; j < nsub.subs.length; j++) newSubs.push(nsub.subs[j]);
-              continue;
-            }
-          }
-          newSubs.push(nsub);
-        }
-        if (changed) {
+      case Regexp.Op.ALTERNATE:
+        if (state.changed) {
+          const newSubs = state.subs;
           if (newSubs.length === 0) return new Regexp(re2.op === Regexp.Op.CONCAT ? Regexp.Op.EMPTY_MATCH : Regexp.Op.NO_MATCH);
           if (newSubs.length === 1) return newSubs[0];
           const nre = Regexp.fromRegexp(re2);
-          nre.runes = [];
+          nre.runes = /* @__PURE__ */ new Int32Array(0);
           nre.subs = newSubs;
           return nre;
         }
         return re2;
-      }
-      case Regexp.Op.CHAR_CLASS:
-        if (re2.runes === null) return re2;
-        if (re2.runes.length === 0) return new Regexp(Regexp.Op.NO_MATCH);
-        if (re2.runes.length === 2 && re2.runes[0] === 0 && re2.runes[1] === Unicode.MAX_RUNE) return new Regexp(Regexp.Op.ANY_CHAR);
-        if (re2.runes.length === 4 && re2.runes[0] === 0 && re2.runes[1] === Codepoint.CODES.get("\n") - 1 && re2.runes[2] === Codepoint.CODES.get("\n") + 1 && re2.runes[3] === Unicode.MAX_RUNE) return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL);
-        return re2;
       case Regexp.Op.STAR:
       case Regexp.Op.PLUS:
-      case Regexp.Op.QUEST: {
-        const sub = Simplify2.simplify(re2.subs[0]);
-        return Simplify2.simplify1(re2.op, re2.flags, sub, re2);
-      }
-      case Regexp.Op.REPEAT: {
-        if (re2.min === 0 && re2.max === 0) return new Regexp(Regexp.Op.EMPTY_MATCH);
-        const sub = Simplify2.simplify(re2.subs[0]);
-        if (re2.max === -1) {
-          if (re2.min === 0) return Simplify2.simplify1(Regexp.Op.STAR, re2.flags, sub, null);
-          if (re2.min === 1) return Simplify2.simplify1(Regexp.Op.PLUS, re2.flags, sub, null);
-          const nre = new Regexp(Regexp.Op.CONCAT);
-          const subs = [];
-          for (let i = 0; i < re2.min - 1; i++) subs.push(sub);
-          subs.push(Simplify2.simplify1(Regexp.Op.PLUS, re2.flags, sub, null));
-          nre.subs = subs.slice(0);
-          return Simplify2.simplify(nre);
-        }
-        if (re2.min === 1 && re2.max === 1) return sub;
-        let prefixSubs = null;
-        if (re2.min > 0) {
-          prefixSubs = [];
-          for (let i = 0; i < re2.min; i++) prefixSubs.push(sub);
-        }
-        if (re2.max > re2.min) {
-          let suffix = Simplify2.simplify1(Regexp.Op.QUEST, re2.flags, sub, null);
-          for (let i = re2.min + 1; i < re2.max; i++) {
-            const nre2 = new Regexp(Regexp.Op.CONCAT);
-            nre2.subs = [sub, suffix];
-            suffix = Simplify2.simplify1(Regexp.Op.QUEST, re2.flags, nre2, null);
-          }
-          if (prefixSubs === null) return suffix;
-          prefixSubs.push(suffix);
-        }
-        if (prefixSubs !== null) {
-          const prefix = new Regexp(Regexp.Op.CONCAT);
-          prefix.subs = prefixSubs.slice(0);
-          return Simplify2.simplify(prefix);
-        }
-        return new Regexp(Regexp.Op.NO_MATCH);
+      case Regexp.Op.QUEST:
+        return Simplify2.simplify1(re2.op, re2.flags, state.sub, re2);
+      case Regexp.Op.REPEAT:
+        return Simplify2.simplifyRepeat(re2, state.sub);
+      default:
+        return re2;
+    }
+  }
+  static simplifyRepeat(re2, sub) {
+    if (re2.max === -1) {
+      if (re2.min === 0) return Simplify2.simplify1(Regexp.Op.STAR, re2.flags, sub, null);
+      if (re2.min === 1) return Simplify2.simplify1(Regexp.Op.PLUS, re2.flags, sub, null);
+      const subs = [];
+      for (let i = 0; i < re2.min - 1; i++) subs.push(sub);
+      subs.push(Simplify2.simplify1(Regexp.Op.PLUS, re2.flags, sub, null));
+      return Simplify2.concat(subs);
+    }
+    if (re2.min === 1 && re2.max === 1) return sub;
+    let prefixSubs = null;
+    if (re2.min > 0) {
+      prefixSubs = [];
+      for (let i = 0; i < re2.min; i++) prefixSubs.push(sub);
+    }
+    if (re2.max > re2.min) {
+      let suffix = Simplify2.simplify1(Regexp.Op.QUEST, re2.flags, sub, null);
+      for (let i = re2.min + 1; i < re2.max; i++) suffix = Simplify2.simplify1(Regexp.Op.QUEST, re2.flags, Simplify2.concat([sub, suffix]), null);
+      if (prefixSubs === null) return suffix;
+      prefixSubs.push(suffix);
+    }
+    if (prefixSubs !== null) return Simplify2.concat(prefixSubs);
+    return new Regexp(Regexp.Op.NO_MATCH);
+  }
+  static concat(subs) {
+    const newSubs = [];
+    for (let i = 0; i < subs.length; i++) {
+      const sub = subs[i];
+      if (sub.op === Regexp.Op.NO_MATCH) return new Regexp(Regexp.Op.NO_MATCH);
+      if (sub.op === Regexp.Op.EMPTY_MATCH) continue;
+      if (sub.op === Regexp.Op.CONCAT) {
+        for (let j = 0; j < sub.subs.length; j++) newSubs.push(sub.subs[j]);
+        continue;
       }
+      newSubs.push(sub);
     }
-    return re2;
+    if (newSubs.length === 0) return new Regexp(Regexp.Op.EMPTY_MATCH);
+    if (newSubs.length === 1) return newSubs[0];
+    const nre = new Regexp(Regexp.Op.CONCAT);
+    nre.subs = newSubs;
+    return nre;
   }
   static simplify1(op, flags, sub, re2) {
     if (sub.op === Regexp.Op.EMPTY_MATCH) return sub;
@@ -5587,46 +5881,35 @@ var CharClass = class CharClass2 {
     result += "]";
     return result;
   }
-  static cmp(array, i, pivotFrom, pivotTo) {
-    const cmp = array[i] - pivotFrom;
-    return cmp !== 0 ? cmp : pivotTo - array[i + 1];
-  }
-  static qsortIntPair(array, left, right) {
-    const pivotIndex = ((left + right) / 2 | 0) & -2;
-    const pivotFrom = array[pivotIndex];
-    const pivotTo = array[pivotIndex + 1];
-    let i = left;
-    let j = right;
-    while (i <= j) {
-      while (i < right && CharClass2.cmp(array, i, pivotFrom, pivotTo) < 0) i += 2;
-      while (j > left && CharClass2.cmp(array, j, pivotFrom, pivotTo) > 0) j -= 2;
-      if (i <= j) {
-        if (i !== j) {
-          let temp = array[i];
-          array[i] = array[j];
-          array[j] = temp;
-          temp = array[i + 1];
-          array[i + 1] = array[j + 1];
-          array[j + 1] = temp;
-        }
-        i += 2;
-        j -= 2;
-      }
+  static sortRanges(array, len) {
+    const n = len >> 1;
+    const order = new Array(n);
+    for (let i = 0; i < n; i++) order[i] = i;
+    order.sort((a, b) => array[2 * a] - array[2 * b] || array[2 * b + 1] - array[2 * a + 1]);
+    const sorted = array.slice(0, len);
+    for (let i = 0; i < n; i++) {
+      array[2 * i] = sorted[2 * order[i]];
+      array[2 * i + 1] = sorted[2 * order[i] + 1];
     }
-    if (left < j) CharClass2.qsortIntPair(array, left, j);
-    if (i < right) CharClass2.qsortIntPair(array, i, right);
   }
   constructor(r = Utils.emptyInts()) {
     this.r = r;
     this.len = r.length;
   }
   toArray() {
-    if (this.len === this.r.length) return this.r;
-    else return this.r.slice(0, this.len);
+    if (this.r instanceof Int32Array) return this.len === this.r.length ? this.r : this.r.subarray(0, this.len);
+    return new Int32Array(this.len === this.r.length ? this.r : this.r.slice(0, this.len));
+  }
+  toGrowableArray() {
+    if (Array.isArray(this.r)) {
+      this.r.length = this.len;
+      return this.r;
+    }
+    return Array.from(this.r.subarray(0, this.len));
   }
   cleanClass() {
     if (this.len < 4) return this;
-    CharClass2.qsortIntPair(this.r, 0, this.len - 2);
+    CharClass2.sortRanges(this.r, this.len);
     let w = 2;
     for (let i = 2; i < this.len; i += 2) {
       const lo = this.r[i];
@@ -5823,7 +6106,7 @@ var Parser = class Parser2 {
   static ERR_LARGE = "expression too large";
   static ERR_INVALID_CAPTURE_IN_LOOKBEHIND = "invalid capture in lookbehind";
   static MAX_HEIGHT = 1e3;
-  static MAX_SIZE = 3355443;
+  static MAX_SIZE = 1398101;
   static MAX_RUNES = 33554432;
   static ANY_TABLE = new UnicodeRangeTable(new Uint32Array([
     0,
@@ -5969,15 +6252,17 @@ var Parser = class Parser2 {
       case Regexp.Op.ANY_CHAR_NOT_NL:
         if (Parser2.matchRune(src, Codepoint.CODES.get("\n"))) dst.op = Regexp.Op.ANY_CHAR;
         break;
-      case Regexp.Op.CHAR_CLASS:
-        if (src.op === Regexp.Op.LITERAL) dst.runes = new CharClass(dst.runes).appendLiteral(src.runes[0], src.flags).toArray();
-        else dst.runes = new CharClass(dst.runes).appendClass(src.runes).toArray();
+      case Regexp.Op.CHAR_CLASS: {
+        const cc = new CharClass(Array.isArray(dst.runes) ? dst.runes : Array.from(dst.runes));
+        if (src.op === Regexp.Op.LITERAL) cc.appendLiteral(src.runes[0], src.flags);
+        else cc.appendClass(src.runes);
+        dst.runes = cc.toGrowableArray();
         break;
+      }
       case Regexp.Op.LITERAL:
         if (src.runes[0] === dst.runes[0] && src.flags === dst.flags) break;
         dst.op = Regexp.Op.CHAR_CLASS;
-        dst.runes = new CharClass().appendLiteral(dst.runes[0], dst.flags).appendLiteral(src.runes[0], src.flags).toArray();
-        break;
+        dst.runes = new CharClass().appendLiteral(dst.runes[0], dst.flags).appendLiteral(src.runes[0], src.flags).toGrowableArray();
     }
   }
   static parseEscape(t) {
@@ -6043,7 +6328,6 @@ var Parser = class Parser2 {
         return Codepoint.CODES.get("\v");
       default:
         if (c <= Unicode.MAX_ASCII && !Utils.isalnum(c)) return c;
-        break;
     }
     throw new RE2JSSyntaxException(Parser2.ERR_INVALID_ESCAPE, t.from(startPos));
   }
@@ -6052,10 +6336,6 @@ var Parser = class Parser2 {
     if (t.lookingAt("\\")) return Parser2.parseEscape(t);
     return t.pop();
   }
-  static concatRunes(x, y) {
-    for (let i = 0; i < y.length; i++) x.push(y[i]);
-    return x;
-  }
   static hasCapture(re2) {
     if (re2 === null) return false;
     if (re2.op === Regexp.Op.CAPTURE) return true;
@@ -6186,9 +6466,7 @@ var Parser = class Parser2 {
     const n = this.stack.length;
     let i = n;
     while (i > 0 && !Regexp.isPseudoOp(this.stack[i - 1].op)) i--;
-    const r = this.stack.slice(i, n);
-    this.stack = this.stack.slice(0, i);
-    return r;
+    return this.stack.splice(i, n - i);
   }
   push(re2) {
     this.numRunes += re2.runes.length;
@@ -6213,7 +6491,8 @@ var Parser = class Parser2 {
     const re1 = this.stack[n - 1];
     const re2 = this.stack[n - 2];
     if (re1.op !== Regexp.Op.LITERAL || re2.op !== Regexp.Op.LITERAL || (re1.flags & RE2Flags.FOLD_CASE) !== (re2.flags & RE2Flags.FOLD_CASE)) return false;
-    re2.runes = Parser2.concatRunes(re2.runes, re1.runes);
+    if (!Array.isArray(re2.runes)) re2.runes = Array.from(re2.runes);
+    for (let i = 0; i < re1.runes.length; i++) re2.runes.push(re1.runes[i]);
     if (r >= 0) {
       re1.runes = [r];
       re1.flags = flags;
@@ -6285,12 +6564,12 @@ var Parser = class Parser2 {
   }
   cleanAlt(re2) {
     if (re2.op === Regexp.Op.CHAR_CLASS) {
-      re2.runes = new CharClass(re2.runes).cleanClass().toArray();
+      re2.runes = new CharClass(Array.from(re2.runes)).cleanClass().toArray();
       if (re2.runes.length === 2 && re2.runes[0] === 0 && re2.runes[1] === Unicode.MAX_RUNE) {
-        re2.runes = [];
+        re2.runes = /* @__PURE__ */ new Int32Array(0);
         re2.op = Regexp.Op.ANY_CHAR;
       } else if (re2.runes.length === 4 && re2.runes[0] === 0 && re2.runes[1] === Codepoint.CODES.get("\n") - 1 && re2.runes[2] === Codepoint.CODES.get("\n") + 1 && re2.runes[3] === Unicode.MAX_RUNE) {
-        re2.runes = [];
+        re2.runes = /* @__PURE__ */ new Int32Array(0);
         re2.op = Regexp.Op.ANY_CHAR_NOT_NL;
       }
     }
@@ -6455,7 +6734,6 @@ var Parser = class Parser2 {
           }
           default:
             re2.subs = re2.subs.slice(1, re2.subs.length);
-            break;
         }
       }
       return re2;
@@ -6556,7 +6834,6 @@ var Parser = class Parser2 {
               break;
             case Codepoint.CODES.get("?"):
               op = Regexp.Op.QUEST;
-              break;
           }
           this.repeat(op, min, max, repeatPos, t, lastRepeatPos);
           break;
@@ -6610,7 +6887,6 @@ var Parser = class Parser2 {
               break bigswitch;
             default:
               t.rewindTo(savedPos);
-              break;
           }
           else t.rewindTo(savedPos);
           const re2 = this.newRegexp(Regexp.Op.CHAR_CLASS);
@@ -6636,7 +6912,6 @@ var Parser = class Parser2 {
         }
         default:
           this.literal(t.pop());
-          break;
       }
       lastRepeatPos = repeatPos;
     }
@@ -6835,7 +7110,7 @@ var Parser = class Parser2 {
     if ((this.flags & RE2Flags.FOLD_CASE) === 0 || fold === null) cc.appendTableWithSign(tab, sign);
     else {
       const tmp = new CharClass().appendTable(tab).appendTable(fold).cleanClass().toArray();
-      cc.appendClassWithSign(tmp, sign);
+      cc.appendClassWithSign(Array.from(tmp), sign);
     }
     return true;
   }
@@ -7001,7 +7276,10 @@ var RE2 = class RE22 {
     }
     return [];
   }
-  executeEngine(input, pos, anchor, ncap) {
+  createLookbehindState() {
+    return this.prog.numLb > 0 ? new LookbehindState(this.prog) : null;
+  }
+  executeEngine(input, pos, anchor, ncap, lbState = null) {
     if (this.prefixComplete && (ncap === 0 || this.numSubexp === 0)) return this.matchPrefixComplete(input, pos, anchor, ncap);
     if (this.prefilter !== null && anchor === RE2Flags.UNANCHORED) {
       if (!this.prefilter.eval(input, pos)) return null;
@@ -7009,14 +7287,14 @@ var RE2 = class RE22 {
     if (this.onepass !== null) return OnePass.execute(this, input, pos, anchor, ncap);
     if (ncap > 0) {
       if (this.prog.numLb === 0 && input.endPos() <= Backtracker.maxBitStateLen(this.prog)) return Backtracker.execute(this, input, pos, anchor, ncap);
-      return this.doExecuteNFA(input, pos, anchor, ncap);
+      return this.doExecuteNFA(input, pos, anchor, ncap, lbState);
     }
     if (this.prog.numLb === 0) {
       const dfaResult = this.dfa.match(input, pos, anchor);
       if (dfaResult !== null) return dfaResult ? [] : null;
       if (input.endPos() <= Backtracker.maxBitStateLen(this.prog)) return Backtracker.execute(this, input, pos, anchor, ncap);
     }
-    return this.doExecuteNFA(input, pos, anchor, ncap);
+    return this.doExecuteNFA(input, pos, anchor, ncap, lbState);
   }
   /**
   * Returns the number of parenthesized subexpressions in this regular expression.
@@ -7042,11 +7320,11 @@ var RE2 = class RE22 {
   toString() {
     return this.expr;
   }
-  doExecuteNFA(input, pos, anchor, ncap) {
+  doExecuteNFA(input, pos, anchor, ncap, lbState = null) {
     let m = this.get();
     if (!m) m = Machine.fromRE2(this);
     m.init(ncap);
-    const cap = m.match(input, pos, anchor) ? m.submatches() : null;
+    const cap = m.match(input, pos, anchor, lbState) ? m.submatches() : null;
     this.put(m);
     return cap;
   }
@@ -7065,17 +7343,21 @@ var RE2 = class RE22 {
   * @param anchor the anchoring flag (UNANCHORED, ANCHOR_START, ANCHOR_BOTH)
   * @param group the array to fill with submatch positions
   * @param ngroup the number of array pairs to fill in
+  * @param lbState optional state carried between successive matches over the same input (see
+  *   createLookbehindState); omit it to evaluate lookbehinds from the beginning of the input
   * @returns true if a match was found
   */
-  matchWithGroup(input, start, end, anchor, ngroup) {
-    if (!(input instanceof MatcherInputBase)) if (Utils.isByteArray(input)) input = MatcherInput.utf8(input);
-    else input = MatcherInput.utf16(input);
-    return this.matchMachineInput(input, start, end, anchor, ngroup);
+  matchWithGroup(input, start, end, anchor, ngroup, lbState = null) {
+    if (!(input instanceof MatcherInputBase)) {
+      if (Utils.isByteArray(input)) input = MatcherInput.utf8(input);
+      else input = MatcherInput.utf16(input);
+    }
+    return this.matchMachineInput(input, start, end, anchor, ngroup, lbState);
   }
-  matchMachineInput(input, start, end, anchor, ngroup) {
+  matchMachineInput(input, start, end, anchor, ngroup, lbState = null) {
     if (start > end) return [false, null];
     const machineInput = input.isUTF16Encoding() ? MachineInput.fromUTF16(input.asCharSequence(), 0, end) : MachineInput.fromUTF8(input.asBytes(), 0, end);
-    const groupMatch = this.executeEngine(machineInput, start, anchor, 2 * ngroup);
+    const groupMatch = this.executeEngine(machineInput, start, anchor, 2 * ngroup, lbState);
     if (groupMatch === null) return [false, null];
     return [true, groupMatch];
   }
@@ -7112,9 +7394,10 @@ var RE2 = class RE22 {
     let searchPos = 0;
     let out = "";
     const input = MachineInput.fromUTF16(src);
+    const lbState = this.createLookbehindState();
     let numReplaces = 0;
     while (searchPos <= src.length) {
-      const a = this.executeEngine(input, searchPos, RE2Flags.UNANCHORED, 2);
+      const a = this.executeEngine(input, searchPos, RE2Flags.UNANCHORED, 2, lbState);
       if (a === null || a.length === 0) break;
       out += src.substring(lastMatchEnd, a[0]);
       if (a[1] > lastMatchEnd || a[0] === 0) {
@@ -7148,8 +7431,9 @@ var RE2 = class RE22 {
     let pos = 0;
     let i = 0;
     let prevMatchEnd = -1;
+    const lbState = this.createLookbehindState();
     while (i < n && pos <= end) {
-      const matches = this.executeEngine(input, pos, RE2Flags.UNANCHORED, this.prog.numCap);
+      const matches = this.executeEngine(input, pos, RE2Flags.UNANCHORED, this.prog.numCap, lbState);
       if (matches === null || matches.length === 0) break;
       let accept = true;
       if (matches[1] === pos) {
@@ -7417,7 +7701,9 @@ var RE2Set = class RE2Set2 {
   */
   compile() {
     if (this.prog) return;
-    this.prog = Compiler.compileSet(this.regexps);
+    const prog = Compiler.compileSet(this.regexps);
+    if (prog.numInst() > Parser.MAX_SIZE) throw new RE2JSCompileException(`${Parser.ERR_LARGE}: the set compiles to ${prog.numInst()} instructions, more than ${Parser.MAX_SIZE}`);
+    this.prog = prog;
     this.dfa = new DFA(this.prog, this.maxMem);
     this.dummyRe2 = {
       prog: this.prog,