@seyuna/cli 1.0.0-canary.23 → 1.0.0-canary.24

package/esm/deps/jsr.io/@std/async/1.0.16/retry.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Error thrown in {@linkcode retry} once the maximum number of failed attempts
+ * has been reached.
+ *
+ * @example Usage
+ * ```ts no-assert ignore
+ * import { RetryError } from "@std/async/retry";
+ *
+ * throw new RetryError({ foo: "bar" }, 3);
+ * ```
+ */
+export declare class RetryError extends Error {
+    /**
+     * Constructs a new {@linkcode RetryError} instance.
+     *
+     * @param cause the cause for this error.
+     * @param attempts the number of retry attempts made.
+     */
+    constructor(cause: unknown, attempts: number);
+}
+/** Options for {@linkcode retry}. */
+export interface RetryOptions {
+    /**
+     * How much to backoff after each retry.
+     *
+     * @default {2}
+     */
+    multiplier?: number;
+    /**
+     * The maximum milliseconds between attempts.
+     *
+     * @default {60000}
+     */
+    maxTimeout?: number;
+    /**
+     * The maximum amount of attempts until failure.
+     *
+     * @default {5}
+     */
+    maxAttempts?: number;
+    /**
+     * The initial and minimum amount of milliseconds between attempts.
+     *
+     * @default {1000}
+     */
+    minTimeout?: number;
+    /**
+     * Amount of jitter to introduce to the time between attempts. This is `1`
+     * for full jitter by default.
+     *
+     * @default {1}
+     */
+    jitter?: number;
+}
+/**
+ * Calls the given (possibly asynchronous) function up to `maxAttempts` times.
+ * Retries as long as the given function throws. If the attempts are exhausted,
+ * throws a {@linkcode RetryError} with `cause` set to the inner exception.
+ *
+ * The backoff is calculated by multiplying `minTimeout` with `multiplier` to the power of the current attempt counter (starting at 0 up to `maxAttempts - 1`). It is capped at `maxTimeout` however.
+ * How long the actual delay is, depends on `jitter`.
+ *
+ * When `jitter` is the default value of `1`, waits between two attempts for a
+ * randomized amount between 0 and the backoff time. With the default options
+ * the maximal delay will be `15s = 1s + 2s + 4s + 8s`. If all five attempts
+ * are exhausted the mean delay will be `9.5s = ½(4s + 15s)`.
+ *
+ * When `jitter` is `0`, waits the full backoff time.
+ *
+ * @example Example configuration 1
+ * ```ts no-assert
+ * import { retry } from "@std/async/retry";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Below resolves to the first non-error result of `req`
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2,
+ *  maxTimeout: 60000,
+ *  maxAttempts: 5,
+ *  minTimeout: 100,
+ *  jitter: 1,
+ * });
+ * ```
+ *
+ * @example Example configuration 2
+ * ```ts no-assert
+ * import { retry } from "@std/async/retry";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Make sure we wait at least 1 minute, but at most 2 minutes
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2.34,
+ *  maxTimeout: 80000,
+ *  maxAttempts: 7,
+ *  minTimeout: 1000,
+ *  jitter: 0.5,
+ * });
+ * ```
+ *
+ * @typeParam T The return type of the function to retry and returned promise.
+ * @param fn The function to retry.
+ * @param options Additional options.
+ * @returns The promise that resolves with the value returned by the function to retry.
+ */
+export declare function retry<T>(fn: (() => Promise<T>) | (() => T), options?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/esm/deps/jsr.io/@std/async/1.0.16/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.16/retry.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC;;;;;OAKG;gBACS,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM;CAK7C;AAED,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,EAAE,EAAE,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAClC,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,CAAC,CAAC,CA6CZ"}

package/esm/deps/jsr.io/@std/async/1.0.16/retry.js

@@ -0,0 +1,107 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { exponentialBackoffWithJitter } from "./_util.js";
+/**
+ * Error thrown in {@linkcode retry} once the maximum number of failed attempts
+ * has been reached.
+ *
+ * @example Usage
+ * ```ts no-assert ignore
+ * import { RetryError } from "@std/async/retry";
+ *
+ * throw new RetryError({ foo: "bar" }, 3);
+ * ```
+ */
+export class RetryError extends Error {
+    /**
+     * Constructs a new {@linkcode RetryError} instance.
+     *
+     * @param cause the cause for this error.
+     * @param attempts the number of retry attempts made.
+     */
+    constructor(cause, attempts) {
+        super(`Retrying exceeded the maxAttempts (${attempts}).`);
+        this.name = "RetryError";
+        this.cause = cause;
+    }
+}
+/**
+ * Calls the given (possibly asynchronous) function up to `maxAttempts` times.
+ * Retries as long as the given function throws. If the attempts are exhausted,
+ * throws a {@linkcode RetryError} with `cause` set to the inner exception.
+ *
+ * The backoff is calculated by multiplying `minTimeout` with `multiplier` to the power of the current attempt counter (starting at 0 up to `maxAttempts - 1`). It is capped at `maxTimeout` however.
+ * How long the actual delay is, depends on `jitter`.
+ *
+ * When `jitter` is the default value of `1`, waits between two attempts for a
+ * randomized amount between 0 and the backoff time. With the default options
+ * the maximal delay will be `15s = 1s + 2s + 4s + 8s`. If all five attempts
+ * are exhausted the mean delay will be `9.5s = ½(4s + 15s)`.
+ *
+ * When `jitter` is `0`, waits the full backoff time.
+ *
+ * @example Example configuration 1
+ * ```ts no-assert
+ * import { retry } from "@std/async/retry";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Below resolves to the first non-error result of `req`
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2,
+ *  maxTimeout: 60000,
+ *  maxAttempts: 5,
+ *  minTimeout: 100,
+ *  jitter: 1,
+ * });
+ * ```
+ *
+ * @example Example configuration 2
+ * ```ts no-assert
+ * import { retry } from "@std/async/retry";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Make sure we wait at least 1 minute, but at most 2 minutes
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2.34,
+ *  maxTimeout: 80000,
+ *  maxAttempts: 7,
+ *  minTimeout: 1000,
+ *  jitter: 0.5,
+ * });
+ * ```
+ *
+ * @typeParam T The return type of the function to retry and returned promise.
+ * @param fn The function to retry.
+ * @param options Additional options.
+ * @returns The promise that resolves with the value returned by the function to retry.
+ */
+export async function retry(fn, options) {
+    const { multiplier = 2, maxTimeout = 60000, maxAttempts = 5, minTimeout = 1000, jitter = 1, } = options ?? {};
+    if (maxTimeout <= 0) {
+        throw new TypeError(`Cannot retry as 'maxTimeout' must be positive: current value is ${maxTimeout}`);
+    }
+    if (minTimeout > maxTimeout) {
+        throw new TypeError(`Cannot retry as 'minTimeout' must be <= 'maxTimeout': current values 'minTimeout=${minTimeout}', 'maxTimeout=${maxTimeout}'`);
+    }
+    if (jitter > 1) {
+        throw new TypeError(`Cannot retry as 'jitter' must be <= 1: current value is ${jitter}`);
+    }
+    let attempt = 0;
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (attempt + 1 >= maxAttempts) {
+                throw new RetryError(error, maxAttempts);
+            }
+            const timeout = exponentialBackoffWithJitter(maxTimeout, minTimeout, attempt, multiplier, jitter);
+            await new Promise((r) => setTimeout(r, timeout));
+        }
+        attempt++;
+    }
+}

package/esm/deps/jsr.io/@std/async/1.0.16/tee.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Utility for representing n-tuple. Used in {@linkcode tee}.
+ *
+ * @internal
+ */
+export type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : TupleOf<T, N, []> : never;
+/**
+ * Utility for representing n-tuple of. Used in {@linkcode Tuple}.
+ *
+ * @internal
+ */
+export type TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : TupleOf<T, N, [T, ...R]>;
+/**
+ * Branches the given async iterable into the `n` branches.
+ *
+ * @example Usage
+ * ```ts
+ * import { tee } from "@std/async/tee";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const gen = async function* gen() {
+ *   yield 1;
+ *   yield 2;
+ *   yield 3;
+ * };
+ *
+ * const [branch1, branch2] = tee(gen());
+ *
+ * const result1 = await Array.fromAsync(branch1);
+ * assertEquals(result1, [1, 2, 3]);
+ *
+ * const result2 = await Array.fromAsync(branch2);
+ * assertEquals(result2, [1, 2, 3]);
+ * ```
+ *
+ * @typeParam T The type of the provided async iterable and the returned async iterables.
+ * @typeParam N The amount of branches to tee into.
+ * @param iterable The iterable to tee.
+ * @param n The amount of branches to tee into.
+ * @returns The tuple where each element is an async iterable.
+ */
+export declare function tee<T, N extends number = 2>(iterable: AsyncIterable<T>, n?: N): Tuple<AsyncIterable<T>, N>;
+//# sourceMappingURL=tee.d.ts.map

package/esm/deps/jsr.io/@std/async/1.0.16/tee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.16/tee.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,GAChD,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GAC1C,KAAK,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,EAAE,IAC1D,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,GACrB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AAuC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,CAAC,EACzC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,CAAC,GAAE,CAAU,GACZ,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAuB5B"}

package/esm/deps/jsr.io/@std/async/1.0.16/tee.js

@@ -0,0 +1,102 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _Queue_source, _Queue_queue;
+class Queue {
+    constructor(iterable) {
+        _Queue_source.set(this, void 0);
+        _Queue_queue.set(this, void 0);
+        Object.defineProperty(this, "head", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        __classPrivateFieldSet(this, _Queue_source, iterable[Symbol.asyncIterator](), "f");
+        __classPrivateFieldSet(this, _Queue_queue, {
+            value: undefined,
+            next: undefined,
+        }, "f");
+        this.head = __classPrivateFieldGet(this, _Queue_queue, "f");
+        this.done = false;
+    }
+    async next() {
+        const result = await __classPrivateFieldGet(this, _Queue_source, "f").next();
+        if (!result.done) {
+            const nextNode = {
+                value: result.value,
+                next: undefined,
+            };
+            __classPrivateFieldGet(this, _Queue_queue, "f").next = nextNode;
+            __classPrivateFieldSet(this, _Queue_queue, nextNode, "f");
+        }
+        else {
+            this.done = true;
+        }
+    }
+}
+_Queue_source = new WeakMap(), _Queue_queue = new WeakMap();
+/**
+ * Branches the given async iterable into the `n` branches.
+ *
+ * @example Usage
+ * ```ts
+ * import { tee } from "@std/async/tee";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const gen = async function* gen() {
+ *   yield 1;
+ *   yield 2;
+ *   yield 3;
+ * };
+ *
+ * const [branch1, branch2] = tee(gen());
+ *
+ * const result1 = await Array.fromAsync(branch1);
+ * assertEquals(result1, [1, 2, 3]);
+ *
+ * const result2 = await Array.fromAsync(branch2);
+ * assertEquals(result2, [1, 2, 3]);
+ * ```
+ *
+ * @typeParam T The type of the provided async iterable and the returned async iterables.
+ * @typeParam N The amount of branches to tee into.
+ * @param iterable The iterable to tee.
+ * @param n The amount of branches to tee into.
+ * @returns The tuple where each element is an async iterable.
+ */
+export function tee(iterable, n = 2) {
+    const queue = new Queue(iterable);
+    async function* generator() {
+        let buffer = queue.head;
+        while (true) {
+            if (buffer.next) {
+                buffer = buffer.next;
+                yield buffer.value;
+            }
+            else if (queue.done) {
+                return;
+            }
+            else {
+                await queue.next();
+            }
+        }
+    }
+    return Array.from({ length: n }).map(() => generator());
+}

package/esm/deps/jsr.io/@std/cli/1.0.25/unstable_spinner.d.ts

@@ -0,0 +1,176 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+/**
+ * This is a hack to allow us to use the same type for both the color name and
+ * an ANSI escape code.
+ *
+ * @see {@link https://github.com/microsoft/TypeScript/issues/29729#issuecomment-460346421}
+ *
+ * @internal
+ */
+export type Ansi = string & {};
+/**
+ * Color options for {@linkcode SpinnerOptions.color}.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export type Color = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | Ansi;
+/**
+ * Options for {@linkcode Spinner}.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export interface SpinnerOptions {
+    /**
+     * The sequence of characters to be iterated through for animation.
+     *
+     * @default {["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]}
+     */
+    spinner?: string[];
+    /**
+     * The message to display next to the spinner. This can be changed while the
+     * spinner is active.
+     */
+    message?: string;
+    /**
+     * The time between each frame of the spinner in milliseconds.
+     *
+     * @default {75}
+     */
+    interval?: number;
+    /**
+     * The color of the spinner. Defaults to the default terminal color.
+     * This can be changed while the spinner is active.
+     */
+    color?: Color;
+    /**
+     * The stream to write the spinner to.
+     *
+     * @default {Deno.stdout}
+     */
+    output?: typeof dntShim.Deno.stderr | typeof dntShim.Deno.stdout;
+}
+/**
+ * A spinner that can be used to indicate that something is loading.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { Spinner } from "@std/cli/unstable-spinner";
+ *
+ * const spinner = new Spinner({ message: "Loading...", color: "yellow" });
+ * spinner.start();
+ *
+ * setTimeout(() => {
+ *  spinner.stop();
+ *  console.log("Finished loading!");
+ * }, 3_000);
+ *
+ * // You can also use the spinner with `Deno.stderr`
+ * const spinner2 = new Spinner({ message: "Loading...", color: "yellow", output: Deno.stderr });
+ * spinner2.start();
+ *
+ * setTimeout(() => {
+ *  spinner2.stop();
+ *  console.error("Finished loading!");
+ * }, 3_000);
+ * ```
+ */
+export declare class Spinner {
+    #private;
+    /**
+     * The message to display next to the spinner.
+     * This can be changed while the spinner is active.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Working..." });
+     * spinner.start();
+     *
+     * for (let step = 0; step < 5; step++) {
+     *   // do some work
+     *   await new Promise((resolve) => setTimeout(resolve, 1000));
+     *
+     *   spinner.message = `Finished Step #${step}`;
+     * }
+     *
+     * spinner.stop();
+     * console.log("Done!");
+     * ```
+     */
+    message: string;
+    /**
+     * Creates a new spinner.
+     *
+     * @param options Options for the spinner.
+     */
+    constructor(options?: SpinnerOptions);
+    /**
+     * Set the color of the spinner. This defaults to the default terminal color.
+     * This can be changed while the spinner is active.
+     *
+     * Providing `undefined` will use the default terminal color.
+     *
+     * @param value Color to set.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading...", color: "yellow" });
+     * spinner.start();
+     *
+     * // do some work
+     * await new Promise((resolve) => setTimeout(resolve, 1000));
+     *
+     * spinner.color = "magenta";
+     * ```
+     */
+    set color(value: Color | undefined);
+    /**
+     * Get the current color of the spinner.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading", color: "blue" });
+     *
+     * spinner.color; // Blue ANSI escape sequence
+     * ```
+     * @returns The color of the spinner or `undefined` if it's using the terminal default.
+     */
+    get color(): Color | undefined;
+    /**
+     * Starts the spinner.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.start();
+     * ```
+     */
+    start(): void;
+    /**
+     * Stops the spinner.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.start();
+     *
+     * setTimeout(() => {
+     *  spinner.stop();
+     *  console.log("Finished loading!");
+     * }, 3_000);
+     * ```
+     */
+    stop(): void;
+}
+//# sourceMappingURL=unstable_spinner.d.ts.map

package/esm/deps/jsr.io/@std/cli/1.0.25/unstable_spinner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unstable_spinner.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cli/1.0.25/unstable_spinner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAUxD;;;;;;;GAOG;AAEH,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,EAAE,CAAC;AAE/B;;;;GAIG;AACH,MAAM,MAAM,KAAK,GACb,OAAO,GACP,KAAK,GACL,OAAO,GACP,QAAQ,GACR,MAAM,GACN,SAAS,GACT,MAAM,GACN,OAAO,GACP,MAAM,GACN,IAAI,CAAC;AAcT;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;CAClE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,OAAO;;IAGlB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,EAAE,MAAM,CAAC;IAOhB;;;;OAIG;gBACS,OAAO,CAAC,EAAE,cAAc;IAcpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,EAEjC;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,KAAK,IAAI,KAAK,GAAG,SAAS,CAE7B;IAED;;;;;;;;;;OAUG;IACH,KAAK;IA4BL;;;;;;;;;;;;;;;OAeG;IACH,IAAI;CAML"}