@temboplus/afloat 0.1.58 → 0.1.60

package/script/npm/src/_dnt.test_shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/almost_equals.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers
+ * through a given tolerance. It can be used to take into account IEEE-754
+ * double-precision floating-point representation limitations. If the values
+ * are not almost equal then throw.
+ *
+ * The default tolerance is one hundred thousandth of a percent of the
+ * expected value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertAlmostEquals } from "@std/assert";
+ *
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(1e-8, 1e-9); // Throws
+ * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ *
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param tolerance The tolerance to consider the values almost equal. The
+ * default is one hundred thousandth of a percent of the expected value.
+ * @param msg The optional message to include in the error.
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+//# sourceMappingURL=almost_equals.d.ts.map

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/almost_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"almost_equals.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@std/assert/1.0.10/almost_equals.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,GAAG,CAAC,EAAE,MAAM,QAmBb"}

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/almost_equals.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertAlmostEquals = assertAlmostEquals;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers
+ * through a given tolerance. It can be used to take into account IEEE-754
+ * double-precision floating-point representation limitations. If the values
+ * are not almost equal then throw.
+ *
+ * The default tolerance is one hundred thousandth of a percent of the
+ * expected value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertAlmostEquals } from "@std/assert";
+ *
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(1e-8, 1e-9); // Throws
+ * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ *
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param tolerance The tolerance to consider the values almost equal. The
+ * default is one hundred thousandth of a percent of the expected value.
+ * @param msg The optional message to include in the error.
+ */
+function assertAlmostEquals(actual, expected, tolerance, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const delta = Math.abs(expected - actual);
+    if (tolerance === undefined) {
+        tolerance = isFinite(expected) ? Math.abs(expected * 1e-7) : 1e-7;
+    }
+    if (delta <= tolerance) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const f = (n) => Number.isInteger(n) ? n : n.toExponential();
+    throw new assertion_error_js_1.AssertionError(`Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
+delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`);
+}

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/array_includes.d.ts

@@ -0,0 +1,24 @@
+/** An array-like object (`Array`, `Uint8Array`, `NodeList`, etc.) that is not a string */
+export type ArrayLikeArg<T> = ArrayLike<T> & object;
+/**
+ * Make an assertion that `actual` includes the `expected` values. If not then
+ * an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ *
+ * @typeParam T The type of the elements in the array to compare.
+ * @param actual The array-like object to check for.
+ * @param expected The array-like object to check for.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertArrayIncludes<T>(actual: ArrayLikeArg<T>, expected: ArrayLikeArg<T>, msg?: string): void;
+//# sourceMappingURL=array_includes.d.ts.map

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/array_includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_includes.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@std/assert/1.0.10/array_includes.ts"],"names":[],"mappings":"AAMA,0FAA0F;AAC1F,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,GAAG,CAAC,EAAE,MAAM,QAwBb"}

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/array_includes.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArrayIncludes = assertArrayIncludes;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const equal_js_1 = require("./equal.js");
+const format_js_1 = require("../../internal/1.0.5/format.js");
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` includes the `expected` values. If not then
+ * an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ *
+ * @typeParam T The type of the elements in the array to compare.
+ * @param actual The array-like object to check for.
+ * @param expected The array-like object to check for.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertArrayIncludes(actual, expected, msg) {
+    const missing = [];
+    for (let i = 0; i < expected.length; i++) {
+        let found = false;
+        for (let j = 0; j < actual.length; j++) {
+            if ((0, equal_js_1.equal)(expected[i], actual[j])) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            missing.push(expected[i]);
+        }
+    }
+    if (missing.length === 0) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${(0, format_js_1.format)(actual)}" to include: "${(0, format_js_1.format)(expected)}"${msgSuffix}\nmissing: ${(0, format_js_1.format)(missing)}`;
+    throw new assertion_error_js_1.AssertionError(msg);
+}

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/assert.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assert } from "@std/assert";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+//# sourceMappingURL=assert.d.ts.map

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@std/assert/1.0.10/assert.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAI5D"}

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/assert.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assert } from "@std/assert";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/assertion_error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=assertion_error.d.ts.map

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/assertion_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@std/assert/1.0.10/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/assertion_error.js

@@ -0,0 +1,34 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionError = void 0;
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AssertionError";
+    }
+}
+exports.AssertionError = AssertionError;

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/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/script/npm/src/deps/jsr.io/@std/assert/1.0.10/equal.d.ts.map

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

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/equal.js

@@ -0,0 +1,209 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equal = equal;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const dntShim = __importStar(require("../../../../../_dnt.test_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 ??
+    new Proxy({}, { get: () => { } });
+/** 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`
+ * ```
+ */
+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 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/npm/src/deps/jsr.io/@std/assert/1.0.10/equals.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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: When comparing `Blob` objects, you should first convert them to
+ * `Uint8Array` using the `Blob.bytes()` method and then compare their
+ * contents.
+ *
+ * @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/npm/src/deps/jsr.io/@std/assert/1.0.10/equals.d.ts.map

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

package/script/npm/src/deps/jsr.io/@std/assert/1.0.10/equals.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertEquals = assertEquals;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const equal_js_1 = require("./equal.js");
+const build_message_js_1 = require("../../internal/1.0.5/build_message.js");
+const diff_js_1 = require("../../internal/1.0.5/diff.js");
+const diff_str_js_1 = require("../../internal/1.0.5/diff_str.js");
+const format_js_1 = require("../../internal/1.0.5/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: When comparing `Blob` objects, you should first convert them to
+ * `Uint8Array` using the `Blob.bytes()` method and then compare their
+ * contents.
+ *
+ * @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 }).join("\n");
+    message = `${message}\n${diffMsg}`;
+    throw new assertion_error_js_1.AssertionError(message);
+}