@augment-vir/assert 31.0.0 → 31.1.0

package/dist/assertions/numeric.js

@@ -1,87 +1,336 @@
 import { stringify } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
-import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import { isNumber } from './runtime-type.js';
-function isAbove(actual, expected, failureMessage) {
-    if (actual <= expected) {
-        throw new AssertionError(`${actual} is not above ${expected}`, failureMessage);
-    }
-}
-function isAtLeast(actual, expected, failureMessage) {
-    if (actual < expected) {
-        throw new AssertionError(`${actual} is not at least ${expected}`, failureMessage);
-    }
-}
-function isInBounds(actual, { max, min }, failureMessage) {
-    if (actual < min || max < actual) {
-        throw new AssertionError(`${actual} is not within the bounds ${stringify({ min, max })}`, failureMessage);
-    }
-}
-function isOutBounds(actual, { min, max }, failureMessage) {
-    if (min <= actual && actual <= max) {
-        throw new AssertionError(`${actual} is not outside the bounds ${stringify({ min, max })}`, failureMessage);
-    }
-}
-function isInteger(actual, failureMessage) {
-    isNumber(actual);
-    if (!Number.isInteger(actual)) {
-        throw new AssertionError(`${actual} is not an integer.`, failureMessage);
-    }
-}
-function isNotInteger(actual, failureMessage) {
-    if (Number.isInteger(actual)) {
-        throw new AssertionError(`${actual} is an integer.`, failureMessage);
-    }
-}
-function isBelow(actual, expected, failureMessage) {
-    if (actual >= expected) {
-        throw new AssertionError(`${actual} is not below ${expected}`, failureMessage);
-    }
-}
-function isAtMost(actual, expected, failureMessage) {
-    if (actual > expected) {
-        throw new AssertionError(`${actual} is not at most ${expected}`, failureMessage);
-    }
-}
-function isNaNGuard(actual, failureMessage) {
-    if (!isNaN(actual)) {
-        throw new AssertionError(`${actual} is not NaN`, failureMessage);
-    }
-}
-function isFiniteGuard(actual, failureMessage) {
-    if (isNaN(actual) || actual === Infinity || actual === -Infinity) {
-        throw new AssertionError(`${actual} is not finite`, failureMessage);
-    }
-}
-function isInfinite(actual, failureMessage) {
-    if (actual !== Infinity && actual !== -Infinity) {
-        throw new AssertionError(`${actual} is not infinite`, failureMessage);
-    }
-}
-function isApproximately(actual, expected, delta, failureMessage) {
-    if (actual < expected - delta || actual > expected + delta) {
-        throw new AssertionError(`${actual} is not within ±${delta} of ${expected}`, failureMessage);
-    }
-}
-function isNotApproximately(actual, expected, delta, failureMessage) {
-    if (actual >= expected - delta && actual <= expected + delta) {
-        throw new AssertionError(`${actual} is within ±${delta} of ${expected}`, failureMessage);
-    }
-}
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
 const assertions = {
-    isInBounds,
-    isOutBounds,
-    isInteger,
-    isNotInteger,
-    isAbove,
-    isAtLeast,
-    isBelow,
-    isAtMost,
-    isNaN: isNaNGuard,
-    isFinite: isFiniteGuard,
-    isInfinite,
-    isApproximately,
-    isNotApproximately,
+    /**
+     * Asserts that a number is inside the provided min and max bounds, inclusive.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isInBounds(5, {min: 1, max: 10}); // passes
+     * assert.isInBounds(10, {min: 1, max: 10}); // passes
+     * assert.isInBounds(11, {min: 1, max: 10}); // fails
+     * assert.isInBounds(0, {min: 1, max: 10}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isOutBounds} : the opposite assertion.
+     */
+    isInBounds(actual, { max, min }, failureMessage) {
+        if (actual < min || max < actual) {
+            throw new AssertionError(`${actual} is not within the bounds ${stringify({ min, max })}`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is outside the provided min and max bounds, exclusive.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isOutBounds(5, {min: 1, max: 10}); // fails
+     * assert.isOutBounds(10, {min: 1, max: 10}); // fails
+     * assert.isOutBounds(11, {min: 1, max: 10}); // passes
+     * assert.isOutBounds(0, {min: 1, max: 10}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isInBounds} : the opposite assertion.
+     */
+    isOutBounds(actual, { min, max }, failureMessage) {
+        if (min <= actual && actual <= max) {
+            throw new AssertionError(`${actual} is not outside the bounds ${stringify({ min, max })}`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is an integer. This has the same limitations as
+     * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isInteger(5); // passes
+     * assert.isInteger(5.0000000000000001); // passes
+     * assert.isInteger(5.1); // fails
+     * assert.isInteger(NaN); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNotInteger} : the opposite assertion.
+     */
+    isInteger(actual, failureMessage) {
+        if (typeof actual !== 'number' || isNaN(actual) || !Number.isInteger(actual)) {
+            throw new AssertionError(`${actual} is not an integer.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is not an integer. This has the same limitations, as
+     * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotInteger(5); // fails
+     * assert.isNotInteger(5.0000000000000001); // fails
+     * assert.isNotInteger(5.1); // passes
+     * assert.isNotInteger(NaN); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isInteger} : the opposite assertion.
+     */
+    isNotInteger(actual, failureMessage) {
+        if (Number.isInteger(actual)) {
+            throw new AssertionError(`${actual} is an integer.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is above the expectation (`actual > expected`).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isAbove(10, 5); // passes
+     * assert.isAbove(5, 5); // fails
+     * assert.isAbove(5, 10); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isBelow} : the opposite assertion.
+     * - {@link assert.isAtLeast} : the more lenient assertion.
+     */
+    isAbove(actual, expected, failureMessage) {
+        if (actual <= expected) {
+            throw new AssertionError(`${actual} is not above ${expected}`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is at least the expectation (`actual >= expected`).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isAtLeast(10, 5); // passes
+     * assert.isAtLeast(5, 5); // passes
+     * assert.isAtLeast(5, 10); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isAtMost} : the opposite assertion.
+     * - {@link assert.isAbove} : the more restrictive assertion.
+     */
+    isAtLeast(actual, expected, failureMessage) {
+        if (actual < expected) {
+            throw new AssertionError(`${actual} is not at least ${expected}`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is below the expectation (`actual < expected`).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isBelow(10, 5); // fails
+     * assert.isBelow(5, 5); // fails
+     * assert.isBelow(5, 10); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isAbove} : the opposite assertion.
+     * - {@link assert.isAtMost} : the more lenient assertion.
+     */
+    isBelow(actual, expected, failureMessage) {
+        if (actual >= expected) {
+            throw new AssertionError(`${actual} is not below ${expected}`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is at most the expectation (`actual <= expected`).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isAtMost(10, 5); // fails
+     * assert.isAtMost(5, 5); // passes
+     * assert.isAtMost(5, 10); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isAtLeast} : the opposite assertion.
+     * - {@link assert.isBelow} : the more restrictive assertion.
+     */
+    isAtMost(actual, expected, failureMessage) {
+        if (actual > expected) {
+            throw new AssertionError(`${actual} is not at most ${expected}`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is
+     * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNaN(10); // fails
+     * assert.isNaN(parseInt('invalid')); // passes
+     * assert.isNaN(Infinity); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNumber} : can be used as the opposite assertion.
+     */
+    isNaN(actual, failureMessage) {
+        if (!isNaN(actual)) {
+            throw new AssertionError(`${actual} is not NaN`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isFinite(10); // passes
+     * assert.isFinite(parseInt('invalid')); // fails
+     * assert.isFinite(Infinity); // fails
+     * assert.isFinite(-Infinity); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNaN} : an opposite assertion.
+     * - {@link assert.isInfinite} : an opposite assertion.
+     */
+    isFinite(actual, failureMessage) {
+        if (isNaN(actual) || actual === Infinity || actual === -Infinity) {
+            throw new AssertionError(`${actual} is not finite`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is either `Infinity` or `-Infinity`.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isInfinite(10); // fails
+     * assert.isInfinite(parseInt('invalid')); // fails
+     * assert.isInfinite(Infinity); // passes
+     * assert.isInfinite(-Infinity); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNaN} : an opposite assertion.
+     * - {@link assert.isInfinite} : an opposite assertion.
+     */
+    isInfinite(actual, failureMessage) {
+        if (actual !== Infinity && actual !== -Infinity) {
+            throw new AssertionError(`${actual} is not infinite`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is within ±`delta` of the expectation.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isApproximately(10, 8, 4); // passes
+     * assert.isApproximately(10, 12, 4); // passes
+     * assert.isApproximately(10, 8, 1); // fails
+     * assert.isApproximately(10, 12, 1); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNotApproximately} : the opposite assertion.
+     */
+    isApproximately(actual, expected, delta, failureMessage) {
+        if (actual < expected - delta || actual > expected + delta) {
+            throw new AssertionError(`${actual} is not within ±${delta} of ${expected}`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a number is outside ±`delta` of the expectation.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotApproximately(10, 8, 4); // fails
+     * assert.isNotApproximately(10, 12, 4); // fails
+     * assert.isNotApproximately(10, 8, 1); // passes
+     * assert.isNotApproximately(10, 12, 1); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isApproximately} : the opposite assertion.
+     */
+    isNotApproximately(actual, expected, delta, failureMessage) {
+        if (actual >= expected - delta && actual <= expected + delta) {
+            throw new AssertionError(`${actual} is within ±${delta} of ${expected}`, failureMessage);
+        }
+    },
 };
 export const numericGuards = {
     assert: assertions,
@@ -105,7 +354,9 @@ export const numericGuards = {
          * @see
          * - {@link check.isOutBounds} : the opposite check.
          */
-        isInBounds: autoGuardSymbol,
+        isInBounds(actual, { max, min }) {
+            return min <= actual && actual <= max;
+        },
         /**
          * Checks that a number is outside the provided min and max bounds, exclusive.
          *
@@ -125,7 +376,9 @@ export const numericGuards = {
          * @see
          * - {@link check.isInBounds} : the opposite check.
          */
-        isOutBounds: autoGuardSymbol,
+        isOutBounds(actual, { max, min }) {
+            return actual < min || max < actual;
+        },
         /**
          * Checks that a number is an integer. This has the same limitations as
          * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
@@ -146,7 +399,9 @@ export const numericGuards = {
          * @see
          * - {@link check.isNotInteger} : the opposite check.
          */
-        isInteger: autoGuardSymbol,
+        isInteger(actual) {
+            return typeof actual === 'number' && !isNaN(actual) && Number.isInteger(actual);
+        },
         /**
          * Checks that a number is not an integer. This has the same limitations, as
          * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
@@ -167,7 +422,9 @@ export const numericGuards = {
          * @see
          * - {@link check.isInteger} : the opposite check.
          */
-        isNotInteger: autoGuardSymbol,
+        isNotInteger(actual) {
+            return typeof actual !== 'number' || isNaN(actual) || !Number.isInteger(actual);
+        },
         /**
          * Checks that a number is above the expectation (`actual > expected`).
          *
@@ -187,7 +444,9 @@ export const numericGuards = {
          * - {@link check.isBelow} : the opposite check.
          * - {@link check.isAtLeast} : the more lenient check.
          */
-        isAbove: autoGuardSymbol,
+        isAbove(actual, expected) {
+            return actual > expected;
+        },
         /**
          * Checks that a number is at least the expectation (`actual >= expected`).
          *
@@ -207,7 +466,9 @@ export const numericGuards = {
          * - {@link check.isAtMost} : the opposite check.
          * - {@link check.isAbove} : the more restrictive check.
          */
-        isAtLeast: autoGuardSymbol,
+        isAtLeast(actual, expected) {
+            return actual >= expected;
+        },
         /**
          * Checks that a number is below the expectation (`actual < expected`).
          *
@@ -227,7 +488,9 @@ export const numericGuards = {
          * - {@link check.isAbove} : the opposite check.
          * - {@link check.isAtMost} : the more lenient check.
          */
-        isBelow: autoGuardSymbol,
+        isBelow(actual, expected) {
+            return actual < expected;
+        },
         /**
          * Checks that a number is at most the expectation (`actual <= expected`).
          *
@@ -247,7 +510,9 @@ export const numericGuards = {
          * - {@link check.isAtLeast} : the opposite check.
          * - {@link check.isBelow} : the more restrictive check.
          */
-        isAtMost: autoGuardSymbol,
+        isAtMost(actual, expected) {
+            return actual <= expected;
+        },
         /**
          * Checks that a number is
          * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
@@ -267,7 +532,9 @@ export const numericGuards = {
          * @see
          * - {@link check.isNumber} : can be used as the opposite check.
          */
-        isNaN: autoGuardSymbol,
+        isNaN(input) {
+            return isNaN(input);
+        },
         /**
          * Checks that a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
          *
@@ -288,7 +555,9 @@ export const numericGuards = {
          * - {@link check.isNaN} : an opposite check.
          * - {@link check.isInfinite} : an opposite check.
          */
-        isFinite: autoGuardSymbol,
+        isFinite(actual) {
+            return !isNaN(actual) && actual !== Infinity && actual !== -Infinity;
+        },
         /**
          * Checks that a number is either `Infinity` or `-Infinity`.
          *
@@ -309,7 +578,9 @@ export const numericGuards = {
          * - {@link check.isNaN} : an opposite check.
          * - {@link check.isInfinite} : an opposite check.
          */
-        isInfinite: autoGuardSymbol,
+        isInfinite(actual) {
+            return actual === Infinity || actual === -Infinity;
+        },
         /**
          * Checks that a number is within ±`delta` of the expectation.
          *
@@ -329,7 +600,9 @@ export const numericGuards = {
          * @see
          * - {@link check.isNotApproximately} : the opposite check.
          */
-        isApproximately: autoGuardSymbol,
+        isApproximately(actual, expected, delta) {
+            return expected - delta <= actual && actual <= expected + delta;
+        },
         /**
          * Checks that a number is outside ±`delta` of the expectation.
          *
@@ -349,7 +622,9 @@ export const numericGuards = {
          * @see
          * - {@link check.isApproximately} : the opposite check.
          */
-        isNotApproximately: autoGuardSymbol,
+        isNotApproximately(actual, expected, delta) {
+            return actual < expected - delta || actual > expected + delta;
+        },
     },
     assertWrap: {
         /**
@@ -373,7 +648,12 @@ export const numericGuards = {
          * @see
          * - {@link assertWrap.isOutBounds} : the opposite assertion.
          */
-        isInBounds: autoGuardSymbol,
+        isInBounds(actual, { max, min }, failureMessage) {
+            if (actual < min || max < actual) {
+                throw new AssertionError(`${actual} is not within the bounds ${stringify({ min, max })}`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is outside the provided min and max bounds, exclusive. Returns the
          * number if the assertion passes.
@@ -395,7 +675,12 @@ export const numericGuards = {
          * @see
          * - {@link assertWrap.isInBounds} : the opposite assertion.
          */
-        isOutBounds: autoGuardSymbol,
+        isOutBounds(actual, { min, max }, failureMessage) {
+            if (min <= actual && actual <= max) {
+                throw new AssertionError(`${actual} is not outside the bounds ${stringify({ min, max })}`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is an integer. Returns the number if the assertion passes. This has
          * the same limitations as
@@ -418,7 +703,12 @@ export const numericGuards = {
          * @see
          * - {@link assertWrap.isNotInteger} : the opposite assertion.
          */
-        isInteger: autoGuardSymbol,
+        isInteger(actual, failureMessage) {
+            if (typeof actual !== 'number' || isNaN(actual) || !Number.isInteger(actual)) {
+                throw new AssertionError(`${actual} is not an integer.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is not an integer. Returns the number if the assertion passes. This
          * has the same limitations, as
@@ -441,7 +731,12 @@ export const numericGuards = {
          * @see
          * - {@link assertWrap.isInteger} : the opposite assertion.
          */
-        isNotInteger: autoGuardSymbol,
+        isNotInteger(actual, failureMessage) {
+            if (Number.isInteger(actual)) {
+                throw new AssertionError(`${actual} is an integer.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is above the expectation (`actual > expected`). Returns the number
          * if the assertion passes.
@@ -464,7 +759,12 @@ export const numericGuards = {
          * - {@link assertWrap.isBelow} : the opposite assertion.
          * - {@link assertWrap.isAtLeast} : the more lenient assertion.
          */
-        isAbove: autoGuardSymbol,
+        isAbove(actual, expected, failureMessage) {
+            if (actual <= expected) {
+                throw new AssertionError(`${actual} is not above ${expected}`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is at least the expectation (`actual >= expected`). Returns the
          * number if the assertion passes.
@@ -487,7 +787,12 @@ export const numericGuards = {
          * - {@link assertWrap.isAtMost} : the opposite assertion.
          * - {@link assertWrap.isAbove} : the more restrictive assertion.
          */
-        isAtLeast: autoGuardSymbol,
+        isAtLeast(actual, expected, failureMessage) {
+            if (actual < expected) {
+                throw new AssertionError(`${actual} is not at least ${expected}`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is below the expectation (`actual < expected`). Returns the number
          * if the assertion passes.
@@ -510,7 +815,12 @@ export const numericGuards = {
          * - {@link assertWrap.isAbove} : the opposite assertion.
          * - {@link assertWrap.isAtMost} : the more lenient assertion.
          */
-        isBelow: autoGuardSymbol,
+        isBelow(actual, expected, failureMessage) {
+            if (actual >= expected) {
+                throw new AssertionError(`${actual} is not below ${expected}`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is at most the expectation (`actual <= expected`). Returns the
          * number if the assertion passes.
@@ -533,7 +843,12 @@ export const numericGuards = {
          * - {@link assertWrap.isAtLeast} : the opposite assertion.
          * - {@link assertWrap.isBelow} : the more restrictive assertion.
          */
-        isAtMost: autoGuardSymbol,
+        isAtMost(actual, expected, failureMessage) {
+            if (actual > expected) {
+                throw new AssertionError(`${actual} is not at most ${expected}`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is
          * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
@@ -556,7 +871,12 @@ export const numericGuards = {
          * @see
          * - {@link assertWrap.isNumber} : can be used as the opposite assertion.
          */
-        isNaN: autoGuardSymbol,
+        isNaN(actual, failureMessage) {
+            if (!isNaN(actual)) {
+                throw new AssertionError(`${actual} is not NaN`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
          * Returns the number if the assertion passes.
@@ -580,7 +900,12 @@ export const numericGuards = {
          * - {@link assertWrap.isNaN} : an opposite assertion.
          * - {@link assertWrap.isInfinite} : an opposite assertion.
          */
-        isFinite: autoGuardSymbol,
+        isFinite(actual, failureMessage) {
+            if (isNaN(actual) || actual === Infinity || actual === -Infinity) {
+                throw new AssertionError(`${actual} is not finite`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is either `Infinity` or `-Infinity`. Returns the number if the
          * assertion passes.
@@ -604,7 +929,12 @@ export const numericGuards = {
          * - {@link assertWrap.isNaN} : an opposite assertion.
          * - {@link assertWrap.isInfinite} : an opposite assertion.
          */
-        isInfinite: autoGuardSymbol,
+        isInfinite(actual, failureMessage) {
+            if (actual !== Infinity && actual !== -Infinity) {
+                throw new AssertionError(`${actual} is not infinite`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is within ±`delta` of the expectation. Returns the number if the
          * assertion passes.
@@ -627,7 +957,12 @@ export const numericGuards = {
          * @see
          * - {@link assertWrap.isNotApproximately} : the opposite assertion.
          */
-        isApproximately: autoGuardSymbol,
+        isApproximately(actual, expected, delta, failureMessage) {
+            if (actual < expected - delta || actual > expected + delta) {
+                throw new AssertionError(`${actual} is not within ±${delta} of ${expected}`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a number is outside ±`delta` of the expectation. Returns the number if the
          * assertion passes.
@@ -650,7 +985,12 @@ export const numericGuards = {
          * @see
          * - {@link assertWrap.isApproximately} : the opposite assertion.
          */
-        isNotApproximately: autoGuardSymbol,
+        isNotApproximately(actual, expected, delta, failureMessage) {
+            if (actual >= expected - delta && actual <= expected + delta) {
+                throw new AssertionError(`${actual} is within ±${delta} of ${expected}`, failureMessage);
+            }
+            return actual;
+        },
     },
     checkWrap: {
         /**
@@ -673,7 +1013,14 @@ export const numericGuards = {
          * @see
          * - {@link checkWrap.isOutBounds} : the opposite check.
          */
-        isInBounds: autoGuardSymbol,
+        isInBounds(actual, { max, min }) {
+            if (min <= actual && actual <= max) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is outside the provided min and max bounds, exclusive. Returns the
          * number if the check passes, otherwise `undefined`.
@@ -694,7 +1041,14 @@ export const numericGuards = {
          * @see
          * - {@link checkWrap.isInBounds} : the opposite check.
          */
-        isOutBounds: autoGuardSymbol,
+        isOutBounds(actual, { max, min }) {
+            if (actual < min || max < actual) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is an integer. Returns the number if the check passes, otherwise
          * `undefined`. This has the same limitations as
@@ -716,7 +1070,14 @@ export const numericGuards = {
          * @see
          * - {@link checkWrap.isNotInteger} : the opposite check.
          */
-        isInteger: autoGuardSymbol,
+        isInteger(actual) {
+            if (typeof actual === 'number' && !isNaN(actual) && Number.isInteger(actual)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is not an integer. Returns the number if the check passes, otherwise
          * `undefined`. This has the same limitations, as
@@ -738,7 +1099,14 @@ export const numericGuards = {
          * @see
          * - {@link checkWrap.isInteger} : the opposite check.
          */
-        isNotInteger: autoGuardSymbol,
+        isNotInteger(actual) {
+            if (typeof actual !== 'number' || isNaN(actual) || !Number.isInteger(actual)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is above the expectation (`actual > expected`). Returns the number
          * if the check passes, otherwise `undefined`.
@@ -760,7 +1128,14 @@ export const numericGuards = {
          * - {@link checkWrap.isBelow} : the opposite check.
          * - {@link checkWrap.isAtLeast} : the more lenient check.
          */
-        isAbove: autoGuardSymbol,
+        isAbove(actual, expected) {
+            if (actual > expected) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is at least the expectation (`actual >= expected`). Returns the
          * number if the check passes, otherwise `undefined`.
@@ -782,7 +1157,14 @@ export const numericGuards = {
          * - {@link checkWrap.isAtMost} : the opposite check.
          * - {@link checkWrap.isAbove} : the more restrictive check.
          */
-        isAtLeast: autoGuardSymbol,
+        isAtLeast(actual, expected) {
+            if (actual >= expected) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is below the expectation (`actual < expected`). Returns the number
          * if the check passes, otherwise `undefined`.
@@ -804,7 +1186,14 @@ export const numericGuards = {
          * - {@link checkWrap.isAbove} : the opposite check.
          * - {@link checkWrap.isAtMost} : the more lenient check.
          */
-        isBelow: autoGuardSymbol,
+        isBelow(actual, expected) {
+            if (actual < expected) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is at most the expectation (`actual <= expected`). Returns the
          * number if the check passes, otherwise `undefined`.
@@ -826,7 +1215,14 @@ export const numericGuards = {
          * - {@link checkWrap.isAtLeast} : the opposite check.
          * - {@link checkWrap.isBelow} : the more restrictive check.
          */
-        isAtMost: autoGuardSymbol,
+        isAtMost(actual, expected) {
+            if (actual <= expected) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is
          * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
@@ -848,7 +1244,14 @@ export const numericGuards = {
          * @see
          * - {@link checkWrap.isNumber} : can be used as the opposite check.
          */
-        isNaN: autoGuardSymbol,
+        isNaN(actual) {
+            if (isNaN(actual)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
          * Returns the number if the check passes, otherwise `undefined`.
@@ -871,7 +1274,14 @@ export const numericGuards = {
          * - {@link checkWrap.isNaN} : an opposite check.
          * - {@link checkWrap.isInfinite} : an opposite check.
          */
-        isFinite: autoGuardSymbol,
+        isFinite(actual) {
+            if (!isNaN(actual) && actual !== Infinity && actual !== -Infinity) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is either `Infinity` or `-Infinity`. Returns the number if the check
          * passes, otherwise `undefined`.
@@ -894,7 +1304,14 @@ export const numericGuards = {
          * - {@link checkWrap.isNaN} : an opposite check.
          * - {@link checkWrap.isInfinite} : an opposite check.
          */
-        isInfinite: autoGuardSymbol,
+        isInfinite(actual) {
+            if (actual === Infinity || actual === -Infinity) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is within ±`delta` of the expectation. Returns the number if the
          * check passes, otherwise `undefined`.
@@ -916,7 +1333,14 @@ export const numericGuards = {
          * @see
          * - {@link checkWrap.isNotApproximately} : the opposite check.
          */
-        isApproximately: autoGuardSymbol,
+        isApproximately(actual, expected, delta) {
+            if (expected - delta <= actual && actual <= expected + delta) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a number is outside ±`delta` of the expectation. Returns the number if the
          * check passes, otherwise `undefined`.
@@ -938,7 +1362,14 @@ export const numericGuards = {
          * @see
          * - {@link checkWrap.isApproximately} : the opposite check.
          */
-        isNotApproximately: autoGuardSymbol,
+        isNotApproximately(actual, expected, delta) {
+            if (actual < expected - delta || actual > expected + delta) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -962,7 +1393,7 @@ export const numericGuards = {
          * @see
          * - {@link waitUntil.isOutBounds} : the opposite assertion.
          */
-        isInBounds: autoGuardSymbol,
+        isInBounds: createWaitUntil(assertions.isInBounds),
         /**
          * Repeatedly calls a callback until its output is outside the provided min and max bounds,
          * exclusive. If the attempts time out, an error is thrown.
@@ -984,7 +1415,7 @@ export const numericGuards = {
          * @see
          * - {@link waitUntil.isInBounds} : the opposite assertion.
          */
-        isOutBounds: autoGuardSymbol,
+        isOutBounds: createWaitUntil(assertions.isOutBounds),
         /**
          * Repeatedly calls a callback until its output is an integer. This has the same limitations
          * as
@@ -1008,7 +1439,7 @@ export const numericGuards = {
          * @see
          * - {@link waitUntil.isNotInteger} : the opposite assertion.
          */
-        isInteger: autoGuardSymbol,
+        isInteger: createWaitUntil(assertions.isInteger),
         /**
          * Repeatedly calls a callback until its output is not an integer. This has the same
          * limitations, as
@@ -1032,7 +1463,7 @@ export const numericGuards = {
          * @see
          * - {@link waitUntil.isInteger} : the opposite assertion.
          */
-        isNotInteger: autoGuardSymbol,
+        isNotInteger: createWaitUntil(assertions.isNotInteger),
         /**
          * Repeatedly calls a callback until its output is a number that is above the expectation
          * (`actual > expected`). Once the callback output passes, it is returned. If the attempts
@@ -1056,7 +1487,7 @@ export const numericGuards = {
          * - {@link waitUntil.isBelow} : the opposite assertion.
          * - {@link waitUntil.isAtLeast} : the more lenient assertion.
          */
-        isAbove: autoGuardSymbol,
+        isAbove: createWaitUntil(assertions.isAbove),
         /**
          * Repeatedly calls a callback until its output is a number that is at least the expectation
          * (`actual >= expected`). Once the callback output passes, it is returned. If the attempts
@@ -1080,7 +1511,7 @@ export const numericGuards = {
          * - {@link waitUntil.isAtMost} : the opposite assertion.
          * - {@link waitUntil.isAbove} : the more restrictive assertion.
          */
-        isAtLeast: autoGuardSymbol,
+        isAtLeast: createWaitUntil(assertions.isAtLeast),
         /**
          * Repeatedly calls a callback until its output is a number that is below the expectation
          * (`actual < expected`). Once the callback output passes, it is returned. If the attempts
@@ -1104,7 +1535,7 @@ export const numericGuards = {
          * - {@link waitUntil.isAbove} : the opposite assertion.
          * - {@link waitUntil.isAtMost} : the more lenient assertion.
          */
-        isBelow: autoGuardSymbol,
+        isBelow: createWaitUntil(assertions.isBelow),
         /**
          * Repeatedly calls a callback until its output is a number that is at most the expectation
          * (`actual <= expected`). Once the callback output passes, it is returned. If the attempts
@@ -1128,7 +1559,7 @@ export const numericGuards = {
          * - {@link waitUntil.isAtLeast} : the opposite assertion.
          * - {@link waitUntil.isBelow} : the more restrictive assertion.
          */
-        isAtMost: autoGuardSymbol,
+        isAtMost: createWaitUntil(assertions.isAtMost),
         /**
          * Repeatedly calls a callback until its output is a number that is
          * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
@@ -1152,7 +1583,7 @@ export const numericGuards = {
          * @see
          * - {@link waitUntil.isNumber} : can be used as the opposite assertion.
          */
-        isNaN: autoGuardSymbol,
+        isNaN: createWaitUntil(assertions.isNaN),
         /**
          * Repeatedly calls a callback until its output is a number that is finite: meaning, not
          * `NaN` and not `Infinity` or `-Infinity`. Once the callback output passes, it is returned.
@@ -1177,7 +1608,7 @@ export const numericGuards = {
          * - {@link waitUntil.isNaN} : an opposite assertion.
          * - {@link waitUntil.isInfinite} : an opposite assertion.
          */
-        isFinite: autoGuardSymbol,
+        isFinite: createWaitUntil(assertions.isFinite),
         /**
          * Repeatedly calls a callback until its output is a number that is either `Infinity` or
          * `-Infinity`. Once the callback output passes, it is returned. If the attempts time out,
@@ -1202,7 +1633,7 @@ export const numericGuards = {
          * - {@link waitUntil.isNaN} : an opposite assertion.
          * - {@link waitUntil.isInfinite} : an opposite assertion.
          */
-        isInfinite: autoGuardSymbol,
+        isInfinite: createWaitUntil(assertions.isInfinite),
         /**
          * Repeatedly calls a callback until its output is a number that is within ±`delta` of the
          * expectation. Once the callback output passes, it is returned. If the attempts time out,
@@ -1226,7 +1657,7 @@ export const numericGuards = {
          * @see
          * - {@link waitUntil.isNotApproximately} : the opposite assertion.
          */
-        isApproximately: autoGuardSymbol,
+        isApproximately: createWaitUntil(assertions.isApproximately),
         /**
          * Repeatedly calls a callback until its output is a number that is outside ±`delta` of the
          * expectation. Once the callback output passes, it is returned. If the attempts time out,
@@ -1250,6 +1681,6 @@ export const numericGuards = {
          * @see
          * - {@link waitUntil.isApproximately} : the opposite assertion.
          */
-        isNotApproximately: autoGuardSymbol,
+        isNotApproximately: createWaitUntil(assertions.isNotApproximately),
     },
 };