@plugjs/expect5 0.4.4 → 0.4.6

package/dist/expectation/matchers.d.ts

@@ -0,0 +1,375 @@
+import { Expectations, type AssertedType, type AssertionFunction, type InferMatchers } from './expectations';
+import { type Constructor, type TypeMappings, type TypeName } from './types';
+type Matcher = (expectations: Expectations) => Expectations;
+export declare class Matchers<T = unknown> {
+    private readonly _matchers;
+    readonly not: NegativeMatchers<T>;
+    constructor();
+    expect(value: unknown): T;
+    private _push;
+    /**
+     * Expects the value to be of the specified _extended_ {@link TypeName type},
+     * and (if specified) further asserts it with an {@link AssertionFunction}.
+     *
+     * Negation: {@link NegativeMatchers.toBeA `not.toBeA(...)`}
+     */
+    toBeA<Name extends TypeName, Mapped extends TypeMappings[Name], Assert extends AssertionFunction<Mapped>>(type: Name, assertion?: Assert): Matchers<AssertedType<Mapped, Assert>>;
+    /**
+     * Expects the value to be a `number` within a given +/- _delta_ range of the
+     * specified expected value.
+     *
+     * Negation: {@link NegativeMatchers.toBeCloseTo `not.toBeCloseTo(...)`}
+     */
+    toBeCloseTo(value: number, delta: number): Matchers<number>;
+    /**
+     * Expects the value to be a `bigint` within a given +/- _delta_ range of the
+     * specified expected value.
+     *
+     * Negation: {@link NegativeMatchers.toBeCloseTo `not.toBeCloseTo(...)`}
+     */
+    toBeCloseTo(value: bigint, delta: bigint): Matchers<bigint>;
+    /**
+     * Expects the value to be neither `null` nor `undefined`.
+     *
+     * Negation: {@link NegativeMatchers.toBeDefined `not.toBeDefined()`}
+     */
+    toBeDefined(): Matchers<T>;
+    /**
+     * Expect the value to be an instance of {@link Error}.
+     *
+     * If specified, the {@link Error}'s own message will be further expected to
+     * either match the specified {@link RegExp}, or equal the specified `string`.
+     */
+    toBeError(message?: string | RegExp): Matchers<Error>;
+    /**
+     * Expect the value to be an instance of {@link Error} and further asserts
+     * it to be an instance of the specifed {@link Error} {@link Constructor}.
+     *
+     * If specified, the {@link Error}'s own message will be further expected to
+     * either match the specified {@link RegExp}, or equal the specified `string`.
+     */
+    toBeError<Class extends Constructor<Error>>(constructor: Class, message?: string | RegExp): Matchers<InstanceType<Class>>;
+    /** Expects the value strictly equal to `false`. */
+    toBeFalse(): Matchers<false>;
+    /**
+     * Expects the value to be _falsy_ (zero, empty string, `false`, ...).
+     *
+     * Negation: {@link Matchers.toBeTruthy `toBeTruthy()`}
+     */
+    toBeFalsy(): Matchers<T>;
+    /**
+     * Expects the value to be a `number` greater than the specified* expected
+     * value.
+     *
+     * Negation: {@link Matchers.toBeLessThanOrEqual `toBeLessThanOrEqual(...)`}
+     */
+    toBeGreaterThan(value: number): Matchers<number>;
+    /**
+     * Expects the value to be a `bigint` greater than the specified expected
+     * value.
+     *
+     * Negation: {@link Matchers.toBeLessThanOrEqual `toBeLessThanOrEqual(...)`}
+     */
+    toBeGreaterThan(value: bigint): Matchers<bigint>;
+    /**
+     * Expects the value to be a `number` greater than or equal to the specified
+     * expected value.
+     *
+     * Negation: {@link Matchers.toBeLessThan `toBeLessThan(...)`}
+     */
+    toBeGreaterThanOrEqual(value: number): Matchers<number>;
+    /**
+     * Expects the value to be a `bigint` greater than or equal to the specified
+     * expected value.
+     *
+     * Negation: {@link Matchers.toBeLessThan `toBeLessThan(...)`}
+     */
+    toBeGreaterThanOrEqual(value: bigint): Matchers<bigint>;
+    /**
+     * Expects the value to be an instance of the specified {@link Constructor},
+     * and (if specified) further asserts it with an {@link AssertionFunction}.
+     *
+     * Negation: {@link NegativeMatchers.toBeInstanceOf `not.toInstanceOf(...)`}
+     */
+    toBeInstanceOf<Class extends Constructor, Assert extends AssertionFunction<InstanceType<Class>>>(constructor: Class, assertion?: Assert): Matchers<AssertedType<InstanceType<Class>, Assert>>;
+    /**
+     * Expects the value to be a `number` less than the specified expected value.
+     *
+     * Negation: {@link Matchers.toBeGreaterThanOrEqual `toBeGreaterThanOrEqual(...)`}
+     */
+    toBeLessThan(value: number): Matchers<number>;
+    /**
+     * Expects the value to be a `bigint` less than the specified expected value.
+     *
+     * Negation: {@link Matchers.toBeGreaterThanOrEqual `toBeGreaterThanOrEqual(...)`}
+     */
+    toBeLessThan(value: bigint): Matchers<bigint>;
+    /**
+     * Expects the value to be a `number` less than or equal to* the specified
+     * expected value.
+     *
+     * Negation: {@link Matchers.toBeGreaterThan `toBeGreaterThan(...)`}
+     */
+    toBeLessThanOrEqual(value: number): Matchers<number>;
+    /**
+     * Expects the value to be a `bigint` less than or equal to the specified
+     * expected value.
+     *
+     * Negation: {@link Matchers.toBeGreaterThan `toBeGreaterThan(...)`}
+     */
+    toBeLessThanOrEqual(value: bigint): Matchers<bigint>;
+    /**
+     * Expects the value to be `NaN`.
+     *
+     * Negation: {@link NegativeMatchers.toBeNaN `not.toBeNaN()`}
+     */
+    toBeNaN(): Matchers<number>;
+    /** Expects the value to strictly equal `null`. */
+    toBeNull(): Matchers<null>;
+    /** Expects the value to strictly equal `true`. */
+    toBeTrue(): Matchers<true>;
+    /**
+     * Expects the value to be _falsy_ (non-zero, non-empty string, ...).
+     *
+     * Negation: {@link Matchers.toBeFalsy `toBeFalsy()`}
+     */
+    toBeTruthy(): Matchers<T>;
+    /** Expects the value to strictly equal `undefined`. */
+    toBeUndefined(): Matchers<undefined>;
+    /**
+     * Expects the value to be a `number` within the specified range where the
+     * minimum and maximum values are inclusive.
+     *
+     * Negation: {@link NegativeMatchers.toBeWithinRange `not.toBeWithinRange(...)`}
+     */
+    toBeWithinRange(min: number, max: number): Matchers<number>;
+    /**
+     * Expects the value to be a `bigint` within the specified range where the
+     * minimum and maximum values are inclusive.
+     *
+     * Negation: {@link NegativeMatchers.toBeWithinRange `not.toBeWithinRange(...)`}
+     */
+    toBeWithinRange(min: bigint, max: bigint): Matchers<bigint>;
+    /**
+     * Expects the value to be _deep equal to_ the specified expected one.
+     *
+     * Negation: {@link NegativeMatchers.toEqual `not.toEqual(...)`}
+     */
+    toEqual<Type>(expected: Type): Matchers<InferMatchers<Type>>;
+    /**
+     * Expects the value to have a `number` _property_ `length` with the specified
+     * expected value.
+     *
+     * Negation: {@link NegativeMatchers.toHaveLength `not.toHaveLength(...)`}
+     */
+    toHaveLength(length: number): Matchers<T & {
+        length: number;
+    }>;
+    /**
+     * Expects the value to have the specified _property_ and (if specified)
+     * further asserts its value with an {@link AssertionFunction}.
+     *
+     * Negation: {@link NegativeMatchers.toHaveProperty `not.toHaveProperty(...)`}
+     */
+    toHaveProperty<Prop extends string | number | symbol, Assert extends AssertionFunction>(property: Prop, assertion?: Assert): Matchers<T & {
+        [keyt in Prop]: AssertedType<unknown, Assert>;
+    }>;
+    /**
+     * Expects the value to have a `number` _property_ `size` with the specified
+     * expected value.
+     *
+     * Negation: {@link NegativeMatchers.toHaveSize `not.toHaveSize(...)`}
+     */
+    toHaveSize(size: number): Matchers<T & {
+        size: number;
+    }>;
+    /**
+     * Expect the value to include _all_ properties from the specified _object_.
+     *
+     * If the object being expected is a {@link Map}, the properties specified
+     * here will be treated as _mappings_ for said {@link Map}.
+     *
+     * Negation: {@link NegativeMatchers.toInclude `not.toInclude(...)`}
+     */
+    toInclude<P extends Record<string, any>>(properties: P): Matchers<T>;
+    /**
+     * Expect the value to include _all_ mappings from the specified {@link Map}.
+     *
+     * Negation: {@link NegativeMatchers.toInclude `not.toInclude(...)`}
+     */
+    toInclude(mappings: Map<any, any>): Matchers<T>;
+    /**
+     * Expect the value to be an {@link Iterable} object includind _all_ values
+     * from the specified {@link Set}, in any order.
+     *
+     * Negation: {@link NegativeMatchers.toInclude `not.toInclude(...)`}
+     */
+    toInclude(entries: Set<any>): Matchers<T>;
+    /**
+     * Expect the value to be an {@link Iterable} object includind _all_ values
+     * from the specified _array_, in any order.
+     *
+     * Negation: {@link NegativeMatchers.toInclude `not.toInclude(...)`}
+     */
+    toInclude(values: any[]): Matchers<T>;
+    /**
+     * Expects the value to be a `string` _matching_ the specified sub-`string`
+     * or {@link RegExp}.
+     *
+     * Negation: {@link NegativeMatchers.toMatch `not.toMatch(...)`}
+     */
+    toMatch<Matcher extends string | RegExp>(matcher: Matcher): Matchers<string>;
+    /**
+     * Expect the value to be an {@link Iterable} object includind _all_ values
+     * (and only those values) from the specified _array_, in any order.
+     */
+    toMatchContents(contents: any[]): Matchers<T>;
+    /**
+     * Expect the value to be an {@link Iterable} object includind _all_ values
+     * (and only those values) from the specified {@link Set}, in any order.
+     */
+    toMatchContents(contents: Set<any>): Matchers<T>;
+    /**
+     * Expects the value to be _strictly equal to_ the specified expected one.
+     *
+     * Negation: {@link NegativeMatchers.toStrictlyEqual `not.toStrictlyEqual(...)`}
+     */
+    toStrictlyEqual<Type>(expected: Type): Matchers<Type>;
+}
+export declare class NegativeMatchers<T = unknown> {
+    private readonly _instance;
+    private readonly _matchers;
+    constructor(_instance: Matchers<T>, _matchers: Matcher[]);
+    private _push;
+    /**
+     * Expects the value _**NOT**_ to be of the specified _extended_
+     * {@link TypeName type}.
+     *
+     * Negates: {@link Matchers.toBeA `toBeA(...)`}
+     */
+    toBeA(type: TypeName): Matchers<T>;
+    /**
+     * Expects the value to be a `number` _**OUTSIDE**_ of the given +/- _delta_
+     * range of the specified expected value.
+     *
+     * Negates: {@link Matchers.toBeCloseTo `toBeCloseTo(...)`}
+     */
+    toBeCloseTo(value: number, delta: number): Matchers<number>;
+    /**
+     * Expects the value to be a `bigint` _**OUTSIDE**_ of the given +/- _delta_
+     * range of the specified expected value.
+     *
+     * Negates: {@link Matchers.toBeCloseTo `toBeCloseTo(...)`}
+     */
+    toBeCloseTo(value: bigint, delta: bigint): Matchers<bigint>;
+    /**
+     * Expects the value to be either `null` or `undefined`.
+     *
+     * Negates: {@link Matchers.toBeDefined `toBeDefined()`}
+     */
+    toBeDefined(): Matchers<null | undefined>;
+    /**
+     * Expects the value _**NOT**_ to be an instance of the specified
+     * {@link Constructor}.
+     *
+     * Negates: {@link Matchers.toBeInstanceOf `toBeInstanceOf(...)`}
+     */
+    toBeInstanceOf(constructor: Constructor): Matchers<T>;
+    /**
+     * Expects the value _**NOT**_ to be `NaN`.
+     *
+     * Negates: {@link Matchers.toBeNaN `toBeNaN()`}
+     */
+    toBeNaN(): Matchers<number>;
+    /**
+     * Expects the value to be a `number` _**OUTSIDE**_ of the specified range
+     * where minimum and maximum values are inclusive.
+     *
+     * Negates: {@link Matchers.toBeWithinRange `toBeWithinRange(...)`}
+     */
+    toBeWithinRange(min: number, max: number): Matchers<number>;
+    /**
+     * Expects the value to be a `bigint` _**OUTSIDE**_ of the specified range
+     * where minimum and maximum values are inclusive.
+     *
+     * Negates: {@link Matchers.toBeWithinRange `toBeWithinRange(...)`}
+     */
+    toBeWithinRange(min: bigint, max: bigint): Matchers<bigint>;
+    /**
+     * Expects the value _**NOT**_ to be _deep equal to_ the specified expected
+     * one.
+     *
+     * Negates: {@link Matchers.toEqual `toEqual(...)`}
+     */
+    toEqual(expected: any): Matchers<T>;
+    /**
+     * Expects the value to have a `number` _property_ `length` _different_ from
+     * the specified expected value.
+     *
+     * Negates: {@link Matchers.toHaveLength `toHaveLength(...)`}
+     */
+    toHaveLength(length: number): Matchers<T & {
+        length: number;
+    }>;
+    /**
+     * Expects the value _**NOT**_ to have the specified _property_.
+     *
+     * Negates: {@link Matchers.toHaveProperty `toHaveProperty(...)`}
+     */
+    toHaveProperty(property: string | number | symbol): Matchers<T>;
+    /**
+     * Expects the value to have a `number` _property_ `size` _different_ from
+     * the specified expected value.
+     *
+     * Negates: {@link Matchers.toHaveSize `toHaveSize(...)`}
+     */
+    toHaveSize(size: number): Matchers<T & {
+        size: number;
+    }>;
+    /**
+     * Expect the value to include _none_ of the properties from the specified
+     * _object_.
+     *
+     * If the object being expected is a {@link Map}, the properties specified
+     * here will be treated as _mappings_ for said {@link Map}.
+     *
+     * Negates: {@link Matchers.toInclude `toInclude(...)`}
+     */
+    toInclude<P extends Record<string, any>>(properties: P): Matchers<T>;
+    /**
+     * Expect the value to include _none_ of the mappings from the specified
+     * {@link Map}.
+     *
+     * Negates: {@link Matchers.toInclude `toInclude(...)`}
+     */
+    toInclude(mappings: Map<any, any>): Matchers<T>;
+    /**
+     * Expect the value to be an {@link Iterable} object includind _none_ of the
+     * values from the specified {@link Set}.
+     *
+     * Negates: {@link Matchers.toInclude `toInclude(...)`}
+     */
+    toInclude(entries: Set<any>): Matchers<T>;
+    /**
+     * Expect the value to be an {@link Iterable} object includind _none_ of the
+     * values from the specified _array_.
+     *
+     * Negates: {@link Matchers.toInclude `toInclude(...)`}
+     */
+    toInclude(values: any[]): Matchers<T>;
+    /**
+     * Expects the value to be a `string` _**NOT MATCHING**_ the specified
+     * sub-`string` or {@link RegExp}.
+     *
+     * Negates: {@link Matchers.toMatch `toMatch(...)`}
+     */
+    toMatch(matcher: string | RegExp): Matchers<string>;
+    /**
+     * Expects the value _**NOT**_ to be _strictly equal to_ the specified
+     * expected one.
+     *
+     * Negates: {@link Matchers.toStrictlyEqual `toStrictlyEqual(...)`}
+     */
+    toStrictlyEqual(expected: any): Matchers<T>;
+}
+export {};

package/dist/expectation/matchers.mjs

@@ -0,0 +1,328 @@
+// expectation/matchers.ts
+import {
+  Expectations
+} from "./expectations.mjs";
+import {
+  matcherMarker
+} from "./types.mjs";
+var Matchers = class {
+  _matchers;
+  not;
+  constructor() {
+    const matchers = [];
+    this.not = new NegativeMatchers(this, matchers);
+    this._matchers = matchers;
+  }
+  expect(value) {
+    let expectations = new Expectations(value, void 0);
+    for (const matcher of this._matchers) {
+      expectations = matcher(expectations);
+    }
+    return expectations.value;
+  }
+  _push(matcher) {
+    const matchers = new Matchers();
+    matchers._matchers.push(...this._matchers, matcher);
+    return matchers;
+  }
+  static {
+    this.prototype[matcherMarker] = matcherMarker;
+  }
+  /* ------------------------------------------------------------------------ *
+   * BASIC                                                                    *
+   * ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be of the specified _extended_ {@link TypeName type},
+   * and (if specified) further asserts it with an {@link AssertionFunction}.
+   *
+   * Negation: {@link NegativeMatchers.toBeA `not.toBeA(...)`}
+   */
+  toBeA(type, assertion) {
+    return this._push((e) => e.toBeA(type, assertion));
+  }
+  /**
+   * Expects the value to be a `number` or `bigint` within a given +/- _delta_
+   * range of the specified expected value.
+   *
+   * Negation: {@link NegativeMatchers.toBeCloseTo `not.toBeCloseTo(...)`}
+   */
+  toBeCloseTo(value, delta) {
+    return this._push((e) => e.toBeCloseTo(value, delta));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be neither `null` nor `undefined`.
+   *
+   * Negation: {@link NegativeMatchers.toBeDefined `not.toBeDefined()`}
+   */
+  toBeDefined() {
+    return this._push((e) => e.toBeDefined());
+  }
+  toBeError(constructorOrMessage, maybeMessage) {
+    const [constructor, message] = typeof constructorOrMessage === "function" ? [constructorOrMessage, maybeMessage] : [Error, constructorOrMessage];
+    return this._push((e) => e.toBeError(constructor, message));
+  }
+  /* ------------------------------------------------------------------------ */
+  /** Expects the value strictly equal to `false`. */
+  toBeFalse() {
+    return this._push((e) => e.toBeFalse());
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be _falsy_ (zero, empty string, `false`, ...).
+   *
+   * Negation: {@link Matchers.toBeTruthy `toBeTruthy()`}
+   */
+  toBeFalsy() {
+    return this._push((e) => e.toBeFalsy());
+  }
+  toBeGreaterThan(value) {
+    return this._push((e) => e.toBeGreaterThan(value));
+  }
+  toBeGreaterThanOrEqual(value) {
+    return this._push((e) => e.toBeGreaterThanOrEqual(value));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be an instance of the specified {@link Constructor},
+   * and (if specified) further asserts it with an {@link AssertionFunction}.
+   *
+   * Negation: {@link NegativeMatchers.toBeInstanceOf `not.toInstanceOf(...)`}
+   */
+  toBeInstanceOf(constructor, assertion) {
+    return this._push((e) => e.toBeInstanceOf(constructor, assertion));
+  }
+  toBeLessThan(value) {
+    return this._push((e) => e.toBeLessThan(value));
+  }
+  toBeLessThanOrEqual(value) {
+    return this._push((e) => e.toBeLessThanOrEqual(value));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be `NaN`.
+   *
+   * Negation: {@link NegativeMatchers.toBeNaN `not.toBeNaN()`}
+   */
+  toBeNaN() {
+    return this._push((e) => e.toBeNaN());
+  }
+  /* ------------------------------------------------------------------------ */
+  /** Expects the value to strictly equal `null`. */
+  toBeNull() {
+    return this._push((e) => e.toBeNull());
+  }
+  /* ------------------------------------------------------------------------ */
+  /** Expects the value to strictly equal `true`. */
+  toBeTrue() {
+    return this._push((e) => e.toBeTrue());
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be _falsy_ (non-zero, non-empty string, ...).
+   *
+   * Negation: {@link Matchers.toBeFalsy `toBeFalsy()`}
+   */
+  toBeTruthy() {
+    return this._push((e) => e.toBeTruthy());
+  }
+  /* ------------------------------------------------------------------------ */
+  /** Expects the value to strictly equal `undefined`. */
+  toBeUndefined() {
+    return this._push((e) => e.toBeUndefined());
+  }
+  /**
+   * Expects the value to be a `number` or `bigint` within the specified range
+   * where minimum and maximum values are inclusive.
+   *
+   * Negation: {@link NegativeMatchers.toBeWithinRange `not.toBeWithinRange(...)`}
+   */
+  toBeWithinRange(min, max) {
+    return this._push((e) => e.toBeWithinRange(min, max));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be _deep equal to_ the specified expected one.
+   *
+   * Negation: {@link NegativeMatchers.toEqual `not.toEqual(...)`}
+   */
+  toEqual(expected) {
+    return this._push((e) => e.toEqual(expected));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to have a `number` _property_ `length` with the specified
+   * expected value.
+   *
+   * Negation: {@link NegativeMatchers.toHaveLength `not.toHaveLength(...)`}
+   */
+  toHaveLength(length) {
+    return this._push((e) => e.toHaveLength(length));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to have the specified _property_ and (if specified)
+   * further asserts its value with an {@link AssertionFunction}.
+   *
+   * Negation: {@link NegativeMatchers.toHaveProperty `not.toHaveProperty(...)`}
+   */
+  toHaveProperty(property, assertion) {
+    return this._push((e) => e.toHaveProperty(property, assertion));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to have a `number` _property_ `size` with the specified
+   * expected value.
+   *
+   * Negation: {@link NegativeMatchers.toHaveSize `not.toHaveSize(...)`}
+   */
+  toHaveSize(size) {
+    return this._push((e) => e.toHaveSize(size));
+  }
+  toInclude(contents) {
+    return this._push((e) => e.toInclude(contents));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be a `string` _matching_ the specified sub-`string`
+   * or {@link RegExp}.
+   *
+   * Negation: {@link NegativeMatchers.toMatch `not.toMatch(...)`}
+   */
+  toMatch(matcher) {
+    return this._push((e) => e.toMatch(matcher));
+  }
+  toMatchContents(contents) {
+    return this._push((e) => e.toMatchContents(contents));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be _strictly equal to_ the specified expected one.
+   *
+   * Negation: {@link NegativeMatchers.toStrictlyEqual `not.toStrictlyEqual(...)`}
+   */
+  toStrictlyEqual(expected) {
+    return this._push((e) => e.toStrictlyEqual(expected));
+  }
+};
+var NegativeMatchers = class {
+  constructor(_instance, _matchers) {
+    this._instance = _instance;
+    this._matchers = _matchers;
+  }
+  _push(matcher) {
+    this._matchers.push((expectations) => matcher(expectations.not));
+    return this._instance;
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value _**NOT**_ to be of the specified _extended_
+   * {@link TypeName type}.
+   *
+   * Negates: {@link Matchers.toBeA `toBeA(...)`}
+   */
+  toBeA(type) {
+    return this._push((e) => e.toBeA(type));
+  }
+  toBeCloseTo(value, delta) {
+    return this._push((e) => e.toBeCloseTo(value, delta));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be either `null` or `undefined`.
+   *
+   * Negates: {@link Matchers.toBeDefined `toBeDefined()`}
+   */
+  toBeDefined() {
+    return this._push((e) => e.toBeDefined());
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value _**NOT**_ to be an instance of the specified
+   * {@link Constructor}.
+   *
+   * Negates: {@link Matchers.toBeInstanceOf `toBeInstanceOf(...)`}
+   */
+  toBeInstanceOf(constructor) {
+    return this._push((e) => e.toBeInstanceOf(constructor));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value _**NOT**_ to be `NaN`.
+   *
+   * Negates: {@link Matchers.toBeNaN `toBeNaN()`}
+   */
+  toBeNaN() {
+    return this._push((e) => e.toBeNaN());
+  }
+  toBeWithinRange(min, max) {
+    return this._push((e) => e.toBeWithinRange(min, max));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value _**NOT**_ to be _deep equal to_ the specified expected
+   * one.
+   *
+   * Negates: {@link Matchers.toEqual `toEqual(...)`}
+   */
+  toEqual(expected) {
+    return this._push((e) => e.toEqual(expected));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to have a `number` _property_ `length` _different_ from
+   * the specified expected value.
+   *
+   * Negates: {@link Matchers.toHaveLength `toHaveLength(...)`}
+   */
+  toHaveLength(length) {
+    return this._push((e) => e.toHaveLength(length));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value _**NOT**_ to have the specified _property_.
+   *
+   * Negates: {@link Matchers.toHaveProperty `toHaveProperty(...)`}
+   */
+  toHaveProperty(property) {
+    return this._push((e) => e.toHaveProperty(property));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to have a `number` _property_ `size` _different_ from
+   * the specified expected value.
+   *
+   * Negates: {@link Matchers.toHaveSize `toHaveSize(...)`}
+   */
+  toHaveSize(size) {
+    return this._push((e) => e.toHaveSize(size));
+  }
+  toInclude(contents) {
+    return this._push((e) => e.toInclude(contents));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value to be a `string` _**NOT MATCHING**_ the specified
+   * sub-`string` or {@link RegExp}.
+   *
+   * Negates: {@link Matchers.toMatch `toMatch(...)`}
+   */
+  toMatch(matcher) {
+    return this._push((e) => e.toMatch(matcher));
+  }
+  /* ------------------------------------------------------------------------ */
+  /**
+   * Expects the value _**NOT**_ to be _strictly equal to_ the specified
+   * expected one.
+   *
+   * Negates: {@link Matchers.toStrictlyEqual `toStrictlyEqual(...)`}
+   */
+  toStrictlyEqual(expected) {
+    return this._push((e) => e.toStrictlyEqual(expected));
+  }
+};
+export {
+  Matchers,
+  NegativeMatchers
+};
+//# sourceMappingURL=matchers.mjs.map