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

package/esm/deps/jsr.io/@cliffy/table/1.0.0-rc.8/unicode_width.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Calculate the physical width of a string in a TTY-like environment. This is
+ * useful for cases such as calculating where a line-wrap will occur and
+ * underlining strings.
+ *
+ * The physical width is given by the number of columns required to display
+ * the string. The number of columns a given unicode character occupies can
+ * vary depending on the character itself.
+ *
+ * @param str The string to measure.
+ * @returns The unicode width of the string.
+ *
+ * @example Calculating the unicode width of a string
+ * ```ts
+ * import { unicodeWidth } from "@std/cli/unicode-width";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(unicodeWidth("hello world"), 11);
+ * assertEquals(unicodeWidth("天地玄黃宇宙洪荒"), 16);
+ * assertEquals(unicodeWidth("ｆｕｌｌｗｉｄｔｈ"), 18);
+ * ```
+ *
+ * @example Calculating the unicode width of a color-encoded string
+ * ```ts
+ * import { unicodeWidth } from "@std/cli/unicode-width";
+ * import { stripAnsiCode } from "@std/fmt/colors";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(unicodeWidth(stripAnsiCode("\x1b[36mголубой\x1b[39m")), 7);
+ * assertEquals(unicodeWidth(stripAnsiCode("\x1b[31m紅色\x1b[39m")), 4);
+ * assertEquals(unicodeWidth(stripAnsiCode("\x1B]8;;https://deno.land\x07🦕\x1B]8;;\x07")), 2);
+ * ```
+ *
+ * Use
+ * {@linkcode https://jsr.io/@std/fmt/doc/colors/~/stripAnsiCode | stripAnsiCode}
+ * to remove ANSI escape codes from a string before passing it to
+ * {@linkcode unicodeWidth}.
+ */
+export declare function unicodeWidth(str: string): number;
+//# sourceMappingURL=unicode_width.d.ts.map

package/esm/deps/jsr.io/@cliffy/table/1.0.0-rc.8/unicode_width.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unicode_width.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@cliffy/table/1.0.0-rc.8/unicode_width.ts"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/esm/deps/jsr.io/@cliffy/table/1.0.0-rc.8/unicode_width.js

@@ -0,0 +1,95 @@
+let tables = null;
+const data = {
+    "UNICODE_VERSION": "15.0.0",
+    "tables": [
+        {
+            "d": "AAECAwQFBgcICQoLDA0OAw8DDwkQCRESERIA",
+            "r": "AQEBAgEBAQEBAQEBAQEBBwEHAVABBwcBBwF4",
+        },
+        {
+            "d": "AAECAwQFBgcGCAYJCgsMDQ4PEAYREhMUBhUWFxgZGhscHR4fICEiIyIkJSYnKCkqJSssLS4vMDEyMzQ1Njc4OToGOzwKBj0GPj9AQUIGQwZEBkVGR0hJSktMTQZOBgoGT1BRUlNUVVZXWFkGWgZbBlxdXl1fYGFiY2RlZmdoBmlqBmsGAQZsBm1uO29wcXI7czt0dXZ3OwY7eHkGent8Bn0Gfn+AgYKDhIWGBoc7iAZdO4kGiosGAXGMBo0GjgaPBpAGkQaSBpMGlJUGlpcGmJmam5ydnp+gLgahLKIGo6SlpganqKmqqwasBq0Grq8GsLGyswa0BrUGtre4Brm6uwZHvAa9vga/wME7wjvDxAbFO8bHO8gGyQbKywbMzQbOBs/Q0QbSBr8GvgbT1AbUBtUG1gbXBtjZ2tsG3N0G3t/g4eLjO+Tl5ufoO+k76gbrBuztOwbu7/AGO+XxCgYKCwZd8g==",
+            "r": "AQEBAQEBAQEBAQEBAQEBAQEBAQMBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECBQEOAQEBAQEBAQEBAwEBAQEBAQEBAQIBAwEIAQEBAQEBAQEBAQEBAQIBAQEBAQEBAQEBAQEBAQEBDQEBBQEBAQEBAgEBAwEBAQEBAQEBAQEBbQHaAQEFAQEBBAECAQEBAQEBAQEBAwGuASFkCAELAQEBAQEBAQEHAQMBAQEaAQIBCAEFAQEBAQEBAQEBAQEBAQEBAQEBAQECAQEBAQIBAQEBAQEBAwEDAQEBAQEBAQUBAQEBAQEBBAEBAVIBAdkBARABAQFfARMBAYoBBAEBBQEmAUkBAQcBAQIBHgEBARUBAQEBAQUBAQcBDwEBARoBAgEBAQEBAQECAQEBAQEBAQEBAQEBAQEBAQMBBAEBAgEBAQEUfwEBAQIDAXj/AQ==",
+        },
+        {
+            "d": "AFUVAF3Xd3X/93//VXVVV9VX9V91f1/31X93XVXdVdVV9dVV/VVX1X9X/131VfXVVXV3V1VdVV1V1/1dV1X/3VUAVf3/3/9fVf3/3/9fVV1V/11VFQBQVQEAEEEQVQBQVQBAVFUVAFVUVQUAEAAUBFBVFVFVAEBVBQBUVRUAVVFVBRAAAVBVAVVQVQBVBQBAVUVUAQBUUQEAVQVVUVVUAVRVUVUFVUVBVVRBFRRQUVVQUVUBEFRRVQVVBQBRVRQBVFVRVUFVBVVFVVRVUVVUVQRUBQRQVUFVBVVFVVBVBVVQVRVUAVRVUVUFVVFVRVUFRFVRAEBVFQBAVVEAVFUAQFVQVRFRVQEAQAAEVQEAAQBUVUVVAQQAQVVQBVRVAVRVRUFVUVVRVaoAVQFVBVRVBVUFVQVVEABQVUUBAFVRVRUAVUFVUVVAFVRVRVUBVRUUVUUAQEQBAFQVABRVAEBVAFUEQFRFVRUAVVBVBVAQUFVFUBFQVQAFVUAABABUUVVUUFUVANd/X3//BUD3XdV1VQAEAFVXVdX9V1VXVQBUVdVdVdV1VX111VXVV9V//1X/X1VdVf9fVV9VdVdV1VX31dfVXXX9193/d1X/VV9VV3VVX//1VfVVXVVdVdVVdVWlVWlVqVaWVf/f/1X/Vf/1X1Xf/19V9VVf9df1X1X1X1XVVWlVfV31VVpVd1V3VapV33/fVZVVlVX1WVWlVelV+v/v//7/31Xv/6/77/tVWaVVVlVdVWaVmlX1/1WpVVZVlVWVVlVW+V9VFVBVAKqaqlWqWlWqVaoKoKpqqapqgapVqaqpqmqqVapqqv+qVqpqVRVAAFBVBVVQVUUVVUFVVFVQVQBQVRVVBQBQVRUAUFWqVkBVFQVQVVFVAUBBVRVVVFVUVQQUVAVRVVBVRVVRVFFVqlVFVQCqWlUAqmqqaqpVqlZVqmpVAV1VUVVUVQVAVQFBVQBVQBVVQVUAVRVUVQFVBQBUVQVQVVFVAEBVFFRVFVBVFUBBUUVVUVVAVRUAAQBUVRVVUFUFAEBVARRVFVAEVUVVFQBAVVRVBQBUAFRVAAVEVUVVFQBEFQRVBVBVEFRVUFUVAEARVFUVUQAQVQEFEABVFQBBVRVEFVUABVVUVQEAQFUVABRAVRVVAUABVQUAQFBVAEAAEFUFAAUABEFVAUBFEAAQVVARVRVUVVBVBUBVRFVUFQBQVQBUVQBAVRVVFUBVqlRVWlWqVapaVapWVaqpqmmqalVlVWpZVapVqlVBAFUAUABAVRVQVRUAQAEAVQVQVQVUVQBAFQBUVVFVVFUVAAEAVQBAABQAEARAVUVVAFUAQFUAQFVWVZVV/39V/1//X1X/76uq6v9XVWpVqlWqVlVaVapaVapWVamqmqqmqlWqapWqVapWqmqmqpaqWlWVaqpVZVVpVVZVlapVqlpVVmqpVapVlVZVqlZVqlVWVapqqpqqVapWqlZVqpqqWlWlqlWqVlWqVlVRVQD/Xw==",
+            "r": "CBcBCAEBAQEBAQEBAQECAQEBAQEBAQEBAQEBAQMBAQECAQEBAQEBAQEBAQEBBAEBGAEDAQwBAwEIAQEBAQEBAQgcCAEDAQEBAQEDAQEBDQEDEAELAQEBEQEKAQEBDgEBAgIBAQoBBQQBCAEBAQEBAQEHAQEHBgEWAQIBDQECAgEFAQECAgEKAQ0BAQIKAQ0BDQEBAQEBAQEBAgEHAQ4BAQEBAQQBBgEBDgEBAQEBAQcBAQIBAQEBBAEFAQEBDgEBAQEBAQECAQcBDwECAQwCDQEBAQEBAQECAQgBAQEEAQcBDQEBAQEBAQQBBwERAQEBARYBAQECAQEBGAECAQIBARIBBgEBDQECAQEBAQECAQgBAQEZAQEBAgYBAQEDAQECAQEBAQMBCBgIBwEMAQEGAQcBBwEQAQEBAQEBAgIBCgEBDQEIAQ0BAQEBAQEBBgEBDgEBAQEBAQEBAgEMBwEMAQwBAQEBCQECAwEHAQEBAQ0BAQEBDgIBBgEDAQEBAQEBAQMBAQEBAgEBAQEBAQEBCAEBAgEBAQEBAQkBCAgBAwECAQEBAgEBAQkBAQEBAwECAQMBAQIBBwEFAQEDAQYBAQEBAgEBAQEBAQEBAQECAgEDAQECBAIDAgIBBQEEAQEBAwEPAQEBCyIBCAEJAwQBAQIBAQEBAgECAQEBAQMBAQEBAwEBAQEBAQEBAQgBAQMDAgEBAwEEAQIBAQEBBAEBAQEBAQECAQEBAQEBAQEBAQEHAQQBAwEBAQcBAgUBBgECAQYBAQwBAQEUAQELCAYBFgMFAQYDAQoBAQMBARQBAQkBAQoBBgEVAwsBCgIPAQ0BGQEBAgEHARQBAwIBBgEBAQUBBgQBAgEJAQEBBQECAQMHAQELAQECCQEQAQECAgECAQsBDAEBAQEBCgEBAQsBAQEECQ4BCAQCAQEECAEEAQEFCAEPAQEEAQEPAQgBFAEBAQEBAQEKAQEJAQ8BEAEBEwEBAQIBCwEBDgENAwEKAQEBAQELAQEBAQECAQwBCAEBAQEBDgEDAQwBAQECAQEXAQEBAQEHAgEBBQEIAQEBAQEQAgEBBQEUAQEBAQEbAQEBAQEGARQBAQEBARkBAQEBCQEBAQEQAQIBDwEBARQBAQEBBwEBAQkBAQEBAQECAQEBCwECAQEVAQEBAQQBBQEBAQEOAQEBAQEBEgEBFgEBAgEMAQEBAQ8BAQMBFgEBDgEBBQEPAQETAQECAQMOAgUBCgIBGQEBAQEIAQMBBwEBAwECEwgBAQcLAQUBFwEBAQEDAQEBBwEBBAEBDg0BAQwBAQEDAQQBAQEDBAEBBAEBAQEBEAEPAQgBAQsBAQ4BEQEMAgEBBwEOAQEHAQEBAQQBBAEDCwECAQEBAwEBBggBAgEBAREBBQMKAQEBAwQCEQEBHgEPAQIBAQYEAQYBAwEUAQUMAQEBAQEBAQECAQEBAgEIAwEBBgsBAgEODAMBAgEBCwEBAQEBAwECAQECAQEBBwgPAQ==",
+        },
+    ],
+};
+function lookupWidth(cp) {
+    if (!tables)
+        tables = data.tables.map(runLengthDecode);
+    const t1Offset = tables[0][(cp >> 13) & 0xff];
+    const t2Offset = tables[1][128 * t1Offset + ((cp >> 6) & 0x7f)];
+    const packedWidths = tables[2][16 * t2Offset + ((cp >> 2) & 0xf)];
+    const width = (packedWidths >> (2 * (cp & 0b11))) & 0b11;
+    return width === 3 ? 1 : width;
+}
+const cache = new Map();
+function charWidth(char) {
+    if (cache.has(char))
+        return cache.get(char);
+    const codePoint = char.codePointAt(0);
+    let width = null;
+    if (codePoint < 0x7f) {
+        width = codePoint >= 0x20 ? 1 : codePoint === 0 ? 0 : null;
+    }
+    else if (codePoint >= 0xa0) {
+        width = lookupWidth(codePoint);
+    }
+    else {
+        width = null;
+    }
+    cache.set(char, width);
+    return width;
+}
+/**
+ * Calculate the physical width of a string in a TTY-like environment. This is
+ * useful for cases such as calculating where a line-wrap will occur and
+ * underlining strings.
+ *
+ * The physical width is given by the number of columns required to display
+ * the string. The number of columns a given unicode character occupies can
+ * vary depending on the character itself.
+ *
+ * @param str The string to measure.
+ * @returns The unicode width of the string.
+ *
+ * @example Calculating the unicode width of a string
+ * ```ts
+ * import { unicodeWidth } from "@std/cli/unicode-width";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(unicodeWidth("hello world"), 11);
+ * assertEquals(unicodeWidth("天地玄黃宇宙洪荒"), 16);
+ * assertEquals(unicodeWidth("ｆｕｌｌｗｉｄｔｈ"), 18);
+ * ```
+ *
+ * @example Calculating the unicode width of a color-encoded string
+ * ```ts
+ * import { unicodeWidth } from "@std/cli/unicode-width";
+ * import { stripAnsiCode } from "@std/fmt/colors";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(unicodeWidth(stripAnsiCode("\x1b[36mголубой\x1b[39m")), 7);
+ * assertEquals(unicodeWidth(stripAnsiCode("\x1b[31m紅色\x1b[39m")), 4);
+ * assertEquals(unicodeWidth(stripAnsiCode("\x1B]8;;https://deno.land\x07🦕\x1B]8;;\x07")), 2);
+ * ```
+ *
+ * Use
+ * {@linkcode https://jsr.io/@std/fmt/doc/colors/~/stripAnsiCode | stripAnsiCode}
+ * to remove ANSI escape codes from a string before passing it to
+ * {@linkcode unicodeWidth}.
+ */
+export function unicodeWidth(str) {
+    return [...str].map((ch) => charWidth(ch) ?? 0).reduce((a, b) => a + b, 0);
+}
+function runLengthDecode({ d, r }) {
+    const data = atob(d);
+    const runLengths = atob(r);
+    let out = "";
+    for (const [i, ch] of [...runLengths].entries()) {
+        out += data[i].repeat(ch.codePointAt(0));
+    }
+    return Uint8Array.from([...out].map((x) => x.codePointAt(0)));
+}

package/esm/deps/jsr.io/@std/assert/1.0.16/equal.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param a The actual value
+ * @param b The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
+ * ```
+ */
+export declare function equal(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=equal.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.16/equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/equal.ts"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAgHrD"}

package/esm/deps/jsr.io/@std/assert/1.0.16/equal.js

@@ -0,0 +1,186 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import * as dntShim from "../../../../../_dnt.shims.js";
+function isKeyedCollection(x) {
+    return x instanceof Set || x instanceof Map;
+}
+function prototypesEqual(a, b) {
+    const pa = Object.getPrototypeOf(a);
+    const pb = Object.getPrototypeOf(b);
+    return pa === pb ||
+        pa === Object.prototype && pb === null ||
+        pa === null && pb === Object.prototype;
+}
+function isBasicObjectOrArray(obj) {
+    const proto = Object.getPrototypeOf(obj);
+    return proto === null || proto === Object.prototype ||
+        proto === Array.prototype;
+}
+// Slightly faster than Reflect.ownKeys in V8 as of 12.9.202.13-rusty (2024-10-28)
+function ownKeys(obj) {
+    return [
+        ...Object.getOwnPropertyNames(obj),
+        ...Object.getOwnPropertySymbols(obj),
+    ];
+}
+function getKeysDeep(obj) {
+    const keys = new Set();
+    while (obj !== Object.prototype && obj !== Array.prototype && obj != null) {
+        for (const key of ownKeys(obj)) {
+            keys.add(key);
+        }
+        obj = Object.getPrototypeOf(obj);
+    }
+    return keys;
+}
+// deno-lint-ignore no-explicit-any
+const Temporal = dntShim.dntGlobalThis.Temporal ?? Object.create(null);
+/** A non-exhaustive list of prototypes that can be accurately fast-path compared with `String(instance)` */
+const stringComparablePrototypes = new Set([
+    Intl.Locale,
+    RegExp,
+    Temporal.Duration,
+    Temporal.Instant,
+    Temporal.PlainDate,
+    Temporal.PlainDateTime,
+    Temporal.PlainTime,
+    Temporal.PlainYearMonth,
+    Temporal.PlainMonthDay,
+    Temporal.ZonedDateTime,
+    URL,
+    URLSearchParams,
+].filter((x) => x != null).map((x) => x.prototype));
+function isPrimitive(x) {
+    return typeof x === "string" ||
+        typeof x === "number" ||
+        typeof x === "boolean" ||
+        typeof x === "bigint" ||
+        typeof x === "symbol" ||
+        x == null;
+}
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+function compareTypedArrays(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < b.length; i++) {
+        if (!sameValueZero(a[i], b[i]))
+            return false;
+    }
+    return true;
+}
+/** Check both strict equality (`0 == -0`) and `Object.is` (`NaN == NaN`) */
+function sameValueZero(a, b) {
+    return a === b || Object.is(a, b);
+}
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param a The actual value
+ * @param b The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
+ * ```
+ */
+export function equal(a, b) {
+    const seen = new Map();
+    return (function compare(a, b) {
+        if (sameValueZero(a, b))
+            return true;
+        if (isPrimitive(a) || isPrimitive(b))
+            return false;
+        if (a instanceof Date && b instanceof Date) {
+            return Object.is(a.getTime(), b.getTime());
+        }
+        if (a && typeof a === "object" && b && typeof b === "object") {
+            if (!prototypesEqual(a, b)) {
+                return false;
+            }
+            if (a instanceof TypedArray) {
+                return compareTypedArrays(a, b);
+            }
+            if (a instanceof ArrayBuffer ||
+                (globalThis.SharedArrayBuffer && a instanceof SharedArrayBuffer)) {
+                return compareTypedArrays(new Uint8Array(a), new Uint8Array(b));
+            }
+            if (a instanceof WeakMap) {
+                throw new TypeError("Cannot compare WeakMap instances");
+            }
+            if (a instanceof WeakSet) {
+                throw new TypeError("Cannot compare WeakSet instances");
+            }
+            if (a instanceof WeakRef) {
+                return compare(a.deref(), b.deref());
+            }
+            if (seen.get(a) === b) {
+                return true;
+            }
+            if (Object.keys(a).length !== Object.keys(b).length) {
+                return false;
+            }
+            seen.set(a, b);
+            if (isKeyedCollection(a) && isKeyedCollection(b)) {
+                if (a.size !== b.size) {
+                    return false;
+                }
+                const aKeys = [...a.keys()];
+                const primitiveKeysFastPath = aKeys.every(isPrimitive);
+                if (primitiveKeysFastPath) {
+                    if (a instanceof Set) {
+                        return a.symmetricDifference(b).size === 0;
+                    }
+                    for (const key of aKeys) {
+                        if (!b.has(key) ||
+                            !compare(a.get(key), b.get(key))) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+                let unmatchedEntries = a.size;
+                for (const [aKey, aValue] of a.entries()) {
+                    for (const [bKey, bValue] of b.entries()) {
+                        /* Given that Map keys can be references, we need
+                         * to ensure that they are also deeply equal */
+                        if (!compare(aKey, bKey))
+                            continue;
+                        if ((aKey === aValue && bKey === bValue) ||
+                            (compare(aValue, bValue))) {
+                            unmatchedEntries--;
+                            break;
+                        }
+                    }
+                }
+                return unmatchedEntries === 0;
+            }
+            let keys;
+            if (isBasicObjectOrArray(a)) {
+                // fast path
+                keys = ownKeys({ ...a, ...b });
+            }
+            else if (stringComparablePrototypes.has(Object.getPrototypeOf(a))) {
+                // medium path
+                return String(a) === String(b);
+            }
+            else {
+                // slow path
+                keys = getKeysDeep(a).union(getKeysDeep(b));
+            }
+            for (const key of keys) {
+                if (!compare(a[key], b[key])) {
+                    return false;
+                }
+                if (((key in a) && (!(key in b))) || ((key in b) && (!(key in a)))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    })(a, b);
+}

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

@@ -0,0 +1,2 @@
+export declare function exponentialBackoffWithJitter(cap: number, base: number, attempt: number, multiplier: number, jitter: number): number;
+//# sourceMappingURL=_util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.16/_util.ts"],"names":[],"mappings":"AAGA,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,UAIf"}

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

@@ -0,0 +1,6 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export function exponentialBackoffWithJitter(cap, base, attempt, multiplier, jitter) {
+    const exp = Math.min(cap, base * multiplier ** attempt);
+    return (1 - jitter * Math.random()) * exp;
+}

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

@@ -0,0 +1,107 @@
+/**
+ * Make a {@linkcode Promise} abortable with the given signal.
+ *
+ * @throws {DOMException} If the signal is already aborted and `signal.reason`
+ * is undefined. Otherwise, throws `signal.reason`.
+ * @typeParam T The type of the provided and returned promise.
+ * @param p The promise to make abortable.
+ * @param signal The signal to abort the promise with.
+ * @returns A promise that can be aborted.
+ *
+ * @example Error-handling a timeout
+ * ```ts ignore
+ * import { abortable, delay } from "@std/async";
+ * import { assertRejects, assertEquals } from "@std/assert";
+ *
+ * const promise = delay(1_000);
+ *
+ * // Rejects with `DOMException` after 100 ms
+ * await assertRejects(
+ *   () => abortable(promise, AbortSignal.timeout(100)),
+ *   DOMException,
+ *   "Signal timed out."
+ * );
+ * ```
+ *
+ * @example Error-handling an abort
+ * ```ts ignore
+ * import { abortable, delay } from "@std/async";
+ * import { assertRejects, assertEquals } from "@std/assert";
+ *
+ * const promise = delay(1_000);
+ * const controller = new AbortController();
+ * controller.abort(new Error("This is my reason"));
+ *
+ * // Rejects with `DOMException` immediately
+ * await assertRejects(
+ *   () => abortable(promise, controller.signal),
+ *   Error,
+ *   "This is my reason"
+ * );
+ * ```
+ */
+export declare function abortable<T>(p: Promise<T>, signal: AbortSignal): Promise<T>;
+/**
+ * Make an {@linkcode AsyncIterable} abortable with the given signal.
+ *
+ * @throws {DOMException} If the signal is already aborted and `signal.reason`
+ * is undefined. Otherwise, throws `signal.reason`.
+ * @typeParam T The type of the provided and returned async iterable.
+ * @param p The async iterable to make abortable.
+ * @param signal The signal to abort the promise with.
+ * @returns An async iterable that can be aborted.
+ *
+ * @example Error-handling a timeout
+ * ```ts
+ * import { abortable, delay } from "@std/async";
+ * import { assertRejects, assertEquals } from "@std/assert";
+ *
+ * const asyncIter = async function* () {
+ *   yield "Hello";
+ *   await delay(1_000);
+ *   yield "World";
+ * };
+ *
+ * const items: string[] = [];
+ * // Below throws `DOMException` after 100 ms and items become `["Hello"]`
+ * await assertRejects(
+ *   async () => {
+ *     for await (const item of abortable(asyncIter(), AbortSignal.timeout(100))) {
+ *       items.push(item);
+ *     }
+ *   },
+ *   DOMException,
+ *   "Signal timed out."
+ * );
+ * assertEquals(items, ["Hello"]);
+ * ```
+ *
+ * @example Error-handling an abort
+ * ```ts
+ * import { abortable, delay } from "@std/async";
+ * import { assertRejects, assertEquals } from "@std/assert";
+ *
+ * const asyncIter = async function* () {
+ *   yield "Hello";
+ *   await delay(1_000);
+ *   yield "World";
+ * };
+ * const controller = new AbortController();
+ * controller.abort(new Error("This is my reason"));
+ *
+ * const items: string[] = [];
+ * // Below throws `DOMException` immediately
+ * await assertRejects(
+ *   async () => {
+ *     for await (const item of abortable(asyncIter(), controller.signal)) {
+ *       items.push(item);
+ *     }
+ *   },
+ *   Error,
+ *   "This is my reason"
+ * );
+ * assertEquals(items, []);
+ * ```
+ */
+export declare function abortable<T>(p: AsyncIterable<T>, signal: AbortSignal): AsyncGenerator<T>;
+//# sourceMappingURL=abortable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abortable.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.16/abortable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAClB,cAAc,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,46 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export function abortable(p, signal) {
+    if (p instanceof Promise) {
+        return abortablePromise(p, signal);
+    }
+    else {
+        return abortableAsyncIterable(p, signal);
+    }
+}
+function abortablePromise(p, signal) {
+    const { promise, reject } = Promise.withResolvers();
+    const abort = () => reject(signal.reason);
+    if (signal.aborted)
+        abort();
+    signal.addEventListener("abort", abort, { once: true });
+    return Promise.race([promise, p]).finally(() => {
+        signal.removeEventListener("abort", abort);
+    });
+}
+async function* abortableAsyncIterable(p, signal) {
+    signal.throwIfAborted();
+    const { promise, reject } = Promise.withResolvers();
+    const abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    const it = p[Symbol.asyncIterator]();
+    try {
+        while (true) {
+            const race = Promise.race([promise, it.next()]);
+            race.catch(() => {
+                signal.removeEventListener("abort", abort);
+            });
+            const { done, value } = await race;
+            if (done) {
+                signal.removeEventListener("abort", abort);
+                const result = await it.return?.(value);
+                return result?.value;
+            }
+            yield value;
+        }
+    }
+    catch (e) {
+        await it.return?.();
+        throw e;
+    }
+}

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

@@ -0,0 +1,37 @@
+/** Options for {@linkcode deadline}. */
+export interface DeadlineOptions {
+    /** Signal used to abort the deadline. */
+    signal?: AbortSignal;
+}
+/**
+ * Create a promise which will be rejected with {@linkcode DOMException} when
+ * a given delay is exceeded.
+ *
+ * Note: Prefer to use {@linkcode AbortSignal.timeout} instead for the APIs
+ * that accept {@linkcode AbortSignal}.
+ *
+ * @throws {DOMException & { name: "TimeoutError" }} If the provided duration
+ * runs out before resolving.
+ * @throws {DOMException & { name: "AbortError" }} If the optional signal is
+ * aborted with the default `reason` before resolving or timing out.
+ * @throws {AbortSignal["reason"]} If the optional signal is aborted with a
+ * custom `reason` before resolving or timing out.
+ * @typeParam T The type of the provided and returned promise.
+ * @param p The promise to make rejectable.
+ * @param ms Duration in milliseconds for when the promise should time out. If
+ * greater than `Number.MAX_SAFE_INTEGER`, the deadline will never expire.
+ * @param options Additional options.
+ * @returns A promise that will reject if the provided duration runs out before resolving.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { deadline } from "@std/async/deadline";
+ * import { delay } from "@std/async/delay";
+ *
+ * const delayedPromise = delay(1_000);
+ * // Below throws `DOMException` after 10 ms
+ * const result = await deadline(delayedPromise, 10);
+ * ```
+ */
+export declare function deadline<T>(p: Promise<T>, ms: number, options?: DeadlineOptions): Promise<T>;
+//# sourceMappingURL=deadline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.16/deadline.ts"],"names":[],"mappings":"AAKA,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EACb,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,CAAC,CAAC,CAKZ"}

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

@@ -0,0 +1,41 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { abortable } from "./abortable.js";
+/**
+ * Create a promise which will be rejected with {@linkcode DOMException} when
+ * a given delay is exceeded.
+ *
+ * Note: Prefer to use {@linkcode AbortSignal.timeout} instead for the APIs
+ * that accept {@linkcode AbortSignal}.
+ *
+ * @throws {DOMException & { name: "TimeoutError" }} If the provided duration
+ * runs out before resolving.
+ * @throws {DOMException & { name: "AbortError" }} If the optional signal is
+ * aborted with the default `reason` before resolving or timing out.
+ * @throws {AbortSignal["reason"]} If the optional signal is aborted with a
+ * custom `reason` before resolving or timing out.
+ * @typeParam T The type of the provided and returned promise.
+ * @param p The promise to make rejectable.
+ * @param ms Duration in milliseconds for when the promise should time out. If
+ * greater than `Number.MAX_SAFE_INTEGER`, the deadline will never expire.
+ * @param options Additional options.
+ * @returns A promise that will reject if the provided duration runs out before resolving.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { deadline } from "@std/async/deadline";
+ * import { delay } from "@std/async/delay";
+ *
+ * const delayedPromise = delay(1_000);
+ * // Below throws `DOMException` after 10 ms
+ * const result = await deadline(delayedPromise, 10);
+ * ```
+ */
+export async function deadline(p, ms, options = {}) {
+    const signals = [];
+    if (ms < Number.MAX_SAFE_INTEGER)
+        signals.push(AbortSignal.timeout(ms));
+    if (options.signal)
+        signals.push(options.signal);
+    return await abortable(p, AbortSignal.any(signals));
+}

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

@@ -0,0 +1,44 @@
+/**
+ * A debounced function that will be delayed by a given `wait`
+ * time in milliseconds. If the method is called again before
+ * the timeout expires, the previous call will be aborted.
+ */
+export interface DebouncedFunction<T extends Array<unknown>> {
+    (...args: T): void;
+    /** Clears the debounce timeout and omits calling the debounced function. */
+    clear(): void;
+    /** Clears the debounce timeout and calls the debounced function immediately. */
+    flush(): void;
+    /** Returns a boolean whether a debounce call is pending or not. */
+    readonly pending: boolean;
+}
+/**
+ * Creates a debounced function that delays the given `func`
+ * by a given `wait` time in milliseconds. If the method is called
+ * again before the timeout expires, the previous call will be
+ * aborted.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { debounce } from "@std/async/debounce";
+ *
+ * const log = debounce(
+ *   (event: Deno.FsEvent) =>
+ *     console.log("[%s] %s", event.kind, event.paths[0]),
+ *   200,
+ * );
+ *
+ * for await (const event of Deno.watchFs("./")) {
+ *   log(event);
+ * }
+ * // wait 200ms ...
+ * // output: Function debounced after 200ms with baz
+ * ```
+ *
+ * @typeParam T The arguments of the provided function.
+ * @param fn The function to debounce.
+ * @param wait The time in milliseconds to delay the function.
+ * @returns The debounced function.
+ */
+export declare function debounce<T extends Array<any>>(fn: (this: DebouncedFunction<T>, ...args: T) => void, wait: number): DebouncedFunction<T>;
+//# sourceMappingURL=debounce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.16/debounce.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,KAAK,CAAC,OAAO,CAAC;IACzD,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,4EAA4E;IAC5E,KAAK,IAAI,IAAI,CAAC;IACd,gFAAgF;IAChF,KAAK,IAAI,IAAI,CAAC;IACd,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAC3C,EAAE,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,EACpD,IAAI,EAAE,MAAM,GACX,iBAAiB,CAAC,CAAC,CAAC,CA8BtB"}