@thomasfosterau/effect-parse 0.5.0 → 0.6.0

package/dist/ParserStream.js

@@ -1,5 +1,6 @@
 import * as Predicate from "effect/Predicate";
 import { Fail, Failure, State, fromSource } from "./Input.js";
+import { isParser } from "./Parser.js";
 import * as Registry from "./internal/compiler/registry.js";
 import * as Run from "./internal/run.js";
 import { isEmptyUnits } from "./internal/text.js";
@@ -19,6 +20,12 @@ import * as Stream from "effect/Stream";
 * retried once more data arrives. When the stream ends, the leftover input
 * is parsed in complete mode.
 *
+* Every runner bounds what it buffers: `maxBufferSize` (see
+* {@link BufferOptions}) defaults to 64 MiB ({@link defaultMaxBufferSize}),
+* and a stream that exceeds it fails with a {@link BufferLimitError}, so a
+* socket or an HTTP body can be parsed without wrapping the stream first.
+* Pass `Infinity` for input that is trusted to be large.
+*
 * @example
 * ```ts
 * import { Effect, Stream } from "effect"
@@ -35,19 +42,149 @@ import * as Stream from "effect/Stream";
 *
 * @since 0.1.0
 */
-const concat = (first, b) => {
-	const a = first;
-	if (Predicate.isString(a)) return a + b;
-	if (a instanceof Uint8Array) {
-		if (a.byteLength === 0) return b;
-		const out = new Uint8Array(a.length + b.length);
-		out.set(a);
-		out.set(b, a.length);
-		return out;
+/**
+* The default `maxBufferSize` of {@link parseMany}, {@link parseAll},
+* {@link parseReadable} and {@link parseResponse}: 64 MiB, counted in tokens
+* of the input (UTF-16 code units of a string, bytes of a `Uint8Array`,
+* elements of an array).
+*
+* @since 0.6.0
+* @category constants
+*/
+const defaultMaxBufferSize = 67108864;
+/**
+* A stream runner would have buffered more than its `maxBufferSize`: `size`
+* tokens against a limit of `limit`. It is a different failure from a
+* `ParseError`: the input is too large, not malformed (an HTTP server
+* answers 413 for the one and 400 for the other), and nothing of the input
+* is attached to it.
+*
+* @example
+* ```ts
+* import { Effect, Stream } from "effect"
+* import { Parser, ParserStream, Token } from "@thomasfosterau/effect-parse"
+*
+* const line = Parser.terminated(Token.takeTill("\n"), Token.literal("\n"))
+*
+* Stream.make("no newline, ", "ever").pipe(
+*   ParserStream.parseMany(line, { maxBufferSize: 8 }),
+*   Stream.runCollect,
+*   Effect.catchTag("BufferLimitError", (e) => Effect.succeed(`too large: ${e.size} > ${e.limit}`))
+* )
+* ```
+*
+* @since 0.6.0
+* @category errors
+*/
+var BufferLimitError = class extends (/*#__PURE__*/ Data.TaggedError("BufferLimitError")) {
+	get message() {
+		return `the input is larger than maxBufferSize: ${this.size} tokens, limit ${this.limit}`;
+	}
+};
+/** The limit `options` asks for: a positive number of tokens, or `Infinity`. */
+const limitOf = (options) => {
+	const limit = options?.maxBufferSize ?? 67108864;
+	if (!(limit > 0)) throw new RangeError("maxBufferSize must be a positive number of tokens, or Infinity");
+	return limit;
+};
+/**
+* Above this many unconsumed tokens, {@link parseMany} stops retrying its
+* unfinished value on every chunk (see {@link Pending.due}).
+*/
+const BackoffThreshold = 65536;
+/**
+* The input `parseMany` has not consumed yet: what is left of the chunks
+* after the values parsed from them, which is one unfinished value.
+*
+* Appending is amortized constant time per token: text is concatenated (a
+* rope until it is parsed), bytes go into a buffer that doubles, and
+* elements are pushed. Bytes that a parse has seen are never overwritten,
+* since the values parsed from them may be views of the buffer
+* (`Token.take` returns a `subarray`): the buffer is only ever appended to
+* past its end, or replaced by a larger one.
+*/
+var Pending = class {
+	kind;
+	text = "";
+	bytes = /* @__PURE__ */ new Uint8Array(0);
+	/** Where the unconsumed bytes start and end in `bytes`, and how far `bytes` may be written. */
+	start = 0;
+	end = 0;
+	capacity = 0;
+	items = [];
+	/** The unconsumed size at the last attempt that ran out of input, or 0 when none is outstanding. */
+	attempted = 0;
+	/** The number of unconsumed tokens. */
+	get size() {
+		return this.kind === 1 ? this.end - this.start : this.kind === 2 ? this.items.length : this.text.length;
+	}
+	get isEmpty() {
+		return this.kind === void 0;
+	}
+	append(chunk) {
+		if (Predicate.isString(chunk)) {
+			this.kind ??= 0;
+			this.text += chunk;
+		} else if (chunk instanceof Uint8Array) {
+			this.kind ??= 1;
+			this.appendBytes(chunk);
+		} else {
+			this.kind ??= 2;
+			for (let i = 0; i < chunk.length; i++) this.items.push(chunk[i]);
+		}
+	}
+	appendBytes(chunk) {
+		const held = this.end - this.start;
+		if (held === 0) {
+			this.bytes = chunk;
+			this.start = 0;
+			this.end = this.capacity = chunk.length;
+			return;
+		}
+		const needed = held + chunk.length;
+		if (this.end + chunk.length > this.capacity) {
+			const grown = new Uint8Array(Math.max(needed * 2, 4096));
+			grown.set(this.bytes.subarray(this.start, this.end));
+			this.bytes = grown;
+			this.start = 0;
+			this.end = held;
+			this.capacity = grown.length;
+		}
+		this.bytes.set(chunk, this.end);
+		this.end += chunk.length;
+	}
+	/** The unconsumed input. */
+	input() {
+		if (this.kind === 1) return this.bytes.subarray(this.start, this.end);
+		if (this.kind === 2) return this.items;
+		return this.text;
+	}
+	/** Drops the first `count` tokens, which values were parsed from. */
+	consume(count) {
+		if (count === 0) return;
+		if (this.kind === 1) this.start += count;
+		else if (this.kind === 2) this.items = this.items.slice(count);
+		else this.text = this.text.slice(count);
+	}
+	/** Records whether the attempt just made left an unfinished value. */
+	attemptedWith(unfinished) {
+		this.attempted = unfinished ? this.size : 0;
+	}
+	/**
+	* Whether to parse now. A value that is still unfinished is parsed again
+	* from its start, so retrying on every chunk costs the square of its
+	* size: a megabyte with no delimiter, in 1 KiB chunks, took seconds. Past
+	* {@link BackoffThreshold} tokens, the next attempt therefore waits until
+	* the buffer has grown by an eighth, which keeps the total work linear
+	* (each token is re-read at most about nine times). Smaller values are
+	* retried on every chunk, as cheaply as before, so a record is emitted
+	* as soon as its last chunk arrives.
+	*/
+	due() {
+		const attempted = this.attempted;
+		return attempted <= BackoffThreshold || this.size - attempted >= attempted >>> 3;
 	}
-	return [...a, ...b];
 };
-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
@@ -63,48 +200,81 @@ const noProgress = (input, offset) => ParseError.fromFailure(input, new Failure(
 * cut short by its chunk is not: compiled code reports `Incomplete` where
 * the interpreter does.
 *
+* **Untrusted streams.** The input not yet consumed (one unfinished value)
+* is limited to `maxBufferSize` tokens, 64 MiB by default
+* ({@link defaultMaxBufferSize}); past it the stream fails with a
+* {@link BufferLimitError}, so a peer that never sends the delimiter cannot
+* grow the buffer without bound. An unfinished value is parsed again from
+* its start when more input arrives. Up to 64 KiB that happens on every
+* chunk; a larger one is retried only once the buffer has grown by an
+* eighth, so the work stays linear in its size. The cost: the last chunk of
+* a value larger than 64 KiB may not complete it in the output until more
+* input arrives or the stream ends, when everything left is parsed.
+*
+* @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, { maxBufferSize: 1024 }),
+*   Stream.runCollect
+* )
+* // Effect.runSync(program) => [1, 23, 4]
+* ```
+*
 * @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, false);
-			if (a === Fail) {
-				if (partial && state.mode === "Incomplete") break;
+const parseMany = /*#__PURE__*/ dual((args) => Stream.isStream(args[0]), (self, parser, options) => {
+	const limit = limitOf(options);
+	return Stream.suspend(() => {
+		const step = parser.step;
+		const pending = new Pending();
+		if (options?.empty !== void 0) pending.append(fromSource(options.empty));
+		const drain = (context, partial) => {
+			const out = [];
+			if (pending.isEmpty) return Effect.succeed(out);
+			const input = pending.input();
+			const state = new State(input);
+			let offset = 0;
+			while (offset < input.length) {
 				state.reset(offset, {
 					partial,
 					context
 				});
-				Run.runOn(parser, step, state);
-				return Effect.fail(ParseError.fromFailure(input, state.reportedFailure(), state.mode, state.encoding));
+				const a = Run.runOn(parser, step, state, false);
+				if (a === Fail) {
+					if (partial && state.mode === "Incomplete") break;
+					state.reset(offset, {
+						partial,
+						context
+					});
+					Run.runOn(parser, step, state);
+					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;
 			}
-			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))));
-}));
+			pending.consume(offset);
+			pending.attemptedWith(offset < input.length);
+			const size = input.length - offset;
+			return size > limit ? Effect.fail(new BufferLimitError({
+				limit,
+				size
+			})) : Effect.succeed(out);
+		};
+		const feed = (source) => Effect.flatMap(Effect.context(), (context) => Effect.suspend(() => {
+			pending.append(fromSource(source));
+			return pending.due() || pending.size > limit ? drain(context, true) : Effect.succeed([]);
+		}));
+		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
@@ -158,6 +328,10 @@ var Incremental = class {
 		if (this.kind === 2) return this.items;
 		return this.text;
 	}
+	/** The tokens held: the whole input so far. */
+	get size() {
+		return this.length;
+	}
 	push(chunk) {
 		if (isEmptyUnits(chunk)) return;
 		this.append(chunk);
@@ -228,13 +402,30 @@ var Incremental = class {
 * callbacks should be pure: the elements parsed before a checkpoint are
 * not parsed again, and on failure everything is parsed again.
 *
+* The whole input is held until the stream ends, so it is limited to
+* `maxBufferSize` tokens (64 MiB by default, see {@link BufferOptions}):
+* a stream that would exceed it fails with a {@link BufferLimitError}
+* before the chunk that crosses the limit is buffered.
+*
 * @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()));
-})));
+const parseAll = /*#__PURE__*/ dual((args) => Stream.isStream(args[0]), (self, parser, options) => {
+	const limit = limitOf(options);
+	return 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, (source) => Effect.suspend(() => {
+			const chunk = fromSource(source);
+			const size = incremental.size + chunk.length;
+			if (size > limit) return Effect.fail(new BufferLimitError({
+				limit,
+				size
+			}));
+			incremental.push(chunk);
+			return Effect.void;
+		})), () => Effect.suspend(() => incremental.finish()));
+	}));
+});
 /**
 * An error reading a `ReadableStream` given to {@link parseReadable} or
 * {@link parseResponse}.
@@ -243,11 +434,16 @@ const parseAll = /*#__PURE__*/ dual((args) => Stream.isStream(args[0]), (self, p
 * @category errors
 */
 var ReadError = class extends (/*#__PURE__*/ Data.TaggedError("ReadError")) {};
+/** Whether a web-stream runner was called with its stream first: the other form starts with the parser. */
+const isDataFirst = (args) => !isParser(args[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`.
+* first. Use a byte parser, e.g. one built from `Text.utf8`. The stream is
+* limited to `maxBufferSize` bytes (64 MiB by default, see
+* {@link BufferOptions}), past which it fails with a
+* {@link BufferLimitError}.
 *
 * @example
 * ```ts
@@ -264,15 +460,36 @@ var ReadError = class extends (/*#__PURE__*/ Data.TaggedError("ReadError")) {};
 * @since 0.1.0
 * @category combinators
 */
-const parseReadable = /*#__PURE__*/ dual(2, (self, parser) => parseAll(Stream.fromReadableStream({
+const parseReadable = /*#__PURE__*/ dual(isDataFirst, (self, parser, options) => parseAll(Stream.fromReadableStream({
 	evaluate: () => self,
 	onError: (cause) => new ReadError({ cause })
-}), parser, { empty: /* @__PURE__ */ new Uint8Array(0) }));
+}), parser, {
+	empty: /* @__PURE__ */ new Uint8Array(0),
+	maxBufferSize: options?.maxBufferSize
+}));
+/**
+* The length a response declares for the body as it will be read, if it
+* declares one: `Content-Length` counts the encoded body, so a response
+* with a `Content-Encoding` (which `fetch` decodes) declares nothing about
+* the bytes parsed.
+*/
+const declaredLength = (response) => {
+	if (response.headers.has("content-encoding")) return void 0;
+	const header = response.headers.get("content-length");
+	if (header === null || !/^[0-9]+$/.test(header)) return void 0;
+	return Number(header);
+};
 /**
 * 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.
 *
+* The body is limited to `maxBufferSize` bytes (64 MiB by default, see
+* {@link BufferOptions}). A response whose `Content-Length` already exceeds
+* the limit fails with a {@link BufferLimitError} before any of the body is
+* read; the limit is enforced on the bytes read as well, since the header
+* may be absent or wrong.
+*
 * @example
 * ```ts
 * import { Effect } from "effect"
@@ -281,13 +498,23 @@ const parseReadable = /*#__PURE__*/ dual(2, (self, parser) => parseAll(Stream.fr
 * 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))
+* const value = await Effect.runPromise(
+*   ParserStream.parseResponse(response, lines, { maxBufferSize: 8 * 1024 * 1024 })
+* )
 * ```
 *
 * @since 0.1.0
 * @category combinators
 */
-const parseResponse = /*#__PURE__*/ dual(2, (self, parser) => parseReadable(self.body ?? new ReadableStream({ start: (c) => c.close() }), parser));
-export { ReadError, parseAll, parseMany, parseReadable, parseResponse };
+const parseResponse = /*#__PURE__*/ dual(isDataFirst, (self, parser, options) => Effect.suspend(() => {
+	const limit = limitOf(options);
+	const size = declaredLength(self);
+	if (size !== void 0 && size > limit) return Effect.fail(new BufferLimitError({
+		limit,
+		size
+	}));
+	return parseReadable(self.body ?? new ReadableStream({ start: (c) => c.close() }), parser, options);
+}));
+export { BufferLimitError, ReadError, defaultMaxBufferSize, parseAll, parseMany, parseReadable, parseResponse };
 
 //# sourceMappingURL=ParserStream.js.map

package/dist/ParserStream.js.map

@@ -1 +1 @@
-{"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 { isEmptyUnits } from \"./internal/text.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>(first: I, b: I): I => {\n  // Widened so the checks below narrow it (a type parameter does not narrow).\n  const a: Chunkable = first\n  if (Predicate.isString(a)) {\n    // SAFETY: both are chunks of one stream of `I`, so `b` is a string when `a` is, and so is their concatenation\n    return (a + (b as string)) as I\n  }\n  if (a instanceof Uint8Array) {\n    if (a.byteLength === 0) return b\n    // SAFETY: both are chunks of one stream of `I`, so `b` is a `Uint8Array` when `a` is\n    const out = new Uint8Array(a.length + (b as Uint8Array).length)\n    out.set(a)\n    // SAFETY: both are chunks of one stream of `I`, so `b` is a `Uint8Array` when `a` is\n    out.set(b as Uint8Array, a.length)\n    // SAFETY: `I` is `a`'s type, a `Uint8Array` here, and `out` is a new `Uint8Array`\n    return out as I\n  }\n  // SAFETY: both are chunks of one stream of `I`, so `b` is an array when `a` is\n  const joined: Chunkable = [...a, ...(b as ReadonlyArray<unknown>)]\n  // SAFETY: `I` is `a`'s type, an array here, and `joined` is a new array of both chunks' elements\n  return joined as I\n}\n\nconst sliceFrom = <I extends Chunkable>(input: I, offset: number): I =>\n  // SAFETY: slicing a string, `Uint8Array` or array returns a value of the same kind\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 * is parsed again interpreted, so errors are the interpreter's. A value\n * cut short by its chunk is not: compiled code reports `Incomplete` where\n * the interpreter does.\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          // A compiled `Incomplete` is the interpreter's: only an error needs the interpreted run\n          const a = Run.runOn(parser, step, state, false)\n          if (a === Fail) {\n            if (partial && state.mode === \"Incomplete\") break\n            state.reset(offset, { partial, context })\n            Run.runOn(parser, step, state)\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  private pushed = 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    if (this.kind === 1) {\n      // SAFETY: `kind` 1 is set by the first chunk being a `Uint8Array`, so `I` is `Uint8Array`\n      return this.bytes.subarray(0, this.length) as I\n    }\n    if (this.kind === 2) {\n      // Items are only appended between attempts, after each state has read its `end`\n      const items: Chunkable = this.items\n      // SAFETY: `kind` 2 is set by the first chunk being an array, so `I` is an array of the items' type\n      return items as I\n    }\n    // SAFETY: `kind` 0 means the first chunk was a string, so `I` is `string`; while `kind` is unset (no\n    // chunk arrived) `I` is unknown and the empty string stands for the empty input\n    return this.text as I\n  }\n\n  push(chunk: I): void {\n    if (isEmptyUnits(chunk)) return\n    this.append(chunk)\n    if (this.settled !== undefined) return\n    // The first attempt waits for a second chunk: an input that arrives in\n    // one chunk (most small responses) is parsed once, by `finish`, instead\n    // of once in partial mode and again in complete mode, since a repetition\n    // that completes without resuming keeps no checkpoint\n    if (++this.pushed === 1) 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  /**\n   * The step attempts run: the parser's compiled code if it was compiled\n   * (the resumable build, unless `resumable` is false), else the interpreter.\n   */\n  private step(state: State<I>, resumable = true): A | Fail {\n    // SAFETY: a compiled step (typed `any` by the compilers) returns what the parser's own step returns\n    return Stack.run(Registry.stepFor(this.parser, state, resumable) ?? this.parser.step, state) as A | Fail\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, 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      // with no attempt before it, it is an ordinary parse\n      const state = new State(this.input(), { context: this.context })\n      const resumable = this.attempted > 0\n      if (resumable) state.resume = this.resume\n      const a = this.step(state, resumable)\n      if (a !== Fail && state.pos === state.end) return Effect.succeed(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, 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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"}
+{"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 * Every runner bounds what it buffers: `maxBufferSize` (see\n * {@link BufferOptions}) defaults to 64 MiB ({@link defaultMaxBufferSize}),\n * and a stream that exceeds it fails with a {@link BufferLimitError}, so a\n * socket or an HTTP body can be parsed without wrapping the stream first.\n * Pass `Infinity` for input that is trusted to be large.\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 { isEmptyUnits } from \"./internal/text.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { isParser } 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\n/**\n * The default `maxBufferSize` of {@link parseMany}, {@link parseAll},\n * {@link parseReadable} and {@link parseResponse}: 64 MiB, counted in tokens\n * of the input (UTF-16 code units of a string, bytes of a `Uint8Array`,\n * elements of an array).\n *\n * @since 0.6.0\n * @category constants\n */\nexport const defaultMaxBufferSize: number = 64 * 1024 * 1024\n\n/**\n * A stream runner would have buffered more than its `maxBufferSize`: `size`\n * tokens against a limit of `limit`. It is a different failure from a\n * `ParseError`: the input is too large, not malformed (an HTTP server\n * answers 413 for the one and 400 for the other), and nothing of the input\n * is attached to it.\n *\n * @example\n * ```ts\n * import { Effect, Stream } from \"effect\"\n * import { Parser, ParserStream, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const line = Parser.terminated(Token.takeTill(\"\\n\"), Token.literal(\"\\n\"))\n *\n * Stream.make(\"no newline, \", \"ever\").pipe(\n *   ParserStream.parseMany(line, { maxBufferSize: 8 }),\n *   Stream.runCollect,\n *   Effect.catchTag(\"BufferLimitError\", (e) => Effect.succeed(`too large: ${e.size} > ${e.limit}`))\n * )\n * ```\n *\n * @since 0.6.0\n * @category errors\n */\nexport class BufferLimitError\n  extends /*#__PURE__*/ Data.TaggedError(\"BufferLimitError\")<{\n    /** The `maxBufferSize` in force, in tokens. */\n    readonly limit: number\n    /** The tokens the runner held, or was about to hold (for `parseResponse`, the declared `Content-Length`). */\n    readonly size: number\n  }>\n{\n  override get message(): string {\n    return `the input is larger than maxBufferSize: ${this.size} tokens, limit ${this.limit}`\n  }\n}\n\n/**\n * The limit on buffered input that the stream runners share.\n *\n * @since 0.6.0\n * @category models\n */\nexport interface BufferOptions {\n  /**\n   * The most tokens a runner buffers (UTF-16 code units of a string, bytes\n   * of a `Uint8Array`, elements of an array) before it fails with a\n   * {@link BufferLimitError}. Defaults to {@link defaultMaxBufferSize}\n   * (64 MiB); `Infinity` turns the limit off.\n   *\n   * {@link parseMany} counts the input it has not consumed yet, which is one\n   * unfinished value: complete values in a chunk are parsed and emitted\n   * first, whatever the chunk's size. {@link parseAll},\n   * {@link parseReadable} and {@link parseResponse} hold the whole input, so\n   * they count all of it.\n   */\n  readonly maxBufferSize?: number | undefined\n}\n\n/** The limit `options` asks for: a positive number of tokens, or `Infinity`. */\nconst limitOf = (options: BufferOptions | undefined): number => {\n  const limit = options?.maxBufferSize ?? defaultMaxBufferSize\n  if (!(limit > 0)) throw new RangeError(\"maxBufferSize must be a positive number of tokens, or Infinity\")\n  return limit\n}\n\n/**\n * Above this many unconsumed tokens, {@link parseMany} stops retrying its\n * unfinished value on every chunk (see {@link Pending.due}).\n */\nconst BackoffThreshold = 64 * 1024\n\n/**\n * The input `parseMany` has not consumed yet: what is left of the chunks\n * after the values parsed from them, which is one unfinished value.\n *\n * Appending is amortized constant time per token: text is concatenated (a\n * rope until it is parsed), bytes go into a buffer that doubles, and\n * elements are pushed. Bytes that a parse has seen are never overwritten,\n * since the values parsed from them may be views of the buffer\n * (`Token.take` returns a `subarray`): the buffer is only ever appended to\n * past its end, or replaced by a larger one.\n */\nclass Pending<I extends Chunkable> {\n  private kind: 0 | 1 | 2 | undefined\n  private text = \"\"\n  private bytes: Uint8Array = new Uint8Array(0)\n  /** Where the unconsumed bytes start and end in `bytes`, and how far `bytes` may be written. */\n  private start = 0\n  private end = 0\n  private capacity = 0\n  private items: Array<unknown> = []\n  /** The unconsumed size at the last attempt that ran out of input, or 0 when none is outstanding. */\n  private attempted = 0\n\n  /** The number of unconsumed tokens. */\n  get size(): number {\n    return this.kind === 1 ? this.end - this.start : this.kind === 2 ? this.items.length : this.text.length\n  }\n\n  get isEmpty(): boolean {\n    return this.kind === undefined\n  }\n\n  append(chunk: I): void {\n    if (Predicate.isString(chunk)) {\n      this.kind ??= 0\n      this.text += chunk\n    } else if (chunk instanceof Uint8Array) {\n      this.kind ??= 1\n      this.appendBytes(chunk)\n    } else {\n      this.kind ??= 2\n      for (let i = 0; i < chunk.length; i++) this.items.push(chunk[i])\n    }\n  }\n\n  private appendBytes(chunk: Uint8Array): void {\n    const held = this.end - this.start\n    if (held === 0) {\n      // Nothing is pending: the chunk is the buffer, uncopied. It is the\n      // caller's, so it is never written to (`capacity` is its end)\n      this.bytes = chunk\n      this.start = 0\n      this.end = this.capacity = chunk.length\n      return\n    }\n    const needed = held + chunk.length\n    if (this.end + chunk.length > this.capacity) {\n      // Twice what is needed, so appending costs amortized constant time per byte\n      const grown = new Uint8Array(Math.max(needed * 2, 4096))\n      grown.set(this.bytes.subarray(this.start, this.end))\n      this.bytes = grown\n      this.start = 0\n      this.end = held\n      this.capacity = grown.length\n    }\n    this.bytes.set(chunk, this.end)\n    this.end += chunk.length\n  }\n\n  /** The unconsumed input. */\n  input(): I {\n    if (this.kind === 1) {\n      // SAFETY: `kind` 1 is set by the first chunk being a `Uint8Array`, so `I` is `Uint8Array`\n      return this.bytes.subarray(this.start, this.end) as I\n    }\n    if (this.kind === 2) {\n      const items: Chunkable = this.items\n      // SAFETY: `kind` 2 is set by the first chunk being an array, so `I` is an array of the items' type\n      return items as I\n    }\n    // SAFETY: `kind` 0 is set by the first chunk being a string, so `I` is `string`\n    return this.text as I\n  }\n\n  /** Drops the first `count` tokens, which values were parsed from. */\n  consume(count: number): void {\n    if (count === 0) return\n    if (this.kind === 1) this.start += count\n    // A new array: the one parsed is the `input` of the state that read it\n    else if (this.kind === 2) this.items = this.items.slice(count)\n    else this.text = this.text.slice(count)\n  }\n\n  /** Records whether the attempt just made left an unfinished value. */\n  attemptedWith(unfinished: boolean): void {\n    this.attempted = unfinished ? this.size : 0\n  }\n\n  /**\n   * Whether to parse now. A value that is still unfinished is parsed again\n   * from its start, so retrying on every chunk costs the square of its\n   * size: a megabyte with no delimiter, in 1 KiB chunks, took seconds. Past\n   * {@link BackoffThreshold} tokens, the next attempt therefore waits until\n   * the buffer has grown by an eighth, which keeps the total work linear\n   * (each token is re-read at most about nine times). Smaller values are\n   * retried on every chunk, as cheaply as before, so a record is emitted\n   * as soon as its last chunk arrives.\n   */\n  due(): boolean {\n    const attempted = this.attempted\n    return attempted <= BackoffThreshold || this.size - attempted >= attempted >>> 3\n  }\n}\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} and {@link parseAll}.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ParseManyOptions<I> extends BufferOptions {\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 * is parsed again interpreted, so errors are the interpreter's. A value\n * cut short by its chunk is not: compiled code reports `Incomplete` where\n * the interpreter does.\n *\n * **Untrusted streams.** The input not yet consumed (one unfinished value)\n * is limited to `maxBufferSize` tokens, 64 MiB by default\n * ({@link defaultMaxBufferSize}); past it the stream fails with a\n * {@link BufferLimitError}, so a peer that never sends the delimiter cannot\n * grow the buffer without bound. An unfinished value is parsed again from\n * its start when more input arrives. Up to 64 KiB that happens on every\n * chunk; a larger one is retried only once the buffer has grown by an\n * eighth, so the work stays linear in its size. The cost: the last chunk of\n * a value larger than 64 KiB may not complete it in the output until more\n * input arrives or the stream ends, when everything left is parsed.\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, { maxBufferSize: 1024 }),\n *   Stream.runCollect\n * )\n * // Effect.runSync(program) => [1, 23, 4]\n * ```\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>(\n    self: Stream.Stream<Source<I>, E0, R0>\n  ) => Stream.Stream<A, E0 | ParseError.ParseError<E> | BufferLimitError, 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> | BufferLimitError, 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> | BufferLimitError, R0 | R> => {\n    const limit = limitOf(options)\n    return Stream.suspend(() => {\n      const step = parser.step\n      const pending = new Pending<I>()\n      if (options?.empty !== undefined) pending.append(fromSource<I>(options.empty))\n\n      const drain = (\n        context: any,\n        partial: boolean\n      ): Effect.Effect<Array<A>, ParseError.ParseError<E> | BufferLimitError> => {\n        const out: Array<A> = []\n        if (pending.isEmpty) return Effect.succeed(out)\n        const input = pending.input()\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          // A compiled `Incomplete` is the interpreter's: only an error needs the interpreted run\n          const a = Run.runOn(parser, step, state, false)\n          if (a === Fail) {\n            if (partial && state.mode === \"Incomplete\") break\n            state.reset(offset, { partial, context })\n            Run.runOn(parser, step, state)\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        pending.consume(offset)\n        pending.attemptedWith(offset < input.length)\n        // Only what no value consumed counts: an unfinished value larger than the limit\n        const size = input.length - offset\n        return size > limit ? Effect.fail(new BufferLimitError({ limit, size })) : Effect.succeed(out)\n      }\n\n      const feed = (source: Source<I>) =>\n        Effect.flatMap(Effect.context<R>(), (context) =>\n          Effect.suspend((): Effect.Effect<Array<A>, ParseError.ParseError<E> | BufferLimitError> => {\n            pending.append(fromSource<I>(source))\n            // Over the limit, parse whatever the back-off says, so that complete values are not counted\n            return pending.due() || pending.size > limit ? drain(context, true) : Effect.succeed([])\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/**\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  private pushed = 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    if (this.kind === 1) {\n      // SAFETY: `kind` 1 is set by the first chunk being a `Uint8Array`, so `I` is `Uint8Array`\n      return this.bytes.subarray(0, this.length) as I\n    }\n    if (this.kind === 2) {\n      // Items are only appended between attempts, after each state has read its `end`\n      const items: Chunkable = this.items\n      // SAFETY: `kind` 2 is set by the first chunk being an array, so `I` is an array of the items' type\n      return items as I\n    }\n    // SAFETY: `kind` 0 means the first chunk was a string, so `I` is `string`; while `kind` is unset (no\n    // chunk arrived) `I` is unknown and the empty string stands for the empty input\n    return this.text as I\n  }\n\n  /** The tokens held: the whole input so far. */\n  get size(): number {\n    return this.length\n  }\n\n  push(chunk: I): void {\n    if (isEmptyUnits(chunk)) return\n    this.append(chunk)\n    if (this.settled !== undefined) return\n    // The first attempt waits for a second chunk: an input that arrives in\n    // one chunk (most small responses) is parsed once, by `finish`, instead\n    // of once in partial mode and again in complete mode, since a repetition\n    // that completes without resuming keeps no checkpoint\n    if (++this.pushed === 1) 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  /**\n   * The step attempts run: the parser's compiled code if it was compiled\n   * (the resumable build, unless `resumable` is false), else the interpreter.\n   */\n  private step(state: State<I>, resumable = true): A | Fail {\n    // SAFETY: a compiled step (typed `any` by the compilers) returns what the parser's own step returns\n    return Stack.run(Registry.stepFor(this.parser, state, resumable) ?? this.parser.step, state) as A | Fail\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, 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      // with no attempt before it, it is an ordinary parse\n      const state = new State(this.input(), { context: this.context })\n      const resumable = this.attempted > 0\n      if (resumable) state.resume = this.resume\n      const a = this.step(state, resumable)\n      if (a !== Fail && state.pos === state.end) return Effect.succeed(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 * The whole input is held until the stream ends, so it is limited to\n * `maxBufferSize` tokens (64 MiB by default, see {@link BufferOptions}):\n * a stream that would exceed it fails with a {@link BufferLimitError}\n * before the chunk that crosses the limit is buffered.\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>(\n    self: Stream.Stream<Source<I>, E0, R0>\n  ) => Effect.Effect<A, E0 | ParseError.ParseError<E> | BufferLimitError, 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> | BufferLimitError, 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> | BufferLimitError, R0 | R> => {\n    const limit = limitOf(options)\n    return 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, empty)\n        return Effect.flatMap(\n          Stream.runForEach(self, (source) =>\n            Effect.suspend(() => {\n              const chunk = fromSource<I>(source)\n              // Checked before the chunk is copied in: the whole input is held, so all of it counts\n              const size = incremental.size + chunk.length\n              if (size > limit) return Effect.fail(new BufferLimitError({ limit, size }))\n              incremental.push(chunk)\n              return Effect.void\n            })\n          ),\n          () => Effect.suspend(() => incremental.finish())\n        )\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/** Whether a web-stream runner was called with its stream first: the other form starts with the parser. */\nconst isDataFirst = (args: IArguments): boolean => !isParser(args[0])\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`. The stream is\n * limited to `maxBufferSize` bytes (64 MiB by default, see\n * {@link BufferOptions}), past which it fails with a\n * {@link BufferLimitError}.\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    options?: BufferOptions\n  ): (self: ReadableStream<BinaryInput>) => Effect.Effect<A, ParseError.ParseError<E> | ReadError | BufferLimitError, R>\n  <A, E, R>(\n    self: ReadableStream<BinaryInput>,\n    parser: Parser<A, E, R, Uint8Array>,\n    options?: BufferOptions\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError | BufferLimitError, R>\n} = /*#__PURE__*/ dual(\n  isDataFirst,\n  <A, E, R>(\n    self: ReadableStream<BinaryInput>,\n    parser: Parser<A, E, R, Uint8Array>,\n    options?: BufferOptions\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError | BufferLimitError, R> =>\n    parseAll(\n      Stream.fromReadableStream({ evaluate: () => self, onError: (cause) => new ReadError({ cause }) }),\n      parser,\n      { empty: new Uint8Array(0), maxBufferSize: options?.maxBufferSize }\n    )\n)\n\n/**\n * The length a response declares for the body as it will be read, if it\n * declares one: `Content-Length` counts the encoded body, so a response\n * with a `Content-Encoding` (which `fetch` decodes) declares nothing about\n * the bytes parsed.\n */\nconst declaredLength = (response: Response): number | undefined => {\n  if (response.headers.has(\"content-encoding\")) return undefined\n  const header = response.headers.get(\"content-length\")\n  if (header === null || !/^[0-9]+$/.test(header)) return undefined\n  return Number(header)\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 * The body is limited to `maxBufferSize` bytes (64 MiB by default, see\n * {@link BufferOptions}). A response whose `Content-Length` already exceeds\n * the limit fails with a {@link BufferLimitError} before any of the body is\n * read; the limit is enforced on the bytes read as well, since the header\n * may be absent or wrong.\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(\n *   ParserStream.parseResponse(response, lines, { maxBufferSize: 8 * 1024 * 1024 })\n * )\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    options?: BufferOptions\n  ): (self: Response) => Effect.Effect<A, ParseError.ParseError<E> | ReadError | BufferLimitError, R>\n  <A, E, R>(\n    self: Response,\n    parser: Parser<A, E, R, Uint8Array>,\n    options?: BufferOptions\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError | BufferLimitError, R>\n} = /*#__PURE__*/ dual(\n  isDataFirst,\n  <A, E, R>(\n    self: Response,\n    parser: Parser<A, E, R, Uint8Array>,\n    options?: BufferOptions\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError | BufferLimitError, R> =>\n    Effect.suspend(() => {\n      const limit = limitOf(options)\n      const size = declaredLength(self)\n      if (size !== undefined && size > limit) return Effect.fail(new BufferLimitError({ limit, size }))\n      return parseReadable(self.body ?? new ReadableStream<Uint8Array>({ start: (c) => c.close() }), parser, options)\n    })\n)\n"],"mappings":"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"}

package/dist/Syntax.js

@@ -2,11 +2,11 @@ import * as Predicate from "effect/Predicate";
 import { Fail, State, fromSource } from "./Input.js";
 import { described, isParser } from "./Parser.js";
 import { Key } from "./internal/key.js";
+import { nodeOf } from "./internal/node.js";
 import * as Option from "effect/Option";
 import { dual } from "effect/Function";
 import * as ParseError from "./ParseError.js";
 import * as Stack from "./internal/stack.js";
-import { nodeOf } from "./internal/node.js";
 import * as Str from "effect/String";
 import { SyntaxBuilder, absolute, errorKind } from "./internal/syntax.js";
 // src/Syntax.ts

package/dist/Text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Text.d.ts","names":[],"sources":["../src/Text.ts"],"mappings":";;;;;;;;;;YAgEY,iBAAiB;;;;;;;;;;;;;;;;;qBAsChB,WAAY,iBAAe;;;;;;;;qBAS3B,cAAc;;;;;;;qBAQd,UAAU;;;;;;;qBAQV,aAAa;;;;;;;qBAQb,aAAa;;;;;;;;qBASb,gBAAgB;;;;;;;;qBAShB,WAAW;;;;;;;qBAQX,gBAAgB;;;;;;;;qBAShB,cAAc;;;;;;;;qBASd,SAAS;;;;;;;;qBAYT,WAAW;;;;;;;;qBASX,cAAc;;;;;;;qBAQd,eAAe;;;;;;;qBAQf,WAAW;;;;;;;;;;;;iBAiBP,YAAY,mBAAmB;;WAErC,UAAU,SAAS;;WAKnB,KAAK,6BAA6B;;;;;WAKlC,gBAAgB,kBAAkB,SAAS,MAAM,OAAO,iBAAiB;;;;;;WAMzE,WAAW,oBAAoB,6BAA6B;;WAE5D,QAAQ,KAAK,mBAAmB,6BAA6B;;WAE7D,SAAS,KAAK,mBAAmB,6BAA6B;;WAE9D,KAAK,8BAA8B;;WAKnC,OAAO,kBAAkB,6BAA6B;;WAEtD,YAAY,KAAK,gBAAgB,QAAQ,UAAU,6BAA6B;;WAEhF,WAAW,KAAK,gBAAgB,QAAQ,UAAU,6BAA6B;;WAE/E,YAAY,iBAAiB,QAAQ,UAAU,6BAA6B;;WAE5E,MAAM,6BAA6B;;;;;WAKnC,QAAQ,GAAG,GAAG,GAAG,MAAM,OAAO,GAAG,GAAG,GAAG,OAAO,eAAe,GAAG,GAAG;;WAKnE,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,eAAe,6BAA6B;;WAE5C,eAAe,6BAA6B;;WAE5C,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,aAAa,6BAA6B;;WAE1C,aAAa,6BAA6B;;;;;WAK1C,YAAY,6BAA6B;;WAKzC,SAAS,2BAA2B;;WAEpC,MAAM,6BAA6B;;WAEnC,KAAK,2BAA2B;;WAEhC,YAAY,oCAAoC;;WAEhD,gBAAgB,6BAA6B;;WAK7C,SAAS,8BAA8B;;WAEvC,QAAQ,8BAA8B;;WAEtC,YAAY,6BAA6B;;WAEzC,WAAW,6BAA6B;;WAExC,SAAS,8BAA8B;;WAEvC,OAAO,6BAA6B;;;;;WAQpC,cAAc,GAAG,GAAG,GAAG,GAAG,IAAI,IACrC,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,iBACA,WAAW,OAAO,GAAG,IAAI,IAAI,OAC1B,eAAe,IAAI,IAAI,IAAI,IAAI;;;;;WAK3B,UAAU,GAAG,GAAG,IAAI,IAC3B,QAAQ,eAAe,GAAG,GAAG,IAC7B,iBACA,QAAQ,eAAe,IAAI,IAAI,OAC5B,eAAe,IAAI,IAAI,IAAI,IAAI;;;;;;;;;;;;;;;;qBAyCzB,OAAQ,mBAAmB,YAAY,UAAU,SAAS,OAAK,YAAY;;;;;;;qBAwZ3E,QAAQ;;;;;;;;;;;;;;;;qBAiBR,MAAM,YAAY;;;;;;;qBAQlB,SAAS,YAAY;;;;;;;qBAQrB,SAAS,YAAY;;;;;;;qBAQrB,QAAQ,YAAY"}
+{"version":3,"file":"Text.d.ts","names":[],"sources":["../src/Text.ts"],"mappings":";;;;;;;;;;YAiEY,iBAAiB;;;;;;;;;;;;;;;;;qBAsChB,WAAY,iBAAe;;;;;;;;qBAS3B,cAAc;;;;;;;qBAQd,UAAU;;;;;;;qBAQV,aAAa;;;;;;;qBAQb,aAAa;;;;;;;;qBASb,gBAAgB;;;;;;;;qBAShB,WAAW;;;;;;;qBAQX,gBAAgB;;;;;;;;qBAShB,cAAc;;;;;;;;qBASd,SAAS;;;;;;;;qBAYT,WAAW;;;;;;;;qBASX,cAAc;;;;;;;qBAQd,eAAe;;;;;;;qBAQf,WAAW;;;;;;;;;;;;iBAiBP,YAAY,mBAAmB;;WAErC,UAAU,SAAS;;WAKnB,KAAK,6BAA6B;;;;;WAKlC,gBAAgB,kBAAkB,SAAS,MAAM,OAAO,iBAAiB;;;;;;WAMzE,WAAW,oBAAoB,6BAA6B;;WAE5D,QAAQ,KAAK,mBAAmB,6BAA6B;;WAE7D,SAAS,KAAK,mBAAmB,6BAA6B;;WAE9D,KAAK,8BAA8B;;WAKnC,OAAO,kBAAkB,6BAA6B;;WAEtD,YAAY,KAAK,gBAAgB,QAAQ,UAAU,6BAA6B;;WAEhF,WAAW,KAAK,gBAAgB,QAAQ,UAAU,6BAA6B;;WAE/E,YAAY,iBAAiB,QAAQ,UAAU,6BAA6B;;WAE5E,MAAM,6BAA6B;;;;;WAKnC,QAAQ,GAAG,GAAG,GAAG,MAAM,OAAO,GAAG,GAAG,GAAG,OAAO,eAAe,GAAG,GAAG;;WAKnE,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,eAAe,6BAA6B;;WAE5C,eAAe,6BAA6B;;WAE5C,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,aAAa,6BAA6B;;WAE1C,aAAa,6BAA6B;;;;;WAK1C,YAAY,6BAA6B;;WAKzC,SAAS,2BAA2B;;WAEpC,MAAM,6BAA6B;;WAEnC,KAAK,2BAA2B;;WAEhC,YAAY,oCAAoC;;WAEhD,gBAAgB,6BAA6B;;WAK7C,SAAS,8BAA8B;;WAEvC,QAAQ,8BAA8B;;WAEtC,YAAY,6BAA6B;;WAEzC,WAAW,6BAA6B;;WAExC,SAAS,8BAA8B;;WAEvC,OAAO,6BAA6B;;;;;WAQpC,cAAc,GAAG,GAAG,GAAG,GAAG,IAAI,IACrC,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,iBACA,WAAW,OAAO,GAAG,IAAI,IAAI,OAC1B,eAAe,IAAI,IAAI,IAAI,IAAI;;;;;WAK3B,UAAU,GAAG,GAAG,IAAI,IAC3B,QAAQ,eAAe,GAAG,GAAG,IAC7B,iBACA,QAAQ,eAAe,IAAI,IAAI,OAC5B,eAAe,IAAI,IAAI,IAAI,IAAI;;;;;;;;;;;;;;;;qBAwCzB,OAAQ,mBAAmB,YAAY,UAAU,SAAS,OAAK,YAAY;;;;;;;qBA4Z3E,QAAQ;;;;;;;;;;;;;;;;qBAiBR,MAAM,YAAY;;;;;;;qBAQlB,SAAS,YAAY;;;;;;;qBAQrB,SAAS,YAAY;;;;;;;qBAQrB,QAAQ,YAAY"}