@effectionx/jsonl-store 0.3.1 → 0.4.1

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

@@ -1,123 +0,0 @@
-// 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 _TextDelimiterStream_instances, _TextDelimiterStream_buf, _TextDelimiterStream_delimiter, _TextDelimiterStream_inspectIndex, _TextDelimiterStream_matchIndex, _TextDelimiterStream_delimLPS, _TextDelimiterStream_disp, _TextDelimiterStream_handle;
-import { createLPS } from "./_common.js";
-/**
- * Transform a stream `string` into a stream where each chunk is divided by a
- * given delimiter.
- *
- * If you are working with a stream of `Uint8Array`, consider using {@linkcode DelimiterStream}.
- *
- * If you want to split by a newline, consider using {@linkcode TextLineStream}.
- *
- * @example Comma-separated values
- * ```ts
- * import { TextDelimiterStream } from "@std/streams/text-delimiter-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   "alice,20,",
- *   ",US,",
- * ]);
- *
- * const valueStream = stream.pipeThrough(new TextDelimiterStream(","));
- *
- * assertEquals(
- *   await Array.fromAsync(valueStream),
- *   ["alice", "20", "", "US", ""],
- * );
- * ```
- *
- * @example Semicolon-separated values with suffix disposition
- * ```ts
- * import { TextDelimiterStream } from "@std/streams/text-delimiter-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   "const a = 42;;let b =",
- *   " true;",
- * ]);
- *
- * const valueStream = stream.pipeThrough(
- *   new TextDelimiterStream(";", { disposition: "suffix" }),
- * );
- *
- * assertEquals(
- *   await Array.fromAsync(valueStream),
- *   ["const a = 42;", ";", "let b = true;", ""],
- * );
- * ```
- */
-export class TextDelimiterStream extends TransformStream {
-    /**
-     * Constructs a new instance.
-     *
-     * @param delimiter A delimiter to split the stream by.
-     * @param options Options for the stream.
-     */
-    constructor(delimiter, options) {
-        super({
-            transform: (chunk, controller) => {
-                __classPrivateFieldGet(this, _TextDelimiterStream_instances, "m", _TextDelimiterStream_handle).call(this, chunk, controller);
-            },
-            flush: (controller) => {
-                controller.enqueue(__classPrivateFieldGet(this, _TextDelimiterStream_buf, "f"));
-            },
-        });
-        _TextDelimiterStream_instances.add(this);
-        _TextDelimiterStream_buf.set(this, "");
-        _TextDelimiterStream_delimiter.set(this, void 0);
-        _TextDelimiterStream_inspectIndex.set(this, 0);
-        _TextDelimiterStream_matchIndex.set(this, 0);
-        _TextDelimiterStream_delimLPS.set(this, void 0);
-        _TextDelimiterStream_disp.set(this, void 0);
-        __classPrivateFieldSet(this, _TextDelimiterStream_delimiter, delimiter, "f");
-        __classPrivateFieldSet(this, _TextDelimiterStream_delimLPS, createLPS(new TextEncoder().encode(delimiter)), "f");
-        __classPrivateFieldSet(this, _TextDelimiterStream_disp, options?.disposition ?? "discard", "f");
-    }
-}
-_TextDelimiterStream_buf = new WeakMap(), _TextDelimiterStream_delimiter = new WeakMap(), _TextDelimiterStream_inspectIndex = new WeakMap(), _TextDelimiterStream_matchIndex = new WeakMap(), _TextDelimiterStream_delimLPS = new WeakMap(), _TextDelimiterStream_disp = new WeakMap(), _TextDelimiterStream_instances = new WeakSet(), _TextDelimiterStream_handle = function _TextDelimiterStream_handle(chunk, controller) {
-    var _a, _b, _c;
-    __classPrivateFieldSet(this, _TextDelimiterStream_buf, __classPrivateFieldGet(this, _TextDelimiterStream_buf, "f") + chunk, "f");
-    let localIndex = 0;
-    while (__classPrivateFieldGet(this, _TextDelimiterStream_inspectIndex, "f") < __classPrivateFieldGet(this, _TextDelimiterStream_buf, "f").length) {
-        if (chunk[localIndex] === __classPrivateFieldGet(this, _TextDelimiterStream_delimiter, "f")[__classPrivateFieldGet(this, _TextDelimiterStream_matchIndex, "f")]) {
-            __classPrivateFieldSet(this, _TextDelimiterStream_inspectIndex, (_a = __classPrivateFieldGet(this, _TextDelimiterStream_inspectIndex, "f"), _a++, _a), "f");
-            localIndex++;
-            __classPrivateFieldSet(this, _TextDelimiterStream_matchIndex, (_b = __classPrivateFieldGet(this, _TextDelimiterStream_matchIndex, "f"), _b++, _b), "f");
-            if (__classPrivateFieldGet(this, _TextDelimiterStream_matchIndex, "f") === __classPrivateFieldGet(this, _TextDelimiterStream_delimiter, "f").length) {
-                // Full match
-                const start = __classPrivateFieldGet(this, _TextDelimiterStream_inspectIndex, "f") - __classPrivateFieldGet(this, _TextDelimiterStream_delimiter, "f").length;
-                const end = __classPrivateFieldGet(this, _TextDelimiterStream_disp, "f") === "suffix" ? __classPrivateFieldGet(this, _TextDelimiterStream_inspectIndex, "f") : start;
-                const copy = __classPrivateFieldGet(this, _TextDelimiterStream_buf, "f").slice(0, end);
-                controller.enqueue(copy);
-                const shift = __classPrivateFieldGet(this, _TextDelimiterStream_disp, "f") === "prefix" ? start : __classPrivateFieldGet(this, _TextDelimiterStream_inspectIndex, "f");
-                __classPrivateFieldSet(this, _TextDelimiterStream_buf, __classPrivateFieldGet(this, _TextDelimiterStream_buf, "f").slice(shift), "f");
-                __classPrivateFieldSet(this, _TextDelimiterStream_inspectIndex, __classPrivateFieldGet(this, _TextDelimiterStream_disp, "f") === "prefix"
-                    ? __classPrivateFieldGet(this, _TextDelimiterStream_delimiter, "f").length
-                    : 0, "f");
-                __classPrivateFieldSet(this, _TextDelimiterStream_matchIndex, 0, "f");
-            }
-        }
-        else {
-            if (__classPrivateFieldGet(this, _TextDelimiterStream_matchIndex, "f") === 0) {
-                __classPrivateFieldSet(this, _TextDelimiterStream_inspectIndex, (_c = __classPrivateFieldGet(this, _TextDelimiterStream_inspectIndex, "f"), _c++, _c), "f");
-                localIndex++;
-            }
-            else {
-                __classPrivateFieldSet(this, _TextDelimiterStream_matchIndex, __classPrivateFieldGet(this, _TextDelimiterStream_delimLPS, "f")[__classPrivateFieldGet(this, _TextDelimiterStream_matchIndex, "f") - 1], "f");
-            }
-        }
-    }
-};

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

@@ -1,72 +0,0 @@
-/** Options for {@linkcode TextLineStream}. */
-export interface TextLineStreamOptions {
-    /**
-     * Allow splitting by `\r`.
-     *
-     * @default {false}
-     */
-    allowCR?: boolean;
-}
-/**
- * Transform a stream into a stream where each chunk is divided by a newline,
- * be it `\n` or `\r\n`. `\r` can be enabled via the `allowCR` option.
- *
- * If you want to split by a custom delimiter, consider using {@linkcode TextDelimiterStream}.
- *
- * @example JSON Lines
- * ```ts
- * import { TextLineStream } from "@std/streams/text-line-stream";
- * import { toTransformStream } from "@std/streams/to-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   '{"name": "Alice", "age": ',
- *   '30}\n{"name": "Bob", "age"',
- *   ": 25}\n",
- * ]);
- *
- * type Person = { name: string; age: number };
- *
- * // Split the stream by newline and parse each line as a JSON object
- * const jsonStream = stream.pipeThrough(new TextLineStream())
- *   .pipeThrough(toTransformStream(async function* (src) {
- *     for await (const chunk of src) {
- *       if (chunk.trim().length === 0) {
- *         continue;
- *       }
- *       yield JSON.parse(chunk) as Person;
- *     }
- *   }));
- *
- * assertEquals(
- *   await Array.fromAsync(jsonStream),
- *   [{ "name": "Alice", "age": 30 }, { "name": "Bob", "age": 25 }],
- * );
- * ```
- *
- * @example Allow splitting by `\r`
- *
- * ```ts
- * import { TextLineStream } from "@std/streams/text-line-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *  "CR\rLF",
- *  "\nCRLF\r\ndone",
- * ]).pipeThrough(new TextLineStream({ allowCR: true }));
- *
- * const lines = await Array.fromAsync(stream);
- *
- * assertEquals(lines, ["CR", "LF", "CRLF", "done"]);
- * ```
- */
-export declare class TextLineStream extends TransformStream<string, string> {
-    #private;
-    /**
-     * Constructs a new instance.
-     *
-     * @param options Options for the stream.
-     */
-    constructor(options?: TextLineStreamOptions);
-}
-//# sourceMappingURL=text_line_stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"text_line_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/text_line_stream.ts"],"names":[],"mappings":"AAGA,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,qBAAa,cAAe,SAAQ,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC;;IAGjE;;;;OAIG;gBACS,OAAO,GAAE,qBAA0C;CAoChE"}

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

@@ -1,107 +0,0 @@
-// 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 _TextLineStream_currentLine;
-/**
- * Transform a stream into a stream where each chunk is divided by a newline,
- * be it `\n` or `\r\n`. `\r` can be enabled via the `allowCR` option.
- *
- * If you want to split by a custom delimiter, consider using {@linkcode TextDelimiterStream}.
- *
- * @example JSON Lines
- * ```ts
- * import { TextLineStream } from "@std/streams/text-line-stream";
- * import { toTransformStream } from "@std/streams/to-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   '{"name": "Alice", "age": ',
- *   '30}\n{"name": "Bob", "age"',
- *   ": 25}\n",
- * ]);
- *
- * type Person = { name: string; age: number };
- *
- * // Split the stream by newline and parse each line as a JSON object
- * const jsonStream = stream.pipeThrough(new TextLineStream())
- *   .pipeThrough(toTransformStream(async function* (src) {
- *     for await (const chunk of src) {
- *       if (chunk.trim().length === 0) {
- *         continue;
- *       }
- *       yield JSON.parse(chunk) as Person;
- *     }
- *   }));
- *
- * assertEquals(
- *   await Array.fromAsync(jsonStream),
- *   [{ "name": "Alice", "age": 30 }, { "name": "Bob", "age": 25 }],
- * );
- * ```
- *
- * @example Allow splitting by `\r`
- *
- * ```ts
- * import { TextLineStream } from "@std/streams/text-line-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *  "CR\rLF",
- *  "\nCRLF\r\ndone",
- * ]).pipeThrough(new TextLineStream({ allowCR: true }));
- *
- * const lines = await Array.fromAsync(stream);
- *
- * assertEquals(lines, ["CR", "LF", "CRLF", "done"]);
- * ```
- */
-export class TextLineStream extends TransformStream {
-    /**
-     * Constructs a new instance.
-     *
-     * @param options Options for the stream.
-     */
-    constructor(options = { allowCR: false }) {
-        super({
-            transform: (chars, controller) => {
-                chars = __classPrivateFieldGet(this, _TextLineStream_currentLine, "f") + chars;
-                while (true) {
-                    const lfIndex = chars.indexOf("\n");
-                    const crIndex = options.allowCR ? chars.indexOf("\r") : -1;
-                    if (crIndex !== -1 && crIndex !== (chars.length - 1) &&
-                        (lfIndex === -1 || (lfIndex - 1) > crIndex)) {
-                        controller.enqueue(chars.slice(0, crIndex));
-                        chars = chars.slice(crIndex + 1);
-                        continue;
-                    }
-                    if (lfIndex === -1)
-                        break;
-                    const endIndex = chars[lfIndex - 1] === "\r" ? lfIndex - 1 : lfIndex;
-                    controller.enqueue(chars.slice(0, endIndex));
-                    chars = chars.slice(lfIndex + 1);
-                }
-                __classPrivateFieldSet(this, _TextLineStream_currentLine, chars, "f");
-            },
-            flush: (controller) => {
-                if (__classPrivateFieldGet(this, _TextLineStream_currentLine, "f") === "")
-                    return;
-                const currentLine = options.allowCR && __classPrivateFieldGet(this, _TextLineStream_currentLine, "f").endsWith("\r")
-                    ? __classPrivateFieldGet(this, _TextLineStream_currentLine, "f").slice(0, -1)
-                    : __classPrivateFieldGet(this, _TextLineStream_currentLine, "f");
-                controller.enqueue(currentLine);
-            },
-        });
-        _TextLineStream_currentLine.set(this, "");
-    }
-}
-_TextLineStream_currentLine = new WeakMap();

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

@@ -1,22 +0,0 @@
-/**
- * Converts a {@linkcode ReadableStream} of {@linkcode Uint8Array}s to an
- * {@linkcode ArrayBuffer}. Works the same as {@linkcode Response.arrayBuffer}.
- *
- * @param readableStream A `ReadableStream` of `Uint8Array`s to convert into an `ArrayBuffer`.
- * @returns A promise that resolves with the `ArrayBuffer` containing all the data from the stream.
- *
- * @example Basic usage
- * ```ts
- * import { toArrayBuffer } from "@std/streams/to-array-buffer";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   new Uint8Array([1, 2]),
- *   new Uint8Array([3, 4, 5]),
- * ]);
- * const buf = await toArrayBuffer(stream);
- * assertEquals(buf.byteLength, 5);
- * ```
- */
-export declare function toArrayBuffer(readableStream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
-//# sourceMappingURL=to_array_buffer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to_array_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/to_array_buffer.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,aAAa,CACjC,cAAc,EAAE,cAAc,CAAC,UAAU,CAAC,GACzC,OAAO,CAAC,WAAW,CAAC,CAetB"}

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

@@ -1,35 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { concat } from "../../bytes/1.0.6/concat.js";
-/**
- * Converts a {@linkcode ReadableStream} of {@linkcode Uint8Array}s to an
- * {@linkcode ArrayBuffer}. Works the same as {@linkcode Response.arrayBuffer}.
- *
- * @param readableStream A `ReadableStream` of `Uint8Array`s to convert into an `ArrayBuffer`.
- * @returns A promise that resolves with the `ArrayBuffer` containing all the data from the stream.
- *
- * @example Basic usage
- * ```ts
- * import { toArrayBuffer } from "@std/streams/to-array-buffer";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   new Uint8Array([1, 2]),
- *   new Uint8Array([3, 4, 5]),
- * ]);
- * const buf = await toArrayBuffer(stream);
- * assertEquals(buf.byteLength, 5);
- * ```
- */
-export async function toArrayBuffer(readableStream) {
-    const reader = readableStream.getReader();
-    const chunks = [];
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            break;
-        }
-        chunks.push(value);
-    }
-    return concat(chunks).buffer;
-}

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

@@ -1,22 +0,0 @@
-/**
- * Converts a {@linkcode ReadableStream} of {@linkcode Uint8Array}s to a
- * {@linkcode Blob}. Works the same as {@linkcode Response.blob}.
- *
- * @param stream A `ReadableStream` of `Uint8Array`s to convert into a `Blob`.
- * @returns A `Promise` that resolves to the `Blob`.
- *
- * @example Basic usage
- * ```ts
- * import { toBlob } from "@std/streams/to-blob";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   new Uint8Array([1, 2]),
- *   new Uint8Array([3, 4, 5]),
- * ]);
- * const blob = await toBlob(stream);
- * assertEquals(blob.size, 5);
- * ```
- */
-export declare function toBlob(stream: ReadableStream<Uint8Array>): Promise<Blob>;
-//# sourceMappingURL=to_blob.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to_blob.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/to_blob.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,MAAM,CAC1B,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC,CAEf"}

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

@@ -1,25 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Converts a {@linkcode ReadableStream} of {@linkcode Uint8Array}s to a
- * {@linkcode Blob}. Works the same as {@linkcode Response.blob}.
- *
- * @param stream A `ReadableStream` of `Uint8Array`s to convert into a `Blob`.
- * @returns A `Promise` that resolves to the `Blob`.
- *
- * @example Basic usage
- * ```ts
- * import { toBlob } from "@std/streams/to-blob";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   new Uint8Array([1, 2]),
- *   new Uint8Array([3, 4, 5]),
- * ]);
- * const blob = await toBlob(stream);
- * assertEquals(blob.size, 5);
- * ```
- */
-export async function toBlob(stream) {
-    return await new Response(stream).blob();
-}

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

@@ -1,38 +0,0 @@
-/**
- * Converts a
- * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON}-formatted
- * {@linkcode ReadableSteam} of strings or {@linkcode Uint8Array}s to an object.
- * Works the same as {@linkcode Response.json} and {@linkcode Request.json}, but
- * also extends to support streams of strings.
- *
- * @param stream A `ReadableStream` whose chunks compose a JSON.
- * @returns A promise that resolves to the parsed JSON.
- *
- * @example Usage with a stream of strings
- * ```ts
- * import { toJson } from "@std/streams/to-json";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   "[1, true",
- *   ', [], {}, "hello',
- *   '", null]',
- * ]);
- * assertEquals(await toJson(stream), [1, true, [], {}, "hello", null]);
- * ```
- *
- * @example Usage with a stream of `Uint8Array`s
- * ```ts
- * import { toJson } from "@std/streams/to-json";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   "[1, true",
- *   ', [], {}, "hello',
- *   '", null]',
- * ]).pipeThrough(new TextEncoderStream());
- * assertEquals(await toJson(stream), [1, true, [], {}, "hello", null]);
- * ```
- */
-export declare function toJson(stream: ReadableStream<string> | ReadableStream<Uint8Array>): Promise<unknown>;
-//# sourceMappingURL=to_json.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to_json.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/to_json.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,MAAM,CACpB,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,UAAU,CAAC,GAC1D,OAAO,CAAC,OAAO,CAAC,CAElB"}

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

@@ -1,42 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { toText } from "./to_text.js";
-/**
- * Converts a
- * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON}-formatted
- * {@linkcode ReadableSteam} of strings or {@linkcode Uint8Array}s to an object.
- * Works the same as {@linkcode Response.json} and {@linkcode Request.json}, but
- * also extends to support streams of strings.
- *
- * @param stream A `ReadableStream` whose chunks compose a JSON.
- * @returns A promise that resolves to the parsed JSON.
- *
- * @example Usage with a stream of strings
- * ```ts
- * import { toJson } from "@std/streams/to-json";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   "[1, true",
- *   ', [], {}, "hello',
- *   '", null]',
- * ]);
- * assertEquals(await toJson(stream), [1, true, [], {}, "hello", null]);
- * ```
- *
- * @example Usage with a stream of `Uint8Array`s
- * ```ts
- * import { toJson } from "@std/streams/to-json";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   "[1, true",
- *   ', [], {}, "hello',
- *   '", null]',
- * ]).pipeThrough(new TextEncoderStream());
- * assertEquals(await toJson(stream), [1, true, [], {}, "hello", null]);
- * ```
- */
-export function toJson(stream) {
-    return toText(stream).then(JSON.parse);
-}

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

@@ -1,29 +0,0 @@
-/**
- * Converts a {@linkcode ReadableSteam} of strings or {@linkcode Uint8Array}s
- * to a single string. Works the same as {@linkcode Response.text} and
- * {@linkcode Request.text}, but also extends to support streams of strings.
- *
- * @param stream A `ReadableStream` to convert into a `string`.
- * @returns A `Promise` that resolves to the `string`.
- *
- * @example Basic usage with a stream of strings
- * ```ts
- * import { toText } from "@std/streams/to-text";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["Hello, ", "world!"]);
- * assertEquals(await toText(stream), "Hello, world!");
- * ```
- *
- * @example Basic usage with a stream of `Uint8Array`s
- * ```ts
- * import { toText } from "@std/streams/to-text";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["Hello, ", "world!"])
- *   .pipeThrough(new TextEncoderStream());
- * assertEquals(await toText(stream), "Hello, world!");
- * ```
- */
-export declare function toText(stream: ReadableStream<string> | ReadableStream<Uint8Array>): Promise<string>;
-//# sourceMappingURL=to_text.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to_text.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/to_text.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,MAAM,CAC1B,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,UAAU,CAAC,GAC1D,OAAO,CAAC,MAAM,CAAC,CAkBjB"}

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

@@ -1,45 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Converts a {@linkcode ReadableSteam} of strings or {@linkcode Uint8Array}s
- * to a single string. Works the same as {@linkcode Response.text} and
- * {@linkcode Request.text}, but also extends to support streams of strings.
- *
- * @param stream A `ReadableStream` to convert into a `string`.
- * @returns A `Promise` that resolves to the `string`.
- *
- * @example Basic usage with a stream of strings
- * ```ts
- * import { toText } from "@std/streams/to-text";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["Hello, ", "world!"]);
- * assertEquals(await toText(stream), "Hello, world!");
- * ```
- *
- * @example Basic usage with a stream of `Uint8Array`s
- * ```ts
- * import { toText } from "@std/streams/to-text";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["Hello, ", "world!"])
- *   .pipeThrough(new TextEncoderStream());
- * assertEquals(await toText(stream), "Hello, world!");
- * ```
- */
-export async function toText(stream) {
-    const textDecoder = new TextDecoder();
-    const reader = stream.getReader();
-    let result = "";
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            break;
-        }
-        result += typeof value === "string"
-            ? value
-            : textDecoder.decode(value, { stream: true });
-    }
-    result += textDecoder.decode();
-    return result;
-}

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

@@ -1,61 +0,0 @@
-/**
- * Convert the generator function into a {@linkcode TransformStream}.
- *
- * @typeparam I The type of the chunks in the source stream.
- * @typeparam O The type of the chunks in the transformed stream.
- * @param transformer A function to transform.
- * @param writableStrategy An object that optionally defines a queuing strategy for the stream.
- * @param readableStrategy An object that optionally defines a queuing strategy for the stream.
- * @returns A {@linkcode TransformStream} that transforms the source stream as defined by the provided transformer.
- *
- * @example Build a transform stream that multiplies each value by 100
- * ```ts
- * import { toTransformStream } from "@std/streams/to-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([0, 1, 2])
- *   .pipeThrough(toTransformStream(async function* (src) {
- *     for await (const chunk of src) {
- *       yield chunk * 100;
- *     }
- *   }));
- *
- * assertEquals(
- *   await Array.fromAsync(stream),
- *   [0, 100, 200],
- * );
- * ```
- *
- * @example JSON Lines
- * ```ts
- * import { TextLineStream } from "@std/streams/text-line-stream";
- * import { toTransformStream } from "@std/streams/to-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   '{"name": "Alice", "age": ',
- *   '30}\n{"name": "Bob", "age"',
- *   ": 25}\n",
- * ]);
- *
- * type Person = { name: string; age: number };
- *
- * // Split the stream by newline and parse each line as a JSON object
- * const jsonStream = stream.pipeThrough(new TextLineStream())
- *   .pipeThrough(toTransformStream(async function* (src) {
- *     for await (const chunk of src) {
- *       if (chunk.trim().length === 0) {
- *         continue;
- *       }
- *       yield JSON.parse(chunk) as Person;
- *     }
- *   }));
- *
- * assertEquals(
- *   await Array.fromAsync(jsonStream),
- *   [{ "name": "Alice", "age": 30 }, { "name": "Bob", "age": 25 }],
- * );
- * ```
- */
-export declare function toTransformStream<I, O>(transformer: (src: ReadableStream<I>) => Iterable<O> | AsyncIterable<O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
-//# sourceMappingURL=to_transform_stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to_transform_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/to_transform_stream.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EACpC,WAAW,EAAE,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EACvE,gBAAgB,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,EACrC,gBAAgB,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GACpC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CA2CvB"}