@versori/run 0.3.0-veta.1 → 0.4.0-alpha.1

package/script/deps/jsr.io/@std/cache/0.2.0/lru_cache.js

@@ -1,155 +0,0 @@
-"use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _LruCache_instances, _LruCache_setMostRecentlyUsed, _LruCache_pruneToMaxSize;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LruCache = void 0;
-/**
- * Least-recently-used cache.
- *
- * @experimental **UNSTABLE**: New API, yet to be vetted.
- *
- * @see {@link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU | Least-recently-used cache}
- *
- * Automatically removes entries above the max size based on when they were
- * last accessed with `get`, `set`, or `has`.
- *
- * @typeParam K The type of the cache keys.
- * @typeParam V The type of the cache values.
- *
- * @example Basic usage
- * ```ts
- * import { LruCache } from "@std/cache";
- * import { assert, assertEquals } from "@std/assert";
- *
- * const MAX_SIZE = 3;
- * const cache = new LruCache<string, number>(MAX_SIZE);
- *
- * cache.set("a", 1);
- * cache.set("b", 2);
- * cache.set("c", 3);
- * cache.set("d", 4);
- *
- * // most recent values are stored up to `MAX_SIZE`
- * assertEquals(cache.get("b"), 2);
- * assertEquals(cache.get("c"), 3);
- * assertEquals(cache.get("d"), 4);
- *
- * // less recent values are removed
- * assert(!cache.has("a"));
- * ```
- */
-class LruCache extends Map {
-    /**
-     * Constructs a new `LruCache`.
-     *
-     * @param maxSize The maximum number of entries to store in the cache.
-     */
-    constructor(maxSize) {
-        super();
-        _LruCache_instances.add(this);
-        /**
-         * The maximum number of entries to store in the cache.
-         *
-         * @example Max size
-         * ```ts no-assert
-         * import { LruCache } from "@std/cache";
-         * import { assertEquals } from "@std/assert";
-         *
-         * const cache = new LruCache<string, number>(100);
-         * assertEquals(cache.maxSize, 100);
-         * ```
-         */
-        Object.defineProperty(this, "maxSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.maxSize = maxSize;
-    }
-    /**
-     * Checks whether an element with the specified key exists or not.
-     *
-     * @param key The key to check.
-     * @returns `true` if the cache contains the specified key, otherwise `false`.
-     *
-     * @example Checking for the existence of a key
-     * ```ts
-     * import { LruCache } from "@std/cache";
-     * import { assert } from "@std/assert";
-     *
-     * const cache = new LruCache<string, number>(100);
-     *
-     * cache.set("a", 1);
-     * assert(cache.has("a"));
-     * ```
-     */
-    has(key) {
-        const exists = super.has(key);
-        if (exists) {
-            __classPrivateFieldGet(this, _LruCache_instances, "m", _LruCache_setMostRecentlyUsed).call(this, key, super.get(key));
-        }
-        return exists;
-    }
-    /**
-     * Gets the element with the specified key.
-     *
-     * @param key The key to get the value for.
-     * @returns The value associated with the specified key, or `undefined` if the key is not present in the cache.
-     *
-     * @example Getting a value from the cache
-     * ```ts
-     * import { LruCache } from "@std/cache";
-     * import { assertEquals } from "@std/assert";
-     *
-     * const cache = new LruCache<string, number>(100);
-     *
-     * cache.set("a", 1);
-     * assertEquals(cache.get("a"), 1);
-     * ```
-     */
-    get(key) {
-        if (super.has(key)) {
-            const value = super.get(key);
-            __classPrivateFieldGet(this, _LruCache_instances, "m", _LruCache_setMostRecentlyUsed).call(this, key, value);
-            return value;
-        }
-        return undefined;
-    }
-    /**
-     * Sets the specified key to the specified value.
-     *
-     * @param key The key to set the value for.
-     * @param value The value to set.
-     * @returns `this` for chaining.
-     *
-     * @example Setting a value in the cache
-     * ```ts no-assert
-     * import { LruCache } from "@std/cache";
-     *
-     * const cache = new LruCache<string, number>(100);
-     * cache.set("a", 1);
-     * ```
-     */
-    set(key, value) {
-        __classPrivateFieldGet(this, _LruCache_instances, "m", _LruCache_setMostRecentlyUsed).call(this, key, value);
-        __classPrivateFieldGet(this, _LruCache_instances, "m", _LruCache_pruneToMaxSize).call(this);
-        return this;
-    }
-}
-exports.LruCache = LruCache;
-_LruCache_instances = new WeakSet(), _LruCache_setMostRecentlyUsed = function _LruCache_setMostRecentlyUsed(key, value) {
-    // delete then re-add to ensure most recently accessed elements are last
-    super.delete(key);
-    super.set(key, value);
-}, _LruCache_pruneToMaxSize = function _LruCache_pruneToMaxSize() {
-    if (this.size > this.maxSize) {
-        this.delete(this.keys().next().value);
-    }
-};

package/script/deps/jsr.io/@std/cache/0.2.0/memoize.d.ts

@@ -1,111 +0,0 @@
-/**
- * A cache suitable for use with {@linkcode memoize}.
- *
- * @experimental **UNSTABLE**: New API, yet to be vetted.
- */
-export type MemoizationCache<K, V> = {
-    has: (key: K) => boolean;
-    get: (key: K) => V | undefined;
-    set: (key: K, val: V) => unknown;
-    delete: (key: K) => unknown;
-};
-/**
- * The result of a memoized function, as stored in its cache.
- *
- * @experimental **UNSTABLE**: New API, yet to be vetted.
- */
-export type MemoizationCacheResult<T> = {
-    kind: "ok";
-    value: T;
-} | {
-    kind: "error";
-    error: unknown;
-} | (T extends Promise<unknown> ? {
-    kind: "promise";
-    value: T;
-} : never);
-/**
- * Options for {@linkcode memoize}.
- *
- * @experimental **UNSTABLE**: New API, yet to be vetted.
- *
- * @typeParam Fn The type of the function to memoize.
- * @typeParam Key The type of the cache key.
- * @typeParam Cache The type of the cache.
- */
-export type MemoizeOptions<Fn extends (...args: never[]) => unknown, Key, Cache extends MemoizationCache<Key, MemoizationCacheResult<ReturnType<Fn>>>> = {
-    /**
-     * Provide a custom cache for getting previous results. By default, a new
-     * {@linkcode Map} object is instantiated upon memoization and used as a cache, with no
-     * limit on the number of results to be cached.
-     *
-     * Alternatively, you can supply a {@linkcode LruCache} with a specified max
-     * size to limit memory usage.
-     */
-    cache?: Cache;
-    /**
-     * Function to get a unique cache key from the function's arguments. By
-     * default, a composite key is created from all the arguments plus the `this`
-     * value, using reference equality to check for equivalence.
-     *
-     * @example
-     * ```ts
-     * import { memoize } from "@std/cache";
-     * import { assertEquals } from "@std/assert";
-     *
-     * const fn = memoize(({ value }: { cacheKey: number; value: number }) => {
-     *   return value;
-     * }, { getKey: ({ cacheKey }) => cacheKey });
-     *
-     * assertEquals(fn({ cacheKey: 1, value: 2 }), 2);
-     * assertEquals(fn({ cacheKey: 1, value: 99 }), 2);
-     * assertEquals(fn({ cacheKey: 2, value: 99 }), 99);
-     * ```
-     */
-    getKey?: (this: ThisParameterType<Fn>, ...args: Parameters<Fn>) => Key;
-    /**
-     * Callback to determine if an error or other thrown value is cacheable.
-     *
-     * @default {() => false}
-     *
-     * @param err The thrown error or other value.
-     * @returns `true` if the error is cacheable, `false` otherwise.
-     */
-    errorIsCacheable?: (err: unknown) => boolean;
-};
-/**
- * Cache the results of a function based on its arguments.
- *
- * @experimental **UNSTABLE**: New API, yet to be vetted.
- *
- * @typeParam Fn The type of the function to memoize.
- * @typeParam Key The type of the cache key.
- * @typeParam Cache The type of the cache.
- * @param fn The function to memoize
- * @param options Options for memoization
- *
- * @returns The memoized function.
- *
- * @example Basic usage
- * ```ts
- * import { memoize } from "@std/cache";
- * import { assertEquals } from "@std/assert";
- *
- * // fibonacci function, which is very slow for n > ~30 if not memoized
- * const fib = memoize((n: bigint): bigint => {
- *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
- * });
- *
- * assertEquals(fib(100n), 354224848179261915075n);
- * ```
- *
- * > [!NOTE]
- * > * By default, memoization is on the basis of all arguments passed to the
- * >   function, with equality determined by reference. This means that, for
- * >   example, passing a memoized function as `arr.map(func)` will not use the
- * >   cached results, as the index is implicitly passed as an argument. To
- * >   avoid this, you can pass a custom `getKey` option or use the memoized
- * >   function inside an anonymous callback like `arr.map((x) => func(x))`.
- */
-export declare function memoize<Fn extends (...args: never[]) => unknown, Key = string, Cache extends MemoizationCache<Key, MemoizationCacheResult<ReturnType<Fn>>> = Map<Key, MemoizationCacheResult<ReturnType<Fn>>>>(fn: Fn, options?: MemoizeOptions<Fn, Key, Cache>): Fn;
-//# sourceMappingURL=memoize.d.ts.map

package/script/deps/jsr.io/@std/cache/0.2.0/memoize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/memoize.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,IAAI;IACnC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IACzB,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAC/B,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IACjC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;CAC7B,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAChC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG,KAAK,CAAC,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,CACxB,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EACxC,GAAG,EACH,KAAK,SAAS,gBAAgB,CAAC,GAAG,EAAE,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,IACzE;IACF;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC;IACvE;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,OAAO,CACrB,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EACxC,GAAG,GAAG,MAAM,EACZ,KAAK,SAAS,gBAAgB,CAAC,GAAG,EAAE,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,GACzE,GAAG,CACD,GAAG,EACH,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CACvC,EAEH,EAAE,EAAE,EAAE,EACN,OAAO,CAAC,EAAE,cAAc,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,GACvC,EAAE,CA+DJ"}

package/script/deps/jsr.io/@std/cache/0.2.0/memoize.js

@@ -1,85 +0,0 @@
-"use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.memoize = memoize;
-const _serialize_arg_list_js_1 = require("./_serialize_arg_list.js");
-/**
- * Cache the results of a function based on its arguments.
- *
- * @experimental **UNSTABLE**: New API, yet to be vetted.
- *
- * @typeParam Fn The type of the function to memoize.
- * @typeParam Key The type of the cache key.
- * @typeParam Cache The type of the cache.
- * @param fn The function to memoize
- * @param options Options for memoization
- *
- * @returns The memoized function.
- *
- * @example Basic usage
- * ```ts
- * import { memoize } from "@std/cache";
- * import { assertEquals } from "@std/assert";
- *
- * // fibonacci function, which is very slow for n > ~30 if not memoized
- * const fib = memoize((n: bigint): bigint => {
- *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
- * });
- *
- * assertEquals(fib(100n), 354224848179261915075n);
- * ```
- *
- * > [!NOTE]
- * > * By default, memoization is on the basis of all arguments passed to the
- * >   function, with equality determined by reference. This means that, for
- * >   example, passing a memoized function as `arr.map(func)` will not use the
- * >   cached results, as the index is implicitly passed as an argument. To
- * >   avoid this, you can pass a custom `getKey` option or use the memoized
- * >   function inside an anonymous callback like `arr.map((x) => func(x))`.
- */
-function memoize(fn, options) {
-    const cache = options?.cache ?? new Map();
-    const getKey = options?.getKey ??
-        (0, _serialize_arg_list_js_1._serializeArgList)(cache);
-    const errorIsCacheable = options?.errorIsCacheable ?? (() => false);
-    const memoized = function (...args) {
-        const key = getKey.apply(this, args);
-        if (cache.has(key)) {
-            const result = cache.get(key);
-            switch (result.kind) {
-                case "ok":
-                case "promise":
-                    return result.value;
-                case "error":
-                    throw result.error;
-            }
-        }
-        try {
-            let value = fn.apply(this, args);
-            if (value instanceof Promise) {
-                value = value.catch((reason) => {
-                    if (!errorIsCacheable(reason)) {
-                        cache.delete(key);
-                    }
-                    throw reason;
-                });
-                cache.set(key, { kind: "promise", value });
-            }
-            else {
-                cache.set(key, { kind: "ok", value });
-            }
-            return value;
-        }
-        catch (e) {
-            if (errorIsCacheable(e)) {
-                cache.set(key, { kind: "error", error: e });
-            }
-            throw e;
-        }
-    };
-    return Object.defineProperties(memoized, {
-        length: { value: fn.length },
-        name: { value: fn.name },
-    });
-}

package/script/deps/jsr.io/@std/cache/0.2.0/mod.d.ts

@@ -1,24 +0,0 @@
-/**
- * In-memory cache utilities, such as memoization and caches with different
- * expiration policies.
- *
- * ```ts
- * import { memoize, LruCache, type MemoizationCacheResult } from "@std/cache";
- * import { assertEquals } from "@std/assert";
- *
- * const cache = new LruCache<string, MemoizationCacheResult<bigint>>(1000);
- *
- * // fibonacci function, which is very slow for n > ~30 if not memoized
- * const fib = memoize((n: bigint): bigint => {
- *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
- * }, { cache });
- *
- * assertEquals(fib(100n), 354224848179261915075n);
- * ```
- *
- * @module
- */
-export * from "./lru_cache.js";
-export * from "./memoize.js";
-export * from "./ttl_cache.js";
-//# sourceMappingURL=mod.d.ts.map

package/script/deps/jsr.io/@std/cache/0.2.0/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}

package/script/deps/jsr.io/@std/cache/0.2.0/mod.js

@@ -1,41 +0,0 @@
-"use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-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 });
-/**
- * In-memory cache utilities, such as memoization and caches with different
- * expiration policies.
- *
- * ```ts
- * import { memoize, LruCache, type MemoizationCacheResult } from "@std/cache";
- * import { assertEquals } from "@std/assert";
- *
- * const cache = new LruCache<string, MemoizationCacheResult<bigint>>(1000);
- *
- * // fibonacci function, which is very slow for n > ~30 if not memoized
- * const fib = memoize((n: bigint): bigint => {
- *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
- * }, { cache });
- *
- * assertEquals(fib(100n), 354224848179261915075n);
- * ```
- *
- * @module
- */
-__exportStar(require("./lru_cache.js"), exports);
-__exportStar(require("./memoize.js"), exports);
-__exportStar(require("./ttl_cache.js"), exports);

package/script/deps/jsr.io/@std/cache/0.2.0/ttl_cache.d.ts

@@ -1,129 +0,0 @@
-import type { MemoizationCache } from "./memoize.js";
-/**
- * Time-to-live cache.
- *
- * @experimental **UNSTABLE**: New API, yet to be vetted.
- *
- * Automatically removes entries after the configured amount of time elapses.
- *
- * @typeParam K The type of the cache keys.
- * @typeParam V The type of the cache values.
- *
- * @example Usage
- * ```ts
- * import { TtlCache } from "@std/cache/ttl-cache";
- * import { assertEquals } from "@std/assert/equals";
- * import { delay } from "@std/async/delay";
- *
- * const cache = new TtlCache<string, number>(1000);
- *
- * cache.set("a", 1);
- * assertEquals(cache.size, 1);
- * await delay(2000);
- * assertEquals(cache.size, 0);
- * ```
- */
-export declare class TtlCache<K, V> extends Map<K, V> implements MemoizationCache<K, V> {
-    #private;
-    /**
-     * Constructs a new instance.
-     *
-     * @experimental **UNSTABLE**: New API, yet to be vetted.
-     *
-     * @param defaultTtl The default time-to-live in milliseconds. This value must
-     * be equal to or greater than 0. Its limit is determined by the current
-     * runtime's {@linkcode setTimeout} implementation.
-     */
-    constructor(defaultTtl: number);
-    /**
-     * Set a value in the cache.
-     *
-     * @experimental **UNSTABLE**: New API, yet to be vetted.
-     *
-     * @param key The cache key
-     * @param value The value to set
-     * @param ttl A custom time-to-live. If supplied, overrides the cache's
-     * default TTL for this entry. This value must
-     * be equal to or greater than 0. Its limit is determined by the current
-     * runtime's {@linkcode setTimeout} implementation.
-     * @returns `this` for chaining.
-     *
-     * @example Usage
-     * ```ts
-     * import { TtlCache } from "@std/cache/ttl-cache";
-     * import { assertEquals } from "@std/assert/equals";
-     * import { delay } from "@std/async/delay";
-     *
-     * const cache = new TtlCache<string, number>(100);
-     *
-     * cache.set("a", 1);
-     * assertEquals(cache.get("a"), 1);
-     *
-     * await delay(200);
-     * assertEquals(cache.get("a"), undefined);
-     * ```
-     */
-    set(key: K, value: V, ttl?: number): this;
-    /**
-     * Deletes the value associated with the given key.
-     *
-     * @experimental **UNSTABLE**: New API, yet to be vetted.
-     *
-     * @param key The key to delete.
-     * @returns `true` if the key was deleted, `false` otherwise.
-     *
-     * @example Usage
-     * ```ts
-     * import { TtlCache } from "@std/cache";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const cache = new TtlCache<string, number>(1000);
-     *
-     * cache.set("a", 1);
-     * cache.delete("a");
-     * assertEquals(cache.has("a"), false);
-     * ```
-     */
-    delete(key: K): boolean;
-    /**
-     * Clears the cache.
-     *
-     * @experimental **UNSTABLE**: New API, yet to be vetted.
-     *
-     * @example Usage
-     * ```ts
-     * import { TtlCache } from "@std/cache";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const cache = new TtlCache<string, number>(1000);
-     *
-     * cache.set("a", 1);
-     * cache.set("b", 2);
-     * cache.clear();
-     * assertEquals(cache.size, 0);
-     * ```
-     */
-    clear(): void;
-    /**
-     * Automatically clears all remaining timeouts once the cache goes out of
-     * scope if the cache is declared with `using`.
-     *
-     * @experimental **UNSTABLE**: New API, yet to be vetted.
-     *
-     * @example Usage
-     * ```ts no-assert
-     * import { TtlCache } from "@std/cache/ttl-cache";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * let c: TtlCache<string, number>;
-     * {
-     *  using cache = new TtlCache<string, number>(1000);
-     *  cache.set("a", 1);
-     *  c = cache;
-     * }
-     * assertEquals(c.size, 0);
-     * ```
-     */
-    [Symbol.dispose](): void;
-}
-//# sourceMappingURL=ttl_cache.d.ts.map

package/script/deps/jsr.io/@std/cache/0.2.0/ttl_cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ttl_cache.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/ttl_cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAC1C,YAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;;IAIjC;;;;;;;;OAQG;gBACS,UAAU,EAAE,MAAM;IAK9B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAE,MAAyB,GAAG,IAAI;IAOpE;;;;;;;;;;;;;;;;;;;OAmBG;IACM,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAMhC;;;;;;;;;;;;;;;;;OAiBG;IACM,KAAK,IAAI,IAAI;IAQtB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAGzB"}