@nberlette/math 0.7.0

package/cjs/float32/round.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundFloat32 = roundFloat32;
+/**
+ * Rounds a number to the nearest 32-bit floating point value (single
+ * precision), following the IEEE 754-2008 specification.
+ *
+ * @module float32/round
+ */
+const encode_js_1 = require("./encode.js");
+const decode_js_1 = require("./decode.js");
+/**
+ * Rounds a number to the nearest 32-bit floating point value (single
+ * precision).
+ *
+ * Based on `Math.fround` function, this function follows the same rounding and
+ * conversion rules as per the IEEE 754-2008 specification for single-precision
+ * floating-point numbers (also known as `binary32`).
+ *
+ * @param x The number to round.
+ * @returns The 32-bit floating point rounded value of the number.
+ * @category Rounding
+ * @tags float, float32
+ * @example
+ * ```ts
+ * import { roundFloat32 } from "@nick/math/float32/round";
+ * import { PI } from "@nick/math/constants";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(roundFloat32(PI), Math.fround(PI)); // OK
+ * ```
+ */
+function roundFloat32(x) {
+    return (0, decode_js_1.decodeFloat32)((0, encode_js_1.encodeFloat32)(+x));
+}
+//# sourceMappingURL=round.js.map

package/cjs/float32/round.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.js","sourceRoot":"","sources":["../../src/float32/round.ts"],"names":[],"mappings":";;AA8BA,oCAEC;AAhCD;;;;;GAKG;AACH,2CAA4C;AAC5C,2CAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,YAAY,CAAC,CAAS;IACpC,OAAO,IAAA,yBAAa,EAAC,IAAA,yBAAa,EAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC"}

package/cjs/floor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Performant local implementation of the `Math.floor` function.
+ *
+ * @param x The number to round down to the nearest whole number
+ * @returns The largest integer less than or equal to the provided number.
+ * @category Arithmetic
+ * @tags rounding, floor
+ */
+export declare function floor(x: number): number;
+//# sourceMappingURL=floor.d.ts.map

package/cjs/floor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor.d.ts","sourceRoot":"","sources":["../src/floor.ts"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAQvC"}

package/cjs/floor.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.floor = floor;
+/**
+ * Performant local implementation of the `Math.floor` function.
+ *
+ * @category Arithmetic
+ * @module floor
+ */
+const negative_infinity_js_1 = require("./constants/negative_infinity.js");
+const positive_infinity_js_1 = require("./constants/positive_infinity.js");
+/**
+ * Performant local implementation of the `Math.floor` function.
+ *
+ * @param x The number to round down to the nearest whole number
+ * @returns The largest integer less than or equal to the provided number.
+ * @category Arithmetic
+ * @tags rounding, floor
+ */
+function floor(x) {
+    x = +x;
+    if (x !== x || x === positive_infinity_js_1.POSITIVE_INFINITY || x === negative_infinity_js_1.NEGATIVE_INFINITY)
+        return x;
+    if (x === 0)
+        return x;
+    const remainder = x % 1;
+    if (remainder === 0)
+        return x;
+    const truncated = x - remainder;
+    return x < 0 ? truncated - 1 : truncated;
+}
+//# sourceMappingURL=floor.js.map

package/cjs/floor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor.js","sourceRoot":"","sources":["../src/floor.ts"],"names":[],"mappings":";;AAiBA,sBAQC;AAzBD;;;;;GAKG;AACH,2EAAqE;AACrE,2EAAqE;AAErE;;;;;;;GAOG;AACH,SAAgB,KAAK,CAAC,CAAS;IAC7B,CAAC,GAAG,CAAC,CAAC,CAAC;IACP,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,wCAAiB,IAAI,CAAC,KAAK,wCAAiB;QAAE,OAAO,CAAC,CAAC;IAC5E,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACtB,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,SAAS,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,SAAS,GAAG,CAAC,GAAG,SAAS,CAAC;IAChC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3C,CAAC"}

package/cjs/fround.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Rounds a number to the nearest 32-bit floating point value (single
+ * precision).
+ *
+ * Based on `Math.fround` function, this function follows the same rounding and
+ * conversion rules as per the IEEE 754-2008 specification for single-precision
+ * floating-point numbers (also known as `binary32`).
+ *
+ * @param x The number to round.
+ * @returns The 32-bit floating point rounded value of the number.
+ * @category Rounding
+ * @tags float, float32
+ * @example
+ * ```ts
+ * import { fround } from "@nick/math/fround";
+ * import { PI } from "@nick/math/constants";
+ *
+ * console.assert(fround(PI) === 3.1415927410125732); // OK
+ * console.assert(Math.fround(PI) === 3.1415927410125732); // OK
+ * ```
+ */
+export declare function fround(x: number): number;
+//# sourceMappingURL=fround.d.ts.map

package/cjs/fround.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fround.d.ts","sourceRoot":"","sources":["../src/fround.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC"}

package/cjs/fround.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fround = fround;
+/**
+ * Rounds a number to the nearest 32-bit floating point value (single
+ * precision).
+ *
+ * @module fround
+ */
+const round_js_1 = require("./float32/round.js");
+/**
+ * Rounds a number to the nearest 32-bit floating point value (single
+ * precision).
+ *
+ * Based on `Math.fround` function, this function follows the same rounding and
+ * conversion rules as per the IEEE 754-2008 specification for single-precision
+ * floating-point numbers (also known as `binary32`).
+ *
+ * @param x The number to round.
+ * @returns The 32-bit floating point rounded value of the number.
+ * @category Rounding
+ * @tags float, float32
+ * @example
+ * ```ts
+ * import { fround } from "@nick/math/fround";
+ * import { PI } from "@nick/math/constants";
+ *
+ * console.assert(fround(PI) === 3.1415927410125732); // OK
+ * console.assert(Math.fround(PI) === 3.1415927410125732); // OK
+ * ```
+ */
+function fround(x) {
+    return (0, round_js_1.roundFloat32)(x);
+}
+//# sourceMappingURL=fround.js.map

package/cjs/fround.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fround.js","sourceRoot":"","sources":["../src/fround.ts"],"names":[],"mappings":";;AA6BA,wBAEC;AA/BD;;;;;GAKG;AACH,iDAAkD;AAElD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,MAAM,CAAC,CAAS;IAC9B,OAAO,IAAA,uBAAY,EAAC,CAAC,CAAC,CAAC;AACzB,CAAC"}

package/cjs/guards/finite.d.ts

@@ -0,0 +1,23 @@
+import type { Finite } from "../types/finite.js";
+/**
+ * Checks if a number is finite, meaning it is not infinite or `NaN`.
+ *
+ * This is a dependency-free, type-safe implementation of the `Number.isFinite`
+ * function. It is not dependent on the global `Number` object and will not be
+ * affected by global variable shadowing, reassignment, or malicious tampering.
+ *
+ * @param number The value to check.
+ * @returns `true` if the value is finite, `false` otherwise.
+ * @category Guards
+ * @tags Finite
+ */
+export declare function isFinite<N extends number>(number: N): number is Finite<N>;
+/**
+ * Checks if a number is finite, meaning it is not infinite or `NaN`.
+ *
+ * @param number The value to check.
+ * @returns `true` if the value is finite, `false` otherwise.
+ */
+export declare function isFinite(number: unknown): number is Finite;
+export type { Finite };
+//# sourceMappingURL=finite.d.ts.map

package/cjs/guards/finite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finite.d.ts","sourceRoot":"","sources":["../../src/guards/finite.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvC,MAAM,EAAE,CAAC,GACR,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;AAEvB;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,MAAM,CAAC;AAQ5D,YAAY,EAAE,MAAM,EAAE,CAAC"}

package/cjs/guards/finite.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFinite = isFinite;
+/**
+ * Checks if a number is finite, meaning it is not infinite or `NaN`.
+ *
+ * This is a dependency-free, type-safe implementation of the `Number.isFinite`
+ * function. It is not dependent on the global `Number` object and will not be
+ * affected by global variable shadowing, reassignment, or malicious tampering.
+ *
+ * @module guards/finite
+ */
+const nan_js_1 = require("./nan.js");
+const negative_infinity_js_1 = require("./negative_infinity.js");
+const positive_infinity_js_1 = require("./positive_infinity.js");
+/** @internal */
+function isFinite(number) {
+    return typeof number === "number" && !(0, nan_js_1.isNaN)(number) &&
+        !(0, positive_infinity_js_1.isPositiveInfinity)(number) && !(0, negative_infinity_js_1.isNegativeInfinity)(number);
+}
+//# sourceMappingURL=finite.js.map

package/cjs/guards/finite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finite.js","sourceRoot":"","sources":["../../src/guards/finite.ts"],"names":[],"mappings":";;AAuCA,4BAGC;AA1CD;;;;;;;;GAQG;AACH,qCAAiC;AACjC,iEAA4D;AAC5D,iEAA4D;AA2B5D,gBAAgB;AAChB,SAAgB,QAAQ,CAAC,MAAe;IACtC,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,IAAA,cAAK,EAAC,MAAM,CAAC;QACjD,CAAC,IAAA,yCAAkB,EAAC,MAAM,CAAC,IAAI,CAAC,IAAA,yCAAkB,EAAC,MAAM,CAAC,CAAC;AAC/D,CAAC"}

package/cjs/guards/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Type guards for checking various numeric conditions, ensuring a value is of
+ * the expected type/value both at runtime and at compile-time.
+ *
+ * This module provides type-safe implementations for every native numeric
+ * guard in the ECMAScript specification, including all top-level global guards
+ * like [`isNaN`], and static `Number` methods like [`isFinite`].
+ *
+ * | Type Guard             | Description                                                   | Native Equivalent                       |
+ * | ---------------------- | ------------------------------------------------------------- | --------------------------------------- |
+ * | [`isNaN`]              | Checks if a value is `NaN` when coerced to a number.          | [`isNaN`][native-isnan]                 |
+ * | [`isFinite`]           | Checks if a number is finite (i.e., not `±Infinity` or `NaN`) | [`isFinite`][native-isfinite]           |
+ * | [`isInteger`]          | Checks if a value is an integer when coerced to a number.     | `--`                                    |
+ * | [`isSafeInteger`]      | Checks if a number is a safe integer without coercion.        | [`Number.isSafeInteger`][issafeinteger] |
+ * | [`isNumberInteger`]    | Checks if a number is an integer without coercion.            | [`Number.isInteger`][number-isint]      |
+ * | [`isNumberNaN`]        | Checks if a number is `NaN` without coercion.                 | [`Number.isNaN`][native-number-isnan]   |
+ * | [`isNegativeZero`]     | Checks if a number is `-0`.                                   | [`Object.is`][native-object-is]         |
+ * | [`isPositiveZero`]     | Checks if a number is `+0` (and explicitly not `-0`).         | [`Object.is`][native-object-is]         |
+ * | [`isInfinity`]         | Checks if a number is `+Infinity` or `-Infinity`.             | `--`                                    |
+ * | [`isNegativeInfinity`] | Checks if a number is `-Infinity`.                            | `--`                                    |
+ * | [`isPositiveInfinity`] | Checks if a number is `+Infinity`.                            | `--`                                    |
+ *
+ * [`isFinite`]: https://jsr.io/@nick/math/doc/guards/finite/~/isFinite
+ * [`isInfinity`]: https://jsr.io/@nick/math/doc/guards/infinity/~/isInfinity
+ * [`isInteger`]: https://jsr.io/@nick/math/doc/guards/integer/~/isInteger
+ * [`isSafeInteger`]: https://jsr.io/@nick/math/doc/guards/safe-integer/~/isSafeInteger
+ * [`isNumberInteger`]: https://jsr.io/@nick/math/doc/guards/integer/~/isNumberInteger
+ * [`isNaN`]: https://jsr.io/@nick/math/doc/guards/nan/~/isNaN
+ * [`isNumberNaN`]: https://jsr.io/@nick/math/doc/guards/nan/~/isNumberNaN
+ * [`isPositiveInfinity`]: https://jsr.io/@nick/math/doc/guards/positive-infinity/~/isPositiveInfinity
+ * [`isNegativeInfinity`]: https://jsr.io/@nick/math/doc/guards/negative-infinity/~/isNegativeInfinity
+ * [`isPositiveZero`]: https://jsr.io/@nick/math/doc/guards/positive-zero/~/isPositiveZero
+ * [`isNegativeZero`]: https://jsr.io/@nick/math/doc/guards/negative-zero/~/isNegativeZero
+ * [native-isfinite]: https://mdn.io/isFinite
+ * [issafeinteger]: https://mdn.io/Number.isSafeInteger
+ * [number-isint]: https://mdn.io/Number.isInteger
+ * [native-isnan]: https://mdn.io/isNaN
+ * [native-number-isnan]: https://mdn.io/Number.isNaN
+ * [native-object-is]: https://mdn.io/Object.is
+ *
+ * @module guards
+ */
+export * from "./finite.js";
+export * from "./infinity.js";
+export * from "./integer.js";
+export * from "./nan.js";
+export * from "./negative_zero.js";
+export * from "./positive_zero.js";
+export * from "./safe_integer.js";
+//# sourceMappingURL=index.d.ts.map

package/cjs/guards/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}

package/cjs/guards/index.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Type guards for checking various numeric conditions, ensuring a value is of
+ * the expected type/value both at runtime and at compile-time.
+ *
+ * This module provides type-safe implementations for every native numeric
+ * guard in the ECMAScript specification, including all top-level global guards
+ * like [`isNaN`], and static `Number` methods like [`isFinite`].
+ *
+ * | Type Guard             | Description                                                   | Native Equivalent                       |
+ * | ---------------------- | ------------------------------------------------------------- | --------------------------------------- |
+ * | [`isNaN`]              | Checks if a value is `NaN` when coerced to a number.          | [`isNaN`][native-isnan]                 |
+ * | [`isFinite`]           | Checks if a number is finite (i.e., not `±Infinity` or `NaN`) | [`isFinite`][native-isfinite]           |
+ * | [`isInteger`]          | Checks if a value is an integer when coerced to a number.     | `--`                                    |
+ * | [`isSafeInteger`]      | Checks if a number is a safe integer without coercion.        | [`Number.isSafeInteger`][issafeinteger] |
+ * | [`isNumberInteger`]    | Checks if a number is an integer without coercion.            | [`Number.isInteger`][number-isint]      |
+ * | [`isNumberNaN`]        | Checks if a number is `NaN` without coercion.                 | [`Number.isNaN`][native-number-isnan]   |
+ * | [`isNegativeZero`]     | Checks if a number is `-0`.                                   | [`Object.is`][native-object-is]         |
+ * | [`isPositiveZero`]     | Checks if a number is `+0` (and explicitly not `-0`).         | [`Object.is`][native-object-is]         |
+ * | [`isInfinity`]         | Checks if a number is `+Infinity` or `-Infinity`.             | `--`                                    |
+ * | [`isNegativeInfinity`] | Checks if a number is `-Infinity`.                            | `--`                                    |
+ * | [`isPositiveInfinity`] | Checks if a number is `+Infinity`.                            | `--`                                    |
+ *
+ * [`isFinite`]: https://jsr.io/@nick/math/doc/guards/finite/~/isFinite
+ * [`isInfinity`]: https://jsr.io/@nick/math/doc/guards/infinity/~/isInfinity
+ * [`isInteger`]: https://jsr.io/@nick/math/doc/guards/integer/~/isInteger
+ * [`isSafeInteger`]: https://jsr.io/@nick/math/doc/guards/safe-integer/~/isSafeInteger
+ * [`isNumberInteger`]: https://jsr.io/@nick/math/doc/guards/integer/~/isNumberInteger
+ * [`isNaN`]: https://jsr.io/@nick/math/doc/guards/nan/~/isNaN
+ * [`isNumberNaN`]: https://jsr.io/@nick/math/doc/guards/nan/~/isNumberNaN
+ * [`isPositiveInfinity`]: https://jsr.io/@nick/math/doc/guards/positive-infinity/~/isPositiveInfinity
+ * [`isNegativeInfinity`]: https://jsr.io/@nick/math/doc/guards/negative-infinity/~/isNegativeInfinity
+ * [`isPositiveZero`]: https://jsr.io/@nick/math/doc/guards/positive-zero/~/isPositiveZero
+ * [`isNegativeZero`]: https://jsr.io/@nick/math/doc/guards/negative-zero/~/isNegativeZero
+ * [native-isfinite]: https://mdn.io/isFinite
+ * [issafeinteger]: https://mdn.io/Number.isSafeInteger
+ * [number-isint]: https://mdn.io/Number.isInteger
+ * [native-isnan]: https://mdn.io/isNaN
+ * [native-number-isnan]: https://mdn.io/Number.isNaN
+ * [native-object-is]: https://mdn.io/Object.is
+ *
+ * @module guards
+ */
+__exportStar(require("./finite.js"), exports);
+__exportStar(require("./infinity.js"), exports);
+__exportStar(require("./integer.js"), exports);
+__exportStar(require("./nan.js"), exports);
+__exportStar(require("./negative_zero.js"), exports);
+__exportStar(require("./positive_zero.js"), exports);
+__exportStar(require("./safe_integer.js"), exports);
+//# sourceMappingURL=index.js.map

package/cjs/guards/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,8CAA4B;AAC5B,gDAA8B;AAC9B,+CAA6B;AAC7B,2CAAyB;AACzB,qDAAmC;AACnC,qDAAmC;AACnC,oDAAkC"}

package/cjs/guards/infinity.d.ts

@@ -0,0 +1,3 @@
+export * from "./negative_infinity.js";
+export * from "./positive_infinity.js";
+//# sourceMappingURL=infinity.d.ts.map

package/cjs/guards/infinity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infinity.d.ts","sourceRoot":"","sources":["../../src/guards/infinity.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}

package/cjs/guards/infinity.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./negative_infinity.js"), exports);
+__exportStar(require("./positive_infinity.js"), exports);
+//# sourceMappingURL=infinity.js.map

package/cjs/guards/infinity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"infinity.js","sourceRoot":"","sources":["../../src/guards/infinity.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAuC;AACvC,yDAAuC"}

package/cjs/guards/integer.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Checks if the provided number is a whole number (integer), in a way that is
+ * immune to any global variable shadowing or reassignment.
+ *
+ * @param it The number to check for being an integer.
+ * @returns `true` if the provided number is an integer, otherwise `false`.
+ * @category Arithmetic
+ * @module isInteger
+ */
+import type { Integer } from "../types/integer.js";
+/**
+ * Checks if the provided number is a whole number (integer), similar to
+ * `Number.isInteger`, but values are coerced into numbers before checking.
+ * For a check that matches `Number.isInteger` (no input coercion), see
+ * {@linkcode isNumberInteger}.
+ *
+ * @param it The number to check for being an integer.
+ * @returns `true` if the provided number is an integer, otherwise `false`.
+ * @category Guards
+ * @tags Integer
+ */
+export declare function isInteger<const N extends number>(number: N): number is Integer<N>;
+/**
+ * Checks if the provided number is a whole number (integer), similar to
+ * `Number.isInteger`, but values are coerced into numbers before checking.
+ * For a check that matches `Number.isInteger` (no input coercion), see
+ * {@linkcode isNumberInteger}.
+ *
+ * @param number The value to check.
+ * @returns `true` if the provided number is an integer, otherwise `false`.
+ * @category Guards
+ * @tags Integer
+ */
+export declare function isInteger(number: unknown): number is Integer<number>;
+/**
+ * Checks if a given number is a whole number (integer), in a way that is
+ * identical to the native `Number.isInteger` method (i.e., no coercion is
+ * performed on inputs).
+ *
+ * @param number The value to check.
+ * @returns `true` if the number is integral, otherwise `false`.
+ * @category Guards
+ * @tags Number, Integer
+ */
+export declare function isNumberInteger<const N extends number>(number: N): number is Integer<N>;
+export type { Integer };
+//# sourceMappingURL=integer.d.ts.map

package/cjs/guards/integer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../src/guards/integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAC9C,MAAM,EAAE,CAAC,GACR,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;AAExB;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;AAQtE;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EACpD,MAAM,EAAE,CAAC,GACR,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,CAEtB;AAED,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/cjs/guards/integer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteger = isInteger;
+exports.isNumberInteger = isNumberInteger;
+/** @internal */
+// deno-lint-ignore no-explicit-any
+function isInteger(number) {
+    return (number = +number) % 1 === 0;
+}
+/**
+ * Checks if a given number is a whole number (integer), in a way that is
+ * identical to the native `Number.isInteger` method (i.e., no coercion is
+ * performed on inputs).
+ *
+ * @param number The value to check.
+ * @returns `true` if the number is integral, otherwise `false`.
+ * @category Guards
+ * @tags Number, Integer
+ */
+function isNumberInteger(number) {
+    return number % 1 === 0;
+}
+//# sourceMappingURL=integer.js.map

package/cjs/guards/integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/guards/integer.ts"],"names":[],"mappings":";;AAyCA,8BAEC;AAYD,0CAIC;AApBD,gBAAgB;AAChB,mCAAmC;AACnC,SAAgB,SAAS,CAAC,MAAW;IACnC,OAAO,CAAC,MAAM,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,eAAe,CAC7B,MAAS;IAET,OAAO,MAAM,GAAG,CAAC,KAAK,CAAC,CAAC;AAC1B,CAAC"}

package/cjs/guards/nan.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Checks if the provided number is `NaN` (Not a Number), in a way that is
+ * immune to any global variable shadowing or reassignment.
+ *
+ * Unlike the global `isNaN` function, this one narrows its input to a special
+ * nominal type `NAN`, which allows you to distinguish between `NaN` and other
+ * `number` values on the type level.
+ *
+ * @param it The number to check for NaN.
+ * @returns `true` if the provided number is `NaN`, otherwise `false`.
+ * @example
+ * ```ts
+ * import { isNaN, NAN } from "@nick/math";
+ * import assert from "node:assert";
+ *
+ * function assertNotNaN<T extends number>(
+ *   value: T
+ * ): asserts value is Exclude<T, NAN> {
+ *   if (isNaN(value)) throw new TypeError("Expected value to be non-NaN");
+ * }
+ *
+ * const x = 42, y = NAN;
+ *
+ * assertNotNaN(x); // OK
+ * assert.throws(() => assertNotNaN(y)); // Error: Expected value to be non-NaN
+ * ```
+ * @category Arithmetic
+ * @module isNaN
+ */
+import { NAN } from "../constants/nan.js";
+/**
+ * Checks if the provided number is `NaN` (Not a Number), in a way that is
+ * immune to any global variable shadowing or reassignment.
+ *
+ * Unlike the global `isNaN` function, this one narrows its input to a special
+ * nominal type `NAN`, which allows you to distinguish between `NaN` and other
+ * `number` values on the type level.
+ *
+ * @param it The number to check for NaN.
+ * @returns `true` if the provided number is `NaN`, otherwise `false`.
+ * @example
+ * ```ts
+ * import { isNaN, NAN } from "@nick/math";
+ * import assert from "node:assert";
+ *
+ * function assertNotNaN<T extends number>(
+ *   value: T
+ * ): asserts value is Exclude<T, NAN> {
+ *   if (isNaN(value)) throw new TypeError("Expected value to be non-NaN");
+ * }
+ *
+ * const x = 42, y = NAN;
+ *
+ * assertNotNaN(x); // OK
+ * assert.throws(() => assertNotNaN(y)); // Error: Expected value to be non-NaN
+ * ```
+ * @category Arithmetic
+ */
+export declare function isNaN(it: number): it is NAN;
+export { NAN, NAN as NaN };
+//# sourceMappingURL=nan.d.ts.map

package/cjs/guards/nan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nan.d.ts","sourceRoot":"","sources":["../../src/guards/nan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,IAAI,GAAG,CAE3C;AAED,OAAO,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,EAAE,CAAC"}

package/cjs/guards/nan.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Checks if the provided number is `NaN` (Not a Number), in a way that is
+ * immune to any global variable shadowing or reassignment.
+ *
+ * Unlike the global `isNaN` function, this one narrows its input to a special
+ * nominal type `NAN`, which allows you to distinguish between `NaN` and other
+ * `number` values on the type level.
+ *
+ * @param it The number to check for NaN.
+ * @returns `true` if the provided number is `NaN`, otherwise `false`.
+ * @example
+ * ```ts
+ * import { isNaN, NAN } from "@nick/math";
+ * import assert from "node:assert";
+ *
+ * function assertNotNaN<T extends number>(
+ *   value: T
+ * ): asserts value is Exclude<T, NAN> {
+ *   if (isNaN(value)) throw new TypeError("Expected value to be non-NaN");
+ * }
+ *
+ * const x = 42, y = NAN;
+ *
+ * assertNotNaN(x); // OK
+ * assert.throws(() => assertNotNaN(y)); // Error: Expected value to be non-NaN
+ * ```
+ * @category Arithmetic
+ * @module isNaN
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NaN = exports.NAN = void 0;
+exports.isNaN = isNaN;
+const nan_js_1 = require("../constants/nan.js");
+Object.defineProperty(exports, "NAN", { enumerable: true, get: function () { return nan_js_1.NAN; } });
+Object.defineProperty(exports, "NaN", { enumerable: true, get: function () { return nan_js_1.NAN; } });
+/**
+ * Checks if the provided number is `NaN` (Not a Number), in a way that is
+ * immune to any global variable shadowing or reassignment.
+ *
+ * Unlike the global `isNaN` function, this one narrows its input to a special
+ * nominal type `NAN`, which allows you to distinguish between `NaN` and other
+ * `number` values on the type level.
+ *
+ * @param it The number to check for NaN.
+ * @returns `true` if the provided number is `NaN`, otherwise `false`.
+ * @example
+ * ```ts
+ * import { isNaN, NAN } from "@nick/math";
+ * import assert from "node:assert";
+ *
+ * function assertNotNaN<T extends number>(
+ *   value: T
+ * ): asserts value is Exclude<T, NAN> {
+ *   if (isNaN(value)) throw new TypeError("Expected value to be non-NaN");
+ * }
+ *
+ * const x = 42, y = NAN;
+ *
+ * assertNotNaN(x); // OK
+ * assert.throws(() => assertNotNaN(y)); // Error: Expected value to be non-NaN
+ * ```
+ * @category Arithmetic
+ */
+function isNaN(it) {
+    return (it = +it) !== it;
+}
+//# sourceMappingURL=nan.js.map

package/cjs/guards/nan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nan.js","sourceRoot":"","sources":["../../src/guards/nan.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;;AAgCH,sBAEC;AAhCD,gDAA0C;AAkCjC,oFAlCA,YAAG,OAkCA;AAAS,oFAlCZ,YAAG,OAkCY;AAhCxB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,KAAK,CAAC,EAAU;IAC9B,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;AAC3B,CAAC"}

package/cjs/guards/negative_infinity.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks if the provided number is `-Infinity` (negative infinity), in a way
+ * that is immune to any global variable shadowing or reassignment.
+ *
+ * @module negative-infinity
+ */
+import { NEGATIVE_INFINITY } from "../constants/negative_infinity.js";
+/**
+ * Checks if the provided number is `-Infinity` (negative infinity), in a way
+ * that is immune to any global variable shadowing or reassignment.
+ *
+ * @param it The number to check for negative infinity.
+ * @returns `true` if the provided number is `-Infinity`, otherwise `false`.
+ * @category Guards
+ * @tags Negative Infinity
+ */
+export declare function isNegativeInfinity(it: number): it is NEGATIVE_INFINITY;
+export { NEGATIVE_INFINITY };
+//# sourceMappingURL=negative_infinity.d.ts.map

package/cjs/guards/negative_infinity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative_infinity.d.ts","sourceRoot":"","sources":["../../src/guards/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,IAAI,iBAAiB,CAEtE;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/cjs/guards/negative_infinity.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEGATIVE_INFINITY = void 0;
+exports.isNegativeInfinity = isNegativeInfinity;
+/**
+ * Checks if the provided number is `-Infinity` (negative infinity), in a way
+ * that is immune to any global variable shadowing or reassignment.
+ *
+ * @module negative-infinity
+ */
+const negative_infinity_js_1 = require("../constants/negative_infinity.js");
+Object.defineProperty(exports, "NEGATIVE_INFINITY", { enumerable: true, get: function () { return negative_infinity_js_1.NEGATIVE_INFINITY; } });
+/**
+ * Checks if the provided number is `-Infinity` (negative infinity), in a way
+ * that is immune to any global variable shadowing or reassignment.
+ *
+ * @param it The number to check for negative infinity.
+ * @returns `true` if the provided number is `-Infinity`, otherwise `false`.
+ * @category Guards
+ * @tags Negative Infinity
+ */
+function isNegativeInfinity(it) {
+    return +it === negative_infinity_js_1.NEGATIVE_INFINITY;
+}
+//# sourceMappingURL=negative_infinity.js.map

package/cjs/guards/negative_infinity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative_infinity.js","sourceRoot":"","sources":["../../src/guards/negative_infinity.ts"],"names":[],"mappings":";;;AAiBA,gDAEC;AAnBD;;;;;GAKG;AACH,4EAAsE;AAe7D,kGAfA,wCAAiB,OAeA;AAb1B;;;;;;;;GAQG;AACH,SAAgB,kBAAkB,CAAC,EAAU;IAC3C,OAAO,CAAC,EAAE,KAAK,wCAAiB,CAAC;AACnC,CAAC"}