@nberlette/math 0.7.0

package/cjs/guards/negative_zero.d.ts

@@ -0,0 +1,12 @@
+import { NEGATIVE_ZERO } from "../constants/negative_zero.js";
+/**
+ * Checks if the provided number is a negative zero.
+ *
+ * @param it The number to check for negative zero.
+ * @returns `true` if the provided number is `-0`, otherwise `false`.
+ * @category Guards
+ * @tags Negative Zero
+ */
+export declare function isNegativeZero(it: number): it is NEGATIVE_ZERO;
+export { NEGATIVE_ZERO };
+//# sourceMappingURL=negative_zero.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"negative_zero.d.ts","sourceRoot":"","sources":["../../src/guards/negative_zero.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,IAAI,aAAa,CAE9D;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/cjs/guards/negative_zero.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEGATIVE_ZERO = void 0;
+exports.isNegativeZero = isNegativeZero;
+/**
+ * Checks if the provided number is a negative zero.
+ *
+ * @module negative-zero
+ */
+const negative_infinity_js_1 = require("./negative_infinity.js");
+const negative_zero_js_1 = require("../constants/negative_zero.js");
+Object.defineProperty(exports, "NEGATIVE_ZERO", { enumerable: true, get: function () { return negative_zero_js_1.NEGATIVE_ZERO; } });
+/**
+ * Checks if the provided number is a negative zero.
+ *
+ * @param it The number to check for negative zero.
+ * @returns `true` if the provided number is `-0`, otherwise `false`.
+ * @category Guards
+ * @tags Negative Zero
+ */
+function isNegativeZero(it) {
+    return (it = +it) === 0 && (0, negative_infinity_js_1.isNegativeInfinity)(1 / it);
+}
+//# sourceMappingURL=negative_zero.js.map

package/cjs/guards/negative_zero.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative_zero.js","sourceRoot":"","sources":["../../src/guards/negative_zero.ts"],"names":[],"mappings":";;;AAgBA,wCAEC;AAlBD;;;;GAIG;AACH,iEAA4D;AAC5D,oEAA8D;AAcrD,8FAdA,gCAAa,OAcA;AAZtB;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,EAAU;IACvC,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAA,yCAAkB,EAAC,CAAC,GAAG,EAAE,CAAC,CAAC;AACxD,CAAC"}

package/cjs/guards/positive_infinity.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive_infinity.d.ts","sourceRoot":"","sources":["../../src/guards/positive_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/positive_infinity.js

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

package/cjs/guards/positive_infinity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/guards/positive_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"}

package/cjs/guards/positive_zero.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if the provided number is exactly positive zero (`+0`). This is a
+ * stricter than `x === 0`, as it will return `false` for `-0`.
+ *
+ * @module positive-zero
+ */
+export * from "../constants/positive_zero.js";
+/**
+ * Checks if the provided number is a positive zero (`+0`).
+ *
+ * @param it The number to check.
+ * @returns `true` if the provided number is exactly `+0`, otherwise `false`.
+ * @category Guards
+ * @tags Positive Zero
+ */
+export declare function isPositiveZero(it: number): it is 0;
+//# sourceMappingURL=positive_zero.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive_zero.d.ts","sourceRoot":"","sources":["../../src/guards/positive_zero.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,+BAA+B,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,IAAI,CAAC,CAElD"}

package/cjs/guards/positive_zero.js

@@ -0,0 +1,36 @@
+"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 });
+exports.isPositiveZero = isPositiveZero;
+/**
+ * Checks if the provided number is exactly positive zero (`+0`). This is a
+ * stricter than `x === 0`, as it will return `false` for `-0`.
+ *
+ * @module positive-zero
+ */
+__exportStar(require("../constants/positive_zero.js"), exports);
+/**
+ * Checks if the provided number is a positive zero (`+0`).
+ *
+ * @param it The number to check.
+ * @returns `true` if the provided number is exactly `+0`, otherwise `false`.
+ * @category Guards
+ * @tags Positive Zero
+ */
+function isPositiveZero(it) {
+    return (it = +it) === 0 && (1 / it) === (1 / 0);
+}
+//# sourceMappingURL=positive_zero.js.map

package/cjs/guards/positive_zero.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"positive_zero.js","sourceRoot":"","sources":["../../src/guards/positive_zero.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAgBA,wCAEC;AAlBD;;;;;GAKG;AACH,gEAA8C;AAE9C;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,EAAU;IACvC,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAClD,CAAC"}

package/cjs/guards/safe_integer.d.ts

@@ -0,0 +1,33 @@
+import { MAX_SAFE_INTEGER } from "../constants/max_safe_integer.js";
+import { MIN_SAFE_INTEGER } from "../constants/min_safe_integer.js";
+import type { SafeInteger } from "../types/safe_integer.js";
+/**
+ * Check if a value is a safe integer within the range of `MIN_SAFE_INTEGER`
+ * (`-2^53 + 1`) and `MAX_SAFE_INTEGER` (`2^53 - 1`).
+ *
+ * This is a dependency-free, performant implementation that is functionally-
+ * equivalent to the native `Number.isSafeInteger` function.
+ *
+ * Note: This guard **does not coerce its input to a number** beforehand. The
+ * value passed for `number` must already satisfy `typeof number === "number"`.
+ *
+ * @template {number} N The type of numeric value to check.
+ * @param number The value to check.
+ * @returns `true` if the value is a safe integer, `false` otherwise.
+ * @category Guards
+ * @tags Safe Integer
+ */
+export declare function isSafeInteger<N extends number>(number: N): number is SafeInteger<N>;
+/**
+ * Check if a value is a safe integer within the range of `MIN_SAFE_INTEGER`
+ * (`-2^53 + 1`) and `MAX_SAFE_INTEGER` (`2^53 - 1`).
+ *
+ * Note: This guard **does not coerce its input to a number** beforehand. The
+ * value passed for `number` must already satisfy `typeof number === "number"`.
+ *
+ * @param number The value to check.
+ * @returns `true` if the value is a safe integer, `false` otherwise.
+ */
+export declare function isSafeInteger(number: number): number is SafeInteger;
+export { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, type SafeInteger };
+//# sourceMappingURL=safe_integer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"safe_integer.d.ts","sourceRoot":"","sources":["../../src/guards/safe_integer.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC5C,MAAM,EAAE,CAAC,GACR,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAE5B;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,WAAW,CAAC;AAQrE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,KAAK,WAAW,EAAE,CAAC"}

package/cjs/guards/safe_integer.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_SAFE_INTEGER = exports.MAX_SAFE_INTEGER = void 0;
+exports.isSafeInteger = isSafeInteger;
+/**
+ * Check if a value is a safe integer within the range of `MIN_SAFE_INTEGER`
+ * (`-2^53 + 1`) and `MAX_SAFE_INTEGER` (`2^53 - 1`).
+ *
+ * This is a dependency-free, performant implementation that is functionally-
+ * equivalent to the native `Number.isSafeInteger` function.
+ *
+ * Note: This guard **does not coerce its input to a number** beforehand. The
+ * value passed for `number` must already satisfy `typeof number === "number"`.
+ *
+ * @module safe-integer
+ */
+const finite_js_1 = require("./finite.js");
+const max_safe_integer_js_1 = require("../constants/max_safe_integer.js");
+Object.defineProperty(exports, "MAX_SAFE_INTEGER", { enumerable: true, get: function () { return max_safe_integer_js_1.MAX_SAFE_INTEGER; } });
+const min_safe_integer_js_1 = require("../constants/min_safe_integer.js");
+Object.defineProperty(exports, "MIN_SAFE_INTEGER", { enumerable: true, get: function () { return min_safe_integer_js_1.MIN_SAFE_INTEGER; } });
+/** @internal */
+function isSafeInteger(number) {
+    return typeof number === "number" && (0, finite_js_1.isFinite)(number) && (number % 1) === 0 &&
+        number >= min_safe_integer_js_1.MIN_SAFE_INTEGER && number <= max_safe_integer_js_1.MAX_SAFE_INTEGER;
+}
+//# sourceMappingURL=safe_integer.js.map

package/cjs/guards/safe_integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe_integer.js","sourceRoot":"","sources":["../../src/guards/safe_integer.ts"],"names":[],"mappings":";;;AAkDA,sCAGC;AArDD;;;;;;;;;;;GAWG;AACH,2CAAuC;AACvC,0EAAoE;AA0C3D,iGA1CA,sCAAgB,OA0CA;AAzCzB,0EAAoE;AAyCzC,iGAzClB,sCAAgB,OAyCkB;AAN3C,gBAAgB;AAChB,SAAgB,aAAa,CAAC,MAAe;IAC3C,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,IAAA,oBAAQ,EAAC,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;QACzE,MAAM,IAAI,sCAAgB,IAAI,MAAM,IAAI,sCAAgB,CAAC;AAC7D,CAAC"}

package/cjs/hypot.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Calculates the hypotenuse value using the Pythagorean theorem, which is the
+ * sqrt of the sum of the squares of its arguments (`sqrt(a^2 + b^2 + ...)`).
+ * Avoids overflow or underflow errors.
+ *
+ * @param values The numbers to calculate the hypotenuse of.
+ * @returns The hypotenuse of the provided numbers (also known as the Euclidean
+ * distance or L² norm of the values).
+ * @category Trigonometry
+ * @tags hypotenuse, pythagorean, euclidean
+ * @example
+ * ```typescript
+ * hypot(3, 4); // 5
+ * hypot(5, 12); // 13
+ * ```
+ */
+export declare function hypot(...values: number[]): number;
+//# sourceMappingURL=hypot.d.ts.map

package/cjs/hypot.d.ts.map

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

package/cjs/hypot.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hypot = hypot;
+/**
+ * Calculates the hypotenuse value using the Pythagorean theorem, which is the
+ * sqrt of the sum of the squares of its arguments (`sqrt(a^2 + b^2 + ...`).
+ * Avoids overflow or underflow errors.
+ *
+ * **Note**: This equation is also known as the Euclidean distance or L² norm.
+ *
+ * @module hypot
+ */
+const abs_js_1 = require("./abs.js");
+const sqrt_js_1 = require("./sqrt.js");
+/**
+ * Calculates the hypotenuse value using the Pythagorean theorem, which is the
+ * sqrt of the sum of the squares of its arguments (`sqrt(a^2 + b^2 + ...)`).
+ * Avoids overflow or underflow errors.
+ *
+ * @param values The numbers to calculate the hypotenuse of.
+ * @returns The hypotenuse of the provided numbers (also known as the Euclidean
+ * distance or L² norm of the values).
+ * @category Trigonometry
+ * @tags hypotenuse, pythagorean, euclidean
+ * @example
+ * ```typescript
+ * hypot(3, 4); // 5
+ * hypot(5, 12); // 13
+ * ```
+ */
+function hypot(...values) {
+    if (values.length === 0)
+        return 0;
+    let hasInfinity = false;
+    let hasNaN = false;
+    let maximum = 0;
+    for (const value of values) {
+        if (value !== value) {
+            hasNaN = true;
+            continue;
+        }
+        if (value === Infinity || value === -Infinity) {
+            hasInfinity = true;
+            continue;
+        }
+        const magnitude = (0, abs_js_1.abs)(value);
+        if (magnitude > maximum)
+            maximum = magnitude;
+    }
+    if (hasInfinity)
+        return Infinity;
+    if (hasNaN)
+        return NaN;
+    if (maximum === 0)
+        return 0;
+    let sum = 0;
+    for (const value of values) {
+        const normalized = value / maximum;
+        sum += normalized * normalized;
+    }
+    return maximum * (0, sqrt_js_1.sqrt)(sum);
+}
+//# sourceMappingURL=hypot.js.map

package/cjs/hypot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hypot.js","sourceRoot":"","sources":["../src/hypot.ts"],"names":[],"mappings":";;AA4BA,sBA8BC;AA1DD;;;;;;;;GAQG;AACH,qCAA+B;AAC/B,uCAAiC;AAEjC;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,KAAK,CAAC,GAAG,MAAgB;IACvC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAClC,IAAI,WAAW,GAAG,KAAK,CAAC;IACxB,IAAI,MAAM,GAAG,KAAK,CAAC;IACnB,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;YACpB,MAAM,GAAG,IAAI,CAAC;YACd,SAAS;QACX,CAAC;QACD,IAAI,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC9C,WAAW,GAAG,IAAI,CAAC;YACnB,SAAS;QACX,CAAC;QACD,MAAM,SAAS,GAAG,IAAA,YAAG,EAAC,KAAK,CAAC,CAAC;QAC7B,IAAI,SAAS,GAAG,OAAO;YAAE,OAAO,GAAG,SAAS,CAAC;IAC/C,CAAC;IAED,IAAI,WAAW;QAAE,OAAO,QAAQ,CAAC;IACjC,IAAI,MAAM;QAAE,OAAO,GAAG,CAAC;IACvB,IAAI,OAAO,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAE5B,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,CAAC;QACnC,GAAG,IAAI,UAAU,GAAG,UAAU,CAAC;IACjC,CAAC;IAED,OAAO,OAAO,GAAG,IAAA,cAAI,EAAC,GAAG,CAAC,CAAC;AAC7B,CAAC"}

package/cjs/ieee754.d.ts

@@ -0,0 +1,16 @@
+/**
+ * IEEE 754 floating point number manipulation.
+ *
+ * This module provides functions for encoding, decoding, and rounding floating
+ * point numbers according to the IEEE 754 standard, for both 16-bit and 32-bit
+ * precision. For utilities specific to 16-bit (half-precision) floats, see the
+ * `float16` module. For 32-bit (single-precision), see the `float32` module.
+ *
+ * **Note**: The `float16` and `float32` modules are used under the hood by the
+ * `f16round` and `fround` functions, respectively.
+ *
+ * @module ieee754
+ */
+export * from "./float16/index.js";
+export * from "./float32/index.js";
+//# sourceMappingURL=ieee754.d.ts.map

package/cjs/ieee754.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ieee754.d.ts","sourceRoot":"","sources":["../src/ieee754.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}

package/cjs/ieee754.js

@@ -0,0 +1,32 @@
+"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 });
+/**
+ * IEEE 754 floating point number manipulation.
+ *
+ * This module provides functions for encoding, decoding, and rounding floating
+ * point numbers according to the IEEE 754 standard, for both 16-bit and 32-bit
+ * precision. For utilities specific to 16-bit (half-precision) floats, see the
+ * `float16` module. For 32-bit (single-precision), see the `float32` module.
+ *
+ * **Note**: The `float16` and `float32` modules are used under the hood by the
+ * `f16round` and `fround` functions, respectively.
+ *
+ * @module ieee754
+ */
+__exportStar(require("./float16/index.js"), exports);
+__exportStar(require("./float32/index.js"), exports);
+//# sourceMappingURL=ieee754.js.map

package/cjs/ieee754.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ieee754.js","sourceRoot":"","sources":["../src/ieee754.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;GAYG;AACH,qDAAmC;AACnC,qDAAmC"}

package/cjs/imul.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Performs a 32-bit integer multiplication of two numbers (interpreted as
+ * 32-bit integers), returning a 32-bit result.
+ *
+ * @module imul
+ */
+/**
+ * Performs a 32-bit integer multiplication of two numbers (interpreted as
+ * 32-bit integers), returning a 32-bit result.
+ *
+ * @param a The first number (treated as a 32-bit integer).
+ * @param b The second number (treated as a 32-bit integer).
+ * @returns The result of multiplying the two numbers as 32-bit integers.
+ * @category Bitwise
+ */
+export declare function imul(a: number, b: number): number;
+//# sourceMappingURL=imul.d.ts.map

package/cjs/imul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imul.d.ts","sourceRoot":"","sources":["../src/imul.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIjD"}

package/cjs/imul.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Performs a 32-bit integer multiplication of two numbers (interpreted as
+ * 32-bit integers), returning a 32-bit result.
+ *
+ * @module imul
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imul = imul;
+/**
+ * Performs a 32-bit integer multiplication of two numbers (interpreted as
+ * 32-bit integers), returning a 32-bit result.
+ *
+ * @param a The first number (treated as a 32-bit integer).
+ * @param b The second number (treated as a 32-bit integer).
+ * @returns The result of multiplying the two numbers as 32-bit integers.
+ * @category Bitwise
+ */
+function imul(a, b) {
+    const ah = (a >>> 16) & 0xffff, al = a & 0xffff;
+    const bh = (b >>> 16) & 0xffff, bl = b & 0xffff;
+    return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0)) | 0;
+}
+//# sourceMappingURL=imul.js.map

package/cjs/imul.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imul.js","sourceRoot":"","sources":["../src/imul.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAWH,oBAIC;AAbD;;;;;;;;GAQG;AACH,SAAgB,IAAI,CAAC,CAAS,EAAE,CAAS;IACvC,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC;IAChD,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC;IAChD,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAC/D,CAAC"}

package/cjs/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * # `@nick/math`
+ *
+ * Standalone implementations of every native API in the `Math` namespace,
+ * written in pure TypeScript with zero external dependencies. Distributed as a
+ * collection of tree-shakeable submodules so you can pick and choose exactly
+ * what features to include based on your specific use case's requirements.
+ *
+ * @example
+ * ```ts
+ * import math from "@nick/math";
+ * import assert from "node:assert";
+ *
+ * // all the same constants from globalThis.Math
+ * assert.strictEqual(math.PI, Math.PI);
+ * assert.strictEqual(math.E, Math.E);
+ * assert.strictEqual(math.SQRT1_2, Math.SQRT1_2);
+ * assert.strictEqual(math.LOG10E, Math.LOG10E);
+ *
+ * // ...and even those from globalThis.Number
+ * assert.strictEqual(math.EPSILON, Number.EPSILON);
+ * assert.strictEqual(math.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
+ * assert.strictEqual(math.NaN, Number.NaN);
+ * // ...
+ * assert.strictEqual(math.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+ *
+ * // all the functions from globalThis.Math
+ * assert.strictEqual(math.abs(-math.PI), math.PI);
+ * assert.strictEqual(math.f16round(math.PI), Math.f16round(Math.PI));
+ * // ...
+ * assert.strictEqual(math.cos(0.99999999999999), Math.cos(0.99999999999999));
+ *
+ * // additional, non-standard guards
+ * assert.ok(math.isNegativeInfinity(-1 / 0));
+ * assert.ok(math.isNegativeZero(-0));
+ * assert.ok(math.isPositiveZero(0));
+ * // ...
+ * assert.ok(math.isFinite(420));
+ * ```
+ * @module math
+ */
+export * from "./abs.js";
+export * from "./acos.js";
+export * from "./acosh.js";
+export * from "./asin.js";
+export * from "./asinh.js";
+export * from "./atan.js";
+export * from "./atanh.js";
+export * from "./atan2.js";
+export * from "./cbrt.js";
+export * from "./ceil.js";
+export * from "./clamp.js";
+export * from "./clz32.js";
+export * from "./constants/index.js";
+export * from "./cos.js";
+export * from "./cosh.js";
+export * from "./exp.js";
+export * from "./expm1.js";
+export * from "./floor.js";
+export * from "./f16round.js";
+export * from "./fround.js";
+export * from "./guards/index.js";
+export * from "./hypot.js";
+export * from "./ieee754.js";
+export * from "./imul.js";
+export * from "./log.js";
+export * from "./log1p.js";
+export * from "./log2.js";
+export * from "./log10.js";
+export * from "./max.js";
+export * from "./min.js";
+export * from "./pow.js";
+export * from "./random.js";
+export * from "./round.js";
+export * from "./sign.js";
+export * from "./sin.js";
+export * from "./sinh.js";
+export * from "./sqrt.js";
+export * from "./tan.js";
+export * from "./tanh.js";
+export * from "./trunc.js";
+export * from "./types/index.js";
+export * as default from "./index.js";
+//# sourceMappingURL=index.d.ts.map

package/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AAEjC,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC"}

package/cjs/index.js

@@ -0,0 +1,113 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+/**
+ * # `@nick/math`
+ *
+ * Standalone implementations of every native API in the `Math` namespace,
+ * written in pure TypeScript with zero external dependencies. Distributed as a
+ * collection of tree-shakeable submodules so you can pick and choose exactly
+ * what features to include based on your specific use case's requirements.
+ *
+ * @example
+ * ```ts
+ * import math from "@nick/math";
+ * import assert from "node:assert";
+ *
+ * // all the same constants from globalThis.Math
+ * assert.strictEqual(math.PI, Math.PI);
+ * assert.strictEqual(math.E, Math.E);
+ * assert.strictEqual(math.SQRT1_2, Math.SQRT1_2);
+ * assert.strictEqual(math.LOG10E, Math.LOG10E);
+ *
+ * // ...and even those from globalThis.Number
+ * assert.strictEqual(math.EPSILON, Number.EPSILON);
+ * assert.strictEqual(math.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
+ * assert.strictEqual(math.NaN, Number.NaN);
+ * // ...
+ * assert.strictEqual(math.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+ *
+ * // all the functions from globalThis.Math
+ * assert.strictEqual(math.abs(-math.PI), math.PI);
+ * assert.strictEqual(math.f16round(math.PI), Math.f16round(Math.PI));
+ * // ...
+ * assert.strictEqual(math.cos(0.99999999999999), Math.cos(0.99999999999999));
+ *
+ * // additional, non-standard guards
+ * assert.ok(math.isNegativeInfinity(-1 / 0));
+ * assert.ok(math.isNegativeZero(-0));
+ * assert.ok(math.isPositiveZero(0));
+ * // ...
+ * assert.ok(math.isFinite(420));
+ * ```
+ * @module math
+ */
+__exportStar(require("./abs.js"), exports);
+__exportStar(require("./acos.js"), exports);
+__exportStar(require("./acosh.js"), exports);
+__exportStar(require("./asin.js"), exports);
+__exportStar(require("./asinh.js"), exports);
+__exportStar(require("./atan.js"), exports);
+__exportStar(require("./atanh.js"), exports);
+__exportStar(require("./atan2.js"), exports);
+__exportStar(require("./cbrt.js"), exports);
+__exportStar(require("./ceil.js"), exports);
+__exportStar(require("./clamp.js"), exports);
+__exportStar(require("./clz32.js"), exports);
+__exportStar(require("./constants/index.js"), exports);
+__exportStar(require("./cos.js"), exports);
+__exportStar(require("./cosh.js"), exports);
+__exportStar(require("./exp.js"), exports);
+__exportStar(require("./expm1.js"), exports);
+__exportStar(require("./floor.js"), exports);
+__exportStar(require("./f16round.js"), exports);
+__exportStar(require("./fround.js"), exports);
+__exportStar(require("./guards/index.js"), exports);
+__exportStar(require("./hypot.js"), exports);
+__exportStar(require("./ieee754.js"), exports);
+__exportStar(require("./imul.js"), exports);
+__exportStar(require("./log.js"), exports);
+__exportStar(require("./log1p.js"), exports);
+__exportStar(require("./log2.js"), exports);
+__exportStar(require("./log10.js"), exports);
+__exportStar(require("./max.js"), exports);
+__exportStar(require("./min.js"), exports);
+__exportStar(require("./pow.js"), exports);
+__exportStar(require("./random.js"), exports);
+__exportStar(require("./round.js"), exports);
+__exportStar(require("./sign.js"), exports);
+__exportStar(require("./sin.js"), exports);
+__exportStar(require("./sinh.js"), exports);
+__exportStar(require("./sqrt.js"), exports);
+__exportStar(require("./tan.js"), exports);
+__exportStar(require("./tanh.js"), exports);
+__exportStar(require("./trunc.js"), exports);
+__exportStar(require("./types/index.js"), exports);
+exports.default = __importStar(require("./index.js"));
+//# sourceMappingURL=index.js.map

package/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,2CAAyB;AACzB,4CAA0B;AAC1B,6CAA2B;AAC3B,4CAA0B;AAC1B,6CAA2B;AAC3B,4CAA0B;AAC1B,6CAA2B;AAC3B,6CAA2B;AAC3B,4CAA0B;AAC1B,4CAA0B;AAC1B,6CAA2B;AAC3B,6CAA2B;AAC3B,uDAAqC;AACrC,2CAAyB;AACzB,4CAA0B;AAC1B,2CAAyB;AACzB,6CAA2B;AAC3B,6CAA2B;AAC3B,gDAA8B;AAC9B,8CAA4B;AAC5B,oDAAkC;AAClC,6CAA2B;AAC3B,+CAA6B;AAC7B,4CAA0B;AAC1B,2CAAyB;AACzB,6CAA2B;AAC3B,4CAA0B;AAC1B,6CAA2B;AAC3B,2CAAyB;AACzB,2CAAyB;AACzB,2CAAyB;AACzB,8CAA4B;AAC5B,6CAA2B;AAC3B,4CAA0B;AAC1B,2CAAyB;AACzB,4CAA0B;AAC1B,4CAA0B;AAC1B,2CAAyB;AACzB,4CAA0B;AAC1B,6CAA2B;AAC3B,mDAAiC;AAEjC,sDAAsC"}