@effectionx/jsonl-store 0.1.2 → 0.2.0

package/esm/deps/jsr.io/@std/streams/1.0.8/limited_bytes_transform_stream.js

@@ -0,0 +1,122 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _LimitedBytesTransformStream_read;
+/**
+ * A {@linkcode TransformStream} that will only read & enqueue chunks until the
+ * total amount of enqueued data exceeds `size`. The last chunk that would
+ * exceed the limit will NOT be enqueued, in which case a {@linkcode RangeError}
+ * is thrown when `options.error` is set to true, otherwise the stream is just
+ * terminated.
+ *
+ * @example `size` is equal to the total byte length of the chunks
+ * ```ts
+ * import { LimitedBytesTransformStream } from "@std/streams/limited-bytes-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(new TextEncoderStream()).pipeThrough(
+ *   new LimitedBytesTransformStream(8),
+ * ).pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(
+ *   await Array.fromAsync(transformed),
+ *   ["1234", "5678"],
+ * );
+ * ```
+ *
+ * @example `size` is less than the total byte length of the chunks, and at the
+ * boundary of the chunks
+ * ```ts
+ * import { LimitedBytesTransformStream } from "@std/streams/limited-bytes-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(new TextEncoderStream()).pipeThrough(
+ *   // `4` is the boundary of the chunks
+ *   new LimitedBytesTransformStream(4),
+ * ).pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(
+ *   await Array.fromAsync(transformed),
+ *   // The first chunk was read, but the second chunk was not
+ *   ["1234"],
+ * );
+ * ```
+ *
+ * @example `size` is less than the total byte length of the chunks, and not at
+ * the boundary of the chunks
+ * ```ts
+ * import { LimitedBytesTransformStream } from "@std/streams/limited-bytes-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(new TextEncoderStream()).pipeThrough(
+ *   // `5` is not the boundary of the chunks
+ *   new LimitedBytesTransformStream(5),
+ * ).pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(
+ *   await Array.fromAsync(transformed),
+ *   // The second chunk was not read because it would exceed the specified size
+ *   ["1234"],
+ * );
+ * ```
+ *
+ * @example Throw error when the total byte length of the chunks exceeds the
+ * specified size
+ *
+ * To do so, set `options.error` to `true`.
+ *
+ * ```ts
+ * import { LimitedBytesTransformStream } from "@std/streams/limited-bytes-transform-stream";
+ * import { assertRejects } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(new TextEncoderStream()).pipeThrough(
+ *   new LimitedBytesTransformStream(5, { error: true }),
+ * ).pipeThrough(new TextDecoderStream());
+ *
+ * await assertRejects(async () => {
+ *   await Array.fromAsync(transformed);
+ * }, RangeError);
+ * ```
+ */
+export class LimitedBytesTransformStream extends TransformStream {
+    /**
+     * Constructs a new instance.
+     *
+     * @param size A size limit in bytes.
+     * @param options Options for the stream.
+     */
+    constructor(size, options = { error: false }) {
+        super({
+            transform: (chunk, controller) => {
+                if ((__classPrivateFieldGet(this, _LimitedBytesTransformStream_read, "f") + chunk.byteLength) > size) {
+                    if (options.error) {
+                        throw new RangeError(`Exceeded byte size limit of '${size}'`);
+                    }
+                    else {
+                        controller.terminate();
+                    }
+                }
+                else {
+                    __classPrivateFieldSet(this, _LimitedBytesTransformStream_read, __classPrivateFieldGet(this, _LimitedBytesTransformStream_read, "f") + chunk.byteLength, "f");
+                    controller.enqueue(chunk);
+                }
+            },
+        });
+        _LimitedBytesTransformStream_read.set(this, 0);
+    }
+}
+_LimitedBytesTransformStream_read = new WeakMap();

package/esm/deps/jsr.io/@std/streams/1.0.8/limited_transform_stream.d.ts

@@ -0,0 +1,84 @@
+/** Options for {@linkcode LimitedTransformStream} */
+export interface LimitedTransformStreamOptions {
+    /**
+     * If true, a {@linkcode RangeError} is thrown when the total number of
+     * enqueued chunks is about to exceed the specified limit.
+     *
+     * @default {false}
+     */
+    error?: boolean;
+}
+/**
+ * A {@linkcode TransformStream} that will only read & enqueue `size` amount of
+ * chunks.
+ *
+ * If `options.error` is set, then instead of terminating the stream,
+ * a {@linkcode RangeError} will be thrown when the total number of enqueued
+ * chunks is about to exceed the specified size.
+ *
+ * @typeparam T The type the chunks in the stream.
+ *
+ * @example `size` is equal to the total number of chunks
+ * ```ts
+ * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(
+ *   new LimitedTransformStream(2),
+ * );
+ *
+ * // All chunks were read
+ * assertEquals(
+ *   await Array.fromAsync(transformed),
+ *   ["1234", "5678"],
+ * );
+ * ```
+ *
+ * @example `size` is less than the total number of chunks
+ * ```ts
+ * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(
+ *   new LimitedTransformStream(1),
+ * );
+ *
+ * // Only the first chunk was read
+ * assertEquals(
+ *   await Array.fromAsync(transformed),
+ *   ["1234"],
+ * );
+ * ```
+ *
+ * @example Throw a {@linkcode RangeError} when the total number of chunks is
+ * about to exceed the specified limit
+ *
+ * Do this by setting `options.error` to `true`.
+ *
+ * ```ts
+ * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
+ * import { assertRejects } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(
+ *   new LimitedTransformStream(1, { error: true }),
+ * );
+ *
+ * await assertRejects(async () => {
+ *   await Array.fromAsync(transformed);
+ * }, RangeError);
+ * ```
+ */
+export declare class LimitedTransformStream<T> extends TransformStream<T, T> {
+    #private;
+    /**
+     * Constructs a new instance.
+     *
+     * @param size The maximum number of chunks to read.
+     * @param options Options for the stream.
+     */
+    constructor(size: number, options?: LimitedTransformStreamOptions);
+}
+//# sourceMappingURL=limited_transform_stream.d.ts.map

package/esm/deps/jsr.io/@std/streams/1.0.8/limited_transform_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limited_transform_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/limited_transform_stream.ts"],"names":[],"mappings":"AAGA,qDAAqD;AACrD,MAAM,WAAW,6BAA6B;IAC5C;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,qBAAa,sBAAsB,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;;IAGlE;;;;;OAKG;gBAED,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,6BAAgD;CAiB5D"}

package/esm/deps/jsr.io/@std/streams/1.0.8/limited_transform_stream.js

@@ -0,0 +1,106 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _LimitedTransformStream_read;
+/**
+ * A {@linkcode TransformStream} that will only read & enqueue `size` amount of
+ * chunks.
+ *
+ * If `options.error` is set, then instead of terminating the stream,
+ * a {@linkcode RangeError} will be thrown when the total number of enqueued
+ * chunks is about to exceed the specified size.
+ *
+ * @typeparam T The type the chunks in the stream.
+ *
+ * @example `size` is equal to the total number of chunks
+ * ```ts
+ * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(
+ *   new LimitedTransformStream(2),
+ * );
+ *
+ * // All chunks were read
+ * assertEquals(
+ *   await Array.fromAsync(transformed),
+ *   ["1234", "5678"],
+ * );
+ * ```
+ *
+ * @example `size` is less than the total number of chunks
+ * ```ts
+ * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(
+ *   new LimitedTransformStream(1),
+ * );
+ *
+ * // Only the first chunk was read
+ * assertEquals(
+ *   await Array.fromAsync(transformed),
+ *   ["1234"],
+ * );
+ * ```
+ *
+ * @example Throw a {@linkcode RangeError} when the total number of chunks is
+ * about to exceed the specified limit
+ *
+ * Do this by setting `options.error` to `true`.
+ *
+ * ```ts
+ * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
+ * import { assertRejects } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["1234", "5678"]);
+ * const transformed = stream.pipeThrough(
+ *   new LimitedTransformStream(1, { error: true }),
+ * );
+ *
+ * await assertRejects(async () => {
+ *   await Array.fromAsync(transformed);
+ * }, RangeError);
+ * ```
+ */
+export class LimitedTransformStream extends TransformStream {
+    /**
+     * Constructs a new instance.
+     *
+     * @param size The maximum number of chunks to read.
+     * @param options Options for the stream.
+     */
+    constructor(size, options = { error: false }) {
+        super({
+            transform: (chunk, controller) => {
+                var _a;
+                if ((__classPrivateFieldGet(this, _LimitedTransformStream_read, "f") + 1) > size) {
+                    if (options.error) {
+                        throw new RangeError(`Exceeded chunk limit of '${size}'`);
+                    }
+                    else {
+                        controller.terminate();
+                    }
+                }
+                else {
+                    __classPrivateFieldSet(this, _LimitedTransformStream_read, (_a = __classPrivateFieldGet(this, _LimitedTransformStream_read, "f"), _a++, _a), "f");
+                    controller.enqueue(chunk);
+                }
+            },
+        });
+        _LimitedTransformStream_read.set(this, 0);
+    }
+}
+_LimitedTransformStream_read = new WeakMap();

package/esm/deps/jsr.io/@std/streams/1.0.8/merge_readable_streams.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Merge multiple streams into a single one, not taking order into account.
+ * If a stream ends before other ones, the other will continue adding data,
+ * and the finished one will not add any more data.
+ *
+ * @typeparam T The type of the chunks in the input/output streams.
+ * @param streams An iterable of `ReadableStream`s to merge.
+ * @returns A `ReadableStream` that will emit the merged chunks.
+ *
+ * @example Merge 2 streams
+ * ```ts
+ * import { mergeReadableStreams } from "@std/streams/merge-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from([1, 2]);
+ * const stream2 = ReadableStream.from([3, 4, 5]);
+ *
+ * const mergedStream = mergeReadableStreams(stream1, stream2);
+ * const merged = await Array.fromAsync(mergedStream);
+ * assertEquals(merged.toSorted(), [1, 2, 3, 4, 5]);
+ * ```
+ *
+ * @example Merge 3 streams
+ * ```ts
+ * import { mergeReadableStreams } from "@std/streams/merge-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from([1, 2]);
+ * const stream2 = ReadableStream.from([3, 4, 5]);
+ * const stream3 = ReadableStream.from([6]);
+ *
+ * const mergedStream = mergeReadableStreams(stream1, stream2, stream3);
+ * const merged = await Array.fromAsync(mergedStream);
+ * assertEquals(merged.toSorted(), [1, 2, 3, 4, 5, 6]);
+ * ```
+ */
+export declare function mergeReadableStreams<T>(...streams: ReadableStream<T>[]): ReadableStream<T>;
+//# sourceMappingURL=merge_readable_streams.d.ts.map

package/esm/deps/jsr.io/@std/streams/1.0.8/merge_readable_streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge_readable_streams.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/merge_readable_streams.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,GAAG,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,GAC9B,cAAc,CAAC,CAAC,CAAC,CA8BnB"}

package/esm/deps/jsr.io/@std/streams/1.0.8/merge_readable_streams.js

@@ -0,0 +1,69 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+/**
+ * Merge multiple streams into a single one, not taking order into account.
+ * If a stream ends before other ones, the other will continue adding data,
+ * and the finished one will not add any more data.
+ *
+ * @typeparam T The type of the chunks in the input/output streams.
+ * @param streams An iterable of `ReadableStream`s to merge.
+ * @returns A `ReadableStream` that will emit the merged chunks.
+ *
+ * @example Merge 2 streams
+ * ```ts
+ * import { mergeReadableStreams } from "@std/streams/merge-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from([1, 2]);
+ * const stream2 = ReadableStream.from([3, 4, 5]);
+ *
+ * const mergedStream = mergeReadableStreams(stream1, stream2);
+ * const merged = await Array.fromAsync(mergedStream);
+ * assertEquals(merged.toSorted(), [1, 2, 3, 4, 5]);
+ * ```
+ *
+ * @example Merge 3 streams
+ * ```ts
+ * import { mergeReadableStreams } from "@std/streams/merge-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from([1, 2]);
+ * const stream2 = ReadableStream.from([3, 4, 5]);
+ * const stream3 = ReadableStream.from([6]);
+ *
+ * const mergedStream = mergeReadableStreams(stream1, stream2, stream3);
+ * const merged = await Array.fromAsync(mergedStream);
+ * assertEquals(merged.toSorted(), [1, 2, 3, 4, 5, 6]);
+ * ```
+ */
+export function mergeReadableStreams(...streams) {
+    const resolvePromises = streams.map(() => Promise.withResolvers());
+    return new ReadableStream({
+        start(controller) {
+            let mustClose = false;
+            Promise.all(resolvePromises.map(({ promise }) => promise))
+                .then(() => {
+                controller.close();
+            })
+                .catch((error) => {
+                mustClose = true;
+                controller.error(error);
+            });
+            for (const [index, stream] of streams.entries()) {
+                (async () => {
+                    try {
+                        for await (const data of stream) {
+                            if (mustClose) {
+                                break;
+                            }
+                            controller.enqueue(data);
+                        }
+                        resolvePromises[index].resolve();
+                    }
+                    catch (error) {
+                        resolvePromises[index].reject(error);
+                    }
+                })();
+            }
+        },
+    });
+}

package/esm/deps/jsr.io/@std/streams/1.0.8/mod.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Utilities for working with the
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/Streams_API | Streams API}.
+ *
+ * Includes buffering and conversion.
+ *
+ * ```ts
+ * import { toText } from "@std/streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["Hello, world!"]);
+ * const text = await toText(stream);
+ *
+ * assertEquals(text, "Hello, world!");
+ * ```
+ *
+ * @module
+ */
+export * from "./buffer.js";
+export * from "./byte_slice_stream.js";
+export * from "./concat_readable_streams.js";
+export * from "./delimiter_stream.js";
+export * from "./early_zip_readable_streams.js";
+export * from "./limited_bytes_transform_stream.js";
+export * from "./limited_transform_stream.js";
+export * from "./merge_readable_streams.js";
+export * from "./text_delimiter_stream.js";
+export * from "./text_line_stream.js";
+export * from "./to_array_buffer.js";
+export * from "./to_blob.js";
+export * from "./to_json.js";
+export * from "./to_text.js";
+export * from "./to_transform_stream.js";
+export * from "./zip_readable_streams.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/streams/1.0.8/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/mod.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC"}

package/esm/deps/jsr.io/@std/streams/1.0.8/mod.js

@@ -0,0 +1,35 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+/**
+ * Utilities for working with the
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/Streams_API | Streams API}.
+ *
+ * Includes buffering and conversion.
+ *
+ * ```ts
+ * import { toText } from "@std/streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from(["Hello, world!"]);
+ * const text = await toText(stream);
+ *
+ * assertEquals(text, "Hello, world!");
+ * ```
+ *
+ * @module
+ */
+export * from "./buffer.js";
+export * from "./byte_slice_stream.js";
+export * from "./concat_readable_streams.js";
+export * from "./delimiter_stream.js";
+export * from "./early_zip_readable_streams.js";
+export * from "./limited_bytes_transform_stream.js";
+export * from "./limited_transform_stream.js";
+export * from "./merge_readable_streams.js";
+export * from "./text_delimiter_stream.js";
+export * from "./text_line_stream.js";
+export * from "./to_array_buffer.js";
+export * from "./to_blob.js";
+export * from "./to_json.js";
+export * from "./to_text.js";
+export * from "./to_transform_stream.js";
+export * from "./zip_readable_streams.js";

package/esm/deps/jsr.io/@std/streams/1.0.8/text_delimiter_stream.d.ts

@@ -0,0 +1,58 @@
+import type { DelimiterStreamOptions } from "./delimiter_stream.js";
+/**
+ * Transform a stream `string` into a stream where each chunk is divided by a
+ * given delimiter.
+ *
+ * If you are working with a stream of `Uint8Array`, consider using {@linkcode DelimiterStream}.
+ *
+ * If you want to split by a newline, consider using {@linkcode TextLineStream}.
+ *
+ * @example Comma-separated values
+ * ```ts
+ * import { TextDelimiterStream } from "@std/streams/text-delimiter-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from([
+ *   "alice,20,",
+ *   ",US,",
+ * ]);
+ *
+ * const valueStream = stream.pipeThrough(new TextDelimiterStream(","));
+ *
+ * assertEquals(
+ *   await Array.fromAsync(valueStream),
+ *   ["alice", "20", "", "US", ""],
+ * );
+ * ```
+ *
+ * @example Semicolon-separated values with suffix disposition
+ * ```ts
+ * import { TextDelimiterStream } from "@std/streams/text-delimiter-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from([
+ *   "const a = 42;;let b =",
+ *   " true;",
+ * ]);
+ *
+ * const valueStream = stream.pipeThrough(
+ *   new TextDelimiterStream(";", { disposition: "suffix" }),
+ * );
+ *
+ * assertEquals(
+ *   await Array.fromAsync(valueStream),
+ *   ["const a = 42;", ";", "let b = true;", ""],
+ * );
+ * ```
+ */
+export declare class TextDelimiterStream extends TransformStream<string, string> {
+    #private;
+    /**
+     * Constructs a new instance.
+     *
+     * @param delimiter A delimiter to split the stream by.
+     * @param options Options for the stream.
+     */
+    constructor(delimiter: string, options?: DelimiterStreamOptions);
+}
+//# sourceMappingURL=text_delimiter_stream.d.ts.map

package/esm/deps/jsr.io/@std/streams/1.0.8/text_delimiter_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text_delimiter_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/text_delimiter_stream.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,qBAAa,mBAAoB,SAAQ,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC;;IAQtE;;;;;OAKG;gBAED,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,sBAAsB;CAkDnC"}