@goast/kotlin 0.4.3 → 0.4.4-beta1

package/src/deps/jsr.io/@std/expect/1.0.7/_asymmetric_matchers.ts

@@ -1,193 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// deno-lint-ignore-file no-explicit-any
-
-import { equal } from "./_equal.js";
-
-export abstract class AsymmetricMatcher<T> {
-  constructor(
-    protected value: T,
-    protected inverse: boolean = false,
-  ) {}
-  abstract equals(other: unknown): boolean;
-}
-
-export class Anything extends AsymmetricMatcher<void> {
-  equals(other: unknown): boolean {
-    return other !== null && other !== undefined;
-  }
-}
-
-export function anything(): Anything {
-  return new Anything();
-}
-
-export class Any extends AsymmetricMatcher<any> {
-  constructor(value: unknown) {
-    if (value === undefined) {
-      throw new TypeError("Expected a constructor function");
-    }
-    super(value);
-  }
-
-  equals(other: unknown): boolean {
-    if (typeof other === "object") {
-      return other instanceof this.value;
-    } else {
-      if (this.value === Number) {
-        return typeof other === "number";
-      }
-
-      if (this.value === String) {
-        return typeof other === "string";
-      }
-
-      if (this.value === Number) {
-        return typeof other === "number";
-      }
-
-      if (this.value === Function) {
-        return typeof other === "function";
-      }
-
-      if (this.value === Boolean) {
-        return typeof other === "boolean";
-      }
-
-      if (this.value === BigInt) {
-        return typeof other === "bigint";
-      }
-
-      if (this.value === Symbol) {
-        return typeof other === "symbol";
-      }
-    }
-    return false;
-  }
-}
-
-export function any(c: unknown): Any {
-  return new Any(c);
-}
-
-export class ArrayContaining extends AsymmetricMatcher<any[]> {
-  constructor(arr: any[], inverse = false) {
-    super(arr, inverse);
-  }
-
-  equals(other: any[]): boolean {
-    const res = Array.isArray(other) &&
-      this.value.every((e) => other.includes(e));
-    return this.inverse ? !res : res;
-  }
-}
-
-export function arrayContaining(c: any[]): ArrayContaining {
-  return new ArrayContaining(c);
-}
-
-export function arrayNotContaining(c: any[]): ArrayContaining {
-  return new ArrayContaining(c, true);
-}
-
-export class CloseTo extends AsymmetricMatcher<number> {
-  readonly #precision: number;
-
-  constructor(num: number, precision: number = 2) {
-    super(num);
-    this.#precision = precision;
-  }
-
-  equals(other: number): boolean {
-    if (typeof other !== "number") {
-      return false;
-    }
-
-    if (
-      (this.value === Number.POSITIVE_INFINITY &&
-        other === Number.POSITIVE_INFINITY) ||
-      (this.value === Number.NEGATIVE_INFINITY &&
-        other === Number.NEGATIVE_INFINITY)
-    ) {
-      return true;
-    }
-
-    return Math.abs(this.value - other) < Math.pow(10, -this.#precision) / 2;
-  }
-}
-
-export function closeTo(num: number, numDigits?: number): CloseTo {
-  return new CloseTo(num, numDigits);
-}
-
-export class StringContaining extends AsymmetricMatcher<string> {
-  constructor(str: string, inverse = false) {
-    super(str, inverse);
-  }
-
-  equals(other: string): boolean {
-    const res = typeof other !== "string" ? false : other.includes(this.value);
-    return this.inverse ? !res : res;
-  }
-}
-
-export function stringContaining(str: string): StringContaining {
-  return new StringContaining(str);
-}
-
-export function stringNotContaining(str: string): StringContaining {
-  return new StringContaining(str, true);
-}
-
-export class StringMatching extends AsymmetricMatcher<RegExp> {
-  constructor(pattern: string | RegExp, inverse = false) {
-    super(new RegExp(pattern), inverse);
-  }
-
-  equals(other: string): boolean {
-    const res = typeof other !== "string" ? false : this.value.test(other);
-    return this.inverse ? !res : res;
-  }
-}
-
-export function stringMatching(pattern: string | RegExp): StringMatching {
-  return new StringMatching(pattern);
-}
-
-export function stringNotMatching(pattern: string | RegExp): StringMatching {
-  return new StringMatching(pattern, true);
-}
-
-export class ObjectContaining
-  extends AsymmetricMatcher<Record<string, unknown>> {
-  constructor(obj: Record<string, unknown>, inverse = false) {
-    super(obj, inverse);
-  }
-
-  equals(other: Record<string, unknown>): boolean {
-    const keys = Object.keys(this.value);
-    let res = true;
-
-    for (const key of keys) {
-      if (
-        !Object.hasOwn(other, key) ||
-        !equal(this.value[key], other[key])
-      ) {
-        res = false;
-      }
-    }
-
-    return this.inverse ? !res : res;
-  }
-}
-
-export function objectContaining(
-  obj: Record<string, unknown>,
-): ObjectContaining {
-  return new ObjectContaining(obj);
-}
-
-export function objectNotContaining(
-  obj: Record<string, unknown>,
-): ObjectContaining {
-  return new ObjectContaining(obj, true);
-}

package/src/deps/jsr.io/@std/expect/1.0.7/_build_message.ts

@@ -1,51 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-import { buildMessage } from "../../internal/1.0.5/build_message.js";
-import { diff } from "../../internal/1.0.5/diff.js";
-import { diffStr } from "../../internal/1.0.5/diff_str.js";
-import { format } from "../../internal/1.0.5/format.js";
-import type { EqualOptions } from "./_types.js";
-
-type EqualErrorMessageOptions = Pick<
-  EqualOptions,
-  "formatter" | "msg"
->;
-
-function isString(value: unknown): value is string {
-  return typeof value === "string";
-}
-
-export function buildEqualErrorMessage<T>(
-  actual: T,
-  expected: T,
-  options: EqualErrorMessageOptions,
-): string {
-  const { formatter = format, msg } = options ?? {};
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  const actualString = formatter(actual);
-  const expectedString = formatter(expected);
-
-  let message = `Values are not equal${msgSuffix}`;
-
-  const stringDiff = isString(actual) && isString(expected);
-  const diffResult = stringDiff
-    ? diffStr(actual, expected)
-    : diff(actualString.split("\n"), expectedString.split("\n"));
-  const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
-  message = `${message}\n${diffMsg}`;
-
-  return message;
-}
-
-export function buildNotEqualErrorMessage<T>(
-  actual: T,
-  expected: T,
-  options: EqualErrorMessageOptions,
-): string {
-  const { msg } = options ?? {};
-  const actualString = String(actual);
-  const expectedString = String(expected);
-
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  return `Expected actual: ${actualString} not to be: ${expectedString}${msgSuffix}`;
-}

package/src/deps/jsr.io/@std/expect/1.0.7/_custom_equality_tester.ts

@@ -1,19 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-import type { Tester } from "./_types.js";
-
-const customEqualityTesters: Tester[] = [];
-
-export function addCustomEqualityTesters(newTesters: Tester[]) {
-  if (!Array.isArray(newTesters)) {
-    throw new TypeError(
-      `customEqualityTester expects an array of Testers. But got ${typeof newTesters}`,
-    );
-  }
-
-  customEqualityTesters.push(...newTesters);
-}
-
-export function getCustomEqualityTesters() {
-  return customEqualityTesters;
-}

package/src/deps/jsr.io/@std/expect/1.0.7/_equal.ts

@@ -1,230 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-// This file is copied from `std/assert`.
-
-import type { EqualOptions } from "./_types.js";
-import { AsymmetricMatcher } from "./_asymmetric_matchers.js";
-
-type KeyedCollection = Set<unknown> | Map<unknown, unknown>;
-function isKeyedCollection(x: unknown): x is KeyedCollection {
-  return x instanceof Set || x instanceof Map;
-}
-
-function constructorsEqual(a: object, b: object) {
-  return a.constructor === b.constructor ||
-    a.constructor === Object && !b.constructor ||
-    !a.constructor && b.constructor === Object;
-}
-
-function asymmetricEqual(a: unknown, b: unknown) {
-  const asymmetricA = a instanceof AsymmetricMatcher;
-  const asymmetricB = b instanceof AsymmetricMatcher;
-
-  if (asymmetricA && asymmetricB) {
-    return undefined;
-  }
-
-  if (asymmetricA) {
-    return a.equals(b);
-  }
-
-  if (asymmetricB) {
-    return b.equals(a);
-  }
-}
-
-/**
- * Deep equality comparison used in assertions
- * @param c actual value
- * @param d expected value
- * @param options for the equality check
- */
-export function equal(c: unknown, d: unknown, options?: EqualOptions): boolean {
-  const { customTesters = [], strictCheck } = options ?? {};
-  const seen = new Map();
-
-  return (function compare(a: unknown, b: unknown): boolean {
-    const asymmetric = asymmetricEqual(a, b);
-    if (asymmetric !== undefined) {
-      return asymmetric;
-    }
-
-    if (customTesters?.length) {
-      for (const customTester of customTesters) {
-        const testContext = {
-          equal,
-        };
-        const pass = customTester.call(testContext, a, b, customTesters);
-        if (pass !== undefined) {
-          return pass;
-        }
-      }
-    }
-
-    // Have to render RegExp & Date for string comparison
-    // unless it's mistreated as object
-    if (
-      a &&
-      b &&
-      ((a instanceof RegExp && b instanceof RegExp) ||
-        (a instanceof URL && b instanceof URL))
-    ) {
-      return String(a) === String(b);
-    }
-
-    if (a instanceof Date && b instanceof Date) {
-      const aTime = a.getTime();
-      const bTime = b.getTime();
-      // Check for NaN equality manually since NaN is not
-      // equal to itself.
-      if (Number.isNaN(aTime) && Number.isNaN(bTime)) {
-        return true;
-      }
-      return aTime === bTime;
-    }
-    if (a instanceof Error && b instanceof Error) {
-      return a.message === b.message;
-    }
-    if (typeof a === "number" && typeof b === "number") {
-      return Number.isNaN(a) && Number.isNaN(b) || a === b;
-    }
-    if (a === null || b === null) {
-      return a === b;
-    }
-    const className = Object.prototype.toString.call(a);
-    if (className !== Object.prototype.toString.call(b)) {
-      return false;
-    }
-    if (Object.is(a, b)) {
-      return true;
-    }
-    if (a && typeof a === "object" && b && typeof b === "object") {
-      if (strictCheck && a && b && !constructorsEqual(a, b)) {
-        return false;
-      }
-      if (a instanceof WeakMap || b instanceof WeakMap) {
-        if (!(a instanceof WeakMap && b instanceof WeakMap)) return false;
-        throw new TypeError("Cannot compare WeakMap instances");
-      }
-      if (a instanceof WeakSet || b instanceof WeakSet) {
-        if (!(a instanceof WeakSet && b instanceof WeakSet)) return false;
-        throw new TypeError("Cannot compare WeakSet instances");
-      }
-      if (seen.get(a) === b) {
-        return true;
-      }
-
-      const aKeys = Object.keys(a ?? {});
-      const bKeys = Object.keys(b ?? {});
-      let aLen = aKeys.length;
-      let bLen = bKeys.length;
-
-      if (strictCheck && aLen !== bLen) {
-        return false;
-      }
-
-      if (!strictCheck) {
-        if (aLen > 0) {
-          for (let i = 0; i < aKeys.length; i += 1) {
-            const key = aKeys[i]!;
-            if (
-              (key in a) && (a[key as keyof typeof a] === undefined) &&
-              !(key in b)
-            ) {
-              aLen -= 1;
-            }
-          }
-        }
-
-        if (bLen > 0) {
-          for (let i = 0; i < bKeys.length; i += 1) {
-            const key = bKeys[i]!;
-            if (
-              (key in b) && (b[key as keyof typeof b] === undefined) &&
-              !(key in a)
-            ) {
-              bLen -= 1;
-            }
-          }
-        }
-      }
-
-      seen.set(a, b);
-      if (isKeyedCollection(a) && isKeyedCollection(b)) {
-        if (a.size !== b.size) {
-          return false;
-        }
-
-        const aKeys = [...a.keys()];
-        const primitiveKeysFastPath = aKeys.every((k) => {
-          return typeof k === "string" ||
-            typeof k === "number" ||
-            typeof k === "boolean" ||
-            typeof k === "bigint" ||
-            typeof k === "symbol" ||
-            k == null;
-        });
-        if (primitiveKeysFastPath) {
-          if (a instanceof Set) {
-            return a.symmetricDifference(b).size === 0;
-          }
-
-          for (const key of aKeys) {
-            if (
-              !b.has(key) ||
-              !compare(a.get(key), (b as Map<unknown, unknown>).get(key))
-            ) {
-              return false;
-            }
-          }
-          return true;
-        }
-
-        let unmatchedEntries = a.size;
-
-        for (const [aKey, aValue] of a.entries()) {
-          for (const [bKey, bValue] of b.entries()) {
-            /* Given that Map keys can be references, we need
-             * to ensure that they are also deeply equal */
-
-            if (!compare(aKey, bKey)) continue;
-
-            if (
-              (aKey === aValue && bKey === bValue) ||
-              (compare(aValue, bValue))
-            ) {
-              unmatchedEntries--;
-              break;
-            }
-          }
-        }
-
-        return unmatchedEntries === 0;
-      }
-      const merged = { ...a, ...b };
-      for (
-        const key of [
-          ...Object.getOwnPropertyNames(merged),
-          ...Object.getOwnPropertySymbols(merged),
-        ]
-      ) {
-        type Key = keyof typeof merged;
-        if (!compare(a && a[key as Key], b && b[key as Key])) {
-          return false;
-        }
-        if (
-          ((key in a) && (a[key as Key] !== undefined) && (!(key in b))) ||
-          ((key in b) && (b[key as Key] !== undefined) && (!(key in a)))
-        ) {
-          return false;
-        }
-      }
-      if (a instanceof WeakRef || b instanceof WeakRef) {
-        if (!(a instanceof WeakRef && b instanceof WeakRef)) return false;
-        return compare(a.deref(), b.deref());
-      }
-      return true;
-    }
-    return false;
-  })(c, d);
-}

package/src/deps/jsr.io/@std/expect/1.0.7/_extend.ts

@@ -1,16 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-import type { Matchers } from "./_types.js";
-
-let extendMatchers = {};
-
-export function getExtendMatchers() {
-  return extendMatchers;
-}
-
-export function setExtendMatchers(newExtendMatchers: Matchers) {
-  extendMatchers = {
-    ...extendMatchers,
-    ...newExtendMatchers,
-  };
-}

package/src/deps/jsr.io/@std/expect/1.0.7/_inspect_args.ts

@@ -1,15 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// deno-lint-ignore-file
-import * as dntShim from "../../../../../_dnt.test_shims.js";
-
-
-export function inspectArgs(args: unknown[]): string {
-  return args.map(inspectArg).join(", ");
-}
-
-export function inspectArg(arg: unknown): string {
-  const { Deno } = dntShim.dntGlobalThis as any;
-  return typeof Deno !== "undefined" && Deno.inspect
-    ? Deno.inspect(arg)
-    : String(arg);
-}