@effectionx/jsonl-store 0.2.0 → 0.3.1

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_file_url.js

@@ -0,0 +1,34 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { encodeWhitespace } from "../_common/to_file_url.js";
+import { isAbsolute } from "./is_absolute.js";
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "@std/path/windows/to-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * ```
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+export function toFileUrl(path) {
+    if (!isAbsolute(path)) {
+        throw new TypeError(`Path must be absolute: received "${path}"`);
+    }
+    const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
+    const url = new URL("file:///");
+    url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
+    if (hostname !== undefined && hostname !== "localhost") {
+        url.hostname = hostname;
+        if (!url.hostname) {
+            throw new TypeError(`Invalid hostname: "${url.hostname}"`);
+        }
+    }
+    return url;
+}

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_namespaced_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_namespaced_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.3/windows/to_namespaced_path.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgCrD"}

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_namespaced_path.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK, } from "../_common/constants.js";
+import { isWindowsDeviceRoot } from "./_util.js";
+import { resolve } from "./resolve.js";
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+export function toNamespacedPath(path) {
+    // Note: this will *probably* throw somewhere.
+    if (typeof path !== "string")
+        return path;
+    if (path.length === 0)
+        return "";
+    const resolvedPath = resolve(path);
+    if (resolvedPath.length >= 3) {
+        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
+            // Possible UNC root
+            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
+                const code = resolvedPath.charCodeAt(2);
+                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
+                    // Matched non-long UNC root, convert the path to a long UNC path
+                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
+            // Possible device root
+            if (resolvedPath.charCodeAt(1) === CHAR_COLON &&
+                resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
+                // Matched device root, convert the path to a long UNC path
+                return `\\\\?\\${resolvedPath}`;
+            }
+        }
+    }
+    return path;
+}

package/esm/deps/jsr.io/@std/streams/1.0.14/_common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_common.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/_common.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAmBrD"}

package/esm/deps/jsr.io/@std/streams/1.0.14/_common.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export const DEFAULT_CHUNK_SIZE = 16_640;
+export const DEFAULT_BUFFER_SIZE = 32 * 1024;
+/** Generate longest proper prefix which is also suffix array. */
+export function createLPS(pat) {
+    const length = pat.length;
+    const lps = new Uint8Array(length);
+    lps[0] = 0;
+    let prefixEnd = 0;
+    let i = 1;
+    while (i < length) {
+        if (pat[i] === pat[prefixEnd]) {
+            prefixEnd++;
+            lps[i] = prefixEnd;
+            i++;
+        }
+        else if (prefixEnd === 0) {
+            lps[i] = 0;
+            i++;
+        }
+        else {
+            prefixEnd = lps[prefixEnd - 1];
+        }
+    }
+    return lps;
+}

package/esm/deps/jsr.io/@std/streams/1.0.14/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/buffer.ts"],"names":[],"mappings":"AAQA,4CAA4C;AAC5C,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,MAAM;;IAqBjB;;;;;;;;;;;;OAYG;IACH,IAAI,QAAQ,IAAI,cAAc,CAAC,UAAU,CAAC,CAEzC;IASD;;;;;;;;;;;;OAYG;IACH,IAAI,QAAQ,IAAI,cAAc,CAAC,UAAU,CAAC,CAEzC;IAED;;;;OAIG;gBACS,EAAE,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,MAAM,CAAC;IAQpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;IACH,KAAK,CAAC,OAAO,GAAE,kBAAmC,GAAG,UAAU;IAK/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,KAAK,IAAI,OAAO;IAIhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAazB;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK;IAoDL;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM;CASf"}

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

@@ -0,0 +1,411 @@
+// Copyright 2018-2025 the Deno authors. 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.6/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);
+            },
+        }));
+        if (ab === undefined) {
+            __classPrivateFieldSet(this, _Buffer_buf, new Uint8Array(0), "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Buffer_buf, 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 RangeError(`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 RangeError(`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 RangeError(`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.14/byte_slice_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte_slice_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/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.14/byte_slice_stream.js

@@ -0,0 +1,85 @@
+// Copyright 2018-2025 the Deno authors. 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.14/concat_readable_streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat_readable_streams.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/concat_readable_streams.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;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.14/concat_readable_streams.js

@@ -0,0 +1,48 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * 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.14/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.14/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"}