@augment-vir/assert 30.5.1 → 30.6.1

package/dist/assertions/numeric.d.ts

@@ -1,6 +1,11 @@
+import { type MinMax } from '@augment-vir/core';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
 declare function isAbove(actual: number, expected: number, failureMessage?: string | undefined): void;
 declare function isAtLeast(actual: number, expected: number, failureMessage?: string | undefined): void;
+declare function isInBounds(actual: number, { max, min }: MinMax, failureMessage?: string | undefined): void;
+declare function isOutBounds(actual: number, { min, max }: MinMax, failureMessage?: string | undefined): void;
+declare function isInteger(actual: number, failureMessage?: string | undefined): void;
+declare function isNotInteger(actual: number, failureMessage?: string | undefined): void;
 declare function isBelow(actual: number, expected: number, failureMessage?: string | undefined): void;
 declare function isAtMost(actual: number, expected: number, failureMessage?: string | undefined): void;
 declare function isNaNGuard(actual: number, failureMessage?: string | undefined): void;
@@ -10,6 +15,92 @@ declare function isApproximately(actual: number, expected: number, delta: number
 declare function isNotApproximately(actual: number, expected: number, delta: number, failureMessage?: string | undefined): void;
 export declare const numericGuards: {
     assert: {
+        /**
+         * 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: typeof isInBounds;
+        /**
+         * 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: typeof isOutBounds;
+        /**
+         * 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: typeof isInteger;
+        /**
+         * 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: typeof isNotInteger;
         /**
          * Asserts that a number is above the expectation (`actual > expected`).
          *
@@ -203,6 +294,88 @@ export declare const numericGuards: {
         isNotApproximately: typeof isNotApproximately;
     };
     check: {
+        /**
+         * Checks that a number is inside the provided min and max bounds, inclusive.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isInBounds(5, {min: 1, max: 10}); // passes
+         * check.isInBounds(10, {min: 1, max: 10}); // passes
+         * check.isInBounds(11, {min: 1, max: 10}); // fails
+         * check.isInBounds(0, {min: 1, max: 10}); // fails
+         * ```
+         *
+         * @see
+         * - {@link check.isOutBounds} : the opposite check.
+         */
+        isInBounds: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is outside the provided min and max bounds, exclusive.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isOutBounds(5, {min: 1, max: 10}); // fails
+         * check.isOutBounds(10, {min: 1, max: 10}); // fails
+         * check.isOutBounds(11, {min: 1, max: 10}); // passes
+         * check.isOutBounds(0, {min: 1, max: 10}); // passes
+         * ```
+         *
+         * @see
+         * - {@link check.isInBounds} : the opposite check.
+         */
+        isOutBounds: typeof autoGuardSymbol;
+        /**
+         * 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.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isInteger(5); // passes
+         * check.isInteger(5.0000000000000001); // passes
+         * check.isInteger(5.1); // fails
+         * check.isInteger(NaN); // fails
+         * ```
+         *
+         * @see
+         * - {@link check.isNotInteger} : the opposite check.
+         */
+        isInteger: typeof autoGuardSymbol;
+        /**
+         * 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.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isNotInteger(5); // fails
+         * check.isNotInteger(5.0000000000000001); // fails
+         * check.isNotInteger(5.1); // passes
+         * check.isNotInteger(NaN); // passes
+         * ```
+         *
+         * @see
+         * - {@link check.isInteger} : the opposite check.
+         */
+        isNotInteger: typeof autoGuardSymbol;
         /**
          * Checks that a number is above the expectation (`actual > expected`).
          *
@@ -387,6 +560,96 @@ export declare const numericGuards: {
         isNotApproximately: typeof autoGuardSymbol;
     };
     assertWrap: {
+        /**
+         * Asserts that a number is inside the provided min and max bounds, inclusive. Returns the
+         * number if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isInBounds(5, {min: 1, max: 10}); // returns `5`
+         * assertWrap.isInBounds(10, {min: 1, max: 10}); // returns `10`
+         * assertWrap.isInBounds(11, {min: 1, max: 10}); // fails
+         * assertWrap.isInBounds(0, {min: 1, max: 10}); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isOutBounds} : the opposite assertion.
+         */
+        isInBounds: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is outside the provided min and max bounds, exclusive. Returns the
+         * number if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isOutBounds(5, {min: 1, max: 10}); // fails
+         * assertWrap.isOutBounds(10, {min: 1, max: 10}); // fails
+         * assertWrap.isOutBounds(11, {min: 1, max: 10}); // returns `11`
+         * assertWrap.isOutBounds(0, {min: 1, max: 10}); // returns `0`
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isInBounds} : the opposite assertion.
+         */
+        isOutBounds: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is an integer. Returns the number if the assertion passes. 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 {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isInteger(5); // returns `5`
+         * assertWrap.isInteger(5.0000000000000001); // returns `5`
+         * assertWrap.isInteger(5.1); // fails
+         * assertWrap.isInteger(NaN); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isNotInteger} : the opposite assertion.
+         */
+        isInteger: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is not an integer. Returns the number if the assertion passes. 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 {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isNotInteger(5); // fails
+         * assertWrap.isNotInteger(5.0000000000000001); // fails
+         * assertWrap.isNotInteger(5.1); // returns `5.1`
+         * assertWrap.isNotInteger(NaN); // returns `NaN`
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isInteger} : the opposite assertion.
+         */
+        isNotInteger: typeof autoGuardSymbol;
         /**
          * Asserts that a number is above the expectation (`actual > expected`). Returns the number
          * if the assertion passes.
@@ -598,6 +861,92 @@ export declare const numericGuards: {
         isNotApproximately: typeof autoGuardSymbol;
     };
     checkWrap: {
+        /**
+         * Checks that a number is inside the provided min and max bounds, inclusive. Returns the
+         * number if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isInBounds(5, {min: 1, max: 10}); // returns `5`
+         * checkWrap.isInBounds(10, {min: 1, max: 10}); // returns `10`
+         * checkWrap.isInBounds(11, {min: 1, max: 10}); // returns `undefined`
+         * checkWrap.isInBounds(0, {min: 1, max: 10}); // returns `undefined`
+         * ```
+         *
+         * @see
+         * - {@link checkWrap.isOutBounds} : the opposite check.
+         */
+        isInBounds: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is outside the provided min and max bounds, exclusive. Returns the
+         * number if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isOutBounds(5, {min: 1, max: 10}); // returns `undefined`
+         * checkWrap.isOutBounds(10, {min: 1, max: 10}); // returns `undefined`
+         * checkWrap.isOutBounds(11, {min: 1, max: 10}); // returns `11`
+         * checkWrap.isOutBounds(0, {min: 1, max: 10}); // returns `0`
+         * ```
+         *
+         * @see
+         * - {@link checkWrap.isInBounds} : the opposite check.
+         */
+        isOutBounds: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is an integer. Returns the number if the check passes, otherwise
+         * `undefined`. 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 {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isInteger(5); // returns `5`
+         * checkWrap.isInteger(5.0000000000000001); // returns `5`
+         * checkWrap.isInteger(5.1); // returns `undefined`
+         * checkWrap.isInteger(NaN); // returns `undefined`
+         * ```
+         *
+         * @see
+         * - {@link checkWrap.isNotInteger} : the opposite check.
+         */
+        isInteger: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is not an integer. Returns the number if the check passes, otherwise
+         * `undefined`. 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 {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isNotInteger(5); // returns `undefined`
+         * checkWrap.isNotInteger(5.0000000000000001); // returns `undefined`
+         * checkWrap.isNotInteger(5.1); // returns `5.1`
+         * checkWrap.isNotInteger(NaN); // returns `NaN`
+         * ```
+         *
+         * @see
+         * - {@link checkWrap.isInteger} : the opposite check.
+         */
+        isNotInteger: typeof autoGuardSymbol;
         /**
          * Checks that a number is above the expectation (`actual > expected`). Returns the number
          * if the check passes, otherwise `undefined`.
@@ -800,6 +1149,98 @@ export declare const numericGuards: {
         isNotApproximately: typeof autoGuardSymbol;
     };
     waitUntil: {
+        /**
+         * Repeatedly calls a callback until its output is a number is inside the provided min and
+         * max bounds, inclusive. If the attempts time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isInBounds(5, {min: 1, max: 10}); // passes
+         * waitUntil.isInBounds(10, {min: 1, max: 10}); // passes
+         * waitUntil.isInBounds(11, {min: 1, max: 10}); // fails
+         * waitUntil.isInBounds(0, {min: 1, max: 10}); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isOutBounds} : the opposite assertion.
+         */
+        isInBounds: typeof autoGuardSymbol;
+        /**
+         * 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.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isOutBounds(5, {min: 1, max: 10}); // fails
+         * waitUntil.isOutBounds(10, {min: 1, max: 10}); // fails
+         * waitUntil.isOutBounds(11, {min: 1, max: 10}); // passes
+         * waitUntil.isOutBounds(0, {min: 1, max: 10}); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isInBounds} : the opposite assertion.
+         */
+        isOutBounds: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is an integer. This has the same limitations
+         * as
+         * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
+         * If the attempts time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isInteger(5); // passes
+         * waitUntil.isInteger(5.0000000000000001); // passes
+         * waitUntil.isInteger(5.1); // fails
+         * waitUntil.isInteger(NaN); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isNotInteger} : the opposite assertion.
+         */
+        isInteger: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is not an integer. This has the same
+         * limitations, as
+         * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
+         * If the attempts time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isNotInteger(5); // fails
+         * waitUntil.isNotInteger(5.0000000000000001); // fails
+         * waitUntil.isNotInteger(5.1); // passes
+         * waitUntil.isNotInteger(NaN); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isInteger} : the opposite assertion.
+         */
+        isNotInteger: typeof autoGuardSymbol;
         /**
          * 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

package/dist/assertions/numeric.js

@@ -1,5 +1,7 @@
+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);
@@ -10,6 +12,27 @@ function isAtLeast(actual, expected, failureMessage) {
         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);
@@ -46,6 +69,10 @@ function isNotApproximately(actual, expected, delta, failureMessage) {
     }
 }
 const assertions = {
+    isInBounds,
+    isOutBounds,
+    isInteger,
+    isNotInteger,
     isAbove,
     isAtLeast,
     isBelow,
@@ -59,6 +86,88 @@ const assertions = {
 export const numericGuards = {
     assert: assertions,
     check: {
+        /**
+         * Checks that a number is inside the provided min and max bounds, inclusive.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isInBounds(5, {min: 1, max: 10}); // passes
+         * check.isInBounds(10, {min: 1, max: 10}); // passes
+         * check.isInBounds(11, {min: 1, max: 10}); // fails
+         * check.isInBounds(0, {min: 1, max: 10}); // fails
+         * ```
+         *
+         * @see
+         * - {@link check.isOutBounds} : the opposite check.
+         */
+        isInBounds: autoGuardSymbol,
+        /**
+         * Checks that a number is outside the provided min and max bounds, exclusive.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isOutBounds(5, {min: 1, max: 10}); // fails
+         * check.isOutBounds(10, {min: 1, max: 10}); // fails
+         * check.isOutBounds(11, {min: 1, max: 10}); // passes
+         * check.isOutBounds(0, {min: 1, max: 10}); // passes
+         * ```
+         *
+         * @see
+         * - {@link check.isInBounds} : the opposite check.
+         */
+        isOutBounds: autoGuardSymbol,
+        /**
+         * 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.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isInteger(5); // passes
+         * check.isInteger(5.0000000000000001); // passes
+         * check.isInteger(5.1); // fails
+         * check.isInteger(NaN); // fails
+         * ```
+         *
+         * @see
+         * - {@link check.isNotInteger} : the opposite check.
+         */
+        isInteger: autoGuardSymbol,
+        /**
+         * 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.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isNotInteger(5); // fails
+         * check.isNotInteger(5.0000000000000001); // fails
+         * check.isNotInteger(5.1); // passes
+         * check.isNotInteger(NaN); // passes
+         * ```
+         *
+         * @see
+         * - {@link check.isInteger} : the opposite check.
+         */
+        isNotInteger: autoGuardSymbol,
         /**
          * Checks that a number is above the expectation (`actual > expected`).
          *
@@ -243,6 +352,96 @@ export const numericGuards = {
         isNotApproximately: autoGuardSymbol,
     },
     assertWrap: {
+        /**
+         * Asserts that a number is inside the provided min and max bounds, inclusive. Returns the
+         * number if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isInBounds(5, {min: 1, max: 10}); // returns `5`
+         * assertWrap.isInBounds(10, {min: 1, max: 10}); // returns `10`
+         * assertWrap.isInBounds(11, {min: 1, max: 10}); // fails
+         * assertWrap.isInBounds(0, {min: 1, max: 10}); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isOutBounds} : the opposite assertion.
+         */
+        isInBounds: autoGuardSymbol,
+        /**
+         * Asserts that a number is outside the provided min and max bounds, exclusive. Returns the
+         * number if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isOutBounds(5, {min: 1, max: 10}); // fails
+         * assertWrap.isOutBounds(10, {min: 1, max: 10}); // fails
+         * assertWrap.isOutBounds(11, {min: 1, max: 10}); // returns `11`
+         * assertWrap.isOutBounds(0, {min: 1, max: 10}); // returns `0`
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isInBounds} : the opposite assertion.
+         */
+        isOutBounds: autoGuardSymbol,
+        /**
+         * Asserts that a number is an integer. Returns the number if the assertion passes. 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 {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isInteger(5); // returns `5`
+         * assertWrap.isInteger(5.0000000000000001); // returns `5`
+         * assertWrap.isInteger(5.1); // fails
+         * assertWrap.isInteger(NaN); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isNotInteger} : the opposite assertion.
+         */
+        isInteger: autoGuardSymbol,
+        /**
+         * Asserts that a number is not an integer. Returns the number if the assertion passes. 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 {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isNotInteger(5); // fails
+         * assertWrap.isNotInteger(5.0000000000000001); // fails
+         * assertWrap.isNotInteger(5.1); // returns `5.1`
+         * assertWrap.isNotInteger(NaN); // returns `NaN`
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isInteger} : the opposite assertion.
+         */
+        isNotInteger: autoGuardSymbol,
         /**
          * Asserts that a number is above the expectation (`actual > expected`). Returns the number
          * if the assertion passes.
@@ -454,6 +653,92 @@ export const numericGuards = {
         isNotApproximately: autoGuardSymbol,
     },
     checkWrap: {
+        /**
+         * Checks that a number is inside the provided min and max bounds, inclusive. Returns the
+         * number if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isInBounds(5, {min: 1, max: 10}); // returns `5`
+         * checkWrap.isInBounds(10, {min: 1, max: 10}); // returns `10`
+         * checkWrap.isInBounds(11, {min: 1, max: 10}); // returns `undefined`
+         * checkWrap.isInBounds(0, {min: 1, max: 10}); // returns `undefined`
+         * ```
+         *
+         * @see
+         * - {@link checkWrap.isOutBounds} : the opposite check.
+         */
+        isInBounds: autoGuardSymbol,
+        /**
+         * Checks that a number is outside the provided min and max bounds, exclusive. Returns the
+         * number if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isOutBounds(5, {min: 1, max: 10}); // returns `undefined`
+         * checkWrap.isOutBounds(10, {min: 1, max: 10}); // returns `undefined`
+         * checkWrap.isOutBounds(11, {min: 1, max: 10}); // returns `11`
+         * checkWrap.isOutBounds(0, {min: 1, max: 10}); // returns `0`
+         * ```
+         *
+         * @see
+         * - {@link checkWrap.isInBounds} : the opposite check.
+         */
+        isOutBounds: autoGuardSymbol,
+        /**
+         * Checks that a number is an integer. Returns the number if the check passes, otherwise
+         * `undefined`. 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 {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isInteger(5); // returns `5`
+         * checkWrap.isInteger(5.0000000000000001); // returns `5`
+         * checkWrap.isInteger(5.1); // returns `undefined`
+         * checkWrap.isInteger(NaN); // returns `undefined`
+         * ```
+         *
+         * @see
+         * - {@link checkWrap.isNotInteger} : the opposite check.
+         */
+        isInteger: autoGuardSymbol,
+        /**
+         * Checks that a number is not an integer. Returns the number if the check passes, otherwise
+         * `undefined`. 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 {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isNotInteger(5); // returns `undefined`
+         * checkWrap.isNotInteger(5.0000000000000001); // returns `undefined`
+         * checkWrap.isNotInteger(5.1); // returns `5.1`
+         * checkWrap.isNotInteger(NaN); // returns `NaN`
+         * ```
+         *
+         * @see
+         * - {@link checkWrap.isInteger} : the opposite check.
+         */
+        isNotInteger: autoGuardSymbol,
         /**
          * Checks that a number is above the expectation (`actual > expected`). Returns the number
          * if the check passes, otherwise `undefined`.
@@ -656,6 +941,98 @@ export const numericGuards = {
         isNotApproximately: autoGuardSymbol,
     },
     waitUntil: {
+        /**
+         * Repeatedly calls a callback until its output is a number is inside the provided min and
+         * max bounds, inclusive. If the attempts time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isInBounds(5, {min: 1, max: 10}); // passes
+         * waitUntil.isInBounds(10, {min: 1, max: 10}); // passes
+         * waitUntil.isInBounds(11, {min: 1, max: 10}); // fails
+         * waitUntil.isInBounds(0, {min: 1, max: 10}); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isOutBounds} : the opposite assertion.
+         */
+        isInBounds: autoGuardSymbol,
+        /**
+         * 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.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isOutBounds(5, {min: 1, max: 10}); // fails
+         * waitUntil.isOutBounds(10, {min: 1, max: 10}); // fails
+         * waitUntil.isOutBounds(11, {min: 1, max: 10}); // passes
+         * waitUntil.isOutBounds(0, {min: 1, max: 10}); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isInBounds} : the opposite assertion.
+         */
+        isOutBounds: autoGuardSymbol,
+        /**
+         * Repeatedly calls a callback until its output is an integer. This has the same limitations
+         * as
+         * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
+         * If the attempts time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isInteger(5); // passes
+         * waitUntil.isInteger(5.0000000000000001); // passes
+         * waitUntil.isInteger(5.1); // fails
+         * waitUntil.isInteger(NaN); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isNotInteger} : the opposite assertion.
+         */
+        isInteger: autoGuardSymbol,
+        /**
+         * Repeatedly calls a callback until its output is not an integer. This has the same
+         * limitations, as
+         * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
+         * If the attempts time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * waitUntil.isNotInteger(5); // fails
+         * waitUntil.isNotInteger(5.0000000000000001); // fails
+         * waitUntil.isNotInteger(5.1); // passes
+         * waitUntil.isNotInteger(NaN); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isInteger} : the opposite assertion.
+         */
+        isNotInteger: autoGuardSymbol,
         /**
          * 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

package/dist/assertions/runtime-type.d.ts

@@ -16,7 +16,7 @@ declare function isArray<const Actual>(actual: Actual, failureMessage?: string |
 declare function isBigInt(actual: unknown, failureMessage?: string | undefined): asserts actual is bigint;
 declare function isBoolean(actual: unknown, failureMessage?: string | undefined): asserts actual is boolean;
 declare function isFunction<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is NarrowToActual<Actual, AnyFunction>;
-declare function isNumber(actual: unknown, failureMessage?: string | undefined): asserts actual is number;
+export declare function isNumber(actual: unknown, failureMessage?: string | undefined): asserts actual is number;
 declare function isObject(actual: unknown, failureMessage?: string | undefined): asserts actual is UnknownObject;
 declare function isString(actual: unknown, failureMessage?: string | undefined): asserts actual is string;
 declare function isSymbol(actual: unknown, failureMessage?: string | undefined): asserts actual is symbol;

package/dist/assertions/runtime-type.js

@@ -43,7 +43,7 @@ function isBoolean(actual, failureMessage) {
 function isFunction(actual, failureMessage) {
     assertRuntimeType(actual, 'function', failureMessage);
 }
-function isNumber(actual, failureMessage) {
+export function isNumber(actual, failureMessage) {
     assertRuntimeType(actual, 'number', failureMessage);
     if (isNaN(actual)) {
         throw new AssertionError('Value is NaN.', failureMessage);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/assert",
-    "version": "30.5.1",
+    "version": "30.6.1",
     "description": "A collection of assertions for test and production code alike.",
     "keywords": [
         "augment",
@@ -41,7 +41,7 @@
         "test:update": "npm test"
     },
     "dependencies": {
-        "@augment-vir/core": "^30.5.1",
+        "@augment-vir/core": "^30.6.1",
         "@date-vir/duration": "^6.0.1",
         "deep-eql": "^5.0.2",
         "expect-type": "^1.1.0",