{
  "version": 3,
  "sources": ["../src/index.ts", "../src/assertjunky.ts"],
  "sourcesContent": ["export * from './assertjunky.js';\r\n", "/**\r\n * Simplified assert + route helpers.\r\n *\r\n * Focus:\r\n * - Core throwing assertions (`assert*`)\r\n * - `test()` \u2192 turn throwing assertion(s) into boolean\r\n * - `expect()` \u2192 run assertions over a value and return the value\r\n * - `fork()` / `forkAsync()` \u2192 attach pass/fail handlers\r\n * - `fn()` / `fnAsync()` \u2192 wrap a function so\r\n *   AssertError in the callback yields a default value.\r\n */\r\n\r\n// =====================\r\n// Error type\r\n// =====================\r\n\r\nexport class AssertError extends Error {\r\n  readonly code = 'ASSERT_FAILED' as const;\r\n  readonly info?: Record<string, unknown>;\r\n  constructor(message = 'Assertion failed', info?: Record<string, unknown>) {\r\n    super(message);\r\n    this.name = 'AssertError';\r\n    this.info = info;\r\n  }\r\n}\r\n\r\nexport type AssertErrorListener = (error: AssertError) => void;\r\n\r\nconst assertErrorListeners = new Set<AssertErrorListener>();\r\n\r\nexport const assertErrorEmitter = {\r\n  on(listener: AssertErrorListener) {\r\n    assertErrorListeners.add(listener);\r\n    return () => {\r\n      assertErrorListeners.delete(listener);\r\n    };\r\n  },\r\n  off(listener: AssertErrorListener) {\r\n    assertErrorListeners.delete(listener);\r\n  },\r\n  once(listener: AssertErrorListener) {\r\n    const wrapped: AssertErrorListener = (error) => {\r\n      assertErrorListeners.delete(wrapped);\r\n      listener(error);\r\n    };\r\n    assertErrorListeners.add(wrapped);\r\n    return () => {\r\n      assertErrorListeners.delete(wrapped);\r\n    };\r\n  },\r\n  emit(error: AssertError) {\r\n    for (const listener of Array.from(assertErrorListeners)) {\r\n      try {\r\n        listener(error);\r\n      } catch {\r\n        // ignore listener errors to keep assertion semantics stable\r\n      }\r\n    }\r\n    return error;\r\n  },\r\n} as const;\r\n\r\nfunction emitAssertError(error: AssertError): AssertError {\r\n  return assertErrorEmitter.emit(error);\r\n}\r\n\r\n// =====================\r\n// Core assert\r\n// =====================\r\n\r\nexport function assert(condition: unknown, message = 'Assertion failed', info?: Record<string, unknown>): asserts condition {\r\n  if (!condition) throw emitAssertError(new AssertError(message, info));\r\n}\r\n\r\n// =====================\r\n// Assertion helpers (type guards that throw)\r\n// =====================\r\nexport function isFunction(x: unknown): x is (...args: unknown[]) => unknown {\r\n  return typeof x === 'function';\r\n}\r\n\r\n/** Returns true if x is Promise-like (has a then method). */\r\nexport function isPromiseLike<T = unknown>(x: unknown): x is PromiseLike<T> {\r\n  return x != null && typeof (x as Promise<unknown>).then === 'function';\r\n}\r\n\r\nexport function assertString(x: unknown, message = 'Expected string'): asserts x is string {\r\n  assert(typeof x === 'string', message);\r\n}\r\n\r\nexport function assertNumber(x: unknown, message = 'Expected finite number'): asserts x is number {\r\n  assert(typeof x === 'number' && Number.isFinite(x), message);\r\n}\r\n\r\nexport function assertBoolean(x: unknown, message = 'Expected boolean'): asserts x is boolean {\r\n  assert(typeof x === 'boolean', message);\r\n}\r\n\r\nexport function assertArray<T = unknown>(x: unknown, message = 'Expected array'): asserts x is T[] {\r\n  assert(Array.isArray(x), message);\r\n}\r\n\r\nexport function assertObject(x: unknown, message = 'Expected object'): asserts x is Record<string, unknown> {\r\n  // Accept arrays as objects; only exclude null.\r\n  assert(typeof x === 'object' && x !== null, message);\r\n}\r\n\r\n/** Asserts that x is a plain (non-array) object. */\r\nexport function assertPlainObject(x: unknown, message = 'Expected plain object'): asserts x is Record<string, unknown> {\r\n  assert(typeof x === 'object' && x !== null && !Array.isArray(x), message);\r\n}\r\n\r\n/** Ensure a plain (non-array) object and return it typed. */\r\nexport function expectPlainObject(x: unknown, message?: string): Record<string, unknown> {\r\n  assertPlainObject(x, message ?? 'Expected plain object');\r\n  return x as Record<string, unknown>;\r\n}\r\n\r\nexport function assertDate(x: unknown, message = 'Expected valid Date'): asserts x is Date {\r\n  assert(x instanceof Date && !Number.isNaN(x.getTime?.()), message);\r\n}\r\n\r\nexport function assertNonNull<T>(x: T | null, message = 'Expected non-null'): asserts x is T {\r\n  assert(x !== null, message);\r\n}\r\n\r\nexport function assertExists<T>(x: T | null | undefined, message = 'Expected value (not null/undefined)'): asserts x is T {\r\n  assert(x !== null && x !== undefined, message);\r\n}\r\n/**\r\n * Asserts that x is a function.\r\n *\r\n * Narrowing:\r\n * - On success, narrows x to (...args:any[]) => unknown.\r\n */\r\nexport function assertFunction(x: unknown, message = 'Expected function', info?: Record<string, unknown>): asserts x is (...args: unknown[]) => unknown {\r\n  assert(isFunction(x), message, { ...info, got: typeof x });\r\n}\r\nexport function isDefined<T>(x: T | undefined): x is T {\r\n  return x !== undefined;\r\n}\r\n\r\nexport function isNonNull<T>(x: T | null): x is T {\r\n  return x !== null;\r\n}\r\nexport function isPresent<T>(x: T | null | undefined): x is T {\r\n  return x !== null && x !== undefined;\r\n}\r\n\r\nexport function isNotNil<T>(x: T | null | undefined): x is T {\r\n  return x !== null && x !== undefined;\r\n}\r\n\r\n/**\r\n * Asserts that x is Promise-like (has a then method).\r\n *\r\n * Narrowing:\r\n * - On success, narrows x to PromiseLike<unknown>.\r\n */\r\nexport function assertPromiseLike<T = unknown>(x: unknown, message = 'Expected Promise-like', info?: Record<string, unknown>): asserts x is PromiseLike<T> {\r\n  assert(isPromiseLike<T>(x), message, { ...info, got: typeof x });\r\n}\r\n\r\nexport function assertDefined<T>(x: T | undefined, message = 'Expected defined', info?: Record<string, unknown>): asserts x is T {\r\n  assert(isDefined(x), message, info);\r\n}\r\n\r\nexport function assertPresent<T>(x: T | null | undefined, message = 'Expected value present', info?: Record<string, unknown>): asserts x is T {\r\n  assert(isPresent(x), message, info);\r\n}\r\n\r\n/** Assert that a value is not null or undefined (aka not nil). */\r\nexport function assertNotNil<T>(x: T | null | undefined, message = 'Expected value not nil'): asserts x is T {\r\n  assert(isNotNil(x), message);\r\n}\r\n\r\n// =====================\r\n// expect() and convenience expect* helpers\r\n// =====================\r\n\r\n/**\r\n * Expect overloads:\r\n * - Factory: given an assertion function, return an `expectX`-style function that\r\n *   runs the assertion and returns the narrowed value.\r\n * - Value mode: run one or more assertion functions against a value and return the value.\r\n */\r\nexport function expect<T, A extends unknown[]>(assertFn: (x: unknown, ...args: A) => asserts x is T): (x: unknown, ...args: A) => T;\r\nexport function expect<V>(value: V, ...assertions: Array<(v: V) => void>): V;\r\nexport function expect(...args: unknown[]): unknown {\r\n  const first = args[0] as unknown;\r\n  if (typeof first === 'function') {\r\n    const assertFn = first as (x: unknown, ...rest: unknown[]) => void;\r\n    return (x: unknown, ...rest: unknown[]) => {\r\n      assertFn(x, ...rest);\r\n      return x as unknown;\r\n    };\r\n  }\r\n  const value = first as unknown;\r\n  const assertions = args.slice(1) as Array<(v: unknown) => void>;\r\n  for (const a of assertions) a(value);\r\n  return value;\r\n}\r\n\r\nexport function expectString(x: unknown, message?: string): string {\r\n  assertString(x, message);\r\n  return x as string;\r\n}\r\nexport function expectNumber(x: unknown, message?: string): number {\r\n  assertNumber(x, message);\r\n  return x as number;\r\n}\r\nexport function expectBoolean(x: unknown, message?: string): boolean {\r\n  assertBoolean(x, message);\r\n  return x as boolean;\r\n}\r\nexport function expectArray<T = unknown>(x: unknown, message?: string): T[] {\r\n  assertArray<T>(x, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayNotEmpty<T = unknown>(x: unknown, message?: string): T[] {\r\n  assertArrayNotEmpty<T>(x, message);\r\n  return x as T[];\r\n}\r\nexport function expectObject(x: unknown, message?: string): Record<string, unknown> {\r\n  assertObject(x, message);\r\n  return x as Record<string, unknown>;\r\n}\r\nexport function expectDate(x: unknown, message?: string): Date {\r\n  assertDate(x, message);\r\n  return x as Date;\r\n}\r\nexport function expectNonNull<T>(x: T | null, message?: string): T {\r\n  assertNonNull(x, message);\r\n  return x as T;\r\n}\r\nexport function expectExists<T>(x: T | null | undefined, message?: string): T {\r\n  assertExists(x, message);\r\n  return x as T;\r\n}\r\n\r\n// ---- Additional expect helpers ----\r\n\r\nexport function expectFunction<F extends (...args: unknown[]) => unknown>(x: unknown, message?: string): F {\r\n  assertFunction(x, message);\r\n  return x as F;\r\n}\r\n\r\nexport function expectPromiseLike<T = unknown>(x: unknown, message?: string): PromiseLike<T> {\r\n  assertPromiseLike<T>(x, message);\r\n  return x as PromiseLike<T>;\r\n}\r\n\r\nexport function expectDefined<T>(x: T | undefined, message?: string): T {\r\n  assertDefined(x, message);\r\n  return x as T;\r\n}\r\n\r\nexport function expectPresent<T>(x: T | null | undefined, message?: string): T {\r\n  assertPresent(x, message);\r\n  return x as T;\r\n}\r\n\r\n/** Ensure value is not null or undefined and return it. */\r\nexport function expectNotNil<T>(x: T | null | undefined, message?: string): T {\r\n  assertNotNil(x, message);\r\n  return x as T;\r\n}\r\n\r\nexport function expectTruthy<T>(x: T, message?: string): Exclude<T, null | undefined | false | 0 | ''> {\r\n  assertTruthy(x, message);\r\n  return x as Exclude<T, null | undefined | false | 0 | ''>;\r\n}\r\n\r\nexport function expectFalsey(x: unknown, message?: string): null | undefined | false | 0 | '' {\r\n  assertFalsey(x, message);\r\n  return x as null | undefined | false | 0 | '';\r\n}\r\n\r\n// String expects\r\nexport function expectStringLength(x: unknown, len: number, message?: string): string {\r\n  assertStringLength(x, len, message);\r\n  return x as string;\r\n}\r\nexport function expectStringLengthAtLeast(x: unknown, n: number, message?: string): string {\r\n  assertStringLengthAtLeast(x, n, message);\r\n  return x as string;\r\n}\r\nexport function expectStringLengthAtMost(x: unknown, n: number, message?: string): string {\r\n  assertStringLengthAtMost(x, n, message);\r\n  return x as string;\r\n}\r\nexport function expectStringLengthBetween(x: unknown, min: number, max: number, message?: string): string {\r\n  assertStringLengthBetween(x, min, max, message);\r\n  return x as string;\r\n}\r\nexport function expectStringContains(x: unknown, needle: string | RegExp, message?: string): string {\r\n  assertStringContains(x, needle, message);\r\n  return x as string;\r\n}\r\nexport function expectStringStartsWith(x: unknown, prefix: string, message?: string): string {\r\n  assertStringStartsWith(x, prefix, message);\r\n  return x as string;\r\n}\r\nexport function expectStringEndsWith(x: unknown, suffix: string, message?: string): string {\r\n  assertStringEndsWith(x, suffix, message);\r\n  return x as string;\r\n}\r\nexport function expectStringMatches(x: unknown, re: RegExp, message?: string): string {\r\n  assertStringMatches(x, re, message);\r\n  return x as string;\r\n}\r\nexport function expectStringEqualsIgnoreCase(x: unknown, expected: string, message?: string): string {\r\n  assertStringEqualsIgnoreCase(x, expected, message);\r\n  return x as string;\r\n}\r\nexport function expectStringIncludesAny(x: unknown, ...needles: string[]): string {\r\n  assertStringIncludesAny(x, ...needles);\r\n  return x as string;\r\n}\r\nexport function expectStringIncludesAll(x: unknown, ...needles: string[]): string {\r\n  assertStringIncludesAll(x, ...needles);\r\n  return x as string;\r\n}\r\nexport function expectStringIsJSON(x: unknown, message?: string): string {\r\n  assertStringIsJSON(x, message);\r\n  return x as string;\r\n}\r\nexport function expectStringTrimmedNotEmpty(x: unknown, message?: string): string {\r\n  assertStringTrimmedNotEmpty(x, message);\r\n  return x as string;\r\n}\r\n\r\n// Non-empty expects\r\nexport function expectNonEmptyString(x: unknown, message?: string): string {\r\n  assertString(x, message);\r\n  assert((x as string).length > 0, message ?? 'Expected non-empty string');\r\n  return x as string;\r\n}\r\nexport function expectNonEmptyArray<T = unknown>(x: unknown, message?: string): T[] {\r\n  assertArrayNotEmpty<T>(x, message);\r\n  return x as T[];\r\n}\r\n\r\n// Number expects\r\nexport function expectNumberGreaterThan(x: unknown, n: number, message?: string): number {\r\n  assertNumberGreaterThan(x, n, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberGreaterOrEqual(x: unknown, n: number, message?: string): number {\r\n  assertNumberGreaterOrEqual(x, n, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberLessThan(x: unknown, n: number, message?: string): number {\r\n  assertNumberLessThan(x, n, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberLessOrEqual(x: unknown, n: number, message?: string): number {\r\n  assertNumberLessOrEqual(x, n, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberBetween(x: unknown, min: number, max: number, message?: string): number {\r\n  assertNumberBetween(x, min, max, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberNotZero(x: unknown, message?: string): number {\r\n  assertNumberNotZero(x, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberPositive(x: unknown, message?: string): number {\r\n  assertNumberPositive(x, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberNonNegative(x: unknown, message?: string): number {\r\n  assertNumberNonNegative(x, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberNegative(x: unknown, message?: string): number {\r\n  assertNumberNegative(x, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberNonPositive(x: unknown, message?: string): number {\r\n  assertNumberNonPositive(x, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberInteger(x: unknown, message?: string): number {\r\n  assertNumberInteger(x, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberSafeInteger(x: unknown, message?: string): number {\r\n  assertNumberSafeInteger(x, message);\r\n  return x as number;\r\n}\r\nexport function expectNumberApproxEquals(x: unknown, expected: number, epsilon?: number, message?: string): number {\r\n  assertNumberApproxEquals(x, expected, epsilon, message);\r\n  return x as number;\r\n}\r\n\r\n// Array expects\r\nexport function expectArrayLength<T = unknown>(x: unknown, len: number, message?: string): T[] {\r\n  assertArrayLength<T>(x, len, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayHasAnyOf<T = unknown>(x: unknown, items: string[], message?: string): T[] {\r\n  assertArrayHasAnyOf<T>(x, items, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayHasEveryOf<T = unknown>(x: unknown, items: string[], message?: string): T[] {\r\n  assertArrayHasEveryOf<T>(x, items, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayItemIsBoolean<T = unknown>(x: unknown, i: number, message?: string): T[] {\r\n  assertArrayItemIsBoolean<T>(x, i, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayItemIsString<T = unknown>(x: unknown, i: number, message?: string): T[] {\r\n  assertArrayItemIsString<T>(x, i, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayItemIsNumber<T = unknown>(x: unknown, i: number, message?: string): T[] {\r\n  assertArrayItemIsNumber<T>(x, i, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayItemIsObject<T = unknown>(x: unknown, i: number, message?: string): T[] {\r\n  assertArrayItemIsObject<T>(x, i, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayIncludesString<T = unknown>(x: unknown, needle: string, message?: string): T[] {\r\n  assertArrayIncludesString<T>(x, needle, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayIncludesNumber<T = unknown>(x: unknown, needle: number, message?: string): T[] {\r\n  assertArrayIncludesNumber<T>(x, needle, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayIncludesObject<T = unknown>(x: unknown, needle: Record<string, unknown>, message?: string): T[] {\r\n  assertArrayIncludesObject<T>(x, needle, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayOnlyHasObjects(x: unknown, message?: string): Record<string, unknown>[] {\r\n  assertArrayOnlyHasObjects(x, message);\r\n  return x as Record<string, unknown>[];\r\n}\r\nexport function expectArrayOnlyHasStrings(x: unknown, message?: string): string[] {\r\n  assertArrayOnlyHasStrings(x, message);\r\n  return x as string[];\r\n}\r\nexport function expectArrayOnlyHasNumbers(x: unknown, message?: string): number[] {\r\n  assertArrayOnlyHasNumbers(x, message);\r\n  return x as number[];\r\n}\r\nexport function expectArrayEveryIsFalsy<T = unknown>(x: unknown, message?: string): T[] {\r\n  assertArrayEveryIsFalsy<T>(x, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayEveryIsTruthy<T = unknown>(x: unknown, message?: string): T[] {\r\n  assertArrayEveryIsTruthy<T>(x, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayUnique<T = unknown>(x: unknown, message?: string): T[] {\r\n  assertArrayUnique<T>(x, message);\r\n  return x as T[];\r\n}\r\nexport function expectArrayIncludesCondition<T = unknown>(x: unknown, predicate: (item: unknown) => boolean, message?: string): T[] {\r\n  assertArrayIncludesCondition<T>(x, predicate, message);\r\n  return x as T[];\r\n}\r\n\r\n// Object expects\r\nexport function expectHasKey<O extends Record<string, unknown>, K extends string>(obj: unknown, key: K, message?: string): O & Record<K, unknown> {\r\n  assertHasKey<O, K>(obj, key, message);\r\n  return obj as O & Record<K, unknown>;\r\n}\r\nexport function expectHasKeys<O extends Record<string, unknown>, const K extends readonly string[]>(obj: unknown, ...keys: K): O & { [P in K[number]]: unknown } {\r\n  assertHasKeys<O, K>(obj, ...keys);\r\n  return obj as O & { [P in K[number]]: unknown };\r\n}\r\nexport function expectKeyEquals<O extends Record<string, unknown>, K extends keyof O, E>(obj: unknown, key: K, expected: E, message?: string): O & Record<K, E> {\r\n  assertKeyEquals<O, K, E>(obj, key, expected, message);\r\n  return obj as O & Record<K, E>;\r\n}\r\nexport function expectSameKeys(obj: unknown, expected: Record<string, unknown>, message?: string): Record<string, unknown> {\r\n  assertSameKeys(obj, expected, message);\r\n  return obj as Record<string, unknown>;\r\n}\r\nexport function expectAllKeysFalsy(obj: unknown, message?: string): Record<string, unknown> {\r\n  assertAllKeysFalsy(obj, message);\r\n  return obj as Record<string, unknown>;\r\n}\r\nexport function expectAllKeysSet(obj: unknown, message?: string): Record<string, unknown> {\r\n  assertAllKeysSet(obj, message);\r\n  return obj as Record<string, unknown>;\r\n}\r\nexport function expectAnyKeyNull(obj: unknown, message?: string): Record<string, unknown> {\r\n  assertAnyKeyNull(obj, message);\r\n  return obj as Record<string, unknown>;\r\n}\r\n\r\n// Element expects\r\nexport function expectElement(x: unknown, message?: string): Element {\r\n  assertElement(x, message);\r\n  return x as Element;\r\n}\r\nexport function expectHTMLElement(x: unknown, message?: string): HTMLElement {\r\n  assertHTMLElement(x, message);\r\n  return x as HTMLElement;\r\n}\r\n\r\nexport function expectElementTags<K extends keyof HTMLElementTagNameMap>(x: unknown, tags: readonly K[], message?: string): HTMLElementTagNameMap[K] {\r\n  const el = expectElement(x, message);\r\n  const t = el.tagName.toLowerCase() as K;\r\n\r\n  if (!tags.includes(t)) {\r\n    throw new Error(message ?? `Expected one of ${tags.join(', ')}, got <${t}>`);\r\n  }\r\n  return el as HTMLElementTagNameMap[K];\r\n}\r\n\r\nexport const expectDiv = (x: unknown, m?: string) => expectElementTags(x, ['div'], m);\r\n\r\nexport const expectSpan = (x: unknown, m?: string) => expectElementTags(x, ['span'], m);\r\n\r\nexport const expectP = (x: unknown, m?: string) => expectElementTags(x, ['p'], m);\r\n\r\nexport const expectUl = (x: unknown, m?: string) => expectElementTags(x, ['ul'], m);\r\n\r\nexport const expectOl = (x: unknown, m?: string) => expectElementTags(x, ['ol'], m);\r\n\r\nexport const expectLi = (x: unknown, m?: string) => expectElementTags(x, ['li'], m);\r\n\r\nexport const expectForm = (x: unknown, m?: string) => expectElementTags(x, ['form'], m);\r\n\r\nexport const expectInput = (x: unknown, m?: string) => expectElementTags(x, ['input'], m);\r\n\r\nexport const expectTextarea = (x: unknown, m?: string) => expectElementTags(x, ['textarea'], m);\r\n\r\nexport const expectButton = (x: unknown, m?: string) => expectElementTags(x, ['button'], m);\r\n\r\nexport const expectSelect = (x: unknown, m?: string) => expectElementTags(x, ['select'], m);\r\n\r\nexport const expectOption = (x: unknown, m?: string) => expectElementTags(x, ['option'], m);\r\n\r\nexport const expectLabel = (x: unknown, m?: string) => expectElementTags(x, ['label'], m);\r\n\r\nexport const expectImg = (x: unknown, m?: string) => expectElementTags(x, ['img'], m);\r\n\r\nexport const expectVideo = (x: unknown, m?: string) => expectElementTags(x, ['video'], m);\r\n\r\nexport const expectAudio = (x: unknown, m?: string) => expectElementTags(x, ['audio'], m);\r\n\r\nexport const expectCanvas = (x: unknown, m?: string) => expectElementTags(x, ['canvas'], m);\r\n\r\nexport const expectTable = (x: unknown, m?: string) => expectElementTags(x, ['table'], m);\r\n\r\nexport const expectTHead = (x: unknown, m?: string) => expectElementTags(x, ['thead'], m);\r\n\r\nexport const expectTBody = (x: unknown, m?: string) => expectElementTags(x, ['tbody'], m);\r\n\r\nexport const expectTFoot = (x: unknown, m?: string) => expectElementTags(x, ['tfoot'], m);\r\n\r\nexport const expectTr = (x: unknown, m?: string) => expectElementTags(x, ['tr'], m);\r\n\r\nexport const expectTh = (x: unknown, m?: string) => expectElementTags(x, ['th'], m);\r\n\r\nexport const expectTd = (x: unknown, m?: string) => expectElementTags(x, ['td'], m);\r\n\r\nexport function expectSvgElement(x: unknown, message?: string): SVGElement {\r\n  if (!(x instanceof SVGElement)) {\r\n    throw new Error(message ?? 'Expected SVGElement');\r\n  }\r\n  return x;\r\n}\r\n\r\nexport function expectSvgTag<K extends keyof SVGElementTagNameMap>(x: unknown, tag: K, message?: string): SVGElementTagNameMap[K] {\r\n  const el = expectSvgElement(x, message);\r\n  const t = el.tagName.toLowerCase() as K;\r\n\r\n  if (t !== tag) {\r\n    throw new Error(message ?? `Expected <${tag}>, got <${t}>`);\r\n  }\r\n  return el as SVGElementTagNameMap[K];\r\n}\r\nexport const expectSvg = (x: unknown, m?: string) => expectSvgTag(x, 'svg', m);\r\n\r\nexport const expectSvgPath = (x: unknown, m?: string) => expectSvgTag(x, 'path', m);\r\n\r\nexport const expectSvgGroup = (x: unknown, m?: string) => expectSvgTag(x, 'g', m);\r\n\r\nexport const expectSvgCircle = (x: unknown, m?: string) => expectSvgTag(x, 'circle', m);\r\n\r\nexport const expectSvgRect = (x: unknown, m?: string) => expectSvgTag(x, 'rect', m);\r\n\r\nexport const expectSvgLine = (x: unknown, m?: string) => expectSvgTag(x, 'line', m);\r\n\r\nexport function expectElementHasChildren(x: unknown, message?: string): Element {\r\n  assertElementHasChildren(x, message);\r\n  return x as Element;\r\n}\r\nexport function expectElementHasChild(x: unknown, message?: string): Element {\r\n  assertElementHasChild(x, message);\r\n  return x as Element;\r\n}\r\nexport function expectElementHasChildMatching(x: unknown, selector: string, message?: string): Element {\r\n  assertElementHasChildMatching(x, selector, message);\r\n  return x as Element;\r\n}\r\nexport function expectElementHasDescendant(x: unknown, selector: string, message?: string): Element {\r\n  assertElementHasDescendant(x, selector, message);\r\n  return x as Element;\r\n}\r\nexport function expectElementHasAttribute(x: unknown, name: string, message?: string): Element {\r\n  assertElementHasAttribute(x, name, message);\r\n  return x as Element;\r\n}\r\nexport function expectElementAttributeEquals(x: unknown, name: string, expected: string, message?: string): Element {\r\n  assertElementAttributeEquals(x, name, expected, message);\r\n  return x as Element;\r\n}\r\nexport function expectElementHidden(x: unknown, message?: string): Element {\r\n  assertElementHidden(x, message);\r\n  return x as Element;\r\n}\r\nexport function expectElementVisible(x: unknown, message?: string): Element {\r\n  assertElementVisible(x, message);\r\n  return x as Element;\r\n}\r\n\r\n// Date expects\r\nexport function expectDateEarlier(x: unknown, than: Date, message?: string): Date {\r\n  assertDateEarlier(x, than, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateLater(x: unknown, than: Date, message?: string): Date {\r\n  assertDateLater(x, than, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateBetween(x: unknown, min: Date, max: Date, message?: string): Date {\r\n  assertDateBetween(x, min, max, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateYear(x: unknown, year: number, message?: string): Date {\r\n  assertDateYear(x, year, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateBefore(x: unknown, than: Date, message?: string): Date {\r\n  assertDateBefore(x, than, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateAfter(x: unknown, than: Date, message?: string): Date {\r\n  assertDateAfter(x, than, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateOnOrBefore(x: unknown, than: Date, message?: string): Date {\r\n  assertDateOnOrBefore(x, than, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateOnOrAfter(x: unknown, than: Date, message?: string): Date {\r\n  assertDateOnOrAfter(x, than, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateBetweenInclusive(x: unknown, min: Date, max: Date, message?: string): Date {\r\n  assertDateBetweenInclusive(x, min, max, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateBetweenExclusive(x: unknown, min: Date, max: Date, message?: string): Date {\r\n  assertDateBetweenExclusive(x, min, max, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateInPast(x: unknown, message?: string): Date {\r\n  assertDateInPast(x, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateInFuture(x: unknown, message?: string): Date {\r\n  assertDateInFuture(x, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateWithinPast(x: unknown, ms: number, message?: string): Date {\r\n  assertDateWithinPast(x, ms, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateWithinFuture(x: unknown, ms: number, message?: string): Date {\r\n  assertDateWithinFuture(x, ms, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateSameYear(x: unknown, other: Date, message?: string): Date {\r\n  assertDateSameYear(x, other, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateSameMonth(x: unknown, other: Date, message?: string): Date {\r\n  assertDateSameMonth(x, other, message);\r\n  return x as Date;\r\n}\r\nexport function expectDateSameDay(x: unknown, other: Date, message?: string): Date {\r\n  assertDateSameDay(x, other, message);\r\n  return x as Date;\r\n}\r\n\r\n// =====================\r\n// test() \u2192 turn throwing assertions into boolean\r\n// =====================\r\n\r\n/**\r\n * Execute an assertion function; return true if it succeeds, false if it throws AssertError.\r\n * Non-AssertError exceptions are rethrown (to avoid swallowing real errors).\r\n */\r\nexport function test(assertion: () => void): boolean {\r\n  try {\r\n    assertion();\r\n    return true;\r\n  } catch (e) {\r\n    if (e instanceof AssertError) return false;\r\n    throw e;\r\n  }\r\n}\r\n\r\n// =====================\r\n// fork: pass/fail handlers\r\n// =====================\r\n\r\nexport function fork(assertion: () => void, onPass: (...args: unknown[]) => void, onFail: (error: AssertError, ...args: unknown[]) => void, ...args: unknown[]): void {\r\n  try {\r\n    assertion();\r\n    onPass(...args);\r\n  } catch (e) {\r\n    if (e instanceof AssertError) {\r\n      onFail(e, ...args);\r\n      return;\r\n    }\r\n    throw e; // non-assert error \u2192 rethrow\r\n  }\r\n}\r\n\r\nexport async function forkAsync(assertion: () => Promise<void>, onPass: (...args: unknown[]) => Promise<void>, onFail: (error: AssertError, ...args: unknown[]) => Promise<void>, ...args: unknown[]): Promise<void> {\r\n  try {\r\n    await assertion();\r\n    await onPass(...args);\r\n  } catch (e) {\r\n    if (e instanceof AssertError) {\r\n      await onFail(e, ...args);\r\n      return;\r\n    }\r\n    throw e;\r\n  }\r\n}\r\n\r\n// =====================\r\n// fn / fnAsync\r\n// =====================\r\n\r\nexport type AssertFnOptions = {\r\n  onError?: (err: AssertError) => void;\r\n  catchNonAssertErrors?: boolean; // default false: rethrow non-AssertError\r\n};\r\n\r\n/**\r\n * Wrap a function; if an AssertError occurs inside the callback, return the provided default.\r\n * - `defaultValue` can be a value or a thunk receiving `(error, ...args)`\r\n * - Non-Assert errors are rethrown\r\n */\r\nexport function fn<R, A extends unknown[]>(defaultValue: R | ((error: AssertError, ...args: A) => R), callback: (...args: A) => R, options?: AssertFnOptions): (...args: A) => R {\r\n  const { onError, catchNonAssertErrors = false } = options ?? {};\r\n  return (...args: A) => {\r\n    try {\r\n      return callback(...args);\r\n    } catch (e) {\r\n      if (e instanceof AssertError) {\r\n        emitAssertError(e);\r\n        onError?.(e);\r\n        return typeof defaultValue === 'function' ? (defaultValue as (error: AssertError, ...args: A) => R)(e, ...args) : defaultValue;\r\n      }\r\n      if (catchNonAssertErrors) {\r\n        const err = e instanceof Error ? e : new Error(String(e));\r\n        const ae = new AssertError(err.message);\r\n        emitAssertError(ae);\r\n        onError?.(ae);\r\n        return typeof defaultValue === 'function' ? (defaultValue as (error: AssertError, ...args: A) => R)(ae, ...args) : defaultValue;\r\n      }\r\n      throw e;\r\n    }\r\n  };\r\n}\r\n\r\nexport function fnAsync<R, A extends unknown[]>(defaultValue: R | ((error: AssertError, ...args: A) => R | Promise<R>), callback: (...args: A) => Promise<R>, options?: AssertFnOptions): (...args: A) => Promise<R> {\r\n  const { onError, catchNonAssertErrors = false } = options ?? {};\r\n  return async (...args: A) => {\r\n    try {\r\n      return await callback(...args);\r\n    } catch (e) {\r\n      if (e instanceof AssertError) {\r\n        emitAssertError(e);\r\n        onError?.(e);\r\n        return typeof defaultValue === 'function' ? await (defaultValue as (error: AssertError, ...args: A) => R | Promise<R>)(e, ...args) : (defaultValue as R);\r\n      }\r\n      if (catchNonAssertErrors) {\r\n        const err = e instanceof Error ? e : new Error(String(e));\r\n        const ae = new AssertError(err.message);\r\n        emitAssertError(ae);\r\n        onError?.(ae);\r\n        const dv = typeof defaultValue === 'function' ? (defaultValue as (error: AssertError, ...args: A) => R | Promise<R>)(ae, ...args) : (defaultValue as R);\r\n        return await Promise.resolve(dv);\r\n      }\r\n      throw e;\r\n    }\r\n  };\r\n}\r\n\r\n/**\r\n * Immediate exec, zero-arg: run `cb` now. On AssertError, return `fallback`.\r\n * Optionally catch non-Assert errors and observe via `onError`.\r\n */\r\nexport function fnRun<T>(fallback: T, cb: () => T, options?: AssertFnOptions): T {\r\n  const { onError, catchNonAssertErrors = false } = options ?? {};\r\n  try {\r\n    return cb();\r\n  } catch (e) {\r\n    if (e instanceof AssertError) {\r\n      emitAssertError(e);\r\n      onError?.(e);\r\n      return fallback;\r\n    }\r\n    if (catchNonAssertErrors) {\r\n      const err = e instanceof Error ? e : new Error(String(e));\r\n      const ae = new AssertError(err.message);\r\n      emitAssertError(ae);\r\n      onError?.(ae);\r\n      return fallback;\r\n    }\r\n    throw e;\r\n  }\r\n}\r\n\r\n/**\r\n * Immediate async exec, zero-arg: run `cb` now. On AssertError, resolve with `fallback`.\r\n * Optionally catch non-Assert errors and observe via `onError`.\r\n */\r\nexport async function fnRunAsync<T>(fallback: T, cb: () => Promise<T>, options?: AssertFnOptions): Promise<T> {\r\n  const { onError, catchNonAssertErrors = false } = options ?? {};\r\n  try {\r\n    return await cb();\r\n  } catch (e) {\r\n    if (e instanceof AssertError) {\r\n      emitAssertError(e);\r\n      onError?.(e);\r\n      return fallback;\r\n    }\r\n    if (catchNonAssertErrors) {\r\n      const err = e instanceof Error ? e : new Error(String(e));\r\n      const ae = new AssertError(err.message);\r\n      emitAssertError(ae);\r\n      onError?.(ae);\r\n      return fallback;\r\n    }\r\n    throw e;\r\n  }\r\n}\r\n\r\n// Prefer fn/fnAsync + fnRun/fnRunAsync for scoped fallback behavior.\r\nexport function assertStringLength(x: unknown, len: number, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected string length ${len}`);\r\n  assert((x as string).length === len, message ?? `Expected string length ${len}`);\r\n}\r\n\r\n/** Asserts that x is a string with length >= `n`. */\r\nexport function assertStringLengthAtLeast(x: unknown, n: number, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected string length >= ${n}`);\r\n  assert((x as string).length >= n, message ?? `Expected string length >= ${n}`);\r\n}\r\n\r\n/** Asserts that x is a string with length <= `n`. */\r\nexport function assertStringLengthAtMost(x: unknown, n: number, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected string length <= ${n}`);\r\n  assert((x as string).length <= n, message ?? `Expected string length <= ${n}`);\r\n}\r\n\r\n/** Asserts that x is a string with min/max inclusive bounds. */\r\nexport function assertStringLengthBetween(x: unknown, min: number, max: number, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected string length between ${min} and ${max}`);\r\n  const l = (x as string).length;\r\n  assert(l >= min && l <= max, message ?? `Expected string length between ${min} and ${max}`);\r\n}\r\n\r\n/** Asserts that x is a string containing substring or matching regex. */\r\nexport function assertStringContains(x: unknown, needle: string | RegExp, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected string to contain ${String(needle)}`);\r\n  const s = x as string;\r\n  const ok = typeof needle === 'string' ? s.includes(needle) : needle.test(s);\r\n  assert(ok, message ?? `Expected string to contain ${String(needle)}`);\r\n}\r\n\r\n/** Asserts that x is a string starting with the given prefix. */\r\nexport function assertStringStartsWith(x: unknown, prefix: string, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected string to start with \"${prefix}\"`);\r\n  assert((x as string).startsWith(prefix), message ?? `Expected string to start with \"${prefix}\"`);\r\n}\r\n\r\n/** Asserts that x is a string ending with the given suffix. */\r\nexport function assertStringEndsWith(x: unknown, suffix: string, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected string to end with \"${suffix}\"`);\r\n  assert((x as string).endsWith(suffix), message ?? `Expected string to end with \"${suffix}\"`);\r\n}\r\n\r\n/** Asserts that x is a string that matches the regex. */\r\nexport function assertStringMatches(x: unknown, re: RegExp, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected string to match ${re}`);\r\n  assert(re.test(x as string), message ?? `Expected string to match ${re}`);\r\n}\r\n\r\n/** Asserts that x (string) equals `expected` ignoring case. */\r\nexport function assertStringEqualsIgnoreCase(x: unknown, expected: string, message?: string): asserts x is string {\r\n  assertString(x, message ?? `Expected \"${expected}\" (case-insensitive)`);\r\n  assert((x as string).toLowerCase() === expected.toLowerCase(), message ?? `Expected \"${expected}\" (case-insensitive)`);\r\n}\r\n\r\n/** Asserts that x is a string including any of the provided substrings. */\r\nexport function assertStringIncludesAny(x: unknown, ...needles: string[]): asserts x is string {\r\n  assertString(x, `Expected string`);\r\n  const s = x as string;\r\n  assert(\r\n    needles.some((n) => s.includes(n)),\r\n    `Expected string to include any of [${needles.join(', ')}]`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is a string including all of the provided substrings. */\r\nexport function assertStringIncludesAll(x: unknown, ...needles: string[]): asserts x is string {\r\n  assertString(x, `Expected string`);\r\n  const s = x as string;\r\n  assert(\r\n    needles.every((n) => s.includes(n)),\r\n    `Expected string to include all of [${needles.join(', ')}]`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is a string containing valid JSON. */\r\nexport function assertStringIsJSON(x: unknown, message = 'Expected valid JSON'): asserts x is string {\r\n  assertString(x, message);\r\n  try {\r\n    JSON.parse(x as string);\r\n  } catch {\r\n    assert(false, message);\r\n  }\r\n}\r\n\r\n/** Asserts that x is a string whose trimmed length > 0. */\r\nexport function assertStringTrimmedNotEmpty(x: unknown, message = 'Expected non-empty (trimmed)'): asserts x is string {\r\n  assertString(x, message);\r\n  assert((x as string).trim().length > 0, message);\r\n}\r\n\r\n// ---- Numbers ----\r\n\r\n/** Asserts that x is a number strictly greater than n. */\r\nexport function assertNumberGreaterThan(x: unknown, n: number, message?: string): asserts x is number {\r\n  assertNumber(x, message ?? `Expected > ${n}`);\r\n  assert((x as number) > n, message ?? `Expected > ${n}`);\r\n}\r\n\r\n/** Asserts that x is a number >= n. */\r\nexport function assertNumberGreaterOrEqual(x: unknown, n: number, message?: string): asserts x is number {\r\n  assertNumber(x, message ?? `Expected >= ${n}`);\r\n  assert((x as number) >= n, message ?? `Expected >= ${n}`);\r\n}\r\n\r\n/** Asserts that x is a number strictly less than n. */\r\nexport function assertNumberLessThan(x: unknown, n: number, message?: string): asserts x is number {\r\n  assertNumber(x, message ?? `Expected < ${n}`);\r\n  assert((x as number) < n, message ?? `Expected < ${n}`);\r\n}\r\n\r\n/** Asserts that x is a number <= n. */\r\nexport function assertNumberLessOrEqual(x: unknown, n: number, message?: string): asserts x is number {\r\n  assertNumber(x, message ?? `Expected <= ${n}`);\r\n  assert((x as number) <= n, message ?? `Expected <= ${n}`);\r\n}\r\n\r\n/** Asserts that x is a number within [min, max]. */\r\nexport function assertNumberBetween(x: unknown, min: number, max: number, message?: string): asserts x is number {\r\n  assertNumber(x, message ?? `Expected between ${min} and ${max}`);\r\n  const v = x as number;\r\n  assert(v >= min && v <= max, message ?? `Expected between ${min} and ${max}`);\r\n}\r\n\r\n// ---- Arrays ----\r\n\r\n/** Asserts that x is an array with exact length `len`. */\r\nexport function assertArrayLength<T = unknown>(x: unknown, len: number, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array length ${len}`);\r\n  assert((x as T[]).length === len, message ?? `Expected array length ${len}`);\r\n}\r\n\r\n/** Asserts that x is a non-empty array. */\r\nexport function assertArrayNotEmpty<T = unknown>(x: unknown, message = 'Expected non-empty array'): asserts x is T[] {\r\n  assertArray<T>(x, 'Expected array');\r\n  assert((x as T[]).length > 0, message);\r\n}\r\n\r\n/** Asserts that x is an array containing at least one of the provided items (by string form). */\r\nexport function assertArrayHasAnyOf<T = unknown>(x: unknown, items: string[], message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  const arr = x as unknown[];\r\n  const set = new Set(items);\r\n  const ok = arr.some((el) => set.has(String(el)));\r\n  assert(ok, message ?? `Expected array to contain any of [${items.join(', ')}]`);\r\n}\r\n\r\n/** Asserts that x is an array containing all the provided items (by string form). */\r\nexport function assertArrayHasEveryOf<T = unknown>(x: unknown, items: string[], message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  const arr = x as unknown[];\r\n  const set = new Set(arr.map((v) => (typeof v === 'string' ? v : String(v))));\r\n  const missing = items.filter((k) => !set.has(k));\r\n  assert(missing.length === 0, message ?? `Missing required items: [${missing.join(', ')}]`);\r\n}\r\n\r\n/** Asserts that x is an array and element at index i is a boolean. */\r\nexport function assertArrayItemIsBoolean<T = unknown>(x: unknown, i: number, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(typeof (x as unknown[])[i] === 'boolean', message ?? `Expected boolean at ${i}`);\r\n}\r\n\r\n/** Asserts that x is an array and element at index i is a string. */\r\nexport function assertArrayItemIsString<T = unknown>(x: unknown, i: number, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(typeof (x as unknown[])[i] === 'string', message ?? `Expected string at ${i}`);\r\n}\r\n\r\n/** Asserts that x is an array and element at index i is a number. */\r\nexport function assertArrayItemIsNumber<T = unknown>(x: unknown, i: number, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(typeof (x as unknown[])[i] === 'number', message ?? `Expected number at ${i}`);\r\n}\r\n\r\n/** Asserts that x is an array and element at index i is a plain object. */\r\nexport function assertArrayItemIsObject<T = unknown>(x: unknown, i: number, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  const v = (x as unknown[])[i];\r\n  assert(typeof v === 'object' && v !== null && !Array.isArray(v), message ?? `Expected object at ${i}`);\r\n}\r\n\r\n/** Asserts that x is an array with at least one item whose string form includes `needle`. */\r\nexport function assertArrayIncludesString<T = unknown>(x: unknown, needle: string, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(\r\n    (x as unknown[]).some((item) => String(item).includes(needle)),\r\n    message ?? `Expected array to include string containing \"${needle}\"`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is an array including the exact number `needle`. */\r\nexport function assertArrayIncludesNumber<T = unknown>(x: unknown, needle: number, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(\r\n    (x as unknown[]).some((item) => item === needle),\r\n    message ?? `Expected array to include number ${needle}`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is an array including an object deep-equal to `needle`. */\r\nexport function assertArrayIncludesObject<T = unknown>(x: unknown, needle: Record<string, unknown>, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  const needleStr = JSON.stringify(needle);\r\n  assert(\r\n    (x as unknown[]).some((item) => JSON.stringify(item) === needleStr),\r\n    message ?? `Expected array to include object ${needleStr}`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is an array whose every element is a plain object. */\r\nexport function assertArrayOnlyHasObjects<T = unknown>(x: unknown, message?: string): asserts x is Record<string, unknown>[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(\r\n    (x as unknown[]).every((item) => typeof item === 'object' && item !== null && !Array.isArray(item)),\r\n    message ?? `Expected array to only contain objects`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is an array whose every element is a string. */\r\nexport function assertArrayOnlyHasStrings<T = unknown>(x: unknown, message?: string): asserts x is string[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(\r\n    (x as unknown[]).every((item) => typeof item === 'string'),\r\n    message ?? `Expected array to only contain strings`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is an array whose every element is a number. */\r\nexport function assertArrayOnlyHasNumbers<T = unknown>(x: unknown, message?: string): asserts x is number[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(\r\n    (x as unknown[]).every((item) => typeof item === 'number'),\r\n    message ?? `Expected array to only contain numbers`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is an array and every element is falsy. */\r\nexport function assertArrayEveryIsFalsy<T = unknown>(x: unknown, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(\r\n    (x as unknown[]).every((item) => !item),\r\n    message ?? `Expected every item to be falsy`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is an array and every element is truthy. */\r\nexport function assertArrayEveryIsTruthy<T = unknown>(x: unknown, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert(\r\n    (x as unknown[]).every((item) => !!item),\r\n    message ?? `Expected every item to be truthy`,\r\n  );\r\n}\r\n\r\n/** Assert an array has all unique items by strict equality (===). */\r\nexport function assertArrayUnique<T = unknown>(x: unknown, message = 'Expected array with unique items'): asserts x is T[] {\r\n  assertArray<T>(x, message);\r\n  const arr = x as unknown[];\r\n  const seen = new Set<unknown>();\r\n  for (const item of arr) {\r\n    if (seen.has(item)) {\r\n      assert(false, message);\r\n    }\r\n    seen.add(item);\r\n  }\r\n}\r\n\r\n/** Asserts that x is an array including an element for which predicate returns true. */\r\nexport function assertArrayIncludesCondition<T = unknown>(x: unknown, predicate: (item: unknown) => boolean, message?: string): asserts x is T[] {\r\n  assertArray<T>(x, message ?? `Expected array`);\r\n  assert((x as unknown[]).some(predicate), message ?? `Expected array to include an item matching condition`);\r\n}\r\n\r\n// ---- Objects ----\r\n\r\n/** Asserts that obj is a plain object containing the provided key. */\r\nexport function assertHasKey<O extends Record<string, unknown>, K extends string>(obj: unknown, key: K, message?: string): asserts obj is O & Record<K, unknown> {\r\n  assertObject(obj, message ?? `Expected object`);\r\n  assert(key in (obj as Record<string, unknown>), message ?? `Expected key \"${key}\"`);\r\n}\r\n\r\n/** Asserts that obj is a plain object containing all provided keys. */\r\nexport function assertHasKeys<O extends Record<string, unknown>, const K extends readonly string[]>(obj: unknown, ...keys: K): asserts obj is O & { [P in K[number]]: unknown } {\r\n  assertObject(obj, `Expected object`);\r\n  const r = obj as Record<string, unknown>;\r\n  assert(\r\n    keys.every((k) => k in r),\r\n    `Expected keys: ${keys.join(', ')}`,\r\n  );\r\n}\r\n\r\n/** Asserts that obj[key] strictly equals expected. */\r\nexport function assertKeyEquals<O extends Record<string, unknown>, K extends keyof O, E>(obj: unknown, key: K, expected: E, message?: string): asserts obj is O & Record<K, E> {\r\n  assertObject(obj, message ?? `Expected object`);\r\n  assert((obj as Record<string, unknown>)[key as string] === expected, message ?? `Expected key \"${String(key)}\" to equal ${JSON.stringify(expected)}`);\r\n}\r\n\r\n/** Asserts that obj has exactly the same set of keys as `expected`. */\r\nexport function assertSameKeys(obj: unknown, expected: Record<string, unknown>, message?: string): asserts obj is Record<string, unknown> {\r\n  assertObject(obj, message ?? `Expected object`);\r\n  const a = Object.keys(obj as Record<string, unknown>).sort();\r\n  const b = Object.keys(expected).sort();\r\n  assert(a.length === b.length && a.every((k, i) => k === b[i]), message ?? `Expected same keys`);\r\n}\r\n\r\n/** Asserts that `obj` contains at least all keys present in `other`. */\r\nexport function assertHasAllKeysLike<O extends Record<string, unknown>>(obj: unknown, other: O, message?: string): asserts obj is Record<string, unknown> & { [P in keyof O]: unknown } {\r\n  // Prefer plain object semantics here to avoid array index keys confusion.\r\n  assertPlainObject(obj, message ?? `Expected object`);\r\n  const r = obj as Record<string, unknown>;\r\n  const keys = Object.keys(other as Record<string, unknown>);\r\n  const missing = keys.filter((k) => !(k in r));\r\n  assert(missing.length === 0, message ?? `Missing required keys: [${missing.join(', ')}]`);\r\n}\r\n\r\n/** Ensure `obj` has all keys like `other` and return it with narrowed key presence. */\r\nexport function expectHasAllKeysLike<O extends Record<string, unknown>>(obj: unknown, other: O, message?: string): Record<string, unknown> & { [P in keyof O]: unknown } {\r\n  assertHasAllKeysLike(obj, other, message);\r\n  return obj as Record<string, unknown> & { [P in keyof O]: unknown };\r\n}\r\n\r\n/** Asserts that obj is a plain object with at least one own key. */\r\nexport function assertNonEmptyRecord(obj: unknown, message = 'Expected non-empty record'): asserts obj is Record<string, unknown> {\r\n  assertPlainObject(obj, message);\r\n  assert(Object.keys(obj as Record<string, unknown>).length > 0, message);\r\n}\r\n\r\n/** Ensure obj is a plain object with at least one own key and return it typed. */\r\nexport function expectNonEmptyRecord(obj: unknown, message?: string): Record<string, unknown> {\r\n  assertNonEmptyRecord(obj, message);\r\n  return obj as Record<string, unknown>;\r\n}\r\n\r\n/** Asserts that every value in obj is falsy. */\r\nexport function assertAllKeysFalsy(obj: unknown, message?: string): asserts obj is Record<string, unknown> {\r\n  assertObject(obj, message ?? `Expected object`);\r\n  assert(\r\n    Object.values(obj as Record<string, unknown>).every((v) => !v),\r\n    message ?? `Expected all keys to be falsy`,\r\n  );\r\n}\r\n\r\n/** Asserts that every value in obj is neither null nor undefined. */\r\nexport function assertAllKeysSet(obj: unknown, message?: string): asserts obj is Record<string, unknown> {\r\n  assertObject(obj, message ?? `Expected object`);\r\n  const vals = Object.values(obj as Record<string, unknown>);\r\n  assert(\r\n    vals.every((v) => v !== null && v !== undefined),\r\n    message ?? `Expected all keys to be set (not null/undefined)`,\r\n  );\r\n}\r\nexport function assertExpected<C extends new (...args: unknown[]) => InstanceType<C> | never>(x: unknown, ctor: C, asst?: (v: InstanceType<C>) => boolean): InstanceType<C> {\r\n  if (!(typeof ctor === 'function' && x instanceof ctor)) {\r\n    throw new AssertError('Invalid instance', { got: x, expected: ctor.name ?? ctor });\r\n  }\r\n  if (asst) {\r\n    const ok = asst(x as InstanceType<C>);\r\n    if (ok === false) {\r\n      throw new AssertError('Additional assertion failed', { got: x, expected: asst.name || 'predicate' });\r\n    }\r\n  }\r\n  return x as InstanceType<C>;\r\n}\r\n\r\n/** Asserts that at least one value in obj is null. */\r\nexport function assertAnyKeyNull(obj: unknown, message?: string): asserts obj is Record<string, unknown> {\r\n  assertObject(obj, message ?? `Expected object`);\r\n  const vals = Object.values(obj as Record<string, unknown>);\r\n  assert(\r\n    vals.some((v) => v === null),\r\n    message ?? `Expected any key to be null`,\r\n  );\r\n}\r\n\r\n// ---- Instance checks ----\r\n\r\n/** Type guard: returns true if `x` is an instance of `ctor`. */\r\nexport function isInstanceOf<T>(x: unknown, ctor: new (...args: unknown[]) => T): x is T {\r\n  return typeof ctor === 'function' && x instanceof ctor;\r\n}\r\n\r\n/** Asserts that `x` is an instance of the given constructor. */\r\nexport function assertInstanceOf<T>(x: unknown, ctor: new (...args: unknown[]) => T, message = 'Expected instance'): asserts x is T {\r\n  assert(typeof ctor === 'function', 'Expected constructor');\r\n  assert(x instanceof ctor, message);\r\n}\r\n\r\n/** Ensure `x` is an instance of the given constructor and return it typed. */\r\nexport function expectInstanceOf<T>(x: unknown, ctor: new (...args: unknown[]) => T, message?: string): T {\r\n  assertInstanceOf<T>(x, ctor, message);\r\n  return x as T;\r\n}\r\n\r\n// ---- Elements ----\r\n\r\n/** Returns true if x is a DOM Element (when running in an environment with DOM). */\r\nexport function isElement(x: unknown): x is Element {\r\n  return typeof Element !== 'undefined' && x instanceof Element;\r\n}\r\n\r\n/** Asserts that x is a DOM Element. */\r\nexport function assertElement(x: unknown, message = 'Expected Element'): asserts x is Element {\r\n  assert(isElement(x), message);\r\n} /** Asserts that x is a DOM HTML Element. */\r\nexport function assertHTMLElement(x: unknown, message = 'Expected HTMLElement'): asserts x is HTMLElement {\r\n  assertInstanceOf(x, HTMLElement, message);\r\n}\r\n/** Asserts that the element has at least one child node/element. */\r\nexport function assertElementHasChildren(x: unknown, message = 'Expected element to have children'): asserts x is Element {\r\n  assertElement(x, message);\r\n  const el = x as Element;\r\n  const count = (el as Element).children?.length ?? el.childNodes?.length ?? 0;\r\n  assert(count > 0, message);\r\n}\r\n\r\n/** Asserts that the element has at least one child element. */\r\nexport function assertElementHasChild(x: unknown, message = 'Expected element to have a child'): asserts x is Element {\r\n  assertElement(x, message);\r\n  const el = x as Element;\r\n  assert((el as Element).children?.length > 0, message);\r\n}\r\n\r\n/** Asserts that the element has a child matching the CSS selector. */\r\nexport function assertElementHasChildMatching(x: unknown, selector: string, message?: string): asserts x is Element {\r\n  assertElement(x, message ?? `Expected element`);\r\n  const el = x as Element;\r\n  const children = Array.from((el as Element).children ?? []) as Element[];\r\n  assert(\r\n    children.some((c) => c.matches?.(selector)),\r\n    message ?? `Expected child matching \"${selector}\"`,\r\n  );\r\n}\r\n\r\n/** Asserts that the element has a descendant matching the CSS selector. */\r\nexport function assertElementHasDescendant(x: unknown, selector: string, message?: string): asserts x is Element {\r\n  assertElement(x, message ?? `Expected element`);\r\n  const el = x as Element;\r\n  const found = (el as Element).querySelector?.(selector);\r\n  assert(!!found, message ?? `Expected descendant matching \"${selector}\"`);\r\n}\r\n\r\n/** Asserts that the element has the given attribute. */\r\nexport function assertElementHasAttribute(x: unknown, name: string, message?: string): asserts x is Element {\r\n  assertElement(x, message ?? `Expected element`);\r\n  const el = x as Element;\r\n  const ok = (el as Element).hasAttribute?.(name);\r\n  assert(!!ok, message ?? `Expected element to have attribute \"${name}\"`);\r\n}\r\n\r\n/** Asserts that the element's attribute equals the expected value. */\r\nexport function assertElementAttributeEquals(x: unknown, name: string, expected: string, message?: string): asserts x is Element {\r\n  assertElement(x, message ?? `Expected element`);\r\n  const el = x as Element;\r\n  const val = (el as Element).getAttribute?.(name);\r\n  assert(val === expected, message ?? `Expected attribute \"${name}\" to equal \"${expected}\"`);\r\n}\r\n\r\n/** Returns true if the Element is hidden via display:none or visibility:hidden (DOM environments). */\r\nexport function isElementHidden(x: unknown): x is Element {\r\n  if (typeof Element === 'undefined' || !(x instanceof Element)) return false;\r\n  const computed = typeof window !== 'undefined' ? window.getComputedStyle(x) : null;\r\n  return computed ? computed.display === 'none' || computed.visibility === 'hidden' : false;\r\n}\r\n\r\n/** Returns true if the Element is visible (i.e., not hidden by display/visibility). */\r\nexport function isElementVisible(x: unknown): x is Element {\r\n  if (typeof Element === 'undefined' || !(x instanceof Element)) return false;\r\n  const computed = typeof window !== 'undefined' ? window.getComputedStyle(x) : null;\r\n  return computed ? computed.display !== 'none' && computed.visibility !== 'hidden' : true;\r\n}\r\n\r\n/** Asserts that x is an Element currently hidden by CSS (display or visibility). */\r\nexport function assertElementHidden(x: unknown, message = 'Expected element to be hidden'): asserts x is Element {\r\n  assert(isElementHidden(x), message);\r\n}\r\n\r\n/** Asserts that x is an Element currently visible (not hidden by display/visibility). */\r\nexport function assertElementVisible(x: unknown, message = 'Expected element to be visible'): asserts x is Element {\r\n  assert(isElementVisible(x), message);\r\n}\r\n\r\n// ---- Dates ----\r\n\r\n/** Asserts that x is a Date earlier than `than`. */\r\nexport function assertDateEarlier(x: unknown, than: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? `Expected Date`);\r\n  assert((x as Date).getTime() < than.getTime(), message ?? `Expected date earlier than ${than.toISOString?.() ?? than}`);\r\n}\r\n\r\n/** Asserts that x is a Date later than `than`. */\r\nexport function assertDateLater(x: unknown, than: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? `Expected Date`);\r\n  assert((x as Date).getTime() > than.getTime(), message ?? `Expected date later than ${than.toISOString?.() ?? than}`);\r\n}\r\n\r\n/** Asserts that x is a Date within [min, max]. */\r\nexport function assertDateBetween(x: unknown, min: Date, max: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? `Expected Date`);\r\n  const t = (x as Date).getTime();\r\n  assert(t >= min.getTime() && t <= max.getTime(), message ?? `Expected date between ${min.toISOString?.() ?? min} and ${max.toISOString?.() ?? max}`);\r\n}\r\n\r\n/** Asserts that x is a Date whose full year equals `year`. */\r\nexport function assertDateYear(x: unknown, year: number, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? `Expected Date`);\r\n  assert((x as Date).getFullYear() === year, message ?? `Expected year ${year}`);\r\n}\r\n\r\n// ---- Date Formats & Conversion ----\r\n\r\n/** Supported canonical date formats */\r\nexport type DateFormat = 'ISO' | 'UNIX_MS' | 'UNIX_S' | 'RFC_2822';\r\n\r\n/** Asserts that the input matches the expected date format shape. */\r\nexport function assertDateFormat(input: unknown, format: DateFormat, message?: string): void {\r\n  switch (format) {\r\n    case 'ISO': {\r\n      assert(typeof input === 'string', message ?? 'Expected ISO string');\r\n      const s = input as string;\r\n      // Basic ISO 8601 test via Date.parse consistency and presence of time components\r\n      const d = new Date(s);\r\n      assert(!Number.isNaN(d.getTime()), message ?? 'Invalid ISO date');\r\n      break;\r\n    }\r\n    case 'RFC_2822': {\r\n      assert(typeof input === 'string', message ?? 'Expected RFC 2822 string');\r\n      const s = input as string;\r\n      const t = Date.parse(s);\r\n      assert(Number.isFinite(t), message ?? 'Invalid RFC 2822 date');\r\n      break;\r\n    }\r\n    case 'UNIX_MS': {\r\n      assert(typeof input === 'number' && Number.isFinite(input as number), message ?? 'Expected UNIX ms number');\r\n      const d = new Date(input as number);\r\n      assert(!Number.isNaN(d.getTime()), message ?? 'Invalid UNIX ms timestamp');\r\n      break;\r\n    }\r\n    case 'UNIX_S': {\r\n      assert(typeof input === 'number' && Number.isFinite(input as number), message ?? 'Expected UNIX s number');\r\n      const d = new Date((input as number) * 1000);\r\n      assert(!Number.isNaN(d.getTime()), message ?? 'Invalid UNIX s timestamp');\r\n      break;\r\n    }\r\n  }\r\n}\r\n\r\n/** Converts input of a given format to a Date (throws AssertError on failure). */\r\nexport function DateFromFormat(format: DateFormat, input: unknown, message?: string): Date {\r\n  assertDateFormat(input, format, message);\r\n  switch (format) {\r\n    case 'ISO':\r\n    case 'RFC_2822':\r\n      return new Date(input as string);\r\n    case 'UNIX_MS':\r\n      return new Date(input as number);\r\n    case 'UNIX_S':\r\n      return new Date((input as number) * 1000);\r\n  }\r\n}\r\n\r\n/** Convenience: ensure date-like input, accepting several formats. */\r\nexport function DateEnsure(input: unknown, message?: string, formats: DateFormat[] = ['ISO', 'UNIX_MS', 'UNIX_S', 'RFC_2822']): Date {\r\n  for (const f of formats) {\r\n    try {\r\n      return DateFromFormat(f, input);\r\n    } catch (e) {\r\n      if (!(e instanceof AssertError)) throw e;\r\n    }\r\n  }\r\n  throw new AssertError(message ?? 'Unrecognized date format', { got: typeof input });\r\n}\r\n\r\n// ---- Date ordering and relative-to-now ----\r\n\r\nexport function assertDateBefore(x: unknown, than: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assert((x as Date).getTime() < than.getTime(), message ?? 'Expected date to be before reference');\r\n}\r\n\r\nexport function assertDateAfter(x: unknown, than: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assert((x as Date).getTime() > than.getTime(), message ?? 'Expected date to be after reference');\r\n}\r\n\r\nexport function assertDateOnOrBefore(x: unknown, than: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assert((x as Date).getTime() <= than.getTime(), message ?? 'Expected date to be on or before reference');\r\n}\r\n\r\nexport function assertDateOnOrAfter(x: unknown, than: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assert((x as Date).getTime() >= than.getTime(), message ?? 'Expected date to be on or after reference');\r\n}\r\n\r\nexport function assertDateBetweenInclusive(x: unknown, min: Date, max: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  const t = (x as Date).getTime();\r\n  assert(t >= min.getTime() && t <= max.getTime(), message ?? 'Expected date within inclusive range');\r\n}\r\n\r\nexport function assertDateBetweenExclusive(x: unknown, min: Date, max: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  const t = (x as Date).getTime();\r\n  assert(t > min.getTime() && t < max.getTime(), message ?? 'Expected date within exclusive range');\r\n}\r\n\r\nexport function assertDateInPast(x: unknown, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assert((x as Date).getTime() < Date.now(), message ?? 'Expected date in the past');\r\n}\r\n\r\nexport function assertDateInFuture(x: unknown, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assert((x as Date).getTime() > Date.now(), message ?? 'Expected date in the future');\r\n}\r\n\r\nexport function assertDateWithinPast(x: unknown, ms: number, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assertNumber(ms, 'Expected window in ms');\r\n  const now = Date.now();\r\n  const t = (x as Date).getTime();\r\n  assert(t <= now && t >= now - ms, message ?? 'Expected date within past window');\r\n}\r\n\r\nexport function assertDateWithinFuture(x: unknown, ms: number, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assertNumber(ms, 'Expected window in ms');\r\n  const now = Date.now();\r\n  const t = (x as Date).getTime();\r\n  assert(t >= now && t <= now + ms, message ?? 'Expected date within future window');\r\n}\r\n\r\n// ---- Date component equality ----\r\n\r\nexport function assertDateSameYear(x: unknown, other: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  assert((x as Date).getFullYear() === other.getFullYear(), message ?? 'Expected same year');\r\n}\r\n\r\nexport function assertDateSameMonth(x: unknown, other: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  const a = x as Date;\r\n  assert(a.getFullYear() === other.getFullYear() && a.getMonth() === other.getMonth(), message ?? 'Expected same month');\r\n}\r\n\r\nexport function assertDateSameDay(x: unknown, other: Date, message?: string): asserts x is Date {\r\n  assertDate(x, message ?? 'Expected Date');\r\n  const a = x as Date;\r\n  assert(a.getFullYear() === other.getFullYear() && a.getMonth() === other.getMonth() && a.getDate() === other.getDate(), message ?? 'Expected same day');\r\n}\r\n\r\n// ---- TimeSpan type and helpers ----\r\n\r\nexport type TimeSpan = { ms: number };\r\n\r\nexport function TimeSpanFromMs(ms: number): TimeSpan {\r\n  assertNumber(ms, 'Expected ms number');\r\n  return { ms };\r\n}\r\nexport function TimeSpanFromSeconds(s: number): TimeSpan {\r\n  assertNumber(s, 'Expected seconds number');\r\n  return { ms: s * 1000 };\r\n}\r\nexport function TimeSpanFromMinutes(m: number): TimeSpan {\r\n  assertNumber(m, 'Expected minutes number');\r\n  return { ms: m * 60_000 };\r\n}\r\nexport function TimeSpanFromHours(h: number): TimeSpan {\r\n  assertNumber(h, 'Expected hours number');\r\n  return { ms: h * 3_600_000 };\r\n}\r\nexport function TimeSpanFromDays(d: number): TimeSpan {\r\n  assertNumber(d, 'Expected days number');\r\n  return { ms: d * 86_400_000 };\r\n}\r\n\r\nexport function DateTimeSpanBetween(a: Date, b: Date): TimeSpan {\r\n  assertDate(a, 'Expected Date a');\r\n  assertDate(b, 'Expected Date b');\r\n  return { ms: Math.abs(a.getTime() - b.getTime()) };\r\n}\r\n\r\nexport function assertDateTimeSpanLessThan(a: Date, b: Date, limit: TimeSpan, message?: string): void {\r\n  const span = DateTimeSpanBetween(a, b);\r\n  assert(span.ms < limit.ms, message ?? 'Expected timespan less than limit');\r\n}\r\n\r\nexport function assertDateTimeSpanLessOrEqual(a: Date, b: Date, limit: TimeSpan, message?: string): void {\r\n  const span = DateTimeSpanBetween(a, b);\r\n  assert(span.ms <= limit.ms, message ?? 'Expected timespan <= limit');\r\n}\r\n\r\nexport function assertDateBetweenWithin(a: Date, b: Date, min: TimeSpan, max: TimeSpan, message?: string): void {\r\n  const span = DateTimeSpanBetween(a, b);\r\n  assert(span.ms >= min.ms && span.ms <= max.ms, message ?? 'Expected timespan within bounds');\r\n}\r\n\r\nexport function DateAddSpan(d: Date, span: TimeSpan): Date {\r\n  assertDate(d, 'Expected Date');\r\n  assertNumber(span?.ms as number, 'Expected TimeSpan.ms');\r\n  return new Date(d.getTime() + span.ms);\r\n}\r\n\r\nexport function DateSubtractSpan(d: Date, span: TimeSpan): Date {\r\n  assertDate(d, 'Expected Date');\r\n  assertNumber(span?.ms as number, 'Expected TimeSpan.ms');\r\n  return new Date(d.getTime() - span.ms);\r\n}\r\n\r\n// ---- Nullish / Boolean convenience ----\r\n\r\n/** Asserts that x is strictly true. */\r\nexport function assertTrue(x: unknown, message = 'Expected true'): asserts x is true {\r\n  assert(x === true, message);\r\n}\r\n\r\n/** Asserts that x is strictly false. */\r\nexport function assertFalse(x: unknown, message = 'Expected false'): asserts x is false {\r\n  assert(x === false, message);\r\n}\r\n\r\n/** Asserts that x is strictly null. */\r\nexport function assertNull(x: unknown, message = 'Expected null'): asserts x is null {\r\n  assert(x === null, message);\r\n}\r\n\r\n/** Asserts that x is strictly undefined. */\r\nexport function assertUndefined(x: unknown, message = 'Expected undefined'): asserts x is undefined {\r\n  assert(x === undefined, message);\r\n}\r\n\r\n/** Asserts that x is truthy; narrows away null/undefined/false/0/'' */\r\nexport function assertTruthy<T>(x: T, message = 'Expected truthy'): asserts x is Exclude<T, null | undefined | false | 0 | ''> {\r\n  assert(!!x, message);\r\n}\r\n\r\n/** Asserts that x is falsy (null/undefined/false/0/''). */\r\nexport function assertFalsey(x: unknown, message = 'Expected falsy'): asserts x is null | undefined | false | 0 | '' {\r\n  assert(!x, message);\r\n}\r\n\r\n// ==========================\r\n// Extra number assertions\r\n// ==========================\r\n\r\n/** Asserts that x is a number not equal to 0. */\r\nexport function assertNumberNotZero(x: unknown, message = 'Expected non-zero number'): asserts x is number {\r\n  assertNumber(x, message);\r\n  assert((x as number) !== 0, message);\r\n}\r\n\r\n/** Asserts that x is a number strictly greater than 0. */\r\nexport function assertNumberPositive(x: unknown, message = 'Expected positive number'): asserts x is number {\r\n  assertNumber(x, message);\r\n  assert((x as number) > 0, message);\r\n}\r\n\r\n/** Asserts that x is a number >= 0. */\r\nexport function assertNumberNonNegative(x: unknown, message = 'Expected non-negative number'): asserts x is number {\r\n  assertNumber(x, message);\r\n  assert((x as number) >= 0, message);\r\n}\r\n/** Asserts that x is a number strictly less than 0. */\r\nexport function assertNumberNegative(x: unknown, message = 'Expected negative number'): asserts x is number {\r\n  assertNumber(x, message);\r\n  assert((x as number) < 0, message);\r\n}\r\n\r\n/** Asserts that x is a number <= 0. */\r\nexport function assertNumberNonPositive(x: unknown, message = 'Expected non-positive number'): asserts x is number {\r\n  assertNumber(x, message);\r\n  assert((x as number) <= 0, message);\r\n}\r\n\r\n/** Asserts that x is an integer (Number.isInteger). */\r\nexport function assertNumberInteger(x: unknown, message = 'Expected integer'): asserts x is number {\r\n  assertNumber(x, message);\r\n  assert(Number.isInteger(x as number), message);\r\n}\r\n\r\n/** Asserts that x is a safe integer (Number.isSafeInteger). */\r\nexport function assertNumberSafeInteger(x: unknown, message = 'Expected safe integer'): asserts x is number {\r\n  assertNumber(x, message);\r\n  assert(Number.isSafeInteger(x as number), message);\r\n}\r\n\r\n/** Asserts that x is a number within \u00B1epsilon of expected. */\r\nexport function assertNumberApproxEquals(x: unknown, expected: number, epsilon = 1e-9, message?: string): asserts x is number {\r\n  assertNumber(x, message ?? `Expected approximately ${expected} \u00B1 ${epsilon}`);\r\n  assert(Math.abs((x as number) - expected) <= epsilon, message ?? `Expected approximately ${expected} \u00B1 ${epsilon}`);\r\n}\r\n\r\n// ==========================\r\n// Array/object-of-object assertions\r\n// ==========================\r\n\r\n/** Asserts that x is an array of objects and each object contains `key`. */\r\nexport function assertObjectArrayAllHaveKey<K extends string>(x: unknown, key: K, message?: string): asserts x is Array<Record<string, unknown> & Record<K, unknown>> {\r\n  assertArray(x, message ?? `Expected array`);\r\n  assert(\r\n    (x as unknown[]).every((item) => typeof item === 'object' && item !== null && !Array.isArray(item) && key in (item as Record<string, unknown>)),\r\n    message ?? `Expected every object in array to have key \"${key}\"`,\r\n  );\r\n}\r\n\r\n/** Asserts that x is an array of objects and each object contains all provided keys. */\r\nexport function assertObjectArrayEveryHasKeys<const K extends readonly string[]>(x: unknown, ...keys: K): asserts x is Array<Record<string, unknown> & { [P in K[number]]: unknown }> {\r\n  assertArray(x, `Expected array`);\r\n  assert(\r\n    (x as unknown[]).every((item) => {\r\n      if (!(typeof item === 'object' && item !== null && !Array.isArray(item))) return false;\r\n      const r = item as Record<string, unknown>;\r\n      return keys.every((k) => k in r);\r\n    }),\r\n    `Expected every object in array to have keys: ${keys.join(', ')}`,\r\n  );\r\n}\r\n\r\nexport function expectObjectArrayEveryHasKeys<const K extends readonly string[]>(x: unknown, ...keys: K): Array<Record<string, unknown> & { [P in K[number]]: unknown }> {\r\n  assertObjectArrayEveryHasKeys(x, ...keys);\r\n  return x as Array<Record<string, unknown> & { [P in K[number]]: unknown }>;\r\n}\r\nfunction deepEqual(a: unknown, b: unknown): boolean {\r\n  if (a === b) return true;\r\n  if (a && b && typeof a === 'object' && typeof b === 'object') {\r\n    // Dates\r\n    if (a instanceof Date || b instanceof Date) {\r\n      if (!(a instanceof Date && b instanceof Date)) return false;\r\n      return a.getTime() === b.getTime();\r\n    }\r\n    // Arrays\r\n    if (Array.isArray(a) || Array.isArray(b)) {\r\n      if (!(Array.isArray(a) && Array.isArray(b))) return false;\r\n      if (a.length !== b.length) return false;\r\n      for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;\r\n      return true;\r\n    }\r\n    // Plain objects\r\n    const aObj = a as Record<string, unknown>;\r\n    const bObj = b as Record<string, unknown>;\r\n    const aKeys = Object.keys(aObj);\r\n    const bKeys = Object.keys(bObj);\r\n    if (aKeys.length !== bKeys.length) return false;\r\n    for (const k of aKeys) {\r\n      if (!Object.prototype.hasOwnProperty.call(bObj, k)) return false;\r\n      if (!deepEqual(aObj[k], bObj[k])) return false;\r\n    }\r\n    return true;\r\n  }\r\n  // NaN equals NaN behavior\r\n  return Number.isNaN(a) && Number.isNaN(b);\r\n}\r\n\r\n/** Asserts referential/primitive equality (===). */\r\nexport function assertEquals<T>(actual: T, expected: T, message?: string) {\r\n  assert(actual === expected, message ?? `Expected ${JSON.stringify(actual)} === ${JSON.stringify(expected)}`);\r\n}\r\n\r\n/** Asserts non-equality (!==). */\r\nexport function assertNotEquals<T>(actual: T, expected: T, message?: string) {\r\n  assert(actual !== expected, message ?? `Expected values to differ`);\r\n}\r\n\r\n/** Asserts deep equality using a simple structural comparison (arrays, objects, dates). */\r\nexport function assertDeepEquals<T>(actual: T, expected: T, message?: string) {\r\n  assert(deepEqual(actual, expected), message ?? `Expected deep equality`);\r\n}\r\n\r\nexport function _fn<Args extends unknown[], R>(defaultValue: R, impl: (...args: Args | []) => R): (...args: Args) => R {\r\n  return (...args: Args): R => {\r\n    try {\r\n      return args ? impl(...args) : impl();\r\n    } catch {\r\n      // log as needed\r\n      return defaultValue;\r\n    }\r\n  };\r\n}\r\n\r\nexport function _fnAsync<Args extends unknown[], R>(defaultValue: R, impl: (...args: Args | []) => Promise<R>): (...args: Args) => Promise<R> {\r\n  return async (...args: Args): Promise<R> => {\r\n    try {\r\n      return args && args.length > 0 ? await impl(...args) : await impl();\r\n    } catch {\r\n      // log as needed\r\n      return defaultValue;\r\n    }\r\n  };\r\n}\r\n\r\nexport type AssertErrorTrapOptions = {\r\n  onError?: (err: AssertError) => void;\r\n  /** When true (or returns true), unhandled AssertErrors are suppressed (prevent process/page break). */\r\n  suppress?: boolean | ((err: AssertError) => boolean);\r\n};\r\n\r\n/**\r\n * Install a best-effort global trap for unhandled AssertErrors in Node and browsers.\r\n * - In Node: attaches 'uncaughtException' and 'unhandledRejection' listeners that swallow AssertErrors when suppress=true.\r\n * - In browsers: attaches 'error' and 'unhandledrejection' listeners that prevent default for AssertErrors when suppress=true.\r\n *\r\n * IMPORTANT: Suppressing unhandled errors can leave your app in an unknown state. Prefer assertRoute/confirm at boundaries.\r\n * This helper is provided for last-resort safety nets and diagnostics.\r\n */\r\n\r\nconst process = globalThis.hasOwnProperty('process') ? (globalThis as any).process : undefined;\r\n\r\nexport function installAssertErrorHandler(options: AssertErrorTrapOptions = {}) {\r\n  const { onError, suppress } = options;\r\n  const shouldSuppress = (err: AssertError) => (typeof suppress === 'function' ? suppress(err) : !!suppress);\r\n\r\n  const teardown: Array<() => void> = [];\r\n\r\n  const isNodeEnv = typeof process !== 'undefined' && !!(process as any)?.on && !!(process as any)?.versions?.node;\r\n\r\n  if (isNodeEnv && shouldSuppress(new AssertError('probe'))) {\r\n    const node = process as any;\r\n    const uncaught = (err: unknown) => {\r\n      if (err instanceof AssertError) {\r\n        try {\r\n          onError?.(err);\r\n        } catch {\r\n          /* emty */\r\n        }\r\n        // swallow to avoid process crash\r\n        return;\r\n      }\r\n    };\r\n    const unhandled = (reason: unknown) => {\r\n      if (reason instanceof AssertError) {\r\n        try {\r\n          onError?.(reason);\r\n        } catch {\r\n          /* emty */\r\n        }\r\n        // swallow\r\n        return;\r\n      }\r\n    };\r\n    node.on('uncaughtException', uncaught);\r\n    node.on('unhandledRejection', unhandled);\r\n    teardown.push(() => {\r\n      try {\r\n        node.off('uncaughtException', uncaught);\r\n      } catch {\r\n        /* emty */\r\n      }\r\n      try {\r\n        node.off('unhandledRejection', unhandled);\r\n      } catch {\r\n        /* emty */\r\n      }\r\n    });\r\n  }\r\n\r\n  if (typeof window !== 'undefined' && shouldSuppress(new AssertError('probe'))) {\r\n    const onErrorEvt = (e: Event) => {\r\n      const err = e instanceof ErrorEvent ? ((e as ErrorEvent).error as unknown) : undefined;\r\n      if (err instanceof AssertError) {\r\n        try {\r\n          onError?.(err);\r\n        } catch {\r\n          /* emty */\r\n        }\r\n        (e as ErrorEvent).preventDefault?.();\r\n      }\r\n    };\r\n    const onRejEvt = (e: PromiseRejectionEvent) => {\r\n      const reason = e.reason as unknown;\r\n      if (reason instanceof AssertError) {\r\n        try {\r\n          onError?.(reason);\r\n        } catch {\r\n          /* emty */\r\n        }\r\n        e.preventDefault();\r\n      }\r\n    };\r\n    window.addEventListener('error', onErrorEvt as (e: Event) => unknown);\r\n    window.addEventListener('unhandledrejection', onRejEvt as (e: Event) => unknown);\r\n    teardown.push(() => {\r\n      try {\r\n        window.removeEventListener('error', onErrorEvt as (e: Event) => unknown);\r\n      } catch {\r\n        /* emty */\r\n      }\r\n      try {\r\n        window.removeEventListener('unhandledrejection', onRejEvt as (e: Event) => unknown);\r\n      } catch {\r\n        /* emty */\r\n      }\r\n    });\r\n  }\r\n\r\n  return {\r\n    uninstall() {\r\n      for (const t of teardown) t();\r\n    },\r\n  } as const;\r\n}\r\n"],
  "mappings": "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",
  "names": ["src_exports", "__export", "AssertError", "DateAddSpan", "DateEnsure", "DateFromFormat", "DateSubtractSpan", "DateTimeSpanBetween", "TimeSpanFromDays", "TimeSpanFromHours", "TimeSpanFromMinutes", "TimeSpanFromMs", "TimeSpanFromSeconds", "_fn", "_fnAsync", "assert", "assertAllKeysFalsy", "assertAllKeysSet", "assertAnyKeyNull", "assertArray", "assertArrayEveryIsFalsy", "assertArrayEveryIsTruthy", "assertArrayHasAnyOf", "assertArrayHasEveryOf", "assertArrayIncludesCondition", "assertArrayIncludesNumber", "assertArrayIncludesObject", "assertArrayIncludesString", "assertArrayItemIsBoolean", "assertArrayItemIsNumber", "assertArrayItemIsObject", "assertArrayItemIsString", "assertArrayLength", "assertArrayNotEmpty", "assertArrayOnlyHasNumbers", "assertArrayOnlyHasObjects", "assertArrayOnlyHasStrings", "assertArrayUnique", "assertBoolean", "assertDate", "assertDateAfter", "assertDateBefore", "assertDateBetween", "assertDateBetweenExclusive", "assertDateBetweenInclusive", "assertDateBetweenWithin", "assertDateEarlier", "assertDateFormat", "assertDateInFuture", "assertDateInPast", "assertDateLater", "assertDateOnOrAfter", "assertDateOnOrBefore", "assertDateSameDay", "assertDateSameMonth", "assertDateSameYear", "assertDateTimeSpanLessOrEqual", "assertDateTimeSpanLessThan", "assertDateWithinFuture", "assertDateWithinPast", "assertDateYear", "assertDeepEquals", "assertDefined", "assertElement", "assertElementAttributeEquals", "assertElementHasAttribute", "assertElementHasChild", "assertElementHasChildMatching", "assertElementHasChildren", "assertElementHasDescendant", "assertElementHidden", "assertElementVisible", "assertEquals", "assertErrorEmitter", "assertExists", "assertExpected", "assertFalse", "assertFalsey", "assertFunction", "assertHTMLElement", "assertHasAllKeysLike", "assertHasKey", "assertHasKeys", "assertInstanceOf", "assertKeyEquals", "assertNonEmptyRecord", "assertNonNull", "assertNotEquals", "assertNotNil", "assertNull", "assertNumber", "assertNumberApproxEquals", "assertNumberBetween", "assertNumberGreaterOrEqual", "assertNumberGreaterThan", "assertNumberInteger", "assertNumberLessOrEqual", "assertNumberLessThan", "assertNumberNegative", "assertNumberNonNegative", "assertNumberNonPositive", "assertNumberNotZero", "assertNumberPositive", "assertNumberSafeInteger", "assertObject", "assertObjectArrayAllHaveKey", "assertObjectArrayEveryHasKeys", "assertPlainObject", "assertPresent", "assertPromiseLike", "assertSameKeys", "assertString", "assertStringContains", "assertStringEndsWith", "assertStringEqualsIgnoreCase", "assertStringIncludesAll", "assertStringIncludesAny", "assertStringIsJSON", "assertStringLength", "assertStringLengthAtLeast", "assertStringLengthAtMost", "assertStringLengthBetween", "assertStringMatches", "assertStringStartsWith", "assertStringTrimmedNotEmpty", "assertTrue", "assertTruthy", "assertUndefined", "expect", "expectAllKeysFalsy", "expectAllKeysSet", "expectAnyKeyNull", "expectArray", "expectArrayEveryIsFalsy", "expectArrayEveryIsTruthy", "expectArrayHasAnyOf", "expectArrayHasEveryOf", "expectArrayIncludesCondition", "expectArrayIncludesNumber", "expectArrayIncludesObject", "expectArrayIncludesString", "expectArrayItemIsBoolean", "expectArrayItemIsNumber", "expectArrayItemIsObject", "expectArrayItemIsString", "expectArrayLength", "expectArrayNotEmpty", "expectArrayOnlyHasNumbers", "expectArrayOnlyHasObjects", "expectArrayOnlyHasStrings", "expectArrayUnique", "expectAudio", "expectBoolean", "expectButton", "expectCanvas", "expectDate", "expectDateAfter", "expectDateBefore", "expectDateBetween", "expectDateBetweenExclusive", "expectDateBetweenInclusive", "expectDateEarlier", "expectDateInFuture", "expectDateInPast", "expectDateLater", "expectDateOnOrAfter", "expectDateOnOrBefore", "expectDateSameDay", "expectDateSameMonth", "expectDateSameYear", "expectDateWithinFuture", "expectDateWithinPast", "expectDateYear", "expectDefined", "expectDiv", "expectElement", "expectElementAttributeEquals", "expectElementHasAttribute", "expectElementHasChild", "expectElementHasChildMatching", "expectElementHasChildren", "expectElementHasDescendant", "expectElementHidden", "expectElementTags", "expectElementVisible", "expectExists", "expectFalsey", "expectForm", "expectFunction", "expectHTMLElement", "expectHasAllKeysLike", "expectHasKey", "expectHasKeys", "expectImg", "expectInput", "expectInstanceOf", "expectKeyEquals", "expectLabel", "expectLi", "expectNonEmptyArray", "expectNonEmptyRecord", "expectNonEmptyString", "expectNonNull", "expectNotNil", "expectNumber", "expectNumberApproxEquals", "expectNumberBetween", "expectNumberGreaterOrEqual", "expectNumberGreaterThan", "expectNumberInteger", "expectNumberLessOrEqual", "expectNumberLessThan", "expectNumberNegative", "expectNumberNonNegative", "expectNumberNonPositive", "expectNumberNotZero", "expectNumberPositive", "expectNumberSafeInteger", "expectObject", "expectObjectArrayEveryHasKeys", "expectOl", "expectOption", "expectP", "expectPlainObject", "expectPresent", "expectPromiseLike", "expectSameKeys", "expectSelect", "expectSpan", "expectString", "expectStringContains", "expectStringEndsWith", "expectStringEqualsIgnoreCase", "expectStringIncludesAll", "expectStringIncludesAny", "expectStringIsJSON", "expectStringLength", "expectStringLengthAtLeast", "expectStringLengthAtMost", "expectStringLengthBetween", "expectStringMatches", "expectStringStartsWith", "expectStringTrimmedNotEmpty", "expectSvg", "expectSvgCircle", "expectSvgElement", "expectSvgGroup", "expectSvgLine", "expectSvgPath", "expectSvgRect", "expectSvgTag", "expectTBody", "expectTFoot", "expectTHead", "expectTable", "expectTd", "expectTextarea", "expectTh", "expectTr", "expectTruthy", "expectUl", "expectVideo", "fn", "fnAsync", "fnRun", "fnRunAsync", "fork", "forkAsync", "installAssertErrorHandler", "isDefined", "isElement", "isElementHidden", "isElementVisible", "isFunction", "isInstanceOf", "isNonNull", "isNotNil", "isPresent", "isPromiseLike", "test", "__toCommonJS", "AssertError", "message", "info", "assertErrorListeners", "assertErrorEmitter", "listener", "wrapped", "error", "emitAssertError", "assert", "condition", "isFunction", "x", "isPromiseLike", "assertString", "assertNumber", "assertBoolean", "assertArray", "assertObject", "assertPlainObject", "expectPlainObject", "assertDate", "assertNonNull", "assertExists", "assertFunction", "isDefined", "isNonNull", "isPresent", "isNotNil", "assertPromiseLike", "assertDefined", "assertPresent", "assertNotNil", "expect", "args", "first", "assertFn", "rest", "value", "assertions", "a", "expectString", "expectNumber", "expectBoolean", "expectArray", "expectArrayNotEmpty", "assertArrayNotEmpty", "expectObject", "expectDate", "expectNonNull", "expectExists", "expectFunction", "expectPromiseLike", "expectDefined", "expectPresent", "expectNotNil", "expectTruthy", "assertTruthy", "expectFalsey", "assertFalsey", "expectStringLength", "len", "assertStringLength", "expectStringLengthAtLeast", "n", "assertStringLengthAtLeast", "expectStringLengthAtMost", "assertStringLengthAtMost", "expectStringLengthBetween", "min", "max", "assertStringLengthBetween", "expectStringContains", "needle", "assertStringContains", "expectStringStartsWith", "prefix", "assertStringStartsWith", "expectStringEndsWith", "suffix", "assertStringEndsWith", "expectStringMatches", "re", "assertStringMatches", "expectStringEqualsIgnoreCase", "expected", "assertStringEqualsIgnoreCase", "expectStringIncludesAny", "needles", "assertStringIncludesAny", "expectStringIncludesAll", "assertStringIncludesAll", "expectStringIsJSON", "assertStringIsJSON", "expectStringTrimmedNotEmpty", "assertStringTrimmedNotEmpty", "expectNonEmptyString", "expectNonEmptyArray", "expectNumberGreaterThan", "assertNumberGreaterThan", "expectNumberGreaterOrEqual", "assertNumberGreaterOrEqual", "expectNumberLessThan", "assertNumberLessThan", "expectNumberLessOrEqual", "assertNumberLessOrEqual", "expectNumberBetween", "assertNumberBetween", "expectNumberNotZero", "assertNumberNotZero", "expectNumberPositive", "assertNumberPositive", "expectNumberNonNegative", "assertNumberNonNegative", "expectNumberNegative", "assertNumberNegative", "expectNumberNonPositive", "assertNumberNonPositive", "expectNumberInteger", "assertNumberInteger", "expectNumberSafeInteger", "assertNumberSafeInteger", "expectNumberApproxEquals", "epsilon", "assertNumberApproxEquals", "expectArrayLength", "assertArrayLength", "expectArrayHasAnyOf", "items", "assertArrayHasAnyOf", "expectArrayHasEveryOf", "assertArrayHasEveryOf", "expectArrayItemIsBoolean", "i", "assertArrayItemIsBoolean", "expectArrayItemIsString", "assertArrayItemIsString", "expectArrayItemIsNumber", "assertArrayItemIsNumber", "expectArrayItemIsObject", "assertArrayItemIsObject", "expectArrayIncludesString", "assertArrayIncludesString", "expectArrayIncludesNumber", "assertArrayIncludesNumber", "expectArrayIncludesObject", "assertArrayIncludesObject", "expectArrayOnlyHasObjects", "assertArrayOnlyHasObjects", "expectArrayOnlyHasStrings", "assertArrayOnlyHasStrings", "expectArrayOnlyHasNumbers", "assertArrayOnlyHasNumbers", "expectArrayEveryIsFalsy", "assertArrayEveryIsFalsy", "expectArrayEveryIsTruthy", "assertArrayEveryIsTruthy", "expectArrayUnique", "assertArrayUnique", "expectArrayIncludesCondition", "predicate", "assertArrayIncludesCondition", "expectHasKey", "obj", "key", "assertHasKey", "expectHasKeys", "keys", "assertHasKeys", "expectKeyEquals", "assertKeyEquals", "expectSameKeys", "assertSameKeys", "expectAllKeysFalsy", "assertAllKeysFalsy", "expectAllKeysSet", "assertAllKeysSet", "expectAnyKeyNull", "assertAnyKeyNull", "expectElement", "assertElement", "expectHTMLElement", "assertHTMLElement", "expectElementTags", "tags", "el", "t", "expectDiv", "m", "expectSpan", "expectP", "expectUl", "expectOl", "expectLi", "expectForm", "expectInput", "expectTextarea", "expectButton", "expectSelect", "expectOption", "expectLabel", "expectImg", "expectVideo", "expectAudio", "expectCanvas", "expectTable", "expectTHead", "expectTBody", "expectTFoot", "expectTr", "expectTh", "expectTd", "expectSvgElement", "expectSvgTag", "tag", "expectSvg", "expectSvgPath", "expectSvgGroup", "expectSvgCircle", "expectSvgRect", "expectSvgLine", "expectElementHasChildren", "assertElementHasChildren", "expectElementHasChild", "assertElementHasChild", "expectElementHasChildMatching", "selector", "assertElementHasChildMatching", "expectElementHasDescendant", "assertElementHasDescendant", "expectElementHasAttribute", "name", "assertElementHasAttribute", "expectElementAttributeEquals", "assertElementAttributeEquals", "expectElementHidden", "assertElementHidden", "expectElementVisible", "assertElementVisible", "expectDateEarlier", "than", "assertDateEarlier", "expectDateLater", "assertDateLater", "expectDateBetween", "assertDateBetween", "expectDateYear", "year", "assertDateYear", "expectDateBefore", "assertDateBefore", "expectDateAfter", "assertDateAfter", "expectDateOnOrBefore", "assertDateOnOrBefore", "expectDateOnOrAfter", "assertDateOnOrAfter", "expectDateBetweenInclusive", "assertDateBetweenInclusive", "expectDateBetweenExclusive", "assertDateBetweenExclusive", "expectDateInPast", "assertDateInPast", "expectDateInFuture", "assertDateInFuture", "expectDateWithinPast", "ms", "assertDateWithinPast", "expectDateWithinFuture", "assertDateWithinFuture", "expectDateSameYear", "other", "assertDateSameYear", "expectDateSameMonth", "assertDateSameMonth", "expectDateSameDay", "assertDateSameDay", "test", "assertion", "fork", "onPass", "onFail", "e", "forkAsync", "fn", "defaultValue", "callback", "options", "onError", "catchNonAssertErrors", "err", "ae", "fnAsync", "dv", "fnRun", "fallback", "cb", "fnRunAsync", "l", "s", "ok", "v", "arr", "set", "missing", "k", "item", "needleStr", "seen", "r", "b", "assertHasAllKeysLike", "expectHasAllKeysLike", "assertNonEmptyRecord", "expectNonEmptyRecord", "vals", "assertExpected", "ctor", "asst", "isInstanceOf", "assertInstanceOf", "expectInstanceOf", "isElement", "count", "children", "c", "found", "val", "isElementHidden", "computed", "isElementVisible", "assertDateFormat", "input", "format", "d", "DateFromFormat", "DateEnsure", "formats", "f", "now", "TimeSpanFromMs", "TimeSpanFromSeconds", "TimeSpanFromMinutes", "TimeSpanFromHours", "h", "TimeSpanFromDays", "DateTimeSpanBetween", "assertDateTimeSpanLessThan", "limit", "span", "assertDateTimeSpanLessOrEqual", "assertDateBetweenWithin", "DateAddSpan", "DateSubtractSpan", "assertTrue", "assertFalse", "assertNull", "assertUndefined", "assertObjectArrayAllHaveKey", "assertObjectArrayEveryHasKeys", "expectObjectArrayEveryHasKeys", "deepEqual", "aObj", "bObj", "aKeys", "bKeys", "assertEquals", "actual", "assertNotEquals", "assertDeepEquals", "_fn", "impl", "_fnAsync", "process", "installAssertErrorHandler", "suppress", "shouldSuppress", "teardown", "node", "uncaught", "unhandled", "reason", "onErrorEvt", "onRejEvt"]
}