@effectionx/jsonl-store 0.2.0 → 0.3.0

package/esm/deps/jsr.io/@std/internal/1.0.12/_os.d.ts

@@ -0,0 +1,2 @@
+export declare function checkWindows(): boolean;
+//# sourceMappingURL=_os.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.12/_os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/_os.ts"],"names":[],"mappings":"AAIA,wBAAgB,YAAY,IAAI,OAAO,CAUtC"}

package/esm/deps/jsr.io/@std/internal/1.0.12/_os.js

@@ -0,0 +1,12 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import * as dntShim from "../../../../../_dnt.shims.js";
+export function checkWindows() {
+    // deno-lint-ignore no-explicit-any
+    const global = dntShim.dntGlobalThis;
+    const os = global.Deno?.build?.os;
+    // Check Deno, then the remaining runtimes (e.g. Node, Bun and the browser)
+    return typeof os === "string"
+        ? os === "windows"
+        : global.navigator?.platform?.startsWith("Win") ??
+            global.process?.platform?.startsWith("win") ?? false;
+}

package/esm/deps/jsr.io/@std/internal/1.0.12/os.d.ts

@@ -0,0 +1,3 @@
+/** Whether the current platform is Windows */
+export declare const isWindows: boolean;
+//# sourceMappingURL=os.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.12/os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/os.ts"],"names":[],"mappings":"AAKA,8CAA8C;AAC9C,eAAO,MAAM,SAAS,EAAE,OAAwB,CAAC"}

package/esm/deps/jsr.io/@std/internal/1.0.12/os.js

@@ -0,0 +1,5 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { checkWindows } from "./_os.js";
+/** Whether the current platform is Windows */
+export const isWindows = checkWindows();

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

@@ -0,0 +1 @@
+{"version":3,"file":"_common.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/json/1.0.2/_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.2/concatenated_json_parse_stream.d.ts.map

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

@@ -0,0 +1,196 @@
+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-2025 the Deno authors. MIT license.
+import { toTransformStream } from "../../streams/1.0.14/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.2/mod.d.ts.map

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

@@ -0,0 +1,23 @@
+// Copyright 2018-2025 the Deno authors. 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.2/parse_stream.d.ts

@@ -0,0 +1,53 @@
+import type { JsonValue } from "./types.js";
+/**
+ * Parse each chunk as JSON.
+ *
+ * This can be used to parse {@link https://jsonlines.org/ | JSON lines},
+ * {@link https://en.wikipedia.org/wiki/JSON_streaming#Newline-delimited_JSON | 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.2/parse_stream.d.ts.map

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

@@ -0,0 +1,66 @@
+// Copyright 2018-2025 the Deno authors. 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 https://en.wikipedia.org/wiki/JSON_streaming#Newline-delimited_JSON | 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.2/stringify_stream.d.ts

@@ -0,0 +1,95 @@
+/** 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://en.wikipedia.org/wiki/JSON_streaming#Newline-delimited_JSON | 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.2/stringify_stream.d.ts.map

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

@@ -0,0 +1,88 @@
+// Copyright 2018-2025 the Deno authors. 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://en.wikipedia.org/wiki/JSON_streaming#Newline-delimited_JSON | 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.2/types.d.ts.map

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"assert_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.3/_common/assert_path.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,QAMvC"}

package/esm/deps/jsr.io/@std/path/1.1.3/_common/assert_path.js

@@ -0,0 +1,7 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright the Browserify authors. MIT License.
+export function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string, received "${JSON.stringify(path)}"`);
+    }
+}

package/esm/deps/jsr.io/@std/path/1.1.3/_common/basename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basename.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.3/_common/basename.ts"],"names":[],"mappings":"AAKA,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAchE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAChC,KAAK,SAAI,GACR,MAAM,CAiBR;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,sBAQtD"}

package/esm/deps/jsr.io/@std/path/1.1.3/_common/basename.js

@@ -0,0 +1,40 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { assertPath } from "./assert_path.js";
+export function stripSuffix(name, suffix) {
+    if (suffix.length >= name.length) {
+        return name;
+    }
+    const lenDiff = name.length - suffix.length;
+    for (let i = suffix.length - 1; i >= 0; --i) {
+        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+            return name;
+        }
+    }
+    return name.slice(0, -suffix.length);
+}
+export function lastPathSegment(path, isSep, start = 0) {
+    let matchedNonSeparator = false;
+    let end = path.length;
+    for (let i = path.length - 1; i >= start; --i) {
+        if (isSep(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (!matchedNonSeparator) {
+            matchedNonSeparator = true;
+            end = i + 1;
+        }
+    }
+    return path.slice(start, end);
+}
+export function assertArgs(path, suffix) {
+    assertPath(path);
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string, received "${JSON.stringify(suffix)}"`);
+    }
+}

package/esm/deps/jsr.io/@std/path/1.1.3/_common/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.3/_common/common.ts"],"names":[],"mappings":"AAGA,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAsB3D"}