@mtkruto/node 0.2.42 → 0.2.44

package/script/deps/jsr.io/@std/assert/1.0.5/object_match.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertObjectMatch = void 0;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const equals_js_1 = require("./equals.js");
+/**
+ * Make an assertion that `expected` object is a subset of `actual` object,
+ * deeply. If not, then throw.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * 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 no-eval
+ * 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.
+ */
+function assertObjectMatch(
+// deno-lint-ignore no-explicit-any
+actual, expected, msg) {
+    return (0, equals_js_1.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/deno_std/pull/1419
+    filter(expected, expected), msg);
+}
+exports.assertObjectMatch = assertObjectMatch;
+function isObject(val) {
+    return typeof val === "object" && val !== null;
+}
+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
+        if ((seen.has(a)) && (seen.get(a) === 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) {
+                filtered[key] = a[key];
+            }
+            return filtered;
+        }
+        for (const [key, value] of entries) {
+            // On regexp references, keep value as it to avoid loosing pattern and flags
+            if (value instanceof RegExp) {
+                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)) {
+                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)) {
+                    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)) {
+                    filtered[key] = value.intersection(subset);
+                    continue;
+                }
+                filtered[key] = filterObject(value, subset);
+                continue;
+            }
+            filtered[key] = value;
+        }
+        return filtered;
+    }
+    function filterArray(a, b) {
+        // Prevent infinite loop with circular references with same filter
+        if (seen.has(a) && (seen.get(a) === 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 loosing 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/script/deps/jsr.io/@std/assert/1.0.5/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 no-eval
+ * 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 no-eval
+ * 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: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;
+//# sourceMappingURL=rejects.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.5/rejects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rejects.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.5/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,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EACrC,WAAW,CAAC,EAAE,MAAM,EACpB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/script/deps/jsr.io/@std/assert/1.0.5/rejects.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRejects = void 0;
+// 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");
+const is_error_js_1 = require("./is_error.js");
+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;
+        }
+        else {
+            throw new Error();
+        }
+    }
+    catch (error) {
+        if (!isPromiseReturned) {
+            throw new assertion_error_js_1.AssertionError(`Function throws when expected to reject${msgSuffix}`);
+        }
+        if (ErrorClass) {
+            if (!(error instanceof Error)) {
+                throw new assertion_error_js_1.AssertionError(`A non-Error object was rejected${msgSuffix}`);
+            }
+            (0, is_error_js_1.assertIsError)(error, ErrorClass, msgIncludes, msg);
+        }
+        err = error;
+        doesThrow = true;
+    }
+    if (!doesThrow) {
+        throw new assertion_error_js_1.AssertionError(`Expected function to reject${msgSuffix}`);
+    }
+    return err;
+}
+exports.assertRejects = assertRejects;

package/script/deps/jsr.io/@std/assert/1.0.5/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 no-eval
+ * 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/script/deps/jsr.io/@std/assert/1.0.5/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.5/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,CA+BrB"}

package/script/deps/jsr.io/@std/assert/1.0.5/strict_equals.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertStrictEquals = void 0;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const build_message_js_1 = require("../../internal/1.0.3/build_message.js");
+const diff_js_1 = require("../../internal/1.0.3/diff.js");
+const diff_str_js_1 = require("../../internal/1.0.3/diff_str.js");
+const format_js_1 = require("../../internal/1.0.3/format.js");
+const styles_js_1 = require("../../internal/1.0.3/styles.js");
+const assertion_error_js_1 = require("./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 no-eval
+ * 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.
+ */
+function assertStrictEquals(actual, expected, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message;
+    const actualString = (0, format_js_1.format)(actual);
+    const expectedString = (0, format_js_1.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${(0, styles_js_1.red)(withOffset)}\n`;
+    }
+    else {
+        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 = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
+    }
+    throw new assertion_error_js_1.AssertionError(message);
+}
+exports.assertStrictEquals = assertStrictEquals;

package/script/deps/jsr.io/@std/assert/1.0.5/string_includes.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * 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/script/deps/jsr.io/@std/assert/1.0.5/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.5/string_includes.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,QAMb"}

package/script/deps/jsr.io/@std/assert/1.0.5/string_includes.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertStringIncludes = void 0;
+// 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 includes expected. If not
+ * then throw.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * 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.
+ */
+function assertStringIncludes(actual, expected, msg) {
+    if (actual.includes(expected))
+        return;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${actual}" to contain: "${expected}"${msgSuffix}`;
+    throw new assertion_error_js_1.AssertionError(msg);
+}
+exports.assertStringIncludes = assertStringIncludes;

package/script/deps/jsr.io/@std/assert/1.0.5/throws.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 Usage
+ * ```ts no-eval
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
+ * assertThrows(() => console.log("hello world!")); // Throws
+ * ```
+ *
+ * @param fn The function to execute.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The error that was thrown.
+ */
+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 Usage
+ * ```ts no-eval
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertThrows(() => { throw new TypeError("hello world!"); }, TypeError); // Doesn't throw
+ * assertThrows(() => { throw new TypeError("hello world!"); }, RangeError); // 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 error that was thrown.
+ */
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
+//# sourceMappingURL=throws.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.5/throws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throws.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.5/throws.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,OAAO,EACjB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC;AACX;;;;;;;;;;;;;;;;;;;;;;GAsBG;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/script/deps/jsr.io/@std/assert/1.0.5/throws.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertThrows = void 0;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const is_error_js_1 = require("./is_error.js");
+const assertion_error_js_1 = require("./assertion_error.js");
+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 assertion_error_js_1.AssertionError(`A non-Error object was thrown${msgSuffix}`);
+            }
+            (0, is_error_js_1.assertIsError)(error, ErrorClass, msgIncludes, msg);
+        }
+        err = error;
+        doesThrow = true;
+    }
+    if (!doesThrow) {
+        msg = `Expected function to throw${msgSuffix}`;
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+    return err;
+}
+exports.assertThrows = assertThrows;

package/script/deps/jsr.io/@std/assert/1.0.5/unimplemented.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * import { unimplemented } from "@std/assert";
+ *
+ * unimplemented(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export declare function unimplemented(msg?: string): never;
+//# sourceMappingURL=unimplemented.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.5/unimplemented.d.ts.map

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

package/script/deps/jsr.io/@std/assert/1.0.5/unimplemented.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unimplemented = void 0;
+// 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");
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * import { unimplemented } from "@std/assert";
+ *
+ * unimplemented(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+function unimplemented(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new assertion_error_js_1.AssertionError(`Unimplemented${msgSuffix}`);
+}
+exports.unimplemented = unimplemented;

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

@@ -0,0 +1,15 @@
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * import { unreachable } from "@std/assert";
+ *
+ * unreachable(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export declare function unreachable(msg?: string): never;
+//# sourceMappingURL=unreachable.d.ts.map

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unreachable = void 0;
+// 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");
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * 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}`);
+}
+exports.unreachable = unreachable;

package/script/deps/jsr.io/@std/bytes/0.224.0/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 "@std/bytes/concat";
+ *
+ * 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/script/deps/jsr.io/@std/bytes/0.224.0/concat.d.ts.map

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

package/script/deps/jsr.io/@std/bytes/0.224.0/concat.js

@@ -0,0 +1,35 @@
+"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.concat = void 0;
+/**
+ * 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 "@std/bytes/concat";
+ *
+ * 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 ]
+ * ```
+ */
+function concat(buffers) {
+    let length = 0;
+    for (const buffer of buffers) {
+        length += buffer.length;
+    }
+    const output = new Uint8Array(length);
+    let index = 0;
+    for (const buffer of buffers) {
+        output.set(buffer, index);
+        index += buffer.length;
+    }
+    return output;
+}
+exports.concat = concat;

package/script/deps/jsr.io/@std/encoding/1.0.5/_validate_binary_like.d.ts

@@ -0,0 +1,2 @@
+export declare function validateBinaryLike(source: unknown): Uint8Array;
+//# sourceMappingURL=_validate_binary_like.d.ts.map