@goast/kotlin 0.4.0 → 0.4.2-beta1

package/src/deps/jsr.io/@std/assert/1.0.6/is_error.ts

@@ -1,65 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-import { stripAnsiCode } from "../../internal/1.0.4/styles.js";
-
-/**
- * Make an assertion that `error` is an `Error`.
- * If not then an error will be thrown.
- * An error class and a string that should be included in the
- * error message can also be asserted.
- *
- * @example Usage
- * ```ts ignore
- * import { assertIsError } from "@std/assert";
- *
- * assertIsError(null); // Throws
- * assertIsError(new RangeError("Out of range")); // Doesn't throw
- * assertIsError(new RangeError("Out of range"), SyntaxError); // Throws
- * assertIsError(new RangeError("Out of range"), SyntaxError, "Out of range"); // Doesn't throw
- * assertIsError(new RangeError("Out of range"), SyntaxError, "Within range"); // Throws
- * ```
- *
- * @typeParam E The type of the error to assert.
- * @param error The error to assert.
- * @param ErrorClass The optional error class to assert.
- * @param msgMatches The optional string or RegExp to assert in the error message.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertIsError<E extends Error = Error>(
-  error: unknown,
-  // deno-lint-ignore no-explicit-any
-  ErrorClass?: abstract new (...args: any[]) => E,
-  msgMatches?: string | RegExp,
-  msg?: string,
-): asserts error is E {
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  if (!(error instanceof Error)) {
-    throw new AssertionError(
-      `Expected "error" to be an Error object${msgSuffix}}`,
-    );
-  }
-  if (ErrorClass && !(error instanceof ErrorClass)) {
-    msg =
-      `Expected error to be instance of "${ErrorClass.name}", but was "${error?.constructor?.name}"${msgSuffix}`;
-    throw new AssertionError(msg);
-  }
-  let msgCheck;
-  if (typeof msgMatches === "string") {
-    msgCheck = stripAnsiCode(error.message).includes(
-      stripAnsiCode(msgMatches),
-    );
-  }
-  if (msgMatches instanceof RegExp) {
-    msgCheck = msgMatches.test(stripAnsiCode(error.message));
-  }
-
-  if (msgMatches && !msgCheck) {
-    msg = `Expected error message to include ${
-      msgMatches instanceof RegExp
-        ? msgMatches.toString()
-        : JSON.stringify(msgMatches)
-    }, but got ${JSON.stringify(error?.message)}${msgSuffix}`;
-    throw new AssertionError(msg);
-  }
-}

package/src/deps/jsr.io/@std/assert/1.0.6/match.ts

@@ -1,30 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` match RegExp `expected`. If not
- * then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertMatch } from "@std/assert";
- *
- * assertMatch("Raptor", /Raptor/); // Doesn't throw
- * assertMatch("Denosaurus", /Raptor/); // Throws
- * ```
- *
- * @param actual The actual value to be matched.
- * @param expected The expected pattern to match.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertMatch(
-  actual: string,
-  expected: RegExp,
-  msg?: string,
-) {
-  if (expected.test(actual)) return;
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  msg = `Expected actual: "${actual}" to match: "${expected}"${msgSuffix}`;
-  throw new AssertionError(msg);
-}

package/src/deps/jsr.io/@std/assert/1.0.6/not_instance_of.ts

@@ -1,33 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { assertFalse } from "./false.js";
-
-/**
- * Make an assertion that `obj` is not an instance of `type`.
- * If so, then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertNotInstanceOf } from "@std/assert";
- *
- * assertNotInstanceOf(new Date(), Number); // Doesn't throw
- * assertNotInstanceOf(new Date(), Date); // Throws
- * ```
- *
- * @typeParam A The type of the object to check.
- * @typeParam T The type of the class to check against.
- * @param actual The object to check.
- * @param unexpectedType The class constructor to check against.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertNotInstanceOf<A, T>(
-  actual: A,
-  // deno-lint-ignore no-explicit-any
-  unexpectedType: abstract new (...args: any[]) => T,
-  msg?: string,
-): asserts actual is Exclude<A, T> {
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  msg =
-    `Expected object to not be an instance of "${typeof unexpectedType}"${msgSuffix}`;
-  assertFalse(actual instanceof unexpectedType, msg);
-}

package/src/deps/jsr.io/@std/assert/1.0.6/not_match.ts

@@ -1,30 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` not match RegExp `expected`. If match
- * then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertNotMatch } from "@std/assert";
- *
- * assertNotMatch("Denosaurus", /Raptor/); // Doesn't throw
- * assertNotMatch("Raptor", /Raptor/); // Throws
- * ```
- *
- * @param actual The actual value to match.
- * @param expected The expected value to not match.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertNotMatch(
-  actual: string,
-  expected: RegExp,
-  msg?: string,
-) {
-  if (!expected.test(actual)) return;
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  msg = `Expected actual: "${actual}" to not match: "${expected}"${msgSuffix}`;
-  throw new AssertionError(msg);
-}

package/src/deps/jsr.io/@std/assert/1.0.6/not_strict_equals.ts

@@ -1,42 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-import { format } from "../../internal/1.0.4/format.js";
-
-/**
- * Make an assertion that `actual` and `expected` are not strictly equal, using
- * {@linkcode Object.is} for equality comparison. If the values are strictly
- * equal then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertNotStrictEquals } from "@std/assert";
- *
- * assertNotStrictEquals(1, 1); // Throws
- * assertNotStrictEquals(1, 2); // Doesn't throw
- *
- * assertNotStrictEquals(0, 0); // Throws
- * assertNotStrictEquals(0, -0); // Doesn't throw
- * ```
- *
- * @typeParam T The type of the values to compare.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertNotStrictEquals<T>(
-  actual: T,
-  expected: T,
-  msg?: string,
-) {
-  if (!Object.is(actual, expected)) {
-    return;
-  }
-
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  throw new AssertionError(
-    `Expected "actual" to not be strictly equal to: ${
-      format(actual)
-    }${msgSuffix}\n`,
-  );
-}

package/src/deps/jsr.io/@std/assert/1.0.6/object_match.ts

@@ -1,202 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { assertEquals } from "./equals.js";
-
-/**
- * Make an assertion that `expected` object is a subset of `actual` object,
- * deeply. If not, then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertObjectMatch } from "@std/assert";
- *
- * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
- * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
- * assertObjectMatch({ foo: 1, bar: 2 }, { foo: 1 }); // Doesn't throw
- * assertObjectMatch({ foo: 1 }, { foo: 1, bar: 2 }); // Throws
- * ```
- *
- * @example Usage with nested objects
- * ```ts ignore
- * import { assertObjectMatch } from "@std/assert";
- *
- * assertObjectMatch({ foo: { bar: 3, baz: 4 } }, { foo: { bar: 3 } }); // Doesn't throw
- * assertObjectMatch({ foo: { bar: 3 } }, { foo: { bar: 3, baz: 4 } }); // Throws
- * ```
- *
- * @param actual The actual value to be matched.
- * @param expected The expected value to match.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertObjectMatch(
-  // deno-lint-ignore no-explicit-any
-  actual: Record<PropertyKey, any>,
-  expected: Record<PropertyKey, unknown>,
-  msg?: string,
-): void {
-  return assertEquals(
-    // get the intersection of "actual" and "expected"
-    // side effect: all the instances' constructor field is "Object" now.
-    filter(actual, expected),
-    // set (nested) instances' constructor field to be "Object" without changing expected value.
-    // see https://github.com/denoland/deno_std/pull/1419
-    filter(expected, expected),
-    msg,
-  );
-}
-
-type loose = Record<PropertyKey, unknown>;
-
-function isObject(val: unknown): boolean {
-  return typeof val === "object" && val !== null;
-}
-
-function filter(a: loose, b: loose): loose {
-  const seen = new WeakMap();
-  return filterObject(a, b);
-
-  function filterObject(a: loose, b: loose): loose {
-    // Prevent infinite loop with circular references with same filter
-    if ((seen.has(a)) && (seen.get(a) === b)) {
-      return a;
-    }
-
-    try {
-      seen.set(a, b);
-    } catch (err) {
-      if (err instanceof TypeError) {
-        throw new TypeError(
-          `Cannot assertObjectMatch ${a === null ? null : `type ${typeof a}`}`,
-        );
-      }
-    }
-
-    // Filter keys and symbols which are present in both actual and expected
-    const filtered = {} as loose;
-    const keysA = Reflect.ownKeys(a);
-    const keysB = Reflect.ownKeys(b);
-    const entries = keysA.filter((key) => keysB.includes(key))
-      .map((key) => [key, a[key as string]]) as Array<[string, unknown]>;
-
-    if (keysA.length && keysB.length && !entries.length) {
-      // If both objects are not empty but don't have the same keys or symbols,
-      // returns the entries in object a.
-      for (const key of keysA) {
-        filtered[key] = a[key];
-      }
-
-      return filtered;
-    }
-
-    for (const [key, value] of entries) {
-      // On regexp references, keep value as it to avoid loosing pattern and flags
-      if (value instanceof RegExp) {
-        filtered[key] = value;
-        continue;
-      }
-
-      const subset = (b as loose)[key];
-
-      // On array references, build a filtered array and filter nested objects inside
-      if (Array.isArray(value) && Array.isArray(subset)) {
-        filtered[key] = filterArray(value, subset);
-        continue;
-      }
-
-      // On nested objects references, build a filtered object recursively
-      if (isObject(value) && isObject(subset)) {
-        // When both operands are maps, build a filtered map with common keys and filter nested objects inside
-        if ((value instanceof Map) && (subset instanceof Map)) {
-          filtered[key] = new Map(
-            [...value].filter(([k]) => subset.has(k)).map(
-              ([k, v]) => {
-                const v2 = subset.get(k);
-                if (isObject(v) && isObject(v2)) {
-                  return [k, filterObject(v as loose, v2 as loose)];
-                }
-
-                return [k, v];
-              },
-            ),
-          );
-          continue;
-        }
-
-        // When both operands are set, build a filtered set with common values
-        if ((value instanceof Set) && (subset instanceof Set)) {
-          filtered[key] = value.intersection(subset);
-          continue;
-        }
-
-        filtered[key] = filterObject(value as loose, subset as loose);
-        continue;
-      }
-
-      filtered[key] = value;
-    }
-
-    return filtered;
-  }
-
-  function filterArray(a: unknown[], b: unknown[]): unknown[] {
-    // Prevent infinite loop with circular references with same filter
-    if (seen.has(a) && (seen.get(a) === b)) {
-      return a;
-    }
-
-    seen.set(a, b);
-
-    const filtered: unknown[] = [];
-    const count = Math.min(a.length, b.length);
-
-    for (let i = 0; i < count; ++i) {
-      const value = a[i];
-      const subset = b[i];
-
-      // On regexp references, keep value as it to avoid loosing pattern and flags
-      if (value instanceof RegExp) {
-        filtered.push(value);
-        continue;
-      }
-
-      // On array references, build a filtered array and filter nested objects inside
-      if (Array.isArray(value) && Array.isArray(subset)) {
-        filtered.push(filterArray(value, subset));
-        continue;
-      }
-
-      // On nested objects references, build a filtered object recursively
-      if (isObject(value) && isObject(subset)) {
-        // When both operands are maps, build a filtered map with common keys and filter nested objects inside
-        if ((value instanceof Map) && (subset instanceof Map)) {
-          const map = new Map(
-            [...value].filter(([k]) => subset.has(k))
-              .map(([k, v]) => {
-                const v2 = subset.get(k);
-                if (isObject(v) && isObject(v2)) {
-                  return [k, filterObject(v as loose, v2 as loose)];
-                }
-
-                return [k, v];
-              }),
-          );
-          filtered.push(map);
-          continue;
-        }
-
-        // When both operands are set, build a filtered set with common values
-        if ((value instanceof Set) && (subset instanceof Set)) {
-          filtered.push(value.intersection(subset));
-          continue;
-        }
-
-        filtered.push(filterObject(value as loose, subset as loose));
-        continue;
-      }
-
-      filtered.push(value);
-    }
-
-    return filtered;
-  }
-}

package/src/deps/jsr.io/@std/assert/1.0.6/rejects.ts

@@ -1,123 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-import { assertIsError } from "./is_error.js";
-
-/**
- * Executes a function which returns a promise, expecting it to reject.
- *
- * To assert that a synchronous function throws, use {@linkcode assertThrows}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertRejects } from "@std/assert";
- *
- * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
- * await assertRejects(async () => console.log("Hello world")); // Throws
- * ```
- *
- * @param fn The function to execute.
- * @param msg The optional message to display if the assertion fails.
- * @returns The promise which resolves to the thrown error.
- */
-export function assertRejects(
-  fn: () => PromiseLike<unknown>,
-  msg?: string,
-): Promise<unknown>;
-/**
- * Executes a function which returns a promise, expecting it to reject.
- * If it does not, then it throws. An error class and a string that should be
- * included in the error message can also be asserted.
- *
- * To assert that a synchronous function throws, use {@linkcode assertThrows}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertRejects } from "@std/assert";
- *
- * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
- * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
- * ```
- *
- * @typeParam E The error class to assert.
- * @param fn The function to execute.
- * @param ErrorClass The error class to assert.
- * @param msgIncludes The string that should be included in the error message.
- * @param msg The optional message to display if the assertion fails.
- * @returns The promise which resolves to the thrown error.
- */
-export function assertRejects<E extends Error = Error>(
-  fn: () => PromiseLike<unknown>,
-  // deno-lint-ignore no-explicit-any
-  ErrorClass: abstract new (...args: any[]) => E,
-  msgIncludes?: string,
-  msg?: string,
-): Promise<E>;
-export async function assertRejects<E extends Error = Error>(
-  fn: () => PromiseLike<unknown>,
-  errorClassOrMsg?:
-    // deno-lint-ignore no-explicit-any
-    | (abstract new (...args: any[]) => E)
-    | string,
-  msgIncludesOrMsg?: string,
-  msg?: string,
-): Promise<E | Error | unknown> {
-  // deno-lint-ignore no-explicit-any
-  let ErrorClass: (abstract new (...args: any[]) => E) | undefined;
-  let msgIncludes: string | undefined;
-  let err;
-
-  if (typeof errorClassOrMsg !== "string") {
-    if (
-      errorClassOrMsg === undefined ||
-      errorClassOrMsg.prototype instanceof Error ||
-      errorClassOrMsg.prototype === Error.prototype
-    ) {
-      ErrorClass = errorClassOrMsg;
-      msgIncludes = msgIncludesOrMsg;
-    }
-  } else {
-    msg = errorClassOrMsg;
-  }
-  let doesThrow = false;
-  let isPromiseReturned = false;
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  try {
-    const possiblePromise = fn();
-    if (
-      possiblePromise &&
-      typeof possiblePromise === "object" &&
-      typeof possiblePromise.then === "function"
-    ) {
-      isPromiseReturned = true;
-      await possiblePromise;
-    } else {
-      throw new Error();
-    }
-  } catch (error) {
-    if (!isPromiseReturned) {
-      throw new AssertionError(
-        `Function throws when expected to reject${msgSuffix}`,
-      );
-    }
-    if (ErrorClass) {
-      if (!(error instanceof Error)) {
-        throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
-      }
-      assertIsError(
-        error,
-        ErrorClass,
-        msgIncludes,
-        msg,
-      );
-    }
-    err = error;
-    doesThrow = true;
-  }
-  if (!doesThrow) {
-    throw new AssertionError(
-      `Expected function to reject${msgSuffix}`,
-    );
-  }
-  return err;
-}

package/src/deps/jsr.io/@std/assert/1.0.6/strict_equals.ts

@@ -1,67 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { buildMessage } from "../../internal/1.0.4/build_message.js";
-import { diff } from "../../internal/1.0.4/diff.js";
-import { diffStr } from "../../internal/1.0.4/diff_str.js";
-import { format } from "../../internal/1.0.4/format.js";
-import { red } from "../../internal/1.0.4/styles.js";
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` and `expected` are strictly equal, using
- * {@linkcode Object.is} for equality comparison. If not, then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertStrictEquals } from "@std/assert";
- *
- * const a = {};
- * const b = a;
- * assertStrictEquals(a, b); // Doesn't throw
- *
- * const c = {};
- * const d = {};
- * assertStrictEquals(c, d); // Throws
- * ```
- *
- * @typeParam T The type of the expected value.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertStrictEquals<T>(
-  actual: unknown,
-  expected: T,
-  msg?: string,
-): asserts actual is T {
-  if (Object.is(actual, expected)) {
-    return;
-  }
-
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  let message: string;
-
-  const actualString = format(actual);
-  const expectedString = format(expected);
-
-  if (actualString === expectedString) {
-    const withOffset = actualString
-      .split("\n")
-      .map((l) => `    ${l}`)
-      .join("\n");
-    message =
-      `Values have the same structure but are not reference-equal${msgSuffix}\n\n${
-        red(withOffset)
-      }\n`;
-  } else {
-    const stringDiff = (typeof actual === "string") &&
-      (typeof expected === "string");
-    const diffResult = stringDiff
-      ? diffStr(actual as string, expected as string)
-      : diff(actualString.split("\n"), expectedString.split("\n"));
-    const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
-    message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
-  }
-
-  throw new AssertionError(message);
-}

package/src/deps/jsr.io/@std/expect/1.0.5/_assert_equals.ts

@@ -1,38 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-// This file is copied from `std/assert`.
-
-import { AssertionError } from "../../assert/1.0.6/assertion_error.js";
-import { buildEqualErrorMessage } from "./_build_message.js";
-import { equal } from "./_equal.js";
-import type { EqualOptions } from "./_types.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 ignore
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals("world", "world"); // Doesn't throw
- * assertEquals("hello", "world"); // Throws
- * ```
- *
- * Note: formatter option is experimental and may be removed in the future.
- */
-export function assertEquals<T>(
-  actual: T,
-  expected: T,
-  options?: EqualOptions,
-) {
-  if (equal(actual, expected, options)) {
-    return;
-  }
-
-  const message = buildEqualErrorMessage(actual, expected, options ?? {});
-  throw new AssertionError(message);
-}

package/src/deps/jsr.io/@std/expect/1.0.5/_assert_not_equals.ts

@@ -1,35 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-// This file is copied from `std/assert`.
-
-import { AssertionError } from "../../assert/1.0.6/assertion_error.js";
-import { buildNotEqualErrorMessage } from "./_build_message.js";
-import { equal } from "./_equal.js";
-import type { EqualOptions } from "./_types.js";
-
-/**
- * Make an assertion that `actual` and `expected` are not equal, deeply.
- * If not then throw.
- *
- * Type parameter can be specified to ensure values under comparison have the same type.
- *
- * @example
- * ```ts ignore
- * import { assertNotEquals } from "@std/assert";
- *
- * assertNotEquals(1, 2); // Doesn't throw
- * assertNotEquals(1, 1); // Throws
- * ```
- */
-export function assertNotEquals<T>(
-  actual: T,
-  expected: T,
-  options: EqualOptions = {},
-) {
-  if (!equal(actual, expected, options)) {
-    return;
-  }
-
-  const message = buildNotEqualErrorMessage(actual, expected, options);
-  throw new AssertionError(message);
-}

package/src/deps/jsr.io/@std/expect/1.0.5/_assertion.ts

@@ -1,13 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-import { getAssertionState } from "../../internal/1.0.4/assertion_state.js";
-
-const assertionState = getAssertionState();
-
-export function hasAssertions() {
-  assertionState.setAssertionCheck(true);
-}
-
-export function emitAssertionTrigger() {
-  assertionState.setAssertionTriggered(true);
-}