@mtkruto/node 0.2.43 → 0.2.44

package/script/deps/deno.land/std@0.224.0/assert/assert_not_equals.js

@@ -1,44 +0,0 @@
-"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.assertNotEquals = void 0;
-const _constants_js_1 = require("./_constants.js");
-const equal_js_1 = require("./equal.js");
-const assertion_error_js_1 = require("./assertion_error.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
- * ```ts
- * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
- *
- * assertNotEquals(1, 2); // Doesn't throw
- * assertNotEquals(1, 1); // Throws
- * ```
- */
-function assertNotEquals(actual, expected, msg) {
-    if (!(0, equal_js_1.equal)(actual, expected)) {
-        return;
-    }
-    let actualString;
-    let expectedString;
-    try {
-        actualString = String(actual);
-    }
-    catch {
-        actualString = _constants_js_1.CAN_NOT_DISPLAY;
-    }
-    try {
-        expectedString = String(expected);
-    }
-    catch {
-        expectedString = _constants_js_1.CAN_NOT_DISPLAY;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    throw new assertion_error_js_1.AssertionError(`Expected actual: ${actualString} not to be: ${expectedString}${msgSuffix}`);
-}
-exports.assertNotEquals = assertNotEquals;

package/script/deps/deno.land/std@0.224.0/assert/assert_not_instance_of.d.ts

@@ -1,14 +0,0 @@
-/**
- * Make an assertion that `obj` is not an instance of `type`.
- * If so, then throw.
- *
- * @example
- * ```ts
- * import { assertNotInstanceOf } from "https://deno.land/std@$STD_VERSION/assert/assert_not_instance_of.ts";
- *
- * assertNotInstanceOf(new Date(), Number); // Doesn't throw
- * assertNotInstanceOf(new Date(), Date); // Throws
- * ```
- */
-export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;
-//# sourceMappingURL=assert_not_instance_of.d.ts.map

package/script/deps/deno.land/std@0.224.0/assert/assert_not_instance_of.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert_not_instance_of.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/assert_not_instance_of.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EACtC,MAAM,EAAE,CAAC,EAET,cAAc,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EACzC,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAKjC"}

package/script/deps/deno.land/std@0.224.0/assert/assert_not_instance_of.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNotInstanceOf = void 0;
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-const assert_false_js_1 = require("./assert_false.js");
-/**
- * Make an assertion that `obj` is not an instance of `type`.
- * If so, then throw.
- *
- * @example
- * ```ts
- * import { assertNotInstanceOf } from "https://deno.land/std@$STD_VERSION/assert/assert_not_instance_of.ts";
- *
- * assertNotInstanceOf(new Date(), Number); // Doesn't throw
- * assertNotInstanceOf(new Date(), Date); // Throws
- * ```
- */
-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}`;
-    (0, assert_false_js_1.assertFalse)(actual instanceof unexpectedType, msg);
-}
-exports.assertNotInstanceOf = assertNotInstanceOf;

package/script/deps/deno.land/std@0.224.0/assert/assert_not_match.d.ts

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

package/script/deps/deno.land/std@0.224.0/assert/assert_not_match.d.ts.map

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

package/script/deps/deno.land/std@0.224.0/assert/assert_not_match.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNotMatch = 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` not match RegExp `expected`. If match
- * then throw.
- *
- * @example
- * ```ts
- * import { assertNotMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_not_match.ts";
- *
- * assertNotMatch("Denosaurus", RegExp(/Raptor/)); // Doesn't throw
- * assertNotMatch("Raptor", RegExp(/Raptor/)); // Throws
- * ```
- */
-function assertNotMatch(actual, expected, msg) {
-    if (expected.test(actual)) {
-        const msgSuffix = msg ? `: ${msg}` : ".";
-        msg =
-            `Expected actual: "${actual}" to not match: "${expected}"${msgSuffix}`;
-        throw new assertion_error_js_1.AssertionError(msg);
-    }
-}
-exports.assertNotMatch = assertNotMatch;

package/script/deps/deno.land/std@0.224.0/assert/assert_not_strict_equals.d.ts

@@ -1,14 +0,0 @@
-/**
- * Make an assertion that `actual` and `expected` are not strictly equal.
- * If the values are strictly equal then throw.
- *
- * @example
- * ```ts
- * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_strict_equals.ts";
- *
- * assertNotStrictEquals(1, 1); // Doesn't throw
- * assertNotStrictEquals(1, 2); // Throws
- * ```
- */
-export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
-//# sourceMappingURL=assert_not_strict_equals.d.ts.map

package/script/deps/deno.land/std@0.224.0/assert/assert_not_strict_equals.d.ts.map

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

package/script/deps/deno.land/std@0.224.0/assert/assert_not_strict_equals.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNotStrictEquals = 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 format_js_1 = require("../internal/format.js");
-/**
- * Make an assertion that `actual` and `expected` are not strictly equal.
- * If the values are strictly equal then throw.
- *
- * @example
- * ```ts
- * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_strict_equals.ts";
- *
- * assertNotStrictEquals(1, 1); // Doesn't throw
- * assertNotStrictEquals(1, 2); // Throws
- * ```
- */
-function assertNotStrictEquals(actual, expected, msg) {
-    if (!Object.is(actual, expected)) {
-        return;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    throw new assertion_error_js_1.AssertionError(`Expected "actual" to not be strictly equal to: ${(0, format_js_1.format)(actual)}${msgSuffix}\n`);
-}
-exports.assertNotStrictEquals = assertNotStrictEquals;

package/script/deps/deno.land/std@0.224.0/assert/assert_object_match.d.ts

@@ -1,14 +0,0 @@
-/**
- * Make an assertion that `actual` object is a subset of `expected` object,
- * deeply. If not, then throw.
- *
- * @example
- * ```ts
- * import { assertObjectMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_object_match.ts";
- *
- * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
- * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
- * ```
- */
-export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;
-//# sourceMappingURL=assert_object_match.d.ts.map

package/script/deps/deno.land/std@0.224.0/assert/assert_object_match.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert_object_match.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/assert_object_match.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;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,CA+EN"}

package/script/deps/deno.land/std@0.224.0/assert/assert_object_match.js

@@ -1,91 +0,0 @@
-"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 assert_equals_js_1 = require("./assert_equals.js");
-/**
- * Make an assertion that `actual` object is a subset of `expected` object,
- * deeply. If not, then throw.
- *
- * @example
- * ```ts
- * import { assertObjectMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_object_match.ts";
- *
- * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
- * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
- * ```
- */
-function assertObjectMatch(
-// deno-lint-ignore no-explicit-any
-actual, expected, msg) {
-    function filter(a, b) {
-        const seen = new WeakMap();
-        return fn(a, b);
-        function fn(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}`}`);
-                }
-                else
-                    throw err;
-            }
-            // Filter keys and symbols which are present in both actual and expected
-            const filtered = {};
-            const entries = [
-                ...Object.getOwnPropertyNames(a),
-                ...Object.getOwnPropertySymbols(a),
-            ]
-                .filter((key) => key in b)
-                .map((key) => [key, a[key]]);
-            for (const [key, value] of entries) {
-                // On array references, build a filtered array and filter nested objects inside
-                if (Array.isArray(value)) {
-                    const subset = b[key];
-                    if (Array.isArray(subset)) {
-                        filtered[key] = fn({ ...value }, { ...subset });
-                        continue;
-                    }
-                } // On regexp references, keep value as it to avoid loosing pattern and flags
-                else if (value instanceof RegExp) {
-                    filtered[key] = value;
-                    continue;
-                } // On nested objects references, build a filtered object recursively
-                else if (typeof value === "object" && value !== null) {
-                    const subset = b[key];
-                    if ((typeof subset === "object") && 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]) => [k, typeof v === "object" ? fn(v, subset.get(k)) : v]));
-                            continue;
-                        }
-                        // When both operands are set, build a filtered set with common values
-                        if ((value instanceof Set) && (subset instanceof Set)) {
-                            filtered[key] = new Set([...value].filter((v) => subset.has(v)));
-                            continue;
-                        }
-                        filtered[key] = fn(value, subset);
-                        continue;
-                    }
-                }
-                filtered[key] = value;
-            }
-            return filtered;
-        }
-    }
-    return (0, assert_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;

package/script/deps/deno.land/std@0.224.0/assert/assert_rejects.d.ts

@@ -1,31 +0,0 @@
-/**
- * Executes a function which returns a promise, expecting it to reject.
- *
- * To assert that a synchronous function throws, use {@linkcode assertThrows}.
- *
- * @example
- * ```ts
- * import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts";
- *
- * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
- * await assertRejects(async () => console.log("Hello world")); // Throws
- * ```
- */
-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
- * ```ts
- * import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts";
- *
- * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
- * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
- * ```
- */
-export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;
-//# sourceMappingURL=assert_rejects.d.ts.map

package/script/deps/deno.land/std@0.224.0/assert/assert_rejects.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert_rejects.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/assert/assert_rejects.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,WAAW,CAAC,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAAC;AACpB;;;;;;;;;;;;;;GAcG;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/deno.land/std@0.224.0/assert/assert_rejects.js

@@ -1,55 +0,0 @@
-"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 assert_is_error_js_1 = require("./assert_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;
-        }
-    }
-    catch (error) {
-        if (!isPromiseReturned) {
-            throw new assertion_error_js_1.AssertionError(`Function throws when expected to reject${msgSuffix}`);
-        }
-        if (ErrorClass) {
-            if (error instanceof Error === false) {
-                throw new assertion_error_js_1.AssertionError(`A non-Error object was rejected${msgSuffix}`);
-            }
-            (0, assert_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/deno.land/std@0.224.0/assert/assert_strict_equals.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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/script/deps/deno.land/std@0.224.0/assert/assert_strict_equals.d.ts.map

@@ -1 +0,0 @@
-{"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/script/deps/deno.land/std@0.224.0/assert/assert_strict_equals.js

@@ -1,59 +0,0 @@
-"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 mod_js_1 = require("../internal/mod.js");
-const assertion_error_js_1 = require("./assertion_error.js");
-const _constants_js_1 = require("./_constants.js");
-const colors_js_1 = require("../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
- * ```
- */
-function assertStrictEquals(actual, expected, msg) {
-    if (Object.is(actual, expected)) {
-        return;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    let message;
-    const actualString = (0, mod_js_1.format)(actual);
-    const expectedString = (0, mod_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, colors_js_1.red)(withOffset)}\n`;
-    }
-    else {
-        try {
-            const stringDiff = (typeof actual === "string") &&
-                (typeof expected === "string");
-            const diffResult = stringDiff
-                ? (0, mod_js_1.diffstr)(actual, expected)
-                : (0, mod_js_1.diff)(actualString.split("\n"), expectedString.split("\n"));
-            const diffMsg = (0, mod_js_1.buildMessage)(diffResult, { stringDiff }).join("\n");
-            message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
-        }
-        catch {
-            message = `\n${(0, colors_js_1.red)(_constants_js_1.CAN_NOT_DISPLAY)} + \n\n`;
-        }
-    }
-    throw new assertion_error_js_1.AssertionError(message);
-}
-exports.assertStrictEquals = assertStrictEquals;

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

@@ -1,14 +0,0 @@
-/**
- * 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/script/deps/deno.land/std@0.224.0/assert/assert_string_includes.d.ts.map

@@ -1 +0,0 @@
-{"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/script/deps/deno.land/std@0.224.0/assert/assert_string_includes.js

@@ -1,26 +0,0 @@
-"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
- * ```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
- * ```
- */
-function assertStringIncludes(actual, expected, msg) {
-    if (!actual.includes(expected)) {
-        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/deno.land/std@0.224.0/assert/assert_throws.d.ts

@@ -1,34 +0,0 @@
-/**
- * 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/script/deps/deno.land/std@0.224.0/assert/assert_throws.d.ts.map

@@ -1 +0,0 @@
-{"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/script/deps/deno.land/std@0.224.0/assert/assert_throws.js

@@ -1,49 +0,0 @@
-"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 assert_is_error_js_1 = require("./assert_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, assert_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/deno.land/std@0.224.0/assert/assertion_error.d.ts

@@ -1,15 +0,0 @@
-/**
- * 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/script/deps/deno.land/std@0.224.0/assert/assertion_error.d.ts.map

@@ -1 +0,0 @@
-{"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/script/deps/deno.land/std@0.224.0/assert/assertion_error.js

@@ -1,23 +0,0 @@
-"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
- * ```ts
- * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
- *
- * throw new AssertionError("Assertion failed");
- * ```
- */
-class AssertionError extends Error {
-    /** Constructs a new instance. */
-    constructor(message) {
-        super(message);
-        this.name = "AssertionError";
-    }
-}
-exports.AssertionError = AssertionError;