re2js 2.8.6 → 2.8.7

package/build/index.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
 */
 //#region src/RE2Flags.js
@@ -499,6 +499,10 @@ var UnicodeTables = class {
 */
 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;
@@ -601,7 +605,7 @@ var Utils = class Utils {
 		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");
@@ -660,7 +664,7 @@ var Utils = class Utils {
 			runes.push(cp);
 			i += cp > Unicode.MAX_BMP ? 2 : 1;
 		}
-		return runes;
+		return new Int32Array(runes);
 	}
 	static runeToString(r) {
 		return String.fromCodePoint(r);
@@ -787,7 +791,7 @@ var MatcherInputBase = class MatcherInputBase {
 	asCharSequence() {
 		throw Error("not implemented");
 	}
-	/** @returns {Uint8Array|number[]} */
+	/** @returns {Uint8Array|number[]|null} */
 	asBytes() {
 		throw Error("not implemented");
 	}
@@ -918,7 +922,8 @@ var MachineInputBase = class {
 		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;
@@ -932,33 +937,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 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;
@@ -1023,8 +1041,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;
@@ -1217,6 +1234,8 @@ var Matcher = class Matcher {
 		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));
@@ -1250,9 +1269,13 @@ var Matcher = class Matcher {
 	*/
 	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;
 	}
@@ -1340,11 +1363,11 @@ var Matcher = class Matcher {
 	* @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;
@@ -1377,7 +1400,7 @@ var Matcher = class Matcher {
 	*/
 	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);
 		}
@@ -1400,7 +1423,7 @@ var Matcher = class Matcher {
 	* @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;
@@ -1729,7 +1752,8 @@ var Inst = class Inst {
 		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;
 	}
@@ -1818,19 +1842,27 @@ var Inst = class Inst {
 };
 //#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;
@@ -1846,6 +1878,7 @@ var Queue = class {
 	}
 	clear() {
 		this.size = 0;
+		this.mainThreads = 0;
 	}
 	toString() {
 		let out = "{";
@@ -1857,6 +1890,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 Machine {
 	static fromRE2(re2) {
 		const m = new Machine();
@@ -1864,19 +1909,18 @@ var Machine = class Machine {
 		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;
@@ -1897,14 +1941,23 @@ var Machine = class Machine {
 		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);
@@ -1920,12 +1973,16 @@ var Machine = class Machine {
 		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;
@@ -1938,9 +1995,12 @@ var Machine = class Machine {
 					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);
 				}
@@ -1962,6 +2022,7 @@ var Machine = class Machine {
 			runq = nextq;
 			nextq = tmpq;
 		}
+		runq.clear();
 		nextq.clear();
 		return this.matched;
 	}
@@ -1985,12 +2046,12 @@ var Machine = class Machine {
 		}
 		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);
 			}
@@ -2075,65 +2136,85 @@ var Machine = class Machine {
 		}
 		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;
 		}
 	}
 };
@@ -2153,35 +2234,85 @@ const 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 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;
@@ -2190,7 +2321,7 @@ var DFA = class DFA {
 			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:
@@ -2207,11 +2338,11 @@ var DFA = class DFA {
 			}
 		}
 		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) {
@@ -2222,156 +2353,126 @@ var DFA = class DFA {
 		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);
 	}
 };
@@ -2380,7 +2481,7 @@ var DFA = class DFA {
 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;
@@ -2663,7 +2764,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;
 		}
@@ -2733,7 +2834,7 @@ const 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;
 			}
@@ -2742,7 +2843,7 @@ const 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:
@@ -2754,7 +2855,7 @@ const 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;
 				}
@@ -2765,7 +2866,7 @@ const 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;
@@ -2781,7 +2882,7 @@ const 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;
@@ -2790,21 +2891,20 @@ const 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;
 	};
@@ -2836,8 +2936,7 @@ const 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);
 		}
 	}
 };
@@ -2866,9 +2965,7 @@ var OnePass = class OnePass {
 						return null;
 					}
 					break;
-				default:
-					if (opOut === Inst.MATCH && hasAlt) return null;
-					break;
+				default: if (opOut === Inst.MATCH && hasAlt) return null;
 			}
 		}
 		let p = onePassCopy(prog);
@@ -3019,7 +3116,7 @@ var Regexp = class Regexp {
 		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;
@@ -3030,7 +3127,7 @@ var Regexp = class Regexp {
 	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;
@@ -3074,7 +3171,6 @@ var Regexp = class Regexp {
 							if (this.max >= 0) out += this.max;
 						}
 						out += "}";
-						break;
 				}
 				if ((this.flags & RE2Flags.NON_GREEDY) !== 0) out += "?";
 				break;
@@ -3167,9 +3263,7 @@ var Regexp = class Regexp {
 				}
 				out += "]";
 				break;
-			default:
-				out += this.op;
-				break;
+			default: out += this.op;
 		}
 		return out;
 	}
@@ -3213,70 +3307,158 @@ var Regexp = class Regexp {
 				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;
 	}
@@ -3288,14 +3470,33 @@ var Prefilter = class Prefilter {
 		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;
@@ -3304,7 +3505,7 @@ var Prefilter = class Prefilter {
 				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;
@@ -3313,100 +3514,115 @@ var Prefilter = class Prefilter {
 };
 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;
 	}
 };
@@ -3442,6 +3658,7 @@ var Prog = class {
 		this.numCap = 2;
 		this.lbStarts = [];
 		this.numLb = 0;
+		this.lbInst = null;
 	}
 	getInst(pc) {
 		return this.inst[pc];
@@ -3452,6 +3669,26 @@ 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) {
@@ -3464,7 +3701,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);
 		}
@@ -3528,6 +3765,13 @@ var Prog = class {
 };
 //#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.
 *
@@ -3547,28 +3791,19 @@ var Frag = class {
 * 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 = [];
@@ -3588,11 +3823,19 @@ var Compiler = class Compiler {
 			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);
@@ -3685,7 +3928,7 @@ var Compiler = class Compiler {
 	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);
@@ -3697,56 +3940,74 @@ var Compiler = class Compiler {
 		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");
 		}
 	}
@@ -3756,111 +4017,149 @@ var Compiler = class Compiler {
 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;
@@ -4028,46 +4327,35 @@ var CharClass = class CharClass {
 		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];
@@ -4271,7 +4559,7 @@ var Parser = class Parser {
 	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,
@@ -4413,15 +4701,17 @@ var Parser = class Parser {
 			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) {
@@ -4478,9 +4768,7 @@ var Parser = class Parser {
 			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));
 	}
@@ -4489,10 +4777,6 @@ var Parser = class Parser {
 		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;
@@ -4623,9 +4907,7 @@ var Parser = class Parser {
 		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;
@@ -4650,7 +4932,8 @@ var Parser = class Parser {
 		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;
@@ -4722,12 +5005,12 @@ var Parser = class Parser {
 	}
 	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;
 			}
 		}
@@ -4887,9 +5170,7 @@ var Parser = class Parser {
 						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;
@@ -4988,9 +5269,7 @@ var Parser = class Parser {
 						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;
@@ -5041,9 +5320,7 @@ var Parser = class Parser {
 						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);
@@ -5067,9 +5344,7 @@ var Parser = class Parser {
 					this.literal(Parser.parseEscape(t));
 					break;
 				}
-				default:
-					this.literal(t.pop());
-					break;
+				default: this.literal(t.pop());
 			}
 			lastRepeatPos = repeatPos;
 		}
@@ -5267,7 +5542,7 @@ var Parser = class Parser {
 		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;
 	}
@@ -5445,7 +5720,10 @@ var RE2 = class RE2 {
 		}
 		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;
@@ -5453,14 +5731,14 @@ var RE2 = class RE2 {
 		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.
@@ -5486,11 +5764,11 @@ var RE2 = class RE2 {
 	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;
 	}
@@ -5509,17 +5787,21 @@ var RE2 = class RE2 {
 	* @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];
 	}
@@ -5556,9 +5838,10 @@ var RE2 = class RE2 {
 		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) {
@@ -5592,8 +5875,9 @@ var RE2 = class RE2 {
 		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) {
@@ -5863,7 +6147,9 @@ var RE2Set = class RE2Set {
 	*/
 	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,