@mtkruto/node 0.0.971 → 0.0.972

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertThrows = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+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.196.0/assert/assertion_error.d.ts

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

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

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

package/script/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/script/deps/deno.land/std@0.196.0/assert/equal.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equal = void 0;
+// 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
+ */
+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);
+}
+exports.equal = equal;

package/script/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/script/deps/deno.land/std@0.196.0/assert/fail.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fail = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const assert_js_1 = require("./assert.js");
+/**
+ * Forcefully throws a failed assertion
+ */
+function fail(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    (0, assert_js_1.assert)(false, `Failed assertion${msgSuffix}`);
+}
+exports.fail = fail;

package/script/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/script/deps/deno.land/std@0.196.0/assert/mod.js

@@ -0,0 +1,49 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** 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
+ */
+__exportStar(require("./assert_almost_equals.js"), exports);
+__exportStar(require("./assert_array_includes.js"), exports);
+__exportStar(require("./assert_equals.js"), exports);
+__exportStar(require("./assert_exists.js"), exports);
+__exportStar(require("./assert_false.js"), exports);
+__exportStar(require("./assert_instance_of.js"), exports);
+__exportStar(require("./assert_is_error.js"), exports);
+__exportStar(require("./assert_match.js"), exports);
+__exportStar(require("./assert_not_equals.js"), exports);
+__exportStar(require("./assert_not_instance_of.js"), exports);
+__exportStar(require("./assert_not_match.js"), exports);
+__exportStar(require("./assert_not_strict_equals.js"), exports);
+__exportStar(require("./assert_object_match.js"), exports);
+__exportStar(require("./assert_rejects.js"), exports);
+__exportStar(require("./assert_strict_equals.js"), exports);
+__exportStar(require("./assert_string_includes.js"), exports);
+__exportStar(require("./assert_throws.js"), exports);
+__exportStar(require("./assert.js"), exports);
+__exportStar(require("./assertion_error.js"), exports);
+__exportStar(require("./equal.js"), exports);
+__exportStar(require("./fail.js"), exports);
+__exportStar(require("./unimplemented.js"), exports);
+__exportStar(require("./unreachable.js"), exports);

package/script/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/script/deps/deno.land/std@0.196.0/assert/unimplemented.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unimplemented = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const assertion_error_js_1 = require("./assertion_error.js");
+/** Use this to stub out methods that will throw when invoked. */
+function unimplemented(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new assertion_error_js_1.AssertionError(`Unimplemented${msgSuffix}`);
+}
+exports.unimplemented = unimplemented;

package/script/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/script/deps/deno.land/std@0.196.0/assert/unreachable.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unreachable = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const assertion_error_js_1 = require("./assertion_error.js");
+/** Use this to assert unreachable code. */
+function unreachable() {
+    throw new assertion_error_js_1.AssertionError("unreachable");
+}
+exports.unreachable = unreachable;

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

@@ -79,14 +79,14 @@ const dntShim = __importStar(require("../../../../_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
  */
 function setColorEnabled(value) {
-    if (noColor) {
+    if (Deno?.noColor) {
         return;
     }
     enabled = value;