@thomasfosterau/effect-parse 0.0.0-stage → 0.0.0

package/dist/internal/compiler/jit.js

@@ -0,0 +1,1030 @@
+/**
+ * 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 { 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 { 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";
+/** 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);
+    }
+};
+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;
+};
+const BT = `$S.mode="Backtrack";`;
+const builtinEncodings = 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 = [];
+}
+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 = [];
+    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("||");
+};
+/** 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;
+};
+/** 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.
+ */
+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})`;
+};
+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;
+};
+/** 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 };
+};
+/** 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 };
+};
+//# sourceMappingURL=jit.js.map