@kerebron/test-utils 0.4.28 → 0.4.30

package/src/deps/jsr.io/@std/assert/1.0.16/array_includes.ts

@@ -0,0 +1,57 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { equal } from "./equal.js";
+import { format } from "../../internal/1.0.12/format.js";
+import { AssertionError } from "./assertion_error.js";
+
+/** An array-like object (`Array`, `Uint8Array`, `NodeList`, etc.) that is not a string */
+export type ArrayLikeArg<T> = ArrayLike<T> & object;
+
+/**
+ * Make an assertion that `actual` includes the `expected` values. If not then
+ * an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ *
+ * @typeParam T The type of the elements in the array to compare.
+ * @param actual The array-like object to check for.
+ * @param expected The array-like object to check for.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertArrayIncludes<T>(
+  actual: ArrayLikeArg<T>,
+  expected: ArrayLikeArg<T>,
+  msg?: string,
+) {
+  const missing: unknown[] = [];
+  for (let i = 0; i < expected.length; i++) {
+    let found = false;
+    for (let j = 0; j < actual.length; j++) {
+      if (equal(expected[i], actual[j])) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      missing.push(expected[i]);
+    }
+  }
+  if (missing.length === 0) {
+    return;
+  }
+
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  msg = `Expected actual: "${format(actual)}" to include: "${
+    format(expected)
+  }"${msgSuffix}\nmissing: ${format(missing)}`;
+  throw new AssertionError(msg);
+}

package/src/deps/jsr.io/@std/assert/1.0.16/assert.ts

@@ -0,0 +1,23 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assert } from "@std/assert";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new AssertionError(msg);
+  }
+}

package/src/deps/jsr.io/@std/assert/1.0.16/assertion_error.ts

@@ -0,0 +1,31 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export class AssertionError extends Error {
+  /** Constructs a new instance.
+   *
+   * @param message The error message.
+   * @param options Additional options. This argument is still unstable. It may change in the future release.
+   */
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "AssertionError";
+  }
+}

package/src/deps/jsr.io/@std/assert/1.0.16/equal.ts

@@ -0,0 +1,218 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import * as dntShim from "../../../../../_dnt.shims.js";
+
+
+type KeyedCollection = Set<unknown> | Map<unknown, unknown>;
+function isKeyedCollection(x: unknown): x is KeyedCollection {
+  return x instanceof Set || x instanceof Map;
+}
+
+function prototypesEqual(a: object, b: object) {
+  const pa = Object.getPrototypeOf(a);
+  const pb = Object.getPrototypeOf(b);
+  return pa === pb ||
+    pa === Object.prototype && pb === null ||
+    pa === null && pb === Object.prototype;
+}
+
+function isBasicObjectOrArray(obj: object) {
+  const proto = Object.getPrototypeOf(obj);
+  return proto === null || proto === Object.prototype ||
+    proto === Array.prototype;
+}
+
+// Slightly faster than Reflect.ownKeys in V8 as of 12.9.202.13-rusty (2024-10-28)
+function ownKeys(obj: object) {
+  return [
+    ...Object.getOwnPropertyNames(obj),
+    ...Object.getOwnPropertySymbols(obj),
+  ];
+}
+
+function getKeysDeep(obj: object) {
+  const keys = new Set<string | symbol>();
+
+  while (obj !== Object.prototype && obj !== Array.prototype && obj != null) {
+    for (const key of ownKeys(obj)) {
+      keys.add(key);
+    }
+    obj = Object.getPrototypeOf(obj);
+  }
+
+  return keys;
+}
+
+// deno-lint-ignore no-explicit-any
+const Temporal = (dntShim.dntGlobalThis as any).Temporal ?? Object.create(null);
+
+/** A non-exhaustive list of prototypes that can be accurately fast-path compared with `String(instance)` */
+const stringComparablePrototypes = new Set<unknown>(
+  [
+    Intl.Locale,
+    RegExp,
+    Temporal.Duration,
+    Temporal.Instant,
+    Temporal.PlainDate,
+    Temporal.PlainDateTime,
+    Temporal.PlainTime,
+    Temporal.PlainYearMonth,
+    Temporal.PlainMonthDay,
+    Temporal.ZonedDateTime,
+    URL,
+    URLSearchParams,
+  ].filter((x) => x != null).map((x) => x.prototype),
+);
+
+function isPrimitive(x: unknown) {
+  return typeof x === "string" ||
+    typeof x === "number" ||
+    typeof x === "boolean" ||
+    typeof x === "bigint" ||
+    typeof x === "symbol" ||
+    x == null;
+}
+
+type TypedArray = Pick<Uint8Array | BigUint64Array, "length" | number>;
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+function compareTypedArrays(a: TypedArray, b: TypedArray) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < b.length; i++) {
+    if (!sameValueZero(a[i], b[i])) return false;
+  }
+  return true;
+}
+
+/** Check both strict equality (`0 == -0`) and `Object.is` (`NaN == NaN`) */
+function sameValueZero(a: unknown, b: unknown) {
+  return a === b || Object.is(a, b);
+}
+
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param a The actual value
+ * @param b The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
+ * ```
+ */
+export function equal(a: unknown, b: unknown): boolean {
+  const seen = new Map<unknown, unknown>();
+  return (function compare(a: unknown, b: unknown): boolean {
+    if (sameValueZero(a, b)) return true;
+    if (isPrimitive(a) || isPrimitive(b)) return false;
+
+    if (a instanceof Date && b instanceof Date) {
+      return Object.is(a.getTime(), b.getTime());
+    }
+    if (a && typeof a === "object" && b && typeof b === "object") {
+      if (!prototypesEqual(a, b)) {
+        return false;
+      }
+      if (a instanceof TypedArray) {
+        return compareTypedArrays(a as TypedArray, b as TypedArray);
+      }
+      if (
+        a instanceof ArrayBuffer ||
+        (globalThis.SharedArrayBuffer && a instanceof SharedArrayBuffer)
+      ) {
+        return compareTypedArrays(
+          new Uint8Array(a),
+          new Uint8Array(b as ArrayBuffer | SharedArrayBuffer),
+        );
+      }
+      if (a instanceof WeakMap) {
+        throw new TypeError("Cannot compare WeakMap instances");
+      }
+      if (a instanceof WeakSet) {
+        throw new TypeError("Cannot compare WeakSet instances");
+      }
+      if (a instanceof WeakRef) {
+        return compare(a.deref(), (b as WeakRef<WeakKey>).deref());
+      }
+      if (seen.get(a) === b) {
+        return true;
+      }
+      if (Object.keys(a).length !== Object.keys(b).length) {
+        return false;
+      }
+      seen.set(a, b);
+      if (isKeyedCollection(a) && isKeyedCollection(b)) {
+        if (a.size !== b.size) {
+          return false;
+        }
+
+        const aKeys = [...a.keys()];
+        const primitiveKeysFastPath = aKeys.every(isPrimitive);
+        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;
+      }
+
+      let keys: Iterable<string | symbol>;
+
+      if (isBasicObjectOrArray(a)) {
+        // fast path
+        keys = ownKeys({ ...a, ...b });
+      } else if (stringComparablePrototypes.has(Object.getPrototypeOf(a))) {
+        // medium path
+        return String(a) === String(b);
+      } else {
+        // slow path
+        keys = getKeysDeep(a).union(getKeysDeep(b));
+      }
+
+      for (const key of keys) {
+        type Key = keyof typeof a;
+        if (!compare(a[key as Key], b[key as Key])) {
+          return false;
+        }
+        if (((key in a) && (!(key in b))) || ((key in b) && (!(key in a)))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  })(a, b);
+}

package/src/deps/jsr.io/@std/assert/1.0.16/equals.ts

@@ -0,0 +1,66 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { equal } from "./equal.js";
+import { buildMessage } from "../../internal/1.0.12/build_message.js";
+import { diff } from "../../internal/1.0.12/diff.js";
+import { diffStr } from "../../internal/1.0.12/diff_str.js";
+import { format } from "../../internal/1.0.12/format.js";
+
+import { AssertionError } from "./assertion_error.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.
+ *
+ * Note: When comparing `Blob` objects, you should first convert them to
+ * `Uint8Array` using the `Blob.bytes()` method and then compare their
+ * contents.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
+ * ```
+ * @example Compare `Blob` objects
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * const bytes1 = await new Blob(["foo"]).bytes();
+ * const bytes2 = await new Blob(["foo"]).bytes();
+ *
+ * assertEquals(bytes1, bytes2);
+ * ```
+ *
+ * @typeParam T The type of the values to compare. This is usually inferred.
+ * @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 assertEquals<T>(
+  actual: T,
+  expected: T,
+  msg?: string,
+) {
+  if (equal(actual, expected)) {
+    return;
+  }
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  let message = `Values are not equal${msgSuffix}`;
+
+  const actualString = format(actual);
+  const expectedString = format(expected);
+  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 }, arguments[3])
+    .join("\n");
+  message = `${message}\n${diffMsg}`;
+  throw new AssertionError(message);
+}

package/src/deps/jsr.io/@std/assert/1.0.16/exists.ts

@@ -0,0 +1,31 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertExists } from "@std/assert";
+ *
+ * assertExists("something"); // Doesn't throw
+ * assertExists(undefined); // Throws
+ * ```
+ *
+ * @typeParam T The type of the actual value.
+ * @param actual The actual value to check.
+ * @param msg The optional message to include in the error if the assertion fails.
+ */
+export function assertExists<T>(
+  actual: T,
+  msg?: string,
+): asserts actual is NonNullable<T> {
+  if (actual === undefined || actual === null) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg =
+      `Expected actual: "${actual}" to not be null or undefined${msgSuffix}`;
+    throw new AssertionError(msg);
+  }
+}

package/src/deps/jsr.io/@std/assert/1.0.16/fail.ts

@@ -0,0 +1,21 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Forcefully throws a failed assertion.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { fail } from "@std/assert";
+ *
+ * fail("Deliberately failed!"); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export function fail(msg?: string): never {
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  throw new AssertionError(`Failed assertion${msgSuffix}`);
+}

package/src/deps/jsr.io/@std/assert/1.0.16/false.ts

@@ -0,0 +1,26 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/** Assertion condition for {@linkcode assertFalse}. */
+export type Falsy = false | 0 | 0n | "" | null | undefined;
+
+/**
+ * Make an assertion, error will be thrown if `expr` have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertFalse } from "@std/assert";
+ *
+ * assertFalse(false); // Doesn't throw
+ * assertFalse(true); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertFalse(expr: unknown, msg = ""): asserts expr is Falsy {
+  if (expr) {
+    throw new AssertionError(msg);
+  }
+}

package/src/deps/jsr.io/@std/assert/1.0.16/greater.ts

@@ -0,0 +1,30 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { format } from "../../internal/1.0.12/format.js";
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion that `actual` is greater than `expected`.
+ * If not then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertGreater } from "@std/assert";
+ *
+ * assertGreater(2, 1); // Doesn't throw
+ * assertGreater(1, 1); // Throws
+ * assertGreater(0, 1); // Throws
+ * ```
+ *
+ * @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 assertGreater<T>(actual: T, expected: T, msg?: string) {
+  if (actual > expected) return;
+
+  const actualString = format(actual);
+  const expectedString = format(expected);
+  throw new AssertionError(msg ?? `Expect ${actualString} > ${expectedString}`);
+}

package/src/deps/jsr.io/@std/assert/1.0.16/greater_or_equal.ts

@@ -0,0 +1,36 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { format } from "../../internal/1.0.12/format.js";
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion that `actual` is greater than or equal to `expected`.
+ * If not then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertGreaterOrEqual } from "@std/assert";
+ *
+ * assertGreaterOrEqual(2, 1); // Doesn't throw
+ * assertGreaterOrEqual(1, 1); // Doesn't throw
+ * assertGreaterOrEqual(0, 1); // Throws
+ * ```
+ *
+ * @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 assertGreaterOrEqual<T>(
+  actual: T,
+  expected: T,
+  msg?: string,
+) {
+  if (actual >= expected) return;
+
+  const actualString = format(actual);
+  const expectedString = format(expected);
+  throw new AssertionError(
+    msg ?? `Expect ${actualString} >= ${expectedString}`,
+  );
+}

package/src/deps/jsr.io/@std/assert/1.0.16/instance_of.ts

@@ -0,0 +1,64 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/** Any constructor */
+// deno-lint-ignore no-explicit-any
+export type AnyConstructor = new (...args: any[]) => any;
+/** Gets constructor type */
+export type GetConstructorType<T extends AnyConstructor> = InstanceType<T>;
+
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertInstanceOf } from "@std/assert";
+ *
+ * assertInstanceOf(new Date(), Date); // Doesn't throw
+ * assertInstanceOf(new Date(), Number); // Throws
+ * ```
+ *
+ * @typeParam T The expected type of the object.
+ * @param actual The object to check.
+ * @param expectedType The expected class constructor.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertInstanceOf<
+  // deno-lint-ignore no-explicit-any
+  T extends abstract new (...args: any[]) => any,
+>(
+  actual: unknown,
+  expectedType: T,
+  msg = "",
+): asserts actual is InstanceType<T> {
+  if (actual instanceof expectedType) return;
+
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  const expectedTypeStr = expectedType.name;
+
+  let actualTypeStr = "";
+  if (actual === null) {
+    actualTypeStr = "null";
+  } else if (actual === undefined) {
+    actualTypeStr = "undefined";
+  } else if (typeof actual === "object") {
+    actualTypeStr = actual.constructor?.name ?? "Object";
+  } else {
+    actualTypeStr = typeof actual;
+  }
+
+  if (expectedTypeStr === actualTypeStr) {
+    msg =
+      `Expected object to be an instance of "${expectedTypeStr}"${msgSuffix}`;
+  } else if (actualTypeStr === "function") {
+    msg =
+      `Expected object to be an instance of "${expectedTypeStr}" but was not an instanced object${msgSuffix}`;
+  } else {
+    msg =
+      `Expected object to be an instance of "${expectedTypeStr}" but was "${actualTypeStr}"${msgSuffix}`;
+  }
+
+  throw new AssertionError(msg);
+}

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

@@ -0,0 +1,65 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+import { stripAnsiCode } from "../../internal/1.0.12/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);
+  }
+}