@goast/kotlin 0.4.12 → 0.4.14-beta1

package/script/deps/jsr.io/@std/internal/1.0.5/assertion_state.js

@@ -1,204 +0,0 @@
-"use strict";
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-var _AssertionState_state;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssertionState = void 0;
-exports.getAssertionState = getAssertionState;
-const tslib_1 = require("tslib");
-/**
- * Check the test suite internal state
- *
- * @example Usage
- * ```ts ignore
- * import { AssertionState } from "@std/internal";
- *
- * const assertionState = new AssertionState();
- * ```
- */
-class AssertionState {
-    constructor() {
-        _AssertionState_state.set(this, void 0);
-        tslib_1.__classPrivateFieldSet(this, _AssertionState_state, {
-            assertionCount: undefined,
-            assertionCheck: false,
-            assertionTriggered: false,
-            assertionTriggeredCount: 0,
-        }, "f");
-    }
-    /**
-     * 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 tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").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 tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").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) {
-        tslib_1.__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) {
-        tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").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) {
-        tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").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 (tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== undefined) {
-            tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").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 tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").assertionCheck && !tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").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() {
-        tslib_1.__classPrivateFieldSet(this, _AssertionState_state, {
-            assertionCount: undefined,
-            assertionCheck: false,
-            assertionTriggered: false,
-            assertionTriggeredCount: 0,
-        }, "f");
-    }
-    /**
-     * 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 tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== undefined &&
-            tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== tslib_1.__classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggeredCount;
-    }
-}
-exports.AssertionState = AssertionState;
-_AssertionState_state = new WeakMap();
-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);
- * ```
- */
-function getAssertionState() {
-    return assertionState;
-}

package/script/deps/jsr.io/@std/internal/1.0.5/build_message.d.ts

@@ -1,82 +0,0 @@
-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/script/deps/jsr.io/@std/internal/1.0.5/build_message.d.ts.map

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

@@ -1,116 +0,0 @@
-"use strict";
-// Copyright 2018-2024 the Deno authors. All rights reserved. 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/deno_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));
-        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.
- *
- * @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",
- * //   "",
- * // ]
- * ```
- */
-function buildMessage(diffResult, options = {}) {
-    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) => {
-        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;
-}

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

@@ -1,140 +0,0 @@
-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/script/deps/jsr.io/@std/internal/1.0.5/diff.d.ts.map

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