@effectionx/jsonl-store 0.1.2 → 0.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"delimiter_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/delimiter_stream.ts"],"names":[],"mappings":"AAMA,2EAA2E;AAC3E,MAAM,MAAM,oBAAoB;AAC9B,4CAA4C;AAC1C,QAAQ;AACV,iDAAiD;GAC/C,QAAQ;AACV,6BAA6B;GAC3B,SAAS,CACZ;AAED,+CAA+C;AAC/C,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,eAAgB,SAAQ,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC;;IAO1E;;;;;OAKG;gBAED,SAAS,EAAE,UAAU,EACrB,OAAO,GAAE,sBAA2B;CAkOvC"}

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

@@ -0,0 +1,291 @@
+// 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 _DelimiterStream_instances, _DelimiterStream_bufs, _DelimiterStream_delimiter, _DelimiterStream_matchIndex, _DelimiterStream_delimLPS, _DelimiterStream_disp, _DelimiterStream_handle, _DelimiterStream_handleChar, _DelimiterStream_flush;
+import { concat } from "../../bytes/1.0.6/concat.js";
+import { createLPS } from "./_common.js";
+/**
+ * Divide a stream into chunks delimited by a given byte sequence.
+ *
+ * If you are working with a stream of `string`, consider using {@linkcode TextDelimiterStream}.
+ *
+ * @example
+ * Divide a CSV stream by commas, discarding the commas:
+ * ```ts
+ * import { DelimiterStream } from "@std/streams/delimiter-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inputStream = ReadableStream.from(["foo,bar", ",baz"]);
+ *
+ * const transformed = inputStream.pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(new DelimiterStream(new TextEncoder().encode(",")))
+ *   .pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await Array.fromAsync(transformed), ["foo", "bar", "baz"]);
+ * ```
+ *
+ * @example
+ * Divide a stream after semi-colons, keeping the semicolons in the output:
+ * ```ts
+ * import { DelimiterStream } from "@std/streams/delimiter-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inputStream = ReadableStream.from(["foo;", "bar;baz", ";"]);
+ *
+ * const transformed = inputStream.pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(
+ *     new DelimiterStream(new TextEncoder().encode(";"), {
+ *       disposition: "suffix",
+ *     }),
+ *   ).pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await Array.fromAsync(transformed), ["foo;", "bar;", "baz;"]);
+ * ```
+ */
+export class DelimiterStream extends TransformStream {
+    /**
+     * Constructs a new instance.
+     *
+     * @param delimiter A delimiter to split the stream by.
+     * @param options Options for the delimiter stream.
+     */
+    constructor(delimiter, options = {}) {
+        super({
+            transform: (chunk, controller) => delimiter.length === 1
+                ? __classPrivateFieldGet(this, _DelimiterStream_instances, "m", _DelimiterStream_handleChar).call(this, chunk, controller)
+                : __classPrivateFieldGet(this, _DelimiterStream_instances, "m", _DelimiterStream_handle).call(this, chunk, controller),
+            flush: (controller) => __classPrivateFieldGet(this, _DelimiterStream_instances, "m", _DelimiterStream_flush).call(this, controller),
+        });
+        _DelimiterStream_instances.add(this);
+        _DelimiterStream_bufs.set(this, []);
+        _DelimiterStream_delimiter.set(this, void 0);
+        _DelimiterStream_matchIndex.set(this, 0);
+        _DelimiterStream_delimLPS.set(this, void 0);
+        _DelimiterStream_disp.set(this, void 0);
+        __classPrivateFieldSet(this, _DelimiterStream_delimiter, delimiter, "f");
+        __classPrivateFieldSet(this, _DelimiterStream_delimLPS, delimiter.length > 1 ? createLPS(delimiter) : null, "f");
+        __classPrivateFieldSet(this, _DelimiterStream_disp, options.disposition ?? "discard", "f");
+    }
+}
+_DelimiterStream_bufs = new WeakMap(), _DelimiterStream_delimiter = new WeakMap(), _DelimiterStream_matchIndex = new WeakMap(), _DelimiterStream_delimLPS = new WeakMap(), _DelimiterStream_disp = new WeakMap(), _DelimiterStream_instances = new WeakSet(), _DelimiterStream_handle = function _DelimiterStream_handle(chunk, controller) {
+    const bufs = __classPrivateFieldGet(this, _DelimiterStream_bufs, "f");
+    const length = chunk.byteLength;
+    const disposition = __classPrivateFieldGet(this, _DelimiterStream_disp, "f");
+    const delimiter = __classPrivateFieldGet(this, _DelimiterStream_delimiter, "f");
+    const delimLen = delimiter.length;
+    const lps = __classPrivateFieldGet(this, _DelimiterStream_delimLPS, "f");
+    let chunkStart = 0;
+    let matchIndex = __classPrivateFieldGet(this, _DelimiterStream_matchIndex, "f");
+    let inspectIndex = 0;
+    while (inspectIndex < length) {
+        if (chunk[inspectIndex] === delimiter[matchIndex]) {
+            // Next byte matched our next delimiter byte
+            inspectIndex++;
+            matchIndex++;
+            if (matchIndex === delimLen) {
+                // Full match
+                matchIndex = 0;
+                const delimiterStartIndex = inspectIndex - delimLen;
+                const delimitedChunkEnd = disposition === "suffix"
+                    ? inspectIndex
+                    : delimiterStartIndex;
+                if (delimitedChunkEnd <= 0 && bufs.length === 0) {
+                    // Our chunk started with a delimiter and no previous chunks exist:
+                    // Enqueue an empty chunk.
+                    controller.enqueue(new Uint8Array());
+                    chunkStart = disposition === "prefix" ? 0 : inspectIndex;
+                }
+                else if (delimitedChunkEnd > 0 && bufs.length === 0) {
+                    // No previous chunks, slice from current chunk.
+                    controller.enqueue(chunk.subarray(chunkStart, delimitedChunkEnd));
+                    // Our chunk may have more than one delimiter; we must remember where
+                    // the next delimited chunk begins.
+                    chunkStart = disposition === "prefix"
+                        ? delimiterStartIndex
+                        : inspectIndex;
+                }
+                else if (delimitedChunkEnd === 0 && bufs.length > 0) {
+                    // Our chunk started with a delimiter, previous chunks are passed as
+                    // they are (with concatenation).
+                    if (bufs.length === 1) {
+                        // Concat not needed when a single buffer is passed.
+                        controller.enqueue(bufs[0]);
+                    }
+                    else {
+                        controller.enqueue(concat(bufs));
+                    }
+                    // Drop all previous chunks.
+                    bufs.length = 0;
+                    if (disposition !== "prefix") {
+                        // suffix or discard: The next chunk starts where our inspection finished.
+                        // We should only ever end up here with a discard disposition as
+                        // for a suffix disposition this branch would mean that the previous
+                        // chunk ended with a full match but was not enqueued.
+                        chunkStart = inspectIndex;
+                    }
+                    else {
+                        chunkStart = 0;
+                    }
+                }
+                else if (delimitedChunkEnd < 0 && bufs.length > 0) {
+                    // Our chunk started by finishing a partial delimiter match.
+                    const lastIndex = bufs.length - 1;
+                    const last = bufs[lastIndex];
+                    const lastSliceIndex = last.byteLength + delimitedChunkEnd;
+                    const lastSliced = last.subarray(0, lastSliceIndex);
+                    if (lastIndex === 0) {
+                        controller.enqueue(lastSliced);
+                    }
+                    else {
+                        bufs[lastIndex] = lastSliced;
+                        controller.enqueue(concat(bufs));
+                    }
+                    bufs.length = 0;
+                    if (disposition === "prefix") {
+                        // Must keep last bytes of last chunk.
+                        bufs.push(last.subarray(lastSliceIndex));
+                        chunkStart = 0;
+                    }
+                    else {
+                        chunkStart = inspectIndex;
+                    }
+                }
+                else if (delimitedChunkEnd > 0 && bufs.length > 0) {
+                    // Previous chunks and current chunk together form a delimited chunk.
+                    const chunkSliced = chunk.subarray(chunkStart, delimitedChunkEnd);
+                    const result = concat([...bufs, chunkSliced]);
+                    bufs.length = 0;
+                    controller.enqueue(result);
+                    chunkStart = disposition === "prefix"
+                        ? delimitedChunkEnd
+                        : inspectIndex;
+                }
+                else {
+                    throw new Error("This should be unreachable, please file a bug report against Deno at https://github.com/denoland/std/issues");
+                }
+            }
+        }
+        else if (matchIndex === 0) {
+            // No match ongoing, keep going through the buffer.
+            inspectIndex++;
+        }
+        else {
+            // Ongoing match: Degrade to the previous possible match.
+            // eg. If we're looking for 'AAB' and had matched 'AA' previously
+            // but now got a new 'A', then we'll drop down to having matched
+            // just 'A'. The while loop will turn around again and we'll rematch
+            // to 'AA' and proceed onwards to try and match on 'B' again.
+            matchIndex = lps[matchIndex - 1];
+        }
+    }
+    // Save match index.
+    __classPrivateFieldSet(this, _DelimiterStream_matchIndex, matchIndex, "f");
+    if (chunkStart === 0) {
+        bufs.push(chunk);
+    }
+    else if (chunkStart < length) {
+        // If we matched partially somewhere in the middle of our chunk
+        // then the remnants should be pushed into buffers.
+        bufs.push(chunk.subarray(chunkStart));
+    }
+}, _DelimiterStream_handleChar = function _DelimiterStream_handleChar(chunk, controller) {
+    const bufs = __classPrivateFieldGet(this, _DelimiterStream_bufs, "f");
+    const length = chunk.byteLength;
+    const disposition = __classPrivateFieldGet(this, _DelimiterStream_disp, "f");
+    const delimiter = __classPrivateFieldGet(this, _DelimiterStream_delimiter, "f")[0];
+    let chunkStart = 0;
+    let inspectIndex = 0;
+    while (inspectIndex < length) {
+        if (chunk[inspectIndex] === delimiter) {
+            // Next byte matched our next delimiter
+            inspectIndex++;
+            /**
+             * Always non-negative
+             */
+            const delimitedChunkEnd = disposition === "suffix"
+                ? inspectIndex
+                : inspectIndex - 1;
+            if (delimitedChunkEnd === 0 && bufs.length === 0) {
+                // Our chunk started with a delimiter and no previous chunks exist:
+                // Enqueue an empty chunk.
+                controller.enqueue(new Uint8Array());
+                chunkStart = disposition === "prefix" ? 0 : 1;
+            }
+            else if (delimitedChunkEnd > 0 && bufs.length === 0) {
+                // No previous chunks, slice from current chunk.
+                controller.enqueue(chunk.subarray(chunkStart, delimitedChunkEnd));
+                // Our chunk may have more than one delimiter; we must remember where
+                // the next delimited chunk begins.
+                chunkStart = disposition === "prefix"
+                    ? inspectIndex - 1
+                    : inspectIndex;
+            }
+            else if (delimitedChunkEnd === 0 && bufs.length > 0) {
+                // Our chunk started with a delimiter, previous chunks are passed as
+                // they are (with concatenation).
+                if (bufs.length === 1) {
+                    // Concat not needed when a single buffer is passed.
+                    controller.enqueue(bufs[0]);
+                }
+                else {
+                    controller.enqueue(concat(bufs));
+                }
+                // Drop all previous chunks.
+                bufs.length = 0;
+                if (disposition !== "prefix") {
+                    // suffix or discard: The next chunk starts where our inspection finished.
+                    // We should only ever end up here with a discard disposition as
+                    // for a suffix disposition this branch would mean that the previous
+                    // chunk ended with a full match but was not enqueued.
+                    chunkStart = inspectIndex;
+                }
+            }
+            else if (delimitedChunkEnd > 0 && bufs.length > 0) {
+                // Previous chunks and current chunk together form a delimited chunk.
+                const chunkSliced = chunk.subarray(chunkStart, delimitedChunkEnd);
+                const result = concat([...bufs, chunkSliced]);
+                bufs.length = 0;
+                chunkStart = disposition === "prefix"
+                    ? delimitedChunkEnd
+                    : inspectIndex;
+                controller.enqueue(result);
+            }
+            else {
+                throw new Error("This should be unreachable, please file a bug report against Deno at https://github.com/denoland/std/issues");
+            }
+        }
+        else {
+            inspectIndex++;
+        }
+    }
+    if (chunkStart === 0) {
+        bufs.push(chunk);
+    }
+    else if (chunkStart < length) {
+        // If we matched partially somewhere in the middle of our chunk
+        // then the remnants should be pushed into buffers.
+        bufs.push(chunk.subarray(chunkStart));
+    }
+}, _DelimiterStream_flush = function _DelimiterStream_flush(controller) {
+    const bufs = __classPrivateFieldGet(this, _DelimiterStream_bufs, "f");
+    const length = bufs.length;
+    if (length === 0) {
+        controller.enqueue(new Uint8Array());
+    }
+    else if (length === 1) {
+        controller.enqueue(bufs[0]);
+    }
+    else {
+        controller.enqueue(concat(bufs));
+    }
+};

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

@@ -0,0 +1,83 @@
+/**
+ * Merge multiple streams into a single one, taking order into account, and each
+ * stream will wait for a chunk to enqueue before the next stream can append
+ * another chunk.
+ *
+ * If a stream ends before other ones, the others will be cancelled after the
+ * last chunk of said stream is read. See the examples below for more
+ * comprehensible information. If you want to continue reading the other streams
+ * even after one of them ends, use {@linkcode zipReadableStreams}.
+ *
+ * @typeparam T The type of the chunks in the input streams.
+ * @param streams An iterable of `ReadableStream`s to merge.
+ * @returns A `ReadableStream` that will emit the zipped chunks
+ *
+ * @example Zip 2 streams with the same length
+ * ```ts
+ * import { earlyZipReadableStreams } from "@std/streams/early-zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2", "3"]);
+ * const stream2 = ReadableStream.from(["a", "b", "c"]);
+ * const zippedStream = earlyZipReadableStreams(stream1, stream2);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "3", "c"],
+ * );
+ * ```
+ *
+ * @example Zip 2 streams with different length (first one is shorter)
+ * ```ts
+ * import { earlyZipReadableStreams } from "@std/streams/early-zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2"]);
+ * const stream2 = ReadableStream.from(["a", "b", "c", "d"]);
+ * const zippedStream = earlyZipReadableStreams(stream1, stream2);
+ *
+ * // The first stream ends before the second one. When the first stream ends,
+ * // the second one is cancelled and no more data is read or added to the
+ * // zipped stream.
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b"],
+ * );
+ * ```
+ *
+ * @example Zip 2 streams with different length (first one is longer)
+ * ```ts
+ * import { earlyZipReadableStreams } from "@std/streams/early-zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2", "3", "4"]);
+ * const stream2 = ReadableStream.from(["a", "b"]);
+ * const zippedStream = earlyZipReadableStreams(stream1, stream2);
+ *
+ * // The second stream ends before the first one. When the second stream ends,
+ * // the first one is cancelled, but the chunk of "3" is already read so it
+ * // is added to the zipped stream.
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "3"],
+ * );
+ * ```
+ *
+ * @example Zip 3 streams
+ * ```ts
+ * import { earlyZipReadableStreams } from "@std/streams/early-zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1"]);
+ * const stream2 = ReadableStream.from(["a", "b"]);
+ * const stream3 = ReadableStream.from(["A", "B", "C"]);
+ * const zippedStream = earlyZipReadableStreams(stream1, stream2, stream3);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "A"],
+ * );
+ * ```
+ */
+export declare function earlyZipReadableStreams<T>(...streams: ReadableStream<T>[]): ReadableStream<T>;
+//# sourceMappingURL=early_zip_readable_streams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"early_zip_readable_streams.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/early_zip_readable_streams.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,GAAG,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,GAC9B,cAAc,CAAC,CAAC,CAAC,CAsBnB"}

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

@@ -0,0 +1,102 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Merge multiple streams into a single one, taking order into account, and each
+ * stream will wait for a chunk to enqueue before the next stream can append
+ * another chunk.
+ *
+ * If a stream ends before other ones, the others will be cancelled after the
+ * last chunk of said stream is read. See the examples below for more
+ * comprehensible information. If you want to continue reading the other streams
+ * even after one of them ends, use {@linkcode zipReadableStreams}.
+ *
+ * @typeparam T The type of the chunks in the input streams.
+ * @param streams An iterable of `ReadableStream`s to merge.
+ * @returns A `ReadableStream` that will emit the zipped chunks
+ *
+ * @example Zip 2 streams with the same length
+ * ```ts
+ * import { earlyZipReadableStreams } from "@std/streams/early-zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2", "3"]);
+ * const stream2 = ReadableStream.from(["a", "b", "c"]);
+ * const zippedStream = earlyZipReadableStreams(stream1, stream2);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "3", "c"],
+ * );
+ * ```
+ *
+ * @example Zip 2 streams with different length (first one is shorter)
+ * ```ts
+ * import { earlyZipReadableStreams } from "@std/streams/early-zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2"]);
+ * const stream2 = ReadableStream.from(["a", "b", "c", "d"]);
+ * const zippedStream = earlyZipReadableStreams(stream1, stream2);
+ *
+ * // The first stream ends before the second one. When the first stream ends,
+ * // the second one is cancelled and no more data is read or added to the
+ * // zipped stream.
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b"],
+ * );
+ * ```
+ *
+ * @example Zip 2 streams with different length (first one is longer)
+ * ```ts
+ * import { earlyZipReadableStreams } from "@std/streams/early-zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2", "3", "4"]);
+ * const stream2 = ReadableStream.from(["a", "b"]);
+ * const zippedStream = earlyZipReadableStreams(stream1, stream2);
+ *
+ * // The second stream ends before the first one. When the second stream ends,
+ * // the first one is cancelled, but the chunk of "3" is already read so it
+ * // is added to the zipped stream.
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "3"],
+ * );
+ * ```
+ *
+ * @example Zip 3 streams
+ * ```ts
+ * import { earlyZipReadableStreams } from "@std/streams/early-zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1"]);
+ * const stream2 = ReadableStream.from(["a", "b"]);
+ * const stream3 = ReadableStream.from(["A", "B", "C"]);
+ * const zippedStream = earlyZipReadableStreams(stream1, stream2, stream3);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "A"],
+ * );
+ * ```
+ */
+export function earlyZipReadableStreams(...streams) {
+    const readers = streams.map((stream) => stream.getReader());
+    return new ReadableStream({
+        async pull(controller) {
+            for (let i = 0; i < readers.length; ++i) {
+                const { done, value } = await readers[i].read();
+                if (done) {
+                    await Promise.all(readers.map((reader) => reader.cancel(`Stream at index ${i} ended`)));
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+        },
+        async cancel(reason) {
+            await Promise.all(readers.map((reader) => reader.cancel(reason)));
+        },
+    });
+}

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

@@ -0,0 +1,101 @@
+/** Options for {@linkcode LimitedBytesTransformStream}. */
+export interface LimitedBytesTransformStreamOptions {
+    /**
+     * If true, a {@linkcode RangeError} is thrown when queueing the current chunk
+     * would exceed the specified size limit.
+     *
+     * @default {false}
+     */
+    error?: boolean;
+}
+/**
+ * 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 declare class LimitedBytesTransformStream extends TransformStream<Uint8Array, Uint8Array> {
+    #private;
+    /**
+     * Constructs a new instance.
+     *
+     * @param size A size limit in bytes.
+     * @param options Options for the stream.
+     */
+    constructor(size: number, options?: LimitedBytesTransformStreamOptions);
+}
+//# sourceMappingURL=limited_bytes_transform_stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"limited_bytes_transform_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/limited_bytes_transform_stream.ts"],"names":[],"mappings":"AAGA,2DAA2D;AAC3D,MAAM,WAAW,kCAAkC;IACjD;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,qBAAa,2BACX,SAAQ,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC;;IAG/C;;;;;OAKG;gBAED,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,kCAAqD;CAiBjE"}