@evolu/common 6.0.1-preview.8 → 7.0.0

package/dist/src/Task.d.ts

@@ -0,0 +1,586 @@
+/**
+ * ⚡ Lazy, cancellable Promise that returns Result instead of throwing
+ *
+ * @module
+ */
+import { Result } from "./Result.js";
+import { Duration } from "./Time.js";
+import { PositiveInt } from "./Type.js";
+/**
+ * `Task` is a lazy, cancellable Promise that returns {@link Result} instead of
+ * throwing.
+ *
+ * In other words, Task is a function that creates a Promise when it's called.
+ * This laziness allows safe composition, e.g. retry logic because it prevents
+ * eager execution.
+ *
+ * ### Cancellation
+ *
+ * Tasks support optional cancellation via signal in {@link TaskContext}. When a
+ * Task is called without a signal, it cannot be cancelled and {@link AbortError}
+ * will never be returned. When called with a signal, the Task can be cancelled
+ * and AbortError is added to the error union with precise type safety.
+ *
+ * When composing Tasks, we typically have context and want to abort ASAP by
+ * passing it through. However, there are valid cases where we don't want to
+ * abort because we need some atomic unit to complete. For simple scripts and
+ * tests, omitting context is fine.
+ *
+ * ### Task Helpers
+ *
+ * - {@link toTask} - Convert async function to Task
+ * - {@link wait} - Delay execution for a specified {@link Duration}
+ * - {@link timeout} - Add timeout to any Task
+ * - {@link retry} - Retry failed Tasks with configurable backoff
+ *
+ * ### Example
+ *
+ * ```ts
+ * interface FetchError {
+ *   readonly type: "FetchError";
+ *   readonly error: unknown;
+ * }
+ *
+ * // Task version of fetch with proper error handling and cancellation support.
+ * const fetch = (url: string) =>
+ *   toTask((context) =>
+ *     tryAsync(
+ *       () => globalThis.fetch(url, { signal: context?.signal ?? null }),
+ *       (error): FetchError => ({ type: "FetchError", error }),
+ *     ),
+ *   );
+ *
+ * // `satisfies` shows the expected type signature.
+ * fetch satisfies (url: string) => Task<Response, FetchError>;
+ *
+ * // Add timeout to prevent hanging
+ * const fetchWithTimeout = (url: string) => timeout("30s", fetch(url));
+ *
+ * fetchWithTimeout satisfies (
+ *   url: string,
+ * ) => Task<Response, TimeoutError | FetchError>;
+ *
+ * // Add retry for resilience
+ * const fetchWithRetry = (url: string) =>
+ *   retry(
+ *     {
+ *       retries: PositiveInt.orThrow(3),
+ *       initialDelay: "100ms",
+ *     },
+ *     fetchWithTimeout(url),
+ *   );
+ *
+ * fetchWithRetry satisfies (
+ *   url: string,
+ * ) => Task<
+ *   Response,
+ *   TimeoutError | FetchError | RetryError<TimeoutError | FetchError>
+ * >;
+ *
+ * const semaphore = createSemaphore(PositiveInt.orThrow(2));
+ *
+ * // Control concurrency with semaphore
+ * const fetchWithPermit = (url: string) =>
+ *   semaphore.withPermit(fetchWithRetry(url));
+ *
+ * fetchWithPermit satisfies (url: string) => Task<
+ *   Response,
+ *   | TimeoutError
+ *   | FetchError
+ *   | AbortError // Semaphore dispose aborts Tasks
+ *   | RetryError<TimeoutError | FetchError>
+ * >;
+ *
+ * // Usage
+ * const results = await Promise.all(
+ *   [
+ *     "https://api.example.com/users",
+ *     "https://api.example.com/posts",
+ *     "https://api.example.com/comments",
+ *   ]
+ *     .map(fetchWithPermit)
+ *     .map((task) => task()),
+ * );
+ *
+ * results satisfies Array<
+ *   Result<
+ *     Response,
+ *     | AbortError
+ *     | TimeoutError
+ *     | FetchError
+ *     | RetryError<TimeoutError | FetchError>
+ *   >
+ * >;
+ *
+ * // Handle results
+ * for (const result of results) {
+ *   if (result.ok) {
+ *     // Process successful response
+ *     const response = result.value;
+ *     expect(response).toBeInstanceOf(Response);
+ *   } else {
+ *     // Handle error (TimeoutError, FetchError, RetryError, or AbortError)
+ *     expect(result.error).toBeDefined();
+ *   }
+ * }
+ *
+ * // Cancellation support
+ * const controller = new AbortController();
+ * const cancelableTask = fetchWithPermit("https://api.example.com/data");
+ *
+ * // Start task
+ * const promise = cancelableTask(controller);
+ *
+ * // Cancel after some time
+ * setTimeout(() => {
+ *   controller.abort("User cancelled");
+ * }, 1000);
+ *
+ * const _result = await promise;
+ * // Result will be AbortError if cancelled
+ * ```
+ *
+ * ### Dependency Injection Integration
+ *
+ * Tasks integrate naturally with Evolu's DI pattern. Use `deps` for static
+ * dependencies and `TaskContext` for execution context like cancellation. Usage
+ * follows the pattern: deps → arguments → execution context.
+ */
+export interface Task<T, E> {
+    /**
+     * Invoke the Task.
+     *
+     * Provide a context with an AbortSignal to enable cancellation. When called
+     * without a signal, {@link AbortError} cannot occur and the error type narrows
+     * accordingly.
+     *
+     * ### Example
+     *
+     * ```ts
+     * interface FetchError {
+     *   readonly type: "FetchError";
+     *   readonly error: unknown;
+     * }
+     *
+     * // Task version of fetch with proper error handling and cancellation support.
+     * const fetch = (url: string) =>
+     *   toTask((context) =>
+     *     tryAsync(
+     *       () => globalThis.fetch(url, { signal: context?.signal ?? null }),
+     *       (error): FetchError => ({ type: "FetchError", error }),
+     *     ),
+     *   );
+     *
+     * // `satisfies` shows the expected type signature.
+     * fetch satisfies (url: string) => Task<Response, FetchError>;
+     *
+     * const result1 = await fetch("https://api.example.com/data")();
+     * expectTypeOf(result1).toEqualTypeOf<Result<Response, FetchError>>();
+     *
+     * // With AbortController
+     * const controller = new AbortController();
+     * const result2 = await fetch("https://api.example.com/data")(
+     *   controller,
+     * );
+     * expectTypeOf(result2).toEqualTypeOf<
+     *   Result<Response, FetchError | AbortError>
+     * >();
+     * ```
+     */
+    <TContext extends TaskContext | undefined = undefined>(context?: TContext): Promise<Result<T, TContext extends {
+        signal: AbortSignal;
+    } ? E | AbortError : E>>;
+}
+/** Context passed to {@link Task}s for cancellation. */
+export interface TaskContext {
+    /** Signal for cancellation */
+    readonly signal?: AbortSignal;
+}
+/** Error returned when a {@link Task} is cancelled via AbortSignal. */
+export interface AbortError {
+    readonly type: "AbortError";
+    readonly reason?: unknown;
+}
+/**
+ * Converts async function returning {@link Result} to a {@link Task}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * interface FetchError {
+ *   readonly type: "FetchError";
+ *   readonly error: unknown;
+ * }
+ *
+ * // Task version of fetch with proper error handling and cancellation support.
+ * const fetch = (url: string) =>
+ *   toTask((context) =>
+ *     tryAsync(
+ *       () => globalThis.fetch(url, { signal: context?.signal ?? null }),
+ *       (error): FetchError => ({ type: "FetchError", error }),
+ *     ),
+ *   );
+ *
+ * // `satisfies` shows the expected type signature.
+ * fetch satisfies (url: string) => Task<Response, FetchError>;
+ *
+ * const result1 = await fetch("https://api.example.com/data")();
+ * result1 satisfies Result<Response, FetchError>;
+ *
+ * // With AbortController
+ * const controller = new AbortController();
+ * const result2 = await fetch("https://api.example.com/data")(controller);
+ * result2 satisfies Result<Response, FetchError | AbortError>;
+ * ```
+ */
+export declare const toTask: <T, E>(fn: (context?: TaskContext) => Promise<Result<T, E>>) => Task<T, E>;
+/**
+ * Creates a {@link Task} that waits for the specified duration.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const result1 = await wait("10ms")();
+ * result1 satisfies Result<void, never>;
+ *
+ * // With AbortController
+ * const controller = new AbortController();
+ * const result2 = await wait("10ms")(controller);
+ * result2 satisfies Result<void, AbortError>;
+ * ```
+ */
+export declare const wait: (duration: Duration) => Task<void, never>;
+/** Error returned when {@link timeout} exceeds the specified duration. */
+export interface TimeoutError {
+    readonly type: "TimeoutError";
+    readonly timeoutMs: number;
+}
+/**
+ * Adds timeout behavior to a {@link Task}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * interface FetchError {
+ *   readonly type: "FetchError";
+ *   readonly error: unknown;
+ * }
+ *
+ * // Task version of fetch with proper error handling and cancellation support.
+ * const fetch = (url: string) =>
+ *   toTask((context) =>
+ *     tryAsync(
+ *       () => globalThis.fetch(url, { signal: context?.signal ?? null }),
+ *       (error): FetchError => ({ type: "FetchError", error }),
+ *     ),
+ *   );
+ *
+ * // `satisfies` shows the expected type signature.
+ * fetch satisfies (url: string) => Task<Response, FetchError>;
+ *
+ * const fetchWithTimeout = (url: string) => timeout("2m", fetch(url));
+ *
+ * const result1 = await fetchWithTimeout("https://api.example.com/data")();
+ * result1 satisfies Result<Response, FetchError | TimeoutError>;
+ *
+ * // With AbortController
+ * const controller = new AbortController();
+ * const result2 = await fetchWithTimeout("https://api.example.com/data")(
+ *   controller,
+ * );
+ * result2 satisfies Result<
+ *   Response,
+ *   FetchError | TimeoutError | AbortError
+ * >;
+ * ```
+ */
+export declare const timeout: <T, E>(duration: Duration, task: Task<T, E>) => Task<T, E | TimeoutError>;
+/** Options for configuring {@link retry} behavior. */
+export interface RetryOptions<E> {
+    /** Number of retry attempts after the initial failure. */
+    readonly retries: PositiveInt;
+    /**
+     * Initial delay for exponential backoff (1st retry uses this, 2nd uses
+     * this×factor, 3rd uses this×factor², etc.). Actual delays are randomized by
+     * {@link RetryOptions.jitter}.
+     */
+    readonly initialDelay?: Duration;
+    /** Maximum delay between retries. */
+    readonly maxDelay?: Duration;
+    /** Exponential backoff multiplier. */
+    readonly factor?: number;
+    /** Random jitter factor (0-1) to prevent thundering herd. */
+    readonly jitter?: number;
+    /**
+     * Predicate to determine if error should trigger retry. Receives AbortError
+     * too.
+     */
+    readonly retryable?: (error: E | AbortError) => boolean;
+    /** Callback invoked before each retry attempt. */
+    readonly onRetry?: (error: E, attempt: number, delay: number) => void;
+}
+/** Error returned when {@link retry} exhausts all retry attempts. */
+export interface RetryError<E> {
+    readonly type: "RetryError";
+    readonly cause: E;
+    readonly attempts: number;
+}
+/**
+ * Adds retry logic with exponential backoff and jitter to a {@link Task}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * interface FetchError {
+ *   readonly type: "FetchError";
+ *   readonly error: unknown;
+ * }
+ *
+ * // Task version of fetch with proper error handling and cancellation support.
+ * const fetch = (url: string) =>
+ *   toTask((context) =>
+ *     tryAsync(
+ *       () => globalThis.fetch(url, { signal: context?.signal ?? null }),
+ *       (error): FetchError => ({ type: "FetchError", error }),
+ *     ),
+ *   );
+ *
+ * // `satisfies` shows the expected type signature.
+ * fetch satisfies (url: string) => Task<Response, FetchError>;
+ *
+ * const fetchWithRetry = (url: string) =>
+ *   retry({ retries: PositiveInt.orThrow(3) }, fetch(url));
+ *
+ * const result1 = await fetchWithRetry("https://api.example.com/data")();
+ * result1 satisfies Result<Response, FetchError | RetryError<FetchError>>;
+ *
+ * // With AbortController
+ * const controller = new AbortController();
+ * const result2 = await fetchWithRetry("https://api.example.com/data")(
+ *   controller,
+ * );
+ * result2 satisfies Result<
+ *   Response,
+ *   FetchError | RetryError<FetchError> | AbortError
+ * >;
+ * ```
+ */
+export declare const retry: <T, E>({ retries, initialDelay, maxDelay, factor, jitter, retryable, onRetry, }: RetryOptions<E>, task: Task<T, E>) => Task<T, E | RetryError<E>>;
+/**
+ * A semaphore that limits the number of concurrent async Tasks.
+ *
+ * For mutual exclusion (limiting to exactly one Task), consider using
+ * {@link Mutex} instead.
+ *
+ * @see {@link createSemaphore} to create a semaphore instance.
+ */
+export interface Semaphore extends Disposable {
+    /**
+     * Executes a Task while holding a semaphore permit.
+     *
+     * The Task will wait until a permit is available before executing. Supports
+     * cancellation via AbortSignal - if the signal is aborted while waiting for a
+     * permit or during execution, the Task is cancelled and permits are properly
+     * released.
+     */
+    readonly withPermit: <T, E>(task: Task<T, E>) => Task<T, E | AbortError>;
+}
+/**
+ * Creates a semaphore that limits concurrent async Tasks to the specified
+ * count.
+ *
+ * A semaphore controls access to a resource by maintaining a count of available
+ * permits. Tasks acquire a permit before executing and release it when
+ * complete.
+ *
+ * For mutual exclusion (exactly one Task at a time), consider using
+ * {@link createMutex} instead.
+ *
+ * ### Example
+ *
+ * ```ts
+ * // Allow maximum 3 concurrent Tasks
+ * const semaphore = createSemaphore(PositiveInt.orThrow(3));
+ *
+ * let currentConcurrent = 0;
+ * const events: Array<string> = [];
+ *
+ * const fetchData = (id: number) =>
+ *   toTask<number, never>(async (context) => {
+ *     currentConcurrent++;
+ *     events.push(`start ${id} (concurrent: ${currentConcurrent})`);
+ *
+ *     await wait("10ms")(context);
+ *
+ *     currentConcurrent--;
+ *     events.push(`end ${id} (concurrent: ${currentConcurrent})`);
+ *     return ok(id * 10);
+ *   });
+ *
+ * // These will execute with at most 3 running concurrently
+ * const results = await Promise.all([
+ *   semaphore.withPermit(fetchData(1))(),
+ *   semaphore.withPermit(fetchData(2))(),
+ *   semaphore.withPermit(fetchData(3))(),
+ *   semaphore.withPermit(fetchData(4))(), // waits for one above to complete
+ *   semaphore.withPermit(fetchData(5))(), // waits for permit
+ * ]);
+ *
+ * expect(results.map(getOrThrow)).toEqual([10, 20, 30, 40, 50]);
+ * expect(events).toMatchInlineSnapshot(`
+ *   [
+ *     "start 1 (concurrent: 1)",
+ *     "start 2 (concurrent: 2)",
+ *     "start 3 (concurrent: 3)",
+ *     "end 1 (concurrent: 2)",
+ *     "start 4 (concurrent: 3)",
+ *     "end 2 (concurrent: 2)",
+ *     "start 5 (concurrent: 3)",
+ *     "end 3 (concurrent: 2)",
+ *     "end 4 (concurrent: 1)",
+ *     "end 5 (concurrent: 0)",
+ *   ]
+ * `);
+ * ```
+ */
+export declare const createSemaphore: (maxConcurrent: PositiveInt) => Semaphore;
+/**
+ * A mutex (mutual exclusion) that ensures only one Task runs at a time.
+ *
+ * This is a specialized version of a {@link Semaphore} with a permit count of 1.
+ *
+ * @see {@link createMutex} to create a mutex instance.
+ */
+export interface Mutex extends Disposable {
+    /**
+     * Executes a Task while holding the mutex lock.
+     *
+     * Only one Task can hold the lock at a time. Other Tasks will wait until the
+     * lock is released. Supports cancellation via AbortSignal.
+     */
+    readonly withLock: <T, E>(task: Task<T, E>) => Task<T, E | AbortError>;
+}
+/**
+ * Creates a new mutex for ensuring mutual exclusion.
+ *
+ * A mutex is a {@link createSemaphore} with exactly one permit, ensuring that
+ * only one Task can execute at a time.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const mutex = createMutex();
+ *
+ * const updateTask = (id: number) =>
+ *   toTask((context) =>
+ *     tryAsync(
+ *       () => updateSharedResource(id, context),
+ *       (error): UpdateError => ({ type: "UpdateError", error }),
+ *     ),
+ *   );
+ *
+ * // These Tasks will execute one at a time
+ * const results = await Promise.all([
+ *   mutex.withLock(updateTask(1))(),
+ *   mutex.withLock(updateTask(2))(),
+ *   mutex.withLock(updateTask(3))(),
+ * ]);
+ * ```
+ */
+export declare const createMutex: () => Mutex;
+/**
+ * Schedule a task to run after all interactions (animations, gestures,
+ * navigation) have completed.
+ *
+ * This uses `requestIdleCallback` when available, otherwise falls back to
+ * `setTimeout(0)` for cross-platform compatibility.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const processDataTask: Task<void, ProcessError> = toTask(async () => {
+ *   // Heavy processing work
+ *   return ok();
+ * });
+ *
+ * // Schedule the task to run when idle
+ * void requestIdleTask(processDataTask)();
+ * ```
+ */
+export declare const requestIdleTask: <T, E>(task: Task<T, E>) => Task<T, E>;
+/**
+ * Represents a value that can be either synchronous or asynchronous.
+ *
+ * This type is useful for functions that may complete synchronously or
+ * asynchronously depending on runtime conditions (e.g., cache hit vs network
+ * fetch).
+ *
+ * ### Why MaybeAsync?
+ *
+ * When a function can be sync or async, the typical approaches are:
+ *
+ * 1. **Always return Promise** - Simple but forces microtask overhead even for
+ *    sync values (see "await always adds microtask" test in Task.test.ts)
+ * 2. **Use callbacks** - Can avoid microtask, but calling code must still `await`
+ *    for sane composition, which adds microtask anyway
+ * 3. **Return `T | PromiseLike<T>`** - Calling code can check the value and only
+ *    `await` when needed, avoiding microtask overhead for sync cases
+ *
+ * The third approach (MaybeAsync) provides:
+ *
+ * - **Performance**: No microtask overhead for synchronous operations
+ * - **Reliability**: No interleaving via microtask queue when operations are
+ *   _synchronous_, reducing need for mutexes to protect shared state
+ *
+ * ### Example
+ *
+ * ```ts
+ * // Function that may be sync or async
+ * const getData = (id: string): MaybeAsync<Data> => {
+ *   const cached = cache.get(id);
+ *   if (cached) return cached; // Sync path
+ *   return fetchData(id); // Async path
+ * };
+ *
+ * // Caller can optimize based on actual behavior
+ * const result = getData(id);
+ * const data = isAsync(result) ? await result : result;
+ * ```
+ *
+ * ### Alternative Approaches
+ *
+ * It's possible to eliminate the sync/async distinction using complex
+ * frameworks with custom schedulers. However, such frameworks require depending
+ * on other people's code that controls how your code executes, resulting in
+ * more complex stack traces and debugging experiences. With MaybeAsync, we
+ * don't need that machinery - it works directly with JavaScript's native
+ * primitives and TypeScript's type system.
+ *
+ * ### TODO: Consider
+ *
+ * Use MaybeAsync in Task and Task helpers to preserve synchronous execution
+ * when possible (e.g., mutex with available permit, retry on first success).
+ */
+export type MaybeAsync<T> = T | PromiseLike<T>;
+/**
+ * Type guard to check if a {@link MaybeAsync} value is async (a promise).
+ *
+ * This function narrows the type of a {@link MaybeAsync} value, allowing you to
+ * conditionally `await` only when necessary.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const getData = (id: string): MaybeAsync<Data> => {
+ *   const cached = cache.get(id);
+ *   if (cached) return cached; // Sync path
+ *   return fetchData(id); // Async path
+ * };
+ *
+ * const result = getData(id);
+ * const data = isAsync(result) ? await result : result;
+ * // No microtask overhead when cached!
+ * ```
+ */
+export declare const isAsync: <T>(value: MaybeAsync<T>) => value is T extends PromiseLike<unknown> ? never : PromiseLike<T>;
+//# sourceMappingURL=Task.d.ts.map

package/dist/src/Task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../src/Task.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,MAAM,EAAW,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAA4B,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAkB,WAAW,EAAE,MAAM,WAAW,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2IG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,EAAE,CAAC;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IAEH,CAAC,QAAQ,SAAS,WAAW,GAAG,SAAS,GAAG,SAAS,EACnD,OAAO,CAAC,EAAE,QAAQ,GACjB,OAAO,CACR,MAAM,CAAC,CAAC,EAAE,QAAQ,SAAS;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,GAAG,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC,CACzE,CAAC;CACH;AAED,wDAAwD;AACxD,MAAM,WAAW,WAAW;IAC1B,8BAA8B;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAgDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EACzB,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KACnD,IAAI,CAAC,CAAC,EAAE,CAAC,CAsCM,CAAC;AAiBnB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,GAAI,UAAU,QAAQ,KAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAkBvD,CAAC;AAEJ,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAC1B,UAAU,QAAQ,EAClB,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KACf,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,YAAY,CAcvB,CAAC;AAEL,sDAAsD;AACtD,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAE9B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC;IAEjC,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAE7B,sCAAsC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEzB,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,UAAU,KAAK,OAAO,CAAC;IAExD,kDAAkD;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvE;AAED,qEAAqE;AACrE,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EACxB,0EAQG,YAAY,CAAC,CAAC,CAAC,EAClB,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KACf,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAkDxB,CAAC;AAEL;;;;;;;GAOG;AACH,MAAM,WAAW,SAAU,SAAQ,UAAU;IAC3C;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC;CAC1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,eAAe,GAAI,eAAe,WAAW,KAAG,SA4D5D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,KAAM,SAAQ,UAAU;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC;CACxE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,WAAW,QAAO,KAO9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAQ/D,CAAC;AAOJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EACvB,OAAO,UAAU,CAAC,CAAC,CAAC,KACnB,KAAK,IAAI,CAAC,SAAS,WAAW,CAAC,OAAO,CAAC,GAAG,KAAK,GAAG,WAAW,CAAC,CAAC,CAEtB,CAAC"}