@thomasfosterau/effect-parse 0.1.0 → 0.3.0

package/dist/Parser.js

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