@thomasfosterau/effect-parse 0.1.0 → 0.2.0

package/dist/internal/compiler/jit.js

@@ -1,1030 +1,902 @@
-/**
- * The JIT: emits JavaScript source for a parser's description and builds
- * it with `new Function`.
- *
- * Every rule (the root, every `suspend` target and every non-leaf parser
- * with several parents) becomes a function `f(p)` taking the cursor and
- * returning the value, or `Fail`, leaving the new cursor in the register
- * `P`. Everything else is inlined as straight-line code, with labelled
- * blocks for failure. The cursor is a local; the input and its end are
- * hoisted into locals. Failures only set `state.mode`, as in the closure
- * compiler.
- *
- * Nodes without an inline form run their closure-compiled steps (which run
- * the interpreter for what they can't compile) on the shared state, with
- * `state.pos` kept in sync.
- */
-import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import { Fail } from "../../Input.js";
-import { addEntry, flushEntries, fromEntries, isPlainKey } from "../entries.js";
-import { children, nodeOf } from "../node.js";
 import { floatScan, floatTexts, scanFloatBytes, scanFloatString, toFloat } from "../numbers.js";
 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 { createClosureCompiler } from "./closure.js";
-import { entriesShape, pairOf } from "./entries.js";
-import { planAlt, Strict } from "./first.js";
-import { kindOfEncoding, reachesAbove, TableSize, textSet, tokenSet } from "./sets.js";
+import { addEntry, flushEntries, fromEntries, isPlainKey } from "../entries.js";
+import { children, nodeOf } from "../node.js";
+import { buildsEntries, pairOf } from "./entries.js";
+import { Strict, planAlt } from "./first.js";
+import { TableSize, kindOfEncoding, reachesAbove, textSet, tokenSet } from "./sets.js";
+//#region src/internal/compiler/jit.ts
+/**
+* The JIT: emits JavaScript source for a parser's description and builds
+* it with `new Function`.
+*
+* Every rule (the root, every `suspend` target and every non-leaf parser
+* with several parents) becomes a function `f(p)` taking the cursor and
+* returning the value, or `Fail`, leaving the new cursor in the register
+* `P`. Everything else is inlined as straight-line code, with labelled
+* blocks for failure. The cursor is a local; the input and its end are
+* hoisted into locals. Failures only set `state.mode`, as in the closure
+* compiler.
+*
+* Nodes without an inline form run their closure-compiled steps (which run
+* the interpreter for what they can't compile) on the shared state, with
+* `state.pos` kept in sync.
+*/
 /** Helpers available to generated code as `R`. */
 const runtime = {
-    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)),
-    some: Option.some,
-    none: Option.none,
-    charOf,
-    scanFloatString,
-    scanFloatBytes,
-    isPlainKey,
-    addEntry,
-    flushEntries,
-    /** `Text.taken`: the text of `[start, end)`, or `Fail` if it is malformed. */
-    textOf: (enc, fast, s, start, end) => {
-        const input = s.input;
-        let i = start;
-        if (s.inputKind === 0)
-            while (i < end && input.charCodeAt(i) < fast)
-                i++;
-        else
-            while (i < end && input[i] < fast)
-                i++;
-        if (i < end && validate(enc, s, i, end) < 0) {
-            s.mode = "Backtrack";
-            return Fail;
-        }
-        return enc.text(input, start, end);
-    }
+	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)),
+	some: Option.some,
+	none: Option.none,
+	charOf,
+	scanFloatString,
+	scanFloatBytes,
+	isPlainKey,
+	addEntry,
+	flushEntries,
+	/** `Text.taken`: the text of `[start, end)`, or `Fail` if it is malformed. */
+	textOf: (enc, fast, s, start, end) => {
+		const input = s.input;
+		let i = start;
+		if (s.inputKind === 0) while (i < end && input.charCodeAt(i) < fast) i++;
+		else while (i < end && input[i] < fast) i++;
+		if (i < end && validate(enc, s, i, end) < 0) {
+			s.mode = "Backtrack";
+			return Fail;
+		}
+		return enc.text(input, start, end);
+	}
 };
 let checked;
 let supported = false;
 /**
- * Whether `new Function` works here (it doesn't under a Content Security
- * Policy). Checked once, and again if `globalThis.Function` is replaced.
- */
-export const jitSupported = () => {
-    if (checked !== globalThis.Function) {
-        checked = globalThis.Function;
-        try {
-            supported = checked("return true")() === true;
-        }
-        catch {
-            supported = false;
-        }
-    }
-    return supported;
+* Whether `new Function` works here (it doesn't under a Content Security
+* Policy). Checked once, and again if `globalThis.Function` is replaced.
+*/
+const jitSupported = () => {
+	if (checked !== globalThis.Function) {
+		checked = globalThis.Function;
+		try {
+			supported = checked("return true")() === true;
+		} catch {
+			supported = false;
+		}
+	}
+	return supported;
 };
 const BT = `$S.mode="Backtrack";`;
-const builtinEncodings = new Set([string, utf8, utf16le, utf16be, latin1]);
+const builtinEncodings = /*#__PURE__*/ new Set([
+	string,
+	utf8,
+	utf16le,
+	utf16be,
+	latin1
+]);
 /** How many units past the cursor a single token can depend on (see the closure compiler). */
 const Margin = 4;
 /** Per generated function: its local variables. */
-class Fn {
-    vars = [];
-}
+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;
-    }
+	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);
+const isLetter = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122;
 /** The inclusive ranges of 1s in a table. */
 const runsOf = (table) => {
-    const out = [];
-    for (let i = 0; i < table.length; i++) {
-        if (table[i] !== 1)
-            continue;
-        let j = i;
-        while (j + 1 < table.length && table[j + 1] === 1)
-            j++;
-        out.push([i, j]);
-        i = j;
-    }
-    return out;
+	const out = [];
+	for (let i = 0; i < table.length; i++) {
+		if (table[i] !== 1) continue;
+		let j = i;
+		while (j + 1 < table.length && table[j + 1] === 1) j++;
+		out.push([i, j]);
+		i = j;
+	}
+	return out;
 };
 /** A JavaScript expression testing `v` against ranges, or `undefined` if too long. */
 const rangeTest = (runs, v) => {
-    if (runs.length === 0)
-        return "false";
-    if (runs.length > 4)
-        return undefined;
-    return runs.map(([a, b]) => a === b ? `${v}===${a}` : `(${v}>=${a}&&${v}<=${b})`).join("||");
+	if (runs.length === 0) return "false";
+	if (runs.length > 4) return void 0;
+	return runs.map(([a, b]) => a === b ? `${v}===${a}` : `(${v}>=${a}&&${v}<=${b})`).join("||");
 };
 /** The inclusive ranges of `[0, size)` where `table[c] === value`. */
 const runsWhere = (table, size, value) => {
-    const out = [];
-    for (let i = 0; i < size; i++) {
-        if (table[i] !== value)
-            continue;
-        let j = i;
-        while (j + 1 < size && table[j + 1] === value)
-            j++;
-        out.push([i, j]);
-        i = j;
-    }
-    return out;
+	const out = [];
+	for (let i = 0; i < size; i++) {
+		if (table[i] !== value) continue;
+		let j = i;
+		while (j + 1 < size && table[j + 1] === value) j++;
+		out.push([i, j]);
+		i = j;
+	}
+	return out;
 };
 /** How many comparisons it takes to test a run of `[0, size)`. */
 const runCost = ([a, b], size) => a === b || a === 0 || b === size - 1 ? 1 : 2;
 /**
- * A JavaScript expression testing whether `v`, known to be in `[0, size)`,
- * is accepted by `table`, or `undefined` if that takes too many comparisons.
- * It tests the accepted runs or the rejected ones, whichever is cheaper:
- * `c!==34&&c!==92&&c>=32` rather than three two-sided ranges.
- */
+* A JavaScript expression testing whether `v`, known to be in `[0, size)`,
+* is accepted by `table`, or `undefined` if that takes too many comparisons.
+* It tests the accepted runs or the rejected ones, whichever is cheaper:
+* `c!==34&&c!==92&&c>=32` rather than three two-sided ranges.
+*/
 const tableTest = (table, v, size) => {
-    const accept = runsWhere(table, size, 1);
-    const reject = runsWhere(table, size, 0);
-    if (accept.length === 0)
-        return "false";
-    if (reject.length === 0)
-        return "true";
-    const cost = (runs) => runs.reduce((n, r) => n + runCost(r, size), 0);
-    const acceptCost = cost(accept);
-    const rejectCost = cost(reject);
-    if (Math.min(acceptCost, rejectCost) > 6)
-        return undefined;
-    const terms = acceptCost <= rejectCost
-        ? accept.map(([a, b]) => a === b ? `${v}===${a}` : a === 0 ? `${v}<=${b}` : b === size - 1 ? `${v}>=${a}` : `(${v}>=${a}&&${v}<=${b})`).join("||")
-        : reject.map(([a, b]) => a === b ? `${v}!==${a}` : a === 0 ? `${v}>${b}` : b === size - 1 ? `${v}<${a}` : `(${v}<${a}||${v}>${b})`).join("&&");
-    return `(${terms})`;
+	const accept = runsWhere(table, size, 1);
+	const reject = runsWhere(table, size, 0);
+	if (accept.length === 0) return "false";
+	if (reject.length === 0) return "true";
+	const cost = (runs) => runs.reduce((n, r) => n + runCost(r, size), 0);
+	const acceptCost = cost(accept);
+	const rejectCost = cost(reject);
+	if (Math.min(acceptCost, rejectCost) > 6) return void 0;
+	return `(${acceptCost <= rejectCost ? accept.map(([a, b]) => a === b ? `${v}===${a}` : a === 0 ? `${v}<=${b}` : b === size - 1 ? `${v}>=${a}` : `(${v}>=${a}&&${v}<=${b})`).join("||") : reject.map(([a, b]) => a === b ? `${v}!==${a}` : a === 0 ? `${v}>${b}` : b === size - 1 ? `${v}<${a}` : `(${v}<${a}||${v}>${b})`).join("&&")})`;
+};
+var Emitter = class {
+	root;
+	kind;
+	resumable;
+	constants = [];
+	constantIndex = /* @__PURE__ */ new Map();
+	functions = [];
+	rules = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
+	refs = /* @__PURE__ */ new Map();
+	closure;
+	next = 0;
+	constructor(root, kind, resumable = false) {
+		this.root = root;
+		this.kind = kind;
+		this.resumable = resumable;
+		this.closure = createClosureCompiler(kind, resumable);
+		this.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) {
+			i = this.constants.length;
+			this.constants.push(value);
+			this.constantIndex.set(value, i);
+		}
+		return `C[${i}]`;
+	}
+	/** A JavaScript literal for simple values, otherwise a constant. */
+	lit(value) {
+		if (value === void 0) return "void 0";
+		if (value === null || Predicate.isBoolean(value)) return String(value);
+		if (Predicate.isNumber(value) && Number.isFinite(value) && !Object.is(value, -0)) return String(value);
+		if (Predicate.isString(value) && value.length < 64) return JSON.stringify(value);
+		return this.const(value);
+	}
+	v(fn) {
+		const name = `v${this.next++}`;
+		fn.vars.push(name);
+		return name;
+	}
+	label() {
+		return `L${this.next++}`;
+	}
+	unit(i) {
+		return this.kind === 0 ? `I.charCodeAt(${i})` : `I[${i}]`;
+	}
+	/**
+	* How generated code reads an encoding's code units: units below `fast`
+	* are whole code points, `width` input units long. `guard(i)` says that a
+	* whole unit is available at `i`.
+	*/
+	reader(enc) {
+		if (enc === utf16le || enc === utf16be) {
+			const [lo, hi] = enc === utf16le ? ["", "+1"] : ["+1", ""];
+			return {
+				width: 2,
+				fast: 55296,
+				guard: (i) => `${i}+1<E`,
+				unit: (i) => `(I[${i}${lo}]|I[${i}${hi}]<<8)`
+			};
+		}
+		return {
+			width: 1,
+			fast: enc.unit === 1 ? fastLimit(enc) : 0,
+			guard: (i) => `${i}<E`,
+			unit: (i) => this.unit(i)
+		};
+	}
+	/** The function implementing a rule, generating it on first use. */
+	rule(p, used) {
+		const rules = this.rules[used ? 1 : 0];
+		let name = rules.get(p);
+		if (name !== void 0) return name;
+		name = `f${this.next++}`;
+		rules.set(p, name);
+		const fn = new Fn();
+		const out = used ? this.v(fn) : null;
+		const done = this.label();
+		const body = this.inline(p, used, out, `break ${done};`, fn, 0);
+		this.functions.push(`function ${name}(p){const I=$I,E=$E;${fn.vars.length > 0 ? `let ${fn.vars.join(",")};` : ""}${done}:{${body}P=p;return ${out ?? "void 0"}}return F}`);
+		return name;
+	}
+	/**
+	* Code for `p`: on success it falls through with `p` advanced and, when
+	* `out` is given, the value in `out`; on failure it runs `fail`.
+	*/
+	gen(p, used, out, fail, fn, depth) {
+		const node = nodeOf(p);
+		if (node._tag === "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);
+		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 || node._tag === "Suspend" || node._tag === "Escaped" || node._tag === "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
+	* interpreted, since it may have to report `Incomplete` there. Token code
+	* leaves `p` where it stopped reading, even when it fails.
+	*/
+	partialSafe(p, code, bad, lookahead, out, fail, fn) {
+		const ahead = Math.max(lookahead, Margin);
+		const st = this.v(fn);
+		const ok = this.v(fn);
+		const t = this.v(fn);
+		const leaf = this.label();
+		return `${st}=p;${ok}=false;${leaf}:{${bad}:{${code}${ok}=true;}if(!$S.partial||p+${ahead}<=E){if(${ok})break ${leaf};${fail}}p=${st};$S.pos=p;${t}=${this.const(p.step)}($S);if(${t}===F){${fail}}p=$S.pos;${out === null ? "" : `${out}=${t};`}}`;
+	}
+	/**
+	* Token code for string and byte input, or the parser's step for input
+	* the code can't read. In a resumable build, code that read within
+	* `lookahead` units of the end of a partial input re-runs interpreted.
+	*/
+	leaf(p, node, used, out, fail, fn, lookahead = Margin) {
+		if (!this.native(node.encoding)) return this.delegate(p, used, out, fail, fn);
+		if (!this.resumable) return this.token(node, out, fail, fn) ?? this.delegate(p, used, out, fail, fn);
+		const bad = this.label();
+		const code = this.token(node, out, `break ${bad};`, fn);
+		if (code === void 0) return this.delegate(p, used, out, fail, fn);
+		return this.partialSafe(p, code, bad, lookahead, out, fail, fn);
+	}
+	/** Whether a token parser reads array input as such (`Token`'s, on an array). */
+	array(enc) {
+		return this.kind === 2 && enc === void 0;
+	}
+	/**
+	* Token code for array input, built by `code` with its failure code. Its
+	* set's predicate (or membership test) is called on the element, as the
+	* interpreter calls it. In a resumable build, code that read the last
+	* element of a partial input re-runs interpreted.
+	*/
+	arrayLeaf(p, code, out, fail, fn) {
+		if (!this.resumable) return code(fail);
+		const bad = this.label();
+		return this.partialSafe(p, code(`break ${bad};`), bad, 1, out, fail, fn);
+	}
+	arrayAny(out, fail) {
+		return `if(p>=E){${BT}${fail}}${out === null ? "" : `${out}=I[p];`}p++;`;
+	}
+	arrayOneOf(node, out, fail) {
+		return `if(p>=E||${this.const(compileAny(node.set).forCode.token)}(I[p])===${node.negate}){${BT}${fail}}${out === null ? "" : `${out}=I[p];`}p++;`;
+	}
+	arrayTakeWhile(node, out, fail, fn) {
+		const m = this.const(compileAny(node.set).forCode.token);
+		const st = this.v(fn);
+		return `${st}=p;while(p<E${node.max === Infinity ? "" : `&&p-${st}<${node.max}`}&&${m}(I[p])!==${node.negate})p++;` + (node.min > 0 ? `if(p-${st}<${node.min}){${BT}${fail}}` : "") + (out === null ? "" : `${out}=I.slice(${st},p);`);
+	}
+	call(name, out, fail) {
+		if (out === null) return `if(${name}(p)===F){${fail}}p=P;`;
+		return `${out}=${name}(p);if(${out}===F){${fail}}p=P;`;
+	}
+	/** Runs the closure-compiled step of `p` on the shared state. */
+	delegate(p, used, out, fail, fn) {
+		const step = this.const(this.closure.compile(p, used));
+		const t = out ?? this.v(fn);
+		return `$S.pos=p;${t}=${step}($S);if(${t}===F){${fail}}p=$S.pos;`;
+	}
+	native(enc) {
+		return enc === void 0 ? this.kind !== 2 : kindOfEncoding(enc) === this.kind;
+	}
+	inline(p, used, out, fail, fn, depth) {
+		const node = nodeOf(p);
+		const set = (value) => out === null ? "" : `${out}=${value};`;
+		const d = depth + 1;
+		switch (node._tag) {
+			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 "Location": return set("p");
+			case "RestLen": return set("E-p");
+			case "Suspend": return this.call(this.rule(node.resolve(), used), out, fail);
+			case "Any":
+				if (this.array(node.encoding)) return this.arrayLeaf(p, (f) => this.arrayAny(out, f), out, fail, fn);
+				return this.leaf(p, node, used, out, fail, fn);
+			case "OneOf":
+				if (this.array(node.encoding)) return this.arrayLeaf(p, (f) => this.arrayOneOf(node, out, f), out, fail, fn);
+				return this.leaf(p, node, used, out, fail, fn);
+			case "TakeWhile":
+				if (this.array(node.encoding)) return this.arrayLeaf(p, (f) => this.arrayTakeWhile(node, out, f, fn), out, fail, fn);
+				return this.leaf(p, node, used, out, fail, fn);
+			case "Literal": return this.leaf(p, node, used, out, fail, fn, node.literal.length * 4);
+			case "Escaped":
+				if (!this.native(node.encoding) || this.resumable) return this.delegate(p, used, out, fail, fn);
+				return this.escaped(p, node, out, fail, fn, d);
+			case "Map": {
+				if (!used) return this.gen(node.self, false, null, fail, fn, d);
+				if (node.f === toFloat && out !== null) {
+					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);
+				const t = this.v(fn);
+				return this.gen(node.self, true, t, fail, fn, d) + set(`${this.const(node.f)}(${t})`);
+			}
+			case "As": return this.gen(node.self, false, null, fail, fn, d) + (used ? set(this.lit(node.value)) : "");
+			case "Tap": {
+				const t = out ?? this.v(fn);
+				return this.gen(node.self, true, t, fail, fn, d) + `${this.const(node.f)}(${t});`;
+			}
+			case "TryMap":
+			case "FilterMap": {
+				const t = this.v(fn);
+				const r = this.v(fn);
+				const [tag, field] = node._tag === "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 "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}}`;
+			}
+			case "FlatMap": {
+				const t = this.v(fn);
+				const r = out ?? this.v(fn);
+				this.closure.note(p, node, "the parser returned by the function runs interpreted");
+				return this.gen(node.self, true, t, fail, fn, d) + `$S.pos=p;${r}=${this.const(node.f)}(${t}).step($S);if(${r}===F){${fail}}p=$S.pos;`;
+			}
+			case "Taken": {
+				if (node.encoding !== void 0 && !this.native(node.encoding)) return this.delegate(p, used, out, fail, fn);
+				const st = this.v(fn);
+				const body = `${st}=p;` + this.gen(node.self, false, null, fail, fn, d);
+				if (out === null && node.encoding === void 0) return body;
+				if (node.encoding === void 0) return body + set(this.kind === 0 ? `I.slice(${st},p)` : this.kind === 1 ? `I.subarray(${st},p)` : `$S.slice(${st},p)`);
+				const t = out ?? this.v(fn);
+				return body + `${t}=R.textOf(${this.const(node.encoding)},${fastLimit(node.encoding)},$S,${st},p);if(${t}===F){${fail}}`;
+			}
+			case "WithTaken":
+			case "WithSpan": {
+				const st = this.v(fn);
+				const t = this.v(fn);
+				const extra = node._tag === "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 "Span": {
+				const st = this.v(fn);
+				return `${st}=p;` + this.gen(node.self, false, null, fail, fn, d) + set(`{start:${st},end:p}`);
+			}
+			case "Mode": {
+				const ok = this.label();
+				const bad = this.label();
+				return `${ok}:{${bad}:{${this.gen(node.self, used, out, `break ${bad};`, fn, d)}break ${ok};}if($S.mode===${JSON.stringify(node.from)})$S.mode=${JSON.stringify(node.to)};${fail}}`;
+			}
+			case "Context":
+			case "Expected":
+			case "MapError":
+			case "OrFail":
+			case "Trace":
+			case "Syntax":
+			case "RetryAfter": return this.gen(node.self, used, out, fail, fn, d);
+			case "ResumeAfter": {
+				if (!used) return this.gen(node.self, false, null, fail, fn, d);
+				const t = this.v(fn);
+				return this.gen(node.self, true, t, fail, fn, d) + set(`R.some(${t})`);
+			}
+			case "Opt":
+			case "OrElseSucceed": {
+				const st = this.v(fn);
+				const ok = this.label();
+				const bad = this.label();
+				const t = out === null ? null : this.v(fn);
+				const some = node._tag === "Opt" ? `R.some(${t})` : `${t}`;
+				const orElse = node._tag === "Opt" ? "R.none()" : `${this.const(node.value)}()`;
+				return `${st}=p;${ok}:{${bad}:{${this.gen(node.self, used, t, `break ${bad};`, fn, d)}${set(some)}break ${ok};}if($S.mode!=="Backtrack"){${fail}}p=${st};${set(orElse)}}`;
+			}
+			case "Peek": {
+				const st = this.v(fn);
+				return `${st}=p;${this.gen(node.self, used, out, fail, fn, d)}p=${st};`;
+			}
+			case "Not": {
+				const st = this.v(fn);
+				const ok = this.label();
+				const bad = this.label();
+				return `${st}=p;${ok}:{${bad}:{${this.gen(node.self, false, null, `break ${bad};`, fn, d)}p=${st};${BT}${fail}}if($S.mode!=="Backtrack"){${fail}}p=${st};}${set("void 0")}`;
+			}
+			case "Seq": return this.seq(node, used, out, fail, fn, d);
+			case "Struct": {
+				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));
+				const code = node.parsers.map((q, i) => this.gen(q, true, vars[i], fail, fn, d)).join("");
+				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 "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);
+				const y = this.v(fn);
+				return this.gen(node.self, true, x, fail, fn, d) + this.gen(node.that, true, y, fail, fn, d) + `${out}=${this.const(node.f)}(${x},${y});`;
+			}
+			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 "Separated": return this.separated(node, used, out, fail, fn, d);
+			default: return this.delegate(p, used, out, fail, fn);
+		}
+	}
+	/**
+	* `Ascii.float` and `Text.float` (`map(floatText, toFloat)`): numbers in
+	* decimal notation are matched and converted in one pass by
+	* `scanFloatString` or `scanFloatBytes`, without slicing the input; the
+	* rest (`nan`, `inf`, failures before a digit) runs the parser. Returns
+	* `undefined` when this does not apply.
+	*/
+	float(node, out, fail, fn, d) {
+		if (!floatTexts.has(node.self) || this.kind === 2) return void 0;
+		let taken = nodeOf(node.self);
+		while (taken._tag === "Expected") taken = nodeOf(taken.self);
+		if (taken._tag !== "Taken") return void 0;
+		const enc = taken.encoding;
+		if (enc !== void 0 && !(this.native(enc) && enc.unit === 1 && enc.asciiCompatible)) return void 0;
+		const t = this.v(fn);
+		const scan = this.const(floatScan);
+		const near = this.resumable ? `||$S.partial&&${scan}.read+${Margin}>E` : "";
+		return `${out}=${this.kind === 0 ? "R.scanFloatString" : "R.scanFloatBytes"}(I,p,E);if(${out}===void 0${near}){${this.gen(node.self, true, t, fail, fn, d)}${out}=${this.const(toFloat)}(${t})}else if(${out}===F){${BT}${fail}}else p=${scan}.end;`;
+	}
+	seq(node, used, out, fail, fn, d) {
+		const output = node.output;
+		if (out === null || !used) return node.parsers.map((q) => this.gen(q, false, null, fail, fn, d)).join("");
+		if (Predicate.isNumber(output)) return node.parsers.map((q, i) => this.gen(q, i === output, i === output ? out : null, fail, fn, d)).join("");
+		const keep = (i) => output === "tuple" || output.includes(i);
+		const vars = node.parsers.map((_, i) => keep(i) ? this.v(fn) : null);
+		return node.parsers.map((q, i) => this.gen(q, keep(i), vars[i], fail, fn, d)).join("") + `${out}=[${vars.filter((v) => v !== null).join(",")}];`;
+	}
+	/** A test that the unit `u` may start `first` (false for -1, the end of the input). */
+	startTest(first, u) {
+		const runs = runsOf(first.units);
+		const small = rangeTest(runs, u);
+		const low = small ?? `${this.const(first.units)}[${u}]===1`;
+		if (!first.high) return small !== void 0 ? `(${low})` : `(${u}<${TableSize}&&${low})`;
+		return `(${u}>=${TableSize}||${low})`;
+	}
+	alt(node, used, out, fail, fn, d) {
+		const parsers = node.parsers;
+		if (parsers.length === 0) return `${BT}${fail}`;
+		if (parsers.length === 1) return this.gen(parsers[0], used, out, fail, fn, d);
+		const firsts = this.kind === 2 ? void 0 : parsers.map((q) => this.closure.firsts.of(q));
+		const prune = firsts !== void 0 && planAlt(firsts) !== void 0;
+		const st = this.v(fn);
+		const u = prune ? this.v(fn) : "";
+		const done = this.label();
+		const read = this.resumable ? `$S.partial&&p+${Margin}>E?-2:p<E?${this.unit("p")}:-1` : `p<E?${this.unit("p")}:-1`;
+		let code = `${st}=p;${prune ? `${u}=${read};` : ""}${done}:{`;
+		parsers.forEach((q, i) => {
+			const bad = this.label();
+			const branch = `${bad}:{${this.gen(q, used, out, `break ${bad};`, fn, d)}break ${done};}if($S.mode!=="Backtrack"){${fail}}p=${st};`;
+			const f = firsts?.[i];
+			code += prune && f !== void 0 && f.mode === Strict ? `if(${this.resumable ? `${u}===-2||` : ""}${this.startTest(f, u)}){${branch}}` : branch;
+		});
+		return code + `${BT}${fail}}`;
+	}
+	dispatch(p, node, used, out, fail, fn, d) {
+		const choose = this.const(node.choose);
+		if (node.cases === void 0) {
+			this.closure.note(p, node, "the parser returned by the function of cases runs interpreted");
+			const st = this.v(fn);
+			const k = this.v(fn);
+			const q = this.v(fn);
+			const r = out ?? this.v(fn);
+			return `${st}=p;${this.gen(node.selector, true, k, fail, fn, d)}${q}=${choose}(${k});if(${q}===void 0){p=${st};${BT}${fail}}$S.pos=p;${r}=${q}.step($S);if(${r}===F){${fail}}p=$S.pos;`;
+		}
+		const cases = /* @__PURE__ */ new Map();
+		for (const key of Reflect.ownKeys(node.cases)) {
+			const q = node.cases[key];
+			if (!cases.has(q)) cases.set(q, cases.size);
+		}
+		if (node.otherwise !== void 0 && !cases.has(node.otherwise)) cases.set(node.otherwise, cases.size);
+		const index = this.const(cases);
+		const general = (inline) => {
+			const st = this.v(fn);
+			const k = this.v(fn);
+			const q = this.v(fn);
+			const sw = this.label();
+			let code = `${st}=p;${this.gen(node.selector, true, k, fail, fn, d)}${q}=${choose}(${k});if(${q}===void 0){p=${st};${BT}${fail}}${sw}:switch(${index}.get(${q})){`;
+			for (const [c, i] of cases) {
+				const body = inline ? this.gen(c, used, out, fail, fn, d) : this.call(this.rule(c, used), out, fail);
+				code += `case ${i}:{${body}break ${sw};}`;
+			}
+			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 = sel._tag === "Peek";
+		if (peek) sel = nodeOf(sel.self);
+		if (sel._tag !== "Any" || !this.native(sel.encoding)) return general(true);
+		const enc = sel.encoding;
+		const r = enc === void 0 ? void 0 : this.reader(enc);
+		const limit = r === void 0 ? this.kind === 0 ? 55296 : TableSize : Math.min(r.fast, 55296);
+		const size = Math.min(limit, TableSize);
+		if (size === 0) return general(true);
+		const groups = /* @__PURE__ */ new Map();
+		for (let unit = 0; unit < size; unit++) {
+			const q = node.choose(enc === void 0 && this.kind === 1 ? unit : charOf(unit));
+			if (q === void 0) continue;
+			let g = groups.get(q);
+			if (g === void 0) groups.set(q, g = []);
+			g.push(unit);
+		}
+		const u = this.v(fn);
+		const sw = this.label();
+		const read = r === void 0 ? `p<E?${this.unit("p")}:-1` : `${r.guard("p")}?${r.unit("p")}:p<E?${size}:-1`;
+		let code = `${u}=${this.resumable ? `$S.partial&&p+${Margin}>E?${size}:` : ""}${read};${sw}:switch(${u}){`;
+		for (const [q, units] of groups) code += units.map((x) => `case ${x}:`).join("") + `{${peek ? "" : `p+=${r?.width ?? 1};`}${this.gen(q, used, out, fail, fn, d)}break ${sw};}`;
+		code += `case -1:{${BT}${fail}}default:{if(${u}<${size}){${BT}${fail}}${general(false)}}}`;
+		return code;
+	}
+	repeat(node, used, out, fail, fn, d, collect) {
+		const { max, min } = node;
+		const loop = this.label();
+		const bad = this.label();
+		const n = this.v(fn);
+		const st = this.v(fn);
+		const isFold = node._tag === "Fold";
+		const cond = isFold ? node.while : void 0;
+		const keep = out !== null && used && collect === void 0;
+		const tracked = keep || cond !== void 0;
+		const x = tracked ? this.v(fn) : null;
+		const acc = out !== null && keep ? out : this.v(fn);
+		let init = collect?.init ?? "";
+		let add = "";
+		if (tracked) {
+			if (isFold) {
+				init = `${acc}=${this.const(node.init)}();`;
+				add = `${acc}=${this.const(node.f)}(${acc},${x});`;
+			} else {
+				init = `${acc}=[];`;
+				add = `${acc}.push(${x});`;
+			}
+		}
+		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 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);
+	}
+	/**
+	* In a resumable build, a repetition entered at `entry` may restart from a
+	* checkpoint (`restore`, with the checkpoint in `cp`), or return the result
+	* of a `Done` one; a resumed repetition records its result when it ends.
+	*/
+	resumePoint(fn) {
+		const key = this.const({});
+		const entry = this.v(fn);
+		const resumed = this.v(fn);
+		const done = this.label();
+		return {
+			key,
+			entry,
+			resumed,
+			wrap: (value, restore, fresh, body) => `${entry}=p;${resumed}=false;${done}:{if($S.resume!==void 0){const cp=R.take($S,${key},p);if(cp instanceof R.Done){p=cp.pos;${value}=cp.value;break ${done};}if(cp!==void 0){${restore}${resumed}=true;}}if(!${resumed}){${fresh}}${body}if(${resumed})R.done($S,${key},${entry},${value},p);}`
+		};
+	}
+	separated(node, used, out, fail, fn, d, collect) {
+		const { max, min } = node;
+		const keep = out !== null && used && collect === void 0;
+		if (max === 0) return collect !== void 0 ? collect.init + collect.finish : keep ? `${out}=[];` : "";
+		const x = keep ? this.v(fn) : null;
+		const acc = out !== null && keep ? out : this.v(fn);
+		const n = this.v(fn);
+		const st = this.v(fn);
+		const done = this.label();
+		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 attempt = (body, success, fatal, checkpoint) => {
+			const ok = this.label();
+			const bad = this.label();
+			return `${ok}:{${bad}:{${body(`break ${bad};`)}${success}break ${ok};}${checkpoint}if($S.mode!=="Backtrack"${fatal}){${fail}}p=${st};break ${done};}`;
+		};
+		const self = (f) => collect === void 0 ? this.gen(node.self, keep, x, f, fn, d) : collect.element(f, "");
+		const sep = (f) => this.gen(node.separator, false, null, f, fn, d);
+		const check = max === Infinity ? `if(p===${st}){$S.mode="Cut";${fail}}` : "";
+		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}}`);
+	}
+	/**
+	* `map(self, Object.fromEntries)`, where `buildsEntries(self)`: builds the
+	* object directly, assigning each entry as it is parsed (see
+	* `internal/entries.ts`), without the pairs and their array. `cut`,
+	* `preceded`, `terminated` and diagnostics around the repetition are
+	* compiled as usual around it.
+	*/
+	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 node._tag === "Repeat" ? this.repeat(node, true, out, fail, fn, d, collect) : this.separated(node, true, out, fail, fn, d, collect);
+			}
+			default: 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) {
+		return tableTest(accept, c, size) ?? `${this.const(accept)}[${c}]===1`;
+	}
+	/** An expression: is the code point `c` (at least `TableSize`) accepted? */
+	memberHigh(set, negate, c) {
+		if (set.ranges !== void 0 && !set.ranges.some(([, b]) => b >= TableSize)) return negate ? "true" : "false";
+		return `${this.const(set.test)}(${c})!==${negate}`;
+	}
+	/**
+	* An expression: does a `Text` set accept the unit `c`, known to be below
+	* `r.fast`? Code points from `TableSize` up are tested by the set's
+	* function, unless its ranges show they are all rejected.
+	*/
+	textAccepts(r, cs, accept, negate, c) {
+		if (r.fast <= TableSize) return `(${this.member(accept, c, r.fast)})`;
+		const member = this.member(accept, c);
+		if (reachesAbove(cs, TableSize)) return `(${c}<${TableSize}?${member}:${this.const(cs.test)}(${c})!==${negate})`;
+		return negate ? `(${c}>=${TableSize}||${member})` : `(${c}<${TableSize}&&${member})`;
+	}
+	/**
+	* An expression: does a `Text` set reject `c`, a code point that `decode`
+	* returned? The built-in encodings only decode code points from `r.fast`
+	* up there.
+	*/
+	textRejectsDecoded(enc, r, cs, negate, c) {
+		if (r.fast > 0 && builtinEncodings.has(enc) && !reachesAbove(cs, r.fast)) return String(!negate);
+		return `${this.const(cs.test)}(${c})===${negate}`;
+	}
+	token(node, out, fail, fn) {
+		const set = (value) => out === null ? "" : `${out}=${value};`;
+		const enc = node.encoding;
+		const kind = this.kind;
+		const failBT = `{${BT}${fail}}`;
+		switch (node._tag) {
+			case "Any": {
+				if (enc === void 0) {
+					if (kind === 1) return `if(p>=E)${failBT}${set("I[p]")}p++;`;
+					const c = this.v(fn);
+					return `if(p>=E)${failBT}${c}=I.charCodeAt(p);if(${c}>=55296&&${c}<=56319&&p+1<I.length&&(I.charCodeAt(p+1)&64512)===56320){${set("I.slice(p,p+2)")}p+=2}else{${set("I[p]")}p++}`;
+				}
+				const r = this.reader(enc);
+				const c = this.v(fn);
+				const dec = `${this.const(enc.decode)}(I,p,E)`;
+				return `if(p>=E)${failBT}` + (r.fast > 0 ? `if(${r.guard("p")}&&(${c}=${r.unit("p")})<${r.fast}){${set(`R.charOf(${c})`)}p+=${r.width}}else` : "") + `{${c}=${dec};if(${c}<0)${failBT}${set(`R.charOf(${c})`)}p+=${this.const(enc.width)}(${c})}`;
+			}
+			case "Literal": {
+				const lit = node.literal;
+				if (enc !== void 0) {
+					if (node.caseless) return void 0;
+					const encoded = enc.encode(lit);
+					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);
+				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);
+			}
+			case "OneOf": {
+				const negate = node.negate;
+				const cs = enc === void 0 ? tokenSet(node.set, kind) : textSet(node.set);
+				const accept = acceptTable(cs, negate);
+				const c = this.v(fn);
+				const value = (len) => this.kind === 0 ? `I.slice(p,p+${len})` : `I[p]`;
+				if (enc === void 0) {
+					if (kind === 1) return `if(p>=E)${failBT}${c}=I[p];if(!(${this.member(accept, c)}))${failBT}${set("I[p]")}p++;`;
+					const cp = this.v(fn);
+					if (!negate && this.memberHigh(cs, negate, cp) === "false") return `if(p>=E)${failBT}${c}=I.charCodeAt(p);if(${c}>=${TableSize}||!(${this.member(accept, c)}))${failBT}${set("I[p]")}p++;`;
+					return `if(p>=E)${failBT}${c}=I.charCodeAt(p);if(${c}<${TableSize}){if(!(${this.member(accept, c)}))${failBT}${set("I[p]")}p++}else{${cp}=${c};if(${c}>=55296&&${c}<=56319&&p+1<I.length){const d=I.charCodeAt(p+1);if((d&64512)===56320)${cp}=((${c}-55296)<<10)+(d-56320)+65536}if(!(${this.memberHigh(cs, negate, cp)}))${failBT}if(${cp}>65535){${set(value("2"))}p+=2}else{${set("I[p]")}p++}}`;
+				}
+				const r = this.reader(enc);
+				return `if(p>=E)${failBT}` + (r.fast > 0 ? `if(${r.guard("p")}&&(${c}=${r.unit("p")})<${r.fast}){if(!${this.textAccepts(r, cs, accept, negate, c)})${failBT}${set(`R.charOf(${c})`)}p+=${r.width}}else` : "") + `{${c}=${this.const(enc.decode)}(I,p,E);if(${c}<0||${this.textRejectsDecoded(enc, r, cs, negate, c)})${failBT}${set(`R.charOf(${c})`)}p+=${this.const(enc.width)}(${c})}`;
+			}
+			case "TakeWhile": return this.takeWhile(node, out, fail, fn);
+		}
+	}
+	/** Matches literal units at `p`, advancing past them. */
+	literalUnits(codes, caseless, fail) {
+		const len = codes.length;
+		if (len === 0) return "";
+		const test = (c, i) => {
+			const at = this.unit(i === 0 ? "p" : `p+${i}`);
+			if (caseless && isLetter(c)) return `(${at}|32)===${lowerAscii(c)}`;
+			return `${at}===${c}`;
+		};
+		if (len <= 8) return `if(!(${codes.map(test).join("&&")})){${BT}${fail}}p+=${len};`;
+		if (this.kind === 0 && !caseless) {
+			const str = String.fromCharCode(...codes);
+			return `if(!I.startsWith(${JSON.stringify(str)},p)){${BT}${fail}}p+=${len};`;
+		}
+		const expect = this.const(Uint8Array.from(caseless ? codes.map(lowerAscii) : codes));
+		const lower = caseless ? `${this.const(lowerAscii)}` : "";
+		return `if(E-p<${len}){${BT}${fail}}for(let i=0;i<${len};i++)if(${lower}(${this.unit("p+i")})!==${expect}[i]){${BT}${fail}}p+=${len};`;
+	}
+	takeWhile(node, out, fail, fn) {
+		const enc = node.encoding;
+		const { max, min, negate } = node;
+		const kind = this.kind;
+		const cs = enc === void 0 ? tokenSet(node.set, kind) : textSet(node.set);
+		const accept = acceptTable(cs, negate);
+		const st = this.v(fn);
+		const c = this.v(fn);
+		const n = this.v(fn);
+		const loop = this.label();
+		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 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);
+		if (kind === 1 && (enc === void 0 || fastLimit(enc) >= TableSize)) return `${head}if(!(${member}))break;p++;${count}}${finish}`;
+		if (enc !== void 0) {
+			const r = this.reader(enc);
+			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 fast = 55296;
+		const small = TableSize;
+		const highTest = (v) => this.memberHigh(cs, negate, v);
+		const cp = this.v(fn);
+		const never = highTest(c) === "false";
+		const always = highTest(c) === "true";
+		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}`;
+	}
+	escaped(p, node, out, fail, fn, d) {
+		const enc = node.encoding;
+		const ctrl = node.control;
+		const r = enc === void 0 ? void 0 : this.reader(enc);
+		if (r !== void 0 && !(ctrl < r.fast)) return this.delegate(p, !node.raw, out, fail, fn);
+		const raw = node.raw;
+		const acc = raw ? null : out ?? this.v(fn);
+		const x = raw ? null : this.v(fn);
+		const b = this.v(fn);
+		const st = this.v(fn);
+		const okv = this.v(fn);
+		const loop = this.label();
+		const bad = this.label();
+		const normal = this.gen(node.normal, !raw, x, `break ${bad};`, fn, d);
+		const escape = this.gen(node.escape, !raw, x, 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 ctrlTest = r === void 0 ? `p<E&&${this.unit("p")}===${ctrl}` : `${r.guard("p")}&&${r.unit("p")}===${ctrl}`;
+		return `${raw ? `${st}=p;` : `${acc}="";`}${loop}:while(p<E){${b}=p;${okv}=false;${bad}:{${normal}${okv}=true;}if(${okv}){${onNormal}}else{if($S.mode!=="Backtrack"){${fail}}p=${b}}if(${ctrlTest}){p+=${r?.width ?? 1};${escape}${raw ? "" : `${acc}+=${x};`}}else break ${loop};}` + (raw && out !== null ? `${out}=${slice};` : "");
+	}
 };
-class Emitter {
-    root;
-    kind;
-    resumable;
-    constants = [];
-    constantIndex = new Map();
-    functions = [];
-    rules = [new Map(), new Map()];
-    refs = new Map();
-    closure;
-    next = 0;
-    constructor(root, kind, resumable = false) {
-        this.root = root;
-        this.kind = kind;
-        this.resumable = resumable;
-        this.closure = createClosureCompiler(kind, resumable);
-        this.countRefs(root);
-    }
-    get fallbacks() {
-        return this.closure.fallbacks;
-    }
-    /** Counts the distinct parents of each parser. */
-    countRefs(root) {
-        const seen = new Set();
-        const stack = [root];
-        while (stack.length > 0) {
-            const 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 === undefined) {
-            i = this.constants.length;
-            this.constants.push(value);
-            this.constantIndex.set(value, i);
-        }
-        return `C[${i}]`;
-    }
-    /** A JavaScript literal for simple values, otherwise a constant. */
-    lit(value) {
-        if (value === undefined)
-            return "void 0";
-        if (value === null || typeof value === "boolean")
-            return String(value);
-        if (typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0))
-            return String(value);
-        if (typeof value === "string" && value.length < 64)
-            return JSON.stringify(value);
-        return this.const(value);
-    }
-    v(fn) {
-        const name = `v${this.next++}`;
-        fn.vars.push(name);
-        return name;
-    }
-    label() {
-        return `L${this.next++}`;
-    }
-    unit(i) {
-        return this.kind === 0 ? `I.charCodeAt(${i})` : `I[${i}]`;
-    }
-    /**
-     * How generated code reads an encoding's code units: units below `fast`
-     * are whole code points, `width` input units long. `guard(i)` says that a
-     * whole unit is available at `i`.
-     */
-    reader(enc) {
-        if (enc === utf16le || enc === utf16be) {
-            const [lo, hi] = enc === utf16le ? ["", "+1"] : ["+1", ""];
-            return {
-                width: 2,
-                fast: 0xd800,
-                guard: (i) => `${i}+1<E`,
-                unit: (i) => `(I[${i}${lo}]|I[${i}${hi}]<<8)`
-            };
-        }
-        return { width: 1, fast: enc.unit === 1 ? fastLimit(enc) : 0, guard: (i) => `${i}<E`, unit: (i) => this.unit(i) };
-    }
-    /** The function implementing a rule, generating it on first use. */
-    rule(p, used) {
-        const rules = this.rules[used ? 1 : 0];
-        let name = rules.get(p);
-        if (name !== undefined)
-            return name;
-        name = `f${this.next++}`;
-        rules.set(p, name);
-        const fn = new Fn();
-        const out = used ? this.v(fn) : null;
-        const done = this.label();
-        const body = this.inline(p, used, out, `break ${done};`, fn, 0);
-        this.functions.push(`function ${name}(p){const I=$I,E=$E;${fn.vars.length > 0 ? `let ${fn.vars.join(",")};` : ""}` +
-            `${done}:{${body}P=p;return ${out ?? "void 0"}}return F}`);
-        return name;
-    }
-    /**
-     * Code for `p`: on success it falls through with `p` advanced and, when
-     * `out` is given, the value in `out`; on failure it runs `fail`.
-     */
-    gen(p, used, out, fail, fn, depth) {
-        const node = nodeOf(p);
-        if (node._tag === "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);
-        }
-        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 || node._tag === "Suspend" || node._tag === "Escaped" || node._tag === "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
-     * interpreted, since it may have to report `Incomplete` there. Token code
-     * leaves `p` where it stopped reading, even when it fails.
-     */
-    partialSafe(p, code, bad, lookahead, out, fail, fn) {
-        const ahead = Math.max(lookahead, Margin);
-        const st = this.v(fn);
-        const ok = this.v(fn);
-        const t = this.v(fn);
-        const leaf = this.label();
-        return `${st}=p;${ok}=false;${leaf}:{${bad}:{${code}${ok}=true;}` +
-            `if(!$S.partial||p+${ahead}<=E){if(${ok})break ${leaf};${fail}}` +
-            `p=${st};$S.pos=p;${t}=${this.const(p.step)}($S);if(${t}===F){${fail}}p=$S.pos;${out === null ? "" : `${out}=${t};`}}`;
-    }
-    call(name, out, fail) {
-        if (out === null)
-            return `if(${name}(p)===F){${fail}}p=P;`;
-        return `${out}=${name}(p);if(${out}===F){${fail}}p=P;`;
-    }
-    /** Runs the closure-compiled step of `p` on the shared state. */
-    delegate(p, used, out, fail, fn) {
-        const step = this.const(this.closure.compile(p, used));
-        const t = out ?? this.v(fn);
-        return `$S.pos=p;${t}=${step}($S);if(${t}===F){${fail}}p=$S.pos;`;
-    }
-    native(enc) {
-        return enc === undefined ? this.kind !== 2 : kindOfEncoding(enc) === this.kind;
-    }
-    inline(p, used, out, fail, fn, depth) {
-        const node = nodeOf(p);
-        const set = (value) => out === null ? "" : `${out}=${value};`;
-        const d = depth + 1;
-        switch (node._tag) {
-            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 "Location":
-                return set("p");
-            case "RestLen":
-                return set("E-p");
-            case "Suspend":
-                return this.call(this.rule(node.resolve(), used), out, fail);
-            case "Any":
-            case "Literal":
-            case "OneOf":
-            case "TakeWhile": {
-                if (!this.native(node.encoding))
-                    return this.delegate(p, used, out, fail, fn);
-                if (!this.resumable)
-                    return this.token(node, out, fail, fn) ?? this.delegate(p, used, out, fail, fn);
-                const bad = this.label();
-                const code = this.token(node, out, `break ${bad};`, fn);
-                if (code === undefined)
-                    return this.delegate(p, used, out, fail, fn);
-                return this.partialSafe(p, code, bad, node._tag === "Literal" ? node.literal.length * 4 : Margin, out, fail, fn);
-            }
-            case "Escaped": {
-                // Streaming builds use the closure compiler's escapes, which keep checkpoints
-                if (!this.native(node.encoding) || this.resumable)
-                    return this.delegate(p, used, out, fail, fn);
-                return this.escaped(p, node, out, fail, fn, d);
-            }
-            case "Map": {
-                if (!used)
-                    return this.gen(node.self, false, null, fail, fn, d);
-                if (node.f === toFloat && out !== null) {
-                    const code = this.float(node, out, fail, fn, d);
-                    if (code !== undefined)
-                        return code;
-                }
-                // Streaming builds keep the array, which their checkpoints hold
-                if (node.f === fromEntries && out !== null && !this.resumable && entriesShape(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})`);
-            }
-            case "As":
-                return this.gen(node.self, false, null, fail, fn, d) + (used ? set(this.lit(node.value)) : "");
-            case "Tap": {
-                const t = out ?? this.v(fn);
-                return this.gen(node.self, true, t, fail, fn, d) + `${this.const(node.f)}(${t});`;
-            }
-            case "TryMap":
-            case "FilterMap": {
-                const t = this.v(fn);
-                const r = this.v(fn);
-                const [tag, field] = node._tag === "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 "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}}`;
-            }
-            case "FlatMap": {
-                const t = this.v(fn);
-                const r = out ?? this.v(fn);
-                this.closure.note(p, node, "the parser returned by the function runs interpreted");
-                return this.gen(node.self, true, t, fail, fn, d) +
-                    `$S.pos=p;${r}=${this.const(node.f)}(${t}).step($S);if(${r}===F){${fail}}p=$S.pos;`;
-            }
-            case "Taken": {
-                if (node.encoding !== undefined && !this.native(node.encoding))
-                    return this.delegate(p, used, out, fail, fn);
-                const st = this.v(fn);
-                const body = `${st}=p;` + this.gen(node.self, false, null, fail, fn, d);
-                if (out === null && node.encoding === undefined)
-                    return body;
-                if (node.encoding === undefined) {
-                    return body + set(this.kind === 0 ? `I.slice(${st},p)` : this.kind === 1 ? `I.subarray(${st},p)` : `$S.slice(${st},p)`);
-                }
-                const t = out ?? this.v(fn);
-                const enc = this.const(node.encoding);
-                return body + `${t}=R.textOf(${enc},${fastLimit(node.encoding)},$S,${st},p);if(${t}===F){${fail}}`;
-            }
-            case "WithTaken":
-            case "WithSpan": {
-                const st = this.v(fn);
-                const t = this.v(fn);
-                const extra = node._tag === "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 "Span": {
-                const st = this.v(fn);
-                return `${st}=p;` + this.gen(node.self, false, null, fail, fn, d) + set(`{start:${st},end:p}`);
-            }
-            case "Mode": {
-                const ok = this.label();
-                const bad = this.label();
-                return `${ok}:{${bad}:{${this.gen(node.self, used, out, `break ${bad};`, fn, d)}break ${ok};}` +
-                    `if($S.mode===${JSON.stringify(node.from)})$S.mode=${JSON.stringify(node.to)};${fail}}`;
-            }
-            case "Context":
-            case "Expected":
-            case "MapError":
-            case "OrFail":
-            case "Trace":
-            case "RetryAfter":
-                return this.gen(node.self, used, out, fail, fn, d);
-            case "ResumeAfter": {
-                if (!used)
-                    return this.gen(node.self, false, null, fail, fn, d);
-                const t = this.v(fn);
-                return this.gen(node.self, true, t, fail, fn, d) + set(`R.some(${t})`);
-            }
-            case "Opt":
-            case "OrElseSucceed": {
-                const st = this.v(fn);
-                const ok = this.label();
-                const bad = this.label();
-                const t = out === null ? null : this.v(fn);
-                const some = node._tag === "Opt" ? `R.some(${t})` : t;
-                const orElse = node._tag === "Opt" ? "R.none()" : `${this.const(node.value)}()`;
-                return `${st}=p;${ok}:{${bad}:{${this.gen(node.self, used, t, `break ${bad};`, fn, d)}${set(some)}break ${ok};}` +
-                    `if($S.mode!=="Backtrack"){${fail}}p=${st};${set(orElse)}}`;
-            }
-            case "Peek": {
-                const st = this.v(fn);
-                return `${st}=p;${this.gen(node.self, used, out, fail, fn, d)}p=${st};`;
-            }
-            case "Not": {
-                const st = this.v(fn);
-                const ok = this.label();
-                const bad = this.label();
-                return `${st}=p;${ok}:{${bad}:{${this.gen(node.self, false, null, `break ${bad};`, fn, d)}p=${st};${BT}${fail}}` +
-                    `if($S.mode!=="Backtrack"){${fail}}p=${st};}${set("void 0")}`;
-            }
-            case "Seq":
-                return this.seq(node, used, out, fail, fn, d);
-            case "Struct": {
-                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));
-                const code = node.parsers.map((q, i) => this.gen(q, true, vars[i], fail, fn, d)).join("");
-                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 "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);
-                const y = this.v(fn);
-                return this.gen(node.self, true, x, fail, fn, d) + this.gen(node.that, true, y, fail, fn, d) +
-                    `${out}=${this.const(node.f)}(${x},${y});`;
-            }
-            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 "Separated":
-                return this.separated(node, used, out, fail, fn, d);
-            default:
-                return this.delegate(p, used, out, fail, fn);
-        }
-    }
-    /**
-     * `Ascii.float` and `Text.float` (`map(floatText, toFloat)`): numbers in
-     * decimal notation are matched and converted in one pass by
-     * `scanFloatString` or `scanFloatBytes`, without slicing the input; the
-     * rest (`nan`, `inf`, failures before a digit) runs the parser. Returns
-     * `undefined` when this does not apply.
-     */
-    float(node, out, fail, fn, d) {
-        if (!floatTexts.has(node.self) || this.kind === 2)
-            return undefined;
-        let taken = nodeOf(node.self);
-        while (taken._tag === "Expected")
-            taken = nodeOf(taken.self);
-        if (taken._tag !== "Taken")
-            return undefined;
-        const enc = taken.encoding;
-        // Decimal notation is ASCII, which these encodings read unit by unit
-        if (enc !== undefined && !(this.native(enc) && enc.unit === 1 && enc.asciiCompatible))
-            return undefined;
-        const t = this.v(fn);
-        const scan = this.const(floatScan);
-        // Near the end of a partial input, the parser may have to report `Incomplete`
-        const near = this.resumable ? `||$S.partial&&${scan}.read+${Margin}>E` : "";
-        return `${out}=${this.kind === 0 ? "R.scanFloatString" : "R.scanFloatBytes"}(I,p,E);` +
-            `if(${out}===void 0${near}){${this.gen(node.self, true, t, fail, fn, d)}${out}=${this.const(toFloat)}(${t})}` +
-            `else if(${out}===F){${BT}${fail}}else p=${scan}.end;`;
-    }
-    seq(node, used, out, fail, fn, d) {
-        const output = node.output;
-        if (out === null || !used)
-            return node.parsers.map((q) => this.gen(q, false, null, fail, fn, d)).join("");
-        if (typeof output === "number") {
-            return node.parsers.map((q, i) => this.gen(q, i === output, i === output ? out : null, fail, fn, d)).join("");
-        }
-        const keep = (i) => output === "tuple" || output.includes(i);
-        const vars = node.parsers.map((_, i) => keep(i) ? this.v(fn) : null);
-        const code = node.parsers.map((q, i) => this.gen(q, keep(i), vars[i], fail, fn, d)).join("");
-        return code + `${out}=[${vars.filter((v) => v !== null).join(",")}];`;
-    }
-    /** A test that the unit `u` may start `first` (false for -1, the end of the input). */
-    startTest(first, u) {
-        const runs = runsOf(first.units);
-        const small = rangeTest(runs, u);
-        const low = small ?? `${this.const(first.units)}[${u}]===1`;
-        if (!first.high)
-            return small !== undefined ? `(${low})` : `(${u}<${TableSize}&&${low})`;
-        return `(${u}>=${TableSize}||${low})`;
-    }
-    alt(node, used, out, fail, fn, d) {
-        const parsers = node.parsers;
-        if (parsers.length === 0)
-            return `${BT}${fail}`;
-        if (parsers.length === 1)
-            return this.gen(parsers[0], used, out, fail, fn, d);
-        const firsts = this.kind === 2 ? undefined : parsers.map((q) => this.closure.firsts.of(q));
-        const prune = firsts !== undefined && planAlt(firsts) !== undefined;
-        const st = this.v(fn);
-        const u = prune ? this.v(fn) : "";
-        const done = this.label();
-        // Near the end of a partial input, no branch is skipped: it may be incomplete rather than fail
-        const read = this.resumable ? `$S.partial&&p+${Margin}>E?-2:p<E?${this.unit("p")}:-1` : `p<E?${this.unit("p")}:-1`;
-        let code = `${st}=p;${prune ? `${u}=${read};` : ""}${done}:{`;
-        parsers.forEach((q, i) => {
-            const bad = this.label();
-            const branch = `${bad}:{${this.gen(q, used, out, `break ${bad};`, fn, d)}break ${done};}` +
-                `if($S.mode!=="Backtrack"){${fail}}p=${st};`;
-            const f = firsts?.[i];
-            code += prune && f.mode === Strict
-                ? `if(${this.resumable ? `${u}===-2||` : ""}${this.startTest(f, u)}){${branch}}`
-                : branch;
-        });
-        return code + `${BT}${fail}}`;
-    }
-    dispatch(p, node, used, out, fail, fn, d) {
-        const choose = this.const(node.choose);
-        // The general path: run the selector, choose, then run the case's compiled step
-        const cases = new Map();
-        const caseStep = (q) => {
-            let s = cases.get(q);
-            if (s === undefined)
-                cases.set(q, s = this.closure.compile(q, used));
-            return s;
-        };
-        if (node.cases !== undefined) {
-            for (const key of Reflect.ownKeys(node.cases))
-                caseStep(node.cases[key]);
-            if (node.otherwise !== undefined)
-                caseStep(node.otherwise);
-        }
-        const table = this.const(cases);
-        const general = () => {
-            const st = this.v(fn);
-            const k = this.v(fn);
-            const q = this.v(fn);
-            const r = out ?? this.v(fn);
-            return `${st}=p;${this.gen(node.selector, true, k, fail, fn, d)}${q}=${choose}(${k});` +
-                `if(${q}===void 0){p=${st};${BT}${fail}}$S.pos=p;${r}=(${table}.get(${q})??${q}.step)($S);` +
-                `if(${r}===F){${fail}}p=$S.pos;`;
-        };
-        if (node.cases === undefined) {
-            this.closure.note(p, node, "the parser returned by the function of cases runs interpreted");
-            return general();
-        }
-        let sel = nodeOf(node.selector);
-        const peek = sel._tag === "Peek";
-        if (peek)
-            sel = nodeOf(sel.self);
-        if (sel._tag !== "Any" || !this.native(sel.encoding))
-            return general();
-        const enc = sel.encoding;
-        const r = enc === undefined ? undefined : this.reader(enc);
-        const limit = r === undefined ? (this.kind === 0 ? 0xd800 : TableSize) : Math.min(r.fast, 0xd800);
-        const size = Math.min(limit, TableSize);
-        if (size === 0)
-            return general();
-        // Group the units by the case they select
-        const groups = new Map();
-        for (let unit = 0; unit < size; unit++) {
-            const q = (node.choose)(enc === undefined && this.kind === 1 ? unit : charOf(unit));
-            if (q === undefined)
-                continue;
-            let g = groups.get(q);
-            if (g === undefined)
-                groups.set(q, g = []);
-            g.push(unit);
-        }
-        const u = this.v(fn);
-        const sw = this.label();
-        // A unit cut short by the end of the input takes the general path
-        const read = r === undefined
-            ? `p<E?${this.unit("p")}:-1`
-            : `${r.guard("p")}?${r.unit("p")}:p<E?${size}:-1`;
-        // Near the end of a partial input, the general path handles incomplete units
-        const near = this.resumable ? `$S.partial&&p+${Margin}>E?${size}:` : "";
-        let code = `${u}=${near}${read};${sw}:switch(${u}){`;
-        for (const [q, units] of groups) {
-            code += units.map((x) => `case ${x}:`).join("") +
-                `{${peek ? "" : `p+=${r?.width ?? 1};`}${this.gen(q, used, out, fail, fn, d)}break ${sw};}`;
-        }
-        code += `case -1:{${BT}${fail}}default:{if(${u}<${size}){${BT}${fail}}${general()}}}`;
-        return code;
-    }
-    repeat(node, used, out, fail, fn, d, collect) {
-        const { max, min } = node;
-        const loop = this.label();
-        const bad = this.label();
-        const n = this.v(fn);
-        const st = this.v(fn);
-        const isFold = node._tag === "Fold";
-        const keep = out !== null && used && collect === undefined;
-        const x = keep ? this.v(fn) : null;
-        const acc = keep ? out : this.v(fn);
-        let init = collect?.init ?? "";
-        let add = "";
-        if (keep) {
-            if (isFold) {
-                init = `${acc}=${this.const(node.init)}();`;
-                add = `${acc}=${this.const(node.f)}(${acc},${x});`;
-            }
-            else {
-                init = `${acc}=[];`;
-                add = `${acc}.push(${x});`;
-            }
-        }
-        const check = max === Infinity ? `if(p===${st}){$S.mode="Cut";${fail}}` : "";
-        const bound = max === Infinity ? "" : `${n}<${max}`;
-        const r = this.resumable ? this.resumePoint(fn) : undefined;
-        const save = r === undefined
-            ? ""
-            : `if($S.mode==="Incomplete"&&$S.resume!==void 0)R.save($S,${r.key},${r.entry},{acc:${acc},count:${n},pos:${st}});`;
-        // With `collect` (never in resumable builds), the element adds itself once the loop check passed
-        const element = collect === undefined
-            ? `${this.gen(node.self, keep, x, `break ${bad};`, fn, d)}${check}${add}`
-            : collect.element(`break ${bad};`, check);
-        const body = `${loop}:for(;${bound};${n}++){${st}=p;` +
-            `${bad}:{${element}continue ${loop};}` +
-            `${save}if($S.mode!=="Backtrack"${min > 0 ? `||${n}<${min}` : ""}){${fail}}p=${st};break ${loop};}`;
-        if (r === undefined)
-            return `${init}${n}=0;${body}${collect?.finish ?? ""}`;
-        return r.wrap(acc, `${acc}=cp.acc;${n}=cp.count;p=cp.pos;`, `${init}${n}=0;`, body);
-    }
-    /**
-     * In a resumable build, a repetition entered at `entry` may restart from a
-     * checkpoint (`restore`, with the checkpoint in `cp`), or return the result
-     * of a `Done` one; a resumed repetition records its result when it ends.
-     */
-    resumePoint(fn) {
-        const key = this.const({});
-        const entry = this.v(fn);
-        const resumed = this.v(fn);
-        const done = this.label();
-        return {
-            key,
-            entry,
-            resumed,
-            wrap: (value, restore, fresh, body) => `${entry}=p;${resumed}=false;${done}:{if($S.resume!==void 0){const cp=R.take($S,${key},p);` +
-                `if(cp instanceof R.Done){p=cp.pos;${value}=cp.value;break ${done};}` +
-                `if(cp!==void 0){${restore}${resumed}=true;}}if(!${resumed}){${fresh}}${body}` +
-                `if(${resumed})R.done($S,${key},${entry},${value},p);}`
-        };
-    }
-    separated(node, used, out, fail, fn, d, collect) {
-        const { max, min } = node;
-        const keep = out !== null && used && collect === undefined;
-        if (max === 0)
-            return collect !== undefined ? collect.init + collect.finish : keep ? `${out}=[];` : "";
-        const x = keep ? this.v(fn) : null;
-        const acc = keep ? out : this.v(fn);
-        const n = this.v(fn);
-        const st = this.v(fn);
-        const done = this.label();
-        const loop = this.label();
-        const push = keep ? `${acc}.push(${x});` : "";
-        const r = this.resumable ? this.resumePoint(fn) : undefined;
-        const save = r === undefined
-            ? ""
-            : `if($S.mode==="Incomplete"&&$S.resume!==void 0)R.save($S,${r.key},${r.entry},{acc:${acc},count:${n},pos:${st}});`;
-        // Runs `body`; on its failure, stops the repetition (or fails if `fatal`)
-        const attempt = (body, success, fatal, checkpoint) => {
-            const ok = this.label();
-            const bad = this.label();
-            return `${ok}:{${bad}:{${body(`break ${bad};`)}${success}break ${ok};}` +
-                `${checkpoint}if($S.mode!=="Backtrack"${fatal}){${fail}}p=${st};break ${done};}`;
-        };
-        const self = (f) => collect === undefined ? this.gen(node.self, keep, x, f, fn, d) : collect.element(f, "");
-        const sep = (f) => this.gen(node.separator, false, null, f, fn, d);
-        const check = max === Infinity ? `if(p===${st}){$S.mode="Cut";${fail}}` : "";
-        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 === undefined)
-            return `${done}:{${first}${rest}}${collect?.finish ?? ""}`;
-        // `done` ends the repetition; the checkpoint wrapper records the result after it
-        return r.wrap(acc, `${acc}=cp.acc;${n}=cp.count;p=cp.pos;`, "", `${done}:{if(!${r.resumed}){${first}}${rest}}`);
-    }
-    /**
-     * `map(self, Object.fromEntries)`, where `entriesShape(self)`: builds the
-     * object directly, assigning each entry as it is parsed (see
-     * `internal/entries.ts`), without the pairs and their array. `cut`,
-     * `preceded`, `terminated` and diagnostics around the repetition are
-     * compiled as usual around it.
-     */
-    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);
-                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 node._tag === "Repeat"
-                    ? this.repeat(node, true, out, fail, fn, d, collect)
-                    : this.separated(node, true, out, fail, fn, d, collect);
-            }
-            default:
-                return this.entries(node.self, out, fail, fn, d);
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Tokens
-    // ---------------------------------------------------------------------------
-    /** An expression: is the unit `c`, known to be below `size` (at most `TableSize`), accepted? */
-    member(accept, c, size = TableSize) {
-        return tableTest(accept, c, size) ?? `${this.const(accept)}[${c}]===1`;
-    }
-    /** An expression: is the code point `c` (at least `TableSize`) accepted? */
-    memberHigh(set, negate, c) {
-        if (set.ranges !== undefined && !set.ranges.some(([, b]) => b >= TableSize))
-            return negate ? "true" : "false";
-        return `${this.const(set.test)}(${c})!==${negate}`;
-    }
-    /**
-     * An expression: does a `Text` set accept the unit `c`, known to be below
-     * `r.fast`? Code points from `TableSize` up are tested by the set's
-     * function, unless its ranges show they are all rejected.
-     */
-    textAccepts(r, cs, accept, negate, c) {
-        if (r.fast <= TableSize)
-            return `(${this.member(accept, c, r.fast)})`;
-        const member = this.member(accept, c);
-        if (reachesAbove(cs, TableSize))
-            return `(${c}<${TableSize}?${member}:${this.const(cs.test)}(${c})!==${negate})`;
-        return negate ? `(${c}>=${TableSize}||${member})` : `(${c}<${TableSize}&&${member})`;
-    }
-    /**
-     * An expression: does a `Text` set reject `c`, a code point that `decode`
-     * returned? The built-in encodings only decode code points from `r.fast`
-     * up there.
-     */
-    textRejectsDecoded(enc, r, cs, negate, c) {
-        if (r.fast > 0 && builtinEncodings.has(enc) && !reachesAbove(cs, r.fast))
-            return String(!negate);
-        return `${this.const(cs.test)}(${c})===${negate}`;
-    }
-    token(node, out, fail, fn) {
-        const set = (value) => out === null ? "" : `${out}=${value};`;
-        const enc = node.encoding;
-        const kind = this.kind;
-        const failBT = `{${BT}${fail}}`;
-        switch (node._tag) {
-            case "Any": {
-                if (enc === undefined) {
-                    if (kind === 1)
-                        return `if(p>=E)${failBT}${set("I[p]")}p++;`;
-                    const c = this.v(fn);
-                    return `if(p>=E)${failBT}${c}=I.charCodeAt(p);` +
-                        `if(${c}>=55296&&${c}<=56319&&p+1<I.length&&(I.charCodeAt(p+1)&64512)===56320){${set("I.slice(p,p+2)")}p+=2}` +
-                        `else{${set("I[p]")}p++}`;
-                }
-                const r = this.reader(enc);
-                const c = this.v(fn);
-                const dec = `${this.const(enc.decode)}(I,p,E)`;
-                return `if(p>=E)${failBT}` +
-                    (r.fast > 0 ? `if(${r.guard("p")}&&(${c}=${r.unit("p")})<${r.fast}){${set(`R.charOf(${c})`)}p+=${r.width}}else` : "") +
-                    `{${c}=${dec};if(${c}<0)${failBT}${set(`R.charOf(${c})`)}p+=${this.const(enc.width)}(${c})}`;
-            }
-            case "Literal": {
-                const lit = node.literal;
-                if (enc !== undefined) {
-                    if (node.caseless)
-                        return undefined;
-                    const encoded = enc.encode(lit);
-                    return this.literalUnits(typeof encoded === "string" ? unitsOf(encoded) : Array.from(encoded), false, fail) + set(this.lit(lit));
-                }
-                const literalKind = typeof lit === "string" ? 0 : lit instanceof Uint8Array ? 1 : 2;
-                if (kind === 0 && literalKind !== 0)
-                    return undefined;
-                if (literalKind === 2)
-                    return undefined;
-                const codes = kind === 0
-                    ? unitsOf(lit)
-                    : Array.from(literalKind === 0 ? new TextEncoder().encode(lit) : lit);
-                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);
-            }
-            case "OneOf": {
-                const negate = node.negate;
-                const cs = enc === undefined ? tokenSet(node.set, kind) : textSet(node.set);
-                const accept = acceptTable(cs, negate);
-                const c = this.v(fn);
-                const value = (len) => this.kind === 0 ? `I.slice(p,p+${len})` : `I[p]`;
-                if (enc === undefined) {
-                    if (kind === 1)
-                        return `if(p>=E)${failBT}${c}=I[p];if(!(${this.member(accept, c)}))${failBT}${set("I[p]")}p++;`;
-                    const cp = this.v(fn);
-                    if (!negate && this.memberHigh(cs, negate, cp) === "false") {
-                        return `if(p>=E)${failBT}${c}=I.charCodeAt(p);if(${c}>=${TableSize}||!(${this.member(accept, c)}))${failBT}${set("I[p]")}p++;`;
-                    }
-                    return `if(p>=E)${failBT}${c}=I.charCodeAt(p);` +
-                        `if(${c}<${TableSize}){if(!(${this.member(accept, c)}))${failBT}${set("I[p]")}p++}` +
-                        `else{${cp}=${c};if(${c}>=55296&&${c}<=56319&&p+1<I.length){const d=I.charCodeAt(p+1);` +
-                        `if((d&64512)===56320)${cp}=((${c}-55296)<<10)+(d-56320)+65536}` +
-                        `if(!(${this.memberHigh(cs, negate, cp)}))${failBT}` +
-                        `if(${cp}>65535){${set(value("2"))}p+=2}else{${set("I[p]")}p++}}`;
-                }
-                const r = this.reader(enc);
-                return `if(p>=E)${failBT}` +
-                    (r.fast > 0
-                        ? `if(${r.guard("p")}&&(${c}=${r.unit("p")})<${r.fast}){if(!${this.textAccepts(r, cs, accept, negate, c)})${failBT}${set(`R.charOf(${c})`)}p+=${r.width}}else`
-                        : "") +
-                    `{${c}=${this.const(enc.decode)}(I,p,E);if(${c}<0||${this.textRejectsDecoded(enc, r, cs, negate, c)})${failBT}` +
-                    `${set(`R.charOf(${c})`)}p+=${this.const(enc.width)}(${c})}`;
-            }
-            case "TakeWhile":
-                return this.takeWhile(node, out, fail, fn);
-        }
-    }
-    /** Matches literal units at `p`, advancing past them. */
-    literalUnits(codes, caseless, fail) {
-        const len = codes.length;
-        if (len === 0)
-            return "";
-        const test = (c, i) => {
-            const at = this.unit(i === 0 ? "p" : `p+${i}`);
-            if (caseless && isLetter(c))
-                return `(${at}|32)===${lowerAscii(c)}`;
-            return `${at}===${c}`;
-        };
-        if (len <= 8) {
-            // Reading past the end gives NaN or undefined, which matches nothing
-            return `if(!(${codes.map(test).join("&&")})){${BT}${fail}}p+=${len};`;
-        }
-        if (this.kind === 0 && !caseless) {
-            const str = String.fromCharCode(...codes);
-            return `if(!I.startsWith(${JSON.stringify(str)},p)){${BT}${fail}}p+=${len};`;
-        }
-        const expect = this.const(Uint8Array.from(caseless ? codes.map(lowerAscii) : codes));
-        const lower = caseless ? `${this.const(lowerAscii)}` : "";
-        return `if(E-p<${len}){${BT}${fail}}for(let i=0;i<${len};i++)if(${lower}(${this.unit("p+i")})!==${expect}[i]){${BT}${fail}}p+=${len};`;
-    }
-    takeWhile(node, out, fail, fn) {
-        const enc = node.encoding;
-        const { max, min, negate } = node;
-        const kind = this.kind;
-        const cs = enc === undefined ? tokenSet(node.set, kind) : textSet(node.set);
-        const accept = acceptTable(cs, negate);
-        const st = this.v(fn);
-        const c = this.v(fn);
-        const n = this.v(fn);
-        const loop = this.label();
-        const counted = max !== Infinity || min > 1;
-        const count = counted ? `${n}++;` : "";
-        const bound = max !== Infinity ? `&&${n}<${max}` : "";
-        const slice = enc !== undefined
-            ? `${this.const(enc.text)}(I,${st},p)`
-            : 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);
-        if (kind === 1 && (enc === undefined || fastLimit(enc) >= TableSize)) {
-            // Bytes, one token each
-            return `${head}if(!(${member}))break;p++;${count}}${finish}`;
-        }
-        if (enc !== undefined) {
-            // Text: inline the encoding's single-unit code points, decode the rest
-            const r = this.reader(enc);
-            // The loop condition already checks a unit of width 1
-            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 fast = 0xd800;
-        const small = TableSize;
-        const highTest = (v) => this.memberHigh(cs, negate, v);
-        // Token on strings: code points, with lenient surrogates
-        const cp = this.v(fn);
-        const never = highTest(c) === "false";
-        // Every code point from `TableSize` up is accepted: without a count,
-        // surrogate pairs can be skipped a unit at a time
-        const always = highTest(c) === "true";
-        const rest = 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}`;
-        return `${head}if(${c}<${small}){if(!(${member}))break;p++}else ${rest}${count}}${finish}`;
-    }
-    escaped(p, node, out, fail, fn, d) {
-        const enc = node.encoding;
-        const ctrl = node.control;
-        const r = enc === undefined ? undefined : this.reader(enc);
-        if (r !== undefined && !(ctrl < r.fast))
-            return this.delegate(p, !node.raw, out, fail, fn);
-        const raw = node.raw;
-        const acc = raw ? null : out ?? this.v(fn);
-        const x = raw ? null : this.v(fn);
-        const b = this.v(fn);
-        const st = this.v(fn);
-        const okv = this.v(fn);
-        const loop = this.label();
-        const bad = this.label();
-        const normal = this.gen(node.normal, !raw, x, `break ${bad};`, fn, d);
-        const escape = this.gen(node.escape, !raw, x, 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 !== undefined
-            ? `${this.const(enc.text)}(I,${st},p)`
-            : this.kind === 0
-                ? `I.slice(${st},p)`
-                : `I.subarray(${st},p)`;
-        const ctrlTest = r === undefined ? `p<E&&${this.unit("p")}===${ctrl}` : `${r.guard("p")}&&${r.unit("p")}===${ctrl}`;
-        return `${raw ? `${st}=p;` : `${acc}="";`}${loop}:while(p<E){${b}=p;${okv}=false;` +
-            `${bad}:{${normal}${okv}=true;}` +
-            `if(${okv}){${onNormal}}else{if($S.mode!=="Backtrack"){${fail}}p=${b}}` +
-            `if(${ctrlTest}){p+=${r?.width ?? 1};${escape}${raw ? "" : `${acc}+=${x};`}}else break ${loop};}` +
-            (raw && out !== null ? `${out}=${slice};` : "");
-    }
-}
 /** The UTF-16 code units of a string. */
 const unitsOf = (s) => Array.from({ length: s.length }, (_, i) => s.charCodeAt(i));
 /** 1 where a small code is accepted (taking `negate` into account). */
 const acceptTable = (set, negate) => {
-    const t = new Uint8Array(TableSize);
-    for (let c = 0; c < TableSize; c++)
-        t[c] = (set.table[c] === 1) !== negate ? 1 : 0;
-    return t;
+	const t = new Uint8Array(TableSize);
+	for (let c = 0; c < TableSize; c++) t[c] = set.table[c] === 1 !== negate ? 1 : 0;
+	return t;
 };
 /** Generates the source of a compiled parser, without building it. */
-export const generate = (root, kind, resumable = false) => {
-    const e = new Emitter(root, kind, resumable);
-    const main = e.rule(root, true);
-    const source = `"use strict";let $I,$E,$S,P;${e.functions.join("\n")}\n` +
-        `return 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}}`;
-    return { source, constants: e.constants, fallbacks: e.fallbacks };
+const generate = (root, kind, resumable = false) => {
+	const e = new Emitter(root, kind, resumable);
+	const main = e.rule(root, true);
+	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}}`,
+		constants: e.constants,
+		fallbacks: e.fallbacks
+	};
 };
 /** Compiles a root parser for one input kind with `new Function`. */
-export 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);
-    // Generated code reads past `end` expecting nothing to match there, which
-    // holds when `end` is the input's length, as it is in the runners.
-    let closure;
-    const step = (state) => state.end === state.input.length ? run(state) : (closure ??= createClosureCompiler(kind, resumable).compile(root, true))(state);
-    return { step, fallbacks, source };
+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,
+		fallbacks,
+		source
+	};
 };
+/**
+* The JIT as a backend: generated code where `new Function` is allowed,
+* otherwise (or if generating fails) the closure compiler.
+*/
+const backend = { build: (p, kind, resumable) => {
+	if (!jitSupported()) return backend$1.build(p, kind, resumable);
+	try {
+		const { fallbacks, source, step } = compileJit(p, kind, resumable);
+		return {
+			backend: "jit",
+			step,
+			fallbacks,
+			error: void 0,
+			source
+		};
+	} catch (error) {
+		return {
+			...backend$1.build(p, kind, resumable),
+			jitError: error
+		};
+	}
+} };
+//#endregion
+export { backend };
+
 //# sourceMappingURL=jit.js.map