@nberlette/math 0.7.0

package/esm/float32/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utilities for working with `float32` values (32-bit single precision
+ * floating point numbers), as defined by IEEE 754-2008.
+ *
+ * @module float32
+ */
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./guards.js";
+export * from "./round.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/float32/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/float32/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/esm/float32/index.js

@@ -0,0 +1,11 @@
+/**
+ * Utilities for working with `float32` values (32-bit single precision
+ * floating point numbers), as defined by IEEE 754-2008.
+ *
+ * @module float32
+ */
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./guards.js";
+export * from "./round.js";
+//# sourceMappingURL=index.js.map

package/esm/float32/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/float32/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/esm/float32/round.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 { 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
+ * ```
+ */
+export declare function roundFloat32(x: number): number;
+//# sourceMappingURL=round.d.ts.map

package/esm/float32/round.d.ts.map

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

package/esm/float32/round.js

@@ -0,0 +1,33 @@
+/**
+ * Rounds a number to the nearest 32-bit floating point value (single
+ * precision), following the IEEE 754-2008 specification.
+ *
+ * @module float32/round
+ */
+import { encodeFloat32 } from "./encode.js";
+import { decodeFloat32 } from "./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
+ * ```
+ */
+export function roundFloat32(x) {
+    return decodeFloat32(encodeFloat32(+x));
+}
+//# sourceMappingURL=round.js.map

package/esm/float32/round.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.js","sourceRoot":"","sources":["../../src/float32/round.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,YAAY,CAAC,CAAS;IACpC,OAAO,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC"}

package/esm/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/esm/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/esm/floor.js

@@ -0,0 +1,29 @@
+/**
+ * Performant local implementation of the `Math.floor` function.
+ *
+ * @category Arithmetic
+ * @module floor
+ */
+import { NEGATIVE_INFINITY } from "./constants/negative_infinity.js";
+import { POSITIVE_INFINITY } from "./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
+ */
+export function floor(x) {
+    x = +x;
+    if (x !== x || x === POSITIVE_INFINITY || x === 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/esm/floor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor.js","sourceRoot":"","sources":["../src/floor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAC,CAAS;IAC7B,CAAC,GAAG,CAAC,CAAC,CAAC;IACP,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,iBAAiB,IAAI,CAAC,KAAK,iBAAiB;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/esm/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/esm/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/esm/fround.js

@@ -0,0 +1,32 @@
+/**
+ * Rounds a number to the nearest 32-bit floating point value (single
+ * precision).
+ *
+ * @module fround
+ */
+import { roundFloat32 } from "./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
+ * ```
+ */
+export function fround(x) {
+    return roundFloat32(x);
+}
+//# sourceMappingURL=fround.js.map

package/esm/fround.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fround.js","sourceRoot":"","sources":["../src/fround.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,MAAM,CAAC,CAAS;IAC9B,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;AACzB,CAAC"}

package/esm/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/esm/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/esm/guards/finite.js

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+import { isNaN } from "./nan.js";
+import { isNegativeInfinity } from "./negative_infinity.js";
+import { isPositiveInfinity } from "./positive_infinity.js";
+/** @internal */
+export function isFinite(number) {
+    return typeof number === "number" && !isNaN(number) &&
+        !isPositiveInfinity(number) && !isNegativeInfinity(number);
+}
+//# sourceMappingURL=finite.js.map

package/esm/guards/finite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finite.js","sourceRoot":"","sources":["../../src/guards/finite.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AA2B5D,gBAAgB;AAChB,MAAM,UAAU,QAAQ,CAAC,MAAe;IACtC,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QACjD,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;AAC/D,CAAC"}

package/esm/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/esm/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/esm/guards/index.js

@@ -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.js.map

package/esm/guards/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","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/esm/guards/infinity.d.ts

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

package/esm/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/esm/guards/infinity.js

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

package/esm/guards/infinity.js.map

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

package/esm/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/esm/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/esm/guards/integer.js

@@ -0,0 +1,19 @@
+/** @internal */
+// deno-lint-ignore no-explicit-any
+export 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
+ */
+export function isNumberInteger(number) {
+    return number % 1 === 0;
+}
+//# sourceMappingURL=integer.js.map

package/esm/guards/integer.js.map

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

package/esm/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/esm/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/esm/guards/nan.js

@@ -0,0 +1,63 @@
+/**
+ * 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 function isNaN(it) {
+    return (it = +it) !== it;
+}
+export { NAN, NAN as NaN };
+//# sourceMappingURL=nan.js.map

package/esm/guards/nan.js.map

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

package/esm/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/esm/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"}