@effectionx/jsonl-store 0.1.1 → 0.1.2

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

@@ -1,406 +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 _Buffer_instances, _Buffer_buf, _Buffer_off, _Buffer_readable, _Buffer_writable, _Buffer_tryGrowByReslice, _Buffer_reslice, _Buffer_grow;
-import { copy } from "../../bytes/1.0.5/copy.js";
-const MAX_SIZE = 2 ** 32 - 2;
-const DEFAULT_CHUNK_SIZE = 16_640;
-/**
- * A variable-sized buffer of bytes with `readable` and `writable` getters that
- * allows you to work with {@link https://developer.mozilla.org/en-US/docs/Web/API/Streams_API | Web Streams API}.
- *
- * Buffer is almost always used with some I/O like files and sockets. It allows
- * one to buffer up a download from a socket. Buffer grows and shrinks as
- * necessary.
- *
- * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in
- * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a
- * non-standard ArrayBuffer.
- *
- * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of
- * ArrayBuffer.
- *
- * Based on {@link https://golang.org/pkg/bytes/#Buffer | Go Buffer}.
- *
- * @example Buffer input bytes and convert it to a string
- * ```ts
- * import { Buffer } from "@std/streams/buffer";
- * import { toText } from "@std/streams/to-text";
- * import { assert } from "@std/assert";
- * import { assertEquals } from "@std/assert";
- *
- * // Create a new buffer
- * const buf = new Buffer();
- * assertEquals(buf.capacity, 0);
- * assertEquals(buf.length, 0);
- *
- * // Dummy input stream
- * const inputStream = ReadableStream.from([
- *   "hello, ",
- *   "world",
- *   "!",
- * ]);
- *
- * // Pipe the input stream to the buffer
- * await inputStream.pipeThrough(new TextEncoderStream()).pipeTo(buf.writable);
- * assert(buf.capacity > 0);
- * assert(buf.length > 0);
- *
- * // Convert the buffered bytes to a string
- * const result = await toText(buf.readable);
- * assertEquals(result, "hello, world!");
- * assert(buf.empty());
- * ```
- */
-export class Buffer {
-    /**
-     * Getter returning the instance's {@linkcode ReadableStream}.
-     *
-     * @returns A `ReadableStream` of the buffer.
-     *
-     * @example Read the content out of the buffer to stdout
-     * ```ts ignore
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const buf = new Buffer();
-     * await buf.readable.pipeTo(Deno.stdout.writable);
-     * ```
-     */
-    get readable() {
-        return __classPrivateFieldGet(this, _Buffer_readable, "f");
-    }
-    /**
-     * Getter returning the instance's {@linkcode WritableStream}.
-     *
-     * @returns A `WritableStream` of the buffer.
-     *
-     * @example Write the data from stdin to the buffer
-     * ```ts ignore
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const buf = new Buffer();
-     * await Deno.stdin.readable.pipeTo(buf.writable);
-     * ```
-     */
-    get writable() {
-        return __classPrivateFieldGet(this, _Buffer_writable, "f");
-    }
-    /**
-     * Constructs a new instance.
-     *
-     * @param ab An optional buffer to use as the initial buffer.
-     */
-    constructor(ab) {
-        _Buffer_instances.add(this);
-        _Buffer_buf.set(this, void 0); // contents are the bytes buf[off : len(buf)]
-        _Buffer_off.set(this, 0); // read at buf[off], write at buf[buf.byteLength]
-        _Buffer_readable.set(this, new ReadableStream({
-            type: "bytes",
-            pull: (controller) => {
-                const view = new Uint8Array(controller.byobRequest.view.buffer);
-                if (this.empty()) {
-                    // Buffer is empty, reset to recover space.
-                    this.reset();
-                    controller.close();
-                    controller.byobRequest.respond(0);
-                    return;
-                }
-                const nread = copy(__classPrivateFieldGet(this, _Buffer_buf, "f").subarray(__classPrivateFieldGet(this, _Buffer_off, "f")), view);
-                __classPrivateFieldSet(this, _Buffer_off, __classPrivateFieldGet(this, _Buffer_off, "f") + nread, "f");
-                controller.byobRequest.respond(nread);
-            },
-            autoAllocateChunkSize: DEFAULT_CHUNK_SIZE,
-        }));
-        _Buffer_writable.set(this, new WritableStream({
-            write: (chunk) => {
-                const m = __classPrivateFieldGet(this, _Buffer_instances, "m", _Buffer_grow).call(this, chunk.byteLength);
-                copy(chunk, __classPrivateFieldGet(this, _Buffer_buf, "f"), m);
-            },
-        }));
-        __classPrivateFieldSet(this, _Buffer_buf, ab === undefined ? new Uint8Array(0) : new Uint8Array(ab), "f");
-    }
-    /**
-     * Returns a slice holding the unread portion of the buffer.
-     *
-     * The slice is valid for use only until the next buffer modification (that
-     * is, only until the next call to a method that mutates or consumes the
-     * buffer, like reading data out via `readable`, `reset()`, or `truncate()`).
-     *
-     * If `options.copy` is false the slice aliases the buffer content at least
-     * until the next buffer modification, so immediate changes to the slice will
-     * affect the result of future reads. If `options` is not provided,
-     * `options.copy` defaults to `true`.
-     *
-     * @param options Options for the bytes method.
-     * @returns A copy or a slice of the buffer.
-     *
-     * @example Copy the buffer
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { assertNotEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * const copied = buf.bytes();
-     * assertEquals(copied.length, array.length);
-     *
-     * // Modify an element in the original array
-     * array[1] = 99;
-     * assertEquals(copied[0], array[0]);
-     * // The copied buffer is not affected by the modification
-     * assertNotEquals(copied[1], array[1]);
-     * assertEquals(copied[2], array[2]);
-     * ```
-     *
-     * @example Get a slice to the buffer
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * const slice = buf.bytes({ copy: false });
-     * assertEquals(slice.length, array.length);
-     *
-     * // Modify an element in the original array
-     * array[1] = 99;
-     * assertEquals(slice[0], array[0]);
-     * // The slice _is_ affected by the modification
-     * assertEquals(slice[1], array[1]);
-     * assertEquals(slice[2], array[2]);
-     * ```
-     */
-    bytes(options = { copy: true }) {
-        if (options.copy === false)
-            return __classPrivateFieldGet(this, _Buffer_buf, "f").subarray(__classPrivateFieldGet(this, _Buffer_off, "f"));
-        return __classPrivateFieldGet(this, _Buffer_buf, "f").slice(__classPrivateFieldGet(this, _Buffer_off, "f"));
-    }
-    /**
-     * Returns whether the unread portion of the buffer is empty.
-     *
-     * @returns Whether the buffer is empty.
-     *
-     * @example Empty buffer
-     * ```ts
-     * import { assert } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const buf = new Buffer();
-     * assert(buf.empty());
-     * ```
-     *
-     * @example Non-empty buffer
-     * ```ts
-     * import { assert } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([42]);
-     * const buf = new Buffer(array.buffer);
-     * assert(!buf.empty());
-     * ```
-     *
-     * @example Non-empty, but the content was already read
-     * ```ts ignore
-     * import { assert } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([42]);
-     * const buf = new Buffer(array.buffer);
-     * assert(!buf.empty());
-     * // Read the content out of the buffer
-     * await buf.readable.pipeTo(Deno.stdout.writable);
-     * // The buffer is now empty
-     * assert(buf.empty());
-     * ```
-     */
-    empty() {
-        return __classPrivateFieldGet(this, _Buffer_buf, "f").byteLength <= __classPrivateFieldGet(this, _Buffer_off, "f");
-    }
-    /**
-     * A read only number of bytes of the unread portion of the buffer.
-     *
-     * @returns The number of bytes in the unread portion of the buffer.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * assertEquals(buf.length, 3);
-     * ```
-     *
-     * @example Length becomes 0 after the content is read
-     * ```ts ignore
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([42]);
-     * const buf = new Buffer(array.buffer);
-     * assertEquals(buf.length, 1);
-     * // Read the content out of the buffer
-     * await buf.readable.pipeTo(Deno.stdout.writable);
-     * // The length is now 0
-     * assertEquals(buf.length, 0);
-     * ```
-     */
-    get length() {
-        return __classPrivateFieldGet(this, _Buffer_buf, "f").byteLength - __classPrivateFieldGet(this, _Buffer_off, "f");
-    }
-    /**
-     * The read only capacity of the buffer's underlying byte slice, that is,
-     * the total space allocated for the buffer's data.
-     *
-     * @returns The number of allocated bytes for the buffer.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const arrayBuffer = new ArrayBuffer(256);
-     * const buf = new Buffer(arrayBuffer);
-     * assertEquals(buf.capacity, 256);
-     * ```
-     */
-    get capacity() {
-        return __classPrivateFieldGet(this, _Buffer_buf, "f").buffer.byteLength;
-    }
-    /**
-     * Discards all but the first `n` unread bytes from the buffer but
-     * continues to use the same allocated storage. It throws if `n` is
-     * negative or greater than the length of the buffer.
-     *
-     * @param n The number of bytes to keep.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * assertEquals(buf.bytes(), array);
-     *
-     * // Discard all but the first 2 bytes
-     * buf.truncate(2);
-     * assertEquals(buf.bytes(), array.slice(0, 2));
-     * ```
-     */
-    truncate(n) {
-        if (n === 0) {
-            this.reset();
-            return;
-        }
-        if (n < 0 || n > this.length) {
-            throw new Error(`Buffer truncation value "${n}" is not between 0 and ${this.length}`);
-        }
-        __classPrivateFieldGet(this, _Buffer_instances, "m", _Buffer_reslice).call(this, __classPrivateFieldGet(this, _Buffer_off, "f") + n);
-    }
-    /**
-     * Resets to an empty buffer.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assert } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * assert(!buf.empty());
-     *
-     * // Reset
-     * buf.reset();
-     * assert(buf.empty());
-     * ```
-     */
-    reset() {
-        __classPrivateFieldGet(this, _Buffer_instances, "m", _Buffer_reslice).call(this, 0);
-        __classPrivateFieldSet(this, _Buffer_off, 0, "f");
-    }
-    /**
-     * Grows the buffer's capacity, if necessary, to guarantee space for
-     * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to
-     * the buffer without another allocation. If `n` is negative, `.grow()` will
-     * throw. If the buffer can't grow it will throw an error.
-     *
-     * @param n The number of bytes to grow the buffer by.
-     *
-     * Based on Go Lang's
-     * {@link https://golang.org/pkg/bytes/#Buffer.Grow | Buffer.Grow}.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assert } from "@std/assert";
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const buf = new Buffer();
-     * assertEquals(buf.capacity, 0);
-     *
-     * buf.grow(200);
-     * assert(buf.capacity >= 200);
-     * ```
-     */
-    grow(n) {
-        if (n < 0) {
-            throw new Error(`Cannot grow buffer as growth must be positive: received ${n}`);
-        }
-        const m = __classPrivateFieldGet(this, _Buffer_instances, "m", _Buffer_grow).call(this, n);
-        __classPrivateFieldGet(this, _Buffer_instances, "m", _Buffer_reslice).call(this, m);
-    }
-}
-_Buffer_buf = new WeakMap(), _Buffer_off = new WeakMap(), _Buffer_readable = new WeakMap(), _Buffer_writable = new WeakMap(), _Buffer_instances = new WeakSet(), _Buffer_tryGrowByReslice = function _Buffer_tryGrowByReslice(n) {
-    const l = __classPrivateFieldGet(this, _Buffer_buf, "f").byteLength;
-    if (n <= this.capacity - l) {
-        __classPrivateFieldGet(this, _Buffer_instances, "m", _Buffer_reslice).call(this, l + n);
-        return l;
-    }
-    return -1;
-}, _Buffer_reslice = function _Buffer_reslice(len) {
-    __classPrivateFieldSet(this, _Buffer_buf, new Uint8Array(__classPrivateFieldGet(this, _Buffer_buf, "f").buffer, 0, len), "f");
-}, _Buffer_grow = function _Buffer_grow(n) {
-    const m = this.length;
-    // If buffer is empty, reset to recover space.
-    if (m === 0 && __classPrivateFieldGet(this, _Buffer_off, "f") !== 0) {
-        this.reset();
-    }
-    // Fast: Try to grow by means of a reslice.
-    const i = __classPrivateFieldGet(this, _Buffer_instances, "m", _Buffer_tryGrowByReslice).call(this, n);
-    if (i >= 0) {
-        return i;
-    }
-    const c = this.capacity;
-    if (n <= Math.floor(c / 2) - m) {
-        // We can slide things down instead of allocating a new
-        // ArrayBuffer. We only need m+n <= c to slide, but
-        // we instead let capacity get twice as large so we
-        // don't spend all our time copying.
-        copy(__classPrivateFieldGet(this, _Buffer_buf, "f").subarray(__classPrivateFieldGet(this, _Buffer_off, "f")), __classPrivateFieldGet(this, _Buffer_buf, "f"));
-    }
-    else if (c + n > MAX_SIZE) {
-        throw new Error(`The buffer cannot grow beyond the maximum size of ${MAX_SIZE}`);
-    }
-    else {
-        // Not enough space anywhere, we need to allocate.
-        const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));
-        copy(__classPrivateFieldGet(this, _Buffer_buf, "f").subarray(__classPrivateFieldGet(this, _Buffer_off, "f")), buf);
-        __classPrivateFieldSet(this, _Buffer_buf, buf, "f");
-    }
-    // Restore this.#off and len(this.#buf).
-    __classPrivateFieldSet(this, _Buffer_off, 0, "f");
-    __classPrivateFieldGet(this, _Buffer_instances, "m", _Buffer_reslice).call(this, Math.min(m + n, MAX_SIZE));
-    return m;
-};

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

@@ -1,44 +0,0 @@
-/**
- * A transform stream that only transforms from the zero-indexed `start` and
- * `end` bytes (both inclusive).
- *
- * @example Basic usage
- * ```ts
- * import { ByteSliceStream } from "@std/streams/byte-slice-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   new Uint8Array([0, 1]),
- *   new Uint8Array([2, 3, 4]),
- * ]);
- * const slicedStream = stream.pipeThrough(new ByteSliceStream(1, 3));
- *
- * assertEquals(
- *   await Array.fromAsync(slicedStream),
- *  [new Uint8Array([1]), new Uint8Array([2, 3])]
- * );
- * ```
- *
- * @example Get a range of bytes from a fetch response body
- * ```ts
- * import { ByteSliceStream } from "@std/streams/byte-slice-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const response = await fetch("https://example.com");
- * const rangedStream = response.body!
- *   .pipeThrough(new ByteSliceStream(3, 8));
- * const collected = await Array.fromAsync(rangedStream);
- * assertEquals(collected[0]?.length, 6);
- * ```
- */
-export declare class ByteSliceStream extends TransformStream<Uint8Array, Uint8Array> {
-    #private;
-    /**
-     * Constructs a new instance.
-     *
-     * @param start The zero-indexed byte index to start reading from.
-     * @param end The zero-indexed byte index to stop reading at. Inclusive.
-     */
-    constructor(start?: number, end?: number);
-}
-//# sourceMappingURL=byte_slice_stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"byte_slice_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/byte_slice_stream.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,eAAgB,SAAQ,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC;;IAI1E;;;;;OAKG;gBACS,KAAK,SAAI,EAAE,GAAG,GAAE,MAAiB;CA4B9C"}

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

@@ -1,85 +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 _ByteSliceStream_offsetStart, _ByteSliceStream_offsetEnd;
-/**
- * A transform stream that only transforms from the zero-indexed `start` and
- * `end` bytes (both inclusive).
- *
- * @example Basic usage
- * ```ts
- * import { ByteSliceStream } from "@std/streams/byte-slice-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   new Uint8Array([0, 1]),
- *   new Uint8Array([2, 3, 4]),
- * ]);
- * const slicedStream = stream.pipeThrough(new ByteSliceStream(1, 3));
- *
- * assertEquals(
- *   await Array.fromAsync(slicedStream),
- *  [new Uint8Array([1]), new Uint8Array([2, 3])]
- * );
- * ```
- *
- * @example Get a range of bytes from a fetch response body
- * ```ts
- * import { ByteSliceStream } from "@std/streams/byte-slice-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const response = await fetch("https://example.com");
- * const rangedStream = response.body!
- *   .pipeThrough(new ByteSliceStream(3, 8));
- * const collected = await Array.fromAsync(rangedStream);
- * assertEquals(collected[0]?.length, 6);
- * ```
- */
-export class ByteSliceStream extends TransformStream {
-    /**
-     * Constructs a new instance.
-     *
-     * @param start The zero-indexed byte index to start reading from.
-     * @param end The zero-indexed byte index to stop reading at. Inclusive.
-     */
-    constructor(start = 0, end = Infinity) {
-        super({
-            start: () => {
-                if (start < 0) {
-                    throw new RangeError(`Cannot construct ByteSliceStream as start must be >= 0: received ${start}`);
-                }
-                end += 1;
-            },
-            transform: (chunk, controller) => {
-                __classPrivateFieldSet(this, _ByteSliceStream_offsetStart, __classPrivateFieldGet(this, _ByteSliceStream_offsetEnd, "f"), "f");
-                __classPrivateFieldSet(this, _ByteSliceStream_offsetEnd, __classPrivateFieldGet(this, _ByteSliceStream_offsetEnd, "f") + chunk.byteLength, "f");
-                if (__classPrivateFieldGet(this, _ByteSliceStream_offsetEnd, "f") > start) {
-                    if (__classPrivateFieldGet(this, _ByteSliceStream_offsetStart, "f") < start) {
-                        chunk = chunk.slice(start - __classPrivateFieldGet(this, _ByteSliceStream_offsetStart, "f"));
-                    }
-                    if (__classPrivateFieldGet(this, _ByteSliceStream_offsetEnd, "f") >= end) {
-                        chunk = chunk.slice(0, chunk.byteLength - __classPrivateFieldGet(this, _ByteSliceStream_offsetEnd, "f") + end);
-                        controller.enqueue(chunk);
-                        controller.terminate();
-                    }
-                    else {
-                        controller.enqueue(chunk);
-                    }
-                }
-            },
-        });
-        _ByteSliceStream_offsetStart.set(this, 0);
-        _ByteSliceStream_offsetEnd.set(this, 0);
-    }
-}
-_ByteSliceStream_offsetStart = new WeakMap(), _ByteSliceStream_offsetEnd = new WeakMap();

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

@@ -1,27 +0,0 @@
-/**
- * Concatenates multiple `ReadableStream`s into a single ordered
- * `ReadableStream`.
- *
- * Cancelling the resulting stream will cancel all the input streams.
- *
- * @typeParam T The type of the chunks in the streams.
- * @param streams An iterable of `ReadableStream`s to concat.
- * @returns A `ReadableStream` that will emit the concatenated chunks.
- *
- * @example Usage
- * ```ts
- * import { concatReadableStreams } from "@std/streams/concat-readable-streams";
- * import { assertEquals } from "@std/assert";
- *
- * const stream1 = ReadableStream.from([1, 2, 3]);
- * const stream2 = ReadableStream.from([4, 5, 6]);
- * const stream3 = ReadableStream.from([7, 8, 9]);
- *
- * assertEquals(
- *   await Array.fromAsync(concatReadableStreams(stream1, stream2, stream3)),
- *   [1, 2, 3, 4, 5, 6, 7, 8, 9],
- * );
- * ```
- */
-export declare function concatReadableStreams<T>(...streams: ReadableStream<T>[]): ReadableStream<T>;
-//# sourceMappingURL=concat_readable_streams.d.ts.map

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

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

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

@@ -1,47 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-/**
- * Concatenates multiple `ReadableStream`s into a single ordered
- * `ReadableStream`.
- *
- * Cancelling the resulting stream will cancel all the input streams.
- *
- * @typeParam T The type of the chunks in the streams.
- * @param streams An iterable of `ReadableStream`s to concat.
- * @returns A `ReadableStream` that will emit the concatenated chunks.
- *
- * @example Usage
- * ```ts
- * import { concatReadableStreams } from "@std/streams/concat-readable-streams";
- * import { assertEquals } from "@std/assert";
- *
- * const stream1 = ReadableStream.from([1, 2, 3]);
- * const stream2 = ReadableStream.from([4, 5, 6]);
- * const stream3 = ReadableStream.from([7, 8, 9]);
- *
- * assertEquals(
- *   await Array.fromAsync(concatReadableStreams(stream1, stream2, stream3)),
- *   [1, 2, 3, 4, 5, 6, 7, 8, 9],
- * );
- * ```
- */
-export function concatReadableStreams(...streams) {
-    let i = 0;
-    return new ReadableStream({
-        async pull(controller) {
-            const reader = streams[i].getReader();
-            const { done, value } = await reader.read();
-            if (done) {
-                if (streams.length === ++i) {
-                    return controller.close();
-                }
-                return await this.pull(controller);
-            }
-            controller.enqueue(value);
-            reader.releaseLock();
-        },
-        async cancel(reason) {
-            const promises = streams.map((stream) => stream.cancel(reason));
-            await Promise.allSettled(promises);
-        },
-    });
-}

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

@@ -1,66 +0,0 @@
-/** Disposition of the delimiter for {@linkcode DelimiterStreamOptions}. */
-export type DelimiterDisposition = 
-/** Include delimiter in the found chunk. */
-"suffix"
-/** Include delimiter in the subsequent chunk. */
- | "prefix"
-/** Discard the delimiter. */
- | "discard";
-/** Options for {@linkcode DelimiterStream}. */
-export interface DelimiterStreamOptions {
-    /**
-     * Disposition of the delimiter.
-     *
-     * @default {"discard"}
-     */
-    disposition?: DelimiterDisposition;
-}
-/**
- * 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 declare class DelimiterStream extends TransformStream<Uint8Array, Uint8Array> {
-    #private;
-    /**
-     * Constructs a new instance.
-     *
-     * @param delimiter A delimiter to split the stream by.
-     * @param options Options for the delimiter stream.
-     */
-    constructor(delimiter: Uint8Array, options?: DelimiterStreamOptions);
-}
-//# sourceMappingURL=delimiter_stream.d.ts.map