@effectionx/jsonl-store 0.1.2 → 0.3.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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