@plugjs/expect5 0.4.3 → 0.4.5

package/src/expectation/print.ts

@@ -1,11 +1,15 @@
-import { $grn, $gry, $red, $und, $wht, $ylw } from '@plugjs/plug/logging'
+import { $grn, $gry, $red, $und, $wht, $ylw, type Logger } from '@plugjs/plug/logging'
 import { textDiff } from '@plugjs/plug/utils'
 
+import {
+  type Diff,
+  type ExpectedDiff,
+  type ExtraValueDiff,
+  type MissingValueDiff,
+  type ObjectDiff,
+} from './diff'
 import { stringifyValue } from './types'
 
-import type { Diff, ExtraValueDiff, MissingValueDiff, ObjectDiff, ExpectedDiff } from './diff'
-import type { Logger } from '@plugjs/plug/logging'
-
 /* ========================================================================== *
  * CONSTANT LABELS FOR PRINTING                                               *
  * ========================================================================== */

package/src/expectation/types.ts

@@ -1,5 +1,6 @@
-import type { Diff } from './diff'
-import type { Expectations, Matchers, ExpectationFunctions } from './expect'
+import { type Diff } from './diff'
+import { type Expectations } from './expectations'
+import { type Matchers } from './matchers'
 
 /* ========================================================================== *
  * INTERNAL TYPES FOR EXPECTATIONS                                            *
@@ -44,45 +45,6 @@ export type TypeMappings = {
 /** Values returned by our own _expanded_ `{@link typeOf}` */
 export type TypeName = keyof TypeMappings
 
-/** Join the asserted type of an {@link Expectations} with another type */
-export type JoinExpectations<E, T2> =
-  E extends Expectations<infer T1> ? Expectations<T1 & T2> : Expectations<T2>
-
-/** An assertion function, for sub-expectations and value introspection */
-export type AssertionFunction<T = unknown> = (assert: Expectations<T>) => void | Expectations
-
-/** Get the type asserted by an {@link AssertionFunction} */
-export type AssertedType<F extends AssertionFunction<any>, R = ReturnType<F>> =
-  R extends Expectations<infer T> ? T : unknown
-
-/** Internal context used by expectations functions to operate */
-export interface ExpectationsContext<T = unknown> {
-  /** The value being expected */
-  readonly value: T,
-  /** Whether this is a negative or positive expectation */
-  readonly negative: boolean,
-  /** The optional parent of this instance, when constructed for a property */
-  readonly parent?: ExpectationsParent
-  /** The current _positive_ {@link Expectations} for the value */
-  readonly expects: Expectations<T>
-  /**
-   * If _negative_, the _negative_ {@link ExpectationFunctions} for the value,
-   * otherwise the _positive_ ones (basically, follow the `not` of `expect`).
-   */
-  readonly negated: ExpectationFunctions<T>
-
-  /** Create an {@link Expectation} instance for the specified value */
-  forValue<V>(value: V): Expectations<V>,
-  /** Create an {@link Expectation} instance for a property of this value */
-  forProperty(prop: string | number | symbol): Expectations
-}
-
-/** Parent expectations context (for properties) */
-export interface ExpectationsParent {
-  context: ExpectationsContext,
-  prop: string | number | symbol,
-}
-
 /* ========================================================================== *
  * TYPE INSPECTION, GUARD, AND ASSERTION                                      *
  * ========================================================================== */
@@ -119,16 +81,6 @@ export function typeOf(value: unknown): TypeName {
   return 'object'
 }
 
-/** Asserts that the specified `value` is of the specified _expanded_ `type` */
-export function assertContextType<T extends keyof TypeMappings>(
-    context: ExpectationsContext,
-    type: T,
-): asserts context is ExpectationsContext<TypeMappings[T]> {
-  if (typeOf(context.value) === type) return
-
-  throw new ExpectationError(context, `to be ${prefixType(type)}`, false)
-}
-
 /* ========================================================================== *
  * PRETTY PRINTING FOR MESSAGES AND DIFFS                                     *
  * ========================================================================== */
@@ -188,7 +140,6 @@ export function stringifyValue(value: unknown): string {
   }
 
   // specific object types
-  if (isMatcher(value)) return '<matcher>'
   if (value instanceof RegExp) return String(value)
   if (value instanceof Date) return `[${constructorName(value)}: ${value.toISOString()}]`
   if (value instanceof Boolean) return `[${constructorName(value)}: ${value.valueOf()}]`
@@ -238,10 +189,10 @@ export function prefixType(type: TypeName): string {
 }
 
 /* ========================================================================== *
- * EXPECTATIONS MATCHERS MARKER                                               *
+ * EXPECTATIONS MATCHERS MARKER // avoids import loops                        *
  * ========================================================================== */
 
-export const matcherMarker = Symbol.for('plugjs:expect5:types:ExpectationsMatcher')
+export const matcherMarker = Symbol.for('plugjs:expect5:types:Matcher')
 
 export function isMatcher(what: any): what is Matchers {
   return what && what[matcherMarker] === matcherMarker
@@ -252,69 +203,46 @@ export function isMatcher(what: any): what is Matchers {
  * ========================================================================== */
 
 export class ExpectationError extends Error {
+  remarks?: string
   diff?: Diff | undefined
 
-  /** Create an {@link ExpectationError} from a context and details message */
-  constructor(context: ExpectationsContext, details: string)
-
   /**
-   * Create an {@link ExpectationError} from a context and details message,
-   * including an optional {@link Diff}
+   * Create an {@link ExpectationError} from a {@link Expectations} instance
+   * and details message, including an optional {@link Diff}
    */
-  constructor(context: ExpectationsContext, details: string, diff?: Diff)
-
-  /**
-   * Create an {@link ExpectationError} from a context and details message,
-   * optionally forcing _negation_ to be as specified.
-   */
-  constructor(context: ExpectationsContext, details: string, forcedNegative?: boolean)
-
-  /**
-   * Create an {@link ExpectationError} from a context and details message,
-   * including an optional {@link Diff} and forcing _negation_ to be as
-   * specified.
-   */
-  constructor(context: ExpectationsContext, details: string, diff?: Diff, forcedNegative?: boolean)
-
-  /* Overloaded constructor implementation */
   constructor(
-      context: ExpectationsContext,
+      expectations: Expectations,
       details: string,
-      diffOrForcedNegative?: Diff | boolean,
-      maybeForcedNegative?: boolean,
+      diff?: Diff,
   ) {
-    const diff = typeof diffOrForcedNegative === 'object' ? diffOrForcedNegative : null
-    const negative =
-      typeof diffOrForcedNegative === 'boolean' ? diffOrForcedNegative :
-      typeof maybeForcedNegative === 'boolean' ? maybeForcedNegative :
-      context.negative
-
-    const { value } = context
-    const not = negative ? ' not' : ''
+    const { value } = expectations
 
     // if we're not root...
     let preamble = stringifyValue(value)
-    if (context.parent) {
+    if (expectations.parent) {
       const properties: any[] = []
 
-      while (context.parent) {
-        properties.push(`[${stringifyValue(context.parent.prop)}]`)
-        context = context.parent.context
+      while (expectations.parent) {
+        properties.push(`[${stringifyValue(expectations.parent.prop)}]`)
+        expectations = expectations.parent.expectations
       }
 
       preamble = properties.reverse().join('')
 
       // type of root value is constructor without details
-      const type = typeof context.value === 'object' ?
-          stringifyObjectType(context.value as object) : // parent values can not be null!
-          stringifyValue(context.value)
+      const type = typeof expectations.value === 'object' ?
+          stringifyObjectType(expectations.value as object) : // parent values can not be null!
+          stringifyValue(expectations.value)
 
       // assemble the preamble
       preamble = `property ${preamble} of ${type} (${stringifyValue(value)})`
     }
 
-    super(`Expected ${preamble}${not} ${details}`)
+    // Super constructor!
+    super(`Expected ${preamble} ${details}`)
 
+    // Optional instance values
+    if (expectations.remarks) this.remarks = expectations.remarks
     if (diff) this.diff = diff
   }
 }

package/src/globals.ts

@@ -1,7 +1,7 @@
-import type * as setup from './execution/setup'
+import type { logging } from '@plugjs/plug'
 import type { skip as SkipFunction } from './execution/executable'
 import type { expect as ExpectFunction } from './expectation/expect'
-import type { logging } from '@plugjs/plug'
+import type * as setup from './execution/setup'
 
 declare global {
   const describe: setup.SuiteFunction

package/src/index.ts

@@ -1,22 +1,29 @@
-import { installForking } from '@plugjs/plug/fork'
+import { installForking, type ForkOptions } from '@plugjs/plug/fork'
 import { requireResolve } from '@plugjs/plug/paths'
 
-import type { ForkOptions } from '@plugjs/plug/fork'
-
 /* ========================================================================== *
  * EXPORTED VARIABLES (for when globals is false)                             *
  * ========================================================================== */
 
+export { skip } from './execution/executable'
 export {
-  it, fit, xit,
-  describe, fdescribe, xdescribe,
-  afterAll, afterEach, xafterAll, xafterEach,
-  beforeAll, beforeEach, xbeforeAll, xbeforeEach,
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  fdescribe,
+  fit,
+  it,
+  xafterAll,
+  xafterEach,
+  xbeforeAll,
+  xbeforeEach,
+  xdescribe,
+  xit,
 } from './execution/setup'
-export { skip } from './execution/executable'
-export { expect } from './expectation/expect'
+export * from './expectation/expect'
 
-export type { Expectations } from './expectation/expect'
 
 /* ========================================================================== *
  * EXPORTED OPTIONS TYPE AND PLUG DEFINITION                                  *

package/src/test.ts

@@ -4,21 +4,20 @@
 import { AssertionError } from 'node:assert'
 
 import { BuildFailure } from '@plugjs/plug'
-import { $blu, $grn, $gry, $ms, $red, $wht, $ylw, log, ERROR, NOTICE, WARN } from '@plugjs/plug/logging'
 import { assert } from '@plugjs/plug/asserts'
+import { type Files } from '@plugjs/plug/files'
+import { $blu, $grn, $gry, $ms, $red, $wht, $ylw, ERROR, NOTICE, WARN, log, type Logger } from '@plugjs/plug/logging'
+import { type Context, type PipeParameters, type Plug } from '@plugjs/plug/pipe'
 
-import { skip, Suite } from './execution/executable'
+import * as setup from './execution/setup'
+import { Suite, skip } from './execution/executable'
 import { runSuite } from './execution/executor'
+import { diff } from './expectation/diff'
 import { expect } from './expectation/expect'
-import { ExpectationError, stringifyObjectType } from './expectation/types'
 import { printDiff } from './expectation/print'
-import { diff } from './expectation/diff'
-import * as setup from './execution/setup'
+import { ExpectationError, stringifyObjectType, stringifyValue } from './expectation/types'
 
-import type { Files } from '@plugjs/plug/files'
-import type { Logger } from '@plugjs/plug/logging'
-import type { Context, PipeParameters, Plug } from '@plugjs/plug/pipe'
-import type { TestOptions } from './index'
+import { type TestOptions } from './index'
 
 const _pending = '\u22EF' // middle ellipsis
 const _success = '\u2714' // heavy check mark
@@ -176,6 +175,7 @@ function dumpError(log: Logger, error: any, genericErrorDiffs: boolean): void {
   if (error instanceof ExpectationError) {
     log.enter(ERROR, `${$gry('Expectation Error:')} ${$red(error.message)}`)
     try {
+      dumpProps(log, 17, error)
       dumpStack(log, error)
       if (error.diff) printDiff(log, error.diff)
     } finally {
@@ -188,6 +188,7 @@ function dumpError(log: Logger, error: any, genericErrorDiffs: boolean): void {
     const [ message = 'Unknown Error', ...lines ] = error.message.split('\n')
     log.enter(ERROR, `${$gry('Assertion Error:')} ${$red(message)}`)
     try {
+      dumpProps(log, 15, error)
       dumpStack(log, error)
 
       // If we print diffs from generic errors, we take over
@@ -208,9 +209,12 @@ function dumpError(log: Logger, error: any, genericErrorDiffs: boolean): void {
   // Any other error also gets printed somewhat nicely
   } else if (error instanceof Error) {
     const message = error.message || 'Unknown Error'
-    const type = stringifyObjectType(error)
+    const string = stringifyObjectType(error)
+    // Chai calls its own assertion errors "AssertionError"
+    const type = string === '[AssertionError]' ? 'Assertion Error' : string
     log.enter(ERROR, `${$gry(type)}: ${$red(message)}`)
     try {
+      dumpProps(log, type.length, error)
       dumpStack(log, error)
 
       // if there are "actual" or "expected" properties on the error, diff!
@@ -229,6 +233,26 @@ function dumpError(log: Logger, error: any, genericErrorDiffs: boolean): void {
   }
 }
 
+function dumpProps(log: Logger, pad: number, error: Error): void {
+  const keys = Object.keys(error)
+      .filter((k) => ![
+        'diff', // expectations error,
+        'actual', // assertion error, chai
+        'expected', // assertion error, chai,
+        'generatedMessage', // assertion error,
+        'message', // error
+        'showDiff', // chai
+        'stack', // error
+      ].includes(k))
+      .forEach((k) => {
+        const value = error[k as keyof typeof error]
+        if ((k === 'code') && (value === 'ERR_ASSERTION')) return
+        const details = typeof value === 'string' ? value : stringifyValue(value)
+        log.error($gry(`${k}:`.padStart(pad - 1)), $ylw(details))
+      })
+  log.error('KEYS!!!', keys)
+}
+
 function dumpStack(log: Logger, error: Error): void {
   if (! error.stack) return log.error('<no stack trace>')
   error.stack

package/dist/expectation/basic.cjs

@@ -1,188 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// expectation/basic.ts
-var basic_exports = {};
-__export(basic_exports, {
-  toBeA: () => toBeA,
-  toBeCloseTo: () => toBeCloseTo,
-  toBeError: () => toBeError,
-  toBeGreaterThan: () => toBeGreaterThan,
-  toBeGreaterThanOrEqual: () => toBeGreaterThanOrEqual,
-  toBeInstanceOf: () => toBeInstanceOf,
-  toBeLessThan: () => toBeLessThan,
-  toBeLessThanOrEqual: () => toBeLessThanOrEqual,
-  toBeWithinRange: () => toBeWithinRange,
-  toEqual: () => toEqual,
-  toHaveLength: () => toHaveLength,
-  toHaveProperty: () => toHaveProperty,
-  toHaveSize: () => toHaveSize,
-  toMatch: () => toMatch,
-  toStrictlyEqual: () => toStrictlyEqual
-});
-module.exports = __toCommonJS(basic_exports);
-var import_diff = require("./diff.cjs");
-var import_types = require("./types.cjs");
-function toBeA(type, assert) {
-  const match = (0, import_types.typeOf)(this.value) === type;
-  if (match === this.negative) {
-    throw new import_types.ExpectationError(this, `to be ${(0, import_types.prefixType)(type)}`);
-  } else if (assert) {
-    assert(this.expects);
-  }
-  return this.expects;
-}
-function toBeCloseTo(value, delta) {
-  const min = value - delta;
-  const max = value + delta;
-  return this.negated.toBeWithinRange(min, max);
-}
-function toBeError(...args) {
-  const [constructor, message] = typeof args[0] === "function" ? [args[0], args[1]] : [Error, args[0]];
-  this.negated.toBeInstanceOf(constructor);
-  if (this.negative || message === void 0)
-    return this.expects;
-  return this.expects.toHaveProperty("message", (assert) => {
-    assert.toBeA("string");
-    return typeof message === "string" ? assert.toStrictlyEqual(message) : assert.toMatch(message);
-  });
-}
-function toBeGreaterThan(value) {
-  (0, import_types.assertContextType)(this, typeof value);
-  if (this.value > value !== this.negative)
-    return this.expects;
-  throw new import_types.ExpectationError(this, `to be greater than ${(0, import_types.stringifyValue)(value)}`);
-}
-function toBeGreaterThanOrEqual(value) {
-  (0, import_types.assertContextType)(this, typeof value);
-  if (this.value >= value !== this.negative)
-    return this.expects;
-  throw new import_types.ExpectationError(this, `to be greater than or equal to ${(0, import_types.stringifyValue)(value)}`);
-}
-function toBeInstanceOf(value) {
-  const match = this.value instanceof value;
-  if (match !== this.negative)
-    return this.expects;
-  throw new import_types.ExpectationError(this, `to be an instance of ${(0, import_types.stringifyConstructor)(value)}`);
-}
-function toBeLessThan(value) {
-  (0, import_types.assertContextType)(this, typeof value);
-  if (this.value < value !== this.negative)
-    return this.expects;
-  throw new import_types.ExpectationError(this, `to be less than ${(0, import_types.stringifyValue)(value)}`);
-}
-function toBeLessThanOrEqual(value) {
-  (0, import_types.assertContextType)(this, typeof value);
-  if (this.value <= value !== this.negative)
-    return this.expects;
-  throw new import_types.ExpectationError(this, `to be less than or equal to ${(0, import_types.stringifyValue)(value)}`);
-}
-function toBeWithinRange(min, max) {
-  if (max < min) {
-    const num = max;
-    max = min;
-    min = num;
-  }
-  (0, import_types.assertContextType)(this, typeof min);
-  if ((this.value >= min && this.value <= max) !== this.negative)
-    return this.expects;
-  throw new import_types.ExpectationError(this, `to be within ${(0, import_types.stringifyValue)(min)}...${(0, import_types.stringifyValue)(max)}`);
-}
-function toEqual(expected) {
-  const result = (0, import_diff.diff)(this.value, expected);
-  if (result.diff === this.negative)
-    return this.expects;
-  throw new import_types.ExpectationError(this, `to equal ${(0, import_types.stringifyValue)(expected)}`, result);
-}
-function toHaveLength(length) {
-  this.expects.toBeDefined();
-  const actualLength = this.value.length;
-  if (typeof actualLength !== "number") {
-    throw new import_types.ExpectationError(this, 'to have a numeric "length" property', false);
-  }
-  if (actualLength === length === this.negative) {
-    throw new import_types.ExpectationError(this, `to have length ${(0, import_types.stringifyValue)(length)}`);
-  }
-  return this.expects;
-}
-function toHaveProperty(prop, assert) {
-  this.expects.toBeDefined();
-  const match = this.value[prop] !== void 0;
-  if (match === this.negative) {
-    throw new import_types.ExpectationError(this, `to have property "${String(prop)}"`);
-  } else if (match && assert) {
-    try {
-      assert(this.forProperty(prop));
-    } catch (error) {
-      if (error instanceof import_types.ExpectationError && error.diff) {
-        error.diff = {
-          diff: true,
-          value: this.value,
-          props: { [prop]: error.diff }
-        };
-      }
-      throw error;
-    }
-  }
-  return this.expects;
-}
-function toHaveSize(size) {
-  this.expects.toBeDefined();
-  const actualSize = this.value.size;
-  if (typeof actualSize !== "number") {
-    throw new import_types.ExpectationError(this, 'to have a numeric "size" property', false);
-  }
-  if (actualSize === size === this.negative) {
-    throw new import_types.ExpectationError(this, `to have size ${(0, import_types.stringifyValue)(size)}`);
-  }
-  return this.expects;
-}
-function toMatch(expr) {
-  (0, import_types.assertContextType)(this, "string");
-  const match = !!this.value.match(expr);
-  if (match !== this.negative)
-    return this.expects;
-  throw new import_types.ExpectationError(this, `to match ${(0, import_types.stringifyValue)(expr)}`);
-}
-function toStrictlyEqual(expected) {
-  const match = this.value === expected;
-  if (match !== this.negative)
-    return this.expects;
-  const diff2 = this.negative ? void 0 : { diff: true, value: this.value, expected };
-  throw new import_types.ExpectationError(this, `to strictly equal ${(0, import_types.stringifyValue)(expected)}`, diff2);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  toBeA,
-  toBeCloseTo,
-  toBeError,
-  toBeGreaterThan,
-  toBeGreaterThanOrEqual,
-  toBeInstanceOf,
-  toBeLessThan,
-  toBeLessThanOrEqual,
-  toBeWithinRange,
-  toEqual,
-  toHaveLength,
-  toHaveProperty,
-  toHaveSize,
-  toMatch,
-  toStrictlyEqual
-});
-//# sourceMappingURL=basic.cjs.map

package/dist/expectation/basic.cjs.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/expectation/basic.ts"],
-  "mappings": "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",
-  "names": ["diff"]
-}

package/dist/expectation/basic.d.ts

@@ -1,90 +0,0 @@
-import type { Expectations } from './expect';
-import type { AssertedType, AssertionFunction, Constructor, JoinExpectations, TypeMappings, TypeName } from './types';
-/** Expects the value to be of the specified {@link TypeName type}. */
-declare function toBeA<T extends TypeName>(type: T): Expectations<TypeMappings[T]>;
-/**
- * Expects the value to be of the specified {@link TypeName type}, and further
- * asserts it with the specified callback.
- */
-declare function toBeA<T extends TypeName>(type: T, assert: (valueExpectations: Expectations) => void): Expectations<TypeMappings[T]>;
-/**
- * Expects the value to be a `number` within a given +/- delta range of the
- * specified `number`.
- */
-declare function toBeCloseTo(value: number, delta: number): Expectations<number>;
-/**
- * Expects the value to be a a `bigint` within a given +/- delta range of the
- * specified `bigint`.
- */
-declare function toBeCloseTo(value: bigint, delta: bigint): Expectations<bigint>;
-/** Expects the value to be an {@link Error}. */
-declare function toBeError(): Expectations<Error>;
-/** Expects the value to be an {@link Error} with the specified message. */
-declare function toBeError(message: string): Expectations<Error>;
-/**
- * Expects the value to be an {@link Error} with its message matching the
- * specified {@link RegExp}.
- */
-declare function toBeError(matcher: RegExp): Expectations<Error>;
-/** Expects the value to be an {@link Error} of the specified _type_. */
-declare function toBeError<C extends Constructor<Error>>(constructor: C): Expectations<InstanceType<C>>;
-/**
- * Expects the value to be an {@link Error} of the specified _type_  with the
- * specified message
- */
-declare function toBeError<C extends Constructor<Error>>(constructor: C, message: string): Expectations<InstanceType<C>>;
-/**
- * Expects the value to be an {@link Error} of the specified _type_  with the
- * specified message
- */
-declare function toBeError<C extends Constructor<Error>>(constructor: C, matcher: RegExp): Expectations<InstanceType<C>>;
-/** Expects the value to be a `number` greater than the specified `number`. */
-declare function toBeGreaterThan(value: number): Expectations<number>;
-/** Expects the value to be a `bigint` greater than the specified `bigint`. */
-declare function toBeGreaterThan(value: bigint): Expectations<bigint>;
-/** Expects the value to be a `number` greater than or equal to the specified `number`. */
-declare function toBeGreaterThanOrEqual(value: number): Expectations<number>;
-/** Expects the value to be a `bigint` greater than or equal to the specified `bigint`. */
-declare function toBeGreaterThanOrEqual(value: bigint): Expectations<bigint>;
-/** Expects the value to be an instance of the specified _type_. */
-declare function toBeInstanceOf<C extends Constructor>(value: C): Expectations<InstanceType<C>>;
-/** Expects the value to be a `number` less than the specified `number`. */
-declare function toBeLessThan(value: number): Expectations<number>;
-/** Expects the value to be a `bigint` less than the specified `bigint`. */
-declare function toBeLessThan(value: bigint): Expectations<bigint>;
-/** Expects the value to be a `number` less than or equal to the specified `number`. */
-declare function toBeLessThanOrEqual(value: number): Expectations<number>;
-/** Expects the value to be a `bigint` less than or equal to the specified `bigint`. */
-declare function toBeLessThanOrEqual(value: bigint): Expectations<bigint>;
-/** Expects the value to be a `number` within the specified range (inclusive). */
-declare function toBeWithinRange(min: number, max: number): Expectations<number>;
-/** Expects the value to be a `bigint` within the specified range (inclusive). */
-declare function toBeWithinRange(min: bigint, max: bigint): Expectations<bigint>;
-/** Expects the value to _deeply equal_ to the specified expected value. */
-declare function toEqual<T>(expected: T): Expectations<T>;
-/** Expects the value to have a numerical `length` property with the specified value. */
-declare function toHaveLength<T, N extends number>(this: T, length: N): JoinExpectations<T, {
-    length: N;
-}>;
-/** Expects the value to have a property. */
-declare function toHaveProperty<T, P extends string | number | symbol, A extends AssertionFunction>(this: T, prop: P): JoinExpectations<T, {
-    [key in P]: AssertedType<A>;
-}>;
-/**
- * Expects the value to have a property, and further asserts the property
- * value with the specified callback.
- */
-declare function toHaveProperty<T, P extends string | number | symbol, A extends AssertionFunction>(this: T, prop: P, assert: A): JoinExpectations<T, {
-    [key in P]: AssertedType<A>;
-}>;
-/** Expects the value to have a numerical `size` property with the specified value. */
-declare function toHaveSize<T, N extends number>(this: T, size: N): JoinExpectations<T, {
-    size: N;
-}>;
-/** Expects the value to be a `string` _matching_ the specified substring. */
-declare function toMatch(substring: string): Expectations<string>;
-/** Expects the value to be a `string` _matching_ the specified {@link RegExp}. */
-declare function toMatch(expression: RegExp): Expectations<string>;
-/** Expects the value to _strictly equal_ to the specified expected value. */
-declare function toStrictlyEqual<T>(expected: T): Expectations<T>;
-export { toBeA, toBeCloseTo, toBeError, toBeGreaterThan, toBeGreaterThanOrEqual, toBeInstanceOf, toBeLessThan, toBeLessThanOrEqual, toBeWithinRange, toEqual, toHaveLength, toHaveProperty, toHaveSize, toMatch, toStrictlyEqual, };