@effectionx/jsonl-store 0.2.0 → 0.3.0

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

@@ -1,69 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-/**
- * Merge multiple streams into a single one, not taking order into account.
- * If a stream ends before other ones, the other will continue adding data,
- * and the finished one will not add any more data.
- *
- * @typeparam T The type of the chunks in the input/output streams.
- * @param streams An iterable of `ReadableStream`s to merge.
- * @returns A `ReadableStream` that will emit the merged chunks.
- *
- * @example Merge 2 streams
- * ```ts
- * import { mergeReadableStreams } from "@std/streams/merge-readable-streams";
- * import { assertEquals } from "@std/assert";
- *
- * const stream1 = ReadableStream.from([1, 2]);
- * const stream2 = ReadableStream.from([3, 4, 5]);
- *
- * const mergedStream = mergeReadableStreams(stream1, stream2);
- * const merged = await Array.fromAsync(mergedStream);
- * assertEquals(merged.toSorted(), [1, 2, 3, 4, 5]);
- * ```
- *
- * @example Merge 3 streams
- * ```ts
- * import { mergeReadableStreams } from "@std/streams/merge-readable-streams";
- * import { assertEquals } from "@std/assert";
- *
- * const stream1 = ReadableStream.from([1, 2]);
- * const stream2 = ReadableStream.from([3, 4, 5]);
- * const stream3 = ReadableStream.from([6]);
- *
- * const mergedStream = mergeReadableStreams(stream1, stream2, stream3);
- * const merged = await Array.fromAsync(mergedStream);
- * assertEquals(merged.toSorted(), [1, 2, 3, 4, 5, 6]);
- * ```
- */
-export function mergeReadableStreams(...streams) {
-    const resolvePromises = streams.map(() => Promise.withResolvers());
-    return new ReadableStream({
-        start(controller) {
-            let mustClose = false;
-            Promise.all(resolvePromises.map(({ promise }) => promise))
-                .then(() => {
-                controller.close();
-            })
-                .catch((error) => {
-                mustClose = true;
-                controller.error(error);
-            });
-            for (const [index, stream] of streams.entries()) {
-                (async () => {
-                    try {
-                        for await (const data of stream) {
-                            if (mustClose) {
-                                break;
-                            }
-                            controller.enqueue(data);
-                        }
-                        resolvePromises[index].resolve();
-                    }
-                    catch (error) {
-                        resolvePromises[index].reject(error);
-                    }
-                })();
-            }
-        },
-    });
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/mod.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC"}

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

@@ -1,35 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-/**
- * Utilities for working with the
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/Streams_API | Streams API}.
- *
- * Includes buffering and conversion.
- *
- * ```ts
- * import { toText } from "@std/streams";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["Hello, world!"]);
- * const text = await toText(stream);
- *
- * assertEquals(text, "Hello, world!");
- * ```
- *
- * @module
- */
-export * from "./buffer.js";
-export * from "./byte_slice_stream.js";
-export * from "./concat_readable_streams.js";
-export * from "./delimiter_stream.js";
-export * from "./early_zip_readable_streams.js";
-export * from "./limited_bytes_transform_stream.js";
-export * from "./limited_transform_stream.js";
-export * from "./merge_readable_streams.js";
-export * from "./text_delimiter_stream.js";
-export * from "./text_line_stream.js";
-export * from "./to_array_buffer.js";
-export * from "./to_blob.js";
-export * from "./to_json.js";
-export * from "./to_text.js";
-export * from "./to_transform_stream.js";
-export * from "./zip_readable_streams.js";

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

@@ -1 +0,0 @@
-{"version":3,"file":"text_delimiter_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/text_delimiter_stream.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,qBAAa,mBAAoB,SAAQ,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC;;IAQtE;;;;;OAKG;gBAED,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,sBAAsB;CAkDnC"}

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

@@ -1,123 +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 _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.8/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.8/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.8/text_line_stream.js

@@ -1,107 +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 _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.8/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.8/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.8/to_array_buffer.js

@@ -1,35 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. 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.8/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.8/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.8/to_blob.js

@@ -1,25 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. 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.8/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.8/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.8/to_json.js

@@ -1,42 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. 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.8/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.8/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.8/to_text.js

@@ -1,45 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. 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.8/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.8/to_transform_stream.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,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"}

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

@@ -1,102 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * 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 function toTransformStream(transformer, writableStrategy, readableStrategy) {
-    const { writable, readable, } = new TransformStream(undefined, writableStrategy);
-    const iterable = transformer(readable);
-    const iterator = iterable[Symbol.asyncIterator]?.() ??
-        iterable[Symbol.iterator]?.();
-    return {
-        writable,
-        readable: new ReadableStream({
-            async pull(controller) {
-                let result;
-                try {
-                    result = await iterator.next();
-                }
-                catch (error) {
-                    // Propagate error to stream from iterator
-                    // If the stream status is "errored", it will be thrown, but ignore.
-                    await readable.cancel(error).catch(() => { });
-                    controller.error(error);
-                    return;
-                }
-                if (result.done) {
-                    controller.close();
-                    return;
-                }
-                controller.enqueue(result.value);
-            },
-            async cancel(reason) {
-                // Propagate cancellation to readable and iterator
-                if (typeof iterator.throw === "function") {
-                    try {
-                        await iterator.throw(reason);
-                    }
-                    catch {
-                        /* `iterator.throw()` always throws on site. We catch it. */
-                    }
-                }
-                await readable.cancel(reason);
-            },
-        }, readableStrategy),
-    };
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"zip_readable_streams.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.8/zip_readable_streams.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,GAC9B,cAAc,CAAC,CAAC,CAAC,CAuBnB"}