veryfront 0.1.324 → 0.1.327

package/src/deps/esm.sh/react-dom@19.2.4/client.d.ts

@@ -0,0 +1,105 @@
+/**
+ * WARNING: This entrypoint is only available starting with `react-dom@18.0.0-rc.1`
+ */
+
+// See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
+
+import React = require("https://esm.sh/@types/react@19.2.14/index.d.ts");
+
+export {};
+
+declare const REACT_FORM_STATE_SIGIL: unique symbol;
+export interface ReactFormState {
+    [REACT_FORM_STATE_SIGIL]: never;
+}
+
+export interface HydrationOptions {
+    formState?: ReactFormState | null;
+    /**
+     * Prefix for `useId`.
+     */
+    identifierPrefix?: string;
+    onUncaughtError?:
+        | ((error: unknown, errorInfo: { componentStack?: string | undefined }) => void)
+        | undefined;
+    onRecoverableError?: (error: unknown, errorInfo: ErrorInfo) => void;
+    onCaughtError?:
+        | ((
+            error: unknown,
+            errorInfo: {
+                componentStack?: string | undefined;
+                errorBoundary?: React.Component<unknown> | undefined;
+            },
+        ) => void)
+        | undefined;
+}
+
+export interface RootOptions {
+    /**
+     * Prefix for `useId`.
+     */
+    identifierPrefix?: string;
+    onUncaughtError?:
+        | ((error: unknown, errorInfo: { componentStack?: string | undefined }) => void)
+        | undefined;
+    onRecoverableError?: (error: unknown, errorInfo: ErrorInfo) => void;
+    onCaughtError?:
+        | ((
+            error: unknown,
+            errorInfo: {
+                componentStack?: string | undefined;
+                errorBoundary?: React.Component<unknown> | undefined;
+            },
+        ) => void)
+        | undefined;
+}
+
+export interface ErrorInfo {
+    componentStack?: string;
+}
+
+export interface Root {
+    render(children: React.ReactNode): void;
+    unmount(): void;
+}
+
+/**
+ * Different release channels declare additional types of ReactNode this particular release channel accepts.
+ * App or library types should never augment this interface.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_CREATE_ROOT_CONTAINERS {}
+
+export type Container =
+    | Element
+    | DocumentFragment
+    | Document
+    | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_CREATE_ROOT_CONTAINERS[
+        keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_CREATE_ROOT_CONTAINERS
+    ];
+
+/**
+ * createRoot lets you create a root to display React components inside a browser DOM node.
+ *
+ * @see {@link https://react.dev/reference/react-dom/client/createRoot API Reference for `createRoot`}
+ */
+export function createRoot(container: Container, options?: RootOptions): Root;
+
+/**
+ * Same as `createRoot()`, but is used to hydrate a container whose HTML contents were rendered by ReactDOMServer.
+ *
+ * React will attempt to attach event listeners to the existing markup.
+ *
+ * **Example Usage**
+ *
+ * ```jsx
+ * hydrateRoot(document.querySelector('#root'), <App />)
+ * ```
+ *
+ * @see https://react.dev/reference/react-dom/client/hydrateRoot
+ */
+export function hydrateRoot(
+    container: Element | Document,
+    initialChildren: React.ReactNode,
+    options?: HydrationOptions,
+): Root;

package/src/deps/esm.sh/react-dom@19.2.4/client.js

@@ -0,0 +1,5 @@
+/* esm.sh - react-dom@19.2.4/client */
+import "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/react-dom.mjs";
+import "../scheduler@^0.27.0.js";
+export * from "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/client.mjs";
+export { default } from "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/client.mjs";

package/src/deps/esm.sh/scheduler@^0.27.0.d.ts

@@ -0,0 +1,30 @@
+// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+export type FrameCallbackType = (didTimeout: boolean) => FrameCallbackType | void;
+export interface CallbackNode {
+    callback: FrameCallbackType;
+    priorityLevel: number;
+    expirationTime: number;
+    next: CallbackNode | null;
+    prev: CallbackNode | null;
+}
+
+export const unstable_ImmediatePriority = 1;
+export const unstable_UserBlockingPriority = 2;
+export const unstable_NormalPriority = 3;
+export const unstable_IdlePriority = 5;
+export const unstable_LowPriority = 4;
+export function unstable_runWithPriority<T>(priorityLevel: number, eventHandler: () => T): T;
+export function unstable_scheduleCallback(
+    priorityLevel: number,
+    callback: FrameCallbackType,
+    options?: { delay?: number | undefined; timeout?: number | undefined },
+): CallbackNode;
+export function unstable_next<T>(eventHandler: () => T): T;
+export function unstable_cancelCallback(callbackNode: CallbackNode): void;
+export function unstable_wrapCallback(callback: FrameCallbackType): () => FrameCallbackType;
+export function unstable_getCurrentPriorityLevel(): number;
+export function unstable_shouldYield(): boolean;
+export function unstable_continueExecution(): void;
+export function unstable_pauseExecution(): void;
+export function unstable_getFirstCallbackNode(): CallbackNode | null;
+export function unstable_now(): number;

package/src/deps/esm.sh/scheduler@^0.27.0.js

@@ -0,0 +1,3 @@
+/* esm.sh - scheduler@0.27.0 */
+export * from "scheduler/es2022/scheduler.mjs";
+export { default } from "scheduler/es2022/scheduler.mjs";

package/src/deps/jsr.io/@std/assert/1.0.19/almost_equals.ts

@@ -0,0 +1,56 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers
+ * through a given tolerance. It can be used to take into account IEEE-754
+ * double-precision floating-point representation limitations. If the values
+ * are not almost equal then throw.
+ *
+ * The default tolerance is one hundred thousandth of a percent of the
+ * expected value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertAlmostEquals } from "@std/assert";
+ *
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(1e-8, 1e-9); // Throws
+ * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ *
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param tolerance The tolerance to consider the values almost equal. The
+ * default is one hundred thousandth of a percent of the expected value.
+ * @param msg The optional message to include in the error.
+ * @throws {AssertionError} If the values are not almost equal.
+ */
+export function assertAlmostEquals(
+  actual: number,
+  expected: number,
+  tolerance?: number,
+  msg?: string,
+) {
+  if (Object.is(actual, expected)) {
+    return;
+  }
+  const delta = Math.abs(expected - actual);
+  if (tolerance === undefined) {
+    tolerance = isFinite(expected) ? Math.abs(expected * 1e-7) : 1e-7;
+  }
+  if (delta <= tolerance) {
+    return;
+  }
+
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  const f = (n: number) => Number.isInteger(n) ? n : n.toExponential();
+  throw new AssertionError(
+    `Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
+delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`,
+  );
+}

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

@@ -0,0 +1,76 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { equal } from "./equal.js";
+import { format } from "../../internal/1.0.13/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;
+
+function isPrimitive(value: unknown): boolean {
+  return value === null ||
+    typeof value !== "object" && typeof value !== "function";
+}
+
+/**
+ * Asserts that `actual` contains all values in `expected`, using deep equality
+ * for non-primitive values.
+ *
+ * @example Usage with primitives
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2, 3], [2, 3]); // Passes
+ * assertArrayIncludes([1, 2, 3], [4]); // Throws
+ * ```
+ *
+ * @example Usage with objects (deep equality)
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([{ a: 1 }, { b: 2 }], [{ a: 1 }]); // Passes
+ * ```
+ *
+ * @typeParam T The element type of the arrays.
+ * @param actual The array-like object to search within.
+ * @param expected The values that must be present in `actual`.
+ * @param msg Optional message to display on failure.
+ * @throws {AssertionError} If any value in `expected` is not found in `actual`.
+ */
+export function assertArrayIncludes<T>(
+  actual: ArrayLikeArg<T>,
+  expected: ArrayLikeArg<T>,
+  msg?: string,
+): void {
+  const missing: unknown[] = [];
+  const expectedLen = expected.length;
+  const actualLen = actual.length;
+  for (let i = 0; i < expectedLen; i++) {
+    const item = expected[i];
+    let found: boolean;
+    if (isPrimitive(item)) {
+      // Fast path
+      found = Array.prototype.includes.call(actual, item);
+    } else {
+      found = false;
+      for (let j = 0; j < actualLen; j++) {
+        if (equal(item, actual[j])) {
+          found = true;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      missing.push(item);
+    }
+  }
+  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.19/assert.ts

@@ -0,0 +1,24 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion, an error will be thrown if `expr` does not have a 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.
+ * @throws {AssertionError} If `expr` is falsy.
+ */
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new AssertionError(msg);
+  }
+}

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

@@ -0,0 +1,31 @@
+// Copyright 2018-2026 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.19/equal.ts

@@ -0,0 +1,226 @@
+// Copyright 2018-2026 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.
+ *
+ * This function is based on value equality, but for some cases (such as data
+ * that can only be read asynchronously or function properties) value equality
+ * is not possible to determine. In such cases, reference equality is used
+ * instead, which may cause false negatives for objects such as `Blob`s or
+ * `Request`s.
+ *
+ * @param a The actual value
+ * @param b The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @throws {TypeError} If either value is a `WeakMap` or `WeakSet`.
+ *
+ * @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.19/equals.ts

@@ -0,0 +1,68 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { equal } from "./equal.js";
+import { buildMessage } from "../../internal/1.0.13/build_message.js";
+import { diff } from "../../internal/1.0.13/diff.js";
+import { diffStr } from "../../internal/1.0.13/diff_str.js";
+import { format } from "../../internal/1.0.13/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: This function is based on value equality, but for some cases (such as
+ * data that can only be read asynchronously or function properties) value
+ * equality is not possible to determine. In such cases, reference equality is
+ * used instead, which may cause false negatives for objects such as `Blob`s or
+ * `Request`s.
+ *
+ * @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.19/exists.ts

@@ -0,0 +1,31 @@
+// Copyright 2018-2026 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.19/fail.ts

@@ -0,0 +1,21 @@
+// Copyright 2018-2026 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}`);
+}