@okikio/observables 1.0.2

package/esm/helpers/mod.d.ts

@@ -0,0 +1,90 @@
+/**
+ * High-level operator entrypoint for composing Observable pipelines.
+ *
+ * This is the ergonomic "import most things from one place" surface for the
+ * package. It re-exports the pipe/compose helpers, operator builders, utility
+ * helpers, and the built-in operator families so callers can build an entire
+ * pipeline without remembering which category module each operator lives in.
+ *
+ * The exports here fall into a few broad groups:
+ * - core transformation operators such as `map`, `filter`, `take`, and `scan`
+ * - timing operators such as `debounce`, `delay`, `throttle`, and `timeout`
+ * - combination operators such as `mergeMap`, `concatMap`, and `switchMap`
+ * - batching and error operators for collecting values or recovering from
+ *   failures in a stream
+ *
+ * Everything shares the same Web Streams-based runtime, so backpressure,
+ * teardown, and error-mode behavior stay consistent from one operator to the
+ * next. Import from `./operations/*` only when you want a narrower entrypoint
+ * for discovery or tree-shaken docs. Import from this module when you want the
+ * familiar "just give me the operator toolbox" experience.
+ *
+ * ## Basic Usage
+ *
+ * @example
+ * ```ts
+ * import { pipe, map, filter, take } from "./helpers/mod.ts";
+ * import { Observable } from "./observable.ts";
+ *
+ * // Create an Observable with some data
+ * const source = new Observable(observer => {
+ *   for (let i = 0; i < 10; i++) {
+ *     observer.next(i);
+ *   }
+ *   observer.complete();
+ * });
+ *
+ * // Transform the Observable
+ * const result = pipe(
+ *   source,
+ *   filter(x => x % 2 === 0), // Keep even numbers
+ *   map(x => x * 10),         // Multiply by 10
+ *   take(3)                   // Take only the first 3 values
+ * );
+ *
+ * // Subscribe to the result
+ * result.subscribe({
+ *   next: value => console.log(value),
+ *   complete: () => console.log('Done')
+ * });
+ * // Output: 0, 20, 40
+ * ```
+ *
+ * ## Advanced Composition
+ *
+ * For more complex pipelines, the `compose` function helps you group operators:
+ *
+ * @example
+ * ```ts
+ * import { pipe, compose, map, filter, take, tap } from "./helpers/mod.ts";
+ *
+ * // Use them in a pipeline
+ * const result = pipe(
+ *   source,
+ *
+ *   // Process numbers
+ *   filter(x => x % 2 === 0),
+ *   map(x => x * 10),
+ *   tap(x => console.log('Processed:', x)),
+ *
+ *   // Limit and format output
+ *   take(3),
+ *   map(x => `Result: ${x}`)
+ * );
+ * ```
+ *
+ * ## Limitations
+ *
+ * - Each pipeline is limited to 9 operators due to TypeScript's recursion limits
+ * - Use `compose` to group operators when you need more than 9
+ * - Composed operator groups are also limited to 9 operators
+ *
+ * @module
+ */
+import "../_dnt.polyfills.js";
+export type * from "./_types.js";
+export * from "./operations/mod.js";
+export * from "./operators.js";
+export * from "./pipe.js";
+export * from "./utils.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/helpers/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/helpers/mod.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAGH,OAAO,sBAAsB,CAAC;AAE9B,mBAAmB,aAAa,CAAC;AAEjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC"}

package/esm/helpers/mod.js

@@ -0,0 +1,90 @@
+// @filename: helpers/mod.ts
+/**
+ * High-level operator entrypoint for composing Observable pipelines.
+ *
+ * This is the ergonomic "import most things from one place" surface for the
+ * package. It re-exports the pipe/compose helpers, operator builders, utility
+ * helpers, and the built-in operator families so callers can build an entire
+ * pipeline without remembering which category module each operator lives in.
+ *
+ * The exports here fall into a few broad groups:
+ * - core transformation operators such as `map`, `filter`, `take`, and `scan`
+ * - timing operators such as `debounce`, `delay`, `throttle`, and `timeout`
+ * - combination operators such as `mergeMap`, `concatMap`, and `switchMap`
+ * - batching and error operators for collecting values or recovering from
+ *   failures in a stream
+ *
+ * Everything shares the same Web Streams-based runtime, so backpressure,
+ * teardown, and error-mode behavior stay consistent from one operator to the
+ * next. Import from `./operations/*` only when you want a narrower entrypoint
+ * for discovery or tree-shaken docs. Import from this module when you want the
+ * familiar "just give me the operator toolbox" experience.
+ *
+ * ## Basic Usage
+ *
+ * @example
+ * ```ts
+ * import { pipe, map, filter, take } from "./helpers/mod.ts";
+ * import { Observable } from "./observable.ts";
+ *
+ * // Create an Observable with some data
+ * const source = new Observable(observer => {
+ *   for (let i = 0; i < 10; i++) {
+ *     observer.next(i);
+ *   }
+ *   observer.complete();
+ * });
+ *
+ * // Transform the Observable
+ * const result = pipe(
+ *   source,
+ *   filter(x => x % 2 === 0), // Keep even numbers
+ *   map(x => x * 10),         // Multiply by 10
+ *   take(3)                   // Take only the first 3 values
+ * );
+ *
+ * // Subscribe to the result
+ * result.subscribe({
+ *   next: value => console.log(value),
+ *   complete: () => console.log('Done')
+ * });
+ * // Output: 0, 20, 40
+ * ```
+ *
+ * ## Advanced Composition
+ *
+ * For more complex pipelines, the `compose` function helps you group operators:
+ *
+ * @example
+ * ```ts
+ * import { pipe, compose, map, filter, take, tap } from "./helpers/mod.ts";
+ *
+ * // Use them in a pipeline
+ * const result = pipe(
+ *   source,
+ *
+ *   // Process numbers
+ *   filter(x => x % 2 === 0),
+ *   map(x => x * 10),
+ *   tap(x => console.log('Processed:', x)),
+ *
+ *   // Limit and format output
+ *   take(3),
+ *   map(x => `Result: ${x}`)
+ * );
+ * ```
+ *
+ * ## Limitations
+ *
+ * - Each pipeline is limited to 9 operators due to TypeScript's recursion limits
+ * - Use `compose` to group operators when you need more than 9
+ * - Composed operator groups are also limited to 9 operators
+ *
+ * @module
+ */
+// Re-export all operators from their respective modules
+import "../_dnt.polyfills.js";
+export * from "./operations/mod.js";
+export * from "./operators.js";
+export * from "./pipe.js";
+export * from "./utils.js";

package/esm/helpers/operations/batch.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Operators that collect multiple source values into grouped results.
+ *
+ * This entrypoint contains the batching side of the operator library. Use it
+ * when one output value should summarize several input values, such as turning
+ * a whole stream into a single array with `toArray()` or bundling incoming
+ * items into fixed-size chunks with `batch()`.
+ *
+ * These operators trade immediacy for aggregation. They usually hold on to some
+ * values until a batch fills or the source completes, so they are best for
+ * finite streams or bounded buffers where that extra memory is intentional.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import type { Operator } from "../_types.js";
+import type { ObservableError } from "../../error.js";
+/**
+ * Collects all values from the source stream and emits them as a single array
+ * when the source completes.
+ *
+ * Like `Array.prototype.slice()` for the whole stream, but delivered as a
+ * single chunk when the stream is done.
+ *
+ * @example
+ * ```ts
+ * import { pipe, toArray } from "../../mod.ts";
+ * import { from } from "../../../observable.ts";
+ *
+ * // Array behavior
+ * const fullArray = [1, 2, 3, 4, 5]; // [1, 2, 3, 4, 5]
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, 2, 3, 4, 5]);
+ * const resultObservable = pipe(
+ *   sourceStream,
+ *   toArray()
+ * );
+ *
+ * for await (const result of resultObservable) {
+ *   console.log(result); // [1, 2, 3, 4, 5]
+ * }
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `toArray` when you need to gather all results from a stream before
+ * processing them, such as aggregating data for a final report or waiting for
+ * all parallel operations to complete.
+ *
+ * **Warning**: This operator should only be used with streams that are known
+ * to complete and emit a reasonable number of values to avoid memory issues.
+ *
+ * ## Key Insight
+ *
+ * `toArray` converts a stream back into a promise that resolves with an array,
+ * making it a bridge between asynchronous streams and synchronous array processing.
+ *
+ * @typeParam T - Type of values from the source stream
+ * @returns A stream operator that collects values into an array
+ */
+export declare function toArray<T>(): Operator<T | ObservableError, T[] | ObservableError>;
+/**
+ * Batches values from the source stream into arrays of a specified size.
+ *
+ * Like a chunking utility, it groups items into fixed-size arrays, but for
+ * async streams. If the stream ends before a batch is full, it emits the
+ * partial batch.
+ *
+ * @example
+ * ```ts
+ * import { pipe, batch } from "../../mod.ts";
+ * import { from } from "../../../observable.ts";
+ *
+ * // No direct Array equivalent, but conceptually like chunking:
+ * const data = [1, 2, 3, 4, 5, 6, 7, 8];
+ * // Manual chunking: [[1, 2, 3], [4, 5, 6], [7, 8]]
+ *
+ * // Stream behavior
+ * const sourceStream = from(data);
+ * const batchedStream = pipe(
+ *   sourceStream,
+ *   batch(3)
+ * );
+ *
+ * for await (const result of batchedStream) {
+ *   console.log(result);
+ * }
+ * // Resulting chunks: [1,2,3], [4,5,6], [7,8]
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `batch` to process items in bulk, such as sending data to an API that
+ * accepts multiple records at once, or inserting records into a database in
+ * transactions. This is often more efficient than processing items one by one.
+ *
+ * ## Key Insight
+ *
+ * `batch` helps manage load on downstream systems by reducing the number of
+ * individual processing requests, turning a chatty stream into a more
+ * efficient, chunky one.
+ *
+ * @typeParam T - Type of values from the source stream
+ * @param size - The size of each batch
+ * @returns A stream operator that batches values
+ */
+export declare function batch<T>(size: number): Operator<T | ObservableError, T[] | ObservableError>;
+//# sourceMappingURL=batch.d.ts.map

package/esm/helpers/operations/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../../src/helpers/operations/batch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAgB,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAItD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,OAAO,CAAC,CAAC,KAAK,QAAQ,CACpC,CAAC,GAAG,eAAe,EACnB,CAAC,EAAE,GAAG,eAAe,CACtB,CAYA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,IAAI,EAAE,MAAM,GACX,QAAQ,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,EAAE,GAAG,eAAe,CAAC,CAuBtD"}

package/esm/helpers/operations/batch.js

@@ -0,0 +1,140 @@
+/**
+ * Operators that collect multiple source values into grouped results.
+ *
+ * This entrypoint contains the batching side of the operator library. Use it
+ * when one output value should summarize several input values, such as turning
+ * a whole stream into a single array with `toArray()` or bundling incoming
+ * items into fixed-size chunks with `batch()`.
+ *
+ * These operators trade immediacy for aggregation. They usually hold on to some
+ * values until a batch fills or the source completes, so they are best for
+ * finite streams or bounded buffers where that extra memory is intentional.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import { createStatefulOperator } from "../operators.js";
+/**
+ * Collects all values from the source stream and emits them as a single array
+ * when the source completes.
+ *
+ * Like `Array.prototype.slice()` for the whole stream, but delivered as a
+ * single chunk when the stream is done.
+ *
+ * @example
+ * ```ts
+ * import { pipe, toArray } from "../../mod.ts";
+ * import { from } from "../../../observable.ts";
+ *
+ * // Array behavior
+ * const fullArray = [1, 2, 3, 4, 5]; // [1, 2, 3, 4, 5]
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, 2, 3, 4, 5]);
+ * const resultObservable = pipe(
+ *   sourceStream,
+ *   toArray()
+ * );
+ *
+ * for await (const result of resultObservable) {
+ *   console.log(result); // [1, 2, 3, 4, 5]
+ * }
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `toArray` when you need to gather all results from a stream before
+ * processing them, such as aggregating data for a final report or waiting for
+ * all parallel operations to complete.
+ *
+ * **Warning**: This operator should only be used with streams that are known
+ * to complete and emit a reasonable number of values to avoid memory issues.
+ *
+ * ## Key Insight
+ *
+ * `toArray` converts a stream back into a promise that resolves with an array,
+ * making it a bridge between asynchronous streams and synchronous array processing.
+ *
+ * @typeParam T - Type of values from the source stream
+ * @returns A stream operator that collects values into an array
+ */
+export function toArray() {
+    return createStatefulOperator({
+        name: "toArray",
+        createState: () => [],
+        transform(chunk, state) {
+            // If chunk is an error, we should not push it to the array
+            state.push(chunk); // Ensure chunk is not an error
+        },
+        flush(state, controller) {
+            controller.enqueue(state);
+        },
+    });
+}
+/**
+ * Batches values from the source stream into arrays of a specified size.
+ *
+ * Like a chunking utility, it groups items into fixed-size arrays, but for
+ * async streams. If the stream ends before a batch is full, it emits the
+ * partial batch.
+ *
+ * @example
+ * ```ts
+ * import { pipe, batch } from "../../mod.ts";
+ * import { from } from "../../../observable.ts";
+ *
+ * // No direct Array equivalent, but conceptually like chunking:
+ * const data = [1, 2, 3, 4, 5, 6, 7, 8];
+ * // Manual chunking: [[1, 2, 3], [4, 5, 6], [7, 8]]
+ *
+ * // Stream behavior
+ * const sourceStream = from(data);
+ * const batchedStream = pipe(
+ *   sourceStream,
+ *   batch(3)
+ * );
+ *
+ * for await (const result of batchedStream) {
+ *   console.log(result);
+ * }
+ * // Resulting chunks: [1,2,3], [4,5,6], [7,8]
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `batch` to process items in bulk, such as sending data to an API that
+ * accepts multiple records at once, or inserting records into a database in
+ * transactions. This is often more efficient than processing items one by one.
+ *
+ * ## Key Insight
+ *
+ * `batch` helps manage load on downstream systems by reducing the number of
+ * individual processing requests, turning a chatty stream into a more
+ * efficient, chunky one.
+ *
+ * @typeParam T - Type of values from the source stream
+ * @param size - The size of each batch
+ * @returns A stream operator that batches values
+ */
+export function batch(size) {
+    if (size <= 0) {
+        throw new Error("batch: size must be greater than 0");
+    }
+    return createStatefulOperator({
+        name: "batch",
+        createState: () => [],
+        transform(chunk, buffer, controller) {
+            // If chunk is an error, we should not push it to the buffer
+            buffer.push(chunk); // Ensure chunk is not an error
+            if (buffer.length >= size) {
+                controller.enqueue(Array.from(buffer));
+                buffer.length = 0;
+            }
+        },
+        flush(buffer, controller) {
+            if (buffer.length > 0) {
+                controller.enqueue(Array.from(buffer));
+            }
+        },
+    });
+}

package/esm/helpers/operations/combination.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Operators that turn each source value into another stream and combine the
+ * results.
+ *
+ * This entrypoint covers the "flattening" family of operators such as
+ * `mergeMap`, `concatMap`, and `switchMap`. Use it when one input value needs
+ * to start follow-up async work, for example fetching related records, reading
+ * files, or switching to the latest search request.
+ *
+ * The operators in this module mainly differ in concurrency and cancellation
+ * behavior. `mergeMap` keeps multiple inner streams alive at once, `concatMap`
+ * preserves order by running one at a time, and `switchMap` cancels older work
+ * when a newer source value arrives.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import type { SpecObservable } from "../../_spec.js";
+import type { ExcludeError, Operator } from "../_types.js";
+import { ObservableError } from "../../error.js";
+/**
+ * Transforms each item into a new stream and merges their outputs, running
+ * them in parallel.
+ *
+ * Like `Promise.all(items.map(project))` but for streams, with control over
+ * concurrency. It's designed for high-throughput parallel processing.
+ *
+ * @example
+ * ```ts
+ * import { pipe, mergeMap, from } from "./helpers/mod.ts";
+ * import { of } from "../../observable.ts";
+ *
+ * // Promise.all behavior
+ * const ids = [1, 2, 3];
+ * const promises = ids.map(id => Promise.resolve(`User ${id}`));
+ * const users = await Promise.all(promises); // ["User 1", "User 2", "User 3"]
+ *
+ * // Stream behavior
+ * const idStream = from(ids);
+ * const userStream = pipe(
+ *   idStream,
+ *   mergeMap(id => of(`User ${id}`), 2) // Process 2 at a time
+ * );
+ *
+ * // Results may arrive in any order, e.g., "User 2", "User 1", "User 3"
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `mergeMap` to fetch data for multiple items concurrently. For example,
+ * given a stream of user IDs, you can fetch each user's profile in parallel.
+ * This is much faster than fetching them one by one.
+ *
+ * ## Key Insight
+ *
+ * `mergeMap` is for parallel, high-throughput operations where the order of
+ * results doesn't matter. It's the go-to for maximizing concurrency.
+ *
+ * @typeParam T - Type of values from the source Observable
+ * @typeParam R - Type of values in the result Observable
+ * @param project - Function that maps a source value to an Observable
+ * @param concurrent - Maximum number of inner Observables being subscribed
+ * to concurrently. Default is Infinity.
+ * @returns An operator function that maps and flattens values
+ */
+export declare function mergeMap<T, R>(project: (value: ExcludeError<T>, index: number) => SpecObservable<R>, concurrent?: number): Operator<T | ObservableError, R | ObservableError>;
+/**
+ * Transforms each item into a new stream and runs them one after another, in
+ * strict order.
+ *
+ * Like a series of `await` calls in a `for...of` loop, this ensures that each
+ * new stream completes before the next one begins.
+ *
+ * @example
+ * ```ts
+ * import { pipe, concatMap, from } from "./helpers/mod.ts";
+ * import { of } from "../../observable.ts";
+ *
+ * // Sequential awaits in a loop
+ * async function processSequentially() {
+ *   const results = [];
+ *   for (const id of [1, 2, 3]) {
+ *     const result = await Promise.resolve(`Step ${id}`);
+ *     results.push(result);
+ *   }
+ *   return results; // ["Step 1", "Step 2", "Step 3"]
+ * }
+ *
+ * // Stream behavior
+ * const idStream = from([1, 2, 3]);
+ * const processStream = pipe(
+ *   idStream,
+ *   concatMap(id => of(`Step ${id}`))
+ * );
+ *
+ * // Results are guaranteed to be in order: "Step 1", "Step 2", "Step 3"
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `concatMap` for sequential operations where order matters, such as a
+ * multi-step process where each step depends on the previous one (e.g., create
+ * user, then create their profile, then send a welcome email).
+ *
+ * ## Key Insight
+ *
+ * `concatMap` guarantees order by waiting for each inner stream to complete
+ * before starting the next. It's perfect for sequential tasks but is slower
+ * than `mergeMap` because it doesn't run in parallel.
+ *
+ * @typeParam T - Type of values from the source Observable
+ * @typeParam R - Type of values in the result Observable
+ * @param project - Function that maps a source value to an Observable
+ * @returns An operator function that maps and concatenates values
+ */
+export declare function concatMap<T, R>(project: (value: ExcludeError<T>, index: number) => SpecObservable<R>): Operator<T | ObservableError, R | ObservableError>;
+/**
+ * Transforms items into new streams, but cancels the previous stream when a new
+ * item arrives.
+ *
+ * Like an auto-cancelling search input, it only cares about the latest value
+ * and discards any pending work from previous values.
+ *
+ * @example
+ * ```ts
+ * import { pipe, switchMap, from } from "./helpers/mod.ts";
+ * import { of } from "../../observable.ts";
+ *
+ * // No direct Array equivalent, as it's about handling events over time.
+ *
+ * // Stream behavior for a search input
+ * const queryStream = from(["cat", "cats", "cats rul"]);
+ *
+ * const searchResultStream = pipe(
+ *   queryStream,
+ *   switchMap(query => of(`Results for "${query}"`))
+ * );
+ *
+ * // Assuming each query arrives before the last one "completes":
+ * // The first two searches for "cat" and "cats" would be cancelled.
+ * // The final output would only be: 'Results for "cats rul"'
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * `switchMap` is essential for live search bars or any UI element that
+ * triggers frequent events. It ensures that only the results for the most
+ * recent event are processed, preventing outdated or out-of-order results.
+ *
+ * ## Key Insight
+ *
+ * `switchMap` is the operator of choice for handling rapid-fire events where
+ * only the latest matters. It prevents race conditions and keeps your UI
+ * responsive by cancelling stale, in-flight operations.
+ *
+ * @typeParam T - Type of values from the source Observable
+ * @typeParam R - Type of values in the result Observable
+ * @param project - Function that maps a source value to an Observable
+ * @returns An operator function that maps and switches between values
+ */
+export declare function switchMap<T, R>(project: (value: ExcludeError<T>, index: number) => SpecObservable<R>): Operator<T | ObservableError, R | ObservableError>;
+//# sourceMappingURL=combination.d.ts.map

package/esm/helpers/operations/combination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combination.d.ts","sourceRoot":"","sources":["../../../src/helpers/operations/combination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG3D,OAAO,EAAqB,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,cAAc,CAAC,CAAC,CAAC,EACrE,UAAU,GAAE,MAAiB,GAC5B,QAAQ,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC,CAkHpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,cAAc,CAAC,CAAC,CAAC,GACpE,QAAQ,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC,CAGpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,cAAc,CAAC,CAAC,CAAC,GACpE,QAAQ,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC,CAyIpD"}