@mtkruto/node 0.2.43 → 0.2.45

package/esm/deps/jsr.io/@std/encoding/1.0.5/base64.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param data The data to encode.
+ * @returns The base64-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase64("foobar"), "Zm9vYmFy");
+ * ```
+ */
+export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): string;
+/**
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param b64 The base64-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase64("Zm9vYmFy"),
+ *   new TextEncoder().encode("foobar")
+ * );
+ * ```
+ */
+export declare function decodeBase64(b64: string): Uint8Array;
+//# sourceMappingURL=base64.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.5/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.5/base64.ts"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAmC5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQpD"}

package/esm/deps/jsr.io/@std/encoding/1.0.5/base64.js

@@ -0,0 +1,163 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Utilities for
+ * {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4 | base64}
+ * encoding and decoding.
+ *
+ * ```ts
+ * import {
+ *   encodeBase64,
+ *   decodeBase64,
+ * } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const foobar = new TextEncoder().encode("foobar");
+ *
+ * assertEquals(encodeBase64(foobar), "Zm9vYmFy");
+ * assertEquals(decodeBase64("Zm9vYmFy"), foobar);
+ * ```
+ *
+ * @module
+ */
+import { validateBinaryLike } from "./_validate_binary_like.js";
+const base64abc = [
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "+",
+    "/",
+];
+/**
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param data The data to encode.
+ * @returns The base64-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase64("foobar"), "Zm9vYmFy");
+ * ```
+ */
+export function encodeBase64(data) {
+    // CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+    const uint8 = validateBinaryLike(data);
+    let result = "";
+    let i;
+    const l = uint8.length;
+    for (i = 2; i < l; i += 3) {
+        result += base64abc[(uint8[i - 2]) >> 2];
+        result += base64abc[(((uint8[i - 2]) & 0x03) << 4) |
+            ((uint8[i - 1]) >> 4)];
+        result += base64abc[(((uint8[i - 1]) & 0x0f) << 2) |
+            ((uint8[i]) >> 6)];
+        result += base64abc[(uint8[i]) & 0x3f];
+    }
+    if (i === l + 1) {
+        // 1 octet yet to write
+        result += base64abc[(uint8[i - 2]) >> 2];
+        result += base64abc[((uint8[i - 2]) & 0x03) << 4];
+        result += "==";
+    }
+    if (i === l) {
+        // 2 octets yet to write
+        result += base64abc[(uint8[i - 2]) >> 2];
+        result += base64abc[(((uint8[i - 2]) & 0x03) << 4) |
+            ((uint8[i - 1]) >> 4)];
+        result += base64abc[((uint8[i - 1]) & 0x0f) << 2];
+        result += "=";
+    }
+    return result;
+}
+/**
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param b64 The base64-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase64("Zm9vYmFy"),
+ *   new TextEncoder().encode("foobar")
+ * );
+ * ```
+ */
+export function decodeBase64(b64) {
+    const binString = atob(b64);
+    const size = binString.length;
+    const bytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        bytes[i] = binString.charCodeAt(i);
+    }
+    return bytes;
+}

package/esm/deps/jsr.io/@std/internal/1.0.3/build_message.d.ts

@@ -0,0 +1,82 @@
+import type { DiffResult, DiffType } from "./types.js";
+/**
+ * Colors the output of assertion diffs.
+ *
+ * @param diffType Difference type, either added or removed.
+ * @param background If true, colors the background instead of the text.
+ *
+ * @returns A function that colors the input string.
+ *
+ * @example Usage
+ * ```ts
+ * import { createColor } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ * import { bold, green, red, white } from "@std/fmt/colors";
+ *
+ * assertEquals(createColor("added")("foo"), green(bold("foo")));
+ * assertEquals(createColor("removed")("foo"), red(bold("foo")));
+ * assertEquals(createColor("common")("foo"), white("foo"));
+ * ```
+ */
+export declare function createColor(diffType: DiffType, 
+/**
+ * TODO(@littledivy): Remove this when we can detect true color terminals. See
+ * https://github.com/denoland/deno_std/issues/2575.
+ */
+background?: boolean): (s: string) => string;
+/**
+ * Prefixes `+` or `-` in diff output.
+ *
+ * @param diffType Difference type, either added or removed
+ *
+ * @returns A string representing the sign.
+ *
+ * @example Usage
+ * ```ts
+ * import { createSign } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(createSign("added"), "+   ");
+ * assertEquals(createSign("removed"), "-   ");
+ * assertEquals(createSign("common"), "    ");
+ * ```
+ */
+export declare function createSign(diffType: DiffType): string;
+/** Options for {@linkcode buildMessage}. */
+export interface BuildMessageOptions {
+    /**
+     * Whether to output the diff as a single string.
+     *
+     * @default {false}
+     */
+    stringDiff?: boolean;
+}
+/**
+ * Builds a message based on the provided diff result.
+ *
+ * @param diffResult The diff result array.
+ * @param options Optional parameters for customizing the message.
+ *
+ * @returns An array of strings representing the built message.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { diffStr, buildMessage } from "@std/internal";
+ *
+ * const diffResult = diffStr("Hello, world!", "Hello, world");
+ *
+ * console.log(buildMessage(diffResult));
+ * // [
+ * //   "",
+ * //   "",
+ * //   "    [Diff] Actual / Expected",
+ * //   "",
+ * //   "",
+ * //   "-   Hello, world!",
+ * //   "+   Hello, world",
+ * //   "",
+ * // ]
+ * ```
+ */
+export declare function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>, options?: BuildMessageOptions): string[];
+//# sourceMappingURL=build_message.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.3/build_message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_message.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.3/build_message.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ;AAClB;;;GAGG;AACH,UAAU,UAAQ,GACjB,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CASvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CASrD;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,OAAO,GAAE,mBAAwB,GAChC,MAAM,EAAE,CAsBV"}

package/esm/deps/jsr.io/@std/internal/1.0.3/build_message.js

@@ -0,0 +1,110 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { bgGreen, bgRed, bold, gray, green, red, white } from "./styles.js";
+/**
+ * Colors the output of assertion diffs.
+ *
+ * @param diffType Difference type, either added or removed.
+ * @param background If true, colors the background instead of the text.
+ *
+ * @returns A function that colors the input string.
+ *
+ * @example Usage
+ * ```ts
+ * import { createColor } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ * import { bold, green, red, white } from "@std/fmt/colors";
+ *
+ * assertEquals(createColor("added")("foo"), green(bold("foo")));
+ * assertEquals(createColor("removed")("foo"), red(bold("foo")));
+ * assertEquals(createColor("common")("foo"), white("foo"));
+ * ```
+ */
+export function createColor(diffType, 
+/**
+ * TODO(@littledivy): Remove this when we can detect true color terminals. See
+ * https://github.com/denoland/deno_std/issues/2575.
+ */
+background = false) {
+    switch (diffType) {
+        case "added":
+            return (s) => background ? bgGreen(white(s)) : green(bold(s));
+        case "removed":
+            return (s) => background ? bgRed(white(s)) : red(bold(s));
+        default:
+            return white;
+    }
+}
+/**
+ * Prefixes `+` or `-` in diff output.
+ *
+ * @param diffType Difference type, either added or removed
+ *
+ * @returns A string representing the sign.
+ *
+ * @example Usage
+ * ```ts
+ * import { createSign } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(createSign("added"), "+   ");
+ * assertEquals(createSign("removed"), "-   ");
+ * assertEquals(createSign("common"), "    ");
+ * ```
+ */
+export function createSign(diffType) {
+    switch (diffType) {
+        case "added":
+            return "+   ";
+        case "removed":
+            return "-   ";
+        default:
+            return "    ";
+    }
+}
+/**
+ * Builds a message based on the provided diff result.
+ *
+ * @param diffResult The diff result array.
+ * @param options Optional parameters for customizing the message.
+ *
+ * @returns An array of strings representing the built message.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { diffStr, buildMessage } from "@std/internal";
+ *
+ * const diffResult = diffStr("Hello, world!", "Hello, world");
+ *
+ * console.log(buildMessage(diffResult));
+ * // [
+ * //   "",
+ * //   "",
+ * //   "    [Diff] Actual / Expected",
+ * //   "",
+ * //   "",
+ * //   "-   Hello, world!",
+ * //   "+   Hello, world",
+ * //   "",
+ * // ]
+ * ```
+ */
+export function buildMessage(diffResult, options = {}) {
+    const { stringDiff = false } = options;
+    const messages = [
+        "",
+        "",
+        `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${green(bold("Expected"))}`,
+        "",
+        "",
+    ];
+    const diffMessages = diffResult.map((result) => {
+        const color = createColor(result.type);
+        const line = result.details?.map((detail) => detail.type !== "common"
+            ? createColor(detail.type, true)(detail.value)
+            : detail.value).join("") ?? result.value;
+        return color(`${createSign(result.type)}${line}`);
+    });
+    messages.push(...(stringDiff ? [diffMessages.join("")] : diffMessages), "");
+    return messages;
+}

package/esm/deps/jsr.io/@std/internal/1.0.3/diff.d.ts

@@ -0,0 +1,140 @@
+import type { DiffResult, DiffType } from "./types.js";
+/** Represents the farthest point in the diff algorithm. */
+export interface FarthestPoint {
+    /** The y-coordinate of the point. */
+    y: number;
+    /** The id of the point. */
+    id: number;
+}
+/**
+ * Creates an array of common elements between two arrays.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A The first array.
+ * @param B The second array.
+ *
+ * @returns An array containing the common elements between the two arrays.
+ *
+ * @example Usage
+ * ```ts
+ * import { createCommon } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = [1, 2, 3];
+ * const b = [1, 2, 4];
+ *
+ * assertEquals(createCommon(a, b), [1, 2]);
+ * ```
+ */
+export declare function createCommon<T>(A: T[], B: T[]): T[];
+/**
+ * Asserts that the value is a {@linkcode FarthestPoint}.
+ * If not, an error is thrown.
+ *
+ * @param value The value to check.
+ *
+ * @returns A void value that returns once the assertion completes.
+ *
+ * @example Usage
+ * ```ts
+ * import { assertFp } from "@std/internal/diff";
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertFp({ y: 0, id: 0 });
+ * assertThrows(() => assertFp({ id: 0 }));
+ * assertThrows(() => assertFp({ y: 0 }));
+ * assertThrows(() => assertFp(undefined));
+ * ```
+ */
+export declare function assertFp(value: unknown): asserts value is FarthestPoint;
+/**
+ * Creates an array of backtraced differences.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A The first array.
+ * @param B The second array.
+ * @param current The current {@linkcode FarthestPoint}.
+ * @param swapped Boolean indicating if the arrays are swapped.
+ * @param routes The routes array.
+ * @param diffTypesPtrOffset The offset of the diff types in the routes array.
+ *
+ * @returns An array of backtraced differences.
+ *
+ * @example Usage
+ * ```ts
+ * import { backTrace } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   backTrace([], [], { y: 0, id: 0 }, false, new Uint32Array(0), 0),
+ *   [],
+ * );
+ * ```
+ */
+export declare function backTrace<T>(A: T[], B: T[], current: FarthestPoint, swapped: boolean, routes: Uint32Array, diffTypesPtrOffset: number): Array<{
+    type: DiffType;
+    value: T;
+}>;
+/**
+ * Creates a {@linkcode FarthestPoint}.
+ *
+ * @param k The current index.
+ * @param M The length of the first array.
+ * @param routes The routes array.
+ * @param diffTypesPtrOffset The offset of the diff types in the routes array.
+ * @param ptr The current pointer.
+ * @param slide The slide {@linkcode FarthestPoint}.
+ * @param down The down {@linkcode FarthestPoint}.
+ *
+ * @returns A {@linkcode FarthestPoint}.
+ *
+ * @example Usage
+ * ```ts
+ * import { createFp } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   createFp(
+ *     0,
+ *     0,
+ *     new Uint32Array(0),
+ *     0,
+ *     0,
+ *     { y: -1, id: 0 },
+ *     { y: 0, id: 0 },
+ *   ),
+ *   { y: -1, id: 1 },
+ * );
+ * ```
+ */
+export declare function createFp(k: number, M: number, routes: Uint32Array, diffTypesPtrOffset: number, ptr: number, slide?: FarthestPoint, down?: FarthestPoint): FarthestPoint;
+/**
+ * Renders the differences between the actual and expected values.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A Actual value
+ * @param B Expected value
+ *
+ * @returns An array of differences between the actual and expected values.
+ *
+ * @example Usage
+ * ```ts
+ * import { diff } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = [1, 2, 3];
+ * const b = [1, 2, 4];
+ *
+ * assertEquals(diff(a, b), [
+ *   { type: "common", value: 1 },
+ *   { type: "common", value: 2 },
+ *   { type: "removed", value: 3 },
+ *   { type: "added", value: 4 },
+ * ]);
+ * ```
+ */
+export declare function diff<T>(A: T[], B: T[]): DiffResult<T>[];
+//# sourceMappingURL=diff.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.3/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.3/diff.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;CACZ;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAanD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAWvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,CAAC,EAAE,EACN,CAAC,EAAE,CAAC,EAAE,EACN,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,GACzB,KAAK,CAAC;IACP,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAgCD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,aAAa,GACnB,aAAa,CAsBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAwEvD"}