@augment-vir/assert 30.8.4 → 31.0.1

package/dist/assertions/runtime-type.js

@@ -1,90 +1,467 @@
 import { stringify, } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
-import { autoGuard, autoGuardSymbol } from '../guard-types/guard-override.js';
-function isNotArray(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'array', failureMessage);
-}
-function isNotBigInt(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'bigint', failureMessage);
-}
-function isNotBoolean(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'boolean', failureMessage);
-}
-function isNotFunction(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'function', failureMessage);
-}
-function isNotNumber(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'number', failureMessage);
-}
-function isNotObject(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'object', failureMessage);
-}
-function isNotString(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'string', failureMessage);
-}
-function isNotSymbol(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'symbol', failureMessage);
-}
-function isNotUndefined(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'undefined', failureMessage);
-}
-function isNotNull(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'null', failureMessage);
-}
-function isArray(actual, failureMessage) {
-    assertRuntimeType(actual, 'array', failureMessage);
-}
-function isBigInt(actual, failureMessage) {
-    assertRuntimeType(actual, 'bigint', failureMessage);
-}
-function isBoolean(actual, failureMessage) {
-    assertRuntimeType(actual, 'boolean', failureMessage);
-}
-function isFunction(actual, failureMessage) {
-    assertRuntimeType(actual, 'function', failureMessage);
-}
-export function isNumber(actual, failureMessage) {
-    assertRuntimeType(actual, 'number', failureMessage);
-    if (isNaN(actual)) {
-        throw new AssertionError('Value is NaN.', failureMessage);
-    }
-}
-function isObject(actual, failureMessage) {
-    assertRuntimeType(actual, 'object', failureMessage);
-}
-function isString(actual, failureMessage) {
-    assertRuntimeType(actual, 'string', failureMessage);
-}
-function isSymbol(actual, failureMessage) {
-    assertRuntimeType(actual, 'symbol', failureMessage);
-}
-function isUndefined(actual, failureMessage) {
-    assertRuntimeType(actual, 'undefined', failureMessage);
-}
-function isNull(actual, failureMessage) {
-    assertRuntimeType(actual, 'null', failureMessage);
-}
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
 const assertions = {
-    isArray,
-    isBigInt,
-    isBoolean,
-    isFunction,
-    isNull,
-    isNumber,
-    isObject,
-    isString,
-    isSymbol,
-    isUndefined,
-    isNotArray,
-    isNotBigInt,
-    isNotBoolean,
-    isNotFunction,
-    isNotNull,
-    isNotNumber,
-    isNotObject,
-    isNotString,
-    isNotSymbol,
-    isNotUndefined,
+    /**
+     * Asserts that a value is an array.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isArray([]); // passes
+     * assert.isArray({length: 4}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotArray} : the opposite assertion.
+     */
+    isArray(actual, failureMessage) {
+        if (!Array.isArray(actual)) {
+            throw new AssertionError(`'${stringify(actual)}' is not an array.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a BigInt.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isBigInt(123n); // passes
+     * assert.isBigInt(123); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotBigInt} : the opposite assertion.
+     */
+    isBigInt(actual, failureMessage) {
+        if (typeof actual !== 'bigint') {
+            throw new AssertionError(`'${stringify(actual)}' is not a bigint.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a boolean.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isBoolean(true); // passes
+     * assert.isBoolean('true'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotBoolean} : the opposite assertion.
+     */
+    isBoolean(actual, failureMessage) {
+        if (typeof actual !== 'boolean') {
+            throw new AssertionError(`'${stringify(actual)}' is not a boolean.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a function.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isFunction(() => {}); // passes
+     * assert.isFunction({}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isFunction(actual, failureMessage) {
+        if (typeof actual !== 'function') {
+            throw new AssertionError(`'${stringify(actual)}' is not a function.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is exactly `null`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNull(null); // passes
+     * assert.isNull(undefined); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isNull(actual, failureMessage) {
+        if (actual !== null) {
+            throw new AssertionError(`'${stringify(actual)}' is not nul.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a number. This excludes `NaN`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNumber(123); // passes
+     * assert.isNumber(123n); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isNumber(actual, failureMessage) {
+        if (typeof actual !== 'number' || isNaN(actual)) {
+            throw new AssertionError(`'${stringify(actual)}' is not a number.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is an object. This excludes arrays.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isObject({}); // passes
+     * assert.isObject([]); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isObject(actual, failureMessage) {
+        if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
+            throw new AssertionError(`'${stringify(actual)}' is not a non-null object.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a string.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isString(''); // passes
+     * assert.isString(5); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isString(actual, failureMessage) {
+        if (typeof actual !== 'string') {
+            throw new AssertionError(`'${stringify(actual)}' is not a string.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a symbol.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isSymbol(Symbol('my-symbol')); // passes
+     * assert.isSymbol('my-symbol'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isSymbol(actual, failureMessage) {
+        if (typeof actual !== 'symbol') {
+            throw new AssertionError(`'${stringify(actual)}' is not a symbol.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is exactly `undefined`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isUndefined(undefined); // passes
+     * assert.isUndefined(null); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isUndefined(actual, failureMessage) {
+        if (typeof actual !== 'undefined') {
+            throw new AssertionError(`'${stringify(actual)}' is not a undefined.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ an array.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotArray([]); // fails
+     * assert.isNotArray({length: 4}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isArray} : the opposite assertion.
+     */
+    isNotArray(actual, failureMessage) {
+        if (Array.isArray(actual)) {
+            throw new AssertionError(`'${stringify(actual)}' is an array.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a BigInt.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotBigInt(123n); // fails
+     * assert.isNotBigInt(123); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isBigInt} : the opposite assertion.
+     */
+    isNotBigInt(actual, failureMessage) {
+        if (typeof actual === 'bigint') {
+            throw new AssertionError(`'${stringify(actual)}' is a bigint.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a boolean.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotBoolean(true); // fails
+     * assert.isNotBoolean('true'); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isBoolean} : the opposite assertion.
+     */
+    isNotBoolean(actual, failureMessage) {
+        if (typeof actual === 'boolean') {
+            throw new AssertionError(`'${stringify(actual)}' is a boolean.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a function.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotFunction(() => {}); // fails
+     * assert.isNotFunction({}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotFunction(actual, failureMessage) {
+        if (typeof actual === 'function') {
+            throw new AssertionError(`'${stringify(actual)}' is a function.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ exactly `null`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotNull(null); // fails
+     * assert.isNotNull(undefined); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed. @see
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotNull(actual, failureMessage) {
+        if (actual === null) {
+            throw new AssertionError(`'${stringify(actual)}' is a null.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a number. This includes `NaN`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotNumber(123); // fails
+     * assert.isNotNumber(123n); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isNotNumber(actual, failureMessage) {
+        if (typeof actual === 'number') {
+            throw new AssertionError(`'${stringify(actual)}' is a number.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ an object. This includes arrays.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotObject({}); // fails
+     * assert.isNotObject([]); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotObject(actual, failureMessage) {
+        if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
+            throw new AssertionError(`'${stringify(actual)}' is a non-null object.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a string.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotString(''); // fails
+     * assert.isNotString(5); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotString(actual, failureMessage) {
+        if (typeof actual === 'string') {
+            throw new AssertionError(`'${stringify(actual)}' is a string.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a symbol.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotSymbol(Symbol('my-symbol')); // fails
+     * assert.isNotSymbol('my-symbol'); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotSymbol(actual, failureMessage) {
+        if (typeof actual === 'symbol') {
+            throw new AssertionError(`'${stringify(actual)}' is a symbol.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ exactly `undefined`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotUndefined(undefined); // fails
+     * assert.isNotUndefined(null); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotUndefined(actual, failureMessage) {
+        if (typeof actual === 'undefined') {
+            throw new AssertionError(`'${stringify(actual)}' is a undefined.`, failureMessage);
+        }
+    },
 };
 export const runtimeTypeGuards = {
     assert: assertions,
@@ -106,7 +483,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotArray} : the opposite check.
          */
-        isArray: autoGuard(),
+        isArray(actual) {
+            return Array.isArray(actual);
+        },
         /**
          * Checks that a value is a BigInt.
          *
@@ -124,7 +503,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotBigInt} : the opposite check.
          */
-        isBigInt: autoGuardSymbol,
+        isBigInt(actual) {
+            return typeof actual === 'bigint';
+        },
         /**
          * Checks that a value is a boolean.
          *
@@ -142,7 +523,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotBoolean} : the opposite check.
          */
-        isBoolean: autoGuardSymbol,
+        isBoolean(actual) {
+            return typeof actual === 'boolean';
+        },
         /**
          * Checks that a value is a function.
          *
@@ -160,7 +543,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isFunction: autoGuard(),
+        isFunction(actual) {
+            return typeof actual === 'function';
+        },
         /**
          * Checks that a value is exactly `null`.
          *
@@ -178,7 +563,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isNull: autoGuardSymbol,
+        isNull(actual) {
+            return actual === null;
+        },
         /**
          * Checks that a value is a number. This excludes `NaN`.
          *
@@ -196,7 +583,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isNumber: autoGuardSymbol,
+        isNumber(actual) {
+            return typeof actual === 'number';
+        },
         /**
          * Checks that a value is an object. This excludes arrays.
          *
@@ -214,7 +603,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isObject: autoGuardSymbol,
+        isObject(actual) {
+            return !Array.isArray(actual) && typeof actual === 'object' && !!actual;
+        },
         /**
          * Checks that a value is a string.
          *
@@ -232,7 +623,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isString: autoGuardSymbol,
+        isString(actual) {
+            return typeof actual === 'string';
+        },
         /**
          * Checks that a value is a symbol.
          *
@@ -250,7 +643,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isSymbol: autoGuardSymbol,
+        isSymbol(actual) {
+            return typeof actual === 'symbol';
+        },
         /**
          * Checks that a value is exactly `undefined`.
          *
@@ -268,7 +663,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isUndefined: autoGuardSymbol,
+        isUndefined(actual) {
+            return actual === undefined;
+        },
         /**
          * Checks that a value is _not_ an array.
          *
@@ -286,7 +683,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isArray} : the opposite check.
          */
-        isNotArray: autoGuard(),
+        isNotArray(actual) {
+            return !Array.isArray(actual);
+        },
         /**
          * Checks that a value is _not_ a BigInt.
          *
@@ -304,7 +703,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isBigInt} : the opposite check.
          */
-        isNotBigInt: autoGuard(),
+        isNotBigInt(actual) {
+            return typeof actual !== 'bigint';
+        },
         /**
          * Checks that a value is _not_ a boolean.
          *
@@ -322,7 +723,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isBoolean} : the opposite check.
          */
-        isNotBoolean: autoGuard(),
+        isNotBoolean(actual) {
+            return typeof actual !== 'boolean';
+        },
         /**
          * Checks that a value is _not_ a function.
          *
@@ -340,7 +743,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotFunction: autoGuard(),
+        isNotFunction(actual) {
+            return typeof actual !== 'function';
+        },
         /**
          * Checks that a value is _not_ exactly `null`.
          *
@@ -358,7 +763,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotNull: autoGuard(),
+        isNotNull(actual) {
+            return actual !== null;
+        },
         /**
          * Checks that a value is _not_ a number. This includes `NaN`.
          *
@@ -376,7 +783,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isNotNumber: autoGuard(),
+        isNotNumber(actual) {
+            return typeof actual !== 'number';
+        },
         /**
          * Checks that a value is _not_ an object. This includes arrays.
          *
@@ -394,7 +803,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotObject: autoGuard(),
+        isNotObject(actual) {
+            return Array.isArray(actual) || typeof actual !== 'object' || !actual;
+        },
         /**
          * Checks that a value is _not_ a string.
          *
@@ -412,7 +823,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotString: autoGuard(),
+        isNotString(actual) {
+            return typeof actual !== 'string';
+        },
         /**
          * Checks that a value is _not_ a symbol.
          *
@@ -430,7 +843,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotSymbol: autoGuard(),
+        isNotSymbol(actual) {
+            return typeof actual !== 'symbol';
+        },
         /**
          * Checks that a value is _not_ exactly `undefined`.
          *
@@ -448,7 +863,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotUndefined: autoGuard(),
+        isNotUndefined(actual) {
+            return typeof actual !== 'undefined';
+        },
     },
     assertWrap: {
         /**
@@ -470,7 +887,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotArray} : the opposite assertion.
          */
-        isArray: autoGuard(),
+        isArray(actual, failureMessage) {
+            if (!Array.isArray(actual)) {
+                throw new AssertionError(`'${stringify(actual)}' is not an array.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a BigInt. Returns the value if the assertion passes.
          *
@@ -490,7 +912,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotBigInt} : the opposite assertion.
          */
-        isBigInt: autoGuardSymbol,
+        isBigInt(actual, failureMessage) {
+            if (typeof actual !== 'bigint') {
+                throw new AssertionError(`'${stringify(actual)}' is not a bigint.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a boolean. Returns the value if the assertion passes.
          *
@@ -510,7 +937,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotBoolean} : the opposite assertion.
          */
-        isBoolean: autoGuardSymbol,
+        isBoolean(actual, failureMessage) {
+            if (typeof actual !== 'boolean') {
+                throw new AssertionError(`'${stringify(actual)}' is not a boolean.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a function. Returns the value if the assertion passes.
          *
@@ -530,7 +962,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isFunction: autoGuard(),
+        isFunction(actual, failureMessage) {
+            if (typeof actual !== 'function') {
+                throw new AssertionError(`'${stringify(actual)}' is not a function.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is exactly `null. Returns the value if the assertion passes.
          *
@@ -550,7 +987,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isNull: autoGuardSymbol,
+        isNull(actual, failureMessage) {
+            if (actual !== null) {
+                throw new AssertionError(`'${stringify(actual)}' is not nul.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a number. This excludes `NaN. Returns the value if the assertion
          * passes.
@@ -571,7 +1013,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isNumber: autoGuardSymbol,
+        isNumber(actual, failureMessage) {
+            if (typeof actual !== 'number' || isNaN(actual)) {
+                throw new AssertionError(`'${stringify(actual)}' is not a number.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is an object. This excludes arrays. Returns the value if the
          * assertion passes.
@@ -592,7 +1039,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isObject: autoGuardSymbol,
+        isObject(actual, failureMessage) {
+            if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
+                throw new AssertionError(`'${stringify(actual)}' is not a non-null object.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a string. Returns the value if the assertion passes.
          *
@@ -612,7 +1064,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isString: autoGuardSymbol,
+        isString(actual, failureMessage) {
+            if (typeof actual !== 'string') {
+                throw new AssertionError(`'${stringify(actual)}' is not a string.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Trying to assign a unique symbol to another variable kills the `unique` part of the
          * symbol. this seems to be a bug with TypeScript itself.
@@ -641,7 +1098,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isSymbol: autoGuard(),
+        isSymbol(actual, failureMessage) {
+            if (typeof actual !== 'symbol') {
+                throw new AssertionError(`'${stringify(actual)}' is not a symbol.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is exactly `undefined. Returns the value if the assertion passes.
          *
@@ -661,7 +1123,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isUndefined: autoGuardSymbol,
+        isUndefined(actual, failureMessage) {
+            if (typeof actual !== 'undefined') {
+                throw new AssertionError(`'${stringify(actual)}' is not a undefined.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ an array. Returns the value if the assertion passes.
          *
@@ -681,7 +1148,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isArray} : the opposite assertion.
          */
-        isNotArray: autoGuard(),
+        isNotArray(actual, failureMessage) {
+            if (Array.isArray(actual)) {
+                throw new AssertionError(`'${stringify(actual)}' is an array.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a BigInt. Returns the value if the assertion passes.
          *
@@ -701,7 +1173,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isBigInt} : the opposite assertion.
          */
-        isNotBigInt: autoGuard(),
+        isNotBigInt(actual, failureMessage) {
+            if (typeof actual === 'bigint') {
+                throw new AssertionError(`'${stringify(actual)}' is a bigint.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a boolean. Returns the value if the assertion passes.
          *
@@ -721,7 +1198,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isBoolean} : the opposite assertion.
          */
-        isNotBoolean: autoGuard(),
+        isNotBoolean(actual, failureMessage) {
+            if (typeof actual === 'boolean') {
+                throw new AssertionError(`'${stringify(actual)}' is a boolean.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a function. Returns the value if the assertion passes.
          *
@@ -741,7 +1223,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotFunction: autoGuard(),
+        isNotFunction(actual, failureMessage) {
+            if (typeof actual === 'function') {
+                throw new AssertionError(`'${stringify(actual)}' is a function.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ exactly `null. Returns the value if the assertion passes.
          *
@@ -761,7 +1248,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotNull: autoGuard(),
+        isNotNull(actual, failureMessage) {
+            if (actual === null) {
+                throw new AssertionError(`'${stringify(actual)}' is a null.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a number. This includes `NaN. Returns the value if the
          * assertion passes.
@@ -782,7 +1274,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isNotNumber: autoGuard(),
+        isNotNumber(actual, failureMessage) {
+            if (typeof actual === 'number') {
+                throw new AssertionError(`'${stringify(actual)}' is a number.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ an object. This includes arrays. Returns the value if the
          * assertion passes.
@@ -803,7 +1300,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotObject: autoGuard(),
+        isNotObject(actual, failureMessage) {
+            if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
+                throw new AssertionError(`'${stringify(actual)}' is a non-null object.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a string. Returns the value if the assertion passes.
          *
@@ -823,7 +1325,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotString: autoGuard(),
+        isNotString(actual, failureMessage) {
+            if (typeof actual === 'string') {
+                throw new AssertionError(`'${stringify(actual)}' is a string.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a symbol. Returns the value if the assertion passes.
          *
@@ -843,7 +1350,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotSymbol: autoGuard(),
+        isNotSymbol(actual, failureMessage) {
+            if (typeof actual === 'symbol') {
+                throw new AssertionError(`'${stringify(actual)}' is a symbol.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ exactly `undefined. Returns the value if the assertion
          * passes.
@@ -864,7 +1376,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotUndefined: autoGuard(),
+        isNotUndefined(actual, failureMessage) {
+            if (typeof actual === 'undefined') {
+                throw new AssertionError(`'${stringify(actual)}' is a undefined.`, failureMessage);
+            }
+            return actual;
+        },
     },
     checkWrap: {
         /**
@@ -886,7 +1403,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotArray} : the opposite check.
          */
-        isArray: autoGuard(),
+        isArray(actual) {
+            if (Array.isArray(actual)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a BigInt. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -906,7 +1430,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotBigInt} : the opposite check.
          */
-        isBigInt: autoGuardSymbol,
+        isBigInt(actual) {
+            if (typeof actual === 'bigint') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a boolean. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -926,7 +1457,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotBoolean} : the opposite check.
          */
-        isBoolean: autoGuardSymbol,
+        isBoolean(actual) {
+            if (typeof actual === 'boolean') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a function. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -946,7 +1484,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isFunction: autoGuard(),
+        isFunction(actual) {
+            if (typeof actual === 'function') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is exactly `null. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -966,7 +1511,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isNull: autoGuardSymbol,
+        isNull(actual) {
+            if (actual === null) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a number. This excludes `NaN. Returns the value if the check
          * passes, otherwise `undefined`.
@@ -986,7 +1538,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isNumber: autoGuardSymbol,
+        isNumber(actual) {
+            if (typeof actual === 'number') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is an object. This excludes arrays. Returns the value if the check
          * passes, otherwise `undefined`.
@@ -1006,7 +1565,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isObject: autoGuardSymbol,
+        isObject(actual) {
+            if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a string. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1026,7 +1592,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isString: autoGuardSymbol,
+        isString(actual) {
+            if (typeof actual === 'string') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a symbol. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1046,32 +1619,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isSymbol: autoGuardSymbol,
-        /**
-         * It doesn't make any sense for `checkWrap.isUndefined` to exist. If the input is
-         * `undefined`, it returns `undefined`. If the input isn't `undefined`, it still returns
-         * `undefined`.
-         */
-        /**
-         * Checks that a value is exactly `undefined. Returns the value if the check passes,
-         * otherwise `undefined`.
-         *
-         * Type guards the value.
-         *
-         * @example
-         *
-         * ```ts
-         * import {checkWrap} from '@augment-vir/assert';
-         *
-         * checkWrap.isUndefined(undefined); // returns `undefined`
-         * checkWrap.isUndefined(null); // returns `undefined`
-         * ```
-         *
-         * @returns The value if the check passes. Otherwise, `undefined`.
-         * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
-         */
-        isUndefined: undefined,
+        isSymbol(actual) {
+            if (typeof actual === 'symbol') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is _not_ an array. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1091,7 +1646,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isArray} : the opposite check.
          */
-        isNotArray: autoGuard(),
+        isNotArray(actual) {
+            if (Array.isArray(actual)) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a BigInt. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1111,7 +1673,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isBigInt} : the opposite check.
          */
-        isNotBigInt: autoGuard(),
+        isNotBigInt(actual) {
+            if (typeof actual === 'bigint') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a boolean. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1131,7 +1700,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isBoolean} : the opposite check.
          */
-        isNotBoolean: autoGuard(),
+        isNotBoolean(actual) {
+            if (typeof actual === 'boolean') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a function. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1151,7 +1727,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotFunction: autoGuard(),
+        isNotFunction(actual) {
+            if (typeof actual === 'function') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ exactly `null. Returns the value if the check passes,
          * otherwise `undefined`.
@@ -1171,7 +1754,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotNull: autoGuard(),
+        isNotNull(actual) {
+            if (actual === null) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a number. This includes `NaN. Returns the value if the check
          * passes, otherwise `undefined`.
@@ -1191,7 +1781,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isNotNumber: autoGuard(),
+        isNotNumber(actual) {
+            if (typeof actual === 'number') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ an object. This includes arrays. Returns the value if the
          * check passes, otherwise `undefined`.
@@ -1211,7 +1808,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotObject: autoGuard(),
+        isNotObject(actual) {
+            if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is _not_ a string. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1231,7 +1835,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotString: autoGuard(),
+        isNotString(actual) {
+            if (typeof actual === 'string') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a symbol. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1251,12 +1862,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotSymbol: autoGuard(),
-        /**
-         * It doesn't make any sense for `checkWrap.isNotUndefined` to exist. If the input is not
-         * `undefined`, then it still returns `undefined`.
-         */
-        isNotUndefined: undefined,
+        isNotSymbol(actual) {
+            if (typeof actual === 'symbol') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -1280,7 +1893,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotArray} : the opposite assertion.
          */
-        isArray: autoGuard(),
+        isArray: createWaitUntil(assertions.isArray),
         /**
          * Repeatedly calls a callback until its output is a BigInt. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1300,7 +1913,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotBigInt} : the opposite assertion.
          */
-        isBigInt: autoGuardSymbol,
+        isBigInt: createWaitUntil(assertions.isBigInt),
         /**
          * Repeatedly calls a callback until its output is a boolean. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1320,7 +1933,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotBoolean} : the opposite assertion.
          */
-        isBoolean: autoGuardSymbol,
+        isBoolean: createWaitUntil(assertions.isBoolean),
         /**
          * Repeatedly calls a callback until its output is a function. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1344,7 +1957,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isFunction: autoGuard(),
+        isFunction: createWaitUntil(assertions.isFunction),
         /**
          * Repeatedly calls a callback until its output is exactly `null`. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1364,7 +1977,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isNull: autoGuardSymbol,
+        isNull: createWaitUntil(assertions.isNull),
         /**
          * Repeatedly calls a callback until its output is a number. This excludes `NaN`. Once the
          * callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1384,7 +1997,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isNumber: autoGuardSymbol,
+        isNumber: createWaitUntil(assertions.isNumber),
         /**
          * Repeatedly calls a callback until its output is an object. This excludes arrays. Once the
          * callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1406,7 +2019,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isObject: autoGuardSymbol,
+        isObject: createWaitUntil(assertions.isObject),
         /**
          * Repeatedly calls a callback until its output is a string. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1426,7 +2039,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isString: autoGuardSymbol,
+        isString: createWaitUntil(assertions.isString),
         /**
          * Repeatedly calls a callback until its output is a symbol. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1446,7 +2059,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isSymbol: autoGuardSymbol,
+        isSymbol: createWaitUntil(assertions.isSymbol),
         /**
          * Repeatedly calls a callback until its output is exactly `undefined`. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1466,7 +2079,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isUndefined: autoGuardSymbol,
+        isUndefined: createWaitUntil(assertions.isUndefined),
         /**
          * Repeatedly calls a callback until its output is _not_ an array. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1488,7 +2101,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isArray} : the opposite assertion.
          */
-        isNotArray: autoGuard(),
+        isNotArray: createWaitUntil(assertions.isNotArray),
         /**
          * Repeatedly calls a callback until its output is _not_ a BigInt. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1508,7 +2121,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isBigInt} : the opposite assertion.
          */
-        isNotBigInt: autoGuard(),
+        isNotBigInt: createWaitUntil(assertions.isNotBigInt),
         /**
          * Repeatedly calls a callback until its output is _not_ a boolean. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1528,7 +2141,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isBoolean} : the opposite assertion.
          */
-        isNotBoolean: autoGuard(),
+        isNotBoolean: createWaitUntil(assertions.isNotBoolean),
         /**
          * Repeatedly calls a callback until its output is _not_ a function. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1552,7 +2165,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotFunction: autoGuard(),
+        isNotFunction: createWaitUntil(assertions.isNotFunction),
         /**
          * Repeatedly calls a callback until its output is _not_ exactly `null`. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1572,7 +2185,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotNull: autoGuard(),
+        isNotNull: createWaitUntil(assertions.isNotNull),
         /**
          * Repeatedly calls a callback until its output is _not_ a number. This includes `NaN`. Once
          * the callback output passes, it is returned. If the attempts time out, an error is
@@ -1593,7 +2206,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isNotNumber: autoGuard(),
+        isNotNumber: createWaitUntil(assertions.isNotNumber),
         /**
          * Repeatedly calls a callback until its output is _not_ an object. This includes arrays.
          * Once the callback output passes, it is returned. If the attempts time out, an error is
@@ -1616,7 +2229,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotObject: autoGuard(),
+        isNotObject: createWaitUntil(assertions.isNotObject),
         /**
          * Repeatedly calls a callback until its output is _not_ a string. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1636,7 +2249,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotString: autoGuard(),
+        isNotString: createWaitUntil(assertions.isNotString),
         /**
          * Repeatedly calls a callback until its output is _not_ a symbol. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1656,7 +2269,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotSymbol: autoGuard(),
+        isNotSymbol: createWaitUntil(assertions.isNotSymbol),
         /**
          * Repeatedly calls a callback until its output is _not_ exactly `undefined`. Once the
          * callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1676,90 +2289,6 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotUndefined: autoGuard(),
+        isNotUndefined: createWaitUntil(assertions.isNotUndefined),
     },
 };
-/**
- * An enum representing the possible values returned by {@link getRuntimeType}. These values are
- * similar to the output of the built-in
- * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
- * except that this includes new types `array` and `null`, that `typeof` does not have, which are
- * both distinct from `object`.
- *
- * @category Assert : Util
- * @category Package : @augment-vir/assert
- * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
- */
-export var RuntimeType;
-(function (RuntimeType) {
-    RuntimeType["String"] = "string";
-    RuntimeType["Number"] = "number";
-    RuntimeType["Bigint"] = "bigint";
-    RuntimeType["Boolean"] = "boolean";
-    RuntimeType["Symbol"] = "symbol";
-    RuntimeType["Undefined"] = "undefined";
-    RuntimeType["Object"] = "object";
-    RuntimeType["Function"] = "function";
-    /**
-     * This is not included in {@link RuntimeType.Object}. (Compared to
-     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
-     * which _does_ include `null` in the `'object'` type.)
-     */
-    RuntimeType["Array"] = "array";
-    /**
-     * This is not included in {@link RuntimeType.Object}. (Compared to
-     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
-     * which _does_ include `null` in the `'object'` type.)
-     */
-    RuntimeType["Null"] = "null";
-})(RuntimeType || (RuntimeType = {}));
-/**
- * Determines the {@link RuntimeType} of a variable. This is similar to the built-in
- * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
- * except in the following ways:
- *
- * - This returns an enum value ({@link RuntimeType}) rather than just a string (though the enum values
- *   are strings anyway).
- * - This includes new types `array` and `null`, that `typeof` does not have, which are both distinct
- *   from `object`.
- *
- * @category Assert : Util
- * @category Package : @augment-vir/assert
- * @example
- *
- * ```ts
- * import {getRuntimeType} from '@augment-vir/assert';
- *
- * getRuntimeType(['a']); // RuntimeType.Array
- * getRuntimeType({a: 'a'}); // RuntimeType.Object
- * ```
- *
- * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
- */
-export function getRuntimeType(actual) {
-    if (actual === null) {
-        return RuntimeType.Null;
-    }
-    else if (Array.isArray(actual)) {
-        return RuntimeType.Array;
-    }
-    else {
-        return typeof actual;
-    }
-}
-/**
- * Asserts that the given actual matches the given test type. Note that an name for the actual must
- * be provided for error messaging purposes.
- */
-function assertRuntimeType(actual, testType, failureMessage) {
-    const actualType = getRuntimeType(actual);
-    if (actualType !== testType) {
-        throw new AssertionError(`'${stringify(actual)}' is '${actualType}', not '${testType}'.`, failureMessage);
-    }
-}
-function assertNotRuntimeType(actual, testType, failureMessage) {
-    const actualType = getRuntimeType(actual);
-    if (actualType === testType) {
-        throw new AssertionError(`'${stringify(actual)}' is '${actualType}'.`, failureMessage);
-    }
-}