@nberlette/math 0.7.0 → 0.7.1

package/cjs/constants/sqrt1_2.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `SQRT1_2` constant, matching `Math.SQRT1_2`.
+ *
+ * @example
+ * ```ts
+ * import { SQRT1_2 } from "@nick/math/constants/sqrt1_2";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(SQRT1_2, Math.SQRT1_2);
+ * ```
+ * @category Constants
+ * @module sqrt1-2
+ */
 /**
  * The square root of `1/2`, approximately equal to `0.7071067811865476`.
  *

package/cjs/constants/sqrt1_2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrt1_2.d.ts","sourceRoot":"","sources":["../../src/constants/sqrt1_2.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,OAA4B,CAAC;AACnD,MAAM,MAAM,OAAO,GAAG,kBAAkB,CAAC"}
+{"version":3,"file":"sqrt1_2.d.ts","sourceRoot":"","sources":["../../src/constants/sqrt1_2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,OAA4B,CAAC;AACnD,MAAM,MAAM,OAAO,GAAG,kBAAkB,CAAC"}

package/cjs/constants/sqrt1_2.js

@@ -1,4 +1,18 @@
 "use strict";
+/**
+ * This module provides runtime and type-level implementations of the
+ * `SQRT1_2` constant, matching `Math.SQRT1_2`.
+ *
+ * @example
+ * ```ts
+ * import { SQRT1_2 } from "@nick/math/constants/sqrt1_2";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(SQRT1_2, Math.SQRT1_2);
+ * ```
+ * @category Constants
+ * @module sqrt1-2
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQRT1_2 = void 0;
 /**

package/cjs/constants/sqrt1_2.js.map

@@ -1 +1 @@
-{"version":3,"file":"sqrt1_2.js","sourceRoot":"","sources":["../../src/constants/sqrt1_2.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,OAAO,GAAY,kBAAkB,CAAC"}
+{"version":3,"file":"sqrt1_2.js","sourceRoot":"","sources":["../../src/constants/sqrt1_2.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH;;;;;GAKG;AACU,QAAA,OAAO,GAAY,kBAAkB,CAAC"}

package/cjs/constants/sqrt2.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `SQRT2` constant, matching `Math.SQRT2`.
+ *
+ * @example
+ * ```ts
+ * import { SQRT2 } from "@nick/math/constants/sqrt2";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(SQRT2, Math.SQRT2);
+ * ```
+ * @category Constants
+ * @module sqrt2
+ */
 /**
  * The square root of `2`, approximately equal to `1.4142135623730951`.
  *

package/cjs/constants/sqrt2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrt2.d.ts","sourceRoot":"","sources":["../../src/constants/sqrt2.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAA0B,CAAC;AAC/C,MAAM,MAAM,KAAK,GAAG,kBAAkB,CAAC"}
+{"version":3,"file":"sqrt2.d.ts","sourceRoot":"","sources":["../../src/constants/sqrt2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAA0B,CAAC;AAC/C,MAAM,MAAM,KAAK,GAAG,kBAAkB,CAAC"}

package/cjs/constants/sqrt2.js

@@ -1,4 +1,18 @@
 "use strict";
+/**
+ * This module provides runtime and type-level implementations of the
+ * `SQRT2` constant, matching `Math.SQRT2`.
+ *
+ * @example
+ * ```ts
+ * import { SQRT2 } from "@nick/math/constants/sqrt2";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(SQRT2, Math.SQRT2);
+ * ```
+ * @category Constants
+ * @module sqrt2
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQRT2 = void 0;
 /**

package/cjs/constants/sqrt2.js.map

@@ -1 +1 @@
-{"version":3,"file":"sqrt2.js","sourceRoot":"","sources":["../../src/constants/sqrt2.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,KAAK,GAAU,kBAAkB,CAAC"}
+{"version":3,"file":"sqrt2.js","sourceRoot":"","sources":["../../src/constants/sqrt2.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH;;;;;GAKG;AACU,QAAA,KAAK,GAAU,kBAAkB,CAAC"}

package/cjs/cos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cos.d.ts","sourceRoot":"","sources":["../src/cos.ts"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAUrC"}
+{"version":3,"file":"cos.d.ts","sourceRoot":"","sources":["../src/cos.ts"],"names":[],"mappings":"AAiBA;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAUrC"}

package/cjs/cos.js

@@ -4,6 +4,13 @@ exports.cos = cos;
 /**
  * Calculates the cosine of a number, returning a value in the range `[-1, 1]`.
  *
+ * @example
+ * ```ts
+ * import { cos } from "@nick/math/cos";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(cos(0), 1);
+ * ```
  * @module cos
  */
 const abs_js_1 = require("./abs.js");

package/cjs/cos.js.map

@@ -1 +1 @@
-{"version":3,"file":"cos.js","sourceRoot":"","sources":["../src/cos.ts"],"names":[],"mappings":";;AAkBA,kBAUC;AA5BD;;;;GAIG;AACH,qCAA+B;AAC/B,uDAAiD;AACjD,+CAAyC;AACzC,kDAA8C;AAE9C;;;;;;;GAOG;AACH,SAAgB,GAAG,CAAC,CAAS;IAC3B,IAAI,CAAC,IAAA,oBAAQ,EAAC,CAAC,CAAC;QAAE,OAAO,YAAG,CAAC;IAE7B,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC7B,OAAO,IAAA,YAAG,EAAC,IAAI,CAAC,GAAG,oBAAO,EAAE,CAAC;QAC3B,CAAC,IAAI,CAAC,CAAC;QACP,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC/B,GAAG,IAAI,IAAI,CAAC;IACd,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}
+{"version":3,"file":"cos.js","sourceRoot":"","sources":["../src/cos.ts"],"names":[],"mappings":";;AAyBA,kBAUC;AAnCD;;;;;;;;;;;GAWG;AACH,qCAA+B;AAC/B,uDAAiD;AACjD,+CAAyC;AACzC,kDAA8C;AAE9C;;;;;;;GAOG;AACH,SAAgB,GAAG,CAAC,CAAS;IAC3B,IAAI,CAAC,IAAA,oBAAQ,EAAC,CAAC,CAAC;QAAE,OAAO,YAAG,CAAC;IAE7B,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC7B,OAAO,IAAA,YAAG,EAAC,IAAI,CAAC,GAAG,oBAAO,EAAE,CAAC;QAC3B,CAAC,IAAI,CAAC,CAAC;QACP,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC/B,GAAG,IAAI,IAAI,CAAC;IACd,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/cjs/cosh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cosh.d.ts","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtC"}
+{"version":3,"file":"cosh.d.ts","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtC"}

package/cjs/cosh.js

@@ -4,6 +4,13 @@ exports.cosh = cosh;
 /**
  * Calculates the hyperbolic cosine of a number.
  *
+ * @example
+ * ```ts
+ * import { cosh } from "@nick/math/cosh";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(cosh(0), 1);
+ * ```
  * @module cosh
  */
 const exp_js_1 = require("./exp.js");

package/cjs/cosh.js.map

@@ -1 +1 @@
-{"version":3,"file":"cosh.js","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":";;AAeA,oBAEC;AAjBD;;;;GAIG;AACH,qCAA+B;AAE/B;;;;;;;GAOG;AACH,SAAgB,IAAI,CAAC,CAAS;IAC5B,OAAO,CAAC,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,IAAA,YAAG,EAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAChC,CAAC"}
+{"version":3,"file":"cosh.js","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":";;AAsBA,oBAEC;AAxBD;;;;;;;;;;;GAWG;AACH,qCAA+B;AAE/B;;;;;;;GAOG;AACH,SAAgB,IAAI,CAAC,CAAS;IAC5B,OAAO,CAAC,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,IAAA,YAAG,EAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAChC,CAAC"}

package/cjs/exp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exp.d.ts","sourceRoot":"","sources":["../src/exp.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBrC"}
+{"version":3,"file":"exp.d.ts","sourceRoot":"","sources":["../src/exp.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBrC"}

package/cjs/exp.js

@@ -2,6 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exp = exp;
 /**
+ * Provides the `exp` function, a local implementation of `Math.exp` for
+ * computing exponentials (`e^x`) without relying on the global `Math` object.
+ *
+ * @example
+ * ```ts
+ * import { exp } from "@nick/math/exp";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(exp(0), 1);
+ * ```
  * @category Exponential
  * @module exp
  */

package/cjs/exp.js.map

@@ -1 +1 @@
-{"version":3,"file":"exp.js","sourceRoot":"","sources":["../src/exp.ts"],"names":[],"mappings":";;AA4BA,kBAgBC;AA5CD;;;GAGG;AACH,uDAAiD;AACjD,wEAAmE;AACnE,wEAAmE;AACnE,4CAAwC;AACxC,qCAA+B;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,GAAG,CAAC,CAAS;IAC3B,IAAI,IAAA,yCAAkB,EAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,IAAA,yCAAkB,EAAC,CAAC,CAAC,IAAI,IAAA,cAAK,EAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAChD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAEtB,MAAM,CAAC,GAAG,IAAA,YAAG,EAAC,CAAC,CAAC,CAAC;IACjB,IAAI,MAAM,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC;IAExC,mDAAmD;IACnD,OAAO,IAAI,GAAG,oBAAO,EAAE,CAAC;QACtB,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC;QACtB,MAAM,IAAI,IAAI,CAAC;QACf,SAAS,IAAI,CAAC,CAAC;IACjB,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;AACrC,CAAC"}
+{"version":3,"file":"exp.js","sourceRoot":"","sources":["../src/exp.ts"],"names":[],"mappings":";;AAsCA,kBAgBC;AAtDD;;;;;;;;;;;;;GAaG;AACH,uDAAiD;AACjD,wEAAmE;AACnE,wEAAmE;AACnE,4CAAwC;AACxC,qCAA+B;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,GAAG,CAAC,CAAS;IAC3B,IAAI,IAAA,yCAAkB,EAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,IAAA,yCAAkB,EAAC,CAAC,CAAC,IAAI,IAAA,cAAK,EAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAChD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAEtB,MAAM,CAAC,GAAG,IAAA,YAAG,EAAC,CAAC,CAAC,CAAC;IACjB,IAAI,MAAM,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC;IAExC,mDAAmD;IACnD,OAAO,IAAI,GAAG,oBAAO,EAAE,CAAC;QACtB,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC;QACtB,MAAM,IAAI,IAAI,CAAC;QACf,SAAS,IAAI,CAAC,CAAC;IACjB,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;AACrC,CAAC"}

package/cjs/expm1.d.ts.map

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

package/cjs/expm1.js

@@ -5,6 +5,13 @@ exports.expm1 = expm1;
  * Calculates the exponential of `x` minus 1 (`exp(x) - 1`) with a high degree
  * of accuracy, even for very small values of `x`.
  *
+ * @example
+ * ```ts
+ * import { expm1 } from "@nick/math/expm1";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(expm1(0), 0);
+ * ```
  * @module expm1
  */
 const epsilon_js_1 = require("./constants/epsilon.js");

package/cjs/expm1.js.map

@@ -1 +1 @@
-{"version":3,"file":"expm1.js","sourceRoot":"","sources":["../src/expm1.ts"],"names":[],"mappings":";;AAqBA,sBASC;AA9BD;;;;;GAKG;AACH,uDAAiD;AACjD,qCAA+B;AAC/B,qCAA+B;AAC/B,2EAAqE;AACrE,2EAAqE;AAErE;;;;;;;;GAQG;AACH,SAAgB,KAAK,CAAC,CAAS;IAC7B,8BAA8B;IAC9B,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,aAAa;IAC3C,IAAI,CAAC,KAAK,wCAAiB;QAAE,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,KAAK,wCAAiB;QAAE,OAAO,CAAC,CAAC,CAAC;IACvC,qEAAqE;IACrE,IAAI,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,oBAAO;QAAE,OAAO,CAAC,CAAC;IAC/B,oDAAoD;IACpD,OAAO,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC"}
+{"version":3,"file":"expm1.js","sourceRoot":"","sources":["../src/expm1.ts"],"names":[],"mappings":";;AA4BA,sBASC;AArCD;;;;;;;;;;;;GAYG;AACH,uDAAiD;AACjD,qCAA+B;AAC/B,qCAA+B;AAC/B,2EAAqE;AACrE,2EAAqE;AAErE;;;;;;;;GAQG;AACH,SAAgB,KAAK,CAAC,CAAS;IAC7B,8BAA8B;IAC9B,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,aAAa;IAC3C,IAAI,CAAC,KAAK,wCAAiB;QAAE,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,KAAK,wCAAiB;QAAE,OAAO,CAAC,CAAC,CAAC;IACvC,qEAAqE;IACrE,IAAI,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,oBAAO;QAAE,OAAO,CAAC,CAAC;IAC/B,oDAAoD;IACpD,OAAO,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC"}

package/cjs/f16round.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"f16round.d.ts","sourceRoot":"","sources":["../src/f16round.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C"}
+{"version":3,"file":"f16round.d.ts","sourceRoot":"","sources":["../src/f16round.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C"}

package/cjs/f16round.js

@@ -11,6 +11,13 @@ exports.f16round = f16round;
  *
  * [Float16Array]: https://github.com/tc39/proposal-float16array
  *
+ * @example
+ * ```ts
+ * import { f16round } from "@nick/math/f16round";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(f16round(1.337), Math.f16round(1.337));
+ * ```
  * @module f16round
  */
 const round_js_1 = require("./float16/round.js");

package/cjs/f16round.js.map

@@ -1 +1 @@
-{"version":3,"file":"f16round.js","sourceRoot":"","sources":["../src/f16round.ts"],"names":[],"mappings":";;AAoCA,4BAEC;AAtCD;;;;;;;;;;;GAWG;AACH,iDAAkD;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,QAAQ,CAAC,CAAS;IAChC,OAAO,IAAA,uBAAY,EAAC,CAAC,CAAC,CAAC;AACzB,CAAC"}
+{"version":3,"file":"f16round.js","sourceRoot":"","sources":["../src/f16round.ts"],"names":[],"mappings":";;AA2CA,4BAEC;AA7CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,iDAAkD;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,QAAQ,CAAC,CAAS;IAChC,OAAO,IAAA,uBAAY,EAAC,CAAC,CAAC,CAAC;AACzB,CAAC"}

package/cjs/float16/constants.d.ts

@@ -8,6 +8,13 @@
  * of completeness and transparency, as well as for potential userland usage in
  * cases where the constants are needed for custom encoding/decoding logic.
  *
+ * @example
+ * ```ts
+ * import { FLOAT16_EXPONENT_BITS } from "@nick/math/float16/constants";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(FLOAT16_EXPONENT_BITS, 5);
+ * ```
  * @module float16/constants
  */
 /**

package/cjs/float16/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/float16/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAS,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,IAAS,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,IAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAM,CAAC;AAEzC;;;;GAIG;;;;;;;;;;;AACH,wBASiC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/float16/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAS,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,IAAS,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,IAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAM,CAAC;AAEzC;;;;GAIG;;;;;;;;;;;AACH,wBASW"}

package/cjs/float16/constants.js

@@ -9,6 +9,13 @@
  * of completeness and transparency, as well as for potential userland usage in
  * cases where the constants are needed for custom encoding/decoding logic.
  *
+ * @example
+ * ```ts
+ * import { FLOAT16_EXPONENT_BITS } from "@nick/math/float16/constants";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(FLOAT16_EXPONENT_BITS, 5);
+ * ```
  * @module float16/constants
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/float16/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/float16/constants.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAIH;;;;;;GAMG;AACU,QAAA,WAAW,GAAG,MAAM,CAAC;AAElC;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,MAAM,CAAC;AAEhD;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,MAAM,CAAC;AAEhD;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;;;;;;;GAUG;AACU,QAAA,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;GAIG;AACH,kBAAe;IACb,QAAQ,EAAE,6BAAqB;IAC/B,QAAQ,EAAE,6BAAqB;IAC/B,IAAI,EAAE,6BAAqB;IAC3B,GAAG,EAAE,mBAAW;IAChB,iBAAiB,EAAE,iCAAyB;IAC5C,iBAAiB,EAAE,iCAAyB;IAC5C,aAAa,EAAE,6BAAqB;IACpC,aAAa,EAAE,6BAAqB;CACN,CAAC"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/float16/constants.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAEH;;;;;;GAMG;AACU,QAAA,WAAW,GAAG,MAAM,CAAC;AAElC;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,MAAM,CAAC;AAEhD;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,MAAM,CAAC;AAEhD;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;;;;;;;GAUG;AACU,QAAA,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;GAIG;AACH,kBAAe;IACb,QAAQ,EAAE,6BAAqB;IAC/B,QAAQ,EAAE,6BAAqB;IAC/B,IAAI,EAAE,6BAAqB;IAC3B,GAAG,EAAE,mBAAW;IAChB,iBAAiB,EAAE,iCAAyB;IAC5C,iBAAiB,EAAE,iCAAyB;IAC5C,aAAa,EAAE,6BAAqB;IACpC,aAAa,EAAE,6BAAqB;CAC5B,CAAC"}

package/cjs/float16/decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/float16/decode.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD"}
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/float16/decode.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/cjs/float16/decode.js

@@ -19,6 +19,13 @@ exports.decodeFloat16 = decodeFloat16;
  * value into a standard JavaScript number, which can be used in arithmetic
  * operations or passed to other functions.
  *
+ * @example
+ * ```ts
+ * import { decodeFloat16 } from "@nick/math/float16/decode";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(decodeFloat16(0x3C00), 1);
+ * ```
  * @module float16/decode
  */
 const constants_js_1 = __importDefault(require("./constants.js"));

package/cjs/float16/decode.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/float16/decode.ts"],"names":[],"mappings":";;;;;AA0DA,sCAEC;AA5DD;;;;;;;;;;;;;;;;GAgBG;AACH,kEAAqC;AACrC,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,SAAgB,aAAa,CAAC,IAAY;IACxC,OAAO,IAAA,mBAAM,EAAC,IAAI,EAAE,sBAAO,CAAC,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/float16/decode.ts"],"names":[],"mappings":";;;;;AAiEA,sCAEC;AAnED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kEAAqC;AACrC,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,SAAgB,aAAa,CAAC,IAAY;IACxC,OAAO,IAAA,mBAAM,EAAC,IAAI,EAAE,sBAAO,CAAC,CAAC;AAC/B,CAAC"}

package/cjs/float16/encode.d.ts

@@ -13,6 +13,13 @@
  * DataView via `setUint16`, or used in other applications that require the
  * `Float16` format.
  *
+ * @example
+ * ```ts
+ * import { encodeFloat16 } from "@nick/math/float16/encode";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(encodeFloat16(1), 0x3C00);
+ * ```
  * @module float16/encode
  */
 /**

package/cjs/float16/encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/float16/encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/float16/encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/cjs/float16/encode.js

@@ -14,6 +14,13 @@
  * DataView via `setUint16`, or used in other applications that require the
  * `Float16` format.
  *
+ * @example
+ * ```ts
+ * import { encodeFloat16 } from "@nick/math/float16/encode";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(encodeFloat16(1), 0x3C00);
+ * ```
  * @module float16/encode
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {

package/cjs/float16/encode.js.map

@@ -1 +1 @@
-{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float16/encode.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;;;AAqDH,sCAEC;AArDD,kEAAqC;AACrC,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,SAAgB,aAAa,CAAC,KAAa;IACzC,OAAO,IAAA,mBAAM,EAAC,KAAK,EAAE,sBAAO,CAAC,CAAC;AAChC,CAAC"}
+{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float16/encode.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;;;;AAqDH,sCAEC;AArDD,kEAAqC;AACrC,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,SAAgB,aAAa,CAAC,KAAa;IACzC,OAAO,IAAA,mBAAM,EAAC,KAAK,EAAE,sBAAO,CAAC,CAAC;AAChC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/float16/guards.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;AACrE,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/float16/guards.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;AACrE,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/cjs/float16/guards.js

@@ -5,6 +5,14 @@ exports.isFloat16 = isFloat16;
  * This submodule provides type guards specific to the float16 module of the
  * `@nick/math` library, namely the {@linkcode isFloat16} predicate function.
  *
+ * @example
+ * ```ts
+ * import { isFloat16 } from "@nick/math/float16/guards";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isFloat16(0.5));
+ * assert.ok(!isFloat16(0.1));
+ * ```
  * @module float16/guards
  */
 const nan_js_1 = require("../guards/nan.js");

package/cjs/float16/guards.js.map

@@ -1 +1 @@
-{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float16/guards.ts"],"names":[],"mappings":";;AA8BA,8BAEC;AAhCD;;;;;GAKG;AACH,6CAAyC;AAEzC,yCAA0C;AAsB1C,SAAgB,SAAS,CAAC,EAAW;IACnC,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,IAAA,cAAK,EAAC,EAAE,CAAC,IAAI,EAAE,KAAK,IAAA,uBAAY,EAAC,EAAE,CAAC,CAAC;AACzE,CAAC"}
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float16/guards.ts"],"names":[],"mappings":";;AAsCA,8BAEC;AAxCD;;;;;;;;;;;;;GAaG;AACH,6CAAyC;AAEzC,yCAA0C;AAsB1C,SAAgB,SAAS,CAAC,EAAW;IACnC,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,IAAA,cAAK,EAAC,EAAE,CAAC,IAAI,EAAE,KAAK,IAAA,uBAAY,EAAC,EAAE,CAAC,CAAC;AACzE,CAAC"}

package/cjs/float16/index.d.ts

@@ -2,6 +2,15 @@
  * Utilities for working with `float16` values (16-bit half precision floating
  * point numbers), as defined by IEEE 754-2008.
  *
+ * @example
+ * ```ts
+ * import { decodeFloat16, encodeFloat16 } from "@nick/math/float16";
+ * import assert from "node:assert";
+ *
+ * const encoded = encodeFloat16(1);
+ * assert.strictEqual(decodeFloat16(encoded), 1);
+ * ```
+ * @category IEEE-754
  * @module float16
  */
 export * from "./decode.js";

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

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

package/cjs/float16/index.js

@@ -18,6 +18,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Utilities for working with `float16` values (16-bit half precision floating
  * point numbers), as defined by IEEE 754-2008.
  *
+ * @example
+ * ```ts
+ * import { decodeFloat16, encodeFloat16 } from "@nick/math/float16";
+ * import assert from "node:assert";
+ *
+ * const encoded = encodeFloat16(1);
+ * assert.strictEqual(decodeFloat16(encoded), 1);
+ * ```
+ * @category IEEE-754
  * @module float16
  */
 __exportStar(require("./decode.js"), exports);

package/cjs/float16/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/float16/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;GAKG;AACH,8CAA4B;AAC5B,8CAA4B;AAC5B,8CAA4B;AAC5B,6CAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/float16/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;GAcG;AACH,8CAA4B;AAC5B,8CAA4B;AAC5B,8CAA4B;AAC5B,6CAA2B"}

package/cjs/float16/round.d.ts.map

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

package/cjs/float16/round.js

@@ -13,6 +13,13 @@ exports.roundFloat16 = roundFloat16;
  *
  * [Float16Array]: https://github.com/tc39/proposal-float16array
  *
+ * @example
+ * ```ts
+ * import { roundFloat16 } from "@nick/math/float16/round";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(roundFloat16(1.337), Math.f16round(1.337));
+ * ```
  * @module float16/round
  */
 const encode_js_1 = require("./encode.js");

package/cjs/float16/round.js.map

@@ -1 +1 @@
-{"version":3,"file":"round.js","sourceRoot":"","sources":["../../src/float16/round.ts"],"names":[],"mappings":";;AAwCA,oCAEC;AA1CD;;;;;;;;;;;;;GAaG;AACH,2CAA4C;AAC5C,2CAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;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/float16/round.ts"],"names":[],"mappings":";;AA+CA,oCAEC;AAjDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2CAA4C;AAC5C,2CAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,YAAY,CAAC,CAAS;IACpC,OAAO,IAAA,yBAAa,EAAC,IAAA,yBAAa,EAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC"}

package/cjs/float32/constants.d.ts

@@ -8,6 +8,13 @@
  * of completeness and transparency, as well as for potential userland usage in
  * cases where the constants are needed for custom encoding/decoding logic.
  *
+ * @example
+ * ```ts
+ * import { FLOAT32_EXPONENT_BITS } from "@nick/math/float32/constants";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(FLOAT32_EXPONENT_BITS, 8);
+ * ```
  * @module float32/constants
  */
 /**

package/cjs/float32/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/float32/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,aAAa,CAAC;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,IAAa,CAAC;AAEhD;;;;GAIG;;;;;;;;;;;AACH,wBASiC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/float32/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,aAAa,CAAC;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,IAAa,CAAC;AAEhD;;;;GAIG;;;;;;;;;;;AACH,wBASW"}

package/cjs/float32/constants.js

@@ -9,6 +9,13 @@
  * of completeness and transparency, as well as for potential userland usage in
  * cases where the constants are needed for custom encoding/decoding logic.
  *
+ * @example
+ * ```ts
+ * import { FLOAT32_EXPONENT_BITS } from "@nick/math/float32/constants";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(FLOAT32_EXPONENT_BITS, 8);
+ * ```
  * @module float32/constants
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/float32/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/float32/constants.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAIH;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,CAAC,CAAC;AAEvC;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;GAKG;AACU,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACU,QAAA,WAAW,GAAG,UAAU,CAAC;AAEtC;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;;;;;;;GAUG;AACU,QAAA,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;GAIG;AACH,kBAAe;IACb,QAAQ,EAAE,6BAAqB;IAC/B,QAAQ,EAAE,6BAAqB;IAC/B,IAAI,EAAE,6BAAqB;IAC3B,GAAG,EAAE,mBAAW;IAChB,iBAAiB,EAAE,iCAAyB;IAC5C,iBAAiB,EAAE,iCAAyB;IAC5C,aAAa,EAAE,6BAAqB;IACpC,aAAa,EAAE,6BAAqB;CACN,CAAC"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/float32/constants.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAEH;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,CAAC,CAAC;AAEvC;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;GAKG;AACU,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACU,QAAA,WAAW,GAAG,UAAU,CAAC;AAEtC;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACU,QAAA,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACU,QAAA,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;;;;;;;GAUG;AACU,QAAA,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;GAIG;AACH,kBAAe;IACb,QAAQ,EAAE,6BAAqB;IAC/B,QAAQ,EAAE,6BAAqB;IAC/B,IAAI,EAAE,6BAAqB;IAC3B,GAAG,EAAE,mBAAW;IAChB,iBAAiB,EAAE,iCAAyB;IAC5C,iBAAiB,EAAE,iCAAyB;IAC5C,aAAa,EAAE,6BAAqB;IACpC,aAAa,EAAE,6BAAqB;CAC5B,CAAC"}

package/cjs/float32/decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/float32/decode.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD"}
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/float32/decode.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/cjs/float32/decode.js

@@ -24,6 +24,13 @@ exports.decodeFloat32 = decodeFloat32;
  * with 32-bits of precision), use the {@linkcode decodeFloat32} function of
  * this module, passing it the encoded value.
  *
+ * @example
+ * ```ts
+ * import { decodeFloat32 } from "@nick/math/float32/decode";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(decodeFloat32(0x3F800000), 1);
+ * ```
  * @module float32/decode
  */
 const constants_js_1 = __importDefault(require("./constants.js"));

package/cjs/float32/decode.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/float32/decode.ts"],"names":[],"mappings":";;;;;AA6DA,sCAEC;AA/DD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,kEAAqC;AACrC,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,SAAgB,aAAa,CAAC,IAAY;IACxC,OAAO,IAAA,mBAAM,EAAC,IAAI,EAAE,sBAAO,CAAC,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/float32/decode.ts"],"names":[],"mappings":";;;;;AAoEA,sCAEC;AAtED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,kEAAqC;AACrC,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,SAAgB,aAAa,CAAC,IAAY;IACxC,OAAO,IAAA,mBAAM,EAAC,IAAI,EAAE,sBAAO,CAAC,CAAC;AAC/B,CAAC"}

package/cjs/float32/encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/float32/encode.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/float32/encode.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/cjs/float32/encode.js

@@ -19,6 +19,13 @@ exports.encodeFloat32 = encodeFloat32;
  * {@linkcode decodeFloat32} function of the `./decode` module, passing it the
  * encoded value returned by {@linkcode encodeFloat32}.
  *
+ * @example
+ * ```ts
+ * import { encodeFloat32 } from "@nick/math/float32/encode";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(encodeFloat32(1), 0x3F800000);
+ * ```
  * @module float32/encode
  */
 const constants_js_1 = __importDefault(require("./constants.js"));

package/cjs/float32/encode.js.map

@@ -1 +1 @@
-{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float32/encode.ts"],"names":[],"mappings":";;;;;AAoEA,sCAEC;AAtED;;;;;;;;;;;;;;;;GAgBG;AACH,kEAAqC;AACrC,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,SAAgB,aAAa,CAAC,KAAa;IACzC,OAAO,IAAA,mBAAM,EAAC,KAAK,EAAE,sBAAO,CAAC,CAAC;AAChC,CAAC"}
+{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float32/encode.ts"],"names":[],"mappings":";;;;;AA2EA,sCAEC;AA7ED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kEAAqC;AACrC,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,SAAgB,aAAa,CAAC,KAAa;IACzC,OAAO,IAAA,mBAAM,EAAC,KAAK,EAAE,sBAAO,CAAC,CAAC;AAChC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/float32/guards.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;AACrE,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;AAK9D;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,EAAE,EAAE,CAAC,GACJ,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAChC,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/float32/guards.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;AACrE,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;AAK9D;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,EAAE,EAAE,CAAC,GACJ,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAChC,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/cjs/float32/guards.js

@@ -6,6 +6,15 @@ exports.isFiniteFloat32 = isFiniteFloat32;
  * This submodule provides type guards specific to the float32 module of the
  * `@nick/math` library, namely the {@linkcode isFloat32} predicate function.
  *
+ * @example
+ * ```ts
+ * import { isFiniteFloat32, isFloat32 } from "@nick/math/float32/guards";
+ * import assert from "node:assert";
+ *
+ * assert.ok(isFloat32(Math.fround(1.5)));
+ * assert.ok(isFiniteFloat32(Math.fround(1.5)));
+ * assert.ok(!isFloat32(1.1));
+ * ```
  * @module float32/guards
  */
 const nan_js_1 = require("../guards/nan.js");

package/cjs/float32/guards.js.map

@@ -1 +1 @@
-{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float32/guards.ts"],"names":[],"mappings":";;AA+BA,8BAEC;AAkBD,0CAEC;AArDD;;;;;GAKG;AACH,6CAAyC;AACzC,mDAA4D;AAE5D,yCAA0C;AAsB1C,SAAgB,SAAS,CAAC,EAAW;IACnC,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,IAAA,cAAK,EAAC,EAAE,CAAC,IAAI,EAAE,KAAK,IAAA,uBAAY,EAAC,EAAE,CAAC,CAAC;AACzE,CAAC;AAkBD,SAAgB,eAAe,CAAC,EAAW;IACzC,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,IAAA,oBAAQ,EAAC,EAAE,CAAC,CAAC;AACvC,CAAC"}
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float32/guards.ts"],"names":[],"mappings":";;AAwCA,8BAEC;AAkBD,0CAEC;AA9DD;;;;;;;;;;;;;;GAcG;AACH,6CAAyC;AACzC,mDAA4D;AAE5D,yCAA0C;AAsB1C,SAAgB,SAAS,CAAC,EAAW;IACnC,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,IAAA,cAAK,EAAC,EAAE,CAAC,IAAI,EAAE,KAAK,IAAA,uBAAY,EAAC,EAAE,CAAC,CAAC;AACzE,CAAC;AAkBD,SAAgB,eAAe,CAAC,EAAW;IACzC,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,IAAA,oBAAQ,EAAC,EAAE,CAAC,CAAC;AACvC,CAAC"}

package/cjs/float32/index.d.ts

@@ -2,6 +2,15 @@
  * Utilities for working with `float32` values (32-bit single precision
  * floating point numbers), as defined by IEEE 754-2008.
  *
+ * @example
+ * ```ts
+ * import { decodeFloat32, encodeFloat32 } from "@nick/math/float32";
+ * import assert from "node:assert";
+ *
+ * const encoded = encodeFloat32(1);
+ * assert.strictEqual(decodeFloat32(encoded), 1);
+ * ```
+ * @category IEEE-754
  * @module float32
  */
 export * from "./decode.js";

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/float32/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/cjs/float32/index.js

@@ -18,6 +18,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Utilities for working with `float32` values (32-bit single precision
  * floating point numbers), as defined by IEEE 754-2008.
  *
+ * @example
+ * ```ts
+ * import { decodeFloat32, encodeFloat32 } from "@nick/math/float32";
+ * import assert from "node:assert";
+ *
+ * const encoded = encodeFloat32(1);
+ * assert.strictEqual(decodeFloat32(encoded), 1);
+ * ```
+ * @category IEEE-754
  * @module float32
  */
 __exportStar(require("./decode.js"), exports);

package/cjs/float32/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/float32/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;GAKG;AACH,8CAA4B;AAC5B,8CAA4B;AAC5B,8CAA4B;AAC5B,6CAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/float32/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;GAcG;AACH,8CAA4B;AAC5B,8CAA4B;AAC5B,8CAA4B;AAC5B,6CAA2B"}

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

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