@effectionx/jsonl-store 0.1.1 → 0.1.2

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

@@ -1 +0,0 @@
-{"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

@@ -1,291 +0,0 @@
-// 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.5/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

@@ -1,83 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,102 +0,0 @@
-// 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

@@ -1,101 +0,0 @@
-/** 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

@@ -1 +0,0 @@
-{"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"}