veryfront 0.1.324 → 0.1.326

package/esm/deps/jsr.io/@std/internal/1.0.13/assertion_state.js

@@ -0,0 +1,224 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Check the test suite internal state
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionState } from "@std/internal";
+ *
+ * const assertionState = new AssertionState();
+ * ```
+ */
+import * as dntShim from "../../../../../_dnt.shims.js";
+export class AssertionState {
+    #state;
+    constructor() {
+        this.#state = {
+            assertionCount: undefined,
+            assertionCheck: false,
+            assertionTriggered: false,
+            assertionTriggeredCount: 0,
+        };
+        if (typeof globalThis?.addEventListener === "function") {
+            globalThis.addEventListener("unload", () => {
+                this.#ensureCleanedUp();
+            });
+        }
+        else if (
+        // deno-lint-ignore no-explicit-any
+        typeof dntShim.dntGlobalThis?.process?.on === "function") {
+            // deno-lint-ignore no-explicit-any
+            dntShim.dntGlobalThis.process.on("exit", () => {
+                this.#ensureCleanedUp();
+            });
+        }
+        else {
+            // deno-lint-ignore no-console
+            console.warn("AssertionCounter cleanup step was not registered");
+        }
+    }
+    #ensureCleanedUp() {
+        // If any checks were registered, after the test suite runs the checks,
+        // `resetAssertionState` should also have been called. If it was not,
+        // then the test suite did not run the checks.
+        if (this.#state.assertionCheck ||
+            this.#state.assertionCount !== undefined) {
+            throw new Error("AssertionCounter was not cleaned up: If tests are not otherwise failing, ensure `expect.hasAssertion` and `expect.assertions` are only run in bdd tests");
+        }
+    }
+    /**
+     * Get the number that through `expect.assertions` api set.
+     *
+     * @returns the number that through `expect.assertions` api set.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionCount;
+     * ```
+     */
+    get assertionCount() {
+        return this.#state.assertionCount;
+    }
+    /**
+     * Get a certain number that assertions were called before.
+     *
+     * @returns return a certain number that assertions were called before.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionTriggeredCount;
+     * ```
+     */
+    get assertionTriggeredCount() {
+        return this.#state.assertionTriggeredCount;
+    }
+    /**
+     * If `expect.hasAssertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param val Set #state.assertionCheck's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCheck(true);
+     * ```
+     */
+    setAssertionCheck(val) {
+        this.#state.assertionCheck = val;
+    }
+    /**
+     * If any matchers was called, `#state.assertionTriggered` will be set through this method.
+     *
+     * @param val Set #state.assertionTriggered's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionTriggered(true);
+     * ```
+     */
+    setAssertionTriggered(val) {
+        this.#state.assertionTriggered = val;
+    }
+    /**
+     * If `expect.assertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param num Set #state.assertionCount's value, for example if the value is set 2, that means
+     * you must have two assertion matchers call in your test suite.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCount(2);
+     * ```
+     */
+    setAssertionCount(num) {
+        this.#state.assertionCount = num;
+    }
+    /**
+     * If any matchers was called, `#state.assertionTriggeredCount` value will plus one internally.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.updateAssertionTriggerCount();
+     * ```
+     */
+    updateAssertionTriggerCount() {
+        if (this.#state.assertionCount !== undefined) {
+            this.#state.assertionTriggeredCount += 1;
+        }
+    }
+    /**
+     * Check Assertion internal state, if `#state.assertionCheck` is set true, but
+     * `#state.assertionTriggered` is still false, then should throw an Assertion Error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionErrorState()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionErrorState() {
+        return this.#state.assertionCheck && !this.#state.assertionTriggered;
+    }
+    /**
+     * Reset all assertion state when every test suite function ran completely.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.resetAssertionState();
+     * ```
+     */
+    resetAssertionState() {
+        this.#state = {
+            assertionCount: undefined,
+            assertionCheck: false,
+            assertionTriggered: false,
+            assertionTriggeredCount: 0,
+        };
+    }
+    /**
+     * Check Assertion called state, if `#state.assertionCount` is set to a number value, but
+     * `#state.assertionTriggeredCount` is less then it, then should throw an assertion error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionCountSatisfied()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionCountSatisfied() {
+        return this.#state.assertionCount !== undefined &&
+            this.#state.assertionCount !== this.#state.assertionTriggeredCount;
+    }
+}
+const assertionState = new AssertionState();
+/**
+ * return an instance of AssertionState
+ *
+ * @returns AssertionState
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { getAssertionState } from "@std/internal";
+ *
+ * const assertionState = getAssertionState();
+ * assertionState.setAssertionTriggered(true);
+ * ```
+ */
+export function getAssertionState() {
+    return assertionState;
+}

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

@@ -0,0 +1,80 @@
+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/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.
+ * @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",
+ * //   "",
+ * // ]
+ * ```
+ */
+export declare function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>, options?: BuildMessageOptions, truncateDiff?: (diffResult: ReadonlyArray<DiffResult<string>>, stringDiff: boolean, contextLength?: number | null) => ReadonlyArray<DiffResult<string>>): string[];
+//# sourceMappingURL=build_message.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.13/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.13/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,CAWvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CASrD;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,OAAO,GAAE,mBAAwB,EACjC,YAAY,CAAC,EAAE,CACb,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,UAAU,EAAE,OAAO,EACnB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,KAC1B,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,GACrC,MAAM,EAAE,CA8BV"}

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

@@ -0,0 +1,116 @@
+// Copyright 2018-2026 the Deno authors. 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/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));
+        case "truncation":
+            return gray;
+        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.
+ * @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",
+ * //   "",
+ * // ]
+ * ```
+ */
+export function buildMessage(diffResult, options = {}, truncateDiff) {
+    if (truncateDiff != null) {
+        diffResult = truncateDiff(diffResult, options.stringDiff ?? false);
+    }
+    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.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/esm/deps/jsr.io/@std/internal/1.0.13/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.13/diff.d.ts.map

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