@thomasfosterau/effect-parse 0.0.0 → 0.2.0

package/src/internal/compiler/registry.ts

@@ -1,15 +1,13 @@
 /**
- * The registry of compiled parsers, keyed by parser (see `Parser.compile`).
- * Compiled steps are built lazily, once per input kind.
+ * The registry of compiled parsers, keyed by parser (see the `Compiler`
+ * module). Compiled steps are built lazily, once per input kind.
+ *
+ * Nothing here imports a compiler: a parser is registered with the backend
+ * that compiles it, so a program bundles only the backends it uses.
  */
 import type { State } from "../../Input.js"
 import type { ParserLike } from "../node.js"
 import type { Fallback, Step } from "./closure.js"
-import { compileClosure } from "./closure.js"
-import { compileJit, jitSupported } from "./jit.js"
-
-/** Which compiler to use. */
-export type Backend = "auto" | "closure"
 
 /** What was compiled for a parser and an input kind. */
 export interface Compiled {
@@ -26,42 +24,23 @@ export interface Compiled {
   readonly source?: string
 }
 
+/** A compiler: builds the compiled form of a parser for an input kind. */
+export interface Backend {
+  readonly build: (p: ParserLike, kind: 0 | 1 | 2, resumable: boolean) => Compiled
+}
+
 interface Entry {
   readonly backend: Backend
   readonly byKind: Array<Compiled | undefined>
 }
 
-const registry = new WeakMap<ParserLike, Entry>()
+const registry = /*#__PURE__*/ new WeakMap<ParserLike, Entry>()
 
 export const register = (p: ParserLike, backend: Backend): void => {
   const entry = registry.get(p)
   if (entry === undefined || entry.backend !== backend) registry.set(p, { backend, byKind: [] })
 }
 
-export const isRegistered = (p: ParserLike): boolean => registry.has(p)
-
-const build = (p: ParserLike, kind: 0 | 1 | 2, backend: Backend, resumable: boolean): Compiled => {
-  if (backend === "auto" && jitSupported()) {
-    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 { ...buildClosure(p, kind, resumable), jitError: error }
-    }
-  }
-  return buildClosure(p, kind, resumable)
-}
-
-const buildClosure = (p: ParserLike, kind: 0 | 1 | 2, resumable: boolean): Compiled => {
-  try {
-    const { fallbacks, step } = compileClosure(p, kind, resumable)
-    return { backend: "closure", step, fallbacks, error: undefined }
-  } catch (error) {
-    return { backend: undefined, step: undefined, fallbacks: [], error }
-  }
-}
-
 /**
  * The compiled form of a registered parser for an input kind, compiling it
  * if needed. `resumable` selects the build used by streaming parses, which
@@ -71,7 +50,7 @@ export const compiled = (p: ParserLike, kind: 0 | 1 | 2, resumable = false): Com
   const entry = registry.get(p)
   if (entry === undefined) return undefined
   const index = resumable ? kind + 3 : kind
-  return entry.byKind[index] ??= build(p, kind, entry.backend, resumable)
+  return (entry.byKind[index] ??= entry.backend.build(p, kind, resumable))
 }
 
 /** The compiled step for running `p` on `state`, if it is registered. */

package/src/internal/compiler/sets.ts

@@ -2,7 +2,11 @@
  * Token sets for compiled parsers: membership tables for small units, the
  * exact test for the rest, and the code point ranges when they are known.
  */
+import * as Arr from "effect/Array"
+import * as Order from "effect/Order"
+import * as Predicate from "effect/Predicate"
 import type { Encoding } from "../../Encoding.js"
+import { firstCodePoint } from "../text.js"
 import { compile, compileAny, PredicateRanges } from "../tokens.js"
 
 /** Size of the membership table: every byte, and the Latin-1 code points. */
@@ -18,22 +22,22 @@ export interface CharSet {
 }
 
 const isRange = (u: unknown): u is { readonly from: string | number; readonly to: string | number } =>
-  typeof u === "object" && u !== null && (u as any)._tag === "TokenRange"
+  Predicate.isObjectOrArray(u) && (u as any)._tag === "TokenRange"
 
-const toCode = (u: string | number): number => typeof u === "number" ? u : u.codePointAt(0)!
+const toCode = (u: string | number): number => (Predicate.isNumber(u) ? u : firstCodePoint(u))
 
 /** The code point ranges of a token set, or `undefined` if it has an unknown predicate. */
-export const rangesOf = (set: unknown): Array<[number, number]> | undefined => {
+const rangesOf = (set: unknown): Array<[number, number]> | undefined => {
   const out: Array<[number, number]> = []
   const add = (u: unknown): boolean => {
-    if (typeof u === "string") {
+    if (Predicate.isString(u)) {
       for (const c of u) {
-        const cp = c.codePointAt(0)!
+        const cp = firstCodePoint(c)
         out.push([cp, cp])
       }
       return true
     }
-    if (typeof u === "number") {
+    if (Predicate.isNumber(u)) {
       out.push([u, u])
       return true
     }
@@ -45,7 +49,7 @@ export const rangesOf = (set: unknown): Array<[number, number]> | undefined => {
       out.push([toCode(u.from), toCode(u.to)])
       return true
     }
-    if (typeof u === "function") {
+    if (Predicate.isFunction(u)) {
       const r = (u as any)[PredicateRanges] as ReadonlyArray<readonly [number, number]> | undefined
       if (r === undefined) return false
       for (const [a, b] of r) out.push([a, b])
@@ -55,9 +59,11 @@ export const rangesOf = (set: unknown): Array<[number, number]> | undefined => {
     return false
   }
   if (!add(set)) return undefined
-  out.sort((a, b) => a[0] - b[0])
   const merged: Array<[number, number]> = []
-  for (const [a, b] of out) {
+  for (const [a, b] of Arr.sort(
+    out,
+    Order.mapInput(Order.Number, (range: readonly [number, number]) => range[0])
+  )) {
     if (b < a) continue
     const last = merged[merged.length - 1]
     if (last !== undefined && a <= last[1] + 1) last[1] = Math.max(last[1], b)
@@ -93,8 +99,8 @@ export const reachesAbove = (s: CharSet, limit: number): boolean =>
 /** The input kind a `Text` encoding reads: 0 for strings, 1 for bytes. */
 export const kindOfEncoding = (enc: Encoding<any>): 0 | 1 => {
   let k = kinds.get(enc)
-  if (k === undefined) kinds.set(enc, k = typeof enc.encode("") === "string" ? 0 : 1)
+  if (k === undefined) kinds.set(enc, (k = Predicate.isString(enc.encode("")) ? 0 : 1))
   return k
 }
 
-const kinds = new WeakMap<Encoding<any>, 0 | 1>()
+const kinds = /*#__PURE__*/ new WeakMap<Encoding<any>, 0 | 1>()

package/src/internal/entries.ts

@@ -4,6 +4,8 @@
  * repetition of pairs with `Object.fromEntries` (see `Parser.fromEntries`).
  */
 
+import * as Predicate from "effect/Predicate"
+
 /** The built-in `Object.fromEntries`, which compiled parsers recognize. */
 export const fromEntries: <K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>) => { [P in K]: V } =
   Object.fromEntries as any
@@ -17,7 +19,7 @@ const hasOwn = objectPrototype.hasOwnProperty
  * property): `key` is a string that `Object.prototype` has no property for,
  * so there is no setter (`__proto__`) or read-only property to run into.
  */
-export const isPlainKey = (key: unknown): key is string => typeof key === "string" && !hasOwn.call(objectPrototype, key)
+export const isPlainKey = (key: unknown): key is string => Predicate.isString(key) && !hasOwn.call(objectPrototype, key)
 
 const define = (o: object, key: unknown, value: unknown): void => {
   Object.defineProperty(o, key as PropertyKey, { value, writable: true, enumerable: true, configurable: true })
@@ -36,7 +38,7 @@ export const addEntry = (
   key: unknown,
   value: unknown
 ): Array<unknown> | undefined => {
-  if (deferred === undefined && (typeof key !== "object" || key === null) && typeof key !== "function") {
+  if (deferred === undefined && !Predicate.isObjectOrArray(key) && !Predicate.isFunction(key)) {
     define(o, key, value)
     return undefined
   }

package/src/internal/node.ts

@@ -6,6 +6,7 @@
  * child's own step is always at hand for fallback, and recursion through
  * `Suspend` is just a reference.
  */
+import * as Predicate from "effect/Predicate"
 import type { Encoding } from "../Encoding.js"
 import type { ErrMode, Input, State } from "../Input.js"
 
@@ -53,15 +54,15 @@ export type Node =
   | { readonly _tag: "Identifier"; readonly encoding: Enc }
   | { readonly _tag: "Bom"; readonly encoding: Enc }
   | {
-    readonly _tag: "Escaped"
-    readonly normal: P
-    /** The control character, as a code point (or a byte / unit for `Ascii`). */
-    readonly control: number
-    readonly escape: P
-    /** `takeEscaped`: return the raw slice instead of the unescaped text. */
-    readonly raw: boolean
-    readonly encoding: Enc
-  }
+      readonly _tag: "Escaped"
+      readonly normal: P
+      /** The control character, as a code point (or a byte / unit for `Ascii`). */
+      readonly control: number
+      readonly escape: P
+      /** `takeEscaped`: return the raw slice instead of the unescaped text. */
+      readonly raw: boolean
+      readonly encoding: Enc
+    }
   // Mapping
   | { readonly _tag: "Map"; readonly self: P; readonly f: (a: any) => unknown }
   | { readonly _tag: "As"; readonly self: P; readonly value: unknown }
@@ -88,62 +89,74 @@ export type Node =
   | { readonly _tag: "Not"; readonly self: P }
   // Sequencing
   | {
-    readonly _tag: "Seq"
-    readonly parsers: ReadonlyArray<P>
-    /** Which outputs are kept: all (a tuple), one index, or a pair of indices. */
-    readonly output: "tuple" | number | readonly [number, number]
-  }
+      readonly _tag: "Seq"
+      readonly parsers: ReadonlyArray<P>
+      /** Which outputs are kept: all (a tuple), one index, or a pair of indices. */
+      readonly output: "tuple" | number | readonly [number, number]
+    }
   | { readonly _tag: "Struct"; readonly keys: ReadonlyArray<string>; readonly parsers: ReadonlyArray<P> }
   | { readonly _tag: "ZipWith"; readonly self: P; readonly that: P; readonly f: (a: any, b: any) => unknown }
   // Choice
   | { readonly _tag: "Alt"; readonly parsers: ReadonlyArray<P> }
   | {
-    readonly _tag: "Dispatch"
-    readonly selector: P
-    /** A record of cases, when `dispatch` was given one. */
-    readonly cases: Readonly<Record<PropertyKey, P>> | undefined
-    readonly otherwise: P | undefined
-    readonly choose: (key: any) => P | undefined
-  }
+      readonly _tag: "Dispatch"
+      readonly selector: P
+      /** A record of cases, when `dispatch` was given one. */
+      readonly cases: Readonly<Record<PropertyKey, P>> | undefined
+      readonly otherwise: P | undefined
+      readonly choose: (key: any) => P | undefined
+    }
   // Repetition
   | ({ readonly _tag: "Repeat"; readonly self: P } & Bounds)
   | ({
-    readonly _tag: "Fold"
-    readonly self: P
-    readonly init: () => unknown
-    readonly f: (acc: any, a: any) => unknown
-    readonly name: string
-  } & Bounds)
+      readonly _tag: "Fold"
+      readonly self: P
+      readonly init: () => unknown
+      readonly f: (acc: any, a: any) => unknown
+      /** Stops the repetition once false of the accumulator (after `min` elements). */
+      readonly while: ((acc: any) => boolean) | undefined
+      readonly name: string
+    } & Bounds)
   | ({ readonly _tag: "RepeatTill"; readonly self: P; readonly end: P } & Bounds)
   | ({ readonly _tag: "Separated"; readonly self: P; readonly separator: P } & Bounds)
   | {
-    readonly _tag: "SeparatedFold"
-    readonly self: P
-    readonly separator: P
-    readonly op: (l: any, s: any, r: any) => unknown
-    readonly right: boolean
-  }
+      readonly _tag: "SeparatedFold"
+      readonly self: P
+      readonly separator: P
+      readonly op: (l: any, s: any, r: any) => unknown
+      readonly right: boolean
+    }
   // Services, recovery, debugging
   | { readonly _tag: "Service" }
   | { readonly _tag: "Provide"; readonly self: P }
   | { readonly _tag: "ResumeAfter"; readonly self: P; readonly recover: P }
   | { readonly _tag: "RetryAfter"; readonly self: P; readonly recover: P }
   | { readonly _tag: "Trace"; readonly self: P; readonly name: string }
+  /** `Syntax.node`, `Syntax.token` and `Syntax.field`: identities outside `Syntax` parses. */
+  | {
+      readonly _tag: "Syntax"
+      readonly self: P
+      /** The node kind, or `undefined` for a field. */
+      readonly kind: string | undefined
+      readonly named: boolean
+    }
 
 export type Tag = Node["_tag"]
 
 export type NodeOf<T extends Tag> = Extract<Node, { readonly _tag: T }>
 
 /** Where a parser's description is stored. */
-export const NodeId: unique symbol = Symbol.for("effect-parse/Parser/node")
+export const NodeId: unique symbol = /*#__PURE__*/ Symbol.for("effect-parse/Parser/node")
 
 /** The description of a parser: `Opaque` when it has none. */
 export const nodeOf = (p: ParserLike): Node => (p as any)[NodeId] ?? { _tag: "Opaque", step: p.step }
 
 /** Normalizes a range, as `repeat`, `takeWhile`, ... do. */
-export const bounds = (range: number | { readonly min?: number | undefined; readonly max?: number | undefined } | undefined): Bounds => {
+export const bounds = (
+  range: number | { readonly min?: number | undefined; readonly max?: number | undefined } | undefined
+): Bounds => {
   if (range === undefined) return { min: 0, max: Infinity }
-  if (typeof range === "number") return { min: range, max: range }
+  if (Predicate.isNumber(range)) return { min: range, max: range }
   return { min: range.min ?? 0, max: range.max ?? Infinity }
 }
 
@@ -176,6 +189,7 @@ export const children = (node: Node): ReadonlyArray<P> => {
     case "Fold":
     case "Provide":
     case "Trace":
+    case "Syntax":
       return [node.self]
     case "ResumeAfter":
     case "RetryAfter":
@@ -189,7 +203,7 @@ export const children = (node: Node): ReadonlyArray<P> => {
     case "Dispatch": {
       const out: Array<P> = [node.selector]
       if (node.cases !== undefined) {
-        for (const key of Reflect.ownKeys(node.cases)) out.push(node.cases[key as any]!)
+        for (const key of Reflect.ownKeys(node.cases)) out.push(node.cases[key as any])
       }
       if (node.otherwise !== undefined) out.push(node.otherwise)
       return out

package/src/internal/numbers.ts

@@ -2,16 +2,18 @@
  * Number conversions shared by the `Ascii` and `Text` parsers and the
  * compilers.
  */
+import * as Predicate from "effect/Predicate"
 import type { Input } from "../Input.js"
 import { Fail } from "../Input.js"
 import { latin1 } from "./text.js"
 
-const toText = (s: Input): string =>
-  typeof s === "string" ? s : s instanceof Uint8Array ? latin1.text(s, 0, s.length) : s.join("")
+/** The text of an input slice: as is for a string, Latin-1 for bytes, joined for tokens. */
+export const toText = (s: Input): string =>
+  Predicate.isString(s) ? s : s instanceof Uint8Array ? latin1.text(s, 0, s.length) : s.join("")
 
 /** The value of the text matched by `Ascii.float` and `Text.float`. */
 export const toFloat = (s: Input): number => {
-  if (typeof s === "string") {
+  if (Predicate.isString(s)) {
     // Plain decimal notation (as opposed to `inf` or `nan`) ends in a digit or "."
     const last = s.charCodeAt(s.length - 1)
     if ((last >= 48 && last <= 57) || last === 46) return Number(s)
@@ -29,7 +31,7 @@ export const toFloat = (s: Input): number => {
  * compilers replace them by {@link scanFloatString} and
  * {@link scanFloatBytes} when the text is in decimal notation.
  */
-export const floatTexts = new WeakSet<object>()
+export const floatTexts = /*#__PURE__*/ new WeakSet<object>()
 
 /** Adds a parser to {@link floatTexts}. */
 export const floatText = <P extends object>(p: P): P => {
@@ -38,7 +40,7 @@ export const floatText = <P extends object>(p: P): P => {
 }
 
 /** The powers of ten that doubles represent exactly. */
-const exact = Array.from({ length: 23 }, (_, i) => Number(`1e${i}`))
+const exact = /*#__PURE__*/ Array.from({ length: 23 }, (_, i) => Number(`1e${i}`))
 
 /**
  * Where the latest scan ended, when it succeeded, and the furthest offset it
@@ -63,7 +65,7 @@ const twoProduct = (a: number, b: number): void => {
   const bh = t - (t - b)
   const bl = b - bh
   productHi = p
-  productLo = ((ah * bh - p) + ah * bl + al * bh) + al * bl
+  productLo = ah * bh - p + ah * bl + al * bh + al * bl
 }
 
 /** 2^-96: a bound on the relative error of {@link decimal}'s 19-digit path. */
@@ -87,25 +89,25 @@ const decimal = (negative: boolean, high: number, low: number, lowDigits: number
   let v: number
   if (lowDigits === 0) {
     if (e10 > 22 || e10 < -22) return undefined
-    v = e10 === 0 ? high : e10 > 0 ? high * exact[e10]! : high / exact[-e10]!
+    v = e10 === 0 ? high : e10 > 0 ? high * exact[e10] : high / exact[-e10]
   } else {
     if (e10 > 22 || e10 < -22) return undefined
     // The digits: high * 10^lowDigits + low = wh + wl, exactly
-    twoProduct(high, exact[lowDigits]!)
+    twoProduct(high, exact[lowDigits])
     const wh = productHi + low
     const wl = productLo + (low - (wh - productHi))
     let xh: number
     let xl: number
     if (e10 >= 0) {
-      const p = exact[e10]!
+      const p = exact[e10]
       twoProduct(wh, p)
       xh = productHi
       xl = productLo + wl * p
     } else {
-      const p = exact[-e10]!
+      const p = exact[-e10]
       xh = wh / p
       twoProduct(xh, p)
-      xl = ((wh - productHi) - productLo + wl) / p
+      xl = (wh - productHi - productLo + wl) / p
     }
     v = xh + xl
     const error = (xh < 0 ? -xh : xh) * Error19
@@ -211,9 +213,9 @@ export const scanFloatString = (s: string, i: number, end: number): number | Fai
 /** {@link scanFloatString} on bytes, or the units of an ASCII compatible encoding. */
 export const scanFloatBytes = (b: Uint8Array, i: number, end: number): number | Fail | undefined => {
   const start = i
-  let c = i < end ? b[i]! : -1
+  let c = i < end ? b[i] : -1
   if (c === 45 || c === 43) {
-    c = i + 1 < end ? b[i + 1]! : -1
+    c = i + 1 < end ? b[i + 1] : -1
     if (!isDigit(c) && c !== 46) return undefined
     i++
   } else if (!isDigit(c) && c !== 46) {
@@ -235,11 +237,11 @@ export const scanFloatBytes = (b: Uint8Array, i: number, end: number): number |
         else e10++
         digits++
       }
-      c = ++i < end ? b[i]! : -1
+      c = ++i < end ? b[i] : -1
     } while (isDigit(c))
-    if (c === 46) c = ++i < end ? b[i]! : -1
+    if (c === 46) c = ++i < end ? b[i] : -1
   } else {
-    c = ++i < end ? b[i]! : -1
+    c = ++i < end ? b[i] : -1
     if (!isDigit(c)) {
       floatScan.read = i
       return Fail
@@ -259,19 +261,19 @@ export const scanFloatBytes = (b: Uint8Array, i: number, end: number): number |
       }
       digits++
     }
-    c = ++i < end ? b[i]! : -1
+    c = ++i < end ? b[i] : -1
   }
   let read = i
   if (c === 101 || c === 69) {
     let j = i + 1
-    c = j < end ? b[j]! : -1
+    c = j < end ? b[j] : -1
     const negative = c === 45
-    if (negative || c === 43) c = ++j < end ? b[j]! : -1
+    if (negative || c === 43) c = ++j < end ? b[j] : -1
     if (isDigit(c)) {
       let e = 0
       do {
         if (e < 1e6) e = e * 10 + (c - 48)
-        c = ++j < end ? b[j]! : -1
+        c = ++j < end ? b[j] : -1
       } while (isDigit(c))
       e10 += negative ? -e : e
       i = j

package/src/internal/resume.ts

@@ -25,7 +25,7 @@ export type Checkpoints = Map<object, Map<number, unknown>>
 
 /** Takes (and removes) the checkpoint of `key` entered at `offset`, if any. */
 export const take = (state: State<any>, key: object, offset: number): unknown => {
-  const byKey = state.resume!.get(key)
+  const byKey = state.resume?.get(key)
   if (byKey === undefined) return undefined
   const checkpoint = byKey.get(offset)
   if (checkpoint !== undefined && !(checkpoint instanceof Done)) byKey.delete(offset)
@@ -34,7 +34,10 @@ export const take = (state: State<any>, key: object, offset: number): unknown =>
 
 /** The result of a repetition that completed, and where it ended. */
 export class Done {
-  constructor(readonly value: unknown, readonly pos: number) {}
+  constructor(
+    readonly value: unknown,
+    readonly pos: number
+  ) {}
 }
 
 /**
@@ -48,8 +51,9 @@ export const done = <A>(state: State<any>, key: object, entry: number, resumed:
 
 /** Records the checkpoint of `key` entered at `offset`. */
 export const save = (state: State<any>, key: object, offset: number, checkpoint: unknown): void => {
-  const resume = state.resume!
+  const resume = state.resume
+  if (resume === undefined) return
   let byKey = resume.get(key)
-  if (byKey === undefined) resume.set(key, byKey = new Map())
+  if (byKey === undefined) resume.set(key, (byKey = new Map()))
   byKey.set(offset, checkpoint)
 }

package/src/internal/run.ts

@@ -0,0 +1,41 @@
+/**
+ * Running a parser on a caller-owned `State`, compiled when possible.
+ *
+ * Shared by `Parser.run` and `ParserStream.parseMany`, which keep one
+ * state across many small runs.
+ */
+import { Fail, type State } from "../Input.js"
+import * as Registry from "./compiler/registry.js"
+import type { ParserLike } from "./node.js"
+import * as Stack from "./stack.js"
+
+/**
+ * Runs `p` on `state` from `state.pos`: its compiled form when it has one
+ * and the state allows it, else its step. A compiled run that fails is
+ * thrown away and the step runs again from the same position, so a
+ * failure leaves the state exactly as the interpreter would; with
+ * `diagnostics` false it is not, and the state keeps the compiled run's
+ * `mode`, with the cursor back at the start. Partial states (and states
+ * with streaming checkpoints) use the resumable build.
+ */
+export const runOn = <A>(
+  p: ParserLike,
+  step: (state: State<any>) => A | Fail,
+  state: State<any>,
+  diagnostics: boolean = true
+): A | Fail => {
+  if (state.tracer === undefined && state.recovered === undefined && state.syntax === undefined) {
+    const compiled = Registry.stepFor(p, state, state.partial || state.resume !== undefined)
+    if (compiled !== undefined) {
+      const start = state.pos
+      const a = Stack.run(compiled, state)
+      if (a !== Fail) {
+        // SAFETY: the compiled step returns what the parser's step returns
+        return a as A
+      }
+      state.pos = start
+      if (!diagnostics) return Fail
+    }
+  }
+  return Stack.run(step, state)
+}

package/src/internal/stack.ts

@@ -0,0 +1,36 @@
+/**
+ * Call-stack overflows.
+ *
+ * The interpreter and the compiled backends recurse once (or more) per
+ * nesting level of a recursive grammar, so deeply nested input, such as
+ * thousands of `{`, can exhaust the call stack. The runners catch the
+ * engine's overflow error and report a `TooDeep` failure instead, keeping
+ * their `Result` contract on untrusted input.
+ */
+import type { Fail, State } from "../Input.js"
+
+/** The message of a `TooDeep` failure. */
+const tooDeepMessage = "input is nested too deeply: parsing exhausted the call stack"
+
+/**
+ * Whether `e` is the engine's call-stack overflow: a `RangeError` in V8
+ * and JavaScriptCore, an `InternalError` ("too much recursion") in
+ * SpiderMonkey.
+ */
+export const isStackOverflow = (e: unknown): boolean =>
+  (e instanceof RangeError && /call stack/i.test(e.message)) ||
+  (e instanceof Error && e.name === "InternalError" && /recursion/i.test(e.message))
+
+/**
+ * Runs `step`, turning a call-stack overflow into an unrecoverable
+ * `TooDeep` failure at the offset parsing had reached. Other exceptions
+ * propagate.
+ */
+export const run = <S extends State<any>, A>(step: (state: S) => A, state: S): A | Fail => {
+  try {
+    return step(state)
+  } catch (e) {
+    if (!isStackOverflow(e)) throw e
+    return state.failMessage("Cut", "TooDeep", tooDeepMessage)
+  }
+}