@effectionx/worker 0.1.2 → 0.3.0

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

@@ -0,0 +1,21 @@
+/**
+ * Make an assertion that `actual` and `expected` are not equal, deeply.
+ * If not then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotEquals } from "@std/assert";
+ *
+ * assertNotEquals(1, 2); // Doesn't throw
+ * assertNotEquals(1, 1); // Throws
+ * ```
+ *
+ * @typeParam T The type of the values to compare.
+ * @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 assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+//# sourceMappingURL=not_equals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"not_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/not_equals.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,QAUtE"}

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

@@ -0,0 +1,33 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { equal } from "./equal.js";
+import { AssertionError } from "./assertion_error.js";
+import { format } from "../../internal/1.0.12/format.js";
+/**
+ * Make an assertion that `actual` and `expected` are not equal, deeply.
+ * If not then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotEquals } from "@std/assert";
+ *
+ * assertNotEquals(1, 2); // Doesn't throw
+ * assertNotEquals(1, 1); // Throws
+ * ```
+ *
+ * @typeParam T The type of the values to compare.
+ * @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 function assertNotEquals(actual, expected, msg) {
+    if (!equal(actual, expected)) {
+        return;
+    }
+    const actualString = format(actual);
+    const expectedString = format(expected);
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Expected actual: ${actualString} not to be: ${expectedString}${msgSuffix}`);
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotInstanceOf } from "@std/assert";
+ *
+ * assertNotInstanceOf(new Date(), Number); // Doesn't throw
+ * assertNotInstanceOf(new Date(), Date); // Throws
+ * ```
+ *
+ * @typeParam A The type of the object to check.
+ * @typeParam T The type of the class to check against.
+ * @param actual The object to check.
+ * @param unexpectedType The class constructor to check against.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: abstract new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;
+//# sourceMappingURL=not_instance_of.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"not_instance_of.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/not_instance_of.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EACtC,MAAM,EAAE,CAAC,EAET,cAAc,EAAE,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAClD,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAKjC"}

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

@@ -0,0 +1,29 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { assertFalse } from "./false.js";
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotInstanceOf } from "@std/assert";
+ *
+ * assertNotInstanceOf(new Date(), Number); // Doesn't throw
+ * assertNotInstanceOf(new Date(), Date); // Throws
+ * ```
+ *
+ * @typeParam A The type of the object to check.
+ * @typeParam T The type of the class to check against.
+ * @param actual The object to check.
+ * @param unexpectedType The class constructor to check against.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertNotInstanceOf(actual, 
+// deno-lint-ignore no-explicit-any
+unexpectedType, msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg =
+        `Expected object to not be an instance of "${typeof unexpectedType}"${msgSuffix}`;
+    assertFalse(actual instanceof unexpectedType, msg);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotMatch } from "@std/assert";
+ *
+ * assertNotMatch("Denosaurus", /Raptor/); // Doesn't throw
+ * assertNotMatch("Raptor", /Raptor/); // Throws
+ * ```
+ *
+ * @param actual The actual value to match.
+ * @param expected The expected value to not match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+//# sourceMappingURL=not_match.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"not_match.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/not_match.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,QAMb"}

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

@@ -0,0 +1,26 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotMatch } from "@std/assert";
+ *
+ * assertNotMatch("Denosaurus", /Raptor/); // Doesn't throw
+ * assertNotMatch("Raptor", /Raptor/); // Throws
+ * ```
+ *
+ * @param actual The actual value to match.
+ * @param expected The expected value to not match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertNotMatch(actual, expected, msg) {
+    if (!expected.test(actual))
+        return;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${actual}" to not match: "${expected}"${msgSuffix}`;
+    throw new AssertionError(msg);
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Make an assertion that `actual` and `expected` are not strictly equal, using
+ * {@linkcode Object.is} for equality comparison. If the values are strictly
+ * equal then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotStrictEquals } from "@std/assert";
+ *
+ * assertNotStrictEquals(1, 1); // Throws
+ * assertNotStrictEquals(1, 2); // Doesn't throw
+ *
+ * assertNotStrictEquals(0, 0); // Throws
+ * assertNotStrictEquals(0, -0); // Doesn't throw
+ * ```
+ *
+ * @typeParam T The type of the values to compare.
+ * @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 assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+//# sourceMappingURL=not_strict_equals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"not_strict_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/not_strict_equals.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAYb"}

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

@@ -0,0 +1,32 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+import { format } from "../../internal/1.0.12/format.js";
+/**
+ * Make an assertion that `actual` and `expected` are not strictly equal, using
+ * {@linkcode Object.is} for equality comparison. If the values are strictly
+ * equal then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotStrictEquals } from "@std/assert";
+ *
+ * assertNotStrictEquals(1, 1); // Throws
+ * assertNotStrictEquals(1, 2); // Doesn't throw
+ *
+ * assertNotStrictEquals(0, 0); // Throws
+ * assertNotStrictEquals(0, -0); // Doesn't throw
+ * ```
+ *
+ * @typeParam T The type of the values to compare.
+ * @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 function assertNotStrictEquals(actual, expected, msg) {
+    if (!Object.is(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Expected "actual" to not be strictly equal to: ${format(actual)}${msgSuffix}\n`);
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Make an assertion that `expected` object is a subset of `actual` object,
+ * deeply. If not, then throw a diff of the objects, with mismatching
+ * properties highlighted.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertObjectMatch } from "@std/assert";
+ *
+ * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
+ * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
+ * assertObjectMatch({ foo: 1, bar: 2 }, { foo: 1 }); // Doesn't throw
+ * assertObjectMatch({ foo: 1 }, { foo: 1, bar: 2 }); // Throws
+ * ```
+ *
+ * @example Usage with nested objects
+ * ```ts ignore
+ * import { assertObjectMatch } from "@std/assert";
+ *
+ * assertObjectMatch({ foo: { bar: 3, baz: 4 } }, { foo: { bar: 3 } }); // Doesn't throw
+ * assertObjectMatch({ foo: { bar: 3 } }, { foo: { bar: 3, baz: 4 } }); // Throws
+ * ```
+ *
+ * @param actual The actual value to be matched.
+ * @param expected The expected value to match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;
+//# sourceMappingURL=object_match.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object_match.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/object_match.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iBAAiB,CAE/B,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EAChC,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,EACtC,GAAG,CAAC,EAAE,MAAM,GACX,IAAI,CAUN"}

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

@@ -0,0 +1,167 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { assertEquals } from "./equals.js";
+/**
+ * Make an assertion that `expected` object is a subset of `actual` object,
+ * deeply. If not, then throw a diff of the objects, with mismatching
+ * properties highlighted.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertObjectMatch } from "@std/assert";
+ *
+ * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
+ * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
+ * assertObjectMatch({ foo: 1, bar: 2 }, { foo: 1 }); // Doesn't throw
+ * assertObjectMatch({ foo: 1 }, { foo: 1, bar: 2 }); // Throws
+ * ```
+ *
+ * @example Usage with nested objects
+ * ```ts ignore
+ * import { assertObjectMatch } from "@std/assert";
+ *
+ * assertObjectMatch({ foo: { bar: 3, baz: 4 } }, { foo: { bar: 3 } }); // Doesn't throw
+ * assertObjectMatch({ foo: { bar: 3 } }, { foo: { bar: 3, baz: 4 } }); // Throws
+ * ```
+ *
+ * @param actual The actual value to be matched.
+ * @param expected The expected value to match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertObjectMatch(
+// deno-lint-ignore no-explicit-any
+actual, expected, msg) {
+    return assertEquals(
+    // get the intersection of "actual" and "expected"
+    // side effect: all the instances' constructor field is "Object" now.
+    filter(actual, expected), 
+    // set (nested) instances' constructor field to be "Object" without changing expected value.
+    // see https://github.com/denoland/std/pull/1419
+    filter(expected, expected), msg);
+}
+function isObject(val) {
+    return typeof val === "object" && val !== null;
+}
+function defineProperty(target, key, value) {
+    return Object.defineProperty(target, key, {
+        value,
+        configurable: true,
+        enumerable: true,
+        writable: true,
+    });
+}
+function filter(a, b) {
+    const seen = new WeakMap();
+    return filterObject(a, b);
+    function filterObject(a, b) {
+        // Prevent infinite loop with circular references with same filter
+        const memo = seen.get(a);
+        if (memo && (memo === b))
+            return a;
+        try {
+            seen.set(a, b);
+        }
+        catch (err) {
+            if (err instanceof TypeError) {
+                throw new TypeError(`Cannot assertObjectMatch ${a === null ? null : `type ${typeof a}`}`);
+            }
+        }
+        // Filter keys and symbols which are present in both actual and expected
+        const filtered = {};
+        const keysA = Reflect.ownKeys(a);
+        const keysB = Reflect.ownKeys(b);
+        const entries = keysA.filter((key) => keysB.includes(key))
+            .map((key) => [key, a[key]]);
+        if (keysA.length && keysB.length && !entries.length) {
+            // If both objects are not empty but don't have the same keys or symbols,
+            // returns the entries in object a.
+            for (const key of keysA)
+                defineProperty(filtered, key, a[key]);
+            return filtered;
+        }
+        for (const [key, value] of entries) {
+            // On regexp references, keep value as it to avoid losing pattern and flags
+            if (value instanceof RegExp) {
+                defineProperty(filtered, key, value);
+                continue;
+            }
+            const subset = b[key];
+            // On array references, build a filtered array and filter nested objects inside
+            if (Array.isArray(value) && Array.isArray(subset)) {
+                defineProperty(filtered, key, filterArray(value, subset));
+                continue;
+            }
+            // On nested objects references, build a filtered object recursively
+            if (isObject(value) && isObject(subset)) {
+                // When both operands are maps, build a filtered map with common keys and filter nested objects inside
+                if ((value instanceof Map) && (subset instanceof Map)) {
+                    defineProperty(filtered, key, new Map([...value].filter(([k]) => subset.has(k)).map(([k, v]) => {
+                        const v2 = subset.get(k);
+                        if (isObject(v) && isObject(v2)) {
+                            return [k, filterObject(v, v2)];
+                        }
+                        return [k, v];
+                    })));
+                    continue;
+                }
+                // When both operands are set, build a filtered set with common values
+                if ((value instanceof Set) && (subset instanceof Set)) {
+                    defineProperty(filtered, key, value.intersection(subset));
+                    continue;
+                }
+                defineProperty(filtered, key, filterObject(value, subset));
+                continue;
+            }
+            defineProperty(filtered, key, value);
+        }
+        return filtered;
+    }
+    function filterArray(a, b) {
+        // Prevent infinite loop with circular references with same filter
+        const memo = seen.get(a);
+        if (memo && (memo === b))
+            return a;
+        seen.set(a, b);
+        const filtered = [];
+        const count = Math.min(a.length, b.length);
+        for (let i = 0; i < count; ++i) {
+            const value = a[i];
+            const subset = b[i];
+            // On regexp references, keep value as it to avoid losing pattern and flags
+            if (value instanceof RegExp) {
+                filtered.push(value);
+                continue;
+            }
+            // On array references, build a filtered array and filter nested objects inside
+            if (Array.isArray(value) && Array.isArray(subset)) {
+                filtered.push(filterArray(value, subset));
+                continue;
+            }
+            // On nested objects references, build a filtered object recursively
+            if (isObject(value) && isObject(subset)) {
+                // When both operands are maps, build a filtered map with common keys and filter nested objects inside
+                if ((value instanceof Map) && (subset instanceof Map)) {
+                    const map = new Map([...value].filter(([k]) => subset.has(k))
+                        .map(([k, v]) => {
+                        const v2 = subset.get(k);
+                        if (isObject(v) && isObject(v2)) {
+                            return [k, filterObject(v, v2)];
+                        }
+                        return [k, v];
+                    }));
+                    filtered.push(map);
+                    continue;
+                }
+                // When both operands are set, build a filtered set with common values
+                if ((value instanceof Set) && (subset instanceof Set)) {
+                    filtered.push(value.intersection(subset));
+                    continue;
+                }
+                filtered.push(filterObject(value, subset));
+                continue;
+            }
+            filtered.push(value);
+        }
+        return filtered;
+    }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ *
+ * To assert that a synchronous function throws, use {@linkcode assertThrows}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertRejects } from "@std/assert";
+ *
+ * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
+ * await assertRejects(async () => console.log("Hello world")); // Throws
+ * ```
+ *
+ * @param fn The function to execute.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The promise which resolves to the thrown error.
+ */
+export declare function assertRejects(fn: () => PromiseLike<unknown>, msg?: string): Promise<unknown>;
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ * If it does not, then it throws. An error class and a string that should be
+ * included in the error message can also be asserted.
+ *
+ * To assert that a synchronous function throws, use {@linkcode assertThrows}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertRejects } from "@std/assert";
+ *
+ * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
+ * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
+ * ```
+ *
+ * @typeParam E The error class to assert.
+ * @param fn The function to execute.
+ * @param ErrorClass The error class to assert.
+ * @param msgIncludes The string that should be included in the error message.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The promise which resolves to the thrown error.
+ */
+export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: abstract new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;
+//# sourceMappingURL=rejects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rejects.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/rejects.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,WAAW,CAAC,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAAC;AACpB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EACnD,EAAE,EAAE,MAAM,WAAW,CAAC,OAAO,CAAC,EAE9B,UAAU,EAAE,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAC9C,WAAW,CAAC,EAAE,MAAM,EACpB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,53 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+import { assertIsError } from "./is_error.js";
+export async function assertRejects(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
+    // deno-lint-ignore no-explicit-any
+    let ErrorClass;
+    let msgIncludes;
+    let err;
+    if (typeof errorClassOrMsg !== "string") {
+        if (errorClassOrMsg === undefined ||
+            errorClassOrMsg.prototype instanceof Error ||
+            errorClassOrMsg.prototype === Error.prototype) {
+            ErrorClass = errorClassOrMsg;
+            msgIncludes = msgIncludesOrMsg;
+        }
+    }
+    else {
+        msg = errorClassOrMsg;
+    }
+    let doesThrow = false;
+    let isPromiseReturned = false;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    try {
+        const possiblePromise = fn();
+        if (possiblePromise &&
+            typeof possiblePromise === "object" &&
+            typeof possiblePromise.then === "function") {
+            isPromiseReturned = true;
+            await possiblePromise;
+        }
+        else {
+            throw new Error();
+        }
+    }
+    catch (error) {
+        if (!isPromiseReturned) {
+            throw new AssertionError(`Function throws when expected to reject${msgSuffix}`);
+        }
+        if (ErrorClass) {
+            if (!(error instanceof Error)) {
+                throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
+            }
+            assertIsError(error, ErrorClass, msgIncludes, msg);
+        }
+        err = error;
+        doesThrow = true;
+    }
+    if (!doesThrow) {
+        throw new AssertionError(`Expected function to reject${msgSuffix}`);
+    }
+    return err;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal, using
+ * {@linkcode Object.is} for equality comparison. If not, then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertStrictEquals } from "@std/assert";
+ *
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
+ *
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
+ * ```
+ *
+ * @typeParam T The type of the expected value.
+ * @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 assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+//# sourceMappingURL=strict_equals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strict_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/strict_equals.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,CAAC,CAgCrB"}

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

@@ -0,0 +1,58 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { buildMessage } from "../../internal/1.0.12/build_message.js";
+import { diff } from "../../internal/1.0.12/diff.js";
+import { diffStr } from "../../internal/1.0.12/diff_str.js";
+import { format } from "../../internal/1.0.12/format.js";
+import { red } from "../../internal/1.0.12/styles.js";
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal, using
+ * {@linkcode Object.is} for equality comparison. If not, then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertStrictEquals } from "@std/assert";
+ *
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
+ *
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
+ * ```
+ *
+ * @typeParam T The type of the expected value.
+ * @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 function assertStrictEquals(actual, expected, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message;
+    const actualString = format(actual);
+    const expectedString = format(expected);
+    if (actualString === expectedString) {
+        const withOffset = actualString
+            .split("\n")
+            .map((l) => `    ${l}`)
+            .join("\n");
+        message =
+            `Values have the same structure but are not reference-equal${msgSuffix}\n\n${red(withOffset)}\n`;
+    }
+    else {
+        const stringDiff = (typeof actual === "string") &&
+            (typeof expected === "string");
+        const diffResult = stringDiff
+            ? diffStr(actual, expected)
+            : diff(actualString.split("\n"), expectedString.split("\n"));
+        const diffMsg = buildMessage(diffResult, { stringDiff }, arguments[3])
+            .join("\n");
+        message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
+    }
+    throw new AssertionError(message);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertStringIncludes } from "@std/assert";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
+ *
+ * @param actual The actual string to check for inclusion.
+ * @param expected The expected string to check for inclusion.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+//# sourceMappingURL=string_includes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string_includes.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/string_includes.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,QAMb"}