track-cli 4.0.3-rc1 → 4.1.0-rc1

package/esm/_dnt.shims.d.ts

@@ -5,7 +5,7 @@ import { fetch, File, FormData, Headers, Request, Response } from "undici";
 export { fetch, File, FormData, Headers, Request, Response, type BodyInit, type HeadersInit, type RequestInit, type ResponseInit } from "undici";
 import { alert, confirm, prompt } from "./shim/prompts.js";
 export { alert, confirm, prompt } from "./shim/prompts.js";
-export declare const dntGlobalThis: Omit<typeof globalThis, "fetch" | "Request" | "Response" | "FormData" | "Headers" | "File" | "crypto" | "Deno" | "alert" | "confirm" | "prompt"> & {
+export declare const dntGlobalThis: Omit<typeof globalThis, "fetch" | "FormData" | "Headers" | "Request" | "Response" | "File" | "crypto" | "Deno" | "alert" | "confirm" | "prompt"> & {
     Deno: typeof Deno;
     crypto: import("@deno/shim-crypto").Crypto;
     fetch: typeof fetch;

package/esm/_dnt.test_shims.d.ts

@@ -0,0 +1,20 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
+import { fetch, File, FormData, Headers, Request, Response } from "undici";
+export { fetch, File, FormData, Headers, Request, Response, type BodyInit, type HeadersInit, type RequestInit, type ResponseInit } from "undici";
+import { alert, confirm, prompt } from "./shim/prompts.js";
+export { alert, confirm, prompt } from "./shim/prompts.js";
+export declare const dntGlobalThis: Omit<typeof globalThis, "fetch" | "FormData" | "Headers" | "Request" | "Response" | "File" | "crypto" | "Deno" | "alert" | "confirm" | "prompt"> & {
+    Deno: typeof Deno;
+    crypto: import("@deno/shim-crypto").Crypto;
+    fetch: typeof fetch;
+    File: typeof File;
+    FormData: typeof FormData;
+    Headers: typeof Headers;
+    Request: typeof Request;
+    Response: typeof Response;
+    alert: typeof alert;
+    confirm: typeof confirm;
+    prompt: typeof prompt;
+};

package/esm/_dnt.test_shims.js

@@ -0,0 +1,77 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+import { crypto } from "@deno/shim-crypto";
+export { crypto } from "@deno/shim-crypto";
+import { fetch, File, FormData, Headers, Request, Response } from "undici";
+export { fetch, File, FormData, Headers, Request, Response } from "undici";
+import { alert, confirm, prompt } from "./shim/prompts.js";
+export { alert, confirm, prompt } from "./shim/prompts.js";
+const dntGlobals = {
+    Deno,
+    crypto,
+    fetch,
+    File,
+    FormData,
+    Headers,
+    Request,
+    Response,
+    alert,
+    confirm,
+    prompt,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/deps/deno.land/std@0.195.0/_util/diff.d.ts

@@ -0,0 +1,26 @@
+export declare enum DiffType {
+    removed = "removed",
+    common = "common",
+    added = "added"
+}
+export interface DiffResult<T> {
+    type: DiffType;
+    value: T;
+    details?: Array<DiffResult<T>>;
+}
+/**
+ * Renders the differences between the actual and expected values
+ * @param A Actual value
+ * @param B Expected value
+ */
+export declare function diff<T>(A: T[], B: T[]): Array<DiffResult<T>>;
+/**
+ * Renders the differences between the actual and expected strings
+ * Partially inspired from https://github.com/kpdecker/jsdiff
+ * @param A Actual string
+ * @param B Expected string
+ */
+export declare function diffstr(A: string, B: string): DiffResult<string>[];
+export declare function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>, { stringDiff }?: {
+    stringDiff?: boolean | undefined;
+}): string[];

package/esm/deps/deno.land/std@0.195.0/_util/diff.js

@@ -0,0 +1,311 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { bgGreen, bgRed, bold, gray, green, red, white, } from "../fmt/colors.js";
+export var DiffType;
+(function (DiffType) {
+    DiffType["removed"] = "removed";
+    DiffType["common"] = "common";
+    DiffType["added"] = "added";
+})(DiffType || (DiffType = {}));
+const REMOVED = 1;
+const COMMON = 2;
+const ADDED = 3;
+function createCommon(A, B, reverse) {
+    const common = [];
+    if (A.length === 0 || B.length === 0)
+        return [];
+    for (let i = 0; i < Math.min(A.length, B.length); i += 1) {
+        if (A[reverse ? A.length - i - 1 : i] === B[reverse ? B.length - i - 1 : i]) {
+            common.push(A[reverse ? A.length - i - 1 : i]);
+        }
+        else {
+            return common;
+        }
+    }
+    return common;
+}
+/**
+ * Renders the differences between the actual and expected values
+ * @param A Actual value
+ * @param B Expected value
+ */
+export function diff(A, B) {
+    const prefixCommon = createCommon(A, B);
+    const suffixCommon = createCommon(A.slice(prefixCommon.length), B.slice(prefixCommon.length), true).reverse();
+    A = suffixCommon.length
+        ? A.slice(prefixCommon.length, -suffixCommon.length)
+        : A.slice(prefixCommon.length);
+    B = suffixCommon.length
+        ? B.slice(prefixCommon.length, -suffixCommon.length)
+        : 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 && !suffixCommon.length && !prefixCommon.length)
+        return [];
+    if (!N) {
+        return [
+            ...prefixCommon.map((c) => ({ type: DiffType.common, value: c })),
+            ...A.map((a) => ({
+                type: swapped ? DiffType.added : DiffType.removed,
+                value: a,
+            })),
+            ...suffixCommon.map((c) => ({ type: DiffType.common, value: c })),
+        ];
+    }
+    const offset = N;
+    const delta = M - N;
+    const size = M + N + 1;
+    const fp = Array.from({ length: size }, () => ({ y: -1, id: -1 }));
+    /**
+     * INFO:
+     * This buffer is used to save memory and improve performance.
+     * The first half is used to save route and last half is used to save diff
+     * type.
+     * This is because, when I kept new uint8array area to save type,performance
+     * worsened.
+     */
+    const routes = new Uint32Array((M * N + size + 1) * 2);
+    const diffTypesPtrOffset = routes.length / 2;
+    let ptr = 0;
+    let p = -1;
+    function backTrace(A, B, current, swapped) {
+        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 ? DiffType.removed : DiffType.added,
+                    value: B[b],
+                });
+                b -= 1;
+            }
+            else if (type === ADDED) {
+                result.unshift({
+                    type: swapped ? DiffType.added : DiffType.removed,
+                    value: A[a],
+                });
+                a -= 1;
+            }
+            else {
+                result.unshift({ type: DiffType.common, value: A[a] });
+                a -= 1;
+                b -= 1;
+            }
+            j = routes[prev];
+            type = routes[prev + diffTypesPtrOffset];
+        }
+        return result;
+    }
+    function createFP(slide, down, k, M) {
+        if (slide && slide.y === -1 && down && down.y === -1) {
+            return { y: 0, id: 0 };
+        }
+        if ((down && down.y === -1) ||
+            k === M ||
+            (slide && slide.y) > (down && down.y) + 1) {
+            const prev = slide.id;
+            ptr++;
+            routes[ptr] = prev;
+            routes[ptr + diffTypesPtrOffset] = ADDED;
+            return { y: slide.y, id: ptr };
+        }
+        else {
+            const prev = down.id;
+            ptr++;
+            routes[ptr] = prev;
+            routes[ptr + diffTypesPtrOffset] = REMOVED;
+            return { y: down.y + 1, id: ptr };
+        }
+    }
+    function snake(k, slide, down, _offset, A, B) {
+        const M = A.length;
+        const N = B.length;
+        if (k < -N || M < k)
+            return { y: -1, id: -1 };
+        const fp = createFP(slide, down, k, M);
+        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;
+    }
+    while (fp[delta + offset].y < N) {
+        p = p + 1;
+        for (let k = -p; k < delta; ++k) {
+            fp[k + offset] = snake(k, fp[k - 1 + offset], fp[k + 1 + offset], offset, A, B);
+        }
+        for (let k = delta + p; k > delta; --k) {
+            fp[k + offset] = snake(k, fp[k - 1 + offset], fp[k + 1 + offset], offset, A, B);
+        }
+        fp[delta + offset] = snake(delta, fp[delta - 1 + offset], fp[delta + 1 + offset], offset, A, B);
+    }
+    return [
+        ...prefixCommon.map((c) => ({ type: DiffType.common, value: c })),
+        ...backTrace(A, B, fp[delta + offset], swapped),
+        ...suffixCommon.map((c) => ({ type: DiffType.common, value: c })),
+    ];
+}
+/**
+ * Renders the differences between the actual and expected strings
+ * Partially inspired from https://github.com/kpdecker/jsdiff
+ * @param A Actual string
+ * @param B Expected string
+ */
+export function diffstr(A, B) {
+    function unescape(string) {
+        // unescape invisible characters.
+        // ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#escape_sequences
+        return string
+            .replaceAll("\b", "\\b")
+            .replaceAll("\f", "\\f")
+            .replaceAll("\t", "\\t")
+            .replaceAll("\v", "\\v")
+            .replaceAll(// does not remove line breaks
+        /\r\n|\r|\n/g, (str) => str === "\r" ? "\\r" : str === "\n" ? "\\n\n" : "\\r\\n\r\n");
+    }
+    function tokenize(string, { wordDiff = false } = {}) {
+        if (wordDiff) {
+            // Split string on whitespace symbols
+            const tokens = string.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
+            // Extended Latin character set
+            const words = /^[a-zA-Z\u{C0}-\u{FF}\u{D8}-\u{F6}\u{F8}-\u{2C6}\u{2C8}-\u{2D7}\u{2DE}-\u{2FF}\u{1E00}-\u{1EFF}]+$/u;
+            // Join boundary splits that we do not consider to be boundaries and merge empty strings surrounded by word chars
+            for (let i = 0; i < tokens.length - 1; i++) {
+                if (!tokens[i + 1] && tokens[i + 2] && words.test(tokens[i]) &&
+                    words.test(tokens[i + 2])) {
+                    tokens[i] += tokens[i + 2];
+                    tokens.splice(i + 1, 2);
+                    i--;
+                }
+            }
+            return tokens.filter((token) => token);
+        }
+        else {
+            // Split string on new lines symbols
+            const tokens = [], lines = string.split(/(\n|\r\n)/);
+            // Ignore final empty token when text ends with a newline
+            if (!lines[lines.length - 1]) {
+                lines.pop();
+            }
+            // Merge the content and line separators into single tokens
+            for (let i = 0; i < lines.length; i++) {
+                if (i % 2) {
+                    tokens[tokens.length - 1] += lines[i];
+                }
+                else {
+                    tokens.push(lines[i]);
+                }
+            }
+            return tokens;
+        }
+    }
+    // Create details by filtering relevant word-diff for current line
+    // and merge "space-diff" if surrounded by word-diff for cleaner displays
+    function createDetails(line, tokens) {
+        return tokens.filter(({ type }) => type === line.type || type === DiffType.common).map((result, i, t) => {
+            if ((result.type === DiffType.common) && (t[i - 1]) &&
+                (t[i - 1]?.type === t[i + 1]?.type) && /\s+/.test(result.value)) {
+                return {
+                    ...result,
+                    type: t[i - 1].type,
+                };
+            }
+            return result;
+        });
+    }
+    // Compute multi-line diff
+    const diffResult = diff(tokenize(`${unescape(A)}\n`), tokenize(`${unescape(B)}\n`));
+    const added = [], removed = [];
+    for (const result of diffResult) {
+        if (result.type === DiffType.added) {
+            added.push(result);
+        }
+        if (result.type === DiffType.removed) {
+            removed.push(result);
+        }
+    }
+    // Compute word-diff
+    const aLines = added.length < removed.length ? added : removed;
+    const bLines = aLines === removed ? added : removed;
+    for (const a of aLines) {
+        let tokens = [], b;
+        // Search another diff line with at least one common token
+        while (bLines.length) {
+            b = bLines.shift();
+            tokens = diff(tokenize(a.value, { wordDiff: true }), tokenize(b?.value ?? "", { wordDiff: true }));
+            if (tokens.some(({ type, value }) => type === DiffType.common && value.trim().length)) {
+                break;
+            }
+        }
+        // Register word-diff details
+        a.details = createDetails(a, tokens);
+        if (b) {
+            b.details = createDetails(b, tokens);
+        }
+    }
+    return diffResult;
+}
+/**
+ * Colors the output of assertion diffs
+ * @param diffType Difference type, either added or removed
+ */
+function createColor(diffType, { background = false } = {}) {
+    // TODO(@littledivy): Remove this when we can detect
+    // true color terminals.
+    // https://github.com/denoland/deno_std/issues/2575
+    background = false;
+    switch (diffType) {
+        case DiffType.added:
+            return (s) => background ? bgGreen(white(s)) : green(bold(s));
+        case DiffType.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
+ */
+function createSign(diffType) {
+    switch (diffType) {
+        case DiffType.added:
+            return "+   ";
+        case DiffType.removed:
+            return "-   ";
+        default:
+            return "    ";
+    }
+}
+export function buildMessage(diffResult, { stringDiff = false } = {}) {
+    const messages = [], diffMessages = [];
+    messages.push("");
+    messages.push("");
+    messages.push(`    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${green(bold("Expected"))}`);
+    messages.push("");
+    messages.push("");
+    diffResult.forEach((result) => {
+        const c = createColor(result.type);
+        const line = result.details?.map((detail) => detail.type !== DiffType.common
+            ? createColor(detail.type, { background: true })(detail.value)
+            : detail.value).join("") ?? result.value;
+        diffMessages.push(c(`${createSign(result.type)}${line}`));
+    });
+    messages.push(...(stringDiff ? [diffMessages.join("")] : diffMessages));
+    messages.push("");
+    return messages;
+}

package/esm/deps/deno.land/std@0.195.0/assert/_constants.d.ts

@@ -0,0 +1 @@
+export declare const CAN_NOT_DISPLAY = "[Cannot display]";

package/esm/deps/deno.land/std@0.195.0/assert/_constants.js

@@ -0,0 +1,2 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export const CAN_NOT_DISPLAY = "[Cannot display]";

package/esm/deps/deno.land/std@0.195.0/assert/_format.d.ts

@@ -0,0 +1 @@
+export declare function format(v: unknown): string;

package/esm/deps/deno.land/std@0.195.0/assert/_format.js

@@ -0,0 +1,23 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * 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
+ */
+import * as dntShim from "../../../../_dnt.test_shims.js";
+export function format(v) {
+    // deno-lint-ignore no-explicit-any
+    const { Deno } = dntShim.dntGlobalThis;
+    return typeof Deno?.inspect === "function"
+        ? Deno.inspect(v, {
+            depth: Infinity,
+            sorted: true,
+            trailingComma: true,
+            compact: false,
+            iterableLimit: Infinity,
+            // getters should be true in assertEquals.
+            getters: true,
+        })
+        : `"${String(v).replace(/(?=["\\])/g, "\\")}"`;
+}

package/esm/deps/deno.land/std@0.195.0/assert/assert_almost_equals.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers through
+ * a given tolerance. It can be used to take into account IEEE-754 double-precision
+ * floating-point representation limitations.
+ * If the values are not almost equal then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertAlmostEquals, assertThrows } from "https://deno.land/std@$STD_VERSION/assert/mod.ts";
+ *
+ * assertAlmostEquals(0.1, 0.2);
+ *
+ * // Using a custom tolerance value
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16);
+ * assertThrows(() => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17));
+ * ```
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;

package/esm/deps/deno.land/std@0.195.0/assert/assert_almost_equals.js

@@ -0,0 +1,32 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers through
+ * a given tolerance. It can be used to take into account IEEE-754 double-precision
+ * floating-point representation limitations.
+ * If the values are not almost equal then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertAlmostEquals, assertThrows } from "https://deno.land/std@$STD_VERSION/assert/mod.ts";
+ *
+ * assertAlmostEquals(0.1, 0.2);
+ *
+ * // Using a custom tolerance value
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16);
+ * assertThrows(() => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17));
+ * ```
+ */
+export function assertAlmostEquals(actual, expected, tolerance = 1e-7, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const delta = Math.abs(expected - actual);
+    if (delta <= tolerance) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const f = (n) => Number.isInteger(n) ? n : n.toExponential();
+    throw new AssertionError(`Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
+delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`);
+}

package/esm/deps/deno.land/std@0.195.0/assert/assert_array_includes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Make an assertion that `actual` includes the `expected` values.
+ * If not then an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertArrayIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_array_includes.ts";
+ *
+ * assertArrayIncludes<number>([1, 2], [2])
+ * ```
+ */
+export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;

package/esm/deps/deno.land/std@0.195.0/assert/assert_array_includes.js

@@ -0,0 +1,38 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { equal } from "./equal.js";
+import { format } from "./_format.js";
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that `actual` includes the `expected` values.
+ * If not then an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertArrayIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_array_includes.ts";
+ *
+ * assertArrayIncludes<number>([1, 2], [2])
+ * ```
+ */
+export function assertArrayIncludes(actual, expected, msg) {
+    const missing = [];
+    for (let i = 0; i < expected.length; i++) {
+        let found = false;
+        for (let j = 0; j < actual.length; j++) {
+            if (equal(expected[i], actual[j])) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            missing.push(expected[i]);
+        }
+    }
+    if (missing.length === 0) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${format(actual)}" to include: "${format(expected)}"${msgSuffix}\nmissing: ${format(missing)}`;
+    throw new AssertionError(msg);
+}

package/esm/deps/deno.land/std@0.195.0/assert/assert_equals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Make an assertion that `actual` and `expected` are equal, deeply. If not
+ * deeply equal, then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * Deno.test("example", function (): void {
+ *   assertEquals("world", "world");
+ *   assertEquals({ hello: "world" }, { hello: "world" });
+ * });
+ * ```
+ */
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;

package/esm/deps/deno.land/std@0.195.0/assert/assert_equals.js

@@ -0,0 +1,45 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { equal } from "./equal.js";
+import { format } from "./_format.js";
+import { AssertionError } from "./assertion_error.js";
+import { red } from "../fmt/colors.js";
+import { buildMessage, diff, diffstr } from "../_util/diff.js";
+import { CAN_NOT_DISPLAY } from "./_constants.js";
+/**
+ * Make an assertion that `actual` and `expected` are equal, deeply. If not
+ * deeply equal, then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * Deno.test("example", function (): void {
+ *   assertEquals("world", "world");
+ *   assertEquals({ hello: "world" }, { hello: "world" });
+ * });
+ * ```
+ */
+export function assertEquals(actual, expected, msg) {
+    if (equal(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message = `Values are not equal${msgSuffix}`;
+    const actualString = format(actual);
+    const expectedString = format(expected);
+    try {
+        const stringDiff = (typeof actual === "string") &&
+            (typeof expected === "string");
+        const diffResult = stringDiff
+            ? diffstr(actual, expected)
+            : diff(actualString.split("\n"), expectedString.split("\n"));
+        const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
+        message = `${message}\n${diffMsg}`;
+    }
+    catch {
+        message = `${message}\n${red(CAN_NOT_DISPLAY)} + \n\n`;
+    }
+    throw new AssertionError(message);
+}

package/esm/deps/deno.land/std@0.195.0/assert/assert_exists.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;

package/esm/deps/deno.land/std@0.195.0/assert/assert_exists.js

@@ -0,0 +1,14 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+export function assertExists(actual, msg) {
+    if (actual === undefined || actual === null) {
+        const msgSuffix = msg ? `: ${msg}` : ".";
+        msg =
+            `Expected actual: "${actual}" to not be null or undefined${msgSuffix}`;
+        throw new AssertionError(msg);
+    }
+}