@thomasfosterau/effect-parse 0.4.1 → 0.6.0

package/dist/Parser.js

@@ -2,20 +2,23 @@ import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import { Fail, Failure, State, mergeExpected, mergeFailures, mergeTiedFailures } from "./Input.js";
 import { Key } from "./internal/key.js";
+import { Defer as Defer$1, NodeId, bounds, describedNode } from "./internal/node.js";
 import * as Resume from "./internal/resume.js";
 import * as Registry from "./internal/compiler/registry.js";
+import * as Run from "./internal/run.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 * as Equal from "effect/Equal";
 import { dual } from "effect/Function";
 import { NodeInspectSymbol } from "effect/Inspectable";
+import * as Rec from "effect/Record";
 import { pipeArguments } from "effect/Pipeable";
 import * as ParseError from "./ParseError.js";
 import * as Entries from "./internal/entries.js";
-import * as Run from "./internal/run.js";
 import * as Stack from "./internal/stack.js";
-import { NodeId, bounds } from "./internal/node.js";
+import { tupleStep } from "./internal/tuple.js";
 // src/Parser.ts
 /**
 * The `Parser` data type and its general-purpose combinators.
@@ -166,14 +169,65 @@ const make = (step, name) => new ParserImpl(step, name, void 0);
 * @internal
 */
 const described = (step, name, node) => new ParserImpl(step, name, node);
-const nodeOfParser = (p) => p[NodeId];
+/**
+* Creates a combinator over `parsers` that compiles: `build` makes the
+* combinator's step from the parsers' steps. Write combinators with it
+* rather than with {@link make} when they run other parsers: a `make`
+* parser is opaque to the compilers, so in a compiled grammar it runs
+* interpreted, and so does every parser it runs. Interpreted, `build`
+* receives the parsers' own steps; compiled (see the `Compiler` module), it
+* receives their compiled steps, so the parsers inside compile with the
+* grammar.
+*
+* Each step runs its parser on the state it is given, as `Parser.run` does,
+* and returns the parser's output or `Fail`. The steps must run on the
+* combinator's own state (they are compiled for its input kind): a
+* combinator that runs a parser on another input, as {@link mapParser}
+* does, is written with `make`. `build` may be called more than once (once
+* interpreted, and once for each compiled build), so state its step shares
+* between calls belongs inside `build`.
+*
+* @example
+* ```ts
+* import { Ascii, Input, Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* // One or more `item`s separated by `sep`, returning their count
+* const count = <A, B>(item: Parser.Parser<A>, sep: Parser.Parser<B>) =>
+*   Parser.combinator([item, sep], ([itemStep, sepStep]) => (state) => {
+*     if (itemStep(state) === Input.Fail) return Input.Fail
+*     let n = 1
+*     while (true) {
+*       const start = state.pos
+*       if (sepStep(state) === Input.Fail || itemStep(state) === Input.Fail) {
+*         if (state.mode !== "Backtrack") return Input.Fail
+*         state.rewind(start)
+*         return n
+*       }
+*       n++
+*     }
+*   })
+*
+* Parser.parse(count(Ascii.digit1, Token.literal(",")), "1,22,333") // Result.succeed(3)
+* ```
+*
+* @since 0.5.0
+* @category constructors
+*/
+const combinator = (parsers, build, name) => {
+	const untyped = (steps) => build(steps);
+	return described(untyped(parsers.map((p) => p.step)), name, {
+		_tag: "Combinator",
+		parsers,
+		build: untyped
+	});
+};
 /**
 * 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)));
+const named = /*#__PURE__*/ dual(2, (self, name) => new ParserImpl(self.step, name, describedNode(self)));
 /**
 * A parser that consumes nothing and succeeds with the given value.
 *
@@ -225,6 +279,34 @@ const failBacktrack = {
 	mode: "Backtrack"
 };
 /**
+* A parser that fails (backtracks) with the given user error, reporting it
+* at `offset` rather than where the parser runs. Use it for a check that
+* can only run once a whole construct has parsed but should point at the
+* part at fault: return it from a {@link flatMap} continuation, with an
+* offset taken from {@link location} or {@link withSpan}. Like any failure,
+* one at a later offset is preferred over the failures of other
+* alternatives (the furthest failure wins). The offset is clamped to the
+* input.
+*
+* @example
+* ```ts
+* import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* const tag = (open: string) => Parser.delimited(Token.literal(open), Ascii.alpha1, Token.literal(">"))
+* const element = Parser.seq(tag("<"), Parser.location, tag("</")).pipe(
+*   Parser.flatMap(([start, at, end]) =>
+*     start === end ? Parser.succeed(start) : Parser.failAt(at, `expected </${start}>`)
+*   )
+* )
+* // The error points at the end tag (offset 3), not at the start of the element
+* Parser.parse(element, "<a></b>")
+* ```
+*
+* @since 0.5.0
+* @category constructors
+*/
+const failAt = (offset, error) => described((state) => state.failCause("Backtrack", "Fail", error, offset < 0 ? 0 : offset > state.end ? state.end : offset), "failAt", failBacktrack);
+/**
 * A parser that always fails (backtracks) without a cause. This is winnow's
 * `fail` and nom's `fail()`.
 *
@@ -473,6 +555,50 @@ const tryMap = /*#__PURE__*/ dual(2, (self, f) => {
 	});
 });
 /**
+* Transforms the output of a parser with a function that returns
+* `Input.Fail` to reject it: the allocation-free form of {@link tryMap} and
+* {@link filterMap}, for checks that run on nearly every token. Compiled
+* code compares the result with the sentinel instead of allocating and
+* unwrapping a `Result` or an `Option` on every success.
+*
+* On failure the parser backtracks to where it started. With `orFailWith`,
+* the user error it builds (only on failure) becomes the `cause` of the
+* `ParseError`, as with `tryMap`; without, the failure has no cause, as
+* with `filterMap`.
+*
+* @example
+* ```ts
+* import { Ascii, Input, Parser } from "@thomasfosterau/effect-parse"
+*
+* const byte = Ascii.decUint.pipe(
+*   Parser.mapOrFail(
+*     (n) => (n < 256 ? n : Input.Fail),
+*     (n) => `${n} is not a byte`
+*   )
+* )
+* Parser.parse(byte, "300") // fails with the cause "300 is not a byte"
+* ```
+*
+* @since 0.5.0
+* @category mapping
+*/
+const mapOrFail = /*#__PURE__*/ dual((args) => isParser(args[0]), (self, f, orFailWith) => {
+	const step = self.step;
+	return described((state) => {
+		const start = state.pos;
+		const a = step(state);
+		if (a === Fail) return Fail;
+		const b = f(a);
+		if (b !== Fail) return b;
+		state.rewind(start);
+		return orFailWith === void 0 ? state.backtrack("Verify") : state.failCause("Backtrack", "Verify", orFailWith(a));
+	}, self.name, {
+		_tag: "MapOrFail",
+		self,
+		f
+	});
+});
+/**
 * Like {@link tryMap}, but the function may throw. Thrown values become the
 * `cause` of the error.
 *
@@ -632,6 +758,36 @@ const withSpan = (self) => {
 		self
 	});
 };
+/**
+* Transforms the output of a parser together with the offsets it consumed,
+* `[start, end)`: the allocation-free spelling of
+* `map(withSpan(p), ([a, span]) => f(a, span.start, span.end))`, which
+* builds a tuple and a span object on every success. Compiled code passes
+* the offsets to `f` directly.
+*
+* @example
+* ```ts
+* import { Ascii, Parser } from "@thomasfosterau/effect-parse"
+*
+* const name = Ascii.alpha1.pipe(Parser.mapSpan((text, start, end) => ({ text, start, end })))
+* Parser.parse(name, "abc") // Result.succeed({ text: "abc", start: 0, end: 3 })
+* ```
+*
+* @since 0.5.0
+* @category consumed input
+*/
+const mapSpan = /*#__PURE__*/ dual(2, (self, f) => {
+	const step = self.step;
+	return described((state) => {
+		const start = state.pos;
+		const a = step(state);
+		return a === Fail ? Fail : f(a, start, state.pos);
+	}, self.name, {
+		_tag: "MapSpan",
+		self,
+		f
+	});
+});
 const changeMode = (self, from, to) => {
 	const step = self.step;
 	return described((state) => {
@@ -766,6 +922,181 @@ const expected = /*#__PURE__*/ dual(2, (self, description) => {
 	});
 });
 /**
+* Runs a parser without letting it add to the expectations of later errors
+* (chumsky's `quiet`). Use it on skippers, such as whitespace and comments,
+* that may appear between any two tokens: they stop by failing, and without
+* `quiet` what they would have accepted (`" "`, `"(:"`, ...) is listed in
+* every error raised after them.
+*
+* When the parser succeeds, the hints and the furthest failure it recorded
+* are forgotten, as after a lookahead that succeeded. When it fails
+* recoverably without consuming input, its failure expects nothing, so an
+* enclosing `alt` or `opt` reports only the other alternatives. A failure
+* after consuming input (an unterminated comment) or an unrecoverable one
+* is kept as it is. `Parser.expected` cannot do this: it relabels a failure,
+* and a skipper that matches zero or more times never fails.
+*
+* @example
+* ```ts
+* import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* const comment = Parser.delimited(Token.literal("(:"), Token.takeTill(":"), Token.literal(":)"))
+* const skip = Parser.quiet(Parser.repeat(Parser.alt(Ascii.multispace1, comment)))
+* const number = Parser.preceded(skip, Ascii.digit1)
+* // Fails expecting only a digit: without `quiet`, also whitespace and "(:"
+* Parser.parse(number, " (: one :) x")
+* ```
+*
+* @since 0.5.0
+* @category error management
+*/
+const quiet = (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.hintOffset = hintOffset;
+			state.hintExpected = hintExpected;
+			state.deepest = deepest;
+			return a;
+		}
+		if (state.mode === "Backtrack" && state.failure.offset === start) {
+			const f = state.failure;
+			const expected = hintOffset === start ? hintExpected : [];
+			state.hintOffset = hintOffset;
+			state.hintExpected = hintExpected;
+			state.deepest = deepest;
+			state.failure = new Failure(f.offset, f.kind, expected, f.context, f.hasCause, f.cause, f.message, f.needed);
+		}
+		return a;
+	}, self.name, {
+		_tag: "Quiet",
+		self
+	});
+};
+/**
+* What a fast path (see {@link withFastPath}) returns to leave the input at
+* the current offset to its grammar.
+*
+* @since 0.5.0
+* @category fast paths
+*/
+const Defer = Defer$1;
+/**
+* Puts a hand-written fast path in front of a grammar, which stays the
+* specification: `fast` runs on the state, at the offset where the grammar
+* would, and either returns the value the grammar would return, with
+* `state.pos` where the grammar would stop, or returns {@link Defer}, and
+* the grammar runs from that offset instead. Use it where a scanner written
+* by hand (`indexOf`, a lookup table, interned names) beats compiled code on
+* the tokens that dominate an input, and let the grammar handle everything
+* else.
+*
+* The fast path runs in compiled code only (see the `Compiler` module).
+* Interpreted runs, and so every error, every `Syntax` tree and every trace,
+* come from the grammar alone, so they are exactly the grammar's. It must
+* defer wherever it would not return exactly what the grammar returns, and
+* on partial input wherever the grammar might report `Incomplete`; check it
+* against the grammar with {@link verifyFastPath}.
+*
+* @example
+* ```ts
+* import { Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* const text = Token.takeTill("<", { min: 1 })
+* // The same run, found with `indexOf`; anything else (an empty run, the end of a partial input) defers
+* const fastText = Compiler.jit(
+*   Parser.withFastPath(text, (state) => {
+*     const end = state.input.indexOf("<", state.pos)
+*     if (end <= state.pos || end > state.end) return Parser.Defer
+*     const value = state.input.slice(state.pos, end)
+*     state.pos = end
+*     return value
+*   })
+* )
+* ```
+*
+* @since 0.5.0
+* @category fast paths
+*/
+const withFastPath = /*#__PURE__*/ dual(2, (grammar, fast) => described(grammar.step, grammar.name, {
+	_tag: "FastPath",
+	self: grammar,
+	fast
+}));
+/**
+* Checks a fast path against its grammar (see {@link withFastPath}): on
+* every input, at every offset, on complete and on partial input, wherever
+* `fast` returns a value, the grammar (run interpreted) must return an
+* equal value (by `Equal.equals`, or `options.equivalence`) and stop at the
+* same offset. Returns every place where it doesn't, so a test asserts that
+* the result is empty; generated inputs, mutated and truncated, find the
+* most. Grammars that use services are not supported.
+*
+* @example
+* ```ts
+* import { Input, Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* const text = Token.takeTill("<", { min: 1 })
+* const fast = (state: Input.State<string>) => {
+*   const end = state.input.indexOf("<", state.pos)
+*   if (end <= state.pos || end > state.end) return Parser.Defer
+*   const value = state.input.slice(state.pos, end)
+*   state.pos = end
+*   return value
+* }
+* Parser.verifyFastPath(text, fast, ["a<b", "<", "abc"]) // []
+* ```
+*
+* @since 0.5.0
+* @category fast paths
+*/
+const verifyFastPath = (grammar, fast, inputs, options) => {
+	const equivalence = options?.equivalence ?? Equal.equals;
+	const mismatches = [];
+	for (const input of inputs) {
+		const length = new State(input).end;
+		for (let offset = 0; offset <= length; offset++) for (const partial of [false, true]) {
+			const mismatch = checkFastPath(grammar, fast, input, offset, partial, equivalence);
+			if (mismatch !== void 0) mismatches.push(mismatch);
+		}
+	}
+	return mismatches;
+};
+/** Where `fast` disagrees with `grammar` at `offset`, if it does (see {@link verifyFastPath}). */
+const checkFastPath = (grammar, fast, input, offset, partial, equivalence) => {
+	const state = new State(input, {
+		offset,
+		partial
+	});
+	const a = fast(state);
+	if (a === Defer) return void 0;
+	const expected = new State(input, {
+		offset,
+		partial
+	});
+	const b = Stack.run(grammar.step, expected);
+	if (b !== Fail && expected.pos === state.pos && equivalence(a, b)) return void 0;
+	const grammarOutcome = b === Fail ? { failed: expected.mode } : {
+		value: b,
+		end: expected.pos
+	};
+	return {
+		input,
+		offset,
+		partial,
+		fast: {
+			value: a,
+			end: state.pos
+		},
+		grammar: grammarOutcome
+	};
+};
+/**
 * Transforms the user error (cause) of a parser's failures.
 *
 * @since 0.1.0
@@ -952,20 +1283,50 @@ const allConsuming = (self) => terminated(self, eof);
 * @category sequencing
 */
 const seq = (...parsers) => {
+	const step = tupleStep(parsers.map((p) => p.step));
+	return described(step, "seq", {
+		_tag: "Seq",
+		parsers,
+		output: "tuple"
+	});
+};
+/**
+* Runs parsers in sequence and combines their outputs with `f`, which
+* receives one argument per parser: the allocation-free spelling of
+* `map(seq(...parsers), ([a, b, ...]) => f(a, b, ...))`, which builds a
+* tuple on every success. Compiled code calls `f` with the values directly.
+* {@link zipWith} is the two-parser, pipeable form.
+*
+* @example
+* ```ts
+* import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* const point = Parser.seqWith(
+*   [Ascii.decInt, Token.literal(","), Ascii.decInt],
+*   (x, _, y) => ({ x, y })
+* )
+* Parser.parse(point, "3,-4") // Result.succeed({ x: 3, y: -4 })
+* ```
+*
+* @since 0.5.0
+* @category sequencing
+*/
+const seqWith = (parsers, f) => {
 	const steps = parsers.map((p) => p.step);
 	const n = steps.length;
+	const g = f;
 	return described((state) => {
-		const out = new Array(n);
+		const values = new Array(n);
 		for (let i = 0; i < n; i++) {
 			const a = steps[i](state);
 			if (a === Fail) return Fail;
-			out[i] = a;
+			values[i] = a;
 		}
-		return out;
-	}, "seq", {
-		_tag: "Seq",
+		return g(...values);
+	}, "seqWith", {
+		_tag: "SeqWith",
 		parsers,
-		output: "tuple"
+		f
 	});
 };
 /**
@@ -977,7 +1338,7 @@ const seq = (...parsers) => {
 * @category sequencing
 */
 const struct = (fields) => {
-	const keys = Object.keys(fields);
+	const keys = Rec.keys(fields);
 	const steps = keys.map((k) => fields[k].step);
 	const n = keys.length;
 	return described((state) => {
@@ -1336,9 +1697,8 @@ const dispatch = (selector, cases, otherwise) => {
 * @category choice
 */
 const permutation = (...parsers) => {
-	const steps = parsers.map((p) => p.step);
-	const n = steps.length;
-	return make((state) => {
+	const n = parsers.length;
+	return combinator(parsers, (steps) => (state) => {
 		const ties = new TiedFailures();
 		const done = new Array(n).fill(false);
 		const out = new Array(n);
@@ -1367,11 +1727,7 @@ const permutation = (...parsers) => {
 	}, "permutation");
 };
 const normalizeRange = (range) => {
-	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})`);
+	const { max, min } = bounds(range);
 	return [min, max];
 };
 const assertConsumes = (state, name) => state.failMessage("Cut", "Assert", `\`${name}\` parsers must always consume`);
@@ -1383,7 +1739,6 @@ const saveFold = (state, key, entry, acc, pos) => Resume.save(state, key, entry,
 const foldImpl = (self, range, init, f, name, node, cond) => {
 	const [min, max] = normalizeRange(range);
 	const step = self.step;
-	const checkLoop = max === Infinity;
 	const key = new Key();
 	return described((state) => {
 		const entry = state.pos;
@@ -1413,7 +1768,7 @@ const foldImpl = (self, range, init, f, name, node, cond) => {
 				recover(state, start);
 				return Resume.done(state, key, entry, resumed !== void 0, acc);
 			}
-			if (checkLoop && state.pos === start) return assertConsumes(state, name);
+			if (state.pos === start) return assertConsumes(state, name);
 			acc = f(acc, a);
 		}
 		return Resume.done(state, key, entry, resumed !== void 0, acc);
@@ -1435,9 +1790,9 @@ const foldImpl = (self, range, init, f, name, node, cond) => {
 * 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.
+* A parser that succeeds without consuming input fails the repetition with
+* an unrecoverable `Assert` failure, whatever the range (winnow checks only
+* unbounded ones): a bound can come from the input (`Binary.lengthRepeat`).
 *
 * @example
 * ```ts
@@ -1545,7 +1900,6 @@ 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 = new Key();
 	return described((state) => {
 		const entry = state.pos;
@@ -1581,7 +1935,7 @@ const separated = /*#__PURE__*/ dual(isTwoParserArgs, (self, separator, range) =
 				recover(state, start);
 				return Resume.done(state, key, entry, resumed !== void 0, acc);
 			}
-			if (checkLoop && state.pos === start) return assertConsumes(state, "separated");
+			if (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, {
@@ -1929,9 +2283,9 @@ const NotCompiled = /*#__PURE__*/ Symbol("NotCompiled");
 */
 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);
+	const compiled = Registry.compiled(self, state.inputKind, resumable);
+	if (compiled?.step === void 0) return NotCompiled;
+	const a = Run.runCompiled(compiled.step, compiled.guarded, state);
 	if (a === Fail || whole && state.pos < state.end) return Fail;
 	return a;
 };
@@ -2051,6 +2405,7 @@ const parsePartial = (self, input, options) => {
 		value: compiled,
 		offset: state.pos
 	});
+	if (compiled === Fail && state.mode === "Incomplete") return Result.succeed(incompleteOf(state));
 	if (compiled === Fail) state = makeState(input, options, true);
 	const a = Stack.run(self.step, state);
 	if (a !== Fail) return Result.succeed({
@@ -2058,15 +2413,17 @@ const parsePartial = (self, input, options) => {
 		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()
-		});
-	}
+	if (state.mode === "Incomplete") return Result.succeed(incompleteOf(state));
 	return Result.fail(toError(state));
 };
+/** The `Incomplete` result of a state whose parse ran out of partial input. */
+const incompleteOf = (state) => {
+	const needed = state.failure.needed;
+	return {
+		_tag: "Incomplete",
+		needed: needed > 0 ? Option.some(needed) : Option.none()
+	};
+};
 /**
 * Runs a parser against a complete input as an `Effect`. Services required
 * by the parser are taken from the Effect's context.
@@ -2165,6 +2522,6 @@ const parseRecoverable = (self, input, options) => {
 		errors
 	};
 };
-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 };
+export { Defer, Do, TypeId, allConsuming, alt, as, asSome, asVoid, backtrack, bind, bindTo, combinator, complete, cond, consoleTracer, context, cut, delimited, described, dispatch, empty, eof, expected, fail, failAt, failMessage, filter, filterMap, filterOrFail, flatMap, fold, fromEntries, gen, isParser, let_ as let, location, make, map, mapError, mapOrFail, mapParser, mapSpan, named, not, opt, optional, orElse, orElseSucceed, orFail, parse, parseEffect, parsePartial, parsePeek, parseRecoverable, parseSync, peek, permutation, preceded, provide, provideService, quiet, reject, repeat, repeatTill, resumeAfter, retryAfter, run, separated, separatedFoldl1, separatedFoldr1, separatedPair, seq, seqWith, service, span, struct, succeed, suspend, sync, taken, tap, terminated, todo, trace, tryMap, tryMapUnknown, verifyFastPath, void_ as void, void_, withFastPath, withSpan, withTaken, zip, zipLeft, zipRight, zipWith };
 
 //# sourceMappingURL=Parser.js.map