@mtkruto/node 0.1.124 → 0.1.126

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

@@ -3,6 +3,14 @@ import { AssertionError } from "./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
+ * ```
  */
 export function assertNotMatch(actual, expected, msg) {
     if (expected.test(actual)) {

package/{script/deps/deno.land/std@0.208.0 → esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_strict_equals.js

@@ -5,10 +5,12 @@ import { format } from "./_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
  * ```
  */
 export function assertNotStrictEquals(actual, expected, msg) {

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_object_match.js

@@ -1,8 +1,16 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 import { assertEquals } from "./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
+ * ```
  */
 export function assertObjectMatch(
 // deno-lint-ignore no-explicit-any

package/esm/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/{script/deps/deno.land/std@0.208.0 → esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_strict_equals.js

@@ -12,18 +12,13 @@ import { red } from "../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
  * ```
  */
 export function assertStrictEquals(actual, expected, msg) {

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_string_includes.js

@@ -3,6 +3,14 @@ import { AssertionError } from "./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
+ * ```
  */
 export function assertStringIncludes(actual, expected, msg) {
     if (!actual.includes(expected)) {

package/esm/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/esm/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/esm/deps/deno.land/std@0.209.0/assert/assertion_error.js

@@ -0,0 +1,18 @@
+// 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");
+ * ```
+ */
+export class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message) {
+        super(message);
+        this.name = "AssertionError";
+    }
+}

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/equal.js

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

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/fail.js

@@ -1,7 +1,14 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 import { assert } from "./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
+ * ```
  */
 export function fail(msg) {
     const msgSuffix = msg ? `: ${msg}` : ".";

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/unimplemented.js

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

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/unreachable.js

@@ -1,6 +1,15 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 import { AssertionError } from "./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
+ * ```
+ */
 export function unreachable() {
     throw new AssertionError("unreachable");
 }

package/esm/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;

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/encoding/base64.js

@@ -2,28 +2,12 @@
 // This module is browser compatible.
 import { validateBinaryLike } from "./_util.js";
 /**
- * {@linkcode encodeBase64} and {@linkcode decodeBase64} for
- * [base64](https://en.wikipedia.org/wiki/Base64) encoding.
+ * Utilities for
+ * [base64]{@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ * encoding and decoding.
  *
  * This module is browser compatible.
  *
- * @example
- * ```ts
- * import {
- *   decodeBase64,
- *   encodeBase64,
- * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
- *
- * const b64Repr = "Zm9vYg==";
- *
- * const binaryData = decodeBase64(b64Repr);
- * console.log(binaryData);
- * // => Uint8Array [ 102, 111, 111, 98 ]
- *
- * console.log(encodeBase64(binaryData));
- * // => Zm9vYg==
- * ```
- *
  * @module
  */
 const base64abc = [
@@ -93,22 +77,29 @@ const base64abc = [
     "/",
 ];
 /**
- * @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 const encode = 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 const decode = 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 function encodeBase64(data) {
     // CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
@@ -137,7 +128,16 @@ export function encodeBase64(data) {
     return result;
 }
 /**
- * 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 function decodeBase64(b64) {
     const binString = atob(b64);