@mtkruto/node 0.1.124 → 0.1.126

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_less_or_equal.js

@@ -7,6 +7,15 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that `actual` is less than or equal to `expected`.
  * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertLessOrEqual } from "https://deno.land/std@$STD_VERSION/assert/assert_less_or_equal.ts";
+ *
+ * assertLessOrEqual(1, 2); // Doesn't throw
+ * assertLessOrEqual(1, 1); // Doesn't throw
+ * assertLessOrEqual(1, 0); // Throws
+ * ```
  */
 function assertLessOrEqual(actual, expected, msg) {
     if (actual <= expected)

package/script/deps/deno.land/std@0.209.0/assert/assert_match.d.ts

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

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_match.js

@@ -6,6 +6,14 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that `actual` match RegExp `expected`. If not
  * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_match.ts";
+ *
+ * assertMatch("Raptor", RegExp(/Raptor/)); // Doesn't throw
+ * assertMatch("Denosaurus", RegExp(/Raptor/)); // Throws
+ * ```
  */
 function assertMatch(actual, expected, msg) {
     if (!expected.test(actual)) {

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_equals.d.ts

@@ -8,7 +8,8 @@
  * ```ts
  * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
  *
- * assertNotEquals<number>(1, 2)
+ * assertNotEquals(1, 2); // Doesn't throw
+ * assertNotEquals(1, 1); // Throws
  * ```
  */
 export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_equals.js

@@ -14,7 +14,8 @@ const assertion_error_js_1 = require("./assertion_error.js");
  * ```ts
  * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
  *
- * assertNotEquals<number>(1, 2)
+ * assertNotEquals(1, 2); // Doesn't throw
+ * assertNotEquals(1, 1); // Throws
  * ```
  */
 function assertNotEquals(actual, expected, msg) {

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

@@ -0,0 +1,13 @@
+/**
+ * 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>;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_instance_of.js

@@ -6,6 +6,14 @@ 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

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_match.js

@@ -6,6 +6,14 @@ 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)) {

package/{esm/deps/deno.land/std@0.208.0 → script/deps/deno.land/std@0.209.0}/assert/assert_not_strict_equals.d.ts

@@ -2,10 +2,12 @@
  * 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)
+ * assertNotStrictEquals(1, 1); // Doesn't throw
+ * assertNotStrictEquals(1, 2); // Throws
  * ```
  */
 export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_strict_equals.js

@@ -8,10 +8,12 @@ const _format_js_1 = require("./_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)
+ * assertNotStrictEquals(1, 1); // Doesn't throw
+ * assertNotStrictEquals(1, 2); // Throws
  * ```
  */
 function assertNotStrictEquals(actual, expected, msg) {

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_object_match.js

@@ -4,8 +4,16 @@ exports.assertObjectMatch = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 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.
+ * 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

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

@@ -0,0 +1,26 @@
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ *
+ * @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.
+ *
+ * @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>;

package/{esm/deps/deno.land/std@0.208.0 → script/deps/deno.land/std@0.209.0}/assert/assert_strict_equals.d.ts

@@ -6,18 +6,13 @@
  * ```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);
- * });
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
  *
- * // This test fails
- * Deno.test("isNotStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = {};
- *   assertStrictEquals(a, b);
- * });
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
  * ```
  */
 export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_strict_equals.js

@@ -15,18 +15,13 @@ const colors_js_1 = require("../fmt/colors.js");
  * ```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);
- * });
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
  *
- * // This test fails
- * Deno.test("isNotStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = {};
- *   assertStrictEquals(a, b);
- * });
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
  * ```
  */
 function assertStrictEquals(actual, expected, msg) {

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_string_includes.js

@@ -6,6 +6,14 @@ 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)) {

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_throws.d.ts

@@ -6,18 +6,8 @@
  * ```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");
- *   });
- * });
+ * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
+ * assertThrows(() => console.log("hello world!")); // Throws
  * ```
  */
 export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
@@ -30,25 +20,8 @@ export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
  * ```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");
- *   });
- * });
+ * 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;

package/script/deps/deno.land/std@0.209.0/assert/assertion_error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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);
+}

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assertion_error.js

@@ -1,16 +1,22 @@
 "use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssertionError = void 0;
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * 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);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "AssertionError"
-        });
+        this.name = "AssertionError";
     }
 }
 exports.AssertionError = AssertionError;

package/script/deps/deno.land/std@0.209.0/assert/equal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/equal.js

@@ -14,6 +14,14 @@ function constructorsEqual(a, b) {
  * 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
+ * ```
  */
 function equal(c, d) {
     const seen = new Map();

package/script/deps/deno.land/std@0.209.0/assert/fail.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/fail.js

@@ -4,7 +4,14 @@ 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
+ * Forcefully throws a failed assertion.
+ *
+ * @example
+ * ```ts
+ * import { fail } from "https://deno.land/std@$STD_VERSION/assert/fail.ts";
+ *
+ * fail("Deliberately failed!"); // Throws
+ * ```
  */
 function fail(msg) {
     const msgSuffix = msg ? `: ${msg}` : ".";

package/script/deps/deno.land/std@0.209.0/assert/unimplemented.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/unimplemented.js

@@ -3,7 +3,16 @@ 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. */
+/**
+ * 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
+ * ```
+ */
 function unimplemented(msg) {
     const msgSuffix = msg ? `: ${msg}` : ".";
     throw new assertion_error_js_1.AssertionError(`Unimplemented${msgSuffix}`);

package/script/deps/deno.land/std@0.209.0/assert/unreachable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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(): never;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/unreachable.js

@@ -3,7 +3,16 @@ 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. */
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example
+ * ```ts
+ * import { unreachable } from "https://deno.land/std@$STD_VERSION/assert/unreachable.ts";
+ *
+ * unreachable(); // Throws
+ * ```
+ */
 function unreachable() {
     throw new assertion_error_js_1.AssertionError("unreachable");
 }

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/encoding/base64.d.ts

@@ -1,23 +1,39 @@
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
- *
  * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
  * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
- * @param data
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
  */
 export declare const encode: typeof encodeBase64;
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
- *
  * Decodes a given RFC4648 base64 encoded string
- * @param b64
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
  */
 export declare const decode: typeof decodeBase64;
 /**
- * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): string;
 /**
- * Decodes a given RFC4648 base64 encoded string
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 export declare function decodeBase64(b64: string): Uint8Array;