@mtkruto/browser 0.6.0 → 0.119.0

package/script/deps/jsr.io/@std/internal/1.0.12/build_message.js

@@ -0,0 +1,121 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createColor = createColor;
+exports.createSign = createSign;
+exports.buildMessage = buildMessage;
+const styles_js_1 = require("./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"));
+ * ```
+ */
+function createColor(diffType, 
+/**
+ * TODO(@littledivy): Remove this when we can detect true color terminals. See
+ * https://github.com/denoland/std/issues/2575.
+ */
+background = false) {
+    switch (diffType) {
+        case "added":
+            return (s) => background ? (0, styles_js_1.bgGreen)((0, styles_js_1.white)(s)) : (0, styles_js_1.green)((0, styles_js_1.bold)(s));
+        case "removed":
+            return (s) => background ? (0, styles_js_1.bgRed)((0, styles_js_1.white)(s)) : (0, styles_js_1.red)((0, styles_js_1.bold)(s));
+        case "truncation":
+            return styles_js_1.gray;
+        default:
+            return styles_js_1.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"), "    ");
+ * ```
+ */
+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.
+ * @param truncateDiff Function to truncate the diff (default is no truncation).
+ *
+ * @returns An array of strings representing the built message.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { diffStr, buildMessage } from "@std/internal";
+ *
+ * diffStr("Hello, world!", "Hello, world");
+ * // [
+ * //   "",
+ * //   "",
+ * //   "    [Diff] Actual / Expected",
+ * //   "",
+ * //   "",
+ * //   "-   Hello, world!",
+ * //   "+   Hello, world",
+ * //   "",
+ * // ]
+ * ```
+ */
+function buildMessage(diffResult, options = {}, truncateDiff) {
+    if (truncateDiff != null) {
+        diffResult = truncateDiff(diffResult, options.stringDiff ?? false);
+    }
+    const { stringDiff = false } = options;
+    const messages = [
+        "",
+        "",
+        `    ${(0, styles_js_1.gray)((0, styles_js_1.bold)("[Diff]"))} ${(0, styles_js_1.red)((0, styles_js_1.bold)("Actual"))} / ${(0, styles_js_1.green)((0, styles_js_1.bold)("Expected"))}`,
+        "",
+        "",
+    ];
+    const diffMessages = diffResult.map((result) => {
+        const color = createColor(result.type);
+        const line = result.type === "added" || result.type === "removed"
+            ? result.details?.map((detail) => detail.type !== "common"
+                ? createColor(detail.type, true)(detail.value)
+                : detail.value).join("") ?? result.value
+            : result.value;
+        return color(`${createSign(result.type)}${line}`);
+    });
+    messages.push(...(stringDiff ? [diffMessages.join("")] : diffMessages), "");
+    return messages;
+}

package/script/deps/jsr.io/@std/internal/1.0.12/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/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"}

package/script/deps/jsr.io/@std/internal/1.0.12/diff.js

@@ -0,0 +1,283 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommon = createCommon;
+exports.assertFp = assertFp;
+exports.backTrace = backTrace;
+exports.createFp = createFp;
+exports.diff = diff;
+const REMOVED = 1;
+const COMMON = 2;
+const ADDED = 3;
+/**
+ * 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]);
+ * ```
+ */
+function createCommon(A, B) {
+    const common = [];
+    if (A.length === 0 || B.length === 0)
+        return [];
+    for (let i = 0; i < Math.min(A.length, B.length); i += 1) {
+        const a = A[i];
+        const b = B[i];
+        if (a !== undefined && a === b) {
+            common.push(a);
+        }
+        else {
+            return common;
+        }
+    }
+    return common;
+}
+/**
+ * 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));
+ * ```
+ */
+function assertFp(value) {
+    if (value == null ||
+        typeof value !== "object" ||
+        typeof value?.y !== "number" ||
+        typeof value?.id !== "number") {
+        throw new Error(`Unexpected value, expected 'FarthestPoint': received ${typeof value}`);
+    }
+}
+/**
+ * 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),
+ *   [],
+ * );
+ * ```
+ */
+function backTrace(A, B, current, swapped, routes, diffTypesPtrOffset) {
+    const M = A.length;
+    const N = B.length;
+    const result = [];
+    let a = M - 1;
+    let b = N - 1;
+    let j = routes[current.id];
+    let type = routes[current.id + diffTypesPtrOffset];
+    while (true) {
+        if (!j && !type)
+            break;
+        const prev = j;
+        if (type === REMOVED) {
+            result.unshift({
+                type: swapped ? "removed" : "added",
+                value: B[b],
+            });
+            b -= 1;
+        }
+        else if (type === ADDED) {
+            result.unshift({
+                type: swapped ? "added" : "removed",
+                value: A[a],
+            });
+            a -= 1;
+        }
+        else {
+            result.unshift({ type: "common", value: A[a] });
+            a -= 1;
+            b -= 1;
+        }
+        j = routes[prev];
+        type = routes[prev + diffTypesPtrOffset];
+    }
+    return result;
+}
+/**
+ * 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 },
+ * );
+ * ```
+ */
+function createFp(k, M, routes, diffTypesPtrOffset, ptr, slide, down) {
+    if (slide && slide.y === -1 && down && down.y === -1) {
+        return { y: 0, id: 0 };
+    }
+    const isAdding = (down?.y === -1) ||
+        k === M ||
+        (slide?.y ?? 0) > (down?.y ?? 0) + 1;
+    if (slide && isAdding) {
+        const prev = slide.id;
+        ptr++;
+        routes[ptr] = prev;
+        routes[ptr + diffTypesPtrOffset] = ADDED;
+        return { y: slide.y, id: ptr };
+    }
+    if (down && !isAdding) {
+        const prev = down.id;
+        ptr++;
+        routes[ptr] = prev;
+        routes[ptr + diffTypesPtrOffset] = REMOVED;
+        return { y: down.y + 1, id: ptr };
+    }
+    throw new Error("Unexpected missing 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 },
+ * ]);
+ * ```
+ */
+function diff(A, B) {
+    const prefixCommon = createCommon(A, B);
+    A = A.slice(prefixCommon.length);
+    B = B.slice(prefixCommon.length);
+    const swapped = B.length > A.length;
+    [A, B] = swapped ? [B, A] : [A, B];
+    const M = A.length;
+    const N = B.length;
+    if (!M && !N && !prefixCommon.length)
+        return [];
+    if (!N) {
+        return [
+            ...prefixCommon.map((value) => ({ type: "common", value })),
+            ...A.map((value) => ({ type: swapped ? "added" : "removed", value })),
+        ];
+    }
+    const offset = N;
+    const delta = M - N;
+    const length = M + N + 1;
+    const fp = Array.from({ length }, () => ({ y: -1, id: -1 }));
+    /**
+     * Note: this buffer is used to save memory and improve performance. The first
+     * half is used to save route and the last half is used to save diff type.
+     */
+    const routes = new Uint32Array((M * N + length + 1) * 2);
+    const diffTypesPtrOffset = routes.length / 2;
+    let ptr = 0;
+    function snake(k, A, B, slide, down) {
+        const M = A.length;
+        const N = B.length;
+        const fp = createFp(k, M, routes, diffTypesPtrOffset, ptr, slide, down);
+        ptr = fp.id;
+        while (fp.y + k < M && fp.y < N && A[fp.y + k] === B[fp.y]) {
+            const prev = fp.id;
+            ptr++;
+            fp.id = ptr;
+            fp.y += 1;
+            routes[ptr] = prev;
+            routes[ptr + diffTypesPtrOffset] = COMMON;
+        }
+        return fp;
+    }
+    let currentFp = fp[delta + offset];
+    assertFp(currentFp);
+    let p = -1;
+    while (currentFp.y < N) {
+        p = p + 1;
+        for (let k = -p; k < delta; ++k) {
+            const index = k + offset;
+            fp[index] = snake(k, A, B, fp[index - 1], fp[index + 1]);
+        }
+        for (let k = delta + p; k > delta; --k) {
+            const index = k + offset;
+            fp[index] = snake(k, A, B, fp[index - 1], fp[index + 1]);
+        }
+        const index = delta + offset;
+        fp[delta + offset] = snake(delta, A, B, fp[index - 1], fp[index + 1]);
+        currentFp = fp[delta + offset];
+        assertFp(currentFp);
+    }
+    return [
+        ...prefixCommon.map((value) => ({ type: "common", value })),
+        ...backTrace(A, B, currentFp, swapped, routes, diffTypesPtrOffset),
+    ];
+}

package/script/deps/jsr.io/@std/internal/1.0.12/diff_str.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff_str.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/diff_str.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,YAAY,CAAC;AAGhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAY/C;AAKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,MAAM,EAAE,CAiBnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,EACxB,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,GAC3B,UAAU,CAAC,MAAM,CAAC,EAAE,CAetB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,EAAE,CAkDlE"}

package/script/deps/jsr.io/@std/internal/1.0.12/diff_str.js

@@ -0,0 +1,188 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unescape = unescape;
+exports.tokenize = tokenize;
+exports.createDetails = createDetails;
+exports.diffStr = diffStr;
+const diff_js_1 = require("./diff.js");
+/**
+ * Unescape invisible characters.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#escape_sequences}
+ *
+ * @param string String to unescape.
+ *
+ * @returns Unescaped string.
+ *
+ * @example Usage
+ * ```ts
+ * import { unescape } from "@std/internal/diff-str";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(unescape("Hello\nWorld"), "Hello\\n\nWorld");
+ * ```
+ */
+function unescape(string) {
+    return string
+        .replaceAll("\\", "\\\\")
+        .replaceAll("\b", "\\b")
+        .replaceAll("\f", "\\f")
+        .replaceAll("\t", "\\t")
+        .replaceAll("\v", "\\v")
+        // This does not remove line breaks
+        .replaceAll(/\r\n|\r|\n/g, (str) => str === "\r" ? "\\r" : str === "\n" ? "\\n\n" : "\\r\\n\r\n");
+}
+const WHITESPACE_SYMBOLS = /((?:\\[bftv]|[^\S\r\n])+|\\[rn\\]|[()[\]{}'"\r\n]|\b)/;
+/**
+ * Tokenizes a string into an array of tokens.
+ *
+ * @param string The string to tokenize.
+ * @param wordDiff If true, performs word-based tokenization. Default is false.
+ *
+ * @returns An array of tokens.
+ *
+ * @example Usage
+ * ```ts
+ * import { tokenize } from "@std/internal/diff-str";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(tokenize("Hello\nWorld"), ["Hello\n", "World"]);
+ * ```
+ */
+function tokenize(string, wordDiff = false) {
+    if (wordDiff) {
+        return string
+            .split(WHITESPACE_SYMBOLS)
+            .filter((token) => token);
+    }
+    const tokens = [];
+    const lines = string.split(/(\n|\r\n)/).filter((line) => line);
+    for (const [i, line] of lines.entries()) {
+        if (i % 2) {
+            tokens[tokens.length - 1] += line;
+        }
+        else {
+            tokens.push(line);
+        }
+    }
+    return tokens;
+}
+/**
+ * Create details by filtering relevant word-diff for current line and merge
+ * "space-diff" if surrounded by word-diff for cleaner displays.
+ *
+ * @param line Current line
+ * @param tokens Word-diff tokens
+ *
+ * @returns Array of diff results.
+ *
+ * @example Usage
+ * ```ts
+ * import { createDetails } from "@std/internal/diff-str";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const tokens = [
+ *   { type: "added", value: "a" },
+ *   { type: "removed", value: "b" },
+ *   { type: "common", value: "c" },
+ * ] as const;
+ * assertEquals(
+ *   createDetails({ type: "added", value: "a" }, [...tokens]),
+ *   [{ type: "added", value: "a" }, { type: "common", value: "c" }]
+ * );
+ * ```
+ */
+function createDetails(line, tokens) {
+    return tokens.filter(({ type }) => type === line.type || type === "common")
+        .map((result, i, t) => {
+        const token = t[i - 1];
+        if ((result.type === "common") && token &&
+            (token.type === t[i + 1]?.type) && /\s+/.test(result.value)) {
+            return {
+                ...result,
+                type: token.type,
+            };
+        }
+        return result;
+    });
+}
+const NON_WHITESPACE_REGEXP = /\S/;
+/**
+ * Renders the differences between the actual and expected strings. Partially
+ * inspired from {@link https://github.com/kpdecker/jsdiff}.
+ *
+ * @param A Actual string
+ * @param B Expected string
+ *
+ * @returns Array of diff results.
+ *
+ * @example Usage
+ * ```ts
+ * import { diffStr } from "@std/internal/diff-str";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(diffStr("Hello!", "Hello"), [
+ *   {
+ *     type: "removed",
+ *     value: "Hello!\n",
+ *     details: [
+ *       { type: "common", value: "Hello" },
+ *       { type: "removed", value: "!" },
+ *       { type: "common", value: "\n" }
+ *     ]
+ *   },
+ *   {
+ *     type: "added",
+ *     value: "Hello\n",
+ *     details: [
+ *       { type: "common", value: "Hello" },
+ *       { type: "common", value: "\n" }
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+function diffStr(A, B) {
+    // Compute multi-line diff
+    const diffResult = (0, diff_js_1.diff)(tokenize(`${unescape(A)}\n`), tokenize(`${unescape(B)}\n`));
+    const added = [];
+    const removed = [];
+    for (const result of diffResult) {
+        if (result.type === "added") {
+            added.push(result);
+        }
+        if (result.type === "removed") {
+            removed.push(result);
+        }
+    }
+    // Compute word-diff
+    const hasMoreRemovedLines = added.length < removed.length;
+    const aLines = hasMoreRemovedLines ? added : removed;
+    const bLines = hasMoreRemovedLines ? removed : added;
+    for (const a of aLines) {
+        let tokens = [];
+        let b;
+        // Search another diff line with at least one common token
+        while (bLines.length) {
+            b = bLines.shift();
+            const tokenized = [
+                tokenize(a.value, true),
+                tokenize(b.value, true),
+            ];
+            if (hasMoreRemovedLines)
+                tokenized.reverse();
+            tokens = (0, diff_js_1.diff)(tokenized[0], tokenized[1]);
+            if (tokens.some(({ type, value }) => type === "common" && NON_WHITESPACE_REGEXP.test(value))) {
+                break;
+            }
+        }
+        // Register word-diff details
+        a.details = createDetails(a, tokens);
+        if (b) {
+            b.details = createDetails(b, tokens);
+        }
+    }
+    return diffResult;
+}

package/script/deps/jsr.io/@std/internal/1.0.12/format.d.ts

@@ -0,0 +1,29 @@
+export type InspectFn = (v: unknown, options: {
+    depth: number;
+    sorted: boolean;
+    trailingComma: boolean;
+    compact: boolean;
+    iterableLimit: number;
+    getters: boolean;
+    strAbbreviateSize: number;
+}) => string;
+/**
+ * Converts the input into a string. Objects, Sets and Maps are sorted so as to
+ * make tests less flaky.
+ *
+ * @param v Value to be formatted
+ *
+ * @returns The formatted string
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/internal/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(format({ a: 1, b: 2 }), "{\n  a: 1,\n  b: 2,\n}");
+ * assertEquals(format(new Set([1, 2])), "Set(2) {\n  1,\n  2,\n}");
+ * assertEquals(format(new Map([[1, 2]])), "Map(1) {\n  1 => 2,\n}");
+ * ```
+ */
+export declare function format(v: unknown): string;
+//# sourceMappingURL=format.d.ts.map

package/script/deps/jsr.io/@std/internal/1.0.12/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/format.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,SAAS,GAAG,CACtB,CAAC,EAAE,OAAO,EACV,OAAO,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,KACE,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAmBzC"}