@mtkruto/node 0.0.971 → 0.0.973

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

@@ -0,0 +1,50 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+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.196.0/assert/assert_strict_equals.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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";
+ *
+ * Deno.test("isStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = a;
+ *   assertStrictEquals(a, b);
+ * });
+ *
+ * // This test fails
+ * Deno.test("isNotStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = {};
+ *   assertStrictEquals(a, b);
+ * });
+ * ```
+ */
+export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;

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

@@ -0,0 +1,60 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { format } from "./_format.js";
+import { AssertionError } from "./assertion_error.js";
+import { buildMessage, diff, diffstr } from "../_util/diff.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";
+ *
+ * Deno.test("isStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = a;
+ *   assertStrictEquals(a, b);
+ * });
+ *
+ * // This test fails
+ * Deno.test("isNotStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = {};
+ *   assertStrictEquals(a, b);
+ * });
+ * ```
+ */
+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.196.0/assert/assert_string_includes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;

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

@@ -0,0 +1,13 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ */
+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.196.0/assert/assert_throws.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws.
+ *
+ * @example
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/assert/assert_throws.ts";
+ *
+ * Deno.test("doesThrow", function (): void {
+ *   assertThrows((): void => {
+ *     throw new TypeError("hello world!");
+ *   });
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", function (): void {
+ *   assertThrows((): void => {
+ *     console.log("Hello world");
+ *   });
+ * });
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/assert/assert_throws.ts";
+ *
+ * Deno.test("doesThrow", function (): void {
+ *   assertThrows((): void => {
+ *     throw new TypeError("hello world!");
+ *   }, TypeError);
+ *   assertThrows(
+ *     (): void => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *     TypeError,
+ *     "hello",
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", function (): void {
+ *   assertThrows((): void => {
+ *     console.log("Hello world");
+ *   });
+ * });
+ * ```
+ */
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;

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

@@ -0,0 +1,44 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+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.196.0/assert/assertion_error.d.ts

@@ -0,0 +1,4 @@
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}

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

@@ -0,0 +1,12 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export class AssertionError extends Error {
+    constructor(message) {
+        super(message);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AssertionError"
+        });
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ */
+export declare function equal(c: unknown, d: unknown): boolean;

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

@@ -0,0 +1,102 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+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
+ */
+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.196.0/assert/fail.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Forcefully throws a failed assertion
+ */
+export declare function fail(msg?: string): never;

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

@@ -0,0 +1,9 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { assert } from "./assert.js";
+/**
+ * Forcefully throws a failed assertion
+ */
+export function fail(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    assert(false, `Failed assertion${msgSuffix}`);
+}

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

@@ -0,0 +1,32 @@
+/** 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.
+ *
+ * @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_instance_of.js";
+export * from "./assert_is_error.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.196.0/assert/mod.js

@@ -0,0 +1,33 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/** 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.
+ *
+ * @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_instance_of.js";
+export * from "./assert_is_error.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.196.0/assert/unimplemented.d.ts

@@ -0,0 +1,2 @@
+/** Use this to stub out methods that will throw when invoked. */
+export declare function unimplemented(msg?: string): never;

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

@@ -0,0 +1,7 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/** Use this to stub out methods that will throw when invoked. */
+export function unimplemented(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Unimplemented${msgSuffix}`);
+}

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

@@ -0,0 +1,2 @@
+/** Use this to assert unreachable code. */
+export declare function unreachable(): never;

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

@@ -0,0 +1,6 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/** Use this to assert unreachable code. */
+export function unreachable() {
+    throw new AssertionError("unreachable");
+}

package/esm/deps/deno.land/{std@0.190.0 → std@0.196.0}/fmt/colors.js

@@ -53,14 +53,14 @@ import * as dntShim from "../../../../_dnt.shims.js";
 const { Deno } = dntShim.dntGlobalThis;
 const noColor = typeof Deno?.noColor === "boolean"
     ? Deno.noColor
-    : true;
+    : false;
 let enabled = !noColor;
 /**
  * Set changing text color to enabled or disabled
  * @param value
  */
 export function setColorEnabled(value) {
-    if (noColor) {
+    if (Deno?.noColor) {
         return;
     }
     enabled = value;