@thomasfosterau/effect-parse 0.1.0 → 0.2.0

package/src/internal/compiler/jit.ts

@@ -1,3 +1,5 @@
+// fallow-ignore-file duplicate-export -- every compiler module exports its `backend` under the same name,
+// which the Compiler module imports by path; no barrel re-exports both.
 /**
  * The JIT: emits JavaScript source for a parser's description and builds
  * it with `new Function`.
@@ -14,6 +16,7 @@
  * the interpreter for what they can't compile) on the shared state, with
  * `state.pos` kept in sync.
  */
+import * as Predicate from "effect/Predicate"
 import * as Option from "effect/Option"
 import type { Encoding } from "../../Encoding.js"
 import type { State } from "../../Input.js"
@@ -22,11 +25,13 @@ import type { Node, NodeOf, ParserLike } from "../node.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 { compileAny } from "../tokens.js"
 import * as Resume from "../resume.js"
 import { charOf, fastLimit, latin1, string, utf16be, utf16le, utf8, validate } from "../text.js"
 import type { ClosureCompiler, Fallback, Step } from "./closure.js"
-import { createClosureCompiler } from "./closure.js"
-import { entriesShape, pairOf } from "./entries.js"
+import { backend as closureBackend, createClosureCompiler } from "./closure.js"
+import { buildsEntries, pairOf } from "./entries.js"
+import type { Backend } from "./registry.js"
 import type { First } from "./first.js"
 import { planAlt, Strict } from "./first.js"
 import type { CharSet } from "./sets.js"
@@ -53,7 +58,7 @@ const runtime = {
     const input = s.input
     let i = start
     if (s.inputKind === 0) while (i < end && (input as string).charCodeAt(i) < fast) i++
-    else while (i < end && (input as Uint8Array)[i]! < fast) i++
+    else while (i < end && (input as Uint8Array)[i] < fast) i++
     if (i < end && validate(enc, s, i, end) < 0) {
       s.mode = "Backtrack"
       return Fail
@@ -69,7 +74,7 @@ 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 = (): boolean => {
+const jitSupported = (): boolean => {
   if (checked !== globalThis.Function) {
     checked = globalThis.Function
     try {
@@ -83,7 +88,7 @@ export const jitSupported = (): boolean => {
 
 const BT = `$S.mode="Backtrack";`
 
-const builtinEncodings: ReadonlySet<Encoding<any>> = new Set([string, utf8, utf16le, utf16be, latin1])
+const builtinEncodings: ReadonlySet<Encoding<any>> = /*#__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
@@ -118,7 +123,7 @@ const isLeaf = (node: Node): boolean => {
   }
 }
 
-const lowerAscii = (c: number): number => c >= 65 && c <= 90 ? c + 32 : c
+const lowerAscii = (c: number): number => (c >= 65 && c <= 90 ? c + 32 : c)
 const isLetter = (c: number): boolean => (c >= 65 && c <= 90) || (c >= 97 && c <= 122)
 
 /** The inclusive ranges of 1s in a table. */
@@ -138,7 +143,7 @@ const runsOf = (table: Uint8Array): Array<[number, number]> => {
 const rangeTest = (runs: ReadonlyArray<readonly [number, number]>, v: string): string | undefined => {
   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("||")
+  return runs.map(([a, b]) => (a === b ? `${v}===${a}` : `(${v}>=${a}&&${v}<=${b})`)).join("||")
 }
 
 /** The inclusive ranges of `[0, size)` where `table[c] === value`. */
@@ -173,13 +178,24 @@ const tableTest = (table: Uint8Array, v: string, size: number): string | undefin
   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("&&")
+  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})`
 }
 
@@ -203,7 +219,11 @@ class Emitter {
   private readonly closure: ClosureCompiler
   private next = 0
 
-  constructor(readonly root: ParserLike, readonly kind: 0 | 1 | 2, readonly resumable = false) {
+  constructor(
+    readonly root: ParserLike,
+    readonly kind: 0 | 1 | 2,
+    readonly resumable = false
+  ) {
     this.closure = createClosureCompiler(kind, resumable)
     this.countRefs(root)
   }
@@ -216,8 +236,7 @@ class Emitter {
   private countRefs(root: ParserLike): void {
     const seen = new Set<ParserLike>()
     const stack = [root]
-    while (stack.length > 0) {
-      const p = stack.pop()!
+    for (let p = stack.pop(); p !== undefined; p = stack.pop()) {
       if (seen.has(p)) continue
       seen.add(p)
       for (const c of new Set(children(nodeOf(p)))) {
@@ -240,9 +259,9 @@ class Emitter {
   /** A JavaScript literal for simple values, otherwise a constant. */
   lit(value: unknown): string {
     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)
+    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)
   }
 
@@ -280,7 +299,7 @@ class Emitter {
 
   /** The function implementing a rule, generating it on first use. */
   rule(p: ParserLike, used: boolean): string {
-    const rules = this.rules[used ? 1 : 0]!
+    const rules = this.rules[used ? 1 : 0]
     let name = rules.get(p)
     if (name !== undefined) return name
     name = `f${this.next++}`
@@ -340,9 +359,70 @@ class Emitter {
     const ok = this.v(fn)
     const t = this.v(fn)
     const leaf = this.label()
-    return `${st}=p;${ok}=false;${leaf}:{${bad}:{${code}${ok}=true;}` +
+    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.
+   */
+  private leaf(
+    p: ParserLike,
+    node: NodeOf<"Any" | "Literal" | "OneOf" | "TakeWhile">,
+    used: boolean,
+    out: string | null,
+    fail: string,
+    fn: Fn,
+    lookahead: number = Margin
+  ): string {
+    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, lookahead, out, fail, fn)
+  }
+
+  /** Whether a token parser reads array input as such (`Token`'s, on an array). */
+  private array(enc: Encoding<any> | undefined): boolean {
+    return this.kind === 2 && enc === undefined
+  }
+
+  /**
+   * 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.
+   */
+  private arrayLeaf(p: ParserLike, code: (fail: string) => string, out: string | null, fail: string, fn: Fn): string {
+    if (!this.resumable) return code(fail)
+    const bad = this.label()
+    return this.partialSafe(p, code(`break ${bad};`), bad, 1, out, fail, fn)
+  }
+
+  private arrayAny(out: string | null, fail: string): string {
+    return `if(p>=E){${BT}${fail}}${out === null ? "" : `${out}=I[p];`}p++;`
+  }
+
+  private arrayOneOf(node: NodeOf<"OneOf">, out: string | null, fail: string): string {
+    const m = this.const(compileAny(node.set).forCode.token)
+    return `if(p>=E||${m}(I[p])===${node.negate}){${BT}${fail}}${out === null ? "" : `${out}=I[p];`}p++;`
+  }
+
+  private arrayTakeWhile(node: NodeOf<"TakeWhile">, out: string | null, fail: string, fn: Fn): string {
+    const m = this.const(compileAny(node.set).forCode.token)
+    const st = this.v(fn)
+    const max = node.max === Infinity ? "" : `&&p-${st}<${node.max}`
+    return (
+      `${st}=p;while(p<E${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: string, out: string | null, fail: string): string {
@@ -363,7 +443,7 @@ class Emitter {
 
   inline(p: ParserLike, used: boolean, out: string | null, fail: string, fn: Fn, depth: number): string {
     const node = nodeOf(p)
-    const set = (value: string) => out === null ? "" : `${out}=${value};`
+    const set = (value: string) => (out === null ? "" : `${out}=${value};`)
     const d = depth + 1
     switch (node._tag) {
       case "Succeed":
@@ -373,8 +453,11 @@ class Emitter {
       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}}` : "") +
+        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":
@@ -382,16 +465,17 @@ class Emitter {
       case "Suspend":
         return this.call(this.rule(node.resolve(), used), out, fail)
       case "Any":
-      case "Literal":
+        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":
-      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)
-      }
+        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": {
         // 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)
@@ -404,7 +488,7 @@ class Emitter {
           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)) {
+        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)
@@ -421,8 +505,10 @@ class Emitter {
         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) +
+        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)
@@ -432,8 +518,10 @@ class Emitter {
         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) +
+        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)
@@ -441,7 +529,10 @@ class Emitter {
         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)`)
+          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)
@@ -461,14 +552,17 @@ class Emitter {
       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};}` +
+        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": {
@@ -482,10 +576,12 @@ class Emitter {
         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 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};}` +
+        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)
@@ -495,26 +591,32 @@ class Emitter {
         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}}` +
+        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("")
+        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)
+        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) +
+        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)
@@ -549,20 +651,22 @@ class Emitter {
     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);` +
+    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: NodeOf<"Seq">, used: boolean, out: string | null, fail: string, fn: Fn, d: number): string {
     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") {
+    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: number) => 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("")
+    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(",")}];`
   }
 
@@ -578,7 +682,7 @@ class Emitter {
   alt(node: NodeOf<"Alt">, used: boolean, out: string | null, fail: string, fn: Fn, d: number): string {
     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)
+    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)
@@ -589,75 +693,98 @@ class Emitter {
     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};}` +
+      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
+      code +=
+        prune && f !== undefined && f.mode === Strict
+          ? `if(${this.resumable ? `${u}===-2||` : ""}${this.startTest(f, u)}){${branch}}`
+          : branch
     })
     return code + `${BT}${fail}}`
   }
 
-  dispatch(p: ParserLike, node: NodeOf<"Dispatch">, used: boolean, out: string | null, fail: string, fn: Fn, d: number): string {
+  dispatch(
+    p: ParserLike,
+    node: NodeOf<"Dispatch">,
+    used: boolean,
+    out: string | null,
+    fail: string,
+    fn: Fn,
+    d: number
+  ): string {
     const choose = this.const(node.choose)
-    // The general path: run the selector, choose, then run the case's compiled step
-    const cases = new Map<ParserLike, Step>()
-    const caseStep = (q: ParserLike) => {
-      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 as any]!)
-      if (node.otherwise !== undefined) caseStep(node.otherwise)
-    }
-    const table = this.const(cases)
-    const general = (): string => {
+    if (node.cases === undefined) {
+      // The general path: run the selector, choose, then run the case's step
+      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}=(${table}.get(${q})??${q}.step)($S);` +
+      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;`
+      )
     }
-    if (node.cases === undefined) {
-      this.closure.note(p, node, "the parser returned by the function of cases runs interpreted")
-      return general()
+    // The cases are known: number them, and run the chosen one inline
+    const cases = new Map<ParserLike, number>()
+    for (const key of Reflect.ownKeys(node.cases)) {
+      const q = node.cases[key as any]
+      if (!cases.has(q)) cases.set(q, cases.size)
+    }
+    if (node.otherwise !== undefined && !cases.has(node.otherwise)) cases.set(node.otherwise, cases.size)
+    const index = this.const(cases)
+    // `inline`: the cases' code goes here; otherwise (a fallback next to the
+    // switch on units below, which inlines them already) they are called as rules
+    const general = (inline: boolean): string => {
+      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};}`
+      }
+      // Unreachable unless the record of cases changed after `dispatch` read it
+      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 as NodeOf<"Peek">).self)
-    if (sel._tag !== "Any" || !this.native(sel.encoding)) return general()
+    if (sel._tag !== "Any" || !this.native(sel.encoding)) return general(true)
     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()
+    if (size === 0) return general(true)
     // Group the units by the case they select
     const groups = new Map<ParserLike, Array<number>>()
     for (let unit = 0; unit < size; unit++) {
-      const q = (node.choose)(enc === undefined && this.kind === 1 ? unit : charOf(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 = [])
+      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`
+    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("") +
+      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()}}}`
+    code += `case -1:{${BT}${fail}}default:{if(${u}<${size}){${BT}${fail}}${general(false)}}}`
     return code
   }
 
@@ -676,12 +803,15 @@ class Emitter {
     const n = this.v(fn)
     const st = this.v(fn)
     const isFold = node._tag === "Fold"
+    const cond = isFold ? (node as NodeOf<"Fold">).while : undefined
     const keep = out !== null && used && collect === undefined
-    const x = keep ? this.v(fn) : null
-    const acc = keep ? out! : this.v(fn)
+    // `while` needs the accumulator even when the output is unused
+    const tracked = keep || cond !== undefined
+    const x = tracked ? this.v(fn) : null
+    const acc = out !== null && keep ? out : this.v(fn)
     let init = collect?.init ?? ""
     let add = ""
-    if (keep) {
+    if (tracked) {
       if (isFold) {
         init = `${acc}=${this.const((node as NodeOf<"Fold">).init)}();`
         add = `${acc}=${this.const((node as NodeOf<"Fold">).f)}(${acc},${x});`
@@ -693,14 +823,19 @@ class Emitter {
     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}});`
+    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;` +
+    const element =
+      collect === undefined
+        ? `${this.gen(node.self, tracked, x, `break ${bad};`, fn, d)}${check}${add}`
+        : collect.element(`break ${bad};`, check)
+    const stop =
+      cond === undefined ? "" : `if(${min > 0 ? `${n}>=${min}&&` : ""}!${this.const(cond)}(${acc}))break ${loop};`
+    const body =
+      `${loop}:for(;${bound};${n}++){${stop}${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 ?? ""}`
@@ -742,29 +877,37 @@ class Emitter {
     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 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) : 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}});`
+    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: (fail: string) => string, success: string, fatal: string, checkpoint: string) => {
       const ok = this.label()
       const bad = this.label()
-      return `${ok}:{${bad}:{${body(`break ${bad};`)}${success}break ${ok};}` +
+      return (
+        `${ok}:{${bad}:{${body(`break ${bad};`)}${success}break ${ok};}` +
         `${checkpoint}if($S.mode!=="Backtrack"${fatal}){${fail}}p=${st};break ${done};}`
+      )
     }
-    const self = (f: string) => collect === undefined ? this.gen(node.self, keep, x, f, fn, d) : collect.element(f, "")
+    const self = (f: string) =>
+      collect === undefined ? this.gen(node.self, keep, x, f, fn, d) : collect.element(f, "")
     const sep = (f: string) => 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 +
+    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 ?? ""}`
@@ -773,7 +916,7 @@ class Emitter {
   }
 
   /**
-   * `map(self, Object.fromEntries)`, where `entriesShape(self)`: builds the
+   * `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
@@ -785,27 +928,44 @@ class Emitter {
       case "Mode": {
         const ok = this.label()
         const bad = this.label()
-        return `${ok}:{${bad}:{${this.entries(node.self, out, `break ${bad};`, fn, d)}break ${ok};}` +
+        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 as number
-        return node.parsers.map((q, j) =>
-          j === i ? this.entries(q, out, fail, fn, d) : this.gen(q, false, null, fail, fn, d)
-        ).join("")
+        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 pair = pairOf(node.self)
+        if (pair === undefined) {
+          // Not reached (`buildsEntries` found the pair): build the pairs, then the object
+          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: 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 +
+            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});`
@@ -862,7 +1022,7 @@ class Emitter {
     fail: string,
     fn: Fn
   ): string | undefined {
-    const set = (value: string) => out === null ? "" : `${out}=${value};`
+    const set = (value: string) => (out === null ? "" : `${out}=${value};`)
     const enc = node.encoding
     const kind = this.kind as 0 | 1
     const failBT = `{${BT}${fail}}`
@@ -871,40 +1031,47 @@ class Emitter {
         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);` +
+          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` : "") +
+        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 as string)
-          return this.literalUnits(
-            typeof encoded === "string" ? unitsOf(encoded) : Array.from(encoded),
-            false,
-            fail
-          ) + set(this.lit(lit))
+          return (
+            this.literalUnits(Predicate.isString(encoded) ? unitsOf(encoded) : Array.from(encoded), false, fail) +
+            set(this.lit(lit))
+          )
         }
-        const literalKind = typeof lit === "string" ? 0 : lit instanceof Uint8Array ? 1 : 2
+        const literalKind = Predicate.isString(lit) ? 0 : lit instanceof Uint8Array ? 1 : 2
         if (kind === 0 && literalKind !== 0) return undefined
         if (literalKind === 2) return undefined
-        const codes = kind === 0
-          ? unitsOf(lit as string)
-          : Array.from(literalKind === 0 ? new TextEncoder().encode(lit as string) : lit as Uint8Array)
+        const codes =
+          kind === 0
+            ? unitsOf(lit as string)
+            : Array.from(literalKind === 0 ? new TextEncoder().encode(lit as string) : (lit as Uint8Array))
         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)`
+        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": {
@@ -912,27 +1079,32 @@ class Emitter {
         const cs = enc === undefined ? tokenSet(node.set, kind) : textSet(node.set)
         const accept = acceptTable(cs, negate)
         const c = this.v(fn)
-        const value = (len: string) => this.kind === 0 ? `I.slice(p,p+${len})` : `I[p]`
+        const value = (len: string) => (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++;`
+          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);` +
+          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}` +
+        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)
@@ -974,13 +1146,10 @@ class Emitter {
     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 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)) {
@@ -992,12 +1161,14 @@ class Emitter {
       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}){` +
+      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
@@ -1008,13 +1179,14 @@ class Emitter {
     // 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}`
+    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}`
   }
 
@@ -1024,7 +1196,7 @@ class Emitter {
     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 acc = raw ? null : (out ?? this.v(fn))
     const x = raw ? null : this.v(fn)
     const b = this.v(fn)
     const st = this.v(fn)
@@ -1036,17 +1208,20 @@ class Emitter {
     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 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;` +
+    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};` : "")
+    )
   }
 }
 
@@ -1061,21 +1236,30 @@ const acceptTable = (set: CharSet, negate: boolean): Uint8Array => {
 }
 
 /** Generates the source of a compiled parser, without building it. */
-export const generate = (root: ParserLike, kind: 0 | 1 | 2, resumable = false): {
+const generate = (
+  root: ParserLike,
+  kind: 0 | 1 | 2,
+  resumable = false
+): {
   readonly source: string
   readonly constants: ReadonlyArray<unknown>
   readonly fallbacks: ReadonlyArray<Fallback>
 } => {
   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` +
+  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: ParserLike, kind: 0 | 1 | 2, resumable = false): {
+const compileJit = (
+  root: ParserLike,
+  kind: 0 | 1 | 2,
+  resumable = false
+): {
   readonly step: Step
   readonly fallbacks: ReadonlyArray<Fallback>
   readonly source: string
@@ -1086,6 +1270,25 @@ export const compileJit = (root: ParserLike, kind: 0 | 1 | 2, resumable = false)
   // holds when `end` is the input's length, as it is in the runners.
   let closure: Step | undefined
   const step: Step = (state) =>
-    state.end === state.input.length ? run(state) : (closure ??= createClosureCompiler(kind, resumable).compile(root, true))(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.
+ */
+export const backend: Backend = {
+  build: (p, kind, resumable) => {
+    if (!jitSupported()) return closureBackend.build(p, kind, resumable)
+    try {
+      const { fallbacks, source, step } = compileJit(p, kind, resumable)
+      return { backend: "jit", step, fallbacks, error: undefined, source }
+    } catch (error) {
+      // Fall back to the closure compiler, remembering why
+      return { ...closureBackend.build(p, kind, resumable), jitError: error }
+    }
+  }
+}