@augment-vir/assert 31.0.0 → 31.1.0

package/dist/assertions/promise.js

@@ -1,44 +1,155 @@
 import { stringify } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
-import { autoGuard, autoGuardSymbol } from '../guard-types/guard-override.js';
 import { createWaitUntil } from '../guard-types/wait-until-function.js';
-function isPromiseLike(actual, failureMessage) {
-    if (!(actual instanceof Promise) &&
-        !(actual &&
-            typeof actual === 'object' &&
-            'then' in actual &&
-            typeof actual.then === 'function')) {
-        throw new AssertionError(`'${stringify(actual)}' is not a PromiseLike.`, failureMessage);
-    }
-}
-function isNotPromiseLike(actual, failureMessage) {
-    try {
-        isPromiseLike(actual);
-    }
-    catch {
-        return;
-    }
-    throw new AssertionError(`'${stringify(actual)}' is a PromiseLike.`, failureMessage);
-}
-/**
- * Checks if a value is an actual `Promise` object. In reality this is just a simple wrapper for
- * `instanceof Promise`, but it makes checking a bit more ergonomic.
- */
-function isPromise(actual, failureMessage) {
-    if (!(actual instanceof Promise)) {
-        throw new AssertionError(`'${stringify(actual)}' is not a Promise.`, failureMessage);
-    }
-}
-function isNotPromise(actual, failureMessage) {
-    if (actual instanceof Promise) {
-        throw new AssertionError(`'${stringify(actual)}' is a Promise.`, failureMessage);
-    }
-}
 const assertions = {
-    isPromiseLike,
-    isNotPromiseLike,
-    isPromise,
-    isNotPromise,
+    /**
+     * Asserts that a value is a `PromiseLike`.
+     *
+     * `PromiseLike` is TypeScript built-in type that has a `.then` method and thus behaves like a
+     * promise. This is also referred to as a "thenable". This enables the use of third-party
+     * promise implementations that aren't instances of the built-in `Promise` class.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * class CustomThenable {
+     *     constructor(public value: any) {}
+     *
+     *     then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
+     *         return new CustomThenable(onFulfilled ? onFulfilled(this.value) : this.value);
+     *     }
+     * }
+     *
+     * assert.isPromiseLike(Promise.resolve(5)); // passes
+     * assert.isPromiseLike(new CustomThenable(5)); // passes
+     * assert.isPromiseLike(5); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNotPromiseLike} : the opposite assertion.
+     * - {@link assert.isPromise} : the more precise assertion.
+     */
+    isPromiseLike(actual, failureMessage) {
+        if (!(actual instanceof Promise) &&
+            !(actual &&
+                typeof actual === 'object' &&
+                'then' in actual &&
+                typeof actual.then === 'function')) {
+            throw new AssertionError(`'${stringify(actual)}' is not a PromiseLike.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a `PromiseLike`.
+     *
+     * `PromiseLike` is TypeScript built-in type that has a `.then` method and thus behaves like a
+     * promise. This is also referred to as a "thenable". This enables the use of third-party
+     * promise implementations that aren't instances of the built-in `Promise` class.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * class CustomThenable {
+     *     constructor(public value: any) {}
+     *
+     *     then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
+     *         return new CustomThenable(onFulfilled ? onFulfilled(this.value) : this.value);
+     *     }
+     * }
+     *
+     * assert.isNotPromiseLike(Promise.resolve(5)); // fails
+     * assert.isNotPromiseLike(new CustomThenable(5)); // fails
+     * assert.isNotPromiseLike(5); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isPromiseLike} : the opposite assertion.
+     * - {@link assert.isNotPromise} : the more precise assertion.
+     */
+    isNotPromiseLike(actual, failureMessage) {
+        if (actual instanceof Promise ||
+            (actual &&
+                typeof actual === 'object' &&
+                'then' in actual &&
+                typeof actual.then === 'function')) {
+            throw new AssertionError(`'${stringify(actual)}' is a PromiseLike.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a `Promise` instance.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * class CustomThenable {
+     *     constructor(public value: any) {}
+     *
+     *     then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
+     *         return new CustomThenable(onFulfilled ? onFulfilled(this.value) : this.value);
+     *     }
+     * }
+     *
+     * assert.isPromise(Promise.resolve(5)); // passes
+     * assert.isPromise(new CustomThenable(5)); // fails
+     * assert.isPromise(5); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNotPromise} : the opposite assertion.
+     * - {@link assert.isPromiseLike} : the more lenient assertion.
+     */
+    isPromise(actual, failureMessage) {
+        if (!(actual instanceof Promise)) {
+            throw new AssertionError(`'${stringify(actual)}' is not a Promise.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a _not_ `Promise` instance.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * class CustomThenable {
+     *     constructor(public value: any) {}
+     *
+     *     then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
+     *         return new CustomThenable(onFulfilled ? onFulfilled(this.value) : this.value);
+     *     }
+     * }
+     *
+     * assert.isNotPromise(Promise.resolve(5)); // fails
+     * assert.isNotPromise(new CustomThenable(5)); // passes
+     * assert.isNotPromise(5); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isPromise} : the opposite assertion.
+     * - {@link assert.isNotPromiseLike} : the more lenient assertion.
+     */
+    isNotPromise(actual, failureMessage) {
+        if (actual instanceof Promise) {
+            throw new AssertionError(`'${stringify(actual)}' is a Promise.`, failureMessage);
+        }
+    },
 };
 export const promiseGuards = {
     assert: assertions,
@@ -76,7 +187,13 @@ export const promiseGuards = {
          * - {@link check.isNotPromiseLike} : the opposite check.
          * - {@link check.isPromise} : the more precise check.
          */
-        isPromiseLike: autoGuardSymbol,
+        isPromiseLike(actual) {
+            return !!(actual instanceof Promise ||
+                (actual &&
+                    typeof actual === 'object' &&
+                    'then' in actual &&
+                    typeof actual.then === 'function'));
+        },
         /**
          * Checks that a value is _not_ a `PromiseLike`.
          *
@@ -110,7 +227,13 @@ export const promiseGuards = {
          * - {@link check.isPromiseLike} : the opposite check.
          * - {@link check.isNotPromise} : the more precise check.
          */
-        isNotPromiseLike: autoGuard(),
+        isNotPromiseLike(actual) {
+            return !(actual instanceof Promise ||
+                (actual &&
+                    typeof actual === 'object' &&
+                    'then' in actual &&
+                    typeof actual.then === 'function'));
+        },
         /**
          * Checks that a value is a `Promise` instance.
          *
@@ -140,7 +263,9 @@ export const promiseGuards = {
          * - {@link check.isNotPromise} : the opposite check.
          * - {@link check.isPromiseLike} : the more lenient check.
          */
-        isPromise: autoGuardSymbol,
+        isPromise(actual) {
+            return actual instanceof Promise;
+        },
         /**
          * Checks that a value is a _not_ `Promise` instance.
          *
@@ -170,7 +295,9 @@ export const promiseGuards = {
          * - {@link check.isPromise} : the opposite check.
          * - {@link check.isNotPromiseLike} : the more lenient check.
          */
-        isNotPromise: autoGuard(),
+        isNotPromise(actual) {
+            return !(actual instanceof Promise);
+        },
     },
     assertWrap: {
         /**
@@ -208,7 +335,16 @@ export const promiseGuards = {
          * - {@link assertWrap.isNotPromiseLike} : the opposite assertion.
          * - {@link assertWrap.isPromise} : the more precise assertion.
          */
-        isPromiseLike: autoGuard(),
+        isPromiseLike(actual, failureMessage) {
+            if (!(actual instanceof Promise) &&
+                !(actual &&
+                    typeof actual === 'object' &&
+                    'then' in actual &&
+                    typeof actual.then === 'function')) {
+                throw new AssertionError(`'${stringify(actual)}' is not a PromiseLike.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a `PromiseLike`. Returns the value if the assertion passes.
          *
@@ -244,7 +380,16 @@ export const promiseGuards = {
          * - {@link assertWrap.isPromiseLike} : the opposite assertion.
          * - {@link assertWrap.isNotPromise} : the more precise assertion.
          */
-        isNotPromiseLike: autoGuard(),
+        isNotPromiseLike(actual, failureMessage) {
+            if (actual instanceof Promise ||
+                (actual &&
+                    typeof actual === 'object' &&
+                    'then' in actual &&
+                    typeof actual.then === 'function')) {
+                throw new AssertionError(`'${stringify(actual)}' is a PromiseLike.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a `Promise` instance. Returns the value if the assertion passes.
          *
@@ -276,7 +421,12 @@ export const promiseGuards = {
          * - {@link assertWrap.isNotPromise} : the opposite assertion.
          * - {@link assertWrap.isPromiseLike} : the more lenient assertion.
          */
-        isPromise: autoGuard(),
+        isPromise(actual, failureMessage) {
+            if (!(actual instanceof Promise)) {
+                throw new AssertionError(`'${stringify(actual)}' is not a Promise.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a _not_ `Promise` instance. Returns the value if the assertion
          * passes.
@@ -309,7 +459,12 @@ export const promiseGuards = {
          * - {@link assertWrap.isPromise} : the opposite assertion.
          * - {@link assertWrap.isNotPromiseLike} : the more lenient assertion.
          */
-        isNotPromise: autoGuard(),
+        isNotPromise(actual, failureMessage) {
+            if (actual instanceof Promise) {
+                throw new AssertionError(`'${stringify(actual)}' is a Promise.`, failureMessage);
+            }
+            return actual;
+        },
     },
     checkWrap: {
         /**
@@ -346,7 +501,18 @@ export const promiseGuards = {
          * - {@link checkWrap.isNotPromiseLike} : the opposite check.
          * - {@link checkWrap.isPromise} : the more precise check.
          */
-        isNotPromise: autoGuard(),
+        isPromiseLike(actual) {
+            if (actual instanceof Promise ||
+                (actual &&
+                    typeof actual === 'object' &&
+                    'then' in actual &&
+                    typeof actual.then === 'function')) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is _not_ a `PromiseLike`. Returns the value if the check passes,
          * otherwise `undefined`.
@@ -381,7 +547,18 @@ export const promiseGuards = {
          * - {@link checkWrap.isPromiseLike} : the opposite check.
          * - {@link checkWrap.isNotPromise} : the more precise check.
          */
-        isNotPromiseLike: autoGuard(),
+        isNotPromiseLike(actual) {
+            if (actual instanceof Promise ||
+                (actual &&
+                    typeof actual === 'object' &&
+                    'then' in actual &&
+                    typeof actual.then === 'function')) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is a `Promise` instance. Returns the value if the check passes,
          * otherwise `undefined`.
@@ -412,7 +589,14 @@ export const promiseGuards = {
          * - {@link checkWrap.isNotPromise} : the opposite check.
          * - {@link checkWrap.isPromiseLike} : the more lenient check.
          */
-        isPromise: autoGuardSymbol,
+        isPromise(actual) {
+            if (actual instanceof Promise) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a _not_ `Promise` instance. Returns the value if the check passes,
          * otherwise `undefined`.
@@ -443,7 +627,14 @@ export const promiseGuards = {
          * - {@link checkWrap.isPromise} : the opposite check.
          * - {@link checkWrap.isNotPromiseLike} : the more lenient check.
          */
-        isPromiseLike: autoGuardSymbol,
+        isNotPromise(actual) {
+            if (actual instanceof Promise) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -482,7 +673,7 @@ export const promiseGuards = {
          * - {@link waitUntil.isNotPromiseLike} : the opposite assertion.
          * - {@link waitUntil.isPromise} : the more precise assertion.
          */
-        isPromiseLike: createWaitUntil(isPromiseLike, true),
+        isPromiseLike: createWaitUntil(assertions.isPromiseLike, true),
         /**
          * Repeatedly calls a callback until its output is _not_ a `PromiseLike`. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -519,7 +710,7 @@ export const promiseGuards = {
          * - {@link waitUntil.isPromiseLike} : the opposite assertion.
          * - {@link waitUntil.isNotPromise} : the more precise assertion.
          */
-        isNotPromiseLike: createWaitUntil(isNotPromiseLike, true),
+        isNotPromiseLike: createWaitUntil(assertions.isNotPromiseLike, true),
         /**
          * Repeatedly calls a callback until its output is a `Promise` instance. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -552,7 +743,7 @@ export const promiseGuards = {
          * - {@link waitUntil.isNotPromise} : the opposite assertion.
          * - {@link waitUntil.isPromiseLike} : the more lenient assertion.
          */
-        isPromise: createWaitUntil(isPromise, true),
+        isPromise: createWaitUntil(assertions.isPromise, true),
         /**
          * Repeatedly calls a callback until its output is a _not_ `Promise` instance. Once the
          * callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -585,6 +776,6 @@ export const promiseGuards = {
          * - {@link waitUntil.isPromise} : the opposite assertion.
          * - {@link waitUntil.isNotPromiseLike} : the more lenient assertion.
          */
-        isNotPromise: createWaitUntil(isNotPromise, true),
+        isNotPromise: createWaitUntil(assertions.isNotPromise, true),
     },
 };

package/dist/assertions/regexp.d.ts

@@ -1,6 +1,5 @@
-import { autoGuardSymbol } from '../guard-types/guard-override.js';
-declare function matches(actual: string, expected: RegExp, failureMessage?: string | undefined): void;
-declare function mismatches(actual: string, expected: RegExp, failureMessage?: string | undefined): void;
+import type { MaybePromise } from '@augment-vir/core';
+import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
 export declare const regexpGuards: {
     assert: {
         /**
@@ -21,7 +20,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link assert.mismatches} : the opposite assertion.
          */
-        matches: typeof matches;
+        matches(this: void, actual: string, expected: RegExp, failureMessage?: string | undefined): void;
         /**
          * Asserts that a string (first input, `actual`) does _not_ match a RegExp (second input,
          * `expected`).
@@ -41,7 +40,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link assert.matches} : the opposite assertion.
          */
-        mismatches: typeof mismatches;
+        mismatches(this: void, actual: string, expected: RegExp, failureMessage?: string | undefined): void;
     };
     check: {
         /**
@@ -61,7 +60,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link check.mismatches} : the opposite check.
          */
-        matches: typeof autoGuardSymbol;
+        matches(this: void, actual: string, expected: RegExp): boolean;
         /**
          * Checks that a string (first input, `actual`) does _not_ match a RegExp (second input,
          * `expected`).
@@ -80,7 +79,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link check.matches} : the opposite check.
          */
-        mismatches: typeof autoGuardSymbol;
+        mismatches(this: void, actual: string, expected: RegExp): boolean;
     };
     assertWrap: {
         /**
@@ -103,7 +102,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link assertWrap.mismatches} : the opposite assertion.
          */
-        matches: typeof autoGuardSymbol;
+        matches(this: void, actual: string, expected: RegExp, failureMessage?: string | undefined): string;
         /**
          * Asserts that a string (first input, `actual`) does _not_ match a RegExp (second input,
          * `expected`). Returns the string if the assertion passes.
@@ -124,7 +123,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link assertWrap.matches} : the opposite assertion.
          */
-        mismatches: typeof autoGuardSymbol;
+        mismatches(this: void, actual: string, expected: RegExp, failureMessage?: string | undefined): string;
     };
     checkWrap: {
         /**
@@ -146,7 +145,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link checkWrap.mismatches} : the opposite check.
          */
-        matches: typeof autoGuardSymbol;
+        matches(this: void, actual: string, expected: RegExp): string | undefined;
         /**
          * Checks that a string (first input, `actual`) does _not_ match a RegExp (second input,
          * `expected`). Returns the string if the check passes, otherwise `undefined`.
@@ -166,7 +165,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link checkWrap.matches} : the opposite check.
          */
-        mismatches: typeof autoGuardSymbol;
+        mismatches(this: void, actual: string, expected: RegExp): string | undefined;
     };
     waitUntil: {
         /**
@@ -190,7 +189,7 @@ export declare const regexpGuards: {
          * @see
          * - {@link waitUntil.mismatches} : the opposite assertion.
          */
-        matches: typeof autoGuardSymbol;
+        matches: (this: void, expected: RegExp, callback: () => MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<string>;
         /**
          * Repeatedly calls a callback until its output is a string that does _not_ match a RegExp
          * (first input, `expected`). Once the callback output passes, it is returned. If the
@@ -212,7 +211,6 @@ export declare const regexpGuards: {
          * @see
          * - {@link waitUntil.matches} : the opposite assertion.
          */
-        mismatches: typeof autoGuardSymbol;
+        mismatches: (this: void, expected: RegExp, callback: () => MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<string>;
     };
 };
-export {};

package/dist/assertions/regexp.js

@@ -1,18 +1,53 @@
 import { AssertionError } from '../augments/assertion.error.js';
-import { autoGuardSymbol } from '../guard-types/guard-override.js';
-function matches(actual, expected, failureMessage) {
-    if (!expected.test(actual)) {
-        throw new AssertionError(`'${actual}' does not match ${expected}`, failureMessage);
-    }
-}
-function mismatches(actual, expected, failureMessage) {
-    if (expected.test(actual)) {
-        throw new AssertionError(`'${actual}' matches ${expected}`, failureMessage);
-    }
-}
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
 const assertions = {
-    matches,
-    mismatches,
+    /**
+     * Asserts that a string (first input, `actual`) matches a RegExp (second input, `expected`).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.matches('hi', /^h/); // passes
+     * assert.matches('hi', /^g/); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.mismatches} : the opposite assertion.
+     */
+    matches(actual, expected, failureMessage) {
+        if (!expected.test(actual)) {
+            throw new AssertionError(`'${actual}' does not match ${expected}`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a string (first input, `actual`) does _not_ match a RegExp (second input,
+     * `expected`).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.mismatches('hi', /^h/); // fails
+     * assert.mismatches('hi', /^g/); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.matches} : the opposite assertion.
+     */
+    mismatches(actual, expected, failureMessage) {
+        if (expected.test(actual)) {
+            throw new AssertionError(`'${actual}' matches ${expected}`, failureMessage);
+        }
+    },
 };
 export const regexpGuards = {
     assert: assertions,
@@ -34,7 +69,9 @@ export const regexpGuards = {
          * @see
          * - {@link check.mismatches} : the opposite check.
          */
-        matches: autoGuardSymbol,
+        matches(actual, expected) {
+            return !!expected.test(actual);
+        },
         /**
          * Checks that a string (first input, `actual`) does _not_ match a RegExp (second input,
          * `expected`).
@@ -53,7 +90,9 @@ export const regexpGuards = {
          * @see
          * - {@link check.matches} : the opposite check.
          */
-        mismatches: autoGuardSymbol,
+        mismatches(actual, expected) {
+            return !expected.test(actual);
+        },
     },
     assertWrap: {
         /**
@@ -76,7 +115,12 @@ export const regexpGuards = {
          * @see
          * - {@link assertWrap.mismatches} : the opposite assertion.
          */
-        matches: autoGuardSymbol,
+        matches(actual, expected, failureMessage) {
+            if (!expected.test(actual)) {
+                throw new AssertionError(`'${actual}' does not match ${expected}`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a string (first input, `actual`) does _not_ match a RegExp (second input,
          * `expected`). Returns the string if the assertion passes.
@@ -97,7 +141,12 @@ export const regexpGuards = {
          * @see
          * - {@link assertWrap.matches} : the opposite assertion.
          */
-        mismatches: autoGuardSymbol,
+        mismatches(actual, expected, failureMessage) {
+            if (expected.test(actual)) {
+                throw new AssertionError(`'${actual}' matches ${expected}`, failureMessage);
+            }
+            return actual;
+        },
     },
     checkWrap: {
         /**
@@ -119,7 +168,14 @@ export const regexpGuards = {
          * @see
          * - {@link checkWrap.mismatches} : the opposite check.
          */
-        matches: autoGuardSymbol,
+        matches(actual, expected) {
+            if (expected.test(actual)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a string (first input, `actual`) does _not_ match a RegExp (second input,
          * `expected`). Returns the string if the check passes, otherwise `undefined`.
@@ -139,7 +195,14 @@ export const regexpGuards = {
          * @see
          * - {@link checkWrap.matches} : the opposite check.
          */
-        mismatches: autoGuardSymbol,
+        mismatches(actual, expected) {
+            if (expected.test(actual)) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -163,7 +226,7 @@ export const regexpGuards = {
          * @see
          * - {@link waitUntil.mismatches} : the opposite assertion.
          */
-        matches: autoGuardSymbol,
+        matches: createWaitUntil(assertions.matches, true),
         /**
          * Repeatedly calls a callback until its output is a string that does _not_ match a RegExp
          * (first input, `expected`). Once the callback output passes, it is returned. If the
@@ -185,6 +248,6 @@ export const regexpGuards = {
          * @see
          * - {@link waitUntil.matches} : the opposite assertion.
          */
-        mismatches: autoGuardSymbol,
+        mismatches: createWaitUntil(assertions.mismatches, true),
     },
 };