@nberlette/math 0.7.0 → 0.7.1

package/cjs/float32/round.js

@@ -5,6 +5,13 @@ exports.roundFloat32 = roundFloat32;
  * Rounds a number to the nearest 32-bit floating point value (single
  * precision), following the IEEE 754-2008 specification.
  *
+ * @example
+ * ```ts
+ * import { roundFloat32 } from "@nick/math/float32/round";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(roundFloat32(1.337), Math.fround(1.337));
+ * ```
  * @module float32/round
  */
 const encode_js_1 = require("./encode.js");

package/cjs/float32/round.js.map

@@ -1 +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"}
+{"version":3,"file":"round.js","sourceRoot":"","sources":["../../src/float32/round.ts"],"names":[],"mappings":";;AAqCA,oCAEC;AAvCD;;;;;;;;;;;;GAYG;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.map

@@ -1 +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"}
+{"version":3,"file":"floor.d.ts","sourceRoot":"","sources":["../src/floor.ts"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAQvC"}

package/cjs/floor.js

@@ -5,6 +5,13 @@ exports.floor = floor;
  * Performant local implementation of the `Math.floor` function.
  *
  * @category Arithmetic
+ * @example
+ * ```ts
+ * import { floor } from "@nick/math/floor";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(floor(1.8), 1);
+ * ```
  * @module floor
  */
 const negative_infinity_js_1 = require("./constants/negative_infinity.js");

package/cjs/floor.js.map

@@ -1 +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"}
+{"version":3,"file":"floor.js","sourceRoot":"","sources":["../src/floor.ts"],"names":[],"mappings":";;AAwBA,sBAQC;AAhCD;;;;;;;;;;;;GAYG;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.map

@@ -1 +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"}
+{"version":3,"file":"fround.d.ts","sourceRoot":"","sources":["../src/fround.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC"}

package/cjs/fround.js

@@ -5,6 +5,13 @@ exports.fround = fround;
  * Rounds a number to the nearest 32-bit floating point value (single
  * precision).
  *
+ * @example
+ * ```ts
+ * import { fround } from "@nick/math/fround";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(fround(1.337), Math.fround(1.337));
+ * ```
  * @module fround
  */
 const round_js_1 = require("./float32/round.js");

package/cjs/fround.js.map

@@ -1 +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"}
+{"version":3,"file":"fround.js","sourceRoot":"","sources":["../src/fround.ts"],"names":[],"mappings":";;AAoCA,wBAEC;AAtCD;;;;;;;;;;;;GAYG;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.map

@@ -1 +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"}
+{"version":3,"file":"finite.d.ts","sourceRoot":"","sources":["../../src/guards/finite.ts"],"names":[],"mappings":"AAoBA,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

@@ -8,6 +8,14 @@ exports.isFinite = isFinite;
  * function. It is not dependent on the global `Number` object and will not be
  * affected by global variable shadowing, reassignment, or malicious tampering.
  *
+ * @example
+ * ```ts
+ * import { isFinite } from "@nick/math/guards/finite";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isFinite(42));
+ * assert.ok(!isFinite(Infinity));
+ * ```
  * @module guards/finite
  */
 const nan_js_1 = require("./nan.js");

package/cjs/guards/finite.js.map

@@ -1 +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"}
+{"version":3,"file":"finite.js","sourceRoot":"","sources":["../../src/guards/finite.ts"],"names":[],"mappings":";;AA+CA,4BAGC;AAlDD;;;;;;;;;;;;;;;;GAgBG;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

@@ -38,6 +38,16 @@
  * [native-number-isnan]: https://mdn.io/Number.isNaN
  * [native-object-is]: https://mdn.io/Object.is
  *
+ * @example
+ * ```ts
+ * import { isFinite, isPositiveZero } from "@nick/math/guards";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isFinite(123));
+ * assert.ok(isPositiveZero(0));
+ * assert.ok(!isPositiveZero(-0));
+ * ```
+ * @category Guards
  * @module guards
  */
 export * from "./finite.js";

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;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

@@ -54,6 +54,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * [native-number-isnan]: https://mdn.io/Number.isNaN
  * [native-object-is]: https://mdn.io/Object.is
  *
+ * @example
+ * ```ts
+ * import { isFinite, isPositiveZero } from "@nick/math/guards";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isFinite(123));
+ * assert.ok(isPositiveZero(0));
+ * assert.ok(!isPositiveZero(-0));
+ * ```
+ * @category Guards
  * @module guards
  */
 __exportStar(require("./finite.js"), exports);

package/cjs/guards/index.js.map

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

package/cjs/guards/infinity.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Re-exports the infinity guards for checking positive and negative
+ * infinite values.
+ *
+ * @example
+ * ```ts
+ * import { isNegativeInfinity, isPositiveInfinity } from "@nick/math/guards/infinity";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isPositiveInfinity(1 / 0));
+ * assert.ok(isNegativeInfinity(-1 / 0));
+ * ```
+ * @category Guards
+ * @module guards/infinity
+ */
 export * from "./negative_infinity.js";
 export * from "./positive_infinity.js";
 //# sourceMappingURL=infinity.d.ts.map

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

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

package/cjs/guards/infinity.js

@@ -1,4 +1,19 @@
 "use strict";
+/**
+ * Re-exports the infinity guards for checking positive and negative
+ * infinite values.
+ *
+ * @example
+ * ```ts
+ * import { isNegativeInfinity, isPositiveInfinity } from "@nick/math/guards/infinity";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isPositiveInfinity(1 / 0));
+ * assert.ok(isNegativeInfinity(-1 / 0));
+ * ```
+ * @category Guards
+ * @module guards/infinity
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/cjs/guards/infinity.js.map

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

package/cjs/guards/integer.d.ts

@@ -5,6 +5,14 @@
  * @param it The number to check for being an integer.
  * @returns `true` if the provided number is an integer, otherwise `false`.
  * @category Arithmetic
+ * @example
+ * ```ts
+ * import { isInteger } from "@nick/math/guards/integer";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isInteger(10));
+ * assert.ok(!isInteger(10.5));
+ * ```
  * @module isInteger
  */
 import type { Integer } from "../types/integer.js";

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

@@ -1 +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"}
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../src/guards/integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;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.map

@@ -1 +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"}
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/guards/integer.ts"],"names":[],"mappings":";;AAiDA,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/negative_infinity.d.ts

@@ -2,6 +2,13 @@
  * Checks if the provided number is `-Infinity` (negative infinity), in a way
  * that is immune to any global variable shadowing or reassignment.
  *
+ * @example
+ * ```ts
+ * import { isNegativeInfinity } from "@nick/math/guards/negative-infinity";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isNegativeInfinity(-1 / 0));
+ * ```
  * @module negative-infinity
  */
 import { NEGATIVE_INFINITY } from "../constants/negative_infinity.js";

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

@@ -1 +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"}
+{"version":3,"file":"negative_infinity.d.ts","sourceRoot":"","sources":["../../src/guards/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;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

@@ -6,6 +6,13 @@ 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.
  *
+ * @example
+ * ```ts
+ * import { isNegativeInfinity } from "@nick/math/guards/negative-infinity";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isNegativeInfinity(-1 / 0));
+ * ```
  * @module negative-infinity
  */
 const negative_infinity_js_1 = require("../constants/negative_infinity.js");

package/cjs/guards/negative_infinity.js.map

@@ -1 +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"}
+{"version":3,"file":"negative_infinity.js","sourceRoot":"","sources":["../../src/guards/negative_infinity.ts"],"names":[],"mappings":";;;AAwBA,gDAEC;AA1BD;;;;;;;;;;;;GAYG;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/negative_zero.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"negative_zero.d.ts","sourceRoot":"","sources":["../../src/guards/negative_zero.ts"],"names":[],"mappings":"AAaA,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

@@ -5,6 +5,13 @@ exports.isNegativeZero = isNegativeZero;
 /**
  * Checks if the provided number is a negative zero.
  *
+ * @example
+ * ```ts
+ * import { isNegativeZero } from "@nick/math/guards/negative-zero";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isNegativeZero(-0));
+ * ```
  * @module negative-zero
  */
 const negative_infinity_js_1 = require("./negative_infinity.js");

package/cjs/guards/negative_zero.js.map

@@ -1 +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"}
+{"version":3,"file":"negative_zero.js","sourceRoot":"","sources":["../../src/guards/negative_zero.ts"],"names":[],"mappings":";;;AAuBA,wCAEC;AAzBD;;;;;;;;;;;GAWG;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

@@ -2,6 +2,13 @@
  * Checks if the provided number is `+Infinity` (positive infinity), in a way
  * that is immune to any global variable shadowing or reassignment.
  *
+ * @example
+ * ```ts
+ * import { isPositiveInfinity } from "@nick/math/guards/positive-infinity";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isPositiveInfinity(1 / 0));
+ * ```
  * @module positive-infinity
  */
 import { POSITIVE_INFINITY } from "../constants/positive_infinity.js";

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

@@ -1 +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"}
+{"version":3,"file":"positive_infinity.d.ts","sourceRoot":"","sources":["../../src/guards/positive_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;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

@@ -6,6 +6,13 @@ 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.
  *
+ * @example
+ * ```ts
+ * import { isPositiveInfinity } from "@nick/math/guards/positive-infinity";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isPositiveInfinity(1 / 0));
+ * ```
  * @module positive-infinity
  */
 const positive_infinity_js_1 = require("../constants/positive_infinity.js");

package/cjs/guards/positive_infinity.js.map

@@ -1 +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"}
+{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/guards/positive_infinity.ts"],"names":[],"mappings":";;;AAwBA,gDAEC;AA1BD;;;;;;;;;;;;GAYG;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

@@ -2,6 +2,14 @@
  * Checks if the provided number is exactly positive zero (`+0`). This is a
  * stricter than `x === 0`, as it will return `false` for `-0`.
  *
+ * @example
+ * ```ts
+ * import { isPositiveZero } from "@nick/math/guards/positive-zero";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isPositiveZero(0));
+ * assert.ok(!isPositiveZero(-0));
+ * ```
  * @module positive-zero
  */
 export * from "../constants/positive_zero.js";

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

@@ -1 +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"}
+{"version":3,"file":"positive_zero.d.ts","sourceRoot":"","sources":["../../src/guards/positive_zero.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;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

@@ -19,6 +19,14 @@ 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`.
  *
+ * @example
+ * ```ts
+ * import { isPositiveZero } from "@nick/math/guards/positive-zero";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isPositiveZero(0));
+ * assert.ok(!isPositiveZero(-0));
+ * ```
  * @module positive-zero
  */
 __exportStar(require("../constants/positive_zero.js"), exports);

package/cjs/guards/positive_zero.js.map

@@ -1 +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"}
+{"version":3,"file":"positive_zero.js","sourceRoot":"","sources":["../../src/guards/positive_zero.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAwBA,wCAEC;AA1BD;;;;;;;;;;;;;GAaG;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.map

@@ -1 +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"}
+{"version":3,"file":"safe_integer.d.ts","sourceRoot":"","sources":["../../src/guards/safe_integer.ts"],"names":[],"mappings":"AAqBA,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

@@ -12,6 +12,14 @@ exports.isSafeInteger = isSafeInteger;
  * Note: This guard **does not coerce its input to a number** beforehand. The
  * value passed for `number` must already satisfy `typeof number === "number"`.
  *
+ * @example
+ * ```ts
+ * import { isSafeInteger } from "@nick/math/guards/safe-integer";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isSafeInteger(9007199254740991));
+ * assert.ok(!isSafeInteger(9007199254740992));
+ * ```
  * @module safe-integer
  */
 const finite_js_1 = require("./finite.js");

package/cjs/guards/safe_integer.js.map

@@ -1 +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"}
+{"version":3,"file":"safe_integer.js","sourceRoot":"","sources":["../../src/guards/safe_integer.ts"],"names":[],"mappings":";;;AA0DA,sCAGC;AA7DD;;;;;;;;;;;;;;;;;;;GAmBG;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.map

@@ -1 +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"}
+{"version":3,"file":"hypot.d.ts","sourceRoot":"","sources":["../src/hypot.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CA8BjD"}

package/cjs/hypot.js

@@ -8,6 +8,13 @@ exports.hypot = hypot;
  *
  * **Note**: This equation is also known as the Euclidean distance or L² norm.
  *
+ * @example
+ * ```ts
+ * import { hypot } from "@nick/math/hypot";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(hypot(3, 4), 5);
+ * ```
  * @module hypot
  */
 const abs_js_1 = require("./abs.js");

package/cjs/hypot.js.map

@@ -1 +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"}
+{"version":3,"file":"hypot.js","sourceRoot":"","sources":["../src/hypot.ts"],"names":[],"mappings":";;AAmCA,sBA8BC;AAjED;;;;;;;;;;;;;;;GAeG;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

@@ -9,6 +9,15 @@
  * **Note**: The `float16` and `float32` modules are used under the hood by the
  * `f16round` and `fround` functions, respectively.
  *
+ * @example
+ * ```ts
+ * import { decodeFloat16, encodeFloat16 } from "@nick/math/ieee754";
+ * import assert from "node:assert";
+ *
+ * const encoded = encodeFloat16(1);
+ * assert.strictEqual(decodeFloat16(encoded), 1);
+ * ```
+ * @category IEEE-754
  * @module ieee754
  */
 export * from "./float16/index.js";

package/cjs/ieee754.d.ts.map

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

package/cjs/ieee754.js

@@ -25,6 +25,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * **Note**: The `float16` and `float32` modules are used under the hood by the
  * `f16round` and `fround` functions, respectively.
  *
+ * @example
+ * ```ts
+ * import { decodeFloat16, encodeFloat16 } from "@nick/math/ieee754";
+ * import assert from "node:assert";
+ *
+ * const encoded = encodeFloat16(1);
+ * assert.strictEqual(decodeFloat16(encoded), 1);
+ * ```
+ * @category IEEE-754
  * @module ieee754
  */
 __exportStar(require("./float16/index.js"), exports);

package/cjs/ieee754.js.map

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

package/cjs/imul.d.ts

@@ -2,6 +2,13 @@
  * Performs a 32-bit integer multiplication of two numbers (interpreted as
  * 32-bit integers), returning a 32-bit result.
  *
+ * @example
+ * ```ts
+ * import { imul } from "@nick/math/imul";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(imul(2, 3), 6);
+ * ```
  * @module imul
  */
 /**

package/cjs/imul.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"imul.d.ts","sourceRoot":"","sources":["../src/imul.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIjD"}

package/cjs/imul.js

@@ -3,6 +3,13 @@
  * Performs a 32-bit integer multiplication of two numbers (interpreted as
  * 32-bit integers), returning a 32-bit result.
  *
+ * @example
+ * ```ts
+ * import { imul } from "@nick/math/imul";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(imul(2, 3), 6);
+ * ```
  * @module imul
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/imul.js.map

@@ -1 +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"}
+{"version":3,"file":"imul.js","sourceRoot":"","sources":["../src/imul.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;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

@@ -37,6 +37,7 @@
  * // ...
  * assert.ok(math.isFinite(420));
  * ```
+ * @category Core
  * @module math
  */
 export * from "./abs.js";

package/cjs/index.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;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

@@ -66,6 +66,7 @@ exports.default = void 0;
  * // ...
  * assert.ok(math.isFinite(420));
  * ```
+ * @category Core
  * @module math
  */
 __exportStar(require("./abs.js"), exports);

package/cjs/index.js.map

@@ -1 +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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;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"}

package/cjs/log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAsBrC"}
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAsBrC"}

package/cjs/log.js

@@ -4,6 +4,13 @@ exports.log = log;
 /**
  * Calculates the natural logarithm of a number (logₑ).
  *
+ * @example
+ * ```ts
+ * import { log } from "@nick/math/log";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(log(1), 0);
+ * ```
  * @module log
  */
 const epsilon_js_1 = require("./constants/epsilon.js");

package/cjs/log.js.map

@@ -1 +1 @@
-{"version":3,"file":"log.js","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":";;AAmBA,kBAsBC;AAzCD;;;;GAIG;AACH,uDAAiD;AACjD,+CAAyC;AACzC,+CAAyC;AACzC,2EAAqE;AACrE,2EAAqE;AACrE,qCAA+B;AAE/B;;;;;;GAMG;AACH,SAAgB,GAAG,CAAC,CAAS;IAC3B,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,YAAG,CAAC,CAAC,gBAAgB;IACzD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,wCAAiB,CAAC,CAAC,uBAAuB;IAC9D,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,cAAc;IACrC,IAAI,CAAC,KAAK,wCAAiB;QAAE,OAAO,CAAC,CAAC,CAAC,4BAA4B;IAEnE,MAAM,aAAa,GAAG,oBAAO,GAAG,EAAE,CAAC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,CAAC;QAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;IAE1B,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACxC,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAE7B,kEAAkE;IAClE,OAAO,IAAA,YAAG,EAAC,IAAI,CAAC,IAAI,aAAa,EAAE,CAAC;QAClC,GAAG,IAAI,IAAI,GAAG,CAAC,CAAC;QAChB,IAAI,IAAI,EAAE,CAAC;QACX,CAAC,IAAI,CAAC,CAAC;IACT,CAAC;IAED,+CAA+C;IAC/C,OAAO,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,YAAG,CAAC;AAC3B,CAAC"}
+{"version":3,"file":"log.js","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":";;AA0BA,kBAsBC;AAhDD;;;;;;;;;;;GAWG;AACH,uDAAiD;AACjD,+CAAyC;AACzC,+CAAyC;AACzC,2EAAqE;AACrE,2EAAqE;AACrE,qCAA+B;AAE/B;;;;;;GAMG;AACH,SAAgB,GAAG,CAAC,CAAS;IAC3B,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,YAAG,CAAC,CAAC,gBAAgB;IACzD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,wCAAiB,CAAC,CAAC,uBAAuB;IAC9D,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,cAAc;IACrC,IAAI,CAAC,KAAK,wCAAiB;QAAE,OAAO,CAAC,CAAC,CAAC,4BAA4B;IAEnE,MAAM,aAAa,GAAG,oBAAO,GAAG,EAAE,CAAC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,CAAC;QAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;IAE1B,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACxC,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAE7B,kEAAkE;IAClE,OAAO,IAAA,YAAG,EAAC,IAAI,CAAC,IAAI,aAAa,EAAE,CAAC;QAClC,GAAG,IAAI,IAAI,GAAG,CAAC,CAAC;QAChB,IAAI,IAAI,EAAE,CAAC;QACX,CAAC,IAAI,CAAC,CAAC;IACT,CAAC;IAED,+CAA+C;IAC/C,OAAO,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,YAAG,CAAC;AAC3B,CAAC"}

package/cjs/log10.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log10.d.ts","sourceRoot":"","sources":["../src/log10.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEvC"}
+{"version":3,"file":"log10.d.ts","sourceRoot":"","sources":["../src/log10.ts"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEvC"}

package/cjs/log10.js

@@ -4,6 +4,13 @@ exports.log10 = log10;
 /**
  * Calculates the base-10 logarithm of a number.
  *
+ * @example
+ * ```ts
+ * import { log10 } from "@nick/math/log10";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(log10(1), 0);
+ * ```
  * @module log10
  */
 const log10e_js_1 = require("./constants/log10e.js");

package/cjs/log10.js.map

@@ -1 +1 @@
-{"version":3,"file":"log10.js","sourceRoot":"","sources":["../src/log10.ts"],"names":[],"mappings":";;AAeA,sBAEC;AAjBD;;;;GAIG;AACH,qDAA+C;AAC/C,qCAA+B;AAE/B;;;;;;GAMG;AACH,SAAgB,KAAK,CAAC,CAAS;IAC7B,OAAO,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,kBAAM,CAAC;AACzB,CAAC"}
+{"version":3,"file":"log10.js","sourceRoot":"","sources":["../src/log10.ts"],"names":[],"mappings":";;AAsBA,sBAEC;AAxBD;;;;;;;;;;;GAWG;AACH,qDAA+C;AAC/C,qCAA+B;AAE/B;;;;;;GAMG;AACH,SAAgB,KAAK,CAAC,CAAS;IAC7B,OAAO,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,kBAAM,CAAC;AACzB,CAAC"}

package/cjs/log1p.d.ts.map

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