@thomasfosterau/effect-parse 0.1.0 → 0.3.0

package/dist/ParserStream.js

@@ -1,270 +1,282 @@
+import * as Predicate from "effect/Predicate";
+import { Fail, Failure, State, fromSource } from "./Input.js";
+import * as Registry from "./internal/compiler/registry.js";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
-import * as Stream from "effect/Stream";
-import { Fail, Failure, fromSource, State } from "./Input.js";
 import * as ParseError from "./ParseError.js";
-import * as Compiler from "./internal/compiler/registry.js";
+import * as Run from "./internal/run.js";
+import * as Stack from "./internal/stack.js";
+import * as Stream from "effect/Stream";
+//#region src/ParserStream.ts
+/**
+* Running parsers over Effect `Stream`s of input chunks.
+*
+* This is where nom's and winnow's *partial* (streaming) parsing meets
+* Effect: chunks are buffered and the parser runs in partial mode, so a
+* value split across chunk boundaries is reported as `Incomplete` and
+* retried once more data arrives. When the stream ends, the leftover input
+* is parsed in complete mode.
+*
+* @example
+* ```ts
+* import { Effect, Stream } from "effect"
+* import { Ascii, Parser, ParserStream, Token } from "@thomasfosterau/effect-parse"
+*
+* const line = Parser.terminated(Ascii.decInt, Token.literal("\n"))
+*
+* const program = Stream.make("1\n2", "3\n", "4\n").pipe(
+*   ParserStream.parseMany(line),
+*   Stream.runCollect
+* )
+* // Effect.runSync(program) => [1, 23, 4]
+* ```
+*
+* @since 0.1.0
+*/
 const concat = (a, b) => {
-    if (typeof a === "string")
-        return (a + b);
-    if (a instanceof Uint8Array) {
-        if (a.length === 0)
-            return b;
-        const out = new Uint8Array(a.length + b.length);
-        out.set(a);
-        out.set(b, a.length);
-        return out;
-    }
-    return [...a, ...b];
+	if (Predicate.isString(a)) return a + b;
+	if (a instanceof Uint8Array) {
+		if (a.length === 0) return b;
+		const out = new Uint8Array(a.length + b.length);
+		out.set(a);
+		out.set(b, a.length);
+		return out;
+	}
+	return [...a, ...b];
 };
-const sliceFrom = (input, offset) => (typeof input === "string" ? input.slice(offset) : input.slice(offset));
-const noProgress = (input, offset) => ParseError.fromFailure(input, new Failure(offset, "Assert", [], [], false, undefined, "`parseMany` parsers must always consume", 0), "Cut");
+const sliceFrom = (input, offset) => Predicate.isString(input) ? input.slice(offset) : input.slice(offset);
+const noProgress = (input, offset) => ParseError.fromFailure(input, new Failure(offset, "Assert", [], [], false, void 0, "`parseMany` parsers must always consume", 0), "Cut");
 /**
- * Transforms a stream of input chunks into a stream of parsed values by
- * applying `parser` repeatedly. Each application must consume input.
- *
- * Services required by the parser are taken from the stream's context.
- * Error offsets are relative to the internal buffer of unconsumed input,
- * which is also the `input` of the reported `ParseError`.
- *
- * @since 0.1.0
- * @category combinators
- */
-export const parseMany = dual((args) => Stream.isStream(args[0]), (self, parser, options) => Stream.suspend(() => {
-    const step = parser.step;
-    let buffer = options?.empty === undefined ? undefined : fromSource(options.empty);
-    const drain = (context, partial) => {
-        const out = [];
-        if (buffer === undefined)
-            return Effect.succeed(out);
-        const input = buffer;
-        let offset = 0;
-        while (offset < input.length) {
-            const state = new State(input, { partial, context, offset });
-            const a = step(state);
-            if (a === Fail) {
-                if (partial && state.mode === "Incomplete")
-                    break;
-                return Effect.fail(ParseError.fromFailure(input, state.reportedFailure(), state.mode, state.encoding));
-            }
-            if (state.pos === offset)
-                return Effect.fail(noProgress(input, offset));
-            out.push(a);
-            offset = state.pos;
-        }
-        buffer = sliceFrom(input, offset);
-        return Effect.succeed(out);
-    };
-    const feed = (source) => Effect.flatMap(Effect.context(), (context) => Effect.suspend(() => {
-        const chunk = fromSource(source);
-        buffer = buffer === undefined ? chunk : concat(buffer, chunk);
-        return drain(context, true);
-    }));
-    const finish = Effect.flatMap(Effect.context(), (context) => Effect.suspend(() => drain(context, false)));
-    return self.pipe(Stream.mapEffect(feed), Stream.flattenIterable, Stream.concat(Stream.unwrap(Effect.map(finish, Stream.fromIterable))));
+* Transforms a stream of input chunks into a stream of parsed values by
+* applying `parser` repeatedly. Each application must consume input.
+*
+* Services required by the parser are taken from the stream's context.
+* Error offsets are relative to the internal buffer of unconsumed input,
+* which is also the `input` of the reported `ParseError`.
+*
+* A parser compiled with the `Compiler` module runs compiled, with the
+* build that handles partial input (see `Parser.run`); a value that fails
+* or needs more input is parsed again interpreted, so errors and
+* `Incomplete` are the interpreter's.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const parseMany = /*#__PURE__*/ dual((args) => Stream.isStream(args[0]), (self, parser, options) => Stream.suspend(() => {
+	const step = parser.step;
+	let buffer = options?.empty === void 0 ? void 0 : fromSource(options.empty);
+	const drain = (context, partial) => {
+		const out = [];
+		if (buffer === void 0) return Effect.succeed(out);
+		const input = buffer;
+		const state = new State(input);
+		let offset = 0;
+		while (offset < input.length) {
+			state.reset(offset, {
+				partial,
+				context
+			});
+			const a = Run.runOn(parser, step, state);
+			if (a === Fail) {
+				if (partial && state.mode === "Incomplete") break;
+				return Effect.fail(ParseError.fromFailure(input, state.reportedFailure(), state.mode, state.encoding));
+			}
+			if (state.pos === offset) return Effect.fail(noProgress(input, offset));
+			out.push(a);
+			offset = state.pos;
+		}
+		buffer = sliceFrom(input, offset);
+		return Effect.succeed(out);
+	};
+	const feed = (source) => Effect.flatMap(Effect.context(), (context) => Effect.suspend(() => {
+		const chunk = fromSource(source);
+		buffer = buffer === void 0 ? chunk : concat(buffer, chunk);
+		return drain(context, true);
+	}));
+	const finish = Effect.flatMap(Effect.context(), (context) => Effect.suspend(() => drain(context, false)));
+	return self.pipe(Stream.mapEffect(feed), Stream.flattenIterable, Stream.concat(Stream.unwrap(Effect.map(finish, Stream.fromIterable))));
 }));
 /**
- * Parses a stream of chunks incrementally, as one input. Chunks are parsed
- * as they arrive, in partial mode; when the parser runs out of input, its
- * repetitions keep checkpoints (see `internal/resume.ts`), so the next
- * attempt carries on from where the last one stopped instead of starting
- * over.
- */
-class Incremental {
-    parser;
-    context;
-    kind;
-    text = "";
-    bytes = new Uint8Array(0);
-    items = [];
-    length = 0;
-    resume = new Map();
-    /** The input length at the last attempt, and where that attempt ran out of input. */
-    attempted = 0;
-    restart = 0;
-    /** Set once an attempt settles: a success (with its end offset) or a definite failure. */
-    settled;
-    constructor(parser, context, empty) {
-        this.parser = parser;
-        this.context = context;
-        if (empty !== undefined)
-            this.append(empty);
-    }
-    append(chunk) {
-        if (typeof chunk === "string") {
-            this.kind ??= 0;
-            this.text += chunk;
-            this.length += chunk.length;
-        }
-        else if (chunk instanceof Uint8Array) {
-            this.kind ??= 1;
-            const needed = this.length + chunk.length;
-            if (needed > this.bytes.length) {
-                // Grow geometrically, so appending costs amortized constant time per byte
-                const grown = new Uint8Array(Math.max(needed, this.bytes.length * 2, 4096));
-                grown.set(this.bytes.subarray(0, this.length));
-                this.bytes = grown;
-            }
-            this.bytes.set(chunk, this.length);
-            this.length = needed;
-        }
-        else {
-            this.kind ??= 2;
-            for (let i = 0; i < chunk.length; i++)
-                this.items.push(chunk[i]);
-            this.length = this.items.length;
-        }
-    }
-    input() {
-        switch (this.kind) {
-            case 1:
-                return this.bytes.subarray(0, this.length);
-            case 2:
-                // Items are only appended between attempts, after each state has read its `end`
-                return this.items;
-            default:
-                return this.text;
-        }
-    }
-    push(chunk) {
-        if (chunk.length === 0)
-            return;
-        this.append(chunk);
-        if (this.settled !== undefined)
-            return;
-        // An attempt re-reads what the last one could not finish, from `restart`;
-        // waiting until at least half as much new input has arrived keeps the
-        // total work linear in the input. Strings are also copied when they are
-        // flattened, so they wait for a fraction of the whole input too.
-        const added = this.length - this.attempted;
-        if (added < (this.attempted - this.restart) / 2)
-            return;
-        if (this.kind === 0 && added < this.attempted / 8)
-            return;
-        this.attempt();
-    }
-    /** The step attempts run: the parser's resumable compiled code if it was compiled, else the interpreter. */
-    step(state) {
-        return (Compiler.stepFor(this.parser, state, true) ?? this.parser.step)(state);
-    }
-    attempt() {
-        const state = new State(this.input(), { partial: true, context: this.context });
-        state.resume = this.resume;
-        const a = this.step(state);
-        this.attempted = this.length;
-        if (a !== Fail) {
-            this.settled = { value: a, pos: state.pos };
-        }
-        else if (state.mode === "Incomplete") {
-            this.restart = state.failure.offset;
-        }
-        else {
-            this.settled = "failed";
-        }
-    }
-    finish() {
-        const settled = this.settled;
-        if (settled !== undefined && settled !== "failed") {
-            if (settled.pos === this.length)
-                return Effect.succeed(settled.value);
-        }
-        else if (settled === undefined) {
-            // The last attempt, in complete mode, resumes from the checkpoints too
-            const state = new State(this.input(), { context: this.context });
-            state.resume = this.resume;
-            const a = this.step(state);
-            if (a !== Fail && state.pos === state.end)
-                return Effect.succeed(a);
-        }
-        // The error comes from an ordinary parse of the whole input, so it is the
-        // same as if the input had been parsed in one go
-        const all = this.input();
-        const state = new State(all, { context: this.context });
-        const a = this.parser.step(state);
-        if (a !== Fail && state.pos === state.end)
-            return Effect.succeed(a);
-        if (a !== Fail)
-            state.backtrack("Eof", ["end of input"]);
-        return Effect.fail(ParseError.fromFailure(all, state.reportedFailure(), state.mode, state.encoding));
-    }
-}
+* Parses a stream of chunks incrementally, as one input. Chunks are parsed
+* as they arrive, in partial mode; when the parser runs out of input, its
+* repetitions keep checkpoints (see `internal/resume.ts`), so the next
+* attempt carries on from where the last one stopped instead of starting
+* over.
+*/
+var Incremental = class {
+	parser;
+	context;
+	kind;
+	text = "";
+	bytes = /* @__PURE__ */ new Uint8Array(0);
+	items = [];
+	length = 0;
+	resume = /* @__PURE__ */ new Map();
+	/** The input length at the last attempt, and where that attempt ran out of input. */
+	attempted = 0;
+	restart = 0;
+	/** Set once an attempt settles: a success (with its end offset) or a definite failure. */
+	settled;
+	constructor(parser, context, empty) {
+		this.parser = parser;
+		this.context = context;
+		if (empty !== void 0) this.append(empty);
+	}
+	append(chunk) {
+		if (Predicate.isString(chunk)) {
+			this.kind ??= 0;
+			this.text += chunk;
+			this.length += chunk.length;
+		} else if (chunk instanceof Uint8Array) {
+			this.kind ??= 1;
+			const needed = this.length + chunk.length;
+			if (needed > this.bytes.length) {
+				const grown = new Uint8Array(Math.max(needed, this.bytes.length * 2, 4096));
+				grown.set(this.bytes.subarray(0, this.length));
+				this.bytes = grown;
+			}
+			this.bytes.set(chunk, this.length);
+			this.length = needed;
+		} else {
+			this.kind ??= 2;
+			for (let i = 0; i < chunk.length; i++) this.items.push(chunk[i]);
+			this.length = this.items.length;
+		}
+	}
+	input() {
+		switch (this.kind) {
+			case 1: return this.bytes.subarray(0, this.length);
+			case 2: return this.items;
+			default: return this.text;
+		}
+	}
+	push(chunk) {
+		if (chunk.length === 0) return;
+		this.append(chunk);
+		if (this.settled !== void 0) return;
+		const added = this.length - this.attempted;
+		if (added < (this.attempted - this.restart) / 2) return;
+		if (this.kind === 0 && added < this.attempted / 8) return;
+		this.attempt();
+	}
+	/** The step attempts run: the parser's resumable compiled code if it was compiled, else the interpreter. */
+	step(state) {
+		return Stack.run(Registry.stepFor(this.parser, state, true) ?? this.parser.step, state);
+	}
+	attempt() {
+		const state = new State(this.input(), {
+			partial: true,
+			context: this.context
+		});
+		state.resume = this.resume;
+		const a = this.step(state);
+		this.attempted = this.length;
+		if (a !== Fail) this.settled = {
+			value: a,
+			pos: state.pos
+		};
+		else if (state.mode === "Incomplete") this.restart = state.failure.offset;
+		else this.settled = "failed";
+	}
+	finish() {
+		const settled = this.settled;
+		if (settled !== void 0 && settled !== "failed") {
+			if (settled.pos === this.length) return Effect.succeed(settled.value);
+		} else if (settled === void 0) {
+			const state = new State(this.input(), { context: this.context });
+			state.resume = this.resume;
+			const a = this.step(state);
+			if (a !== Fail && state.pos === state.end) return Effect.succeed(a);
+		}
+		const all = this.input();
+		const state = new State(all, { context: this.context });
+		const a = Stack.run(this.parser.step, state);
+		if (a !== Fail && state.pos === state.end) return Effect.succeed(a);
+		if (a !== Fail) state.backtrack("Eof", ["end of input"]);
+		return Effect.fail(ParseError.fromFailure(all, state.reportedFailure(), state.mode, state.encoding));
+	}
+};
 /**
- * Parses an entire stream of chunks as a single complete input.
- *
- * Parsing does not wait for the stream to end: each chunk is parsed as it
- * arrives, in partial mode, and when the parser runs out of input its
- * repetitions (`repeat`, `separated`, `fold`, `escaped`, ...) remember how
- * far they got, so that the next attempt resumes there rather than starting
- * over. A large document, such as the body of a `fetch` response, is
- * therefore parsed while it downloads, and is ready soon after its last
- * byte. Use {@link parseReadable} or {@link parseResponse} for web streams.
- *
- * The result and any `ParseError` are those of parsing the whole input at
- * once: errors are reported once the stream has ended, by an ordinary
- * interpreted parse of the whole input. A parser compiled with
- * `Parser.compile` streams compiled too (with a build that handles partial
- * input), which is several times faster. As with compiled parsers,
- * callbacks should be pure: the elements parsed before a checkpoint are
- * not parsed again, and on failure everything is parsed again.
- *
- * @since 0.1.0
- * @category combinators
- */
-export const parseAll = dual((args) => Stream.isStream(args[0]), (self, parser, options) => Effect.flatMap(Effect.context(), (context) => Effect.suspend(() => {
-    const empty = options?.empty === undefined ? undefined : fromSource(options.empty);
-    const incremental = new Incremental(parser, context, empty);
-    return Effect.flatMap(Stream.runForEach(self, (chunk) => Effect.sync(() => incremental.push(fromSource(chunk)))), () => Effect.suspend(() => incremental.finish()));
+* Parses an entire stream of chunks as a single complete input.
+*
+* Parsing does not wait for the stream to end: each chunk is parsed as it
+* arrives, in partial mode, and when the parser runs out of input its
+* repetitions (`repeat`, `separated`, `fold`, `escaped`, ...) remember how
+* far they got, so that the next attempt resumes there rather than starting
+* over. A large document, such as the body of a `fetch` response, is
+* therefore parsed while it downloads, and is ready soon after its last
+* byte. Use {@link parseReadable} or {@link parseResponse} for web streams.
+*
+* The result and any `ParseError` are those of parsing the whole input at
+* once: errors are reported once the stream has ended, by an ordinary
+* interpreted parse of the whole input. A parser compiled with the
+* `Compiler` module streams compiled too (with a build that handles partial
+* input), which is several times faster. As with compiled parsers,
+* callbacks should be pure: the elements parsed before a checkpoint are
+* not parsed again, and on failure everything is parsed again.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const parseAll = /*#__PURE__*/ dual((args) => Stream.isStream(args[0]), (self, parser, options) => Effect.flatMap(Effect.context(), (context) => Effect.suspend(() => {
+	const incremental = new Incremental(parser, context, options?.empty === void 0 ? void 0 : fromSource(options.empty));
+	return Effect.flatMap(Stream.runForEach(self, (chunk) => Effect.sync(() => incremental.push(fromSource(chunk)))), () => Effect.suspend(() => incremental.finish()));
 })));
 /**
- * An error reading a `ReadableStream` given to {@link parseReadable} or
- * {@link parseResponse}.
- *
- * @since 0.1.0
- * @category errors
- */
-export class ReadError extends Data.TaggedError("ReadError") {
-}
+* An error reading a `ReadableStream` given to {@link parseReadable} or
+* {@link parseResponse}.
+*
+* @since 0.1.0
+* @category errors
+*/
+var ReadError = class extends (/*#__PURE__*/ Data.TaggedError("ReadError")) {};
 /**
- * Parses a web `ReadableStream` of bytes, such as the body of a `fetch`
- * response, incrementally (see {@link parseAll}): the bytes are parsed as
- * they arrive, without waiting for the end of the stream or decoding them
- * first. Use a byte parser, e.g. one built from `Text.utf8`.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import { Parser, ParserStream, Text } from "@thomasfosterau/effect-parse"
- *
- * const csvLine = Parser.separated(Text.utf8.takeTill(",\n"), Text.utf8.literal(","))
- * const csv = Parser.separated(csvLine, Text.utf8.literal("\n"))
- *
- * const response = await fetch("https://example.com/data.csv")
- * const rows = await Effect.runPromise(ParserStream.parseReadable(response.body!, csv))
- * ```
- *
- * @since 0.1.0
- * @category combinators
- */
-export const parseReadable = dual(2, (self, parser) => parseAll(Stream.fromReadableStream({ evaluate: () => self, onError: (cause) => new ReadError({ cause }) }), parser, { empty: new Uint8Array(0) }));
+* Parses a web `ReadableStream` of bytes, such as the body of a `fetch`
+* response, incrementally (see {@link parseAll}): the bytes are parsed as
+* they arrive, without waiting for the end of the stream or decoding them
+* first. Use a byte parser, e.g. one built from `Text.utf8`.
+*
+* @example
+* ```ts
+* import { Effect } from "effect"
+* import { Parser, ParserStream, Text } from "@thomasfosterau/effect-parse"
+*
+* const csvLine = Parser.separated(Text.utf8.takeTill(",\n"), Text.utf8.literal(","))
+* const csv = Parser.separated(csvLine, Text.utf8.literal("\n"))
+*
+* const response = await fetch("https://example.com/data.csv")
+* const rows = await Effect.runPromise(ParserStream.parseReadable(response.body!, csv))
+* ```
+*
+* @since 0.1.0
+* @category combinators
+*/
+const parseReadable = /*#__PURE__*/ dual(2, (self, parser) => parseAll(Stream.fromReadableStream({
+	evaluate: () => self,
+	onError: (cause) => new ReadError({ cause })
+}), parser, { empty: /* @__PURE__ */ new Uint8Array(0) }));
 /**
- * Parses the body of a `fetch` `Response` incrementally, as it downloads
- * (see {@link parseReadable}). A response without a body is parsed as empty
- * input. The status is not checked.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import { Parser, ParserStream, Text } from "@thomasfosterau/effect-parse"
- *
- * const lines = Parser.separated(Text.utf8.tillLineEnding, Text.utf8.lineEnding)
- *
- * const response = await fetch("https://example.com/log.txt")
- * const value = await Effect.runPromise(ParserStream.parseResponse(response, lines))
- * ```
- *
- * @since 0.1.0
- * @category combinators
- */
-export const parseResponse = dual(2, (self, parser) => parseReadable(self.body ?? new ReadableStream({ start: (c) => c.close() }), parser));
+* Parses the body of a `fetch` `Response` incrementally, as it downloads
+* (see {@link parseReadable}). A response without a body is parsed as empty
+* input. The status is not checked.
+*
+* @example
+* ```ts
+* import { Effect } from "effect"
+* import { Parser, ParserStream, Text } from "@thomasfosterau/effect-parse"
+*
+* const lines = Parser.separated(Text.utf8.tillLineEnding, Text.utf8.lineEnding)
+*
+* const response = await fetch("https://example.com/log.txt")
+* const value = await Effect.runPromise(ParserStream.parseResponse(response, lines))
+* ```
+*
+* @since 0.1.0
+* @category combinators
+*/
+const parseResponse = /*#__PURE__*/ dual(2, (self, parser) => parseReadable(self.body ?? new ReadableStream({ start: (c) => c.close() }), parser));
+//#endregion
+export { ReadError, parseAll, parseMany, parseReadable, parseResponse };
+
 //# sourceMappingURL=ParserStream.js.map

package/dist/ParserStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"ParserStream.js","sourceRoot":"","sources":["../src/ParserStream.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ParserStream.js","names":[],"sources":["../src/ParserStream.ts"],"sourcesContent":["/**\n * Running parsers over Effect `Stream`s of input chunks.\n *\n * This is where nom's and winnow's *partial* (streaming) parsing meets\n * Effect: chunks are buffered and the parser runs in partial mode, so a\n * value split across chunk boundaries is reported as `Incomplete` and\n * retried once more data arrives. When the stream ends, the leftover input\n * is parsed in complete mode.\n *\n * @example\n * ```ts\n * import { Effect, Stream } from \"effect\"\n * import { Ascii, Parser, ParserStream, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const line = Parser.terminated(Ascii.decInt, Token.literal(\"\\n\"))\n *\n * const program = Stream.make(\"1\\n2\", \"3\\n\", \"4\\n\").pipe(\n *   ParserStream.parseMany(line),\n *   Stream.runCollect\n * )\n * // Effect.runSync(program) => [1, 23, 4]\n * ```\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Context from \"effect/Context\"\nimport * as Data from \"effect/Data\"\nimport * as Effect from \"effect/Effect\"\nimport { dual } from \"effect/Function\"\nimport * as Stream from \"effect/Stream\"\nimport type { BinaryInput, Input, Source } from \"./Input.js\"\nimport { Fail, Failure, fromSource, State } from \"./Input.js\"\nimport * as ParseError from \"./ParseError.js\"\nimport * as Registry from \"./internal/compiler/registry.js\"\nimport type * as Resume from \"./internal/resume.js\"\nimport * as Run from \"./internal/run.js\"\nimport * as Stack from \"./internal/stack.js\"\nimport type { Parser } from \"./Parser.js\"\n\n/**\n * Input kinds that can be streamed in chunks.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Chunkable = string | Uint8Array | ReadonlyArray<unknown>\n\nconst concat = <I extends Chunkable>(a: I, b: I): I => {\n  if (Predicate.isString(a)) return (a + (b as string)) as I\n  if (a instanceof Uint8Array) {\n    if (a.length === 0) return b\n    const out = new Uint8Array(a.length + (b as Uint8Array).length)\n    out.set(a)\n    out.set(b as Uint8Array, a.length)\n    return out as I\n  }\n  return [...a, ...(b as ReadonlyArray<unknown>)] as unknown as I\n}\n\nconst sliceFrom = <I extends Chunkable>(input: I, offset: number): I =>\n  (Predicate.isString(input) ? input.slice(offset) : input.slice(offset)) as I\n\nconst noProgress = (input: Input, offset: number) =>\n  ParseError.fromFailure<never>(\n    input,\n    new Failure(offset, \"Assert\", [], [], false, undefined, \"`parseMany` parsers must always consume\", 0),\n    \"Cut\"\n  )\n\n/**\n * Options for {@link parseMany}.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ParseManyOptions<I> {\n  /** The empty input, used to initialise the buffer (inferred from the first chunk if omitted). */\n  readonly empty?: Source<I> | undefined\n}\n\n/**\n * Transforms a stream of input chunks into a stream of parsed values by\n * applying `parser` repeatedly. Each application must consume input.\n *\n * Services required by the parser are taken from the stream's context.\n * Error offsets are relative to the internal buffer of unconsumed input,\n * which is also the `input` of the reported `ParseError`.\n *\n * A parser compiled with the `Compiler` module runs compiled, with the\n * build that handles partial input (see `Parser.run`); a value that fails\n * or needs more input is parsed again interpreted, so errors and\n * `Incomplete` are the interpreter's.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseMany: {\n  <A, E, R, I extends Chunkable>(\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): <E0, R0>(self: Stream.Stream<Source<I>, E0, R0>) => Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R>\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<NoInfer<I>>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R>\n} = /*#__PURE__*/ dual(\n  (args) => Stream.isStream(args[0]),\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<I>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R> =>\n    Stream.suspend(() => {\n      const step = parser.step\n      let buffer: I | undefined = options?.empty === undefined ? undefined : fromSource<I>(options.empty)\n\n      const drain = (context: any, partial: boolean): Effect.Effect<Array<A>, ParseError.ParseError<E>> => {\n        const out: Array<A> = []\n        if (buffer === undefined) return Effect.succeed(out)\n        const input = buffer\n        // One state for the whole buffer, reset before each value\n        const state = new State(input)\n        let offset = 0\n        while (offset < input.length) {\n          state.reset(offset, { partial, context })\n          const a = Run.runOn(parser, step, state)\n          if (a === Fail) {\n            if (partial && state.mode === \"Incomplete\") break\n            return Effect.fail(ParseError.fromFailure<E>(input, state.reportedFailure(), state.mode, state.encoding))\n          }\n          if (state.pos === offset) return Effect.fail(noProgress(input, offset))\n          out.push(a)\n          offset = state.pos\n        }\n        buffer = sliceFrom(input, offset)\n        return Effect.succeed(out)\n      }\n\n      const feed = (source: Source<I>) =>\n        Effect.flatMap(Effect.context<R>(), (context) =>\n          Effect.suspend(() => {\n            const chunk = fromSource<I>(source)\n            buffer = buffer === undefined ? chunk : concat(buffer, chunk)\n            return drain(context, true)\n          })\n        )\n\n      const finish = Effect.flatMap(Effect.context<R>(), (context) => Effect.suspend(() => drain(context, false)))\n\n      return self.pipe(\n        Stream.mapEffect(feed),\n        Stream.flattenIterable,\n        Stream.concat(Stream.unwrap(Effect.map(finish, Stream.fromIterable)))\n      )\n    })\n)\n\n/**\n * Parses a stream of chunks incrementally, as one input. Chunks are parsed\n * as they arrive, in partial mode; when the parser runs out of input, its\n * repetitions keep checkpoints (see `internal/resume.ts`), so the next\n * attempt carries on from where the last one stopped instead of starting\n * over.\n */\nclass Incremental<A, E, I extends Chunkable> {\n  private kind: 0 | 1 | 2 | undefined\n  private text = \"\"\n  private bytes = new Uint8Array(0)\n  private items: Array<unknown> = []\n  private length = 0\n  private readonly resume: Resume.Checkpoints = new Map()\n  /** The input length at the last attempt, and where that attempt ran out of input. */\n  private attempted = 0\n  private restart = 0\n  /** Set once an attempt settles: a success (with its end offset) or a definite failure. */\n  private settled: { readonly value: A; readonly pos: number } | \"failed\" | undefined\n\n  constructor(\n    private readonly parser: Parser<A, E, any, I>,\n    private readonly context: Context.Context<never>,\n    empty: I | undefined\n  ) {\n    if (empty !== undefined) this.append(empty)\n  }\n\n  private append(chunk: I): void {\n    if (Predicate.isString(chunk)) {\n      this.kind ??= 0\n      this.text += chunk\n      this.length += chunk.length\n    } else if (chunk instanceof Uint8Array) {\n      this.kind ??= 1\n      const needed = this.length + chunk.length\n      if (needed > this.bytes.length) {\n        // Grow geometrically, so appending costs amortized constant time per byte\n        const grown = new Uint8Array(Math.max(needed, this.bytes.length * 2, 4096))\n        grown.set(this.bytes.subarray(0, this.length))\n        this.bytes = grown\n      }\n      this.bytes.set(chunk, this.length)\n      this.length = needed\n    } else {\n      this.kind ??= 2\n      for (let i = 0; i < chunk.length; i++) this.items.push(chunk[i])\n      this.length = this.items.length\n    }\n  }\n\n  private input(): I {\n    switch (this.kind) {\n      case 1:\n        return this.bytes.subarray(0, this.length) as I\n      case 2:\n        // Items are only appended between attempts, after each state has read its `end`\n        return this.items as unknown as I\n      default:\n        return this.text as I\n    }\n  }\n\n  push(chunk: I): void {\n    if (chunk.length === 0) return\n    this.append(chunk)\n    if (this.settled !== undefined) return\n    // An attempt re-reads what the last one could not finish, from `restart`;\n    // waiting until at least half as much new input has arrived keeps the\n    // total work linear in the input. Strings are also copied when they are\n    // flattened, so they wait for a fraction of the whole input too.\n    const added = this.length - this.attempted\n    if (added < (this.attempted - this.restart) / 2) return\n    if (this.kind === 0 && added < this.attempted / 8) return\n    this.attempt()\n  }\n\n  /** The step attempts run: the parser's resumable compiled code if it was compiled, else the interpreter. */\n  private step(state: State<I>): unknown {\n    return Stack.run(Registry.stepFor(this.parser, state, true) ?? this.parser.step, state)\n  }\n\n  private attempt(): void {\n    const state = new State(this.input(), { partial: true, context: this.context })\n    state.resume = this.resume\n    const a = this.step(state)\n    this.attempted = this.length\n    if (a !== Fail) {\n      this.settled = { value: a as A, pos: state.pos }\n    } else if (state.mode === \"Incomplete\") {\n      this.restart = state.failure.offset\n    } else {\n      this.settled = \"failed\"\n    }\n  }\n\n  finish(): Effect.Effect<A, ParseError.ParseError<E>> {\n    const settled = this.settled\n    if (settled !== undefined && settled !== \"failed\") {\n      if (settled.pos === this.length) return Effect.succeed(settled.value)\n    } else if (settled === undefined) {\n      // The last attempt, in complete mode, resumes from the checkpoints too\n      const state = new State(this.input(), { context: this.context })\n      state.resume = this.resume\n      const a = this.step(state)\n      if (a !== Fail && state.pos === state.end) return Effect.succeed(a as A)\n    }\n    // The error comes from an ordinary parse of the whole input, so it is the\n    // same as if the input had been parsed in one go\n    const all = this.input()\n    const state = new State(all, { context: this.context })\n    const a = Stack.run(this.parser.step, state)\n    if (a !== Fail && state.pos === state.end) return Effect.succeed(a)\n    if (a !== Fail) state.backtrack(\"Eof\", [\"end of input\"])\n    return Effect.fail(ParseError.fromFailure<E>(all, state.reportedFailure(), state.mode, state.encoding))\n  }\n}\n\n/**\n * Parses an entire stream of chunks as a single complete input.\n *\n * Parsing does not wait for the stream to end: each chunk is parsed as it\n * arrives, in partial mode, and when the parser runs out of input its\n * repetitions (`repeat`, `separated`, `fold`, `escaped`, ...) remember how\n * far they got, so that the next attempt resumes there rather than starting\n * over. A large document, such as the body of a `fetch` response, is\n * therefore parsed while it downloads, and is ready soon after its last\n * byte. Use {@link parseReadable} or {@link parseResponse} for web streams.\n *\n * The result and any `ParseError` are those of parsing the whole input at\n * once: errors are reported once the stream has ended, by an ordinary\n * interpreted parse of the whole input. A parser compiled with the\n * `Compiler` module streams compiled too (with a build that handles partial\n * input), which is several times faster. As with compiled parsers,\n * callbacks should be pure: the elements parsed before a checkpoint are\n * not parsed again, and on failure everything is parsed again.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseAll: {\n  <A, E, R, I extends Chunkable>(\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): <E0, R0>(self: Stream.Stream<Source<I>, E0, R0>) => Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R>\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<NoInfer<I>>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R>\n} = /*#__PURE__*/ dual(\n  (args) => Stream.isStream(args[0]),\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<I>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R> =>\n    Effect.flatMap(Effect.context<R>(), (context) =>\n      Effect.suspend(() => {\n        const empty = options?.empty === undefined ? undefined : fromSource<I>(options.empty)\n        const incremental = new Incremental(parser, context as Context.Context<never>, empty)\n        return Effect.flatMap(\n          Stream.runForEach(self, (chunk) => Effect.sync(() => incremental.push(fromSource<I>(chunk)))),\n          () => Effect.suspend(() => incremental.finish())\n        )\n      })\n    )\n)\n\n/**\n * An error reading a `ReadableStream` given to {@link parseReadable} or\n * {@link parseResponse}.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class ReadError extends /*#__PURE__*/ Data.TaggedError(\"ReadError\")<{ readonly cause: unknown }> {}\n\n/**\n * Parses a web `ReadableStream` of bytes, such as the body of a `fetch`\n * response, incrementally (see {@link parseAll}): the bytes are parsed as\n * they arrive, without waiting for the end of the stream or decoding them\n * first. Use a byte parser, e.g. one built from `Text.utf8`.\n *\n * @example\n * ```ts\n * import { Effect } from \"effect\"\n * import { Parser, ParserStream, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const csvLine = Parser.separated(Text.utf8.takeTill(\",\\n\"), Text.utf8.literal(\",\"))\n * const csv = Parser.separated(csvLine, Text.utf8.literal(\"\\n\"))\n *\n * const response = await fetch(\"https://example.com/data.csv\")\n * const rows = await Effect.runPromise(ParserStream.parseReadable(response.body!, csv))\n * ```\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseReadable: {\n  <A, E, R>(\n    parser: Parser<A, E, R, Uint8Array>\n  ): (self: ReadableStream<BinaryInput>) => Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n  <A, E, R>(\n    self: ReadableStream<BinaryInput>,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R>(\n    self: ReadableStream<BinaryInput>,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>\n    parseAll(\n      Stream.fromReadableStream({ evaluate: () => self, onError: (cause) => new ReadError({ cause }) }),\n      parser,\n      { empty: new Uint8Array(0) }\n    )\n)\n\n/**\n * Parses the body of a `fetch` `Response` incrementally, as it downloads\n * (see {@link parseReadable}). A response without a body is parsed as empty\n * input. The status is not checked.\n *\n * @example\n * ```ts\n * import { Effect } from \"effect\"\n * import { Parser, ParserStream, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const lines = Parser.separated(Text.utf8.tillLineEnding, Text.utf8.lineEnding)\n *\n * const response = await fetch(\"https://example.com/log.txt\")\n * const value = await Effect.runPromise(ParserStream.parseResponse(response, lines))\n * ```\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseResponse: {\n  <A, E, R>(\n    parser: Parser<A, E, R, Uint8Array>\n  ): (self: Response) => Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n  <A, E, R>(\n    self: Response,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R>(\n    self: Response,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>\n    parseReadable(self.body ?? new ReadableStream<Uint8Array>({ start: (c) => c.close() }), parser)\n)\n"],"mappings":"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"}