@ix-xs/node-comfort 1.1.31 → 2.0.0

package/types/src/Async.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Options for `map()`, `forEach()` and `filter()`.
+ */
+export type MapOptions = {
+    /**
+     * How many run at the same time. No limit by default.
+     */
+    concurrency?: number | undefined;
+    /**
+     * Stop at the first error. With `false`, everything runs and you get an `AggregateError` of all failures. Defaults to `true`.
+     */
+    stopOnError?: boolean | undefined;
+    /**
+     * Stops starting new work and rejects with an `AbortError`.
+     */
+    signal?: AbortSignal | undefined;
+};
+/**
+ * A limiter from `limit()`. Call it with a function to run it when there's room.
+ */
+export type Limiter = (<T>(fn: () => T | PromiseLike<T>) => Promise<Awaited<T>>) & {
+    readonly activeCount: number;
+    readonly pendingCount: number;
+    concurrency: number;
+    clearQueue(): void;
+    onIdle(): Promise<void>;
+};
+/**
+ * Options for `queue()`.
+ */
+export type QueueOptions = {
+    /**
+     * How many tasks run at the same time. Defaults to `1`.
+     */
+    concurrency?: number | undefined;
+    /**
+     * Start right away. Defaults to `true`.
+     */
+    autoStart?: boolean | undefined;
+    /**
+     * Time limit per task, like `"30s"`. A slower task rejects with a `TimeoutError`.
+     */
+    timeout?: string | number | undefined;
+};
+/**
+ * Options for `queue.add()`.
+ */
+export type QueueAddOptions = {
+    /**
+     * Higher goes first; equal priorities keep their order. Defaults to `0`.
+     */
+    priority?: number | undefined;
+};
+/**
+ * A queue from `queue()`.
+ */
+export type Queue = {
+    /**
+     * Adds a task; resolves with its result.
+     */
+    add: <T>(task: () => T | PromiseLike<T>, options?: QueueAddOptions) => Promise<Awaited<T>>;
+    /**
+     * Adds several tasks; resolves with all results.
+     */
+    addAll: <T>(tasks: Array<() => T | PromiseLike<T>>, options?: QueueAddOptions) => Promise<Array<Awaited<T>>>;
+    /**
+     * Stops starting tasks. Running ones finish.
+     */
+    pause: () => Queue;
+    /**
+     * Starts again.
+     */
+    start: () => Queue;
+    /**
+     * Drops the tasks that haven't started. Their promises never settle.
+     */
+    clear: () => void;
+    /**
+     * Resolves when nothing is waiting or running.
+     */
+    onIdle: () => Promise<void>;
+    /**
+     * Resolves when nothing is waiting.
+     */
+    onEmpty: () => Promise<void>;
+    /**
+     * Tasks waiting.
+     */
+    size: number;
+    /**
+     * Tasks running.
+     */
+    pending: number;
+    isPaused: boolean;
+    /**
+     * Can be changed on the fly.
+     */
+    concurrency: number;
+};
+/**
+ * A promise with its `resolve` and `reject`.
+ */
+export type Deferred<T> = {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+    /**
+     * Whether it's already resolved or rejected.
+     */
+    settled: boolean;
+};
+/**
+ * What `settle()` returns.
+ */
+export type Settled<T> = {
+    /**
+     * Successful values, in order.
+     */
+    fulfilled: T[];
+    /**
+     * Errors, in order.
+     */
+    rejected: unknown[];
+    /**
+     * Everything, like `Promise.allSettled`.
+     */
+    results: Array<PromiseSettledResult<T>>;
+};
+/**
+ * Options for `poll()`.
+ */
+export type PollOptions = {
+    /**
+     * Time between tries. Defaults to 100 ms.
+     */
+    interval?: string | number | undefined;
+    /**
+     * Give up with a `TimeoutError` after this long.
+     */
+    timeout?: string | number | undefined;
+    /**
+     * Stops with an `AbortError`.
+     */
+    signal?: AbortSignal | undefined;
+};
+/**
+ * A mutex from `mutex()`.
+ */
+export type Mutex = {
+    /**
+     * Runs `fn` once no other `run` is in progress.
+     */
+    run: <T>(fn: () => T | PromiseLike<T>) => Promise<Awaited<T>>;
+    /**
+     * Waits for the lock and gives you the function that releases it.
+     */
+    lock: () => Promise<() => void>;
+    isLocked: boolean;
+};
+/**
+ * Waits for a while. Same as `nc.wait()`.
+ *
+ * @example
+ * await async.sleep("250ms");
+ *
+ * @param {number | string} duration
+ * @param {{ signal?: AbortSignal }} [options]
+ * @returns {Promise<void>}
+ */
+export function sleep(duration: number | string, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+/**
+ * Maps items through an async function, with at most `concurrency` calls
+ * at once. Results stay in order.
+ *
+ * @example
+ * const users = await async.map(ids, (id) => api.getUser(id), { concurrency: 10 });
+ *
+ * @template T
+ * @template R
+ * @param {Iterable<T> | AsyncIterable<T>} items
+ * @param {(item: T, index: number) => R | PromiseLike<R>} fn
+ * @param {MapOptions} [options]
+ * @returns {Promise<Array<Awaited<R>>>}
+ * @throws The first error, an `AggregateError` with `stopOnError: false`, or an `AbortError`.
+ */
+export function map<T, R>(items: Iterable<T> | AsyncIterable<T>, fn: (item: T, index: number) => R | PromiseLike<R>, options?: MapOptions): Promise<Array<Awaited<R>>>;
+/**
+ * Runs an async function for every item, with a concurrency limit.
+ *
+ * @example
+ * await async.forEach(images, (image) => optimize(image), { concurrency: 4 });
+ *
+ * @template T
+ * @param {Iterable<T> | AsyncIterable<T>} items
+ * @param {(item: T, index: number) => unknown} fn
+ * @param {MapOptions} [options]
+ * @returns {Promise<void>}
+ */
+export function forEach<T>(items: Iterable<T> | AsyncIterable<T>, fn: (item: T, index: number) => unknown, options?: MapOptions): Promise<void>;
+/**
+ * Keeps the items that pass an async test, with a concurrency limit.
+ * Order is preserved.
+ *
+ * @example
+ * const alive = await async.filter(hosts, (host) => ping(host), { concurrency: 20 });
+ *
+ * @template T
+ * @param {Iterable<T> | AsyncIterable<T>} items
+ * @param {(item: T, index: number) => unknown} predicate
+ * @param {MapOptions} [options]
+ * @returns {Promise<T[]>}
+ */
+export function filter<T>(items: Iterable<T> | AsyncIterable<T>, predicate: (item: T, index: number) => unknown, options?: MapOptions): Promise<T[]>;
+/**
+ * Runs async functions one after the other and returns their results.
+ *
+ * @example
+ * await async.series([() => migrateUsers(), () => migrateOrders()]);
+ *
+ * @template T
+ * @param {Iterable<() => T | PromiseLike<T>>} tasks
+ * @returns {Promise<Array<Awaited<T>>>}
+ */
+export function series<T>(tasks: Iterable<() => T | PromiseLike<T>>): Promise<Array<Awaited<T>>>;
+/**
+ * A limiter: wrap calls with it, and at most `concurrency` run at once
+ * while the rest wait their turn. Like `p-limit`.
+ *
+ * @example
+ * const limit = async.limit(3);
+ * const results = await Promise.all(urls.map((url) => limit(() => fetch(url))));
+ *
+ * @param {number} concurrency
+ * @returns {Limiter}
+ */
+export function limit(concurrency: number): Limiter;
+/**
+ * A task queue with a concurrency limit, priorities, pause and per-task
+ * timeouts.
+ *
+ * @example
+ * const jobs = async.queue({ concurrency: 2, timeout: "30s" });
+ * jobs.add(() => sendEmail(a));
+ * jobs.add(() => sendEmail(vip), { priority: 10 }); // jumps the line
+ * await jobs.onIdle();
+ *
+ * @param {QueueOptions} [options]
+ * @returns {Queue}
+ */
+export function queue(options?: QueueOptions): Queue;
+/**
+ * A mutex: tasks given to `run()` never overlap. Put it around
+ * read-modify-write steps, like updating a file or refreshing a token.
+ *
+ * @example
+ * const lock = async.mutex();
+ * await lock.run(async () => {
+ *   const data = nc.readJSON("./counter.json", { n: 0 });
+ *   nc.writeJSON("./counter.json", { n: data.n + 1 });
+ * });
+ *
+ * @returns {Mutex}
+ */
+export function mutex(): Mutex;
+/**
+ * A promise along with its `resolve` and `reject`. Handy to connect
+ * callbacks or events to `await`.
+ *
+ * @example
+ * const ready = async.deferred();
+ * socket.once("open", () => ready.resolve());
+ * await ready.promise;
+ *
+ * @template [T=void]
+ * @returns {Deferred<T>}
+ */
+export function deferred<T = void>(): Deferred<T>;
+/**
+ * Waits for every promise and sorts successes from failures.
+ *
+ * @example
+ * const { fulfilled, rejected } = await async.settle(emails.map(send));
+ * nc.info(`${fulfilled.length} sent, ${rejected.length} failed`);
+ *
+ * @template T
+ * @param {Iterable<T | PromiseLike<T>>} promises
+ * @returns {Promise<Settled<Awaited<T>>>}
+ */
+export function settle<T>(promises: Iterable<T | PromiseLike<T>>): Promise<Settled<Awaited<T>>>;
+/**
+ * Like `Promise.all`, for an object of promises.
+ *
+ * @example
+ * const { user, orders } = await async.props({ user: getUser(id), orders: getOrders(id) });
+ *
+ * @template {Record<string, unknown>} T
+ * @param {T} object
+ * @returns {Promise<{ [K in keyof T]: Awaited<T[K]> }>}
+ */
+export function props<T extends Record<string, unknown>>(object: T): Promise<{ [K in keyof T]: Awaited<T[K]>; }>;
+/**
+ * Calls `fn` until it returns something truthy, and resolves with it.
+ * Errors count as "not yet".
+ *
+ * @example
+ * await async.poll(() => fetch(healthUrl).then((res) => res.ok), { interval: "500ms", timeout: "30s" });
+ *
+ * @template T
+ * @param {() => T | PromiseLike<T>} fn
+ * @param {PollOptions} [options]
+ * @returns {Promise<NonNullable<Awaited<T>>>}
+ * @throws {TimeoutError}
+ * @throws {AbortError}
+ */
+export function poll<T>(fn: () => T | PromiseLike<T>, options?: PollOptions): Promise<NonNullable<Awaited<T>>>;
+import { retry } from "./Func.js";
+import { timeout } from "./Func.js";
+export { retry, timeout };
+//# sourceMappingURL=Async.d.ts.map

package/types/src/Async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Async.d.ts","sourceRoot":"","sources":["../../src/Async.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;sBA4Ba,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,IAAI,IAAI,CAAC;IAAC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAoB7L,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;;;;YACrF,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;;;;WACpG,MAAM,KAAK;;;;WACX,MAAM,KAAK;;;;WACX,MAAM,IAAI;;;;YACV,MAAM,OAAO,CAAC,IAAI,CAAC;;;;aACnB,MAAM,OAAO,CAAC,IAAI,CAAC;;;;UACnB,MAAM;;;;aACN,MAAM;cACN,OAAO;;;;iBACP,MAAM;;;;;qBAKP,CAAC;aAEA,OAAO,CAAC,CAAC,CAAC;aACV,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;YACnC,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI;;;;aAC1B,OAAO;;;;;oBAKR,CAAC;;;;eAEA,CAAC,EAAE;;;;cACH,OAAO,EAAE;;;;aACT,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;SAc9B,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;;;;UACxD,MAAM,OAAO,CAAC,MAAM,IAAI,CAAC;cACzB,OAAO;;AAYrB;;;;;;;;;GASG;AACH,gCAJW,MAAM,GAAG,MAAM,YACf;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACtB,OAAO,CAAC,IAAI,CAAC,CAIzB;AAED;;;;;;;;;;;;;;GAcG;AACH,oBARa,CAAC,EACD,CAAC,SACH,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,MAC9B,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,YAC9C,UAAU,GACR,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAgEtC;AAED;;;;;;;;;;;GAWG;AACH,wBANa,CAAC,SACH,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,MAC9B,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,YACnC,UAAU,GACR,OAAO,CAAC,IAAI,CAAC,CAIzB;AAED;;;;;;;;;;;;GAYG;AACH,uBANa,CAAC,SACH,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,aAC9B,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,YACnC,UAAU,GACR,OAAO,CAAC,CAAC,EAAE,CAAC,CASxB;AAED;;;;;;;;;GASG;AACH,uBAJa,CAAC,SACH,QAAQ,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GAChC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAOtC;AAED;;;;;;;;;;GAUG;AACH,mCAHW,MAAM,GACJ,OAAO,CA8CnB;AAED;;;;;;;;;;;;GAYG;AACH,gCAHW,YAAY,GACV,KAAK,CAiGjB;AAED;;;;;;;;;;;;GAYG;AACH,yBAFa,KAAK,CA4BjB;AAED;;;;;;;;;;;GAWG;AACH,yBAHc,CAAC,YACF,QAAQ,CAAC,CAAC,CAAC,CAwBvB;AAED;;;;;;;;;;GAUG;AACH,uBAJa,CAAC,YACH,QAAQ,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CASxC;AAED;;;;;;;;;GASG;AACH,sBAJuC,CAAC,SAA1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,UAC3B,CAAC,GACC,OAAO,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAE,CAAC,CAWtD;AAED;;;;;;;;;;;;;GAaG;AACH,qBAPa,CAAC,MACH,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,YACxB,WAAW,GACT,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAoB5C"}

package/types/src/Cache.d.ts

@@ -0,0 +1,195 @@
+export = Cache;
+/**
+ * An in-memory cache with a size limit and expiry.
+ *
+ * @template K
+ * @template V
+ */
+declare class Cache<K, V> {
+    /**
+     * @example
+     * const cache = new nc.Cache({ max: 500, ttl: "1h", updateAgeOnGet: true });
+     *
+     * @param {CacheOptions<K, V>} [options]
+     */
+    constructor(options?: CacheOptions<K, V>);
+    /**
+     * Reads a value and marks it as recently used.
+     *
+     * @param {K} key
+     * @returns {V | undefined} `undefined` if missing or expired.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Reads a value without counting it as a use or touching the stats.
+     *
+     * @param {K} key
+     * @returns {V | undefined}
+     */
+    peek(key: K): V | undefined;
+    /**
+     * Stores a value. When the cache is full, the least recently used entry
+     * goes.
+     *
+     * @example
+     * cache.set("token", token, { ttl: "15m" });
+     *
+     * @param {K} key
+     * @param {V} value
+     * @param {CacheSetOptions} [options]
+     * @returns {this}
+     */
+    set(key: K, value: V, options?: CacheSetOptions): this;
+    /**
+     * Returns the cached value, or calls `loader`, stores the result and
+     * returns it. Simultaneous calls for the same key share one `loader` call,
+     * and a failed load caches nothing.
+     *
+     * @example
+     * const profile = await cache.getOrSet(`profile:${id}`, () => api.fetchProfile(id), { ttl: "10m" });
+     *
+     * @param {K} key
+     * @param {() => V | PromiseLike<V>} loader
+     * @param {CacheSetOptions} [options]
+     * @returns {Promise<V>}
+     */
+    getOrSet(key: K, loader: () => V | PromiseLike<V>, options?: CacheSetOptions): Promise<V>;
+    /**
+     * Is there a fresh entry for this key? Doesn't count as a use.
+     *
+     * @param {K} key
+     * @returns {boolean}
+     */
+    has(key: K): boolean;
+    /**
+     * Removes an entry.
+     *
+     * @param {K} key
+     * @returns {boolean} `true` if there was one.
+     */
+    delete(key: K): boolean;
+    /**
+     * Removes every entry. Stats are kept.
+     *
+     * @returns {void}
+     */
+    clear(): void;
+    /**
+     * Removes expired entries now instead of waiting for them to be read.
+     *
+     * @returns {number} How many were removed.
+     */
+    prune(): number;
+    /**
+     * Time left before an entry expires.
+     *
+     * @param {K} key
+     * @returns {number | undefined} Milliseconds, `Infinity` if it never expires, `undefined` if missing.
+     */
+    ttl(key: K): number | undefined;
+    /**
+     * Wraps a function so its results are cached here.
+     *
+     * @example
+     * const getWeather = cache.wrap((city) => api.weather(city), { key: (city) => city.toLowerCase(), ttl: "30m" });
+     * await getWeather("Paris");
+     *
+     * @template {any[]} A
+     * @param {(...args: A) => V | PromiseLike<V>} fn
+     * @param {{ key?: (...args: A) => K, ttl?: number | string }} [options] `key` builds the cache key from the arguments; by default they're turned into JSON.
+     * @returns {(...args: A) => Promise<V>}
+     */
+    wrap<A extends any[]>(fn: (...args: A) => V | PromiseLike<V>, options?: {
+        key?: (...args: A) => K;
+        ttl?: number | string;
+    }): (...args: A) => Promise<V>;
+    /** Number of entries, including expired ones not yet removed. */
+    get size(): number;
+    /** Hit and miss counts. */
+    get stats(): CacheStats;
+    /**
+     * Fresh keys, least recently used first.
+     * @returns {K[]}
+     */
+    keys(): K[];
+    /**
+     * Fresh values, least recently used first.
+     * @returns {V[]}
+     */
+    values(): V[];
+    /**
+     * Fresh `[key, value]` pairs, least recently used first.
+     * @returns {Array<[K, V]>}
+     */
+    entries(): Array<[K, V]>;
+    /**
+     * Lets you write `for (const [key, value] of cache)`.
+     * @returns {IterableIterator<[K, V]>}
+     */
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    #private;
+}
+declare namespace Cache {
+    export { CacheRemovalReason, CacheOptions, CacheSetOptions, CacheStats };
+}
+/**
+ * Why an entry left the cache.
+ */
+type CacheRemovalReason = "evict" | "expire" | "delete" | "set" | "clear";
+/**
+ * Options for `new Cache()`.
+ */
+type CacheOptions<K, V> = {
+    /**
+     * Maximum number of entries. When full, the least recently used goes. No limit by default.
+     */
+    max?: number | undefined;
+    /**
+     * How long entries live, in ms or like `"10m"`. `0` means forever, the default.
+     */
+    ttl?: string | number | undefined;
+    /**
+     * Reading an entry restarts its time to live.
+     */
+    updateAgeOnGet?: boolean | undefined;
+    /**
+     * Called whenever an entry leaves the cache.
+     */
+    onRemove?: ((key: K, value: V, reason: CacheRemovalReason) => void) | undefined;
+};
+/**
+ * Options for `set()` and `getOrSet()`.
+ */
+type CacheSetOptions = {
+    /**
+     * Time to live of this entry. `0` means forever.
+     */
+    ttl?: string | number | undefined;
+};
+/**
+ * Cache stats.
+ */
+type CacheStats = {
+    /**
+     * Reads that found a fresh entry.
+     */
+    hits: number;
+    /**
+     * Reads that found nothing or an expired entry.
+     */
+    misses: number;
+    sets: number;
+    /**
+     * Entries dropped because the cache was full.
+     */
+    evictions: number;
+    /**
+     * Entries dropped because they expired.
+     */
+    expirations: number;
+    /**
+     * From 0 to 1.
+     */
+    hitRate: number;
+};
+//# sourceMappingURL=Cache.d.ts.map

package/types/src/Cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../src/Cache.js"],"names":[],"mappings":";AA4DA;;;;;GAKG;AACH,oBAHa,CAAC,EACD,CAAC;IAcZ;;;;;OAKG;IACH,sBAFW,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,EAO5B;IA4BD;;;;;OAKG;IACH,SAHW,CAAC,GACC,CAAC,GAAG,SAAS,CAazB;IAED;;;;;OAKG;IACH,UAHW,CAAC,GACC,CAAC,GAAG,SAAS,CAIzB;IAED;;;;;;;;;;;OAWG;IACH,SALW,CAAC,SACD,CAAC,YACD,eAAe,GACb,IAAI,CAahB;IAED;;;;;;;;;;;;OAYG;IACH,cALW,CAAC,UACD,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,YACxB,eAAe,GACb,OAAO,CAAC,CAAC,CAAC,CAiBtB;IAED;;;;;OAKG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;;;;OAKG;IACH,YAHW,CAAC,GACC,OAAO,CAOnB;IAED;;;;OAIG;IACH,SAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,SAFa,MAAM,CAYlB;IAED;;;;;OAKG;IACH,SAHW,CAAC,GACC,MAAM,GAAG,SAAS,CAM9B;IAED;;;;;;;;;;;OAWG;IACH,KALqB,CAAC,SAAR,GAAG,EAAG,MACT,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,YAClC;QAAE,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAChD,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAOtC;IAED,iEAAiE;IACjE,mBAEC;IAED,2BAA2B;IAC3B,aAEoB,UAAU,CAC7B;IAED;;;OAGG;IACH,QAFa,CAAC,EAAE,CAKf;IAED;;;OAGG;IACH,UAFa,CAAC,EAAE,CAKf;IAED;;;OAGG;IACH,WAFa,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAKzB;IAED;;;OAGG;IACH,qBAFa,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAIpC;;CACF;;;;;;;0BArTY,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO;;;;kBAK/C,CAAC,EACD,CAAC;;;;;;;;;;;;;;;;sBAKM,CAAC,SAAS,CAAC,UAAU,kBAAkB,KAAK,IAAI;;;;;;;;;;;;;;;;;;UAYtD,MAAM;;;;YACN,MAAM;UACN,MAAM;;;;eACN,MAAM;;;;iBACN,MAAM;;;;aACN,MAAM"}