@mtkruto/node 0.2.31 → 0.2.32

package/esm/deps/deno.land/std@0.224.0/assert/assert_rejects.js

@@ -0,0 +1,51 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+import { assertIsError } from "./assert_is_error.js";
+export async function assertRejects(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
+    // deno-lint-ignore no-explicit-any
+    let ErrorClass = undefined;
+    let msgIncludes = undefined;
+    let err;
+    if (typeof errorClassOrMsg !== "string") {
+        if (errorClassOrMsg === undefined ||
+            errorClassOrMsg.prototype instanceof Error ||
+            errorClassOrMsg.prototype === Error.prototype) {
+            // deno-lint-ignore no-explicit-any
+            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;
+        }
+    }
+    catch (error) {
+        if (!isPromiseReturned) {
+            throw new AssertionError(`Function throws when expected to reject${msgSuffix}`);
+        }
+        if (ErrorClass) {
+            if (error instanceof Error === false) {
+                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/deno.land/std@0.224.0/assert/assert_strict_equals.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal. If
+ * not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_strict_equals.ts";
+ *
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
+ *
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
+ * ```
+ */
+export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+//# sourceMappingURL=assert_strict_equals.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/assert_strict_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert_strict_equals.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/assert_strict_equals.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,CAAC,CAmCrB"}

package/esm/deps/deno.land/std@0.224.0/assert/assert_strict_equals.js

@@ -0,0 +1,55 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { buildMessage, diff, diffstr, format } from "../internal/mod.js";
+import { AssertionError } from "./assertion_error.js";
+import { CAN_NOT_DISPLAY } from "./_constants.js";
+import { red } from "../fmt/colors.js";
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal. If
+ * not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_strict_equals.ts";
+ *
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
+ *
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
+ * ```
+ */
+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 {
+        try {
+            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 }).join("\n");
+            message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
+        }
+        catch {
+            message = `\n${red(CAN_NOT_DISPLAY)} + \n\n`;
+        }
+    }
+    throw new AssertionError(message);
+}

package/esm/deps/deno.land/std@0.224.0/assert/assert_string_includes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStringIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_string_includes.ts";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+//# sourceMappingURL=assert_string_includes.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/assert_string_includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert_string_includes.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/assert_string_includes.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,QAOb"}

package/esm/deps/deno.land/std@0.224.0/assert/assert_string_includes.js

@@ -0,0 +1,22 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStringIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_string_includes.ts";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
+ */
+export function assertStringIncludes(actual, expected, msg) {
+    if (!actual.includes(expected)) {
+        const msgSuffix = msg ? `: ${msg}` : ".";
+        msg = `Expected actual: "${actual}" to contain: "${expected}"${msgSuffix}`;
+        throw new AssertionError(msg);
+    }
+}

package/esm/deps/deno.land/std@0.224.0/assert/assert_throws.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws.
+ *
+ * To assert that an asynchronous function rejects, use
+ * {@linkcode assertRejects}.
+ *
+ * @example
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/assert/assert_throws.ts";
+ *
+ * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
+ * assertThrows(() => console.log("hello world!")); // Throws
+ * ```
+ */
+export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
+/**
+ * Executes a function, expecting it to throw. 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 an asynchronous function rejects, use
+ * {@linkcode assertRejects}.
+ *
+ * @example
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/assert/assert_throws.ts";
+ *
+ * assertThrows(() => { throw new TypeError("hello world!"); }, TypeError); // Doesn't throw
+ * assertThrows(() => { throw new TypeError("hello world!"); }, RangeError); // Throws
+ * ```
+ */
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
+//# sourceMappingURL=assert_throws.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/assert_throws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert_throws.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/assert_throws.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,OAAO,EACjB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC;AACX;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAClD,EAAE,EAAE,MAAM,OAAO,EAEjB,UAAU,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EACrC,WAAW,CAAC,EAAE,MAAM,EACpB,GAAG,CAAC,EAAE,MAAM,GACX,CAAC,CAAC"}

package/esm/deps/deno.land/std@0.224.0/assert/assert_throws.js

@@ -0,0 +1,45 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { assertIsError } from "./assert_is_error.js";
+import { AssertionError } from "./assertion_error.js";
+export function assertThrows(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
+    // deno-lint-ignore no-explicit-any
+    let ErrorClass = undefined;
+    let msgIncludes = undefined;
+    let err;
+    if (typeof errorClassOrMsg !== "string") {
+        if (errorClassOrMsg === undefined ||
+            errorClassOrMsg.prototype instanceof Error ||
+            errorClassOrMsg.prototype === Error.prototype) {
+            // deno-lint-ignore no-explicit-any
+            ErrorClass = errorClassOrMsg;
+            msgIncludes = msgIncludesOrMsg;
+        }
+        else {
+            msg = msgIncludesOrMsg;
+        }
+    }
+    else {
+        msg = errorClassOrMsg;
+    }
+    let doesThrow = false;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    try {
+        fn();
+    }
+    catch (error) {
+        if (ErrorClass) {
+            if (error instanceof Error === false) {
+                throw new AssertionError(`A non-Error object was thrown${msgSuffix}`);
+            }
+            assertIsError(error, ErrorClass, msgIncludes, msg);
+        }
+        err = error;
+        doesThrow = true;
+    }
+    if (!doesThrow) {
+        msg = `Expected function to throw${msgSuffix}`;
+        throw new AssertionError(msg);
+    }
+    return err;
+}

package/esm/deps/deno.land/std@0.224.0/assert/assertion_error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message: string);
+}
+//# sourceMappingURL=assertion_error.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/assertion_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,iCAAiC;gBACrB,OAAO,EAAE,MAAM;CAI5B"}

package/esm/deps/deno.land/std@0.224.0/assert/assertion_error.js

@@ -0,0 +1,19 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+export class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message) {
+        super(message);
+        this.name = "AssertionError";
+    }
+}

package/esm/deps/deno.land/std@0.224.0/assert/equal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ *
+ * @example
+ * ```ts
+ * import { equal } from "https://deno.land/std@$STD_VERSION/assert/equal.ts";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+ * ```
+ */
+export declare function equal(c: unknown, d: unknown): boolean;
+//# sourceMappingURL=equal.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/equal.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CA8FrD"}

package/esm/deps/deno.land/std@0.224.0/assert/equal.js

@@ -0,0 +1,111 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+function isKeyedCollection(x) {
+    return [Symbol.iterator, "size"].every((k) => k in x);
+}
+function constructorsEqual(a, b) {
+    return a.constructor === b.constructor ||
+        a.constructor === Object && !b.constructor ||
+        !a.constructor && b.constructor === Object;
+}
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ *
+ * @example
+ * ```ts
+ * import { equal } from "https://deno.land/std@$STD_VERSION/assert/equal.ts";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+ * ```
+ */
+export function equal(c, d) {
+    const seen = new Map();
+    return (function compare(a, b) {
+        // Have to render RegExp & Date for string comparison
+        // unless it's mistreated as object
+        if (a &&
+            b &&
+            ((a instanceof RegExp && b instanceof RegExp) ||
+                (a instanceof URL && b instanceof URL))) {
+            return String(a) === String(b);
+        }
+        if (a instanceof Date && b instanceof Date) {
+            const aTime = a.getTime();
+            const bTime = b.getTime();
+            // Check for NaN equality manually since NaN is not
+            // equal to itself.
+            if (Number.isNaN(aTime) && Number.isNaN(bTime)) {
+                return true;
+            }
+            return aTime === bTime;
+        }
+        if (typeof a === "number" && typeof b === "number") {
+            return Number.isNaN(a) && Number.isNaN(b) || a === b;
+        }
+        if (Object.is(a, b)) {
+            return true;
+        }
+        if (a && typeof a === "object" && b && typeof b === "object") {
+            if (a && b && !constructorsEqual(a, b)) {
+                return false;
+            }
+            if (a instanceof WeakMap || b instanceof WeakMap) {
+                if (!(a instanceof WeakMap && b instanceof WeakMap))
+                    return false;
+                throw new TypeError("cannot compare WeakMap instances");
+            }
+            if (a instanceof WeakSet || b instanceof WeakSet) {
+                if (!(a instanceof WeakSet && b instanceof WeakSet))
+                    return false;
+                throw new TypeError("cannot compare WeakSet instances");
+            }
+            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;
+                }
+                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 ((aKey === aValue && bKey === bValue && compare(aKey, bKey)) ||
+                            (compare(aKey, bKey) && compare(aValue, bValue))) {
+                            unmatchedEntries--;
+                            break;
+                        }
+                    }
+                }
+                return unmatchedEntries === 0;
+            }
+            const merged = { ...a, ...b };
+            for (const key of [
+                ...Object.getOwnPropertyNames(merged),
+                ...Object.getOwnPropertySymbols(merged),
+            ]) {
+                if (!compare(a && a[key], b && b[key])) {
+                    return false;
+                }
+                if (((key in a) && (!(key in b))) || ((key in b) && (!(key in a)))) {
+                    return false;
+                }
+            }
+            if (a instanceof WeakRef || b instanceof WeakRef) {
+                if (!(a instanceof WeakRef && b instanceof WeakRef))
+                    return false;
+                return compare(a.deref(), b.deref());
+            }
+            return true;
+        }
+        return false;
+    })(c, d);
+}

package/esm/deps/deno.land/std@0.224.0/assert/fail.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Forcefully throws a failed assertion.
+ *
+ * @example
+ * ```ts
+ * import { fail } from "https://deno.land/std@$STD_VERSION/assert/fail.ts";
+ *
+ * fail("Deliberately failed!"); // Throws
+ * ```
+ */
+export declare function fail(msg?: string): never;
+//# sourceMappingURL=fail.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/fail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/fail.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAGxC"}

package/esm/deps/deno.land/std@0.224.0/assert/fail.js

@@ -0,0 +1,17 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { assert } from "./assert.js";
+/**
+ * Forcefully throws a failed assertion.
+ *
+ * @example
+ * ```ts
+ * import { fail } from "https://deno.land/std@$STD_VERSION/assert/fail.ts";
+ *
+ * fail("Deliberately failed!"); // Throws
+ * ```
+ */
+export function fail(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    assert(false, `Failed assertion${msgSuffix}`);
+}

package/esm/deps/deno.land/std@0.224.0/assert/mod.d.ts

@@ -0,0 +1,44 @@
+/** A library of assertion functions.
+ * If the assertion is false an `AssertionError` will be thrown which will
+ * result in pretty-printed diff of failing assertion.
+ *
+ * This module is browser compatible, but do not rely on good formatting of
+ * values for AssertionError messages in browsers.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("I am truthy"); // Doesn't throw
+ * assert(false); // Throws `AssertionError`
+ * ```
+ *
+ * @module
+ */
+export * from "./assert_almost_equals.js";
+export * from "./assert_array_includes.js";
+export * from "./assert_equals.js";
+export * from "./assert_exists.js";
+export * from "./assert_false.js";
+export * from "./assert_greater_or_equal.js";
+export * from "./assert_greater.js";
+export * from "./assert_instance_of.js";
+export * from "./assert_is_error.js";
+export * from "./assert_less_or_equal.js";
+export * from "./assert_less.js";
+export * from "./assert_match.js";
+export * from "./assert_not_equals.js";
+export * from "./assert_not_instance_of.js";
+export * from "./assert_not_match.js";
+export * from "./assert_not_strict_equals.js";
+export * from "./assert_object_match.js";
+export * from "./assert_rejects.js";
+export * from "./assert_strict_equals.js";
+export * from "./assert_string_includes.js";
+export * from "./assert_throws.js";
+export * from "./assert.js";
+export * from "./assertion_error.js";
+export * from "./equal.js";
+export * from "./fail.js";
+export * from "./unimplemented.js";
+export * from "./unreachable.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AAEH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/esm/deps/deno.land/std@0.224.0/assert/mod.js

@@ -0,0 +1,45 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/** A library of assertion functions.
+ * If the assertion is false an `AssertionError` will be thrown which will
+ * result in pretty-printed diff of failing assertion.
+ *
+ * This module is browser compatible, but do not rely on good formatting of
+ * values for AssertionError messages in browsers.
+ *
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("I am truthy"); // Doesn't throw
+ * assert(false); // Throws `AssertionError`
+ * ```
+ *
+ * @module
+ */
+export * from "./assert_almost_equals.js";
+export * from "./assert_array_includes.js";
+export * from "./assert_equals.js";
+export * from "./assert_exists.js";
+export * from "./assert_false.js";
+export * from "./assert_greater_or_equal.js";
+export * from "./assert_greater.js";
+export * from "./assert_instance_of.js";
+export * from "./assert_is_error.js";
+export * from "./assert_less_or_equal.js";
+export * from "./assert_less.js";
+export * from "./assert_match.js";
+export * from "./assert_not_equals.js";
+export * from "./assert_not_instance_of.js";
+export * from "./assert_not_match.js";
+export * from "./assert_not_strict_equals.js";
+export * from "./assert_object_match.js";
+export * from "./assert_rejects.js";
+export * from "./assert_strict_equals.js";
+export * from "./assert_string_includes.js";
+export * from "./assert_throws.js";
+export * from "./assert.js";
+export * from "./assertion_error.js";
+export * from "./equal.js";
+export * from "./fail.js";
+export * from "./unimplemented.js";
+export * from "./unreachable.js";

package/esm/deps/deno.land/std@0.224.0/assert/unimplemented.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example
+ * ```ts
+ * import { unimplemented } from "https://deno.land/std@$STD_VERSION/assert/unimplemented.ts";
+ *
+ * unimplemented(); // Throws
+ * ```
+ */
+export declare function unimplemented(msg?: string): never;
+//# sourceMappingURL=unimplemented.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/unimplemented.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unimplemented.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/unimplemented.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAGjD"}

package/esm/deps/deno.land/std@0.224.0/assert/unimplemented.js

@@ -0,0 +1,17 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example
+ * ```ts
+ * import { unimplemented } from "https://deno.land/std@$STD_VERSION/assert/unimplemented.ts";
+ *
+ * unimplemented(); // Throws
+ * ```
+ */
+export function unimplemented(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Unimplemented${msgSuffix}`);
+}

package/esm/deps/deno.land/std@0.224.0/assert/unreachable.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example
+ * ```ts
+ * import { unreachable } from "https://deno.land/std@$STD_VERSION/assert/unreachable.ts";
+ *
+ * unreachable(); // Throws
+ * ```
+ */
+export declare function unreachable(reason?: string): never;
+//# sourceMappingURL=unreachable.d.ts.map

package/esm/deps/deno.land/std@0.224.0/assert/unreachable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unreachable.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/unreachable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAElD"}

package/esm/deps/deno.land/std@0.224.0/assert/unreachable.js

@@ -0,0 +1,16 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example
+ * ```ts
+ * import { unreachable } from "https://deno.land/std@$STD_VERSION/assert/unreachable.ts";
+ *
+ * unreachable(); // Throws
+ * ```
+ */
+export function unreachable(reason) {
+    throw new AssertionError(reason ?? "unreachable");
+}

package/esm/deps/deno.land/std@0.224.0/bytes/concat.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Concatenate an array of byte slices into a single slice.
+ *
+ * @param buffers Array of byte slices to concatenate.
+ * @returns Hello
+ *
+ * @example Basic usage
+ * ```ts
+ * import { concat } from "https://deno.land/std@$STD_VERSION/bytes/concat.ts";
+ *
+ * const a = new Uint8Array([0, 1, 2]);
+ * const b = new Uint8Array([3, 4, 5]);
+ *
+ * concat([a, b]); // Uint8Array(6) [ 0, 1, 2, 3, 4, 5 ]
+ * ```
+ */
+export declare function concat(buffers: Uint8Array[]): Uint8Array;
+//# sourceMappingURL=concat.d.ts.map

package/esm/deps/deno.land/std@0.224.0/bytes/concat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/bytes/concat.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,CAaxD"}