@thomasfosterau/effect-parse 0.4.1 → 0.5.0

package/dist/internal/compiler/jit.js

@@ -7,13 +7,16 @@ import * as Resume from "../resume.js";
 import { compileAny } from "../tokens.js";
 import { backend as backend$1, createClosureCompiler } from "./closure.js";
 import * as Option from "effect/Option";
-import { charOf, fastLimit, latin1, string, utf16be, utf16le, utf8, validate } from "../text.js";
+import { ShortText, charOf, fastLimit, latin1, string, textIn, utf16be, utf16le, utf8, utf8Text, validate } from "../text.js";
 import * as Arr from "effect/Array";
 import { addEntry, flushEntries, fromEntries, isPlainKey } from "../entries.js";
-import { children, nodeOf, scansFloat } from "../node.js";
+import * as Stack from "../stack.js";
+import { Defer, NodeId, nodeOf, scansFloat } from "../node.js";
 import { buildsEntries, pairOf } from "./entries.js";
 import { Strict, planAlt } from "./first.js";
+import { SearchHead, StopCache, nextStop, stopChars } from "./search.js";
 import { TableSize, acceptTable, kindOfEncoding, reachesAbove, textSet, tokenSet } from "./sets.js";
+import { countRefs, isLeaf, isLetter, isSmall, lowerAscii, selectorOf } from "./graph.js";
 // src/internal/compiler/jit.ts
 /**
 * The JIT: emits JavaScript source for a parser's description and builds
@@ -33,11 +36,15 @@ import { TableSize, acceptTable, kindOfEncoding, reachesAbove, textSet, tokenSet
 */
 /** Helpers available to generated code as `R`. */
 const runtime = {
+	StopCache,
+	nextStop,
 	take: Resume.take,
 	save: Resume.save,
 	Done: Resume.Done,
 	/** Records the result of a resumed repetition (see `Resume.done`). */
 	done: (state, key, entry, value, pos) => Resume.save(state, key, entry, new Resume.Done(value, pos)),
+	isStackOverflow: Stack.isStackOverflow,
+	tooDeep: Stack.tooDeep,
 	some: Option.some,
 	none: Option.none,
 	charOf,
@@ -56,8 +63,9 @@ const runtime = {
 			s.mode = "Backtrack";
 			return Fail;
 		}
-		return enc.text(input, start, end);
-	}
+		return textIn(enc, s, start, end);
+	},
+	utf8Text
 };
 let checked;
 let supported = false;
@@ -87,22 +95,6 @@ const Margin = 4;
 var Fn = class {
 	vars = [];
 };
-const isLeaf = (node) => {
-	switch (node._tag) {
-		case "Succeed":
-		case "Fail":
-		case "Eof":
-		case "Location":
-		case "RestLen":
-		case "Any":
-		case "Literal":
-		case "OneOf":
-		case "TakeWhile": return true;
-		default: return false;
-	}
-};
-const lowerAscii = (c) => c >= 65 && c <= 90 ? c + 32 : c;
-const isLetter = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122;
 /** The inclusive ranges of 1s in a table. */
 const runsOf = (table) => {
 	const out = [];
@@ -160,7 +152,7 @@ var Emitter = class {
 	constantIndex = /* @__PURE__ */ new Map();
 	functions = [];
 	rules = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
-	refs = /* @__PURE__ */ new Map();
+	refs;
 	closure;
 	next = 0;
 	constructor(root, kind, resumable = false) {
@@ -168,24 +160,11 @@ var Emitter = class {
 		this.kind = kind;
 		this.resumable = resumable;
 		this.closure = createClosureCompiler(kind, resumable);
-		this.countRefs(root);
+		this.refs = countRefs(root);
 	}
 	get fallbacks() {
 		return this.closure.fallbacks;
 	}
-	/** Counts the distinct parents of each parser. */
-	countRefs(root) {
-		const seen = /* @__PURE__ */ new Set();
-		const stack = [root];
-		for (let p = stack.pop(); p !== void 0; p = stack.pop()) {
-			if (seen.has(p)) continue;
-			seen.add(p);
-			for (const c of new Set(children(nodeOf(p)))) {
-				this.refs.set(c, (this.refs.get(c) ?? 0) + 1);
-				stack.push(c);
-			}
-		}
-	}
 	const(value) {
 		let i = this.constantIndex.get(value);
 		if (i === void 0) {
@@ -195,6 +174,11 @@ var Emitter = class {
 		}
 		return `C[${i}]`;
 	}
+	/** The text of `[start, p)` in `enc`: UTF-8 decodes through the state's ASCII run (see `utf8Text`). */
+	text(enc, start) {
+		const text = `${this.const(enc.text)}(I,${start},p)`;
+		return enc === utf8 ? `(p-${start}>${ShortText}?R.utf8Text($S,${start},p):${text})` : text;
+	}
 	/** A JavaScript literal for simple values, otherwise a constant. */
 	lit(value) {
 		if (value === void 0) return "void 0";
@@ -257,19 +241,9 @@ var Emitter = class {
 	gen(p, used, out, fail, fn, depth) {
 		const node = nodeOf(p);
 		if (Predicate.isTagged(node, "Suspend")) return this.call(this.rule(node.resolve(), used), out, fail);
-		if (!isLeaf(node) && ((this.refs.get(p) ?? 0) > 1 && !this.small(p) || depth > 32)) return this.call(this.rule(p, used), out, fail);
+		if (!isLeaf(node) && ((this.refs.get(p) ?? 0) > 1 && !isSmall(p) || depth > 32)) return this.call(this.rule(p, used), out, fail);
 		return this.inline(p, used, out, fail, fn, depth);
 	}
-	/** Whether a parser is small enough to inline wherever it is used. */
-	small(p) {
-		let budget = 6;
-		const visit = (q) => {
-			const node = nodeOf(q);
-			if (--budget < 0 || Predicate.isTagged(node, "Suspend") || Predicate.isTagged(node, "Escaped") || Predicate.isTagged(node, "Dispatch")) return false;
-			return children(node).every(visit);
-		};
-		return visit(p);
-	}
 	/**
 	* In a resumable build: token code (which fails by breaking out of `bad`)
 	* that read within `lookahead` units of the end of a partial input re-runs
@@ -344,7 +318,7 @@ var Emitter = class {
 			case "Succeed": return set(this.lit(node.value));
 			case "Sync": return used ? set(`${this.const(node.evaluate)}()`) : "";
 			case "Fail": return `$S.mode=${JSON.stringify(node.mode)};${fail}`;
-			case "Eof": return `if(p<E){${BT}${fail}}` + (this.resumable ? `if($S.partial){$S.mode="Incomplete";${fail}}` : "") + set("void 0");
+			case "Eof": return `if(p<E){${BT}${fail}}` + (this.resumable ? `if($S.partial){$S.incomplete(1);${fail}}` : "") + set("void 0");
 			case "Location": return set("p");
 			case "RestLen": return set("E-p");
 			case "Suspend": return this.call(this.rule(node.resolve(), used), out, fail);
@@ -367,7 +341,7 @@ var Emitter = class {
 					const code = this.float(node, out, fail, fn, d);
 					if (code !== void 0) return code;
 				}
-				if (node.f === fromEntries && out !== null && !this.resumable && buildsEntries(node.self)) return this.entries(node.self, out, fail, fn, d);
+				if (node.f === fromEntries && out !== null && buildsEntries(node.self)) return this.entries(node.self, out, fail, fn, d);
 				const t = this.v(fn);
 				return this.gen(node.self, true, t, fail, fn, d) + set(`${this.const(node.f)}(${t})`);
 			}
@@ -383,6 +357,17 @@ var Emitter = class {
 				const [tag, field] = Predicate.isTagged(node, "TryMap") ? ["Success", "success"] : ["Some", "value"];
 				return this.gen(node.self, true, t, fail, fn, d) + `${r}=${this.const(node.f)}(${t});if(${r}._tag!=="${tag}"){${BT}${fail}}${set(`${r}.${field}`)}`;
 			}
+			case "FastPath": {
+				const st = this.v(fn);
+				const t = out ?? this.v(fn);
+				const done = this.label();
+				return `${st}=p;$S.pos=p;${t}=${this.const(node.fast)}($S);${done}:{if(${t}!==${this.const(Defer)}){p=$S.pos;break ${done}}p=${st};${this.gen(node.self, used, out, fail, fn, d)}}`;
+			}
+			case "MapOrFail": {
+				const t = this.v(fn);
+				const r = out ?? this.v(fn);
+				return this.gen(node.self, true, t, fail, fn, d) + `${r}=${this.const(node.f)}(${t});if(${r}===F){${BT}${fail}}`;
+			}
 			case "Filter": {
 				const t = out ?? this.v(fn);
 				return this.gen(node.self, true, t, fail, fn, d) + `if(!${this.const(node.predicate)}(${t})){${BT}${fail}}`;
@@ -409,6 +394,12 @@ var Emitter = class {
 				const extra = Predicate.isTagged(node, "WithSpan") ? `{start:${st},end:p}` : `$S.slice(${st},p)`;
 				return `${st}=p;` + this.gen(node.self, true, t, fail, fn, d) + set(`[${t},${extra}]`);
 			}
+			case "MapSpan": {
+				if (!used) return this.gen(node.self, false, null, fail, fn, d);
+				const st = this.v(fn);
+				const t = this.v(fn);
+				return `${st}=p;` + this.gen(node.self, true, t, fail, fn, d) + set(`${this.const(node.f)}(${t},${st},p)`);
+			}
 			case "Span": {
 				const st = this.v(fn);
 				return `${st}=p;` + this.gen(node.self, false, null, fail, fn, d) + set(`{start:${st},end:p}`);
@@ -420,6 +411,7 @@ var Emitter = class {
 			}
 			case "Context":
 			case "Expected":
+			case "Quiet":
 			case "MapError":
 			case "OrFail":
 			case "Trace":
@@ -458,6 +450,11 @@ var Emitter = class {
 				if (node.keys.includes("__proto__")) return code + `${out}={};` + node.keys.map((k, i) => `${out}[${JSON.stringify(k)}]=${vars[i]};`).join("");
 				return code + `${out}={${node.keys.map((k, i) => `${JSON.stringify(k)}:${vars[i]}`).join(",")}};`;
 			}
+			case "SeqWith": {
+				if (out === null) return node.parsers.map((q) => this.gen(q, false, null, fail, fn, d)).join("");
+				const vars = node.parsers.map(() => this.v(fn));
+				return node.parsers.map((q, i) => this.gen(q, true, vars[i], fail, fn, d)).join("") + `${out}=${this.const(node.f)}(${vars.join(",")});`;
+			}
 			case "ZipWith": {
 				if (out === null) return this.gen(node.self, false, null, fail, fn, d) + this.gen(node.that, false, null, fail, fn, d);
 				const x = this.v(fn);
@@ -467,8 +464,13 @@ var Emitter = class {
 			case "Alt": return this.alt(node, used, out, fail, fn, d);
 			case "Dispatch": return this.dispatch(p, node, used, out, fail, fn, d);
 			case "Repeat":
-			case "Fold": return this.repeat(node, used, out, fail, fn, d);
+			case "Fold": return (out === null && Predicate.isTagged(node, "Repeat") ? this.repeatRun(p, node, fail, fn, d) : void 0) ?? this.repeat(node, used, out, fail, fn, d);
 			case "Separated": return this.separated(node, used, out, fail, fn, d);
+			case "Fixed": {
+				if (this.kind !== 1) return this.delegate(p, used, out, fail, fn);
+				const read = used ? `${out ?? this.v(fn)}=${this.const(node.read)}(I,p,$S);` : "";
+				return `if(E-p>=${node.size}){${read}p+=${node.size}}else{${this.delegate(p, used, out, fail, fn)}}`;
+			}
 			default: return this.delegate(p, used, out, fail, fn);
 		}
 	}
@@ -552,9 +554,7 @@ var Emitter = class {
 			const r = out ?? this.v(fn);
 			return code + `default:{$S.pos=p;${r}=${q}.step($S);if(${r}===F){${fail}}p=$S.pos;}}`;
 		};
-		let sel = nodeOf(node.selector);
-		const peek = Predicate.isTagged(sel, "Peek");
-		if (peek) sel = nodeOf(sel.self);
+		const { node: sel, peek } = selectorOf(node.selector);
 		if (!Predicate.isTagged(sel, "Any") || !this.native(sel.encoding)) return general(true);
 		const enc = sel.encoding;
 		const r = enc === void 0 ? void 0 : this.reader(enc);
@@ -577,6 +577,57 @@ var Emitter = class {
 		code += `case -1:{${BT}${fail}}default:{if(${u}<${size}){${BT}${fail}}${general(false)}}}`;
 		return code;
 	}
+	/**
+	* A repetition whose elements are not kept, rewritten to scan a run of a
+	* character set in one loop instead of one element at a time (#79):
+	*
+	* - `repeat(oneOf(S), range)` matches what `takeWhile(S, range)` matches,
+	*   stopping, failing and reporting `Incomplete` where it does, so it
+	*   compiles as that `takeWhile`, with the repetition's own step as the
+	*   fallback near the end of a partial input.
+	* - `repeat(alt(oneOf(S), ...rest))` with `min` at most 1 and no `max`
+	*   matches what `repeat(alt(takeWhile(S, { min: 1 }), ...rest))` matches:
+	*   a run of `S` is a run of one-character elements, and the counts that
+	*   differ only matter for other ranges. The first branch is a synthetic
+	*   `takeWhile` node; outside resumable builds, which never run its step.
+	*
+	* Returns `undefined` when neither applies.
+	*/
+	repeatRun(p, node, fail, fn, d) {
+		if (this.kind === 2) return void 0;
+		const element = nodeOf(node.self);
+		if (Predicate.isTagged(element, "OneOf") && this.native(element.encoding)) {
+			const { encoding, negate, set } = element;
+			return this.leaf(p, {
+				_tag: "TakeWhile",
+				set,
+				negate,
+				encoding,
+				min: node.min,
+				max: node.max
+			}, false, null, fail, fn);
+		}
+		if (this.resumable || node.min > 1 || node.max !== Infinity || !Predicate.isTagged(element, "Alt")) return void 0;
+		const [first, ...rest] = element.parsers;
+		const head = first === void 0 ? void 0 : nodeOf(first);
+		if (head === void 0 || !Predicate.isTagged(head, "OneOf") || !this.native(head.encoding) || Arr.isReadonlyArrayEmpty(rest)) return;
+		const run = synthetic({
+			_tag: "TakeWhile",
+			set: head.set,
+			negate: head.negate,
+			encoding: head.encoding,
+			min: 1,
+			max: Infinity
+		}, node.self.step);
+		const alt = synthetic({
+			_tag: "Alt",
+			parsers: [run, ...rest]
+		}, node.self.step);
+		return this.repeat({
+			...node,
+			self: alt
+		}, false, null, fail, fn, d);
+	}
 	repeat(node, used, out, fail, fn, d, collect) {
 		const { max, min } = node;
 		const loop = this.label();
@@ -603,11 +654,12 @@ var Emitter = class {
 		const check = max === Infinity ? `if(p===${st}){$S.mode="Cut";${fail}}` : "";
 		const bound = max === Infinity ? "" : `${n}<${max}`;
 		const r = this.resumable ? this.resumePoint(fn) : void 0;
-		const save = r === void 0 ? "" : `if($S.mode==="Incomplete"&&$S.resume!==void 0)R.save($S,${r.key},${r.entry},{acc:${acc},count:${n},pos:${st}});`;
+		const held = collect?.value ?? acc;
+		const save = r === void 0 ? "" : `if($S.mode==="Incomplete"&&$S.resume!==void 0)R.save($S,${r.key},${r.entry},{acc:${held},${collect?.saved ?? ""}count:${n},pos:${st}});`;
 		const element = collect === void 0 ? `${this.gen(node.self, tracked, x, `break ${bad};`, fn, d)}${check}${add}` : collect.element(`break ${bad};`, check);
 		const body = `${loop}:for(;${bound};${n}++){${cond === void 0 ? "" : `if(${min > 0 ? `${n}>=${min}&&` : ""}!${this.const(cond)}(${acc}))break ${loop};`}${st}=p;${bad}:{${element}continue ${loop};}${save}if($S.mode!=="Backtrack"${min > 0 ? `||${n}<${min}` : ""}){${fail}}p=${st};break ${loop};}`;
 		if (r === void 0) return `${init}${n}=0;${body}${collect?.finish ?? ""}`;
-		return r.wrap(acc, `${acc}=cp.acc;${n}=cp.count;p=cp.pos;`, `${init}${n}=0;`, body);
+		return r.wrap(held, `${held}=cp.acc;${collect?.restore ?? ""}${n}=cp.count;p=cp.pos;`, `${init}${n}=0;`, `${body}${collect?.finish ?? ""}`);
 	}
 	/**
 	* In a resumable build, a repetition entered at `entry` may restart from a
@@ -638,7 +690,8 @@ var Emitter = class {
 		const loop = this.label();
 		const push = keep ? `${acc}.push(${x});` : "";
 		const r = this.resumable ? this.resumePoint(fn) : void 0;
-		const save = r === void 0 ? "" : `if($S.mode==="Incomplete"&&$S.resume!==void 0)R.save($S,${r.key},${r.entry},{acc:${acc},count:${n},pos:${st}});`;
+		const held = collect?.value ?? acc;
+		const save = r === void 0 ? "" : `if($S.mode==="Incomplete"&&$S.resume!==void 0)R.save($S,${r.key},${r.entry},{acc:${held},${collect?.saved ?? ""}count:${n},pos:${st}});`;
 		const attempt = (body, success, fatal, checkpoint) => {
 			const ok = this.label();
 			const bad = this.label();
@@ -650,7 +703,7 @@ var Emitter = class {
 		const first = `${collect?.init ?? (keep ? `${acc}=[];` : "")}${n}=0;${st}=p;` + attempt(self, `${push}${n}++;`, min > 0 ? "||true" : "", "");
 		const rest = `${loop}:while(${max === Infinity ? "true" : `${n}<${max}`}){${st}=p;` + attempt(sep, "", `||${n}<${min}`, save) + check + attempt(self, `${push}${n}++;continue ${loop};`, `||${n}<${min}`, save) + `}`;
 		if (r === void 0) return `${done}:{${first}${rest}}${collect?.finish ?? ""}`;
-		return r.wrap(acc, `${acc}=cp.acc;${n}=cp.count;p=cp.pos;`, "", `${done}:{if(!${r.resumed}){${first}}${rest}}`);
+		return r.wrap(held, `${held}=cp.acc;${collect?.restore ?? ""}${n}=cp.count;p=cp.pos;`, "", `${done}:{if(!${r.resumed}){${first}}${rest}}${collect?.finish ?? ""}`);
 	}
 	/**
 	* `map(self, Object.fromEntries)`, where `buildsEntries(self)`: builds the
@@ -661,35 +714,35 @@ var Emitter = class {
 	*/
 	entries(p, out, fail, fn, d) {
 		const node = nodeOf(p);
-		switch (node._tag) {
-			case "Mode": {
-				const ok = this.label();
-				const bad = this.label();
-				return `${ok}:{${bad}:{${this.entries(node.self, out, `break ${bad};`, fn, d)}break ${ok};}if($S.mode===${JSON.stringify(node.from)})$S.mode=${JSON.stringify(node.to)};${fail}}`;
-			}
-			case "Seq": {
-				const i = node.output;
-				return node.parsers.map((q, j) => j === i ? this.entries(q, out, fail, fn, d) : this.gen(q, false, null, fail, fn, d)).join("");
-			}
-			case "Repeat":
-			case "Separated": {
-				const pair = pairOf(node.self);
-				if (pair === void 0) {
-					const t = this.v(fn);
-					return this.gen(p, true, t, fail, fn, d) + `${out}=${this.const(fromEntries)}(${t});`;
-				}
-				const deferred = this.v(fn);
-				const key = this.v(fn);
-				const value = this.v(fn);
-				const collect = {
-					init: `${out}={};${deferred}=void 0;`,
-					element: (f, check) => pair.parsers.map((q, j) => this.gen(q, j === pair.key || j === pair.value, j === pair.key ? key : j === pair.value ? value : null, f, fn, d)).join("") + check + `if(${deferred}===void 0&&R.isPlainKey(${key}))${out}[${key}]=${value};else ${deferred}=R.addEntry(${out},${deferred},${key},${value});`,
-					finish: `if(${deferred}!==void 0)R.flushEntries(${out},${deferred});`
-				};
-				return Predicate.isTagged(node, "Repeat") ? this.repeat(node, true, out, fail, fn, d, collect) : this.separated(node, true, out, fail, fn, d, collect);
+		if (Predicate.isTagged(node, "Mode")) {
+			const ok = this.label();
+			const bad = this.label();
+			return `${ok}:{${bad}:{${this.entries(node.self, out, `break ${bad};`, fn, d)}break ${ok};}if($S.mode===${JSON.stringify(node.from)})$S.mode=${JSON.stringify(node.to)};${fail}}`;
+		}
+		if (Predicate.isTagged(node, "Seq")) {
+			const i = node.output;
+			return node.parsers.map((q, j) => j === i ? this.entries(q, out, fail, fn, d) : this.gen(q, false, null, fail, fn, d)).join("");
+		}
+		if (Predicate.isTagged(node, "Repeat") || Predicate.isTagged(node, "Separated")) {
+			const pair = pairOf(node.self);
+			if (pair === void 0) {
+				const t = this.v(fn);
+				return this.gen(p, true, t, fail, fn, d) + `${out}=${this.const(fromEntries)}(${t});`;
 			}
-			default: return this.entries(node.self, out, fail, fn, d);
+			const deferred = this.v(fn);
+			const key = this.v(fn);
+			const value = this.v(fn);
+			const collect = {
+				init: `${out}={};${deferred}=void 0;`,
+				element: (f, check) => pair.parsers.map((q, j) => this.gen(q, j === pair.key || j === pair.value, j === pair.key ? key : j === pair.value ? value : null, f, fn, d)).join("") + check + `if(${deferred}===void 0&&R.isPlainKey(${key}))${out}[${key}]=${value};else ${deferred}=R.addEntry(${out},${deferred},${key},${value});`,
+				finish: `if(${deferred}!==void 0)R.flushEntries(${out},${deferred});`,
+				value: out,
+				saved: `def:${deferred},`,
+				restore: `${deferred}=cp.def;`
+			};
+			return Predicate.isTagged(node, "Repeat") ? this.repeat(node, true, out, fail, fn, d, collect) : this.separated(node, true, out, fail, fn, d, collect);
 		}
+		return this.entries(node.self, out, fail, fn, d);
 	}
 	/** An expression: is the unit `c`, known to be below `size` (at most `TableSize`), accepted? */
 	member(accept, c, size = TableSize) {
@@ -745,9 +798,10 @@ var Emitter = class {
 					return this.literalUnits(Predicate.isString(encoded) ? unitsOf(encoded) : Array.from(encoded), false, fail) + set(this.lit(lit));
 				}
 				const literalKind = Predicate.isString(lit) ? 0 : lit instanceof Uint8Array ? 1 : 2;
-				if (kind === 0 && literalKind !== 0) return void 0;
-				if (literalKind === 2) return void 0;
-				const codes = kind === 0 ? unitsOf(lit) : Array.from(literalKind === 0 ? new TextEncoder().encode(lit) : lit);
+				let codes;
+				if (Predicate.isString(lit)) codes = kind === 0 ? unitsOf(lit) : Array.from(new TextEncoder().encode(lit));
+				else if (kind === 1 && lit instanceof Uint8Array) codes = Array.from(lit);
+				else return void 0;
 				const len = codes.length;
 				const value = !node.caseless && literalKind === kind ? this.lit(lit) : kind === 0 ? `I.slice(p-${len},p)` : `I.subarray(p-${len},p)`;
 				return this.literalUnits(codes, node.caseless, fail) + set(value);
@@ -801,7 +855,7 @@ var Emitter = class {
 		const counted = max !== Infinity || min > 1;
 		const count = counted ? `${n}++;` : "";
 		const bound = max !== Infinity ? `&&${n}<${max}` : "";
-		const slice = enc !== void 0 ? `${this.const(enc.text)}(I,${st},p)` : kind === 0 ? `I.slice(${st},p)` : `I.subarray(${st},p)`;
+		const slice = enc !== void 0 ? this.text(enc, st) : kind === 0 ? `I.slice(${st},p)` : `I.subarray(${st},p)`;
 		const finish = (min > 0 ? `if(${counted ? n : `p-${st}`}<${min}){${BT}${fail}}` : "") + (out === null ? "" : `${out}=${slice};`);
 		const head = `${st}=p;${counted ? `${n}=0;` : ""}${loop}:while(p<E${bound}){${c}=${this.unit("p")};`;
 		const member = this.member(accept, c);
@@ -811,6 +865,8 @@ var Emitter = class {
 			const guard = r.width === 1 ? "" : `${r.guard("p")}&&`;
 			return `${st}=p;${counted ? `${n}=0;` : ""}${loop}:while(p<E${bound}){` + (r.fast > 0 ? `if(${guard}(${c}=${r.unit("p")})<${r.fast}){if(!${this.textAccepts(r, cs, accept, negate, c)})break ${loop};p+=${r.width}}else` : "") + `{${c}=${this.const(enc.decode)}(I,p,E);if(${c}<0||${this.textRejectsDecoded(enc, r, cs, negate, c)})break ${loop};p+=${this.const(enc.width)}(${c})}${count}}${finish}`;
 		}
+		const stops = negate && !counted ? stopChars(cs) : void 0;
+		if (stops !== void 0) return this.stopSearch(stops, st, c, finish, fn);
 		const fast = 55296;
 		const small = TableSize;
 		const highTest = (v) => this.memberHigh(cs, negate, v);
@@ -820,6 +876,21 @@ var Emitter = class {
 		return `${head}if(${c}<${small}){if(!(${member}))break;p++}else ${never && !negate ? `break;` : always && !counted ? `p++;` : `if(${c}<${fast}||${c}>56319){if(!(${highTest(c)}))break ${loop};p++}else{${cp}=${c};if(p+1<I.length){const d=I.charCodeAt(p+1);if((d&64512)===56320)${cp}=((${c}-55296)<<10)+(d-56320)+65536}if(!(${highTest(cp)}))break ${loop};p+=${cp}>65535?2:1}`}${count}}${finish}`;
 	}
 	/**
+	* `Token.takeTill` on a string, of one to `MaxStops` characters that are
+	* whole code points: the set accepts every other unit, surrogates
+	* included, so the run ends at the first stop character. The first
+	* `SearchHead` units are tested one at a time, which beats a native
+	* search on short runs; a longer run ends at the next occurrence that
+	* `nextStop` finds with `indexOf` (#75).
+	*/
+	stopSearch(stops, st, c, finish, fn) {
+		const h = this.v(fn);
+		const test = stops.map((u) => `${c}!==${u}`).join("&&");
+		const search = stops.length === 1 ? `{p=I.indexOf(${JSON.stringify(String.fromCharCode(stops[0]))},p);if(p<0)p=E}` : `p=R.nextStop(${this.const(new StopCache(stops.map((u) => String.fromCharCode(u))))},$S,p);`;
+		const head = stops.length === 1 ? SearchHead : 2 * SearchHead;
+		return `${st}=p;${h}=p+${head}<E?p+${head}:E;while(p<${h}&&(${c}=I.charCodeAt(p),${test}))p++;if(p===${h}&&p<E&&(${c}=I.charCodeAt(p),${test}))${search}${finish}`;
+	}
+	/**
 	* `escaped`. In a resumable build it keeps the closure compiler's
 	* checkpoints: where the next segment starts and, unless raw, the text
 	* so far, saved when a segment or an escape runs out of input.
@@ -843,37 +914,54 @@ var Emitter = class {
 		const normal = this.gen(node.normal, !raw, x, `break ${bad};`, fn, d);
 		const escape = this.gen(node.escape, !raw, x, `${save(b)}${fail}`, fn, d);
 		const onNormal = raw ? `if(p===${b}){$S.mode="Cut";${fail}}continue ${loop};` : `if(p!==${b}){${acc}+=${x};continue ${loop}}`;
-		const slice = enc !== void 0 ? `${this.const(enc.text)}(I,${st},p)` : this.kind === 0 ? `I.slice(${st},p)` : `I.subarray(${st},p)`;
+		const slice = enc !== void 0 ? this.text(enc, st) : this.kind === 0 ? `I.slice(${st},p)` : `I.subarray(${st},p)`;
 		const ctrlTest = rd === void 0 ? `p<E&&${this.unit("p")}===${ctrl}` : `${rd.guard("p")}&&${rd.unit("p")}===${ctrl}`;
 		const stop = r === void 0 ? loop : this.label();
 		const loopCode = `${loop}:while(p<E){${b}=p;${okv}=false;${bad}:{${normal}${okv}=true;}if(${okv}){${onNormal}}else{if($S.mode!=="Backtrack"){${save(b)}${fail}}p=${b}}if(${ctrlTest}){p+=${rd?.width ?? 1};${escape}${raw ? "" : `${acc}+=${x};`}}else break ${stop};}`;
-		const body = r === void 0 ? loopCode : `${stop}:{${loopCode}if($S.partial){$S.mode="Incomplete";${save("p")}${fail}}}`;
+		const body = r === void 0 ? loopCode : `${stop}:{${loopCode}if($S.partial){$S.incomplete(0);${save("p")}${fail}}}`;
 		if (r === void 0) return `${raw ? `${st}=p;` : `${acc}="";`}${body}${raw && out !== null ? `${out}=${slice};` : ""}`;
 		if (acc !== null) return r.wrap(acc, `${acc}=cp.out;p=cp.pos;`, `${acc}="";`, body);
 		const value = out ?? this.v(fn);
 		return r.wrap(value, "p=cp;", "", `${body}${value}=${out === null ? "void 0" : slice};`);
 	}
 };
+/**
+* A parser that exists only as a description, for the rewrites of
+* `Emitter.repeatRun`. `step` is never run on the paths they compile (the
+* token code of a native `takeWhile`, and alternatives inline), so it is
+* the step of the repetition's element, which describes the same language
+* when its value is unused.
+*/
+const synthetic = (node, step) => {
+	return {
+		step,
+		name: void 0,
+		[NodeId]: node
+	};
+};
 /** The UTF-16 code units of a string. */
 const unitsOf = (s) => Array.from({ length: s.length }, (_, i) => s.charCodeAt(i));
 /** Generates the source of a compiled parser, without building it. */
 const generate = (root, kind, resumable = false) => {
 	const e = new Emitter(root, kind, resumable);
 	const main = e.rule(root, true);
+	let closure;
+	const short = e.const((state) => (closure ??= createClosureCompiler(kind, resumable).compile(root, true))(state));
 	return {
-		source: `"use strict";let $I,$E,$S,P;${e.functions.join("\n")}\nreturn function run(state){const sI=$I,sE=$E,sS=$S,sP=P;$I=state.input;$E=state.end;$S=state;try{const v=${main}(state.pos);if(v!==F)state.pos=P;return v}finally{$I=sI;$E=sE;$S=sS;P=sP}}`,
+		source: `"use strict";let $I,$E,$S,P;${e.functions.join("\n")}\nreturn function run(state){if(state.end!==state.input.length)return ${short}(state);const sI=$I,sE=$E,sS=$S,sP=P;$I=state.input;$E=state.end;$S=state;try{const v=${main}(state.pos);if(v!==F)state.pos=P;return v}catch(e){if(!R.isStackOverflow(e))throw e;return R.tooDeep(state)}finally{$I=sI;$E=sE;$S=sS;P=sP}}`,
 		constants: e.constants,
 		fallbacks: e.fallbacks
 	};
 };
-/** Compiles a root parser for one input kind with `new Function`. */
+/**
+* Compiles a root parser for one input kind with `new Function`. The step
+* is the generated entry, which handles every state and reports call-stack
+* overflows itself.
+*/
 const compileJit = (root, kind, resumable = false) => {
 	const { constants, fallbacks, source } = generate(root, kind, resumable);
-	const run = globalThis.Function("C", "F", "R", source)(constants, Fail, runtime);
-	let closure;
-	const step = (state) => state.end === state.input.length ? run(state) : (closure ??= createClosureCompiler(kind, resumable).compile(root, true))(state);
 	return {
-		step,
+		step: globalThis.Function("C", "F", "R", source)(constants, Fail, runtime),
 		fallbacks,
 		source
 	};
@@ -888,6 +976,7 @@ const backend = { build: (p, kind, resumable) => {
 		onSuccess: ({ fallbacks, source, step }) => ({
 			backend: "jit",
 			step,
+			guarded: true,
 			fallbacks,
 			error: void 0,
 			source
@@ -898,6 +987,6 @@ const backend = { build: (p, kind, resumable) => {
 		})
 	});
 } };
-export { backend };
+export { backend, jitSupported };
 
 //# sourceMappingURL=jit.js.map