@effectionx/jsonl-store 0.1.1 → 0.1.2

package/esm/deps/jsr.io/@std/json/1.0.1/_common.d.ts

@@ -1,4 +0,0 @@
-import type { JsonValue } from "./types.js";
-/** JSON.parse with detailed error message. */
-export declare function parse(text: string): JsonValue;
-//# sourceMappingURL=_common.d.ts.map

package/esm/deps/jsr.io/@std/json/1.0.1/_common.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_common.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/json/1.0.1/_common.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,8CAA8C;AAC9C,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAU7C"}

package/esm/deps/jsr.io/@std/json/1.0.1/_common.js

@@ -1,11 +0,0 @@
-/** JSON.parse with detailed error message. */
-export function parse(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        // Truncate the string so that it is within 30 lengths.
-        const truncatedText = 30 < text.length ? `${text.slice(0, 30)}...` : text;
-        throw new error.constructor(`${error.message} (parsing: '${truncatedText}')`);
-    }
-}

package/esm/deps/jsr.io/@std/json/1.0.1/concatenated_json_parse_stream.d.ts

@@ -1,70 +0,0 @@
-import type { JsonValue } from "./types.js";
-/**
- * Stream to parse
- * {@link https://en.wikipedia.org/wiki/JSON_streaming#Concatenated_JSON | Concatenated JSON}.
- *
- * @example Usage
- *
- * ```ts
- * import { ConcatenatedJsonParseStream } from "@std/json/concatenated-json-parse-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   `{"foo":"bar"}`,
- *   `{"baz":100}`,
- * ]).pipeThrough(new ConcatenatedJsonParseStream());
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   { foo: "bar" },
- *   { baz: 100 },
- * ]);
- * ```
- */
-export declare class ConcatenatedJsonParseStream implements TransformStream<string, JsonValue> {
-    #private;
-    /**
-     * A writable stream of byte data.
-     *
-     * @example Usage
-     * ```ts
-     * import { ConcatenatedJsonParseStream } from "@std/json/concatenated-json-parse-stream";
-     * import { assertEquals } from "@std/assert";
-     *
-     * const stream = ReadableStream.from([
-     *   `{"foo":"bar"}`,
-     *   `{"baz":100}`,
-     * ]).pipeThrough(new ConcatenatedJsonParseStream());
-     *
-     * assertEquals(await Array.fromAsync(stream), [
-     *   { foo: "bar" },
-     *   { baz: 100 },
-     * ]);
-     * ```
-     */
-    readonly writable: WritableStream<string>;
-    /**
-     * A readable stream of byte data.
-     *
-     * @example Usage
-     * ```ts
-     * import { ConcatenatedJsonParseStream } from "@std/json/concatenated-json-parse-stream";
-     * import { assertEquals } from "@std/assert";
-     *
-     * const stream = ReadableStream.from([
-     *   `{"foo":"bar"}`,
-     *   `{"baz":100}`,
-     * ]).pipeThrough(new ConcatenatedJsonParseStream());
-     *
-     * assertEquals(await Array.fromAsync(stream), [
-     *   { foo: "bar" },
-     *   { baz: 100 },
-     * ]);
-     * ```
-     */
-    readonly readable: ReadableStream<JsonValue>;
-    /**
-     * Constructs a new instance.
-     */
-    constructor();
-}
-//# sourceMappingURL=concatenated_json_parse_stream.d.ts.map

package/esm/deps/jsr.io/@std/json/1.0.1/concatenated_json_parse_stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"concatenated_json_parse_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/json/1.0.1/concatenated_json_parse_stream.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAW5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,2BACX,YAAW,eAAe,CAAC,MAAM,EAAE,SAAS,CAAC;;IAC7C;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAC1C;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IAE7C;;OAEG;;CA0HJ"}

package/esm/deps/jsr.io/@std/json/1.0.1/concatenated_json_parse_stream.js

@@ -1,196 +0,0 @@
-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 _ConcatenatedJsonParseStream_instances, _ConcatenatedJsonParseStream_concatenatedJSONIterator;
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import { toTransformStream } from "../../streams/1.0.8/to_transform_stream.js";
-import { parse } from "./_common.js";
-function isBlankChar(char) {
-    return char !== undefined && [" ", "\t", "\r", "\n"].includes(char);
-}
-const primitives = new Map(["null", "true", "false"].map((v) => [v[0], v]));
-/**
- * Stream to parse
- * {@link https://en.wikipedia.org/wiki/JSON_streaming#Concatenated_JSON | Concatenated JSON}.
- *
- * @example Usage
- *
- * ```ts
- * import { ConcatenatedJsonParseStream } from "@std/json/concatenated-json-parse-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   `{"foo":"bar"}`,
- *   `{"baz":100}`,
- * ]).pipeThrough(new ConcatenatedJsonParseStream());
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   { foo: "bar" },
- *   { baz: 100 },
- * ]);
- * ```
- */
-export class ConcatenatedJsonParseStream {
-    /**
-     * Constructs a new instance.
-     */
-    constructor() {
-        _ConcatenatedJsonParseStream_instances.add(this);
-        /**
-         * A writable stream of byte data.
-         *
-         * @example Usage
-         * ```ts
-         * import { ConcatenatedJsonParseStream } from "@std/json/concatenated-json-parse-stream";
-         * import { assertEquals } from "@std/assert";
-         *
-         * const stream = ReadableStream.from([
-         *   `{"foo":"bar"}`,
-         *   `{"baz":100}`,
-         * ]).pipeThrough(new ConcatenatedJsonParseStream());
-         *
-         * assertEquals(await Array.fromAsync(stream), [
-         *   { foo: "bar" },
-         *   { baz: 100 },
-         * ]);
-         * ```
-         */
-        Object.defineProperty(this, "writable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * A readable stream of byte data.
-         *
-         * @example Usage
-         * ```ts
-         * import { ConcatenatedJsonParseStream } from "@std/json/concatenated-json-parse-stream";
-         * import { assertEquals } from "@std/assert";
-         *
-         * const stream = ReadableStream.from([
-         *   `{"foo":"bar"}`,
-         *   `{"baz":100}`,
-         * ]).pipeThrough(new ConcatenatedJsonParseStream());
-         *
-         * assertEquals(await Array.fromAsync(stream), [
-         *   { foo: "bar" },
-         *   { baz: 100 },
-         * ]);
-         * ```
-         */
-        Object.defineProperty(this, "readable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        const { writable, readable } = toTransformStream(__classPrivateFieldGet(this, _ConcatenatedJsonParseStream_instances, "m", _ConcatenatedJsonParseStream_concatenatedJSONIterator));
-        this.writable = writable;
-        this.readable = readable;
-    }
-}
-_ConcatenatedJsonParseStream_instances = new WeakSet(), _ConcatenatedJsonParseStream_concatenatedJSONIterator = async function* _ConcatenatedJsonParseStream_concatenatedJSONIterator(src) {
-    // Counts the number of '{', '}', '[', ']', and when the nesting level reaches 0, concatenates and returns the string.
-    let targetString = "";
-    let hasValue = false;
-    let nestCount = 0;
-    let readingString = false;
-    let escapeNext = false;
-    let readingPrimitive = false;
-    let positionInPrimitive = 0;
-    for await (const string of src) {
-        let sliceStart = 0;
-        for (let i = 0; i < string.length; i++) {
-            const char = string[i];
-            // We're reading a primitive at the top level
-            if (readingPrimitive) {
-                if (char === readingPrimitive[positionInPrimitive]) {
-                    positionInPrimitive++;
-                    // Emit the primitive when done reading
-                    if (positionInPrimitive === readingPrimitive.length) {
-                        yield parse(targetString + string.slice(sliceStart, i + 1));
-                        hasValue = false;
-                        readingPrimitive = false;
-                        positionInPrimitive = 0;
-                        targetString = "";
-                        sliceStart = i + 1;
-                    }
-                }
-                else {
-                    // If the primitive is malformed, keep reading, maybe the next characters can be useful in the syntax error.
-                    readingPrimitive = false;
-                    positionInPrimitive = 0;
-                }
-                continue;
-            }
-            if (readingString) {
-                if (char === '"' && !escapeNext) {
-                    readingString = false;
-                    // When the nesting level is 0, it returns a string when '"' comes.
-                    if (nestCount === 0 && hasValue) {
-                        yield parse(targetString + string.slice(sliceStart, i + 1));
-                        hasValue = false;
-                        targetString = "";
-                        sliceStart = i + 1;
-                    }
-                }
-                escapeNext = !escapeNext && char === "\\";
-                continue;
-            }
-            // Parses number with a nesting level of 0.
-            // example: '0["foo"]' => 0, ["foo"]
-            // example: '3.14{"foo": "bar"}' => 3.14, {foo: "bar"}
-            if (hasValue && nestCount === 0 &&
-                (char === "{" || char === "[" || char === '"' || char === " " ||
-                    char === "n" || char === "t" || char === "f")) {
-                yield parse(targetString + string.slice(sliceStart, i));
-                hasValue = false;
-                readingString = false;
-                targetString = "";
-                sliceStart = i;
-                i--;
-                continue;
-            }
-            switch (char) {
-                case '"':
-                    readingString = true;
-                    escapeNext = false;
-                    break;
-                case "{":
-                case "[":
-                    nestCount++;
-                    break;
-                case "}":
-                case "]":
-                    nestCount--;
-                    break;
-            }
-            if (nestCount === 0 && primitives.has(char)) {
-                // The first letter of a primitive at top level was found
-                readingPrimitive = primitives.get(char);
-                positionInPrimitive = 1;
-            }
-            // parse object or array
-            if (hasValue && nestCount === 0 &&
-                (char === "}" || char === "]")) {
-                yield parse(targetString + string.slice(sliceStart, i + 1));
-                hasValue = false;
-                targetString = "";
-                sliceStart = i + 1;
-                continue;
-            }
-            if (!hasValue && !isBlankChar(char)) {
-                // We want to ignore the character string with only blank, so if there is a character other than blank, record it.
-                hasValue = true;
-            }
-        }
-        targetString += string.slice(sliceStart);
-    }
-    if (hasValue) {
-        yield parse(targetString);
-    }
-};

package/esm/deps/jsr.io/@std/json/1.0.1/mod.d.ts

@@ -1,23 +0,0 @@
-/**
- * Utilities for parsing streaming JSON data.
- *
- * ```ts
- * import { JsonStringifyStream } from "@std/json";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([{ foo: "bar" }, { baz: 100 }])
- *   .pipeThrough(new JsonStringifyStream());
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   `{"foo":"bar"}\n`,
- *   `{"baz":100}\n`
- * ]);
- * ```
- *
- * @module
- */
-export * from "./concatenated_json_parse_stream.js";
-export * from "./types.js";
-export * from "./parse_stream.js";
-export * from "./stringify_stream.js";
-//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/json/1.0.1/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/json/1.0.1/mod.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,cAAc,qCAAqC,CAAC;AACpD,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}

package/esm/deps/jsr.io/@std/json/1.0.1/mod.js

@@ -1,23 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-/**
- * Utilities for parsing streaming JSON data.
- *
- * ```ts
- * import { JsonStringifyStream } from "@std/json";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([{ foo: "bar" }, { baz: 100 }])
- *   .pipeThrough(new JsonStringifyStream());
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   `{"foo":"bar"}\n`,
- *   `{"baz":100}\n`
- * ]);
- * ```
- *
- * @module
- */
-export * from "./concatenated_json_parse_stream.js";
-export * from "./types.js";
-export * from "./parse_stream.js";
-export * from "./stringify_stream.js";

package/esm/deps/jsr.io/@std/json/1.0.1/parse_stream.d.ts

@@ -1,53 +0,0 @@
-import type { JsonValue } from "./types.js";
-/**
- * Parse each chunk as JSON.
- *
- * This can be used to parse {@link https://jsonlines.org/ | JSON lines},
- * {@link http://ndjson.org/ | NDJSON} and
- * {@link https://www.rfc-editor.org/rfc/rfc7464.html | JSON Text Sequences}.
- * Chunks consisting of spaces, tab characters, or newline characters will be ignored.
- *
- * @example Basic usage
- *
- * ```ts
- * import { JsonParseStream } from "@std/json/parse-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   `{"foo":"bar"}\n`,
- *   `{"baz":100}\n`
- * ]).pipeThrough(new JsonParseStream());
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   { foo: "bar" },
- *   { baz: 100 }
- * ]);
- * ```
- *
- * @example parse JSON lines or NDJSON from a file
- * ```ts
- * import { TextLineStream } from "@std/streams/text-line-stream";
- * import { JsonParseStream } from "@std/json/parse-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const file = await Deno.open("json/testdata/test.jsonl");
- *
- * const readable = file.readable
- *   .pipeThrough(new TextDecoderStream())  // convert Uint8Array to string
- *   .pipeThrough(new TextLineStream()) // transform into a stream where each chunk is divided by a newline
- *   .pipeThrough(new JsonParseStream()); // parse each chunk as JSON
- *
- * assertEquals(await Array.fromAsync(readable), [
- *  {"hello": "world"},
- *  ["👋", "👋", "👋"],
- *  {"deno": "🦕"},
- * ]);
- * ```
- */
-export declare class JsonParseStream extends TransformStream<string, JsonValue> {
-    /**
-     * Constructs new instance.
-     */
-    constructor();
-}
-//# sourceMappingURL=parse_stream.d.ts.map

package/esm/deps/jsr.io/@std/json/1.0.1/parse_stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/json/1.0.1/parse_stream.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAQ5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAAa,eAAgB,SAAQ,eAAe,CAAC,MAAM,EAAE,SAAS,CAAC;IACrE;;OAEG;;CAYJ"}

package/esm/deps/jsr.io/@std/json/1.0.1/parse_stream.js

@@ -1,66 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { parse } from "./_common.js";
-const blanks = /^[ \t\r\n]*$/;
-function isBlankSpace(str) {
-    return blanks.test(str);
-}
-/**
- * Parse each chunk as JSON.
- *
- * This can be used to parse {@link https://jsonlines.org/ | JSON lines},
- * {@link http://ndjson.org/ | NDJSON} and
- * {@link https://www.rfc-editor.org/rfc/rfc7464.html | JSON Text Sequences}.
- * Chunks consisting of spaces, tab characters, or newline characters will be ignored.
- *
- * @example Basic usage
- *
- * ```ts
- * import { JsonParseStream } from "@std/json/parse-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([
- *   `{"foo":"bar"}\n`,
- *   `{"baz":100}\n`
- * ]).pipeThrough(new JsonParseStream());
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   { foo: "bar" },
- *   { baz: 100 }
- * ]);
- * ```
- *
- * @example parse JSON lines or NDJSON from a file
- * ```ts
- * import { TextLineStream } from "@std/streams/text-line-stream";
- * import { JsonParseStream } from "@std/json/parse-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const file = await Deno.open("json/testdata/test.jsonl");
- *
- * const readable = file.readable
- *   .pipeThrough(new TextDecoderStream())  // convert Uint8Array to string
- *   .pipeThrough(new TextLineStream()) // transform into a stream where each chunk is divided by a newline
- *   .pipeThrough(new JsonParseStream()); // parse each chunk as JSON
- *
- * assertEquals(await Array.fromAsync(readable), [
- *  {"hello": "world"},
- *  ["👋", "👋", "👋"],
- *  {"deno": "🦕"},
- * ]);
- * ```
- */
-export class JsonParseStream extends TransformStream {
-    /**
-     * Constructs new instance.
-     */
-    constructor() {
-        super({
-            transform(chunk, controller) {
-                if (!isBlankSpace(chunk)) {
-                    controller.enqueue(parse(chunk));
-                }
-            },
-        });
-    }
-}

package/esm/deps/jsr.io/@std/json/1.0.1/stringify_stream.d.ts

@@ -1,95 +0,0 @@
-/** Options for {@linkcode JsonStringifyStream}. */
-export interface StringifyStreamOptions {
-    /**
-     * Prefix to be added after stringify.
-     *
-     * @default {""}
-     */
-    readonly prefix?: string;
-    /**
-     * Suffix to be added after stringify.
-     *
-     * @default {"\n"}
-     */
-    readonly suffix?: string;
-}
-/**
- * Convert each chunk to JSON string.
- *
- * This can be used to stringify {@link https://jsonlines.org/ | JSON lines},
- * {@link https://ndjson.org/ | NDJSON},
- * {@link https://www.rfc-editor.org/rfc/rfc7464.html | JSON Text Sequences},
- * and {@link https://en.wikipedia.org/wiki/JSON_streaming#Concatenated_JSON | Concatenated JSON}.
- *
- * You can optionally specify a prefix and suffix for each chunk. The default prefix is `""` and the default suffix is `"\n"`.
- *
- * @example Basic usage
- *
- * ```ts
- * import { JsonStringifyStream } from "@std/json/stringify-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([{ foo: "bar" }, { baz: 100 }])
- *   .pipeThrough(new JsonStringifyStream());
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   `{"foo":"bar"}\n`,
- *   `{"baz":100}\n`
- * ]);
- * ```
- *
- * @example Stringify stream of JSON text sequences
- *
- * Set `options.prefix` to `\x1E` to stringify
- * {@linkcode https://www.rfc-editor.org/rfc/rfc7464.html | JSON Text Sequences}.
- *
- * ```ts
- * import { JsonStringifyStream } from "@std/json/stringify-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([{ foo: "bar" }, { baz: 100 }])
- *   .pipeThrough(new JsonStringifyStream({ prefix: "\x1E", suffix: "\n" }));
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   `\x1E{"foo":"bar"}\n`,
- *   `\x1E{"baz":100}\n`
- * ]);
- * ```
- *
- * @example Stringify JSON lines from a server
- *
- * ```ts ignore no-assert
- * import { JsonStringifyStream } from "@std/json/stringify-stream";
- *
- * // A server that streams one line of JSON every second
- * Deno.serve(() => {
- *   let intervalId: number | undefined;
- *   const readable = new ReadableStream({
- *     start(controller) {
- *       // Enqueue data once per second
- *       intervalId = setInterval(() => {
- *         controller.enqueue({ now: new Date() });
- *       }, 1000);
- *     },
- *     cancel() {
- *       clearInterval(intervalId);
- *     },
- *   });
- *
- *   const body = readable
- *     .pipeThrough(new JsonStringifyStream()) // Convert data to JSON lines
- *     .pipeThrough(new TextEncoderStream()); // Convert a string to a Uint8Array
- *
- *   return new Response(body);
- * });
- * ```
- */
-export declare class JsonStringifyStream extends TransformStream<unknown, string> {
-    /**
-     * Constructs new instance.
-     *
-     * @param options Options for the stream.
-     */
-    constructor(options?: StringifyStreamOptions);
-}
-//# sourceMappingURL=stringify_stream.d.ts.map

package/esm/deps/jsr.io/@std/json/1.0.1/stringify_stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stringify_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/json/1.0.1/stringify_stream.ts"],"names":[],"mappings":"AAGA,mDAAmD;AACnD,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,qBAAa,mBAAoB,SAAQ,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC;IACvE;;;;OAIG;gBACS,OAAO,CAAC,EAAE,sBAAsB;CAU7C"}

package/esm/deps/jsr.io/@std/json/1.0.1/stringify_stream.js

@@ -1,88 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * Convert each chunk to JSON string.
- *
- * This can be used to stringify {@link https://jsonlines.org/ | JSON lines},
- * {@link https://ndjson.org/ | NDJSON},
- * {@link https://www.rfc-editor.org/rfc/rfc7464.html | JSON Text Sequences},
- * and {@link https://en.wikipedia.org/wiki/JSON_streaming#Concatenated_JSON | Concatenated JSON}.
- *
- * You can optionally specify a prefix and suffix for each chunk. The default prefix is `""` and the default suffix is `"\n"`.
- *
- * @example Basic usage
- *
- * ```ts
- * import { JsonStringifyStream } from "@std/json/stringify-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([{ foo: "bar" }, { baz: 100 }])
- *   .pipeThrough(new JsonStringifyStream());
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   `{"foo":"bar"}\n`,
- *   `{"baz":100}\n`
- * ]);
- * ```
- *
- * @example Stringify stream of JSON text sequences
- *
- * Set `options.prefix` to `\x1E` to stringify
- * {@linkcode https://www.rfc-editor.org/rfc/rfc7464.html | JSON Text Sequences}.
- *
- * ```ts
- * import { JsonStringifyStream } from "@std/json/stringify-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from([{ foo: "bar" }, { baz: 100 }])
- *   .pipeThrough(new JsonStringifyStream({ prefix: "\x1E", suffix: "\n" }));
- *
- * assertEquals(await Array.fromAsync(stream), [
- *   `\x1E{"foo":"bar"}\n`,
- *   `\x1E{"baz":100}\n`
- * ]);
- * ```
- *
- * @example Stringify JSON lines from a server
- *
- * ```ts ignore no-assert
- * import { JsonStringifyStream } from "@std/json/stringify-stream";
- *
- * // A server that streams one line of JSON every second
- * Deno.serve(() => {
- *   let intervalId: number | undefined;
- *   const readable = new ReadableStream({
- *     start(controller) {
- *       // Enqueue data once per second
- *       intervalId = setInterval(() => {
- *         controller.enqueue({ now: new Date() });
- *       }, 1000);
- *     },
- *     cancel() {
- *       clearInterval(intervalId);
- *     },
- *   });
- *
- *   const body = readable
- *     .pipeThrough(new JsonStringifyStream()) // Convert data to JSON lines
- *     .pipeThrough(new TextEncoderStream()); // Convert a string to a Uint8Array
- *
- *   return new Response(body);
- * });
- * ```
- */
-export class JsonStringifyStream extends TransformStream {
-    /**
-     * Constructs new instance.
-     *
-     * @param options Options for the stream.
-     */
-    constructor(options) {
-        const { prefix = "", suffix = "\n" } = options ?? {};
-        super({
-            transform(chunk, controller) {
-                controller.enqueue(`${prefix}${JSON.stringify(chunk)}${suffix}`);
-            },
-        });
-    }
-}

package/esm/deps/jsr.io/@std/json/1.0.1/types.d.ts

@@ -1,5 +0,0 @@
-/** The type of the result of parsing JSON. */
-export type JsonValue = {
-    [key: string]: JsonValue | undefined;
-} | JsonValue[] | string | number | boolean | null;
-//# sourceMappingURL=types.d.ts.map

package/esm/deps/jsr.io/@std/json/1.0.1/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/json/1.0.1/types.ts"],"names":[],"mappings":"AAGA,8CAA8C;AAC9C,MAAM,MAAM,SAAS,GACjB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAA;CAAE,GACxC,SAAS,EAAE,GACX,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,CAAC"}

package/esm/deps/jsr.io/@std/json/1.0.1/types.js

@@ -1,3 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-export {};

package/esm/deps/jsr.io/@std/path/1.0.6/_common/assert_path.d.ts

@@ -1,2 +0,0 @@
-export declare function assertPath(path?: string): void;
-//# sourceMappingURL=assert_path.d.ts.map