re2js 2.8.6 → 2.8.7

package/build/index.umd.js

@@ -2,10 +2,10 @@
 * re2js
 * RE2JS is the JavaScript port of RE2, a regular expression engine that provides linear time matching
 *
-* @version v2.8.6
+* @version v2.8.7
 * @author Oleksii Vasyliev
 * @homepage https://github.com/le0pard/re2js#readme
-* @repository github:le0pard/re2js
+* @repository [object Object]
 * @license MIT
 */
 (function(global, factory) {
@@ -503,6 +503,10 @@
 	*/
 	var Unicode = class Unicode {
 		static MAX_RUNE = 1114111;
+		static RUNE_ERROR = 65533;
+		static isUnsearchable(r) {
+			return r === Unicode.RUNE_ERROR || r >= Unicode.MIN_HIGH_SURROGATE && r <= Unicode.MAX_LOW_SURROGATE;
+		}
 		static MAX_ASCII = 127;
 		static MAX_LATIN1 = 255;
 		static MAX_BMP = 65535;
@@ -605,7 +609,7 @@
 			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");
@@ -664,7 +668,7 @@
 				runes.push(cp);
 				i += cp > Unicode.MAX_BMP ? 2 : 1;
 			}
-			return runes;
+			return new Int32Array(runes);
 		}
 		static runeToString(r) {
 			return String.fromCodePoint(r);
@@ -791,7 +795,7 @@
 		asCharSequence() {
 			throw Error("not implemented");
 		}
-		/** @returns {Uint8Array|number[]} */
+		/** @returns {Uint8Array|number[]|null} */
 		asBytes() {
 			throw Error("not implemented");
 		}
@@ -922,7 +926,8 @@
 			return 0;
 		}
 	};
-	var MachineUTF8Input = class extends MachineInputBase {
+	var MachineUTF8Input = class MachineUTF8Input extends MachineInputBase {
+		static RUNE_ERROR_STEP = Unicode.RUNE_ERROR << 3 | 1;
 		constructor(bytes, start = 0, end = bytes.length) {
 			super();
 			this.bytes = bytes;
@@ -936,33 +941,46 @@
 			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 MachineUTF8Input.RUNE_ERROR_STEP;
+			if (pos + size > this.end) return MachineUTF8Input.RUNE_ERROR_STEP;
+			const c1 = this.bytes[pos + 1] & 255;
+			if (c1 < lo || c1 > hi) return MachineUTF8Input.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 MachineUTF8Input.RUNE_ERROR_STEP;
+				rune = rune << 6 | c2 & 63;
+				if (size > 3) {
+					const c3 = this.bytes[pos + 3] & 255;
+					if ((c3 & 192) !== 128) return MachineUTF8Input.RUNE_ERROR_STEP;
+					rune = rune << 6 | c3 & 63;
+				}
+			}
+			return rune << 3 | size;
 		}
 		index(re2, pos) {
 			pos += this.start;
@@ -1027,8 +1045,7 @@
 			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;
@@ -1221,6 +1238,8 @@
 			this.namedGroups = re2.namedGroups;
 			/** @type {number} */
 			this.numberOfInstructions = re2.numberOfInstructions();
+			/** @type {import('./Machine.js').LookbehindState|null} */
+			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));
@@ -1254,9 +1273,13 @@
 		*/
 		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;
 		}
@@ -1344,11 +1367,11 @@
 		* @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;
@@ -1381,7 +1404,7 @@
 		*/
 		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);
 			}
@@ -1404,7 +1427,7 @@
 		* @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;
@@ -1733,7 +1756,8 @@
 			this.op = op;
 			this.out = 0;
 			this.arg = 0;
-			this.runes = [];
+			/** @type {Int32Array} */
+			this.runes = /* @__PURE__ */ new Int32Array(0);
 			/** @type {Uint32Array | number[] | null} */
 			this.next = null;
 		}
@@ -1822,19 +1846,27 @@
 	};
 	//#endregion
 	//#region src/Machine.js
-	var Queue = class {
+	var Queue = class Queue {
 		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, Queue.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;
@@ -1850,6 +1882,7 @@
 		}
 		clear() {
 			this.size = 0;
+			this.mainThreads = 0;
 		}
 		toString() {
 			let out = "{";
@@ -1861,6 +1894,18 @@
 			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 Machine {
 		static fromRE2(re2) {
 			const m = new Machine();
@@ -1868,19 +1913,18 @@
 			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 Machine.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;
@@ -1901,14 +1945,23 @@
 			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);
@@ -1924,12 +1977,16 @@
 			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;
@@ -1942,9 +1999,12 @@
 						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);
 					}
@@ -1966,6 +2026,7 @@
 				runq = nextq;
 				nextq = tmpq;
 			}
+			runq.clear();
 			nextq.clear();
 			return this.matched;
 		}
@@ -1989,12 +2050,12 @@
 			}
 			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);
 				}
@@ -2079,65 +2140,85 @@
 			}
 			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 {
-						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.EMPTY_WIDTH:
+							pc = (inst.arg & ~cond) === 0 ? inst.out : 0;
+							break;
+						case Inst.NOP:
+							pc = inst.out;
+							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;
 			}
 		}
 	};
@@ -2157,35 +2238,85 @@
 		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 DFA {
-		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 / DFA.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;
@@ -2194,7 +2325,7 @@
 				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:
@@ -2211,11 +2342,11 @@
 				}
 			}
 			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) {
@@ -2226,156 +2357,126 @@
 			let bucket = this.stateCache.get(hash);
 			if (bucket) for (let i = 0; i < bucket.length; i++) {
 				const state = bucket[i];
-				if (arraysEqual(state.nfaStates, sortedPCs)) {
-					state.lastSeen = ++this.clock;
-					return state;
-				}
+				if (arraysEqual(state.nfaStates, sortedPCs)) return state;
 			}
-			else {
+			const cost = DFA.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 >= DFA.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 = DFA.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;
+			this.startState = null;
+			this.memBudget = this.stateBudget;
 		}
-		step(state, charCode, anchor) {
-			if (charCode <= Unicode.MAX_LATIN1) if (anchor === RE2Flags.UNANCHORED) {
-				const next = state.nextLatin1[charCode];
-				if (next !== null) return next;
+		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 < DFA.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);
 		}
 	};
@@ -2384,7 +2485,7 @@
 	const VISITED_BITS = 32;
 	const MAX_BACKTRACK_PROG = 500;
 	const INITIAL_JOB_CAPACITY = 256;
-	const MAX_BACKTRACK_VECTOR = 256 * 1024;
+	const MAX_BACKTRACK_VECTOR = 262144;
 	var BitState = class {
 		constructor() {
 			this.end = 0;
@@ -2667,7 +2768,7 @@
 				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;
 			}
@@ -2737,7 +2838,7 @@
 					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;
 				}
@@ -2746,7 +2847,7 @@
 				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:
@@ -2758,7 +2859,7 @@
 					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;
 					}
@@ -2769,7 +2870,7 @@
 						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;
@@ -2785,7 +2886,7 @@
 						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;
@@ -2794,21 +2895,20 @@
 					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;
 		};
@@ -2840,8 +2940,7 @@
 				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);
 			}
 		}
 	};
@@ -2870,9 +2969,7 @@
 							return null;
 						}
 						break;
-					default:
-						if (opOut === Inst.MATCH && hasAlt) return null;
-						break;
+					default: if (opOut === Inst.MATCH && hasAlt) return null;
 				}
 			}
 			let p = onePassCopy(prog);
@@ -3023,7 +3120,7 @@
 			this.op = op;
 			this.flags = 0;
 			this.subs = Regexp.emptySubs();
-			this.runes = [];
+			this.runes = /* @__PURE__ */ new Int32Array(0);
 			this.min = 0;
 			this.max = 0;
 			this.cap = 0;
@@ -3034,7 +3131,7 @@
 		reinit() {
 			this.flags = 0;
 			this.subs = Regexp.emptySubs();
-			this.runes = [];
+			this.runes = /* @__PURE__ */ new Int32Array(0);
 			this.cap = 0;
 			this.min = 0;
 			this.max = 0;
@@ -3078,7 +3175,6 @@
 								if (this.max >= 0) out += this.max;
 							}
 							out += "}";
-							break;
 					}
 					if ((this.flags & RE2Flags.NON_GREEDY) !== 0) out += "?";
 					break;
@@ -3171,9 +3267,7 @@
 					}
 					out += "]";
 					break;
-				default:
-					out += this.op;
-					break;
+				default: out += this.op;
 			}
 			return out;
 		}
@@ -3217,70 +3311,158 @@
 					if (this.cap !== that.cap || (this.name === null ? that.name !== null : this.name !== that.name) || !this.subs[0].equals(that.subs[0])) return false;
 					break;
 				case Regexp.Op.PLB:
-				case Regexp.Op.NLB:
-					if (this.lb !== that.lb || !this.subs[0].equals(that.subs[0])) return false;
-					break;
+				case Regexp.Op.NLB: if (this.lb !== that.lb || !this.subs[0].equals(that.subs[0])) return false;
 			}
 			return true;
 		}
 	};
 	//#endregion
+	//#region src/RegexpWalker.js
+	/**
+	* Walks a Regexp tree without recursion, visiting nodes in the same order a recursive walk
+	* would (RE2: re2/walker-inl.h, "Helper class for traversing Regexps without recursion").
+	*
+	* The handler sees a node without subexpressions once, through `leaf(re)`, which returns its
+	* result. Any other node is seen up to three times:
+	* - `enter(re)` before its children. It returns the state kept for `re` while its children are
+	*   visited; a state whose `result` is already set skips the children.
+	* - `child(re, state, result, i)` after child `i` produced `result`. Setting `state.result`
+	*   stops visiting the remaining children.
+	* - `leave(re, state)` after the last child; it returns the result for `re`.
+	*
+	* Counted repetitions expand into one nesting level per copy, so the simplified tree can be
+	* thousands of levels deep; recursion over it would overflow the JS stack, which has no fixed
+	* relation to the parser's nesting limit. This walk keeps its frames on the heap instead.
+	*/
+	var RegexpWalker = class {
+		static walk(root, handler) {
+			const stack = [];
+			let re = root;
+			let result;
+			for (;;) {
+				if (re.subs.length === 0) result = handler.leaf(re);
+				else {
+					const state = handler.enter(re);
+					if (state.result === void 0) {
+						stack.push({
+							re,
+							state,
+							i: 0
+						});
+						re = re.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) {
+						re = frame.re.subs[frame.i];
+						break;
+					}
+					stack.pop();
+					result = frame.state.result !== void 0 ? frame.state.result : handler.leave(frame.re, frame.state);
+				}
+			}
+		}
+	};
+	//#endregion
 	//#region src/Prefilter.js
 	var AhoCorasick = class {
-		constructor(wordArrays) {
-			this.next = [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(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 = this.next[node][val];
+					node = child;
 				}
-				this.match[node] = true;
-			}
-			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);
+				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]);
+					}
+					fail[c] = next >= 0 ? next : 0;
 				}
+				match[c] |= match[fail[c]];
+			}
+			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;
+			}
+			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;
 		}
@@ -3292,14 +3474,33 @@
 			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 === Prefilter.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 Prefilter.Type.NONE: return true;
@@ -3308,7 +3509,7 @@
 					for (let i = 0; i < this.subs.length; i++) if (!this.subs[i].eval(input, pos)) return false;
 					return true;
 				case Prefilter.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: return true;
@@ -3317,100 +3518,115 @@
 	};
 	var PrefilterTree = class PrefilterTree {
 		static build(re) {
-			const pf = PrefilterTree.fromRegexp(re);
-			return PrefilterTree.simplify(pf);
-		}
-		static fromRegexp(re) {
 			if (!re) return new Prefilter(Prefilter.Type.NONE);
+			return RegexpWalker.walk(re, PrefilterTree.WALKER);
+		}
+		static WALKER = {
+			leaf: (re) => PrefilterTree.leaf(re),
+			enter: (re) => PrefilterTree.enter(re),
+			child: (re, state, result) => PrefilterTree.child(re, state, result),
+			leave: (re, state) => PrefilterTree.leave(re, state)
+		};
+		static leaf(re) {
+			if (re.op !== Regexp.Op.LITERAL) return new Prefilter(Prefilter.Type.NONE);
+			if (re.runes.length === 0 || (re.flags & RE2Flags.FOLD_CASE) !== 0) return new Prefilter(Prefilter.Type.NONE);
+			let str = "";
+			for (let i = 0; i < re.runes.length; i++) {
+				if (Unicode.isUnsearchable(re.runes[i])) return new Prefilter(Prefilter.Type.NONE);
+				str += String.fromCodePoint(re.runes[i]);
+			}
+			const pf = new Prefilter(Prefilter.Type.EXACT);
+			pf.str = str;
+			pf.bytes = Utils.stringToUtf8ByteArray(pf.str);
+			return pf;
+		}
+		static enter(re) {
 			switch (re.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 (re.runes.length === 0 || (re.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 < re.runes.length; i++) str += String.fromCodePoint(re.runes[i]);
-					pf.str = str;
-					pf.bytes = Utils.stringToUtf8ByteArray(pf.str);
-					return pf;
-				}
 				case Regexp.Op.CAPTURE:
-				case Regexp.Op.PLUS: return PrefilterTree.fromRegexp(re.subs[0]);
+				case Regexp.Op.PLUS: return { sub: null };
 				case Regexp.Op.REPEAT:
-					if (re.min >= 1) return PrefilterTree.fromRegexp(re.subs[0]);
-					return new Prefilter(Prefilter.Type.NONE);
-				case Regexp.Op.CONCAT: {
-					const pf = new Prefilter(Prefilter.Type.AND);
-					for (const sub of re.subs) pf.subs.push(PrefilterTree.fromRegexp(sub));
-					return pf;
+					if (re.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 { result: new Prefilter(Prefilter.Type.NONE) };
+			}
+		}
+		static child(re, state, s) {
+			if (state.subs === void 0) {
+				state.sub = s;
+				return;
+			}
+			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;
 				}
-				case Regexp.Op.ALTERNATE: {
-					const pf = new Prefilter(Prefilter.Type.OR);
-					for (const sub of re.subs) pf.subs.push(PrefilterTree.fromRegexp(sub));
-					return pf;
+				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(re, 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);
 				}
-				default: return new Prefilter(Prefilter.Type.NONE);
+				subs.push(sub);
 			}
-		}
-		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 = PrefilterTree.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);
+				const kept = [];
+				let cost = 0;
+				for (const sub of subs) {
+					if (cost + sub.cost > Prefilter.MAX_SCANS) continue;
+					kept.push(sub);
+					cost += sub.cost;
 				}
-				if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE);
-				if (newSubs.length === 1) return newSubs[0];
-				pf.subs = newSubs;
+				if (kept.length === 0) return new Prefilter(Prefilter.Type.NONE);
+				if (kept.length === 1) return kept[0];
+				pf.subs = kept;
+				pf.cost = cost;
 				return pf;
 			}
-			if (pf.type === Prefilter.Type.OR) {
-				const newSubs = [];
-				for (const sub of pf.subs) {
-					const s = PrefilterTree.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 (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));
-				}
+			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;
 		}
 	};
@@ -3446,6 +3662,7 @@
 			this.numCap = 2;
 			this.lbStarts = [];
 			this.numLb = 0;
+			this.lbInst = null;
 		}
 		getInst(pc) {
 			return this.inst[pc];
@@ -3456,6 +3673,26 @@
 		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) {
@@ -3468,7 +3705,7 @@
 			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);
 			}
@@ -3532,6 +3769,13 @@
 	};
 	//#endregion
 	//#region src/Compiler.js
+	const ANY_RUNE_NOT_NL = new Int32Array([
+		0,
+		Codepoint.CODES.get("\n") - 1,
+		Codepoint.CODES.get("\n") + 1,
+		Unicode.MAX_RUNE
+	]);
+	const ANY_RUNE = new Int32Array([0, Unicode.MAX_RUNE]);
 	/**
 	* A fragment of a compiled regular expression program.
 	*
@@ -3551,28 +3795,19 @@
 	* The only entry point is {@link #compileRegexp}.
 	*/
 	var Compiler = class Compiler {
-		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(re) {
 			const c = new Compiler();
 			const f = c.compile(re);
 			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 Compiler();
 			if (regexps.length === 0) {
 				c.prog.start = c.newInst(Inst.FAIL).i;
+				c.prog.markLookbehindInsts();
 				return c.prog;
 			}
 			let starts = [];
@@ -3592,11 +3827,19 @@
 				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: (re) => this.leaf(re),
+				enter: (re) => this.enter(re),
+				child: (re, state, result) => this.child(re, state, result),
+				leave: (re, state) => this.leave(re, state)
+			};
 		}
 		newInst(op) {
 			this.prog.addInst(op);
@@ -3689,7 +3932,7 @@
 		lookBehind(a, lb) {
 			const id = this.newInst(Inst.LB_WRITE);
 			this.prog.getInst(id.i).arg = lb;
-			const any = this.rune(Compiler.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);
@@ -3701,56 +3944,74 @@
 			return checkId;
 		}
 		compile(re) {
+			return RegexpWalker.walk(re, this.walker);
+		}
+		leaf(re) {
 			switch (re.op) {
 				case Regexp.Op.NO_MATCH: return this.fail();
 				case Regexp.Op.EMPTY_MATCH: return this.nop();
-				case Regexp.Op.LITERAL: if (re.runes.length === 0) return this.nop();
-				else {
+				case Regexp.Op.LITERAL: {
+					if (re.runes.length === 0) return this.nop();
 					let f = null;
 					for (let r of re.runes) {
-						const f1 = this.rune([r], re.flags);
+						let singleRune = this.runeCache.get(r);
+						if (singleRune === void 0) {
+							singleRune = new Int32Array([r]);
+							this.runeCache.set(r, singleRune);
+						}
+						const f1 = this.rune(singleRune, re.flags);
 						f = f === null ? f1 : this.cat(f, f1);
 					}
 					return f;
 				}
 				case Regexp.Op.CHAR_CLASS: return this.rune(re.runes, re.flags);
-				case Regexp.Op.ANY_CHAR_NOT_NL: return this.rune(Compiler.ANY_RUNE_NOT_NL(), 0);
-				case Regexp.Op.ANY_CHAR: return this.rune(Compiler.ANY_RUNE(), 0);
+				case Regexp.Op.ANY_CHAR_NOT_NL: return this.rune(ANY_RUNE_NOT_NL, 0);
+				case Regexp.Op.ANY_CHAR: return this.rune(ANY_RUNE, 0);
 				case Regexp.Op.BEGIN_LINE: return this.empty(Utils.EMPTY_BEGIN_LINE);
 				case Regexp.Op.END_LINE: return this.empty(Utils.EMPTY_END_LINE);
 				case Regexp.Op.BEGIN_TEXT: return this.empty(Utils.EMPTY_BEGIN_TEXT);
 				case Regexp.Op.END_TEXT: return this.empty(Utils.EMPTY_END_TEXT);
 				case Regexp.Op.WORD_BOUNDARY: 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(re) {
+			switch (re.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(re.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(re, state, f1) {
+			if (re.op === Regexp.Op.CONCAT) state.f = state.f === null ? f1 : this.cat(state.f, f1);
+			else if (re.op === Regexp.Op.ALTERNATE) state.f = state.f === null ? f1 : this.alt(state.f, f1);
+			else state.sub = f1;
+		}
+		leave(re, state) {
+			switch (re.op) {
 				case Regexp.Op.PLB:
-				case Regexp.Op.NLB: return this.lookBehind(this.compile(re.subs[0]), re.lb);
+				case Regexp.Op.NLB: return this.lookBehind(state.sub, re.lb);
 				case Regexp.Op.CAPTURE: {
-					const bra = this.cap(re.cap << 1);
-					const sub = this.compile(re.subs[0]);
 					const ket = this.cap(re.cap << 1 | 1);
-					return this.cat(this.cat(bra, sub), ket);
-				}
-				case Regexp.Op.STAR: return this.star(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0);
-				case Regexp.Op.PLUS: return this.plus(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0);
-				case Regexp.Op.QUEST: return this.quest(this.compile(re.subs[0]), (re.flags & RE2Flags.NON_GREEDY) !== 0);
-				case Regexp.Op.CONCAT: if (re.subs.length === 0) return this.nop();
-				else {
-					let f = null;
-					for (let sub of re.subs) {
-						const f1 = this.compile(sub);
-						f = f === null ? f1 : this.cat(f, f1);
-					}
-					return f;
-				}
-				case Regexp.Op.ALTERNATE: if (re.subs.length === 0) return this.nop();
-				else {
-					let f = null;
-					for (let sub of re.subs) {
-						const f1 = this.compile(sub);
-						f = f === null ? f1 : this.alt(f, f1);
-					}
-					return f;
+					return this.cat(this.cat(state.bra, state.sub), ket);
 				}
+				case Regexp.Op.STAR: return this.star(state.sub, (re.flags & RE2Flags.NON_GREEDY) !== 0);
+				case Regexp.Op.PLUS: return this.plus(state.sub, (re.flags & RE2Flags.NON_GREEDY) !== 0);
+				case Regexp.Op.QUEST: return this.quest(state.sub, (re.flags & RE2Flags.NON_GREEDY) !== 0);
+				case Regexp.Op.CONCAT:
+				case Regexp.Op.ALTERNATE: return state.f;
 				default: throw new RE2JSCompileException("regexp: unhandled case in compile");
 			}
 		}
@@ -3760,111 +4021,149 @@
 	var Simplify = class Simplify {
 		static simplify(re) {
 			if (re === null) return null;
+			return RegexpWalker.walk(re, Simplify.WALKER);
+		}
+		static WALKER = {
+			leaf: (re) => Simplify.leaf(re),
+			enter: (re) => Simplify.enter(re),
+			child: (re, state, result, i) => Simplify.child(re, state, result, i),
+			leave: (re, state) => Simplify.leave(re, state)
+		};
+		static leaf(re) {
+			if (re.op === Regexp.Op.CHAR_CLASS) {
+				if (re.runes === null) return re;
+				if (re.runes.length === 0) return new Regexp(Regexp.Op.NO_MATCH);
+				if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) return new Regexp(Regexp.Op.ANY_CHAR);
+				if (re.runes.length === 4 && re.runes[0] === 0 && re.runes[1] === Codepoint.CODES.get("\n") - 1 && re.runes[2] === Codepoint.CODES.get("\n") + 1 && re.runes[3] === Unicode.MAX_RUNE) return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL);
+			}
+			return re;
+		}
+		static enter(re) {
+			switch (re.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 (re.min === 0 && re.max === 0) return { result: new Regexp(Regexp.Op.EMPTY_MATCH) };
+					return { sub: null };
+				default: return { result: re };
+			}
+		}
+		static child(re, state, nsub, i) {
+			if (state.subs === void 0) {
+				state.sub = nsub;
+				return;
+			}
+			if (nsub !== re.subs[i]) state.changed = true;
+			if (re.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(re, state) {
 			switch (re.op) {
 				case Regexp.Op.PLB:
 				case Regexp.Op.NLB:
 				case Regexp.Op.CAPTURE: {
-					const sub = Simplify.simplify(re.subs[0]);
+					const sub = state.sub;
 					if (sub !== re.subs[0]) {
 						const nre = Regexp.fromRegexp(re);
-						nre.runes = [];
+						nre.runes = /* @__PURE__ */ new Int32Array(0);
 						nre.subs = [sub];
 						return nre;
 					}
 					return re;
 				}
 				case Regexp.Op.CONCAT:
-				case Regexp.Op.ALTERNATE: {
-					const newSubs = [];
-					let changed = false;
-					for (let i = 0; i < re.subs.length; i++) {
-						const sub = re.subs[i];
-						const nsub = Simplify.simplify(sub);
-						if (nsub !== sub) changed = true;
-						if (re.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 (re.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(re.op === Regexp.Op.CONCAT ? Regexp.Op.EMPTY_MATCH : Regexp.Op.NO_MATCH);
 						if (newSubs.length === 1) return newSubs[0];
 						const nre = Regexp.fromRegexp(re);
-						nre.runes = [];
+						nre.runes = /* @__PURE__ */ new Int32Array(0);
 						nre.subs = newSubs;
 						return nre;
 					}
 					return re;
-				}
-				case Regexp.Op.CHAR_CLASS:
-					if (re.runes === null) return re;
-					if (re.runes.length === 0) return new Regexp(Regexp.Op.NO_MATCH);
-					if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) return new Regexp(Regexp.Op.ANY_CHAR);
-					if (re.runes.length === 4 && re.runes[0] === 0 && re.runes[1] === Codepoint.CODES.get("\n") - 1 && re.runes[2] === Codepoint.CODES.get("\n") + 1 && re.runes[3] === Unicode.MAX_RUNE) return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL);
-					return re;
 				case Regexp.Op.STAR:
 				case Regexp.Op.PLUS:
-				case Regexp.Op.QUEST: {
-					const sub = Simplify.simplify(re.subs[0]);
-					return Simplify.simplify1(re.op, re.flags, sub, re);
-				}
-				case Regexp.Op.REPEAT: {
-					if (re.min === 0 && re.max === 0) return new Regexp(Regexp.Op.EMPTY_MATCH);
-					const sub = Simplify.simplify(re.subs[0]);
-					if (re.max === -1) {
-						if (re.min === 0) return Simplify.simplify1(Regexp.Op.STAR, re.flags, sub, null);
-						if (re.min === 1) return Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null);
-						const nre = new Regexp(Regexp.Op.CONCAT);
-						const subs = [];
-						for (let i = 0; i < re.min - 1; i++) subs.push(sub);
-						subs.push(Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null));
-						nre.subs = subs.slice(0);
-						return Simplify.simplify(nre);
-					}
-					if (re.min === 1 && re.max === 1) return sub;
-					let prefixSubs = null;
-					if (re.min > 0) {
-						prefixSubs = [];
-						for (let i = 0; i < re.min; i++) prefixSubs.push(sub);
-					}
-					if (re.max > re.min) {
-						let suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, sub, null);
-						for (let i = re.min + 1; i < re.max; i++) {
-							const nre2 = new Regexp(Regexp.Op.CONCAT);
-							nre2.subs = [sub, suffix];
-							suffix = Simplify.simplify1(Regexp.Op.QUEST, re.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 Simplify.simplify(prefix);
-					}
-					return new Regexp(Regexp.Op.NO_MATCH);
+				case Regexp.Op.QUEST: return Simplify.simplify1(re.op, re.flags, state.sub, re);
+				case Regexp.Op.REPEAT: return Simplify.simplifyRepeat(re, state.sub);
+				default: return re;
+			}
+		}
+		static simplifyRepeat(re, sub) {
+			if (re.max === -1) {
+				if (re.min === 0) return Simplify.simplify1(Regexp.Op.STAR, re.flags, sub, null);
+				if (re.min === 1) return Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null);
+				const subs = [];
+				for (let i = 0; i < re.min - 1; i++) subs.push(sub);
+				subs.push(Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null));
+				return Simplify.concat(subs);
+			}
+			if (re.min === 1 && re.max === 1) return sub;
+			let prefixSubs = null;
+			if (re.min > 0) {
+				prefixSubs = [];
+				for (let i = 0; i < re.min; i++) prefixSubs.push(sub);
+			}
+			if (re.max > re.min) {
+				let suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, sub, null);
+				for (let i = re.min + 1; i < re.max; i++) suffix = Simplify.simplify1(Regexp.Op.QUEST, re.flags, Simplify.concat([sub, suffix]), null);
+				if (prefixSubs === null) return suffix;
+				prefixSubs.push(suffix);
+			}
+			if (prefixSubs !== null) return Simplify.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 re;
+			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, re) {
 			if (sub.op === Regexp.Op.EMPTY_MATCH) return sub;
@@ -4032,46 +4331,35 @@
 			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 && CharClass.cmp(array, i, pivotFrom, pivotTo) < 0) i += 2;
-				while (j > left && CharClass.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) CharClass.qsortIntPair(array, left, j);
-			if (i < right) CharClass.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;
-			CharClass.qsortIntPair(this.r, 0, this.len - 2);
+			CharClass.sortRanges(this.r, this.len);
 			let w = 2;
 			for (let i = 2; i < this.len; i += 2) {
 				const lo = this.r[i];
@@ -4275,7 +4563,7 @@
 		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,
@@ -4417,15 +4705,17 @@
 				case Regexp.Op.ANY_CHAR_NOT_NL:
 					if (Parser.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) {
@@ -4482,9 +4772,7 @@
 				case Codepoint.CODES.get("r"): return Codepoint.CODES.get("\r");
 				case Codepoint.CODES.get("t"): return Codepoint.CODES.get("	");
 				case Codepoint.CODES.get("v"): return Codepoint.CODES.get("\v");
-				default:
-					if (c <= Unicode.MAX_ASCII && !Utils.isalnum(c)) return c;
-					break;
+				default: if (c <= Unicode.MAX_ASCII && !Utils.isalnum(c)) return c;
 			}
 			throw new RE2JSSyntaxException(Parser.ERR_INVALID_ESCAPE, t.from(startPos));
 		}
@@ -4493,10 +4781,6 @@
 			if (t.lookingAt("\\")) return Parser.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(re) {
 			if (re === null) return false;
 			if (re.op === Regexp.Op.CAPTURE) return true;
@@ -4627,9 +4911,7 @@
 			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(re) {
 			this.numRunes += re.runes.length;
@@ -4654,7 +4936,8 @@
 			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 = Parser.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;
@@ -4726,12 +5009,12 @@
 		}
 		cleanAlt(re) {
 			if (re.op === Regexp.Op.CHAR_CLASS) {
-				re.runes = new CharClass(re.runes).cleanClass().toArray();
+				re.runes = new CharClass(Array.from(re.runes)).cleanClass().toArray();
 				if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) {
-					re.runes = [];
+					re.runes = /* @__PURE__ */ new Int32Array(0);
 					re.op = Regexp.Op.ANY_CHAR;
 				} else if (re.runes.length === 4 && re.runes[0] === 0 && re.runes[1] === Codepoint.CODES.get("\n") - 1 && re.runes[2] === Codepoint.CODES.get("\n") + 1 && re.runes[3] === Unicode.MAX_RUNE) {
-					re.runes = [];
+					re.runes = /* @__PURE__ */ new Int32Array(0);
 					re.op = Regexp.Op.ANY_CHAR_NOT_NL;
 				}
 			}
@@ -4891,9 +5174,7 @@
 							this.reuse(old);
 							break;
 						}
-						default:
-							re.subs = re.subs.slice(1, re.subs.length);
-							break;
+						default: re.subs = re.subs.slice(1, re.subs.length);
 					}
 				}
 				return re;
@@ -4992,9 +5273,7 @@
 							case Codepoint.CODES.get("+"):
 								op = Regexp.Op.PLUS;
 								break;
-							case Codepoint.CODES.get("?"):
-								op = Regexp.Op.QUEST;
-								break;
+							case Codepoint.CODES.get("?"): op = Regexp.Op.QUEST;
 						}
 						this.repeat(op, min, max, repeatPos, t, lastRepeatPos);
 						break;
@@ -5045,9 +5324,7 @@
 							case Codepoint.CODES.get("z"):
 								this.op(Regexp.Op.END_TEXT);
 								break bigswitch;
-							default:
-								t.rewindTo(savedPos);
-								break;
+							default: t.rewindTo(savedPos);
 						}
 						else t.rewindTo(savedPos);
 						const re = this.newRegexp(Regexp.Op.CHAR_CLASS);
@@ -5071,9 +5348,7 @@
 						this.literal(Parser.parseEscape(t));
 						break;
 					}
-					default:
-						this.literal(t.pop());
-						break;
+					default: this.literal(t.pop());
 				}
 				lastRepeatPos = repeatPos;
 			}
@@ -5271,7 +5546,7 @@
 			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;
 		}
@@ -5449,7 +5724,10 @@
 			}
 			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;
@@ -5457,14 +5735,14 @@
 			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.
@@ -5490,11 +5768,11 @@
 		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;
 		}
@@ -5513,17 +5791,21 @@
 		* @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];
 		}
@@ -5560,9 +5842,10 @@
 			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) {
@@ -5596,8 +5879,9 @@
 			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) {
@@ -5867,7 +6151,9 @@
 		*/
 		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,