@okikio/observables 1.0.2

package/script/helpers/operations/errors.js

@@ -0,0 +1,387 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreErrors = ignoreErrors;
+exports.catchErrors = catchErrors;
+exports.mapErrors = mapErrors;
+exports.onlyErrors = onlyErrors;
+exports.summarizeErrors = summarizeErrors;
+exports.tapError = tapError;
+exports.throwErrors = throwErrors;
+/**
+ * Error-focused operators for recovering from or reshaping stream failures.
+ *
+ * This entrypoint is for pipelines that expect some work to fail and want to
+ * keep going. It exports helpers for dropping wrapped errors, mapping them to
+ * fallback values, logging them, or converting them into a shape that fits the
+ * rest of the pipeline.
+ *
+ * These operators are most useful with the library's pass-through error mode,
+ * where failures travel as `ObservableError` values instead of immediately
+ * terminating the whole stream.
+ *
+ * @module
+ */
+require("../../_dnt.polyfills.js");
+const error_js_1 = require("../../error.js");
+const operators_js_1 = require("../operators.js");
+/**
+ * Removes all errors from the stream, keeping only successful data.
+ *
+ * Like a filter that only allows non-error values to pass. It's a simple way
+ * to clean up a stream when you don't need to handle failures.
+ *
+ * @example
+ * ```ts
+ * import { pipe, ignoreErrors, from } from "./helpers/mod.ts";
+ *
+ * // Array behavior (conceptual)
+ * const mixedData = [1, new Error("fail"), 2, 3];
+ * const goodData = mixedData.filter(item => !(item instanceof Error)); // [1, 2, 3]
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, new ObservableError("fail"), 2, 3]);
+ * const cleanStream = pipe(sourceStream, ignoreErrors()); // Emits 1, 2, 3
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `ignoreErrors` when processing a batch of items where some failures are
+ * expected and acceptable. For example, fetching a list of URLs where some
+ * might be broken. You only want to process the ones that work.
+ *
+ * ## Key Insight
+ *
+ * `ignoreErrors` provides a "fire-and-forget" approach to error handling. It's
+ * useful for non-critical tasks or when partial success is sufficient.
+ *
+ * @template T The type of good data in your stream
+ * @returns A stream operator that silently removes all errors
+ */
+function ignoreErrors() {
+    return (0, operators_js_1.createOperator)({
+        name: "ignoreErrors",
+        errorMode: "ignore",
+        transform(chunk, controller) {
+            controller.enqueue(chunk);
+            // Errors are silently dropped
+        },
+    });
+}
+/**
+ * Replaces any error in the stream with a fallback value.
+ *
+ * Like a `try...catch` block for each item in a stream, but instead of just
+ * handling the error, you provide a default value to take its place.
+ *
+ * @example
+ * ```ts
+ * import { pipe, catchErrors, from } from "./helpers/mod.ts";
+ *
+ * // Conceptual equivalent
+ * function process(item) {
+ *   try {
+ *     if (item instanceof Error) throw item;
+ *     return item;
+ *   } catch {
+ *     return "default";
+ *   }
+ * }
+ * const results = [1, new Error("fail")].map(process); // [1, "default"]
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, new ObservableError("fail")]);
+ * const safeStream = pipe(sourceStream, catchErrors("default")); // Emits 1, "default"
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `catchErrors` to provide a default state or value when an operation
+ * fails. For example, if fetching a user's profile fails, you could return a
+ * default "Guest" profile instead of letting the error propagate.
+ *
+ * ## Key Insight
+ *
+ * `catchErrors` ensures your stream continues with a predictable structure,
+ * even when individual operations fail. It maintains the flow of data by
+ * substituting errors with safe, default values.
+ *
+ * @template T The type of data in your stream.
+ * @template R The type of the fallback value.
+ * @param fallback The value to use whenever an error occurs.
+ * @returns A stream operator that replaces errors with a fallback value.
+ */
+function catchErrors(fallback) {
+    return (0, operators_js_1.createOperator)({
+        name: "catchErrors",
+        errorMode: "manual",
+        transform(chunk, controller) {
+            if ((0, error_js_1.isObservableError)(chunk)) {
+                controller.enqueue(fallback);
+            }
+            else {
+                controller.enqueue(chunk);
+            }
+        },
+    });
+}
+/**
+ * Transforms errors into custom values using a mapping function.
+ *
+ * This is a more powerful version of `catchErrors`. Instead of a single
+ * fallback, you can inspect each error and decide what to replace it with.
+ *
+ * @example
+ * ```ts
+ * import { pipe, mapErrors, from } from "./helpers/mod.ts";
+ *
+ * // Stream behavior
+ * const sourceStream = from([
+ *   1,
+ *   new ObservableError("Not Found"),
+ *   new ObservableError("Server Error")
+ * ]);
+ *
+ * const handledStream = pipe(
+ *   sourceStream,
+ *   mapErrors(err => {
+ *     if (err.message === "Not Found") return { status: 404 };
+ *     return { status: 500 };
+ *   })
+ * );
+ * // Emits 1, { status: 404 }, { status: 500 }
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `mapErrors` to convert different types of errors into meaningful data.
+ * For example, a "Not Found" error could be mapped to `null`, while a "Server
+ * Error" could be mapped to an object that triggers a retry mechanism.
+ *
+ * ## Key Insight
+ *
+ * `mapErrors` treats errors as data. It allows you to create a resilient
+ * stream that can intelligently respond to different failure modes without
+ * stopping.
+ *
+ * @template T The type of successful data in your stream.
+ * @template E The type your errors will be mapped to.
+ * @param errorMapper A function that receives an error and returns a new value.
+ * @returns A stream operator that transforms errors.
+ */
+function mapErrors(errorMapper) {
+    return (0, operators_js_1.createOperator)({
+        name: "mapErrors",
+        errorMode: "manual",
+        transform(chunk, controller) {
+            if ((0, error_js_1.isObservableError)(chunk)) {
+                try {
+                    const mappedError = errorMapper(chunk);
+                    controller.enqueue(mappedError);
+                }
+                catch (mapperError) {
+                    controller.error(new error_js_1.ObservableError([mapperError, chunk], `Your error mapper function threw an error: ${mapperError}`, {
+                        operator: "operator:mapErrors:mapper",
+                        value: mapperError,
+                        cause: chunk,
+                        tip: "The function passed to mapErrors threw an error. Check its implementation.",
+                    }));
+                }
+            }
+            else {
+                controller.enqueue(chunk);
+            }
+        },
+    });
+}
+/**
+ * Keeps only the errors from the stream, discarding successful data.
+ *
+ * This is the inverse of `ignoreErrors`. It's useful for creating a dedicated
+ * error-handling pipeline.
+ *
+ * @example
+ * ```ts
+ * import { pipe, onlyErrors, from } from "./helpers/mod.ts";
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, new ObservableError("fail"), 2]);
+ * const errorStream = pipe(sourceStream, onlyErrors()); // Emits ObservableError("fail")
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `onlyErrors` to separate the error stream from the data stream. You can
+ * then log these errors, send them to a monitoring service, or trigger alerts
+ * without interfering with the main data processing flow.
+ *
+ * ## Key Insight
+ *
+ * `onlyErrors` allows you to create a side-channel for failures, enabling
+ * robust monitoring and debugging.
+ *
+ * @template T The type of data in the source stream.
+ * @returns An operator that filters for errors.
+ */
+function onlyErrors() {
+    return (0, operators_js_1.createOperator)({
+        name: "onlyErrors",
+        errorMode: "manual",
+        transform(chunk, controller) {
+            if ((0, error_js_1.isObservableError)(chunk)) {
+                controller.enqueue(chunk);
+            }
+            // Good data is discarded
+        },
+    });
+}
+/**
+ * Summarizes the stream into a final count of successes and errors.
+ *
+ * This operator waits for the stream to complete and then emits a single
+ * object with the total counts.
+ *
+ * @example
+ * ```ts
+ * import { pipe, summarizeErrors, from } from "./helpers/mod.ts";
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, new ObservableError("fail"), 2, 3]);
+ * const summary = await pipe(sourceStream, summarizeErrors()).toPromise();
+ * // { successCount: 3, errorCount: 1, totalProcessed: 4, successRate: 0.75 }
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `summarizeErrors` at the end of a batch processing job to get a report
+ * on how many items were processed successfully and how many failed. This is
+
+ * useful for logging, monitoring, and generating reports.
+ *
+ * ## Key Insight
+ *
+ * `summarizeErrors` is a terminal operator that provides a high-level overview
+ * of a stream's health and completeness.
+ *
+ * @template T The type of data in the source stream.
+ * @returns An operator that emits a summary of successes and errors.
+ */
+function summarizeErrors() {
+    return (0, operators_js_1.createStatefulOperator)({
+        name: "summarizeErrors",
+        errorMode: "manual",
+        createState: () => ({ successCount: 0, errorCount: 0 }),
+        transform(chunk, state) {
+            if ((0, error_js_1.isObservableError)(chunk)) {
+                state.errorCount++;
+            }
+            else {
+                state.successCount++;
+            }
+        },
+        flush(state, controller) {
+            const total = state.successCount + state.errorCount;
+            controller.enqueue({
+                successCount: state.successCount,
+                errorCount: state.errorCount,
+                totalProcessed: total,
+                successRate: total > 0 ? state.successCount / total : 0,
+            });
+        },
+    });
+}
+/**
+ * Performs a side effect for each error without modifying the stream.
+ *
+ * Like `Array.prototype.forEach` but only for errors. It's useful for logging
+ * or debugging without altering the data flow.
+ *
+ * @example
+ * ```ts
+ * import { pipe, tapError, from } from "./helpers/mod.ts";
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, new ObservableError("fail")]);
+ * const tappedStream = pipe(
+ *   sourceStream,
+ *   tapError(err => console.error("Found an error:", err))
+ * );
+ * // Logs the error, then emits 1 and the error object.
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `tapError` to log errors to the console or a monitoring service as they
+ * happen, without stopping or changing the stream. This is invaluable for
+ * real-time debugging.
+ *
+ * ## Key Insight
+ *
+ * `tapError` gives you a window into the stream's errors without affecting the
+ * stream itself.
+ *
+ * @template T The type of data in the stream.
+ * @param sideEffect A function to call for each error.
+ * @returns An operator that performs a side effect on errors.
+ */
+function tapError(sideEffect) {
+    return (0, operators_js_1.createOperator)({
+        name: "tapError",
+        errorMode: "manual",
+        transform(chunk, controller) {
+            try {
+                if ((0, error_js_1.isObservableError)(chunk)) {
+                    sideEffect(chunk);
+                }
+            }
+            catch (_) {
+                /* no empty */
+            }
+            finally {
+                controller.enqueue(chunk);
+            }
+        },
+    });
+}
+/**
+ * Throws an error if it encounters one in the stream.
+ *
+ * This operator is useful for enforcing strict error handling. If an error is
+ * encountered, it will throw immediately, stopping the iteration.
+ *
+ * @example
+ * ```ts
+ * import { pipe, throwErrors, from } from "./helpers/mod.ts";
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, new ObservableError("fail"), 2]);
+ * const throwingStream = pipe(sourceStream, throwErrors());
+ *
+ * for await (const item of throwingStream) {
+ *   console.log(item); // Will log 1, then throw on "fail"
+ * }
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `throwErrors` when you want to ensure that any error in the stream is
+ * treated as a critical failure. This is useful in scenarios where errors must
+ * be handled immediately and cannot be ignored.
+ *
+ * ## Key Insight
+ *
+ * `throwErrors` provides a way to enforce strict error handling in streams,
+ * ensuring that no errors go unnoticed.
+ *
+ * @template T The type of data in the stream.
+ * @returns An operator that throws on errors.
+ */
+function throwErrors() {
+    return (0, operators_js_1.createOperator)({
+        name: "throwErrors",
+        errorMode: "throw",
+        transform(chunk, controller) {
+            // If it's an error, this will automatically throw due to errorMode: "throw"
+            controller.enqueue(chunk);
+        },
+    });
+}

package/script/helpers/operations/mod.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Category-level entrypoint for the built-in Observable operations.
+ *
+ * This module gathers every operator category that powers the higher-level
+ * `./operators` entrypoint. It is useful when you want a focused import path
+ * for documentation and discovery, but still want access to the full built-in
+ * operator set from one module.
+ *
+ * The re-exports are grouped by job:
+ * - `./core` covers the array-like transformations and terminal operators
+ * - `./timing` covers time-based coordination such as debounce and timeout
+ * - `./combination` covers flattening and concurrency helpers such as
+ *   `mergeMap`, `concatMap`, and `switchMap`
+ * - `./batch`, `./conditional`, and `./errors` cover collection, predicate, and
+ *   recovery-focused utilities
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+export * from "./batch.js";
+export * from "./combination.js";
+export * from "./conditional.js";
+export * from "./core.js";
+export * from "./errors.js";
+export * from "./timing.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/helpers/operations/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/helpers/operations/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,yBAAyB,CAAC;AAEjC,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/script/helpers/operations/mod.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Category-level entrypoint for the built-in Observable operations.
+ *
+ * This module gathers every operator category that powers the higher-level
+ * `./operators` entrypoint. It is useful when you want a focused import path
+ * for documentation and discovery, but still want access to the full built-in
+ * operator set from one module.
+ *
+ * The re-exports are grouped by job:
+ * - `./core` covers the array-like transformations and terminal operators
+ * - `./timing` covers time-based coordination such as debounce and timeout
+ * - `./combination` covers flattening and concurrency helpers such as
+ *   `mergeMap`, `concatMap`, and `switchMap`
+ * - `./batch`, `./conditional`, and `./errors` cover collection, predicate, and
+ *   recovery-focused utilities
+ *
+ * @module
+ */
+require("../../_dnt.polyfills.js");
+__exportStar(require("./batch.js"), exports);
+__exportStar(require("./combination.js"), exports);
+__exportStar(require("./conditional.js"), exports);
+__exportStar(require("./core.js"), exports);
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./timing.js"), exports);

package/script/helpers/operations/timing.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Time-based operators for spacing, delaying, and expiring stream values.
+ *
+ * This entrypoint groups the operators that make time part of your pipeline's
+ * behavior. Use it for UI patterns such as debouncing search input, throttling
+ * bursty events, delaying retries, or timing out work that takes too long.
+ *
+ * Timing operators do not just change values; they change when work is allowed
+ * to move downstream. That makes them especially important for coordinating
+ * async side effects without piling up stale requests or overwhelming slower
+ * consumers.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import type { Operator } from "../_types.js";
+import { ObservableError } from "../../error.js";
+/**
+ * Delays each item in the stream by a specified number of milliseconds.
+ *
+ * This operator shifts the entire stream of events forward in time, preserving
+ * the relative time between them.
+ *
+ * > Note: This does not delay error emissions. If an error occurs, it will
+ * > be emitted immediately, regardless of the delay.
+ *
+ * @example
+ * ```ts
+ * import { pipe, delay, from } from "./helpers/mod.ts";
+ *
+ * // No direct Array equivalent, as it's about timing.
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, 2, 3]);
+ * const delayedStream = pipe(sourceStream, delay(1000));
+ * // Emits 1 (after 1s), then 2 (immediately after), then 3 (immediately after).
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `delay` to simulate network latency in tests, or to introduce a small
+ * pause in a UI animation sequence to make it feel more natural.
+ *
+ * ## Key Insight
+ *
+ * `delay` is about shifting the timeline of events, not about pausing between
+ * them. It's a simple way to control when a stream begins to emit its values.
+ *
+ * @typeParam T - Type of values from the source stream
+ * @param ms - The delay duration in milliseconds
+ * @returns A stream operator that delays each value
+ */
+export declare function delay<T>(ms: number): Operator<T | ObservableError, T | ObservableError>;
+/**
+ * Delays each individual item by a specified number of milliseconds.
+ *
+ * This operator delays every item independently, preserving the relative
+ * spacing between them while shifting each one forward by the same amount.
+ * Think of it as "adding X milliseconds to each item's timestamp."
+ *
+ * > Note: This does not delay error emissions. If an error occurs, it will
+ * > be emitted immediately, regardless of the delay.
+ *
+ * @example
+ * ```ts
+ * import { pipe, delayEach, from } from "./helpers/mod.ts";
+ *
+ * // Stream behavior
+ * const sourceStream = from([1, 2, 3]); // Items at T+0, T+100, T+200
+ * const delayedStream = pipe(sourceStream, delayEach(1000));
+ * // Emits 1 (at T+1000), 2 (at T+1100), 3 (at T+1200)
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `delayEach` to simulate processing time for each item, or to add
+ * consistent lag to every operation (useful for testing race conditions
+ * or simulating network latency per request).
+ *
+ * ## Key Insight
+ *
+ * `delayEach` maintains the original spacing between items while shifting
+ * each one. For delaying the entire stream timeline, use `delay` instead.
+ *
+ * @typeParam T - Type of values from the source stream
+ * @param ms - The delay duration in milliseconds for each item
+ * @returns A stream operator that delays each value individually
+ */
+export declare function delayEach<T>(ms: number): Operator<T | ObservableError, T | ObservableError>;
+/**
+ * Emits only the latest item after a specified period of inactivity.
+ *
+ * This is the "search bar" operator. It waits for the user to stop typing
+ * before firing off a search query.
+ *
+ * > Note: This operator does not delay error emissions. If an error occurs,
+ * > it will be emitted immediately, regardless of the debounce period.
+ *
+ * @example
+ * ```ts
+ * import { pipe, debounce, from } from "./helpers/mod.ts";
+ *
+ * // No direct Array equivalent.
+ *
+ * // Stream behavior
+ * const inputStream = from(["a", "ab", "abc"]); // User typing quickly
+ * const debouncedStream = pipe(inputStream, debounce(300));
+ * // After 300ms of no new input, it will emit "abc".
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `debounce` for any event that fires rapidly, but you only care about the
+ * final value, such as search inputs, window resize events, or auto-saving
+ * form fields.
+ *
+ * ## Key Insight
+ *
+ * `debounce` filters out noise from rapid-fire events, ensuring that expensive
+ * operations (like API calls) are only triggered when necessary.
+ *
+ * @typeParam T - Type of values from the source stream
+ * @param ms - The debounce duration in milliseconds
+ * @returns A stream operator that debounces values
+ */
+export declare function debounce<T>(ms: number): Operator<T | ObservableError, T | ObservableError>;
+/**
+ * Limits the stream to emit at most one item per specified time interval.
+ *
+ * This is the "scroll event" operator. It ensures that even if an event fires
+ * hundreds of times per second, you only handle it at a manageable rate.
+ *
+ * @example
+ * ```ts
+ * import { pipe, throttle, from } from "./helpers/mod.ts";
+ *
+ * // No direct Array equivalent.
+ *
+ * // Stream behavior
+ * const scrollStream = from([10, 20, 50, 100, 150]); // Scroll events
+ * const throttledStream = pipe(scrollStream, throttle(100));
+ * // Emits 10 immediately, then waits 100ms before being able to emit again.
+ * // If 150 is the last value, it will be emitted after the throttle window.
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `throttle` for high-frequency events where you need to guarantee a
+ * regular sampling of the data, such as scroll position tracking, mouse
+ * movement, or real-time data visualization.
+ *
+ * ## Key Insight
+ *
+ * `throttle` guarantees a steady flow of data, unlike `debounce` which waits
+ * for silence. It's about rate-limiting, not just handling the final value.
+ *
+ * @typeParam T - Type of values from the source stream
+ * @param ms - The throttle duration in milliseconds
+ * @returns A stream operator that throttles values
+ */
+export declare function throttle<T>(ms: number): Operator<T | ObservableError, T | ObservableError>;
+/**
+ * Errors if an item takes too long to be processed.
+ *
+ * This operator passes normal synchronous values through immediately, but when
+ * an upstream operator emits a promise-like chunk it waits for that chunk to
+ * settle and races it against a timer. If the promise-like chunk does not
+ * resolve before the timer finishes, it emits an `ObservableError` instead.
+ *
+ * The implementation uses an async transform so Web Streams backpressure keeps
+ * later chunks from overtaking the timed chunk. In practice that means operator
+ * chains still stay ordered: each promise-like chunk either resolves to a value
+ * or times out before the next chunk is processed.
+ *
+ * @example
+ * ```ts
+ * import { pipe, timeout, from } from "./helpers/mod.ts";
+ *
+ * // Stream behavior
+ * const sourceStream = from([
+ *   new Promise(res => setTimeout(() => res(1), 100)),
+ *   new Promise(res => setTimeout(() => res(2), 2000))
+ * ]);
+ *
+ * const timedStream = pipe(sourceStream, timeout(1000));
+ * // Emits 1, then emits an error because the second promise took too long.
+ * ```
+ *
+ * ## Practical Use Case
+ *
+ * Use `timeout` to enforce Service Level Agreements (SLAs) on asynchronous
+ * operations, such as API calls. If a request takes too long, you can gracefully
+ * handle the timeout instead of letting your application hang.
+ *
+ * ## Key Insight
+ *
+ * `timeout` is a crucial tool for building resilient systems that can handle
+ * slow or unresponsive dependencies. It turns an indefinite wait into a
+ * predictable failure.
+ *
+ * @typeParam T The type of data in the stream.
+ * @param ms The timeout duration in milliseconds.
+ * @returns An operator that enforces a timeout on each item.
+ */
+export declare function timeout<T>(ms: number): Operator<T | PromiseLike<T> | ObservableError, T | ObservableError>;
+//# sourceMappingURL=timing.d.ts.map

package/script/helpers/operations/timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../../src/helpers/operations/timing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAgB,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE3D,OAAO,EAAqB,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,EAAE,EAAE,MAAM,GACT,QAAQ,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC,CAiFpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,EAAE,EAAE,MAAM,GACT,QAAQ,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC,CAmDpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,EAAE,EAAE,MAAM,GACT,QAAQ,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC,CA6DpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,EAAE,EAAE,MAAM,GACT,QAAQ,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC,CA8EpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,MAAM,GACT,QAAQ,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC,CAiDrE"}