@effectionx/jsonl-store 0.3.1 → 0.4.1

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

@@ -1,122 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _LimitedBytesTransformStream_read;
-/**
- * A {@linkcode TransformStream} that will only read & enqueue chunks until the
- * total amount of enqueued data exceeds `size`. The last chunk that would
- * exceed the limit will NOT be enqueued, in which case a {@linkcode RangeError}
- * is thrown when `options.error` is set to true, otherwise the stream is just
- * terminated.
- *
- * @example `size` is equal to the total byte length of the chunks
- * ```ts
- * import { LimitedBytesTransformStream } from "@std/streams/limited-bytes-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(new TextEncoderStream()).pipeThrough(
- *   new LimitedBytesTransformStream(8),
- * ).pipeThrough(new TextDecoderStream());
- *
- * assertEquals(
- *   await Array.fromAsync(transformed),
- *   ["1234", "5678"],
- * );
- * ```
- *
- * @example `size` is less than the total byte length of the chunks, and at the
- * boundary of the chunks
- * ```ts
- * import { LimitedBytesTransformStream } from "@std/streams/limited-bytes-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(new TextEncoderStream()).pipeThrough(
- *   // `4` is the boundary of the chunks
- *   new LimitedBytesTransformStream(4),
- * ).pipeThrough(new TextDecoderStream());
- *
- * assertEquals(
- *   await Array.fromAsync(transformed),
- *   // The first chunk was read, but the second chunk was not
- *   ["1234"],
- * );
- * ```
- *
- * @example `size` is less than the total byte length of the chunks, and not at
- * the boundary of the chunks
- * ```ts
- * import { LimitedBytesTransformStream } from "@std/streams/limited-bytes-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(new TextEncoderStream()).pipeThrough(
- *   // `5` is not the boundary of the chunks
- *   new LimitedBytesTransformStream(5),
- * ).pipeThrough(new TextDecoderStream());
- *
- * assertEquals(
- *   await Array.fromAsync(transformed),
- *   // The second chunk was not read because it would exceed the specified size
- *   ["1234"],
- * );
- * ```
- *
- * @example Throw error when the total byte length of the chunks exceeds the
- * specified size
- *
- * To do so, set `options.error` to `true`.
- *
- * ```ts
- * import { LimitedBytesTransformStream } from "@std/streams/limited-bytes-transform-stream";
- * import { assertRejects } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(new TextEncoderStream()).pipeThrough(
- *   new LimitedBytesTransformStream(5, { error: true }),
- * ).pipeThrough(new TextDecoderStream());
- *
- * await assertRejects(async () => {
- *   await Array.fromAsync(transformed);
- * }, RangeError);
- * ```
- */
-export class LimitedBytesTransformStream extends TransformStream {
-    /**
-     * Constructs a new instance.
-     *
-     * @param size A size limit in bytes.
-     * @param options Options for the stream.
-     */
-    constructor(size, options = { error: false }) {
-        super({
-            transform: (chunk, controller) => {
-                if ((__classPrivateFieldGet(this, _LimitedBytesTransformStream_read, "f") + chunk.byteLength) > size) {
-                    if (options.error) {
-                        throw new RangeError(`Exceeded byte size limit of '${size}'`);
-                    }
-                    else {
-                        controller.terminate();
-                    }
-                }
-                else {
-                    __classPrivateFieldSet(this, _LimitedBytesTransformStream_read, __classPrivateFieldGet(this, _LimitedBytesTransformStream_read, "f") + chunk.byteLength, "f");
-                    controller.enqueue(chunk);
-                }
-            },
-        });
-        _LimitedBytesTransformStream_read.set(this, 0);
-    }
-}
-_LimitedBytesTransformStream_read = new WeakMap();

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

@@ -1,84 +0,0 @@
-/** Options for {@linkcode LimitedTransformStream} */
-export interface LimitedTransformStreamOptions {
-    /**
-     * If true, a {@linkcode RangeError} is thrown when the total number of
-     * enqueued chunks is about to exceed the specified limit.
-     *
-     * @default {false}
-     */
-    error?: boolean;
-}
-/**
- * A {@linkcode TransformStream} that will only read & enqueue `size` amount of
- * chunks.
- *
- * If `options.error` is set, then instead of terminating the stream,
- * a {@linkcode RangeError} will be thrown when the total number of enqueued
- * chunks is about to exceed the specified size.
- *
- * @typeparam T The type the chunks in the stream.
- *
- * @example `size` is equal to the total number of chunks
- * ```ts
- * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(
- *   new LimitedTransformStream(2),
- * );
- *
- * // All chunks were read
- * assertEquals(
- *   await Array.fromAsync(transformed),
- *   ["1234", "5678"],
- * );
- * ```
- *
- * @example `size` is less than the total number of chunks
- * ```ts
- * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(
- *   new LimitedTransformStream(1),
- * );
- *
- * // Only the first chunk was read
- * assertEquals(
- *   await Array.fromAsync(transformed),
- *   ["1234"],
- * );
- * ```
- *
- * @example Throw a {@linkcode RangeError} when the total number of chunks is
- * about to exceed the specified limit
- *
- * Do this by setting `options.error` to `true`.
- *
- * ```ts
- * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
- * import { assertRejects } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(
- *   new LimitedTransformStream(1, { error: true }),
- * );
- *
- * await assertRejects(async () => {
- *   await Array.fromAsync(transformed);
- * }, RangeError);
- * ```
- */
-export declare class LimitedTransformStream<T> extends TransformStream<T, T> {
-    #private;
-    /**
-     * Constructs a new instance.
-     *
-     * @param size The maximum number of chunks to read.
-     * @param options Options for the stream.
-     */
-    constructor(size: number, options?: LimitedTransformStreamOptions);
-}
-//# sourceMappingURL=limited_transform_stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"limited_transform_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/limited_transform_stream.ts"],"names":[],"mappings":"AAGA,qDAAqD;AACrD,MAAM,WAAW,6BAA6B;IAC5C;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,qBAAa,sBAAsB,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;;IAGlE;;;;;OAKG;gBAED,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,6BAAgD;CAiB5D"}

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

@@ -1,106 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _LimitedTransformStream_read;
-/**
- * A {@linkcode TransformStream} that will only read & enqueue `size` amount of
- * chunks.
- *
- * If `options.error` is set, then instead of terminating the stream,
- * a {@linkcode RangeError} will be thrown when the total number of enqueued
- * chunks is about to exceed the specified size.
- *
- * @typeparam T The type the chunks in the stream.
- *
- * @example `size` is equal to the total number of chunks
- * ```ts
- * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(
- *   new LimitedTransformStream(2),
- * );
- *
- * // All chunks were read
- * assertEquals(
- *   await Array.fromAsync(transformed),
- *   ["1234", "5678"],
- * );
- * ```
- *
- * @example `size` is less than the total number of chunks
- * ```ts
- * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
- * import { assertEquals } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(
- *   new LimitedTransformStream(1),
- * );
- *
- * // Only the first chunk was read
- * assertEquals(
- *   await Array.fromAsync(transformed),
- *   ["1234"],
- * );
- * ```
- *
- * @example Throw a {@linkcode RangeError} when the total number of chunks is
- * about to exceed the specified limit
- *
- * Do this by setting `options.error` to `true`.
- *
- * ```ts
- * import { LimitedTransformStream } from "@std/streams/limited-transform-stream";
- * import { assertRejects } from "@std/assert";
- *
- * const stream = ReadableStream.from(["1234", "5678"]);
- * const transformed = stream.pipeThrough(
- *   new LimitedTransformStream(1, { error: true }),
- * );
- *
- * await assertRejects(async () => {
- *   await Array.fromAsync(transformed);
- * }, RangeError);
- * ```
- */
-export class LimitedTransformStream extends TransformStream {
-    /**
-     * Constructs a new instance.
-     *
-     * @param size The maximum number of chunks to read.
-     * @param options Options for the stream.
-     */
-    constructor(size, options = { error: false }) {
-        super({
-            transform: (chunk, controller) => {
-                var _a;
-                if ((__classPrivateFieldGet(this, _LimitedTransformStream_read, "f") + 1) > size) {
-                    if (options.error) {
-                        throw new RangeError(`Exceeded chunk limit of '${size}'`);
-                    }
-                    else {
-                        controller.terminate();
-                    }
-                }
-                else {
-                    __classPrivateFieldSet(this, _LimitedTransformStream_read, (_a = __classPrivateFieldGet(this, _LimitedTransformStream_read, "f"), _a++, _a), "f");
-                    controller.enqueue(chunk);
-                }
-            },
-        });
-        _LimitedTransformStream_read.set(this, 0);
-    }
-}
-_LimitedTransformStream_read = new WeakMap();

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

@@ -1,38 +0,0 @@
-/**
- * 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 declare function mergeReadableStreams<T>(...streams: ReadableStream<T>[]): ReadableStream<T>;
-//# sourceMappingURL=merge_readable_streams.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"merge_readable_streams.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/merge_readable_streams.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,GAAG,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,GAC9B,cAAc,CAAC,CAAC,CAAC,CA8BnB"}

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

@@ -1,69 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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.14/mod.d.ts

@@ -1,35 +0,0 @@
-/**
- * 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";
-//# sourceMappingURL=mod.d.ts.map

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

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

@@ -1,35 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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.14/text_delimiter_stream.d.ts

@@ -1,58 +0,0 @@
-import type { DelimiterStreamOptions } from "./delimiter_stream.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 declare class TextDelimiterStream extends TransformStream<string, string> {
-    #private;
-    /**
-     * Constructs a new instance.
-     *
-     * @param delimiter A delimiter to split the stream by.
-     * @param options Options for the stream.
-     */
-    constructor(delimiter: string, options?: DelimiterStreamOptions);
-}
-//# sourceMappingURL=text_delimiter_stream.d.ts.map

package/esm/deps/jsr.io/@std/streams/1.0.14/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.14/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"}