@goast/typescript 0.4.0-beta4 → 0.4.0

package/esm/deps/jsr.io/@std/expect/1.0.5/fn.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Creates a mock function that can be used for testing and assertions.
+ *
+ * @param stubs Functions to be used as stubs for different calls.
+ * @returns A mock function that keeps track of calls and returns values based on the provided stubs.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { fn, expect } from "@std/expect";
+ *
+ * Deno.test("example", () => {
+ *   const mockFn = fn(
+ *     (a: number, b: number) => a + b,
+ *     (a: number, b: number) => a - b
+ *   );
+ *   const result = mockFn(1, 2);
+ *   expect(result).toEqual(3);
+ *   expect(mockFn).toHaveBeenCalledWith(1, 2);
+ *   expect(mockFn).toHaveBeenCalledTimes(1);
+ *
+ *   const result2 = mockFn(3, 2);
+ *   expect(result2).toEqual(1);
+ *   expect(mockFn).toHaveBeenCalledWith(3, 2);
+ *   expect(mockFn).toHaveBeenCalledTimes(2);
+ * });
+ * ```
+ */
+export declare function fn(...stubs: Function[]): Function;
+//# sourceMappingURL=fn.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.5/fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.5/fn.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,EAAE,CAAC,GAAG,KAAK,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAsCjD"}

package/esm/deps/jsr.io/@std/expect/1.0.5/fn.js

@@ -0,0 +1,85 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+// Copyright 2019 Allain Lalonde. All rights reserved. ISC License.
+// deno-lint-ignore-file no-explicit-any ban-types
+/**
+ * This module contains a function to mock functions for testing and assertions.
+ *
+ * ```ts
+ * import { fn, expect } from "@std/expect";
+ *
+ * Deno.test("example", () => {
+ *   const mockFn = fn((a: number, b: number) => a + b);
+ *   const result = mockFn(1, 2);
+ *   expect(result).toEqual(3);
+ *   expect(mockFn).toHaveBeenCalledWith(1, 2);
+ *   expect(mockFn).toHaveBeenCalledTimes(1);
+ * });
+ * ```
+ *
+ * @module
+ */
+import { MOCK_SYMBOL } from "./_mock_util.js";
+/**
+ * Creates a mock function that can be used for testing and assertions.
+ *
+ * @param stubs Functions to be used as stubs for different calls.
+ * @returns A mock function that keeps track of calls and returns values based on the provided stubs.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { fn, expect } from "@std/expect";
+ *
+ * Deno.test("example", () => {
+ *   const mockFn = fn(
+ *     (a: number, b: number) => a + b,
+ *     (a: number, b: number) => a - b
+ *   );
+ *   const result = mockFn(1, 2);
+ *   expect(result).toEqual(3);
+ *   expect(mockFn).toHaveBeenCalledWith(1, 2);
+ *   expect(mockFn).toHaveBeenCalledTimes(1);
+ *
+ *   const result2 = mockFn(3, 2);
+ *   expect(result2).toEqual(1);
+ *   expect(mockFn).toHaveBeenCalledWith(3, 2);
+ *   expect(mockFn).toHaveBeenCalledTimes(2);
+ * });
+ * ```
+ */
+export function fn(...stubs) {
+    const calls = [];
+    const f = (...args) => {
+        const stub = stubs.length === 1
+            // keep reusing the first
+            ? stubs[0]
+            // pick the exact mock for the current call
+            : stubs[calls.length];
+        try {
+            const returned = stub ? stub(...args) : undefined;
+            calls.push({
+                args,
+                returned,
+                timestamp: Date.now(),
+                returns: true,
+                throws: false,
+            });
+            return returned;
+        }
+        catch (err) {
+            calls.push({
+                args,
+                timestamp: Date.now(),
+                returns: false,
+                thrown: err,
+                throws: true,
+            });
+            throw err;
+        }
+    };
+    Object.defineProperty(f, MOCK_SYMBOL, {
+        value: { calls },
+        writable: false,
+    });
+    return f;
+}

package/esm/deps/jsr.io/@std/expect/1.0.5/mod.d.ts

@@ -0,0 +1,85 @@
+/**
+ * This module provides Jest compatible expect assertion functionality.
+ *
+ * ```ts no-assert
+ * import { expect } from "@std/expect";
+ *
+ * const x = 6 * 7;
+ * expect(x).toEqual(42);
+ * expect(x).not.toEqual(0);
+ *
+ * await expect(Promise.resolve(x)).resolves.toEqual(42);
+ * ```
+ *
+ * Currently this module supports the following functions:
+ * - Common matchers:
+ *   - {@linkcode Expected.toBe | toBe}
+ *   - {@linkcode Expected.toEqual | toEqual}
+ *   - {@linkcode Expected.toStrictEqual | toStrictEqual}
+ *   - {@linkcode Expected.toMatch | toMatch}
+ *   - {@linkcode Expected.toMatchObject | toMatchObject}
+ *   - {@linkcode Expected.toBeDefined | toBeDefined}
+ *   - {@linkcode Expected.toBeUndefined | toBeUndefined}
+ *   - {@linkcode Expected.toBeNull | toBeNull}
+ *   - {@linkcode Expected.toBeNaN | toBeNaN}
+ *   - {@linkcode Expected.toBeTruthy | toBeTruthy}
+ *   - {@linkcode Expected.toBeFalsy | toBeFalsy}
+ *   - {@linkcode Expected.toContain | toContain}
+ *   - {@linkcode Expected.toContainEqual | toContainEqual}
+ *   - {@linkcode Expected.toHaveLength | toHaveLength}
+ *   - {@linkcode Expected.toBeGreaterThan | toBeGreaterThan}
+ *   - {@linkcode Expected.toBeGreaterThanOrEqual | toBeGreaterThanOrEqual}
+ *   - {@linkcode Expected.toBeLessThan | toBeLessThan}
+ *   - {@linkcode Expected.toBeLessThanOrEqual | toBeLessThanOrEqual}
+ *   - {@linkcode Expected.toBeCloseTo | toBeCloseTo}
+ *   - {@linkcode Expected.toBeInstanceOf | toBeInstanceOf}
+ *   - {@linkcode Expected.toThrow | toThrow}
+ *   - {@linkcode Expected.toHaveProperty | toHaveProperty}
+ * - Mock related matchers:
+ *   - {@linkcode Expected.toHaveBeenCalled | toHaveBeenCalled}
+ *   - {@linkcode Expected.toHaveBeenCalledTimes | toHaveBeenCalledTimes}
+ *   - {@linkcode Expected.toHaveBeenCalledWith | toHaveBeenCalledWith}
+ *   - {@linkcode Expected.toHaveBeenLastCalledWith | toHaveBeenLastCalledWith}
+ *   - {@linkcode Expected.toHaveBeenNthCalledWith | toHaveBeenNthCalledWith}
+ *   - {@linkcode Expected.toHaveReturned | toHaveReturned}
+ *   - {@linkcode Expected.toHaveReturnedTimes | toHaveReturnedTimes}
+ *   - {@linkcode Expected.toHaveReturnedWith | toHaveReturnedWith}
+ *   - {@linkcode Expected.toHaveLastReturnedWith | toHaveLastReturnedWith}
+ *   - {@linkcode Expected.toHaveNthReturnedWith | toHaveNthReturnedWith}
+ * - Asymmetric matchers:
+ *   - {@linkcode expect.anything}
+ *   - {@linkcode expect.any}
+ *   - {@linkcode expect.arrayContaining}
+ *   - {@linkcode expect.closeTo}
+ *   - {@linkcode expect.stringContaining}
+ *   - {@linkcode expect.stringMatching}
+ * - Utilities:
+ *   - {@linkcode expect.addEqualityTester}
+ *   - {@linkcode expect.extend}
+ *   - {@linkcode expect.hasAssertions}
+ *
+ * Only these functions are still not available:
+ * - Matchers:
+ *   - `toMatchSnapShot`
+ *   - `toMatchInlineSnapshot`
+ *   - `toThrowErrorMatchingSnapshot`
+ *   - `toThrowErrorMatchingInlineSnapshot`
+ * - Asymmetric matchers:
+ *   - `expect.objectContaining`
+ *   - `expect.not.objectContaining`
+ * - Utilities:
+ *   - `expect.assertions`
+ *   - `expect.addSnapshotSerializer`
+ *
+ * The tracking issue to add support for unsupported parts of the API is
+ * {@link https://github.com/denoland/std/issues/3964}.
+ *
+ * This module is largely inspired by
+ * {@link https://github.com/allain/expect | x/expect} module by
+ * {@link https://github.com/allain | Allain Lalonde}.
+ *
+ * @module
+ */
+export * from "./expect.js";
+export * from "./fn.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.5/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.5/mod.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}

package/esm/deps/jsr.io/@std/expect/1.0.5/mod.js

@@ -0,0 +1,87 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2019 Allain Lalonde. All rights reserved. ISC License.
+// This module is browser compatible.
+/**
+ * This module provides Jest compatible expect assertion functionality.
+ *
+ * ```ts no-assert
+ * import { expect } from "@std/expect";
+ *
+ * const x = 6 * 7;
+ * expect(x).toEqual(42);
+ * expect(x).not.toEqual(0);
+ *
+ * await expect(Promise.resolve(x)).resolves.toEqual(42);
+ * ```
+ *
+ * Currently this module supports the following functions:
+ * - Common matchers:
+ *   - {@linkcode Expected.toBe | toBe}
+ *   - {@linkcode Expected.toEqual | toEqual}
+ *   - {@linkcode Expected.toStrictEqual | toStrictEqual}
+ *   - {@linkcode Expected.toMatch | toMatch}
+ *   - {@linkcode Expected.toMatchObject | toMatchObject}
+ *   - {@linkcode Expected.toBeDefined | toBeDefined}
+ *   - {@linkcode Expected.toBeUndefined | toBeUndefined}
+ *   - {@linkcode Expected.toBeNull | toBeNull}
+ *   - {@linkcode Expected.toBeNaN | toBeNaN}
+ *   - {@linkcode Expected.toBeTruthy | toBeTruthy}
+ *   - {@linkcode Expected.toBeFalsy | toBeFalsy}
+ *   - {@linkcode Expected.toContain | toContain}
+ *   - {@linkcode Expected.toContainEqual | toContainEqual}
+ *   - {@linkcode Expected.toHaveLength | toHaveLength}
+ *   - {@linkcode Expected.toBeGreaterThan | toBeGreaterThan}
+ *   - {@linkcode Expected.toBeGreaterThanOrEqual | toBeGreaterThanOrEqual}
+ *   - {@linkcode Expected.toBeLessThan | toBeLessThan}
+ *   - {@linkcode Expected.toBeLessThanOrEqual | toBeLessThanOrEqual}
+ *   - {@linkcode Expected.toBeCloseTo | toBeCloseTo}
+ *   - {@linkcode Expected.toBeInstanceOf | toBeInstanceOf}
+ *   - {@linkcode Expected.toThrow | toThrow}
+ *   - {@linkcode Expected.toHaveProperty | toHaveProperty}
+ * - Mock related matchers:
+ *   - {@linkcode Expected.toHaveBeenCalled | toHaveBeenCalled}
+ *   - {@linkcode Expected.toHaveBeenCalledTimes | toHaveBeenCalledTimes}
+ *   - {@linkcode Expected.toHaveBeenCalledWith | toHaveBeenCalledWith}
+ *   - {@linkcode Expected.toHaveBeenLastCalledWith | toHaveBeenLastCalledWith}
+ *   - {@linkcode Expected.toHaveBeenNthCalledWith | toHaveBeenNthCalledWith}
+ *   - {@linkcode Expected.toHaveReturned | toHaveReturned}
+ *   - {@linkcode Expected.toHaveReturnedTimes | toHaveReturnedTimes}
+ *   - {@linkcode Expected.toHaveReturnedWith | toHaveReturnedWith}
+ *   - {@linkcode Expected.toHaveLastReturnedWith | toHaveLastReturnedWith}
+ *   - {@linkcode Expected.toHaveNthReturnedWith | toHaveNthReturnedWith}
+ * - Asymmetric matchers:
+ *   - {@linkcode expect.anything}
+ *   - {@linkcode expect.any}
+ *   - {@linkcode expect.arrayContaining}
+ *   - {@linkcode expect.closeTo}
+ *   - {@linkcode expect.stringContaining}
+ *   - {@linkcode expect.stringMatching}
+ * - Utilities:
+ *   - {@linkcode expect.addEqualityTester}
+ *   - {@linkcode expect.extend}
+ *   - {@linkcode expect.hasAssertions}
+ *
+ * Only these functions are still not available:
+ * - Matchers:
+ *   - `toMatchSnapShot`
+ *   - `toMatchInlineSnapshot`
+ *   - `toThrowErrorMatchingSnapshot`
+ *   - `toThrowErrorMatchingInlineSnapshot`
+ * - Asymmetric matchers:
+ *   - `expect.objectContaining`
+ *   - `expect.not.objectContaining`
+ * - Utilities:
+ *   - `expect.assertions`
+ *   - `expect.addSnapshotSerializer`
+ *
+ * The tracking issue to add support for unsupported parts of the API is
+ * {@link https://github.com/denoland/std/issues/3964}.
+ *
+ * This module is largely inspired by
+ * {@link https://github.com/allain/expect | x/expect} module by
+ * {@link https://github.com/allain | Allain Lalonde}.
+ *
+ * @module
+ */
+export * from "./expect.js";
+export * from "./fn.js";

package/esm/deps/jsr.io/@std/internal/1.0.4/assertion_state.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Check the test suite internal state
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionState } from "@std/internal";
+ *
+ * const assertionState = new AssertionState();
+ * ```
+ */
+export declare class AssertionState {
+    #private;
+    constructor();
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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.checkAssertionErrorStateAndReset()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionErrorStateAndReset(): boolean;
+}
+/**
+ * return an instance of AssertionState
+ *
+ * @returns AssertionState
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { getAssertionState } from "@std/internal";
+ *
+ * const assertionState = getAssertionState();
+ * assertionState.setAssertionTriggered(true);
+ * ```
+ */
+export declare function getAssertionState(): AssertionState;
+//# sourceMappingURL=assertion_state.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.4/assertion_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_state.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.4/assertion_state.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,qBAAa,cAAc;;;IAazB;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,GAAG,EAAE,OAAO;IAI9B;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,GAAG,EAAE,OAAO;IAIlC;;;;;;;;;;;;;;;;OAgBG;IACH,gCAAgC,IAAI,OAAO;CAe5C;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAElD"}

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

@@ -0,0 +1,101 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+var _AssertionState_instances, _AssertionState_state, _AssertionState_resetAssertionState;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+/**
+ * Check the test suite internal state
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionState } from "@std/internal";
+ *
+ * const assertionState = new AssertionState();
+ * ```
+ */
+export class AssertionState {
+    constructor() {
+        _AssertionState_instances.add(this);
+        _AssertionState_state.set(this, void 0);
+        __classPrivateFieldSet(this, _AssertionState_state, {
+            assertionCheck: false,
+            assertionTriggered: false,
+        }, "f");
+    }
+    /**
+     * 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) {
+        __classPrivateFieldGet(this, _AssertionState_state, "f").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) {
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggered = val;
+    }
+    /**
+     * 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.checkAssertionErrorStateAndReset()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionErrorStateAndReset() {
+        const result = __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCheck &&
+            !__classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggered;
+        __classPrivateFieldGet(this, _AssertionState_instances, "m", _AssertionState_resetAssertionState).call(this);
+        return result;
+    }
+}
+_AssertionState_state = new WeakMap(), _AssertionState_instances = new WeakSet(), _AssertionState_resetAssertionState = function _AssertionState_resetAssertionState() {
+    __classPrivateFieldSet(this, _AssertionState_state, {
+        assertionCheck: false,
+        assertionTriggered: false,
+    }, "f");
+};
+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.4/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.4/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.4/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.4/build_message.js

@@ -0,0 +1,111 @@
+// 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) => {
+        var _a, _b;
+        const color = createColor(result.type);
+        const line = (_b = (_a = result.details) === null || _a === void 0 ? void 0 : _a.map((detail) => detail.type !== "common"
+            ? createColor(detail.type, true)(detail.value)
+            : detail.value).join("")) !== null && _b !== void 0 ? _b : result.value;
+        return color(`${createSign(result.type)}${line}`);
+    });
+    messages.push(...(stringDiff ? [diffMessages.join("")] : diffMessages), "");
+    return messages;
+}