@thomasfosterau/effect-parse 0.1.0 → 0.3.0

package/dist/Parser.js.map

@@ -1 +1 @@
-{"version":3,"file":"Parser.js","sourceRoot":"","sources":["../src/Parser.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Parser.js","names":[],"sources":["../src/Parser.ts"],"sourcesContent":["/**\n * The `Parser` data type and its general-purpose combinators.\n *\n * A `Parser<A, E, R, I>` consumes input of type `I` and produces a value of\n * type `A`. It may fail with a `ParseError<E>`, where `E` is the type of\n * user supplied error causes, and it may require services `R` from an Effect\n * `Context`.\n *\n * Under the hood a parser is a function over a mutable cursor (`Input.State`),\n * as in winnow. Failure is cheap and backtracking is a matter of resetting an\n * offset. On the surface the API follows Effect's conventions: parsers are\n * pipeable, combinators are dual (data-first or data-last), and parsers can\n * be written with generators:\n *\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const point = Parser.gen(function*() {\n *   yield* Token.literal(\"(\")\n *   const x = yield* Ascii.decInt\n *   yield* Token.literal(\",\")\n *   const y = yield* Ascii.decInt\n *   yield* Token.literal(\")\")\n *   return { x, y }\n * })\n *\n * Parser.parse(point, \"(1,-2)\") // Result.succeed({ x: 1, y: -2 })\n * ```\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport { dual } from \"effect/Function\"\nimport { NodeInspectSymbol } from \"effect/Inspectable\"\nimport * as Option from \"effect/Option\"\nimport type { Pipeable } from \"effect/Pipeable\"\nimport { pipeArguments } from \"effect/Pipeable\"\nimport * as Result from \"effect/Result\"\nimport type { Contravariant, Covariant, Simplify } from \"effect/Types\"\nimport type { ErrMode, Input, Slice, Source, TraceEvent } from \"./Input.js\"\nimport { Fail, Failure, mergeExpected, mergeFailures, mergeTiedFailures, State } from \"./Input.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport * as ParseError from \"./ParseError.js\"\nimport * as Registry from \"./internal/compiler/registry.js\"\nimport * as Entries from \"./internal/entries.js\"\nimport * as Resume from \"./internal/resume.js\"\nimport * as Run from \"./internal/run.js\"\nimport * as Stack from \"./internal/stack.js\"\nimport { TiedFailures } from \"./internal/ties.js\"\nimport type { Node } from \"./internal/node.js\"\nimport { bounds, NodeId } from \"./internal/node.js\"\n\n// -----------------------------------------------------------------------------\n// Models\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category type ids\n */\nexport const TypeId = \"~effect-parse/Parser\" as const\n\n/**\n * A parser that consumes input of type `I`, producing a value of type `A`,\n * possibly failing with a user cause of type `E`, and requiring services `R`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Parser<out A, out E = never, out R = never, in I extends Input = string> extends Pipeable {\n  readonly [TypeId]: Parser.Variance<A, E, R, I>\n  /**\n   * Runs one parsing step against a cursor. Returns the parsed value, or the\n   * `Fail` sentinel after recording the failure on the state.\n   *\n   * Calling `step` directly is how custom combinators built with\n   * {@link make} invoke other parsers.\n   */\n  readonly step: (state: State<I>) => A | Fail\n  /** A human-readable name, used by `toString` and tracing. */\n  readonly name: string | undefined\n  [Symbol.iterator](): ParserIterator<Parser<A, E, R, I>>\n}\n\n/**\n * The iterator used by `yield*` inside {@link gen}.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ParserIterator<P extends Parser.Any> {\n  next(...args: ReadonlyArray<any>): IteratorResult<P, Parser.Success<P>>\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport declare namespace Parser {\n  /**\n   * @since 0.1.0\n   */\n  export interface Variance<A, E, R, I> {\n    readonly _A: Covariant<A>\n    readonly _E: Covariant<E>\n    readonly _R: Covariant<R>\n    readonly _I: Contravariant<I>\n  }\n  /**\n   * Any parser.\n   *\n   * @since 0.1.0\n   */\n  export type Any = Parser<any, any, any, any>\n  /**\n   * The output type of a parser.\n   *\n   * @since 0.1.0\n   */\n  export type Success<P> = P extends Parser<infer A, infer _E, infer _R, infer _I> ? A : never\n  /**\n   * The user error type of a parser.\n   *\n   * @since 0.1.0\n   */\n  export type Error<P> = P extends Parser<infer _A, infer E, infer _R, infer _I> ? E : never\n  /**\n   * The services required by a parser.\n   *\n   * @since 0.1.0\n   */\n  export type Services<P> = P extends Parser<infer _A, infer _E, infer R, infer _I> ? R : never\n  /**\n   * The input accepted by a parser (or by every member of a union of\n   * parsers).\n   *\n   * @since 0.1.0\n   */\n  export type InputOf<P> = [P] extends [never]\n    ? Input\n    : [P] extends [Parser<infer _A, infer _E, infer _R, infer I>]\n      ? I\n      : never\n}\n\n/**\n * A repetition range, in the spirit of winnow's `impl Into<Range>`:\n *\n * - `n`: exactly `n` times\n * - `{ min, max }`: between `min` and `max` times (inclusive); `min`\n *   defaults to 0 and `max` to unbounded.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Range = number | { readonly min?: number | undefined; readonly max?: number | undefined }\n\n/**\n * The output of a repetition: a non-empty array when the range has a literal\n * positive minimum.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Repeated<A, Rg> = Rg extends number\n  ? number extends Rg\n    ? Array<A>\n    : Rg extends 0\n      ? Array<A>\n      : NonEmpty<A>\n  : Rg extends { readonly min: infer M extends number }\n    ? number extends M\n      ? Array<A>\n      : M extends 0\n        ? Array<A>\n        : NonEmpty<A>\n    : Array<A>\n\ntype NonEmpty<A> = [A, ...Array<A>]\n\n/**\n * A span of input offsets, `[start, end)`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Span {\n  readonly start: number\n  readonly end: number\n}\n\n// -----------------------------------------------------------------------------\n// Internals\n// -----------------------------------------------------------------------------\n\nconst variance: Parser.Variance<never, never, never, unknown> = {\n  _A: (_) => _,\n  _E: (_) => _,\n  _R: (_) => _,\n  _I: (_) => {}\n}\n\nclass SingleShotGen<T> {\n  private called = false\n  constructor(readonly self: T) {}\n  next(a: any): IteratorResult<T, any> {\n    if (this.called) return { value: a, done: true }\n    this.called = true\n    return { value: this.self, done: false }\n  }\n  return(a: any): IteratorResult<T, any> {\n    return { value: a, done: true }\n  }\n  throw(e: unknown): never {\n    throw e\n  }\n  [Symbol.iterator](): SingleShotGen<T> {\n    return new SingleShotGen(this.self)\n  }\n}\n\nclass ParserImpl<A, E, R, I extends Input> implements Parser<A, E, R, I> {\n  readonly [TypeId] = variance as Parser.Variance<A, E, R, I>\n  /** The description used by the compiler; `undefined` for `Opaque`. */\n  readonly [NodeId]: Node | undefined\n  constructor(\n    readonly step: (state: State<I>) => A | Fail,\n    readonly name: string | undefined,\n    node: Node | undefined\n  ) {\n    this[NodeId] = node\n  }\n  pipe() {\n    return pipeArguments(this, arguments)\n  }\n  [Symbol.iterator](): ParserIterator<Parser<A, E, R, I>> {\n    return new SingleShotGen(this) as any\n  }\n  toString() {\n    return this.name === undefined ? \"Parser\" : `Parser(${this.name})`\n  }\n  toJSON() {\n    return { _id: \"Parser\", name: this.name }\n  }\n  [NodeInspectSymbol]() {\n    return this.toJSON()\n  }\n}\n\n/**\n * Tests whether a value is a `Parser`.\n *\n * @since 0.1.0\n * @category guards\n */\nexport const isParser = (u: unknown): u is Parser<unknown, unknown, unknown, never> =>\n  Predicate.isObjectOrArray(u) && TypeId in u\n\nconst isParserArg = (args: IArguments) => isParser(args[0])\nconst isTwoParserArgs = (args: IArguments) => isParser(args[0]) && isParser(args[1])\n\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n\n/**\n * Creates a parser from a step function over the mutable {@link State}\n * cursor. This is the escape hatch for writing low-level parsers, much like\n * passing a plain function as a parser in winnow.\n *\n * The step function must either return the parsed value, having advanced\n * `state.pos` past the consumed input, or return the result of one of\n * `state.backtrack`, `state.cut`, `state.incomplete`, ... to signal failure.\n *\n * @example\n * ```ts\n * import { Parser } from \"@thomasfosterau/effect-parse\"\n *\n * // Parses a single ASCII uppercase letter\n * const upper = Parser.make<string>((state) => {\n *   const c = state.input.charCodeAt(state.pos)\n *   if (state.pos < state.end && c >= 65 && c <= 90) {\n *     state.pos++\n *     return String.fromCharCode(c)\n *   }\n *   return state.pos >= state.end\n *     ? state.eoi(\"Token\", [\"uppercase letter\"], 1)\n *     : state.backtrack(\"Token\", [\"uppercase letter\"])\n * })\n * ```\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <A, E = never, R = never, I extends Input = string>(\n  step: (state: State<I>) => A | Fail,\n  name?: string\n): Parser<A, E, R, I> => new ParserImpl(step, name, undefined)\n\n/**\n * Creates a parser together with its description, used by the compiler.\n *\n * @internal\n */\nexport const described = <A, E = never, R = never, I extends Input = string>(\n  step: (state: State<I>) => A | Fail,\n  name: string | undefined,\n  node: Node\n): Parser<A, E, R, I> => new ParserImpl(step, name, node)\n\nconst nodeOfParser = (p: Parser.Any): Node | undefined => (p as any)[NodeId]\n\n/**\n * Gives a parser a name, used by `toString`.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const named: {\n  (name: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I> =>\n    new ParserImpl(self.step, name, nodeOfParser(self))\n)\n\n/**\n * A parser that consumes nothing and succeeds with the given value.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const succeed = <A>(value: A): Parser<A, never, never, Input> =>\n  described(() => value, \"succeed\", { _tag: \"Succeed\", value })\n\n/**\n * A parser that consumes nothing and succeeds with the result of a thunk.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const sync = <A>(evaluate: () => A): Parser<A, never, never, Input> =>\n  described(() => evaluate(), \"sync\", { _tag: \"Sync\", evaluate })\n\n/**\n * A parser that consumes nothing and succeeds with `undefined` (winnow's\n * `empty`, nom's `success(())`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const empty: Parser<void, never, never, Input> = /*#__PURE__*/ described(() => undefined, \"empty\", {\n  _tag: \"Succeed\",\n  value: undefined\n})\n\n/**\n * Alias of {@link empty}, following Effect's `Effect.void`.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const void_: Parser<void, never, never, Input> = empty\n\nexport {\n  /**\n   * @since 0.1.0\n   * @category constructors\n   */\n  void_ as void\n}\n\n/**\n * A parser that always fails (backtracks) with the given user error as its\n * cause.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const fail = <E>(error: E): Parser<never, E, never, Input> =>\n  described<never, E, never, Input>((state) => state.failCause(\"Backtrack\", \"Fail\", error), \"fail\", failBacktrack)\n\nconst failBacktrack: Node = { _tag: \"Fail\", mode: \"Backtrack\" }\n\n/**\n * A parser that always fails (backtracks) without a cause. This is winnow's\n * `fail` and nom's `fail()`.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const reject: Parser<never, never, never, Input> = /*#__PURE__*/ described<never, never, never, Input>(\n  (state) => state.backtrack(\"Fail\"),\n  \"reject\",\n  failBacktrack\n)\n\n/**\n * A parser that always fails with a message.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const failMessage = (message: string): Parser<never, never, never, Input> =>\n  described<never, never, never, Input>(\n    (state) => state.failMessage(\"Backtrack\", \"Fail\", message),\n    \"failMessage\",\n    failBacktrack\n  )\n\n/**\n * A placeholder parser that fails with an unrecoverable error (winnow's\n * `todo`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const todo: Parser<never, never, never, Input> = /*#__PURE__*/ described<never, never, never, Input>(\n  (state) => state.failMessage(\"Cut\", \"Assert\", \"`todo` parser reached\"),\n  \"todo\",\n  { _tag: \"Fail\", mode: \"Cut\" }\n)\n\n/**\n * Lazily constructs a parser, which is needed to define recursive grammars.\n * The thunk is evaluated once, on first use.\n *\n * Each level of recursion uses some of the call stack, interpreted or\n * compiled, so input nested a few thousand levels deep exhausts it. The\n * runners catch the overflow and fail with an unrecoverable `ParseError` of\n * kind `\"TooDeep\"` at the offset reached, instead of throwing.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * type Nested = ReadonlyArray<Nested>\n * const nested: Parser.Parser<Nested> = Parser.delimited(\n *   Token.literal(\"[\"),\n *   Parser.repeat(Parser.suspend(() => nested)),\n *   Token.literal(\"]\")\n * )\n * ```\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const suspend = <A, E = never, R = never, I extends Input = string>(\n  evaluate: () => Parser<A, E, R, I>\n): Parser<A, E, R, I> => {\n  let parser: Parser<A, E, R, I> | undefined\n  return described((state) => (parser ??= evaluate()).step(state), \"suspend\", {\n    _tag: \"Suspend\",\n    resolve: () => (parser ??= evaluate())\n  })\n}\n\n/**\n * The current offset into the input (winnow's `Location`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const location: Parser<number, never, never, Input> = /*#__PURE__*/ described((state) => state.pos, \"location\", {\n  _tag: \"Location\"\n})\n\n/**\n * Succeeds (with `undefined`) only at the end of the input; nom's and\n * winnow's `eof`. On partial input, reaching the end of the available data\n * is reported as `Incomplete` since more data may follow.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const eof: Parser<void, never, never, Input> = /*#__PURE__*/ described(\n  (state) => {\n    if (state.pos < state.end) return state.backtrack(\"Eof\", expectedEof)\n    if (state.partial) return state.incomplete(1, expectedEof)\n    return undefined\n  },\n  \"eof\",\n  { _tag: \"Eof\" }\n)\n\nconst expectedEof = [\"end of input\"]\n\n// -----------------------------------------------------------------------------\n// Mapping\n// -----------------------------------------------------------------------------\n\n/**\n * Transforms the output of a parser.\n *\n * @since 0.1.0\n * @category mapping\n */\nexport const map: {\n  <A, B>(f: (a: A) => B): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E, R, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const a = step(state)\n        return a === Fail ? Fail : f(a)\n      },\n      self.name,\n      { _tag: \"Map\", self, f }\n    )\n  }\n)\n\n/**\n * Builds an object from the `[key, value]` entries a parser returns, as\n * `Object.fromEntries` does: `fromEntries(self)` is\n * `map(self, Object.fromEntries)`.\n *\n * Compiled parsers build the object directly when `self` repeats a pair\n * (`separated` or `repeat` of `separatedPair` or a two-element `seq`,\n * possibly inside `preceded`, `terminated`, `delimited` or `cut`), without\n * the pairs and the array. They do the same for `map(Object.fromEntries)`.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const entry = Parser.separatedPair(Ascii.alpha1, Token.literal(\"=\"), Ascii.decUint)\n * const record = Parser.fromEntries(Parser.separated(entry, Token.literal(\",\")))\n * Parser.parse(record, \"a=1,b=2\") // Result.succeed({ a: 1, b: 2 })\n * ```\n *\n * @since 0.2.0\n * @category mapping\n */\nexport const fromEntries = <K extends PropertyKey, V, E, R, I extends Input>(\n  self: Parser<Iterable<readonly [K, V]>, E, R, I>\n): Parser<{ [P in K]: V }, E, R, I> => map(self, Entries.fromEntries)\n\n/**\n * Replaces the output of a parser with a constant (winnow's `value`, nom's\n * `value`).\n *\n * @since 0.1.0\n * @category mapping\n */\nexport const as: {\n  <B>(value: B): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: B): Parser<B, E, R, I>\n} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: B): Parser<B, E, R, I> => {\n  const step = self.step\n  return described((state) => (step(state) === Fail ? Fail : value), self.name, { _tag: \"As\", self, value })\n})\n\n/**\n * Discards the output of a parser (winnow's `void`).\n *\n * @since 0.1.0\n * @category mapping\n */\nexport const asVoid = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<void, E, R, I> => as(self, undefined)\n\n/**\n * Replaces the output of a parser with `Option.some(output)`.\n *\n * @since 0.1.0\n * @category mapping\n */\nexport const asSome = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<Option.Option<A>, E, R, I> =>\n  map(self, Option.some)\n\n/**\n * Runs a side effect on the output of a parser, keeping the output.\n *\n * @since 0.1.0\n * @category mapping\n */\nexport const tap: {\n  <A>(f: (a: A) => void): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, f: (a: A) => void): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, f: (a: A) => void): Parser<A, E, R, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const a = step(state)\n        if (a !== Fail) f(a)\n        return a\n      },\n      self.name,\n      { _tag: \"Tap\", self, f }\n    )\n  }\n)\n\n/**\n * Uses the output of a parser to choose the parser that consumes the rest\n * of the input (winnow's `flat_map`, nom's `flat_map`).\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const flatMap: {\n  <A, B, E2, R2, I2 extends Input>(\n    f: (a: A) => Parser<B, E2, R2, I2>\n  ): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    f: (a: A) => Parser<B, E2, R2, I2>\n  ): Parser<B, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    f: (a: A) => Parser<B, E2, R2, I2>\n  ): Parser<B, E | E2, R | R2, I & I2> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const a = step(state)\n        return a === Fail ? Fail : f(a).step(state)\n      },\n      undefined,\n      { _tag: \"FlatMap\", self, f }\n    )\n  }\n)\n\n/**\n * Applies a second parser to the *output* of the first (winnow's\n * `and_then`, nom's `map_parser`). The output of the first parser must\n * itself be an input, e.g. a slice produced by {@link taken} or\n * `Token.take`.\n *\n * Error offsets reported by the inner parser are translated relative to the\n * start of the outer parser.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * // Take exactly 4 characters, then require them all to be digits\n * const year = Token.take(4).pipe(Parser.mapParser(Parser.allConsuming(Ascii.decUint)))\n * ```\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const mapParser: {\n  <A extends Input, B, E2, R2>(\n    inner: Parser<B, E2, R2, A>\n  ): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | E2, R | R2, I>\n  <A extends Input, E, R, I extends Input, B, E2, R2>(\n    self: Parser<A, E, R, I>,\n    inner: Parser<B, E2, R2, A>\n  ): Parser<B, E | E2, R | R2, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A extends Input, E, R, I extends Input, B, E2, R2>(\n    self: Parser<A, E, R, I>,\n    inner: Parser<B, E2, R2, A>\n  ): Parser<B, E | E2, R | R2, I> => {\n    const step = self.step\n    return make((state) => {\n      const start = state.pos\n      const a = step(state)\n      if (a === Fail) return Fail\n      const sub = new State(a, { context: state.context })\n      sub.tracer = state.tracer\n      sub.depth = state.depth\n      sub.recovered = state.recovered\n      const b = inner.step(sub)\n      if (b === Fail) {\n        const f = sub.failure\n        if (sub.encoding !== undefined) state.encoding = sub.encoding\n        // The inner input is usually a slice ending where the outer parser stopped\n        const base = Math.max(start, state.pos - a.length)\n        const offset = Math.min(base + f.offset, state.pos)\n        return state.failWith(\n          sub.mode === \"Incomplete\" ? \"Backtrack\" : sub.mode,\n          new Failure(offset, f.kind, f.expected, f.context, f.hasCause, f.cause, f.message, 0)\n        )\n      }\n      return b\n    })\n  }\n)\n\n/**\n * Transforms the output of a parser with a function that may fail with a\n * `Result` (winnow's `try_map`, nom's `map_res`). On failure the parser\n * backtracks to where it started and the error becomes the `cause` of the\n * `ParseError`.\n *\n * @since 0.1.0\n * @category mapping\n */\nexport const tryMap: {\n  <A, B, E2>(\n    f: (a: A) => Result.Result<B, E2>\n  ): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | E2, R, I>\n  <A, E, R, I extends Input, B, E2>(\n    self: Parser<A, E, R, I>,\n    f: (a: A) => Result.Result<B, E2>\n  ): Parser<B, E | E2, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B, E2>(\n    self: Parser<A, E, R, I>,\n    f: (a: A) => Result.Result<B, E2>\n  ): Parser<B, E | E2, R, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const start = state.pos\n        const a = step(state)\n        if (a === Fail) return Fail\n        const r = f(a)\n        if (Result.isSuccess(r)) return r.success\n        state.pos = start\n        return state.failCause(\"Backtrack\", \"Verify\", r.failure)\n      },\n      self.name,\n      { _tag: \"TryMap\", self, f }\n    )\n  }\n)\n\n/**\n * Like {@link tryMap}, but the function may throw. Thrown values become the\n * `cause` of the error.\n *\n * @since 0.1.0\n * @category mapping\n */\nexport const tryMapUnknown: {\n  <A, B>(f: (a: A) => B): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | unknown, R, I>\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E | unknown, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, unknown, R, I> =>\n    tryMap(self, (a) => {\n      try {\n        return Result.succeed(f(a))\n      } catch (e) {\n        if (Stack.isStackOverflow(e)) throw e\n        return Result.fail(e)\n      }\n    })\n)\n\n/**\n * Transforms the output of a parser with a function returning an `Option`;\n * `None` makes the parser backtrack (winnow's `verify_map`, nom's\n * `map_opt`).\n *\n * @since 0.1.0\n * @category filtering\n */\nexport const filterMap: {\n  <A, B>(f: (a: A) => Option.Option<B>): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => Option.Option<B>): Parser<B, E, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => Option.Option<B>): Parser<B, E, R, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const start = state.pos\n        const a = step(state)\n        if (a === Fail) return Fail\n        const o = f(a)\n        if (Option.isSome(o)) return o.value\n        state.pos = start\n        return state.backtrack(\"Verify\")\n      },\n      self.name,\n      { _tag: \"FilterMap\", self, f }\n    )\n  }\n)\n\n/**\n * Keeps the output of a parser only if it satisfies a predicate, otherwise\n * backtracks (winnow's and nom's `verify`).\n *\n * @since 0.1.0\n * @category filtering\n */\nexport const filter: {\n  <A, B extends A>(\n    refinement: (a: NoInfer<A>) => a is B\n  ): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>\n  <A>(predicate: (a: NoInfer<A>) => boolean): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input, B extends A>(self: Parser<A, E, R, I>, refinement: (a: A) => a is B): Parser<B, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, predicate: (a: A) => boolean): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, predicate: (a: A) => boolean) => {\n  const step = self.step\n  return described<A, E, R, I>(\n    (state) => {\n      const start = state.pos\n      const a = step(state)\n      if (a === Fail) return Fail\n      if (predicate(a)) return a\n      state.pos = start\n      return state.backtrack(\"Verify\")\n    },\n    self.name,\n    { _tag: \"Filter\", self, predicate }\n  )\n})\n\n/**\n * Keeps the output of a parser only if it satisfies a predicate, otherwise\n * backtracks with the given user error.\n *\n * @since 0.1.0\n * @category filtering\n */\nexport const filterOrFail: {\n  <A, B extends A, E2>(\n    refinement: (a: NoInfer<A>) => a is B,\n    orFailWith: (a: NoInfer<A>) => E2\n  ): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | E2, R, I>\n  <A, E2>(\n    predicate: (a: NoInfer<A>) => boolean,\n    orFailWith: (a: NoInfer<A>) => E2\n  ): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E | E2, R, I>\n  <A, E, R, I extends Input, B extends A, E2>(\n    self: Parser<A, E, R, I>,\n    refinement: (a: A) => a is B,\n    orFailWith: (a: A) => E2\n  ): Parser<B, E | E2, R, I>\n  <A, E, R, I extends Input, E2>(\n    self: Parser<A, E, R, I>,\n    predicate: (a: A) => boolean,\n    orFailWith: (a: A) => E2\n  ): Parser<A, E | E2, R, I>\n} = /*#__PURE__*/ dual(\n  3,\n  <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, predicate: (a: A) => boolean, orFailWith: (a: A) => E2) => {\n    const step = self.step\n    return described<A, E | E2, R, I>(\n      (state) => {\n        const start = state.pos\n        const a = step(state)\n        if (a === Fail) return Fail\n        if (predicate(a)) return a\n        state.pos = start\n        return state.failCause(\"Backtrack\", \"Verify\", orFailWith(a))\n      },\n      self.name,\n      { _tag: \"Filter\", self, predicate }\n    )\n  }\n)\n\n// -----------------------------------------------------------------------------\n// Consumed input\n// -----------------------------------------------------------------------------\n\n/**\n * Returns the slice of input consumed by a parser instead of its output\n * (winnow's `take`, nom's `recognize`).\n *\n * @since 0.1.0\n * @category consumed input\n */\nexport const taken = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<Slice<I>, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const start = state.pos\n      return step(state) === Fail ? Fail : state.slice(start, state.pos)\n    },\n    self.name,\n    { _tag: \"Taken\", self, encoding: undefined }\n  )\n}\n\n/**\n * Returns both the output of a parser and the slice of input it consumed\n * (winnow's `with_taken`; nom's `consumed` returns them in the other order).\n *\n * @since 0.1.0\n * @category consumed input\n */\nexport const withTaken = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>\n): Parser<[output: A, taken: Slice<I>], E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const start = state.pos\n      const a = step(state)\n      return a === Fail ? Fail : [a, state.slice(start, state.pos)]\n    },\n    self.name,\n    { _tag: \"WithTaken\", self }\n  )\n}\n\n/**\n * Returns the span (`[start, end)` offsets) consumed by a parser instead of\n * its output (winnow's `span`).\n *\n * @since 0.1.0\n * @category consumed input\n */\nexport const span = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<Span, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const start = state.pos\n      return step(state) === Fail ? Fail : { start, end: state.pos }\n    },\n    self.name,\n    { _tag: \"Span\", self }\n  )\n}\n\n/**\n * Returns both the output of a parser and the span it consumed (winnow's\n * `with_span`).\n *\n * @since 0.1.0\n * @category consumed input\n */\nexport const withSpan = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>\n): Parser<[output: A, span: Span], E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const start = state.pos\n      const a = step(state)\n      return a === Fail ? Fail : [a, { start, end: state.pos }]\n    },\n    self.name,\n    { _tag: \"WithSpan\", self }\n  )\n}\n\n// -----------------------------------------------------------------------------\n// Error management\n// -----------------------------------------------------------------------------\n\nconst changeMode = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  from: ErrMode,\n  to: ErrMode\n): Parser<A, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const a = step(state)\n      if (a === Fail && state.mode === from) state.mode = to\n      return a\n    },\n    self.name,\n    { _tag: \"Mode\", self, from, to }\n  )\n}\n\n/**\n * Commits to the current branch: recoverable failures of the parser become\n * unrecoverable, so enclosing `alt`, `opt`, `repeat`, ... do not try\n * alternatives (winnow's `cut_err`, nom's `cut`).\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * // Once we have seen \"-\", a number must follow\n * const negative = Parser.preceded(Token.literal(\"-\"), Parser.cut(Ascii.decUint))\n * ```\n *\n * @since 0.1.0\n * @category error management\n */\nexport const cut = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      // A committed failure is reported where it happened (winnow's\n      // `cut_err`): only failures recorded inside `self` can outrank it as the\n      // furthest failure, not ones from abandoned branches or lookaheads before\n      // the commit.\n      const deepest = state.deepest\n      state.deepest = undefined\n      const a = step(state)\n      if (a === Fail && state.mode !== \"Incomplete\") {\n        state.mode = \"Cut\"\n        return a\n      }\n      const inner = state.deepest as Failure | undefined\n      if (deepest !== undefined && (inner === undefined || deepest.offset > inner.offset)) state.deepest = deepest\n      return a\n    },\n    self.name,\n    { _tag: \"Mode\", self, from: \"Backtrack\", to: \"Cut\" }\n  )\n}\n\n/**\n * Turns unrecoverable failures back into recoverable ones (winnow's\n * `backtrack_err`).\n *\n * @since 0.1.0\n * @category error management\n */\nexport const backtrack = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> =>\n  changeMode(self, \"Cut\", \"Backtrack\")\n\n/**\n * Turns `Incomplete` failures into recoverable ones, treating the input as\n * complete for this parser (winnow's `complete_err`, nom's `complete`).\n *\n * @since 0.1.0\n * @category error management\n */\nexport const complete = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const start = state.pos\n      const a = step(state)\n      if (a === Fail && state.mode === \"Incomplete\") {\n        state.pos = start\n        return state.backtrack(\"Complete\")\n      }\n      return a\n    },\n    self.name,\n    { _tag: \"Mode\", self, from: \"Incomplete\", to: \"Backtrack\" }\n  )\n}\n\n/**\n * Adds a context label to failures of a parser (winnow's\n * `context(StrContext::Label(..))`, nom's `context`). Labels are rendered as\n * \"while parsing <label>\" in the error message.\n *\n * @since 0.1.0\n * @category error management\n */\nexport const context: {\n  (label: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, label: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, label: string): Parser<A, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const a = step(state)\n      if (a === Fail && state.mode !== \"Incomplete\") {\n        const f = state.failure\n        state.replaceFailure(\n          new Failure(f.offset, f.kind, f.expected, [...f.context, label], f.hasCause, f.cause, f.message, f.needed)\n        )\n      }\n      return a\n    },\n    self.name ?? label,\n    { _tag: \"Context\", self, label }\n  )\n})\n\n/**\n * Names what a parser expects. When the parser fails without consuming any\n * input, its expectations are replaced with `description`, so a failure is\n * reported as `expected <description>` rather than in terms of the parser's\n * internals (Parsec's `<?>`, winnow's `StrContext::Expected`).\n *\n * @since 0.1.0\n * @category error management\n */\nexport const expected: {\n  (description: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, description: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, description: string): Parser<A, E, R, I> => {\n    const step = self.step\n    const desc = [description]\n    return described(\n      (state) => {\n        const start = state.pos\n        const hintOffset = state.hintOffset\n        const hintExpected = state.hintExpected\n        const a = step(state)\n        if (a === Fail && state.failure.offset === start) {\n          const f = state.failure\n          const expected = hintOffset === start ? mergeExpected(hintExpected, desc) : desc\n          state.replaceFailure(\n            new Failure(f.offset, f.kind, expected, f.context, f.hasCause, f.cause, f.message, f.needed)\n          )\n        }\n        return a\n      },\n      description,\n      { _tag: \"Expected\", self, description }\n    )\n  }\n)\n\n/**\n * Transforms the user error (cause) of a parser's failures.\n *\n * @since 0.1.0\n * @category error management\n */\nexport const mapError: {\n  <E, E2>(f: (e: E) => E2): <A, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E2, R, I>\n  <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, f: (e: E) => E2): Parser<A, E2, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, f: (e: E) => E2): Parser<A, E2, R, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const a = step(state)\n        if (a === Fail && state.failure.hasCause) {\n          const x = state.failure\n          state.replaceFailure(\n            new Failure(x.offset, x.kind, x.expected, x.context, true, f(x.cause as E), x.message, x.needed)\n          )\n        }\n        return a\n      },\n      self.name,\n      { _tag: \"MapError\", self }\n    )\n  }\n)\n\n/**\n * Replaces any failure of a parser with the given user error, keeping the\n * failure's position and mode.\n *\n * @since 0.1.0\n * @category error management\n */\nexport const orFail: {\n  <E2>(error: () => E2): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E2, R, I>\n  <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, error: () => E2): Parser<A, E2, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, error: () => E2): Parser<A, E2, R, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const start = state.pos\n        const a = step(state)\n        if (a === Fail && state.mode !== \"Incomplete\") {\n          const x = state.failure\n          state.replaceFailure(new Failure(start, x.kind, [], x.context, true, error(), undefined, 0))\n        }\n        return a\n      },\n      self.name,\n      { _tag: \"OrFail\", self }\n    )\n  }\n)\n\n/**\n * If the parser fails recoverably, tries `that` from the same position.\n * `p.pipe(Parser.orElse(() => q))` is equivalent to `Parser.alt(p, q)`.\n *\n * @since 0.1.0\n * @category error management\n */\nexport const orElse: {\n  <B, E2, R2, I2 extends Input>(\n    that: () => Parser<B, E2, R2, I2>\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A | B, E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    that: () => Parser<B, E2, R2, I2>\n  ): Parser<A | B, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    that: () => Parser<B, E2, R2, I2>\n  ): Parser<A | B, E | E2, R | R2, I & I2> => alt(self, suspend(that))\n)\n\n/**\n * If the parser fails recoverably, succeeds with the given value without\n * consuming input.\n *\n * @since 0.1.0\n * @category error management\n */\nexport const orElseSucceed: {\n  <B>(value: () => B): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A | B, E, R, I>\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: () => B): Parser<A | B, E, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: () => B): Parser<A | B, E, R, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const start = state.pos\n        const a = step(state)\n        if (a !== Fail) return a\n        if (state.mode !== \"Backtrack\") return Fail\n        recover(state, start)\n        return value()\n      },\n      self.name,\n      { _tag: \"OrElseSucceed\", self, value }\n    )\n  }\n)\n\n/** Rewinds after a recoverable failure, remembering it as a hint. */\nconst recover = (state: State<any>, start: number): void => {\n  state.pos = start\n  const f = state.failure\n  if (f.offset === start) {\n    state.hintOffset = start\n    state.hintExpected = f.expected\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Control\n// -----------------------------------------------------------------------------\n\n/**\n * Makes a parser optional: returns `Option.none()` without consuming input if\n * it fails recoverably (winnow's and nom's `opt`).\n *\n * @since 0.1.0\n * @category control\n */\nexport const opt = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<Option.Option<A>, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const start = state.pos\n      const a = step(state)\n      if (a !== Fail) return Option.some(a)\n      if (state.mode !== \"Backtrack\") return Fail\n      recover(state, start)\n      return Option.none()\n    },\n    self.name,\n    { _tag: \"Opt\", self }\n  )\n}\n\n/**\n * Like {@link opt}, but returns `undefined` instead of `None`.\n *\n * @since 0.1.0\n * @category control\n */\nexport const optional = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A | undefined, E, R, I> =>\n  orElseSucceed(self, () => undefined)\n\n/**\n * Runs the parser only if `condition` holds, otherwise succeeds with\n * `Option.none()` (winnow's and nom's `cond`).\n *\n * @since 0.1.0\n * @category control\n */\nexport const cond = <A, E, R, I extends Input>(\n  condition: boolean,\n  self: Parser<A, E, R, I>\n): Parser<Option.Option<A>, E, R, I> => (condition ? asSome(self) : succeed(Option.none()))\n\n/**\n * Runs a parser without consuming input (winnow's and nom's `peek`).\n *\n * @since 0.1.0\n * @category control\n */\nexport const peek = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const start = state.pos\n      const hintOffset = state.hintOffset\n      const hintExpected = state.hintExpected\n      const deepest = state.deepest\n      const a = step(state)\n      if (a !== Fail) {\n        // Failures inside a lookahead that succeeded are about input that was\n        // never consumed, so they are not reported as the furthest failure\n        state.pos = start\n        state.hintOffset = hintOffset\n        state.hintExpected = hintExpected\n        state.deepest = deepest\n      }\n      return a\n    },\n    self.name,\n    { _tag: \"Peek\", self }\n  )\n}\n\n/**\n * Succeeds, without consuming input, only if the parser fails recoverably\n * (winnow's and nom's `not`).\n *\n * @since 0.1.0\n * @category control\n */\nexport const not = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<void, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const start = state.pos\n      const hintOffset = state.hintOffset\n      const hintExpected = state.hintExpected\n      const deepest = state.deepest\n      const a = step(state)\n      if (a !== Fail) {\n        // The failures inside `self` are not this parser's failure\n        state.pos = start\n        state.deepest = deepest\n        return state.backtrack(\"Not\")\n      }\n      if (state.mode !== \"Backtrack\") return Fail\n      state.pos = start\n      state.hintOffset = hintOffset\n      state.hintExpected = hintExpected\n      state.deepest = deepest\n      return undefined\n    },\n    self.name,\n    { _tag: \"Not\", self }\n  )\n}\n\n/**\n * Requires the parser to consume the whole input (nom's `all_consuming`).\n *\n * @since 0.1.0\n * @category control\n */\nexport const allConsuming = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> =>\n  terminated(self, eof)\n\n// -----------------------------------------------------------------------------\n// Sequencing\n// -----------------------------------------------------------------------------\n\n/**\n * Runs parsers in sequence, collecting their outputs in a tuple (winnow's\n * and nom's tuple parsers, winnow's `seq!`).\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const seq = <const Ps extends ReadonlyArray<Parser.Any>>(\n  ...parsers: Ps\n): Parser<\n  { -readonly [K in keyof Ps]: Parser.Success<Ps[K]> },\n  Parser.Error<Ps[number]>,\n  Parser.Services<Ps[number]>,\n  Parser.InputOf<Ps[number]>\n> => {\n  const steps = parsers.map((p) => p.step)\n  const n = steps.length\n  return described(\n    (state: State<any>) => {\n      const out = new Array(n)\n      for (let i = 0; i < n; i++) {\n        const a = steps[i](state)\n        if (a === Fail) return Fail\n        out[i] = a\n      }\n      return out as any\n    },\n    \"seq\",\n    { _tag: \"Seq\", parsers, output: \"tuple\" }\n  )\n}\n\n/**\n * Runs a record of parsers in sequence (in key order), collecting their\n * outputs in a record. This is the Effect counterpart to winnow's\n * `seq!(Struct { .. })`.\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const struct = <const Fields extends Readonly<Record<string, Parser.Any>>>(\n  fields: Fields\n): Parser<\n  Simplify<{ -readonly [K in keyof Fields]: Parser.Success<Fields[K]> }>,\n  Parser.Error<Fields[keyof Fields]>,\n  Parser.Services<Fields[keyof Fields]>,\n  Parser.InputOf<Fields[keyof Fields]>\n> => {\n  const keys = Object.keys(fields)\n  const steps = keys.map((k) => fields[k].step)\n  const n = keys.length\n  return described(\n    (state: State<any>) => {\n      const out: Record<string, unknown> = {}\n      for (let i = 0; i < n; i++) {\n        const a = steps[i](state)\n        if (a === Fail) return Fail\n        out[keys[i]] = a\n      }\n      return out as any\n    },\n    \"struct\",\n    { _tag: \"Struct\", keys, parsers: keys.map((k) => fields[k]) }\n  )\n}\n\n/**\n * Runs two parsers in sequence and returns both outputs.\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const zip: {\n  <B, E2, R2, I2 extends Input>(\n    that: Parser<B, E2, R2, I2>\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<[A, B], E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    that: Parser<B, E2, R2, I2>\n  ): Parser<[A, B], E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    that: Parser<B, E2, R2, I2>\n  ): Parser<[A, B], E | E2, R | R2, I & I2> => zipWith(self, that, (a, b) => [a, b])\n)\n\n/**\n * Runs two parsers in sequence and combines their outputs.\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const zipWith: {\n  <B, E2, R2, I2 extends Input, A, C>(\n    that: Parser<B, E2, R2, I2>,\n    f: (a: A, b: B) => C\n  ): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<C, E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input, C>(\n    self: Parser<A, E, R, I>,\n    that: Parser<B, E2, R2, I2>,\n    f: (a: A, b: B) => C\n  ): Parser<C, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  3,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input, C>(\n    self: Parser<A, E, R, I>,\n    that: Parser<B, E2, R2, I2>,\n    f: (a: A, b: B) => C\n  ): Parser<C, E | E2, R | R2, I & I2> => {\n    const s1 = self.step\n    const s2 = that.step\n    return described(\n      (state) => {\n        const a = s1(state)\n        if (a === Fail) return Fail\n        const b = s2(state)\n        if (b === Fail) return Fail\n        return f(a, b)\n      },\n      undefined,\n      { _tag: \"ZipWith\", self, that, f }\n    )\n  }\n)\n\n/**\n * Runs two parsers in sequence, keeping the output of the first.\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const zipLeft: {\n  <B, E2, R2, I2 extends Input>(\n    that: Parser<B, E2, R2, I2>\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    that: Parser<B, E2, R2, I2>\n  ): Parser<A, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    that: Parser<B, E2, R2, I2>\n  ): Parser<A, E | E2, R | R2, I & I2> => terminated(self, that)\n)\n\n/**\n * Runs two parsers in sequence, keeping the output of the second.\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const zipRight: {\n  <B, E2, R2, I2 extends Input>(\n    that: Parser<B, E2, R2, I2>\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    that: Parser<B, E2, R2, I2>\n  ): Parser<B, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    that: Parser<B, E2, R2, I2>\n  ): Parser<B, E | E2, R | R2, I & I2> => preceded(self, that)\n)\n\n/**\n * Runs `prefix` then `parser`, keeping the output of `parser` (winnow's and\n * nom's `preceded`).\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const preceded = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends Input>(\n  prefix: Parser<A1, E1, R1, I1>,\n  parser: Parser<A2, E2, R2, I2>\n): Parser<A2, E1 | E2, R1 | R2, I1 & I2> => {\n  const s1 = prefix.step\n  const s2 = parser.step\n  return described((state) => (s1(state) === Fail ? Fail : s2(state)), parser.name, {\n    _tag: \"Seq\",\n    parsers: [prefix, parser],\n    output: 1\n  })\n}\n\n/**\n * Runs `parser` then `suffix`, keeping the output of `parser` (winnow's and\n * nom's `terminated`).\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const terminated = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends Input>(\n  parser: Parser<A1, E1, R1, I1>,\n  suffix: Parser<A2, E2, R2, I2>\n): Parser<A1, E1 | E2, R1 | R2, I1 & I2> => {\n  const s1 = parser.step\n  const s2 = suffix.step\n  return described(\n    (state) => {\n      const a = s1(state)\n      if (a === Fail) return Fail\n      return s2(state) === Fail ? Fail : a\n    },\n    parser.name,\n    { _tag: \"Seq\", parsers: [parser, suffix], output: 0 }\n  )\n}\n\n/**\n * Runs `open`, `parser` and `close`, keeping the output of `parser`\n * (winnow's and nom's `delimited`).\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const delimited = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends Input, A3, E3, R3, I3 extends Input>(\n  open: Parser<A1, E1, R1, I1>,\n  parser: Parser<A2, E2, R2, I2>,\n  close: Parser<A3, E3, R3, I3>\n): Parser<A2, E1 | E2 | E3, R1 | R2 | R3, I1 & I2 & I3> => {\n  const s1 = open.step\n  const s2 = parser.step\n  const s3 = close.step\n  return described(\n    (state) => {\n      if (s1(state) === Fail) return Fail\n      const a = s2(state)\n      if (a === Fail) return Fail\n      return s3(state) === Fail ? Fail : a\n    },\n    parser.name,\n    { _tag: \"Seq\", parsers: [open, parser, close], output: 1 }\n  )\n}\n\n/**\n * Runs `first`, `separator` and `second`, keeping the outputs of `first` and\n * `second` (winnow's and nom's `separated_pair`).\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const separatedPair = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends Input, A3, E3, R3, I3 extends Input>(\n  first: Parser<A1, E1, R1, I1>,\n  separator: Parser<A2, E2, R2, I2>,\n  second: Parser<A3, E3, R3, I3>\n): Parser<[A1, A3], E1 | E2 | E3, R1 | R2 | R3, I1 & I2 & I3> => {\n  const s1 = first.step\n  const s2 = separator.step\n  const s3 = second.step\n  return described(\n    (state) => {\n      const a = s1(state)\n      if (a === Fail) return Fail\n      if (s2(state) === Fail) return Fail\n      const b = s3(state)\n      return b === Fail ? Fail : [a, b]\n    },\n    undefined,\n    { _tag: \"Seq\", parsers: [first, separator, second], output: [0, 2] }\n  )\n}\n\n/**\n * Writes a parser in imperative style with a generator, Effect style:\n * `yield*` a parser to run it and get its output.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const keyValue = Parser.gen(function*() {\n *   const key = yield* Ascii.alpha1\n *   yield* Token.literal(\"=\")\n *   const value = yield* Ascii.decInt\n *   return [key, value] as const\n * })\n * ```\n *\n * The body runs on every parse, so parsers created inside it, like\n * `Token.literal(\"=\")` above, are rebuilt on every run. On hot paths, build\n * them once outside the body:\n *\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const equals = Token.literal(\"=\")\n *\n * const keyValue = Parser.gen(function*() {\n *   const key = yield* Ascii.alpha1\n *   yield* equals\n *   const value = yield* Ascii.decInt\n *   return [key, value] as const\n * })\n * ```\n *\n * @since 0.1.0\n * @category sequencing\n */\nexport const gen = <Eff extends Parser.Any, AEff>(\n  f: () => Generator<Eff, AEff, never>\n): Parser<AEff, Parser.Error<Eff>, Parser.Services<Eff>, Parser.InputOf<Eff>> =>\n  make((state: State<any>) => {\n    const iterator = f()\n    let next = iterator.next()\n    while (!next.done) {\n      const a = next.value.step(state)\n      if (a === Fail) {\n        iterator.return?.(undefined as any)\n        return Fail\n      }\n      next = iterator.next(a as never)\n    }\n    return next.value\n  }, \"gen\")\n\n/**\n * The starting point for Do notation.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const range = Parser.Do.pipe(\n *   Parser.bind(\"start\", () => Ascii.decUint),\n *   Parser.zipLeft(Token.literal(\"..\")),\n *   Parser.bind(\"end\", () => Ascii.decUint)\n * )\n * ```\n *\n * @since 0.1.0\n * @category do notation\n */\nexport const Do: Parser<Record<never, never>, never, never, Input> = /*#__PURE__*/ succeed({})\n\n/**\n * Binds the output of a parser to a field of the Do record.\n *\n * @since 0.1.0\n * @category do notation\n */\nexport const bind: {\n  <N extends string, A extends object, B, E2, R2, I2 extends Input>(\n    name: Exclude<N, keyof A>,\n    f: (a: NoInfer<A>) => Parser<B, E2, R2, I2>\n  ): <E, R, I extends Input>(\n    self: Parser<A, E, R, I>\n  ) => Parser<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2, I & I2>\n  <A extends object, E, R, I extends Input, N extends string, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    name: Exclude<N, keyof A>,\n    f: (a: NoInfer<A>) => Parser<B, E2, R2, I2>\n  ): Parser<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(3, (self: Parser.Any, name: string, f: (a: any) => Parser.Any): Parser.Any =>\n  flatMap(self, (a) => map(f(a), (b) => ({ ...a, [name]: b })))\n)\n\n/**\n * Wraps the output of a parser in a record with a single field.\n *\n * @since 0.1.0\n * @category do notation\n */\nexport const bindTo: {\n  <N extends string>(name: N): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<{ [K in N]: A }, E, R, I>\n  <A, E, R, I extends Input, N extends string>(self: Parser<A, E, R, I>, name: N): Parser<{ [K in N]: A }, E, R, I>\n} = /*#__PURE__*/ dual(2, (self: Parser.Any, name: string): Parser.Any => map(self, (a) => ({ [name]: a })))\n\nconst let_: {\n  <N extends string, A extends object, B>(\n    name: Exclude<N, keyof A>,\n    f: (a: NoInfer<A>) => B\n  ): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<Simplify<Omit<A, N> & { [K in N]: B }>, E, R, I>\n  <A extends object, E, R, I extends Input, N extends string, B>(\n    self: Parser<A, E, R, I>,\n    name: Exclude<N, keyof A>,\n    f: (a: NoInfer<A>) => B\n  ): Parser<Simplify<Omit<A, N> & { [K in N]: B }>, E, R, I>\n} = /*#__PURE__*/ dual(3, (self: Parser.Any, name: string, f: (a: any) => unknown): Parser.Any =>\n  map(self, (a) => ({ ...a, [name]: f(a) }))\n)\n\nexport {\n  /**\n   * Adds a computed field to the Do record.\n   *\n   * @since 0.1.0\n   * @category do notation\n   */\n  let_ as let\n}\n\n// -----------------------------------------------------------------------------\n// Choice\n// -----------------------------------------------------------------------------\n\n/**\n * Tries each parser in turn and returns the output of the first that\n * succeeds (winnow's and nom's `alt`).\n *\n * Unrecoverable (`Cut`) and `Incomplete` failures stop the search\n * immediately. If every alternative fails recoverably, the failures are\n * merged: the one that got furthest wins, and failures at the same offset\n * combine their expectations, e.g. `expected \"true\", \"false\" or \"null\"`.\n *\n * @since 0.1.0\n * @category choice\n */\nexport const alt = <const Ps extends ReadonlyArray<Parser.Any>>(\n  ...parsers: Ps\n): Parser<\n  Parser.Success<Ps[number]>,\n  Parser.Error<Ps[number]>,\n  Parser.Services<Ps[number]>,\n  Parser.InputOf<Ps[number]>\n> => {\n  const steps = parsers.map((p) => p.step)\n  const n = steps.length\n  if (n === 0) return reject as any\n  if (n === 1) return parsers[0]\n  return described(\n    (state: State<any>) => {\n      const start = state.pos\n      // The branches' failures merged left to right, as `mergeFailures` would,\n      // except that the last two failures tied with `failure` wait in `tie1`\n      // and `tie2` and are merged only when needed: when a third tie arrives,\n      // when a succeeding branch stops where they failed (for the hint), or\n      // when the merge is read from the state after `failTies`. An `alt` whose\n      // later branch consumes input discards them unmerged.\n      let failure: Failure | undefined\n      let tie1: Failure | undefined\n      let tie2: Failure | undefined\n      for (let i = 0; i < n; i++) {\n        const a = steps[i](state)\n        if (a !== Fail) {\n          if (failure !== undefined && failure.offset === state.pos) {\n            let expected = failure.expected\n            if (tie1 !== undefined) expected = mergeExpected(expected, tie1.expected)\n            if (tie2 !== undefined) expected = mergeExpected(expected, tie2.expected)\n            state.setHint(failure.offset, expected)\n          }\n          return a\n        }\n        if (state.mode !== \"Backtrack\") return Fail\n        state.pos = start\n        // The branch's failure, whose own ties (from a nested `alt`) can be taken over unmerged\n        const head = state.failureHead\n        if (failure === undefined || head.offset > failure.offset) {\n          failure = head\n          tie1 = state.failureTie1\n          tie2 = state.failureTie2\n        } else if (head.offset === failure.offset) {\n          const f = state.failure\n          if (tie1 === undefined) tie1 = f\n          else if (tie2 === undefined) tie2 = f\n          else {\n            failure = mergeTiedFailures(failure, tie1, mergeExpected(failure.expected, tie1.expected))\n            tie1 = tie2\n            tie2 = f\n          }\n        }\n      }\n      // `failure` is set: there are at least two alternatives, and each one that fails sets it\n      if (failure === undefined) return state.failWith(\"Backtrack\", state.failure)\n      return tie1 === undefined ? state.failWith(\"Backtrack\", failure) : state.failTies(failure, tie1, tie2)\n    },\n    \"alt\",\n    { _tag: \"Alt\", parsers }\n  )\n}\n\n/**\n * Selects the parser to run next based on the output of `selector`, like a\n * `match` over the input (winnow's `dispatch!`). If no case matches, the\n * parser backtracks to where it started.\n *\n * Cases are given either as a record keyed by the selector's output (with\n * an optional `otherwise` parser for unlisted keys, like winnow's `_ =>`\n * arm), or as a function returning a parser (or `undefined` for no match).\n *\n * Prefer a record where the keys are known. Compiled code (see the\n * `Compiler` module) switches on the key and runs every case compiled; the\n * parser a function returns always runs interpreted, and one the function\n * builds (`(c) => Parser.cut(p)`) is rebuilt on every run.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const escape = Parser.preceded(\n *   Token.literal(\"\\\\\"),\n *   Parser.dispatch(Token.any, {\n *     n: Parser.succeed(\"\\n\"),\n *     t: Parser.succeed(\"\\t\"),\n *     u: Parser.preceded(Token.literal(\"{\"), Ascii.hexUint).pipe(\n *       Parser.zipLeft(Token.literal(\"}\")),\n *       Parser.map((cp) => String.fromCodePoint(cp))\n *     )\n *   })\n * )\n * ```\n *\n * @since 0.1.0\n * @category choice\n */\nexport const dispatch: {\n  <K, E, R, I extends Input, P extends Parser.Any>(\n    selector: Parser<K, E, R, I>,\n    cases: (key: K) => P | undefined\n  ): Parser<Parser.Success<P>, E | Parser.Error<P>, R | Parser.Services<P>, I & Parser.InputOf<P>>\n  <\n    K extends PropertyKey,\n    E,\n    R,\n    I extends Input,\n    const Cases extends { readonly [key in K]?: Parser.Any },\n    Otherwise extends Parser.Any = never\n  >(\n    selector: Parser<K, E, R, I>,\n    cases: Cases,\n    otherwise?: Otherwise\n  ): Parser<\n    Parser.Success<NonNullable<Cases[keyof Cases]> | Otherwise>,\n    E | Parser.Error<NonNullable<Cases[keyof Cases]> | Otherwise>,\n    R | Parser.Services<NonNullable<Cases[keyof Cases]> | Otherwise>,\n    I & Parser.InputOf<NonNullable<Cases[keyof Cases]> | Otherwise>\n  >\n} = (\n  selector: Parser.Any,\n  cases: ((key: any) => Parser.Any | undefined) | Record<PropertyKey, Parser.Any>,\n  otherwise?: Parser.Any\n) => {\n  const choose = Predicate.isFunction(cases)\n    ? cases\n    : (key: PropertyKey) => (Object.prototype.hasOwnProperty.call(cases, key) ? cases[key] : otherwise)\n  const step = selector.step\n  return described(\n    (state: State<any>) => {\n      const start = state.pos\n      const key = step(state)\n      if (key === Fail) return Fail\n      const parser = choose(key)\n      if (parser === undefined) {\n        state.pos = start\n        return state.backtrack(\"Dispatch\")\n      }\n      return parser.step(state)\n    },\n    \"dispatch\",\n    {\n      _tag: \"Dispatch\",\n      selector,\n      cases: Predicate.isFunction(cases) ? undefined : cases,\n      otherwise: Predicate.isFunction(cases) ? undefined : otherwise,\n      choose\n    }\n  )\n}\n\n/**\n * Applies every parser exactly once, in whatever order they match, and\n * returns their outputs in the order the parsers were given (winnow's and\n * nom's `permutation`).\n *\n * @since 0.1.0\n * @category choice\n */\nexport const permutation = <const Ps extends ReadonlyArray<Parser.Any>>(\n  ...parsers: Ps\n): Parser<\n  { -readonly [K in keyof Ps]: Parser.Success<Ps[K]> },\n  Parser.Error<Ps[number]>,\n  Parser.Services<Ps[number]>,\n  Parser.InputOf<Ps[number]>\n> => {\n  const steps = parsers.map((p) => p.step)\n  const n = steps.length\n  return make((state: State<any>) => {\n    // A round's failures, merged only if no parser matches in it (#44)\n    const ties = new TiedFailures()\n    const done = new Array<boolean>(n).fill(false)\n    const out = new Array(n)\n    let remaining = n\n    while (remaining > 0) {\n      ties.clear()\n      let matched = false\n      for (let i = 0; i < n; i++) {\n        if (done[i]) continue\n        const start = state.pos\n        const a = steps[i](state)\n        if (a !== Fail) {\n          out[i] = a\n          done[i] = true\n          remaining--\n          matched = true\n          break\n        }\n        if (state.mode !== \"Backtrack\") return Fail\n        state.pos = start\n        ties.add(state)\n      }\n      // Some parser is not done yet, and each one that fails is folded in\n      if (!matched) return ties.fail(state)\n    }\n    return out as any\n  }, \"permutation\")\n}\n\n// -----------------------------------------------------------------------------\n// Repetition\n// -----------------------------------------------------------------------------\n\nconst normalizeRange = (range: Range | undefined): [min: number, max: number] => {\n  if (range === undefined) return [0, Infinity]\n  if (Predicate.isNumber(range)) return [range, range]\n  const min = range.min ?? 0\n  const max = range.max ?? Infinity\n  if (min > max) throw new RangeError(`invalid range: min (${min}) > max (${max})`)\n  return [min, max]\n}\n\nconst assertConsumes = (state: State<any>, name: string): Fail =>\n  state.failMessage(\"Cut\", \"Assert\", `\\`${name}\\` parsers must always consume`)\n\n/** How far a repetition got before a streaming parse ran out of input. */\ninterface FoldCheckpoint<B> {\n  readonly acc: B\n  readonly count: number\n  /** Where the next element starts. */\n  readonly pos: number\n}\n\nconst saveFold = <B>(state: State<any>, key: object, entry: number, acc: B, pos: number): void =>\n  Resume.save(state, key, entry, { acc, count: 0, pos } satisfies FoldCheckpoint<B>)\n\nconst foldImpl = <A, B, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  range: Range | undefined,\n  init: () => B,\n  f: (acc: B, a: A) => B,\n  name: string,\n  node?: Node,\n  cond?: (acc: B) => boolean\n): Parser<B, E, R, I> => {\n  const [min, max] = normalizeRange(range)\n  const step = self.step\n  const checkLoop = max === Infinity\n  const key = {}\n  return described(\n    (state) => {\n      const entry = state.pos\n      let acc: B\n      let count = 0\n      const resumed = state.resume === undefined ? undefined : (Resume.take(state, key, entry) as FoldCheckpoint<B>)\n      if (resumed instanceof Resume.Done) {\n        state.pos = resumed.pos\n        return resumed.value as B\n      }\n      if (resumed !== undefined) {\n        acc = resumed.acc\n        count = resumed.count\n        state.pos = resumed.pos\n      } else {\n        acc = init()\n      }\n      for (; count < max; count++) {\n        if (cond !== undefined && count >= min && !cond(acc)) break\n        const start = state.pos\n        const a = step(state)\n        if (a === Fail) {\n          if (state.mode === \"Incomplete\" && state.resume !== undefined) {\n            Resume.save(state, key, entry, { acc, count, pos: start } satisfies FoldCheckpoint<B>)\n          }\n          if (state.mode !== \"Backtrack\" || count < min) return Fail\n          recover(state, start)\n          return Resume.done(state, key, entry, resumed !== undefined, acc)\n        }\n        if (checkLoop && state.pos === start) return assertConsumes(state, name)\n        acc = f(acc, a)\n      }\n      return Resume.done(state, key, entry, resumed !== undefined, acc)\n    },\n    name,\n    node ?? { _tag: \"Fold\", self, init, f, while: cond, name, ...bounds(range) }\n  )\n}\n\n/**\n * Applies a parser repeatedly, collecting the outputs in an array (winnow's\n * `repeat`, nom's `many0`, `many1`, `many_m_n` and `count`).\n *\n * The range defaults to `{ min: 0 }` (zero or more). A number repeats\n * exactly that many times. With a literal positive `min`, the output is\n * typed as a non-empty array.\n *\n * As in winnow, an unbounded repetition of a parser that succeeds without\n * consuming input fails with an unrecoverable assertion instead of looping\n * forever.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const abs = Parser.repeat(Token.literal(\"ab\"), { min: 1 })\n * Parser.parse(abs, \"ababab\") // Result.succeed([\"ab\", \"ab\", \"ab\"])\n * ```\n *\n * @since 0.1.0\n * @category repetition\n */\nexport const repeat: {\n  <const Rg extends Range = { readonly min: 0 }>(\n    range?: Rg\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<Repeated<A, Rg>, E, R, I>\n  <A, E, R, I extends Input, const Rg extends Range = { readonly min: 0 }>(\n    self: Parser<A, E, R, I>,\n    range?: Rg\n  ): Parser<Repeated<A, Rg>, E, R, I>\n} = /*#__PURE__*/ dual(isParserArg, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, range?: Range) =>\n  foldImpl<A, Array<A>, E, R, I>(\n    self,\n    range,\n    () => [],\n    (acc, a) => {\n      acc.push(a)\n      return acc\n    },\n    \"repeat\",\n    { _tag: \"Repeat\", self, ...bounds(range) }\n  )\n)\n\n/**\n * Applies a parser repeatedly, folding the outputs into an accumulator\n * (winnow's `repeat(..).fold(..)`, nom's `fold_many0`/`fold_many1`/\n * `fold_many_m_n`).\n *\n * With `while`, the repetition also stops, successfully and without\n * consuming more input, as soon as the predicate is false of the\n * accumulator. It is checked before each element once `range.min` elements\n * have been folded, so `min` still holds.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * // Keeps the first two digits, leaving the rest unparsed\n * const two = Parser.fold(Token.oneOf(\"0123456789\"), {\n *   init: () => \"\",\n *   f: (acc, d) => acc + d,\n *   while: (acc) => acc.length < 2\n * })\n * Parser.parsePeek(two, \"1234\") // Result.succeed([\"34\", \"12\"])\n * ```\n *\n * @since 0.1.0\n * @category repetition\n */\nexport const fold: {\n  <A, B>(options: {\n    readonly init: () => B\n    readonly f: (acc: B, a: A) => B\n    readonly range?: Range | undefined\n    readonly while?: ((acc: B) => boolean) | undefined\n  }): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>\n  <A, E, R, I extends Input, B>(\n    self: Parser<A, E, R, I>,\n    options: {\n      readonly init: () => B\n      readonly f: (acc: B, a: A) => B\n      readonly range?: Range | undefined\n      readonly while?: ((acc: B) => boolean) | undefined\n    }\n  ): Parser<B, E, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B>(\n    self: Parser<A, E, R, I>,\n    options: {\n      readonly init: () => B\n      readonly f: (acc: B, a: A) => B\n      readonly range?: Range | undefined\n      readonly while?: ((acc: B) => boolean) | undefined\n    }\n  ): Parser<B, E, R, I> => foldImpl(self, options.range, options.init, options.f, \"fold\", undefined, options.while)\n)\n\n/**\n * Applies `self` repeatedly until `end` succeeds, returning the collected\n * outputs and the output of `end` (winnow's `repeat_till`, nom's\n * `many_till`).\n *\n * @since 0.1.0\n * @category repetition\n */\nexport const repeatTill: {\n  <B, E2, R2, I2 extends Input, const Rg extends Range = { readonly min: 0 }>(\n    end: Parser<B, E2, R2, I2>,\n    range?: Rg\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<[Repeated<A, Rg>, B], E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input, const Rg extends Range = { readonly min: 0 }>(\n    self: Parser<A, E, R, I>,\n    end: Parser<B, E2, R2, I2>,\n    range?: Rg\n  ): Parser<[Repeated<A, Rg>, B], E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  isTwoParserArgs,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    end: Parser<B, E2, R2, I2>,\n    range?: Range\n  ): Parser<[Array<A>, B], E | E2, R | R2, I & I2> => {\n    const [min, max] = normalizeRange(range)\n    const step = self.step\n    const endStep = end.step\n    return described(\n      (state) => {\n        const acc: Array<A> = []\n        while (true) {\n          const start = state.pos\n          let endFailure: Failure | undefined\n          if (acc.length >= min) {\n            const b = endStep(state)\n            if (b !== Fail) return [acc, b]\n            if (state.mode !== \"Backtrack\") return Fail\n            endFailure = state.failure\n            state.pos = start\n            if (acc.length >= max) return Fail\n          }\n          const a = step(state)\n          if (a === Fail) {\n            if (endFailure !== undefined && state.mode === \"Backtrack\") {\n              state.failWith(\"Backtrack\", mergeFailures(endFailure, state.failure))\n            }\n            return Fail\n          }\n          if (state.pos === start) return assertConsumes(state, \"repeatTill\")\n          acc.push(a)\n        }\n      },\n      \"repeatTill\",\n      { _tag: \"RepeatTill\", self, end, ...bounds(range) }\n    )\n  }\n)\n\n/** How far `separated` got: the elements so far, and where the next separator starts. */\ninterface SeparatedCheckpoint<A> {\n  readonly acc: Array<A>\n  readonly pos: number\n}\n\n/**\n * Applies `self` repeatedly, separated by `separator`, collecting the\n * outputs of `self` (winnow's `separated`, nom's `separated_list0` and\n * `separated_list1`). A trailing separator is not consumed.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const csv = Parser.separated(Ascii.decInt, Token.literal(\",\"))\n * Parser.parse(csv, \"1,2,3\") // Result.succeed([1, 2, 3])\n * ```\n *\n * @since 0.1.0\n * @category repetition\n */\nexport const separated: {\n  <S, E2, R2, I2 extends Input, const Rg extends Range = { readonly min: 0 }>(\n    separator: Parser<S, E2, R2, I2>,\n    range?: Rg\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<Repeated<A, Rg>, E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, S, E2, R2, I2 extends Input, const Rg extends Range = { readonly min: 0 }>(\n    self: Parser<A, E, R, I>,\n    separator: Parser<S, E2, R2, I2>,\n    range?: Rg\n  ): Parser<Repeated<A, Rg>, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  isTwoParserArgs,\n  <A, E, R, I extends Input, S, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    separator: Parser<S, E2, R2, I2>,\n    range?: Range\n  ): Parser<Array<A>, E | E2, R | R2, I & I2> => {\n    const [min, max] = normalizeRange(range)\n    const step = self.step\n    const sepStep = separator.step\n    const checkLoop = max === Infinity\n    const key = {}\n    return described(\n      (state) => {\n        const entry = state.pos\n        let acc: Array<A>\n        const resumed =\n          state.resume === undefined ? undefined : (Resume.take(state, key, entry) as SeparatedCheckpoint<A>)\n        if (resumed instanceof Resume.Done) {\n          state.pos = resumed.pos\n          return resumed.value as Array<A>\n        }\n        if (resumed !== undefined) {\n          acc = resumed.acc\n          state.pos = resumed.pos\n        } else {\n          acc = []\n          if (max === 0) return acc\n          const start = state.pos\n          const first = step(state)\n          if (first === Fail) {\n            if (state.mode !== \"Backtrack\" || min > 0) return Fail\n            recover(state, start)\n            return acc\n          }\n          acc.push(first)\n        }\n        while (acc.length < max) {\n          const start = state.pos\n          if (sepStep(state) === Fail) {\n            if (state.mode === \"Incomplete\" && state.resume !== undefined) {\n              Resume.save(state, key, entry, { acc, pos: start } satisfies SeparatedCheckpoint<A>)\n            }\n            if (state.mode !== \"Backtrack\" || acc.length < min) return Fail\n            recover(state, start)\n            return Resume.done(state, key, entry, resumed !== undefined, acc)\n          }\n          if (checkLoop && state.pos === start) return assertConsumes(state, \"separated\")\n          const a = step(state)\n          if (a === Fail) {\n            if (state.mode === \"Incomplete\" && state.resume !== undefined) {\n              Resume.save(state, key, entry, { acc, pos: start } satisfies SeparatedCheckpoint<A>)\n            }\n            if (state.mode !== \"Backtrack\" || acc.length < min) return Fail\n            state.pos = start\n            return Resume.done(state, key, entry, resumed !== undefined, acc)\n          }\n          acc.push(a)\n        }\n        return Resume.done(state, key, entry, resumed !== undefined, acc)\n      },\n      \"separated\",\n      { _tag: \"Separated\", self, separator, ...bounds(range) }\n    )\n  }\n)\n\n/**\n * Parses one or more `self` separated by `separator`, folding them from the\n * left with the separator's output: `((a op b) op c)` (winnow's\n * `separated_foldl1`). This is the classic way to parse left-associative\n * binary operators.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const sum = Parser.separatedFoldl1(\n *   Ascii.decInt,\n *   Parser.alt(Token.literal(\"+\"), Token.literal(\"-\")),\n *   (l, op, r) => op === \"+\" ? l + r : l - r\n * )\n * Parser.parse(sum, \"10-3+2\") // Result.succeed(9)\n * ```\n *\n * @since 0.1.0\n * @category repetition\n */\nexport const separatedFoldl1 = <A, E, R, I extends Input, S, E2, R2, I2 extends Input>(\n  self: Parser<A, E, R, I>,\n  separator: Parser<S, E2, R2, I2>,\n  op: (left: A, separator: S, right: A) => A\n): Parser<A, E | E2, R | R2, I & I2> => {\n  const step = self.step\n  const sepStep = separator.step\n  const key = {}\n  return described(\n    (state) => {\n      const entry = state.pos\n      const resumed = state.resume === undefined ? undefined : (Resume.take(state, key, entry) as FoldCheckpoint<A>)\n      let acc: A | Fail\n      if (resumed instanceof Resume.Done) {\n        state.pos = resumed.pos\n        return resumed.value as A\n      }\n      if (resumed !== undefined) {\n        acc = resumed.acc\n        state.pos = resumed.pos\n      } else {\n        acc = step(state)\n        if (acc === Fail) return Fail\n      }\n      while (true) {\n        const start = state.pos\n        const s = sepStep(state)\n        if (s === Fail) {\n          if (state.mode === \"Incomplete\" && state.resume !== undefined) saveFold(state, key, entry, acc, start)\n          if (state.mode !== \"Backtrack\") return Fail\n          recover(state, start)\n          return Resume.done(state, key, entry, resumed !== undefined, acc as A)\n        }\n        if (state.pos === start) return assertConsumes(state, \"separatedFoldl1\")\n        const a = step(state)\n        if (a === Fail) {\n          if (state.mode === \"Incomplete\" && state.resume !== undefined) saveFold(state, key, entry, acc, start)\n          if (state.mode !== \"Backtrack\") return Fail\n          state.pos = start\n          return Resume.done(state, key, entry, resumed !== undefined, acc as A)\n        }\n        acc = op(acc, s, a)\n      }\n    },\n    \"separatedFoldl1\",\n    { _tag: \"SeparatedFold\", self, separator, op, right: false }\n  )\n}\n\n/**\n * Parses one or more `self` separated by `separator`, folding them from the\n * right with the separator's output: `(a op (b op c))` (winnow's\n * `separated_foldr1`). Useful for right-associative operators such as\n * exponentiation.\n *\n * @since 0.1.0\n * @category repetition\n */\nexport const separatedFoldr1 = <A, E, R, I extends Input, S, E2, R2, I2 extends Input>(\n  self: Parser<A, E, R, I>,\n  separator: Parser<S, E2, R2, I2>,\n  op: (left: A, separator: S, right: A) => A\n): Parser<A, E | E2, R | R2, I & I2> => {\n  const step = self.step\n  const sepStep = separator.step\n  return described(\n    (state) => {\n      const first = step(state)\n      if (first === Fail) return Fail\n      const values: Array<A> = [first]\n      const seps: Array<S> = []\n      while (true) {\n        const start = state.pos\n        const s = sepStep(state)\n        if (s === Fail) {\n          if (state.mode !== \"Backtrack\") return Fail\n          recover(state, start)\n          break\n        }\n        if (state.pos === start) return assertConsumes(state, \"separatedFoldr1\")\n        const a = step(state)\n        if (a === Fail) {\n          if (state.mode !== \"Backtrack\") return Fail\n          state.pos = start\n          break\n        }\n        seps.push(s)\n        values.push(a)\n      }\n      let acc = values[values.length - 1] as A\n      for (let i = seps.length - 1; i >= 0; i--) {\n        acc = op(values[i] as A, seps[i] as S, acc)\n      }\n      return acc\n    },\n    \"separatedFoldr1\",\n    { _tag: \"SeparatedFold\", self, separator, op, right: true }\n  )\n}\n\n// -----------------------------------------------------------------------------\n// Services\n// -----------------------------------------------------------------------------\n\n/**\n * Accesses a service from the parser's context. Services take the place of\n * winnow's `Stateful` input: they can hold configuration, or mutable state\n * such as an indentation stack or a symbol table.\n *\n * Services are provided with {@link provideService} / {@link provide}, with\n * the `context` option of the runners, or taken from the surrounding Effect\n * by {@link parseEffect}.\n *\n * Mutations made to a service's state are not undone on backtracking (as\n * with winnow's `Stateful`).\n *\n * @example\n * ```ts\n * import { Context } from \"effect\"\n * import { Ascii, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * class Radix extends Context.Service<Radix, number>()(\"Radix\") {}\n *\n * const number = Parser.service(Radix).pipe(\n *   Parser.flatMap((radix) =>\n *     Ascii.alphanumeric1.pipe(Parser.map((digits) => parseInt(digits, radix)))\n *   )\n * )\n *\n * Parser.parse(Parser.provideService(number, Radix, 16), \"ff\") // Result.succeed(255)\n * ```\n *\n * @since 0.1.0\n * @category services\n */\nexport const service = <Id, S>(key: Context.Key<Id, S>): Parser<S, never, Id, Input> =>\n  described((state) => Context.getUnsafe(state.context, key), \"service\", serviceNode)\n\nconst serviceNode: Node = { _tag: \"Service\" }\n\n/**\n * Provides a service to a parser.\n *\n * @since 0.1.0\n * @category services\n */\nexport const provideService: {\n  <Id, S>(\n    key: Context.Key<Id, S>,\n    service: NoInfer<S>\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, Exclude<R, Id>, I>\n  <A, E, R, I extends Input, Id, S>(\n    self: Parser<A, E, R, I>,\n    key: Context.Key<Id, S>,\n    service: NoInfer<S>\n  ): Parser<A, E, Exclude<R, Id>, I>\n} = /*#__PURE__*/ dual(\n  3,\n  <A, E, R, I extends Input, Id, S>(\n    self: Parser<A, E, R, I>,\n    key: Context.Key<Id, S>,\n    service: S\n  ): Parser<A, E, Exclude<R, Id>, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const prev = state.context\n        state.context = Context.add(prev, key, service) as Context.Context<never>\n        try {\n          return step(state)\n        } finally {\n          state.context = prev\n        }\n      },\n      self.name,\n      { _tag: \"Provide\", self }\n    )\n  }\n)\n\n/**\n * Provides a context of services to a parser.\n *\n * @since 0.1.0\n * @category services\n */\nexport const provide: {\n  <R2>(\n    context: Context.Context<R2>\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, Exclude<R, R2>, I>\n  <A, E, R, I extends Input, R2>(\n    self: Parser<A, E, R, I>,\n    context: Context.Context<R2>\n  ): Parser<A, E, Exclude<R, R2>, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, R2>(\n    self: Parser<A, E, R, I>,\n    context: Context.Context<R2>\n  ): Parser<A, E, Exclude<R, R2>, I> => {\n    const step = self.step\n    return described(\n      (state) => {\n        const prev = state.context\n        state.context = Context.merge(prev, context) as Context.Context<never>\n        try {\n          return step(state)\n        } finally {\n          state.context = prev\n        }\n      },\n      self.name,\n      { _tag: \"Provide\", self }\n    )\n  }\n)\n\n// -----------------------------------------------------------------------------\n// Error recovery\n// -----------------------------------------------------------------------------\n\n/**\n * Error recovery: if the parser fails, record the failure, skip input with\n * `recover`, and continue with `Option.none()` (winnow's `resume_after`).\n *\n * Recovery is only active when running with {@link parseRecoverable}. Under\n * the other runners the parser behaves like `Parser.asSome(self)`.\n *\n * @since 0.1.0\n * @category error recovery\n */\nexport const resumeAfter: {\n  <B, E2, R2, I2 extends Input>(\n    recover: Parser<B, E2, R2, I2>\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<Option.Option<A>, E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    recover: Parser<B, E2, R2, I2>\n  ): Parser<Option.Option<A>, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    recover: Parser<B, E2, R2, I2>\n  ): Parser<Option.Option<A>, E | E2, R | R2, I & I2> => {\n    const step = self.step\n    const recoverStep = recover.step\n    return described(\n      (state) => {\n        const start = state.pos\n        const a = step(state)\n        if (a !== Fail) return Option.some(a)\n        if (state.recovered === undefined || state.mode === \"Incomplete\") return Fail\n        const failure = state.failure\n        const mode = state.mode\n        state.pos = start\n        if (recoverStep(state) === Fail) return state.failWith(mode, failure)\n        state.recovered.push(failure)\n        state.syntax?.skipped(start, failure, mode)\n        return Option.none()\n      },\n      self.name,\n      { _tag: \"ResumeAfter\", self, recover }\n    )\n  }\n)\n\n/**\n * Error recovery: if the parser fails, record the failure, skip input with\n * `recover`, and try the parser again (winnow's `retry_after`).\n *\n * Recovery is only active when running with {@link parseRecoverable}. Under\n * the other runners the parser behaves like `self`.\n *\n * @since 0.1.0\n * @category error recovery\n */\nexport const retryAfter: {\n  <B, E2, R2, I2 extends Input>(\n    recover: Parser<B, E2, R2, I2>\n  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E | E2, R | R2, I & I2>\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    recover: Parser<B, E2, R2, I2>\n  ): Parser<A, E | E2, R | R2, I & I2>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n    self: Parser<A, E, R, I>,\n    recover: Parser<B, E2, R2, I2>\n  ): Parser<A, E | E2, R | R2, I & I2> => {\n    const step = self.step\n    const recoverStep = recover.step\n    return described(\n      (state) => {\n        while (true) {\n          const start = state.pos\n          const a = step(state)\n          if (a !== Fail) return a\n          if (state.recovered === undefined || state.mode === \"Incomplete\") return Fail\n          const failure = state.failure\n          const mode = state.mode\n          state.pos = start\n          if (recoverStep(state) === Fail || state.pos === start) return state.failWith(mode, failure)\n          state.recovered.push(failure)\n          state.syntax?.skipped(start, failure, mode)\n        }\n      },\n      self.name,\n      { _tag: \"RetryAfter\", self, recover }\n    )\n  }\n)\n\n// -----------------------------------------------------------------------------\n// Debugging\n// -----------------------------------------------------------------------------\n\n/**\n * Traces the execution of a parser (winnow's `trace`). When a tracer is\n * installed (see the `trace` option of {@link parse}), `Enter` and `Exit`\n * events are reported for each traced parser; otherwise tracing has no\n * effect.\n *\n * @since 0.1.0\n * @category debugging\n */\nexport const trace: {\n  (name: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I> => {\n  const step = self.step\n  return described(\n    (state) => {\n      const tracer = state.tracer\n      if (tracer === undefined) return step(state)\n      const start = state.pos\n      const depth = state.depth\n      tracer({ _tag: \"Enter\", name, depth, offset: start, state })\n      state.depth = depth + 1\n      const a = step(state)\n      state.depth = depth\n      tracer({\n        _tag: \"Exit\",\n        name,\n        depth,\n        offset: start,\n        endOffset: state.pos,\n        result: a === Fail ? state.mode : \"Ok\",\n        state\n      })\n      return a\n    },\n    name,\n    { _tag: \"Trace\", self, name }\n  )\n})\n\nconst preview = (state: State<any>, offset: number): string => {\n  const input = state.input\n  if (Predicate.isString(input)) {\n    const s = input.slice(offset, offset + 24)\n    return JSON.stringify(s) + (offset + 24 < input.length ? \"…\" : \"∅\")\n  }\n  if (input instanceof Uint8Array) {\n    return Array.from(input.subarray(offset, offset + 12), (b) => b.toString(16).padStart(2, \"0\")).join(\" \")\n  }\n  return `[${offset}/${input.length}]`\n}\n\n/**\n * A tracer that writes an indented trace to `console.log`, similar to\n * winnow's `debug` feature.\n *\n * @since 0.1.0\n * @category debugging\n */\nexport const consoleTracer = (event: TraceEvent): void => {\n  const indent = \"  \".repeat(event.depth)\n  if (event._tag === \"Enter\") {\n    console.log(`${indent}> ${event.name} @${event.offset} | ${preview(event.state, event.offset)}`)\n  } else {\n    const consumed = (event.endOffset ?? event.offset) - event.offset\n    console.log(`${indent}< ${event.name} | ${event.result === \"Ok\" ? `+${consumed}` : event.result}`)\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Compiled parsers\n// -----------------------------------------------------------------------------\n\n/** Returned by {@link runCompiled} when there is no compiled form to run. */\nconst NotCompiled: unique symbol = /*#__PURE__*/ Symbol(\"NotCompiled\")\n\n/**\n * Runs the compiled form of `self`, if it has one: returns its value, or\n * `Fail` when it failed (or, with `whole`, did not consume the whole\n * input), in which case the state must be thrown away. `resumable` selects\n * the build that handles partial input.\n */\nconst runCompiled = <I extends Input>(\n  self: Parser.Any,\n  state: State<I>,\n  whole: boolean,\n  resumable = false\n): unknown => {\n  if (state.tracer !== undefined || state.recovered !== undefined) return NotCompiled\n  const step = Registry.stepFor(self, state, resumable)\n  if (step === undefined) return NotCompiled\n  const a = Stack.run(step, state)\n  if (a === Fail || (whole && state.pos < state.end)) return Fail\n  return a\n}\n\n// -----------------------------------------------------------------------------\n// Running\n// -----------------------------------------------------------------------------\n\n/**\n * Options accepted by the runners.\n *\n * @since 0.1.0\n * @category running\n */\nexport interface ParseOptions {\n  /**\n   * Install a tracer for {@link trace}d parsers: `true` uses\n   * {@link consoleTracer}.\n   */\n  readonly trace?: boolean | ((event: TraceEvent) => void) | undefined\n  /**\n   * Where to start parsing (default `0`): in code units for strings, bytes\n   * for byte input and elements for arrays. The result is that of parsing\n   * `input.slice(offset)`, but without copying the input, and every offset\n   * (`parsePartial`'s `Done`, `location`, spans, `ParseError.offset` and its\n   * line and column) is a position in the whole input. This is what an\n   * incremental driver, such as a lexer reading one token at a time from a\n   * buffer, needs: compiled parsers run compiled from any offset.\n   *\n   * Throws a `RangeError` unless it is an integer from `0` to the input's\n   * length.\n   */\n  readonly offset?: number | undefined\n}\n\n/**\n * Options accepted by the runners for parsers that require services.\n *\n * @since 0.1.0\n * @category running\n */\nexport interface ParseOptionsWithContext<R> extends ParseOptions {\n  readonly context: Context.Context<R>\n}\n\nconst makeState = <I extends Input>(\n  input: I | Source<I>,\n  options: (ParseOptions & { readonly context?: Context.Context<any> }) | undefined,\n  partial: boolean\n): State<I> => {\n  const offset = options?.offset\n  const state = new State(input, { partial, context: options?.context, offset })\n  if (offset !== undefined && !(Number.isInteger(offset) && offset >= 0 && offset <= state.end)) {\n    throw new RangeError(`Invalid offset ${offset} for an input of length ${state.end}`)\n  }\n  const t = options?.trace\n  if (t !== undefined && t !== false) state.tracer = t === true ? consoleTracer : t\n  return state\n}\n\nconst toError = <E>(state: State<any>): ParseError.ParseError<E> =>\n  ParseError.fromFailure<E>(state.input, state.reportedFailure(), state.mode, state.encoding)\n\n/** Runs a parser against a complete input, compiled when possible. */\nconst parseComplete = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  input: I | Source<I>,\n  options: (ParseOptions & { readonly context?: Context.Context<any> }) | undefined\n): Result.Result<A, ParseError.ParseError<E>> => {\n  const state = makeState(input, options, false)\n  const a = runCompiled(self, state, true)\n  if (a === NotCompiled) return runComplete(self, state)\n  if (a !== Fail) return Result.succeed(a as A)\n  // Re-run interpreted for the diagnostics\n  return runComplete(self, makeState(input, options, false))\n}\n\nconst runComplete = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  state: State<I>\n): Result.Result<A, ParseError.ParseError<E>> => {\n  const a = Stack.run(self.step, state)\n  if (a === Fail) return Result.fail(toError(state))\n  if (state.pos < state.end) {\n    state.backtrack(\"Eof\", expectedEof)\n    return Result.fail(toError(state))\n  }\n  return Result.succeed(a)\n}\n\n/**\n * Runs a parser against a complete input, requiring the whole input to be\n * consumed (winnow's `Parser::parse`).\n *\n * @example\n * ```ts\n * import { Result } from \"effect\"\n * import { Ascii, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * Parser.parse(Ascii.decInt, \"-42\") // Result.succeed(-42)\n * Result.isFailure(Parser.parse(Ascii.decInt, \"42x\")) // true\n * ```\n *\n * @since 0.1.0\n * @category running\n */\nexport const parse: {\n  <A, E, I extends Input>(\n    self: Parser<A, E, never, I>,\n    input: NoInfer<Source<I>>,\n    options?: ParseOptions\n  ): Result.Result<A, ParseError.ParseError<E>>\n  <A, E, R, I extends Input>(\n    self: Parser<A, E, R, I>,\n    input: NoInfer<Source<I>>,\n    options: ParseOptionsWithContext<R>\n  ): Result.Result<A, ParseError.ParseError<E>>\n} = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  input: I | Source<I>,\n  options?: ParseOptions & { readonly context?: Context.Context<R> }\n): Result.Result<A, ParseError.ParseError<E>> => parseComplete(self, input, options)\n\n/**\n * Like {@link parse}, but throws the `ParseError` on failure.\n *\n * @since 0.1.0\n * @category running\n */\nexport const parseSync: {\n  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): A\n  <A, E, R, I extends Input>(\n    self: Parser<A, E, R, I>,\n    input: NoInfer<Source<I>>,\n    options: ParseOptionsWithContext<R>\n  ): A\n} = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  input: I | Source<I>,\n  options?: ParseOptions & { readonly context?: Context.Context<R> }\n): A => {\n  const result = parseComplete(self, input, options)\n  if (Result.isSuccess(result)) return result.success\n  throw result.failure\n}\n\n/**\n * Runs a parser against the start of an input, returning the remaining\n * input along with the output, nom-style (winnow's `parse_peek`, nom's\n * `IResult`).\n *\n * The parser ended at offset `input.length - remaining.length`, which is\n * how a caller running from an `offset` (see {@link ParseOptions}) finds\n * where to continue.\n *\n * @since 0.1.0\n * @category running\n */\nexport const parsePeek: {\n  <A, E, I extends Input>(\n    self: Parser<A, E, never, I>,\n    input: NoInfer<Source<I>>,\n    options?: ParseOptions\n  ): Result.Result<[remaining: Slice<I>, output: A], ParseError.ParseError<E>>\n  <A, E, R, I extends Input>(\n    self: Parser<A, E, R, I>,\n    input: NoInfer<Source<I>>,\n    options: ParseOptionsWithContext<R>\n  ): Result.Result<[remaining: Slice<I>, output: A], ParseError.ParseError<E>>\n} = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  input: I | Source<I>,\n  options?: ParseOptions & { readonly context?: Context.Context<R> }\n): Result.Result<[remaining: Slice<I>, output: A], ParseError.ParseError<E>> => {\n  let state = makeState(input, options, false)\n  const compiled = runCompiled(self, state, false)\n  if (compiled !== NotCompiled && compiled !== Fail) {\n    return Result.succeed([state.slice(state.pos, state.end), compiled as A])\n  }\n  if (compiled === Fail) state = makeState(input, options, false)\n  const a = Stack.run(self.step, state)\n  if (a === Fail) return Result.fail(toError(state))\n  return Result.succeed([state.slice(state.pos, state.end), a])\n}\n\n/**\n * The outcome of parsing a partial (streaming) input.\n *\n * - `Done`: the parser succeeded, consuming input up to `offset`.\n * - `Incomplete`: more input is needed (`needed` tokens, if known).\n *\n * @since 0.1.0\n * @category running\n */\nexport type PartialResult<A> =\n  | { readonly _tag: \"Done\"; readonly value: A; readonly offset: number }\n  | { readonly _tag: \"Incomplete\"; readonly needed: Option.Option<number> }\n\n/**\n * Runs a parser against a *partial* input, i.e. a chunk of a stream that may\n * be followed by more data (winnow's `Partial`, nom's `streaming` parsers).\n * Token parsers that reach the end of the chunk report `Incomplete` instead\n * of failing or succeeding early.\n *\n * The parser does not have to consume the whole input; the returned\n * `offset` says where it stopped. It is a position in the whole input, so\n * with the `offset` option (see {@link ParseOptions}) it is where the next\n * parse starts.\n *\n * A parser compiled with the `Compiler` module runs compiled, with a build\n * that handles partial input. When it fails or needs more input, it runs again\n * interpreted, so `Incomplete`'s `needed` and every `ParseError` are the\n * interpreter's.\n *\n * @example\n * ```ts\n * import { Ascii, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * Parser.parsePartial(Ascii.digit1, \"123\")\n * // Result.succeed({ _tag: \"Incomplete\", needed: Option.some(1) })\n * Parser.parsePartial(Ascii.digit1, \"123;\")\n * // Result.succeed({ _tag: \"Done\", value: \"123\", offset: 3 })\n * ```\n *\n * @since 0.1.0\n * @category running\n */\nexport const parsePartial: {\n  <A, E, I extends Input>(\n    self: Parser<A, E, never, I>,\n    input: NoInfer<Source<I>>,\n    options?: ParseOptions\n  ): Result.Result<PartialResult<A>, ParseError.ParseError<E>>\n  <A, E, R, I extends Input>(\n    self: Parser<A, E, R, I>,\n    input: NoInfer<Source<I>>,\n    options: ParseOptionsWithContext<R>\n  ): Result.Result<PartialResult<A>, ParseError.ParseError<E>>\n} = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  input: I | Source<I>,\n  options?: ParseOptions & { readonly context?: Context.Context<R> }\n): Result.Result<PartialResult<A>, ParseError.ParseError<E>> => {\n  let state = makeState(input, options, true)\n  const compiled = runCompiled(self, state, false, true)\n  if (compiled !== NotCompiled && compiled !== Fail) {\n    return Result.succeed({ _tag: \"Done\", value: compiled as A, offset: state.pos })\n  }\n  // Re-run interpreted for `needed` and the diagnostics\n  if (compiled === Fail) state = makeState(input, options, true)\n  const a = Stack.run(self.step, state)\n  if (a !== Fail) return Result.succeed({ _tag: \"Done\", value: a, offset: state.pos })\n  if (state.mode === \"Incomplete\") {\n    const needed = state.failure.needed\n    return Result.succeed({ _tag: \"Incomplete\", needed: needed > 0 ? Option.some(needed) : Option.none() })\n  }\n  return Result.fail(toError(state))\n}\n\n/**\n * Runs a parser against a complete input as an `Effect`. Services required\n * by the parser are taken from the Effect's context.\n *\n * @example\n * ```ts\n * import { Effect } from \"effect\"\n * import { Ascii, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * const program = Effect.gen(function*() {\n *   const n = yield* Parser.parseEffect(Ascii.decInt, \"42\")\n *   return n + 1\n * })\n * ```\n *\n * @since 0.1.0\n * @category running\n */\nexport const parseEffect = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  input: NoInfer<Source<I>>,\n  options?: ParseOptions\n): Effect.Effect<A, ParseError.ParseError<E>, R> =>\n  Effect.flatMap(Effect.context<R>(), (context) =>\n    Effect.fromResult(parseComplete(self, input, { ...options, context }))\n  )\n\n/**\n * Runs a parser on a state you own, from `state.pos`, and returns its output\n * or {@link Fail}: like calling `self.step(state)`, but using the parser's\n * compiled form when it has one (see the `Compiler` module). This is the\n * runner for drivers that make many small runs over one buffer, such as a\n * lexer reading one token at a time: keep one `Input.State` and\n * `reset` it (`Input.State.reset`) before each run, and no run allocates a\n * state, a `Result` or a slice.\n *\n * On success the cursor is where the parser stopped. On failure the state\n * holds the interpreter's failure (`mode`, `failure`, and what\n * `reportedFailure()` returns): a compiled run that fails is thrown away and\n * the parser's step runs again from the same position. A partial state\n * (`partial: true`) runs the compiled build that handles partial input, so\n * `Incomplete` is reported as the step would report it. Under a tracer,\n * with recovery on or inside a `Syntax` parse, the step runs interpreted.\n *\n * A driver that only needs to know *that* a parser failed (it tries\n * another, or skips a character) can pass `{ diagnostics: false }` to skip\n * the interpreted re-run; see {@link RunOptions}.\n *\n * Compiled code records no hints or furthest failure when it succeeds, so\n * a later failure on the same state can list fewer expectations than one\n * after interpreted runs would: reset the state between runs (as above) and\n * its errors are the ones {@link parse} reports. Deep nesting fails with an\n * unrecoverable `TooDeep` failure instead of throwing, as in the other\n * runners.\n *\n * @example\n * ```ts\n * import { Ascii, Compiler, Input, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const token = Compiler.jit(Parser.preceded(Ascii.space0, Parser.alt(Ascii.alpha1, Token.oneOf(\"+-\"))))\n *\n * const tokens = (text: string): Array<string> => {\n *   const state = new Input.State(text)\n *   const out: Array<string> = []\n *   while (state.pos < state.end) {\n *     const t = Parser.run(token, state.reset(state.pos))\n *     if (t === Input.Fail) break\n *     out.push(t)\n *   }\n *   return out\n * }\n *\n * tokens(\"a + b\") // [\"a\", \"+\", \"b\"]\n * ```\n *\n * @since 0.2.0\n * @category running\n */\nexport const run = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  state: State<I>,\n  options?: RunOptions\n): A | Fail => Run.runOn(self, self.step, state, options?.diagnostics !== false)\n\n/**\n * Options for {@link run}.\n *\n * @since 0.2.0\n * @category running\n */\nexport interface RunOptions {\n  /**\n   * Whether a failure records the interpreter's diagnostics (default\n   * `true`). With `false`, a compiled run that fails is not run again\n   * interpreted: the state's `mode` (`Backtrack`, `Cut` or `Incomplete`)\n   * is set and the cursor is back where the run started, but `failure`,\n   * hints and the furthest failure are left as they were. For drivers that\n   * try a parser and move on when it fails, without reporting why, this\n   * halves the cost of each failure. Parsers that run interpreted record\n   * their diagnostics either way.\n   */\n  readonly diagnostics?: boolean | undefined\n}\n\n/**\n * The outcome of {@link parseRecoverable}.\n *\n * @since 0.1.0\n * @category running\n */\nexport interface RecoverableResult<A, E> {\n  /** The output, if parsing ultimately succeeded. */\n  readonly value: Option.Option<A>\n  /** Every error encountered: recovered ones, then the fatal one (if any). */\n  readonly errors: ReadonlyArray<ParseError.ParseError<E>>\n}\n\n/**\n * Runs a parser with error recovery enabled (winnow's `Recoverable`\n * stream). Failures handled by {@link resumeAfter} and {@link retryAfter}\n * are collected instead of aborting the parse.\n *\n * @since 0.1.0\n * @category running\n */\nexport const parseRecoverable: {\n  <A, E, I extends Input>(\n    self: Parser<A, E, never, I>,\n    input: NoInfer<Source<I>>,\n    options?: ParseOptions\n  ): RecoverableResult<A, E>\n  <A, E, R, I extends Input>(\n    self: Parser<A, E, R, I>,\n    input: NoInfer<Source<I>>,\n    options: ParseOptionsWithContext<R>\n  ): RecoverableResult<A, E>\n} = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  input: I | Source<I>,\n  options?: ParseOptions & { readonly context?: Context.Context<R> }\n): RecoverableResult<A, E> => {\n  const state = makeState(input, options, false)\n  const recovered: Array<Failure> = []\n  state.recovered = recovered\n  const result = runComplete(self, state)\n  const errors = recovered.map((f) => ParseError.fromFailure<E>(state.input, f, \"Backtrack\", state.encoding))\n  if (Result.isSuccess(result)) return { value: Option.some(result.success), errors }\n  errors.push(result.failure)\n  return { value: Option.none(), errors }\n}\n\n// -----------------------------------------------------------------------------\n// Low-level helpers\n// -----------------------------------------------------------------------------\n\n/**\n * Records a failure kind for use in custom parsers; re-exported for\n * convenience.\n *\n * @since 0.1.0\n * @category models\n */\nexport type { ErrorKind }\n"],"mappings":"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"}