@mtkruto/browser 0.6.1 → 0.119.1

package/script/deps/jsr.io/@std/assert/1.0.19/equal.js

@@ -0,0 +1,230 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equal = equal;
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+const dntShim = __importStar(require("../../../../../_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.
+ *
+ * This function is based on value equality, but for some cases (such as data
+ * that can only be read asynchronously or function properties) value equality
+ * is not possible to determine. In such cases, reference equality is used
+ * instead, which may cause false negatives for objects such as `Blob`s or
+ * `Request`s.
+ *
+ * @param a The actual value
+ * @param b The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @throws {TypeError} If either value is a `WeakMap` or `WeakSet`.
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
+ * ```
+ */
+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/script/deps/jsr.io/@std/assert/1.0.19/equals.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Make an assertion that `actual` and `expected` are equal, deeply. If not
+ * deeply equal, then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * Note: This function is based on value equality, but for some cases (such as
+ * data that can only be read asynchronously or function properties) value
+ * equality is not possible to determine. In such cases, reference equality is
+ * used instead, which may cause false negatives for objects such as `Blob`s or
+ * `Request`s.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
+ * ```
+ * @example Compare `Blob` objects
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * const bytes1 = await new Blob(["foo"]).bytes();
+ * const bytes2 = await new Blob(["foo"]).bytes();
+ *
+ * assertEquals(bytes1, bytes2);
+ * ```
+ *
+ * @typeParam T The type of the values to compare. This is usually inferred.
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
+//# sourceMappingURL=equals.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.19/equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/equals.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAmBb"}

package/script/deps/jsr.io/@std/assert/1.0.19/equals.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertEquals = assertEquals;
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+const equal_js_1 = require("./equal.js");
+const build_message_js_1 = require("../../internal/1.0.12/build_message.js");
+const diff_js_1 = require("../../internal/1.0.12/diff.js");
+const diff_str_js_1 = require("../../internal/1.0.12/diff_str.js");
+const format_js_1 = require("../../internal/1.0.12/format.js");
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` and `expected` are equal, deeply. If not
+ * deeply equal, then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * Note: This function is based on value equality, but for some cases (such as
+ * data that can only be read asynchronously or function properties) value
+ * equality is not possible to determine. In such cases, reference equality is
+ * used instead, which may cause false negatives for objects such as `Blob`s or
+ * `Request`s.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
+ * ```
+ * @example Compare `Blob` objects
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * const bytes1 = await new Blob(["foo"]).bytes();
+ * const bytes2 = await new Blob(["foo"]).bytes();
+ *
+ * assertEquals(bytes1, bytes2);
+ * ```
+ *
+ * @typeParam T The type of the values to compare. This is usually inferred.
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertEquals(actual, expected, msg) {
+    if ((0, equal_js_1.equal)(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message = `Values are not equal${msgSuffix}`;
+    const actualString = (0, format_js_1.format)(actual);
+    const expectedString = (0, format_js_1.format)(expected);
+    const stringDiff = (typeof actual === "string") &&
+        (typeof expected === "string");
+    const diffResult = stringDiff
+        ? (0, diff_str_js_1.diffStr)(actual, expected)
+        : (0, diff_js_1.diff)(actualString.split("\n"), expectedString.split("\n"));
+    const diffMsg = (0, build_message_js_1.buildMessage)(diffResult, { stringDiff }, arguments[3])
+        .join("\n");
+    message = `${message}\n${diffMsg}`;
+    throw new assertion_error_js_1.AssertionError(message);
+}

package/script/deps/jsr.io/@std/assert/1.0.19/false.d.ts

@@ -0,0 +1,19 @@
+/** Assertion condition for {@linkcode assertFalse}. */
+export type Falsy = false | 0 | 0n | "" | null | undefined;
+/**
+ * Make an assertion, an error will be thrown if `expr` has a truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertFalse } from "@std/assert";
+ *
+ * assertFalse(false); // Doesn't throw
+ * assertFalse(true); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ * @throws {AssertionError} If `expr` is truthy.
+ */
+export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;
+//# sourceMappingURL=false.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.19/false.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"false.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/false.ts"],"names":[],"mappings":"AAIA,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAE3D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAI1E"}

package/script/deps/jsr.io/@std/assert/1.0.19/false.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertFalse = assertFalse;
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion, an error will be thrown if `expr` has a truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertFalse } from "@std/assert";
+ *
+ * assertFalse(false); // Doesn't throw
+ * assertFalse(true); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ * @throws {AssertionError} If `expr` is truthy.
+ */
+function assertFalse(expr, msg = "") {
+    if (expr) {
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}

package/script/deps/jsr.io/@std/assert/1.0.19/unreachable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unreachable.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/unreachable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAG/C"}

package/script/deps/jsr.io/@std/assert/1.0.19/unreachable.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unreachable = unreachable;
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unreachable } from "@std/assert";
+ *
+ * unreachable(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+function unreachable(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new assertion_error_js_1.AssertionError(`Unreachable${msgSuffix}`);
+}

package/script/deps/jsr.io/@std/async/1.2.0/_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/script/deps/jsr.io/@std/async/1.2.0/_util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/_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/script/deps/jsr.io/@std/async/1.2.0/_util.js

@@ -0,0 +1,9 @@
+"use strict";
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exponentialBackoffWithJitter = exponentialBackoffWithJitter;
+function exponentialBackoffWithJitter(cap, base, attempt, multiplier, jitter) {
+    const exp = Math.min(cap, base * multiplier ** attempt);
+    return (1 - jitter * Math.random()) * exp;
+}

package/script/deps/jsr.io/@std/async/1.2.0/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/script/deps/jsr.io/@std/async/1.2.0/abortable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortable.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/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/script/deps/jsr.io/@std/async/1.2.0/abortable.js

@@ -0,0 +1,49 @@
+"use strict";
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortable = abortable;
+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/script/deps/jsr.io/@std/async/1.2.0/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/script/deps/jsr.io/@std/async/1.2.0/deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.2.0/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"}