@nberlette/math 0.7.0 → 0.7.1

package/esm/constants/negative_infinity.js

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `NEGATIVE_INFINITY` constant, matching `Number.NEGATIVE_INFINITY`.
+ *
+ * @example
+ * ```ts
+ * import { NEGATIVE_INFINITY } from "@nick/math/constants/negative-infinity";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
+ * ```
+ * @category Constants
+ * @module negative-infinity
+ */
 /**
  * Negative Infinity is a special value representing negative infinity, which
  * is less than any other number. It is approximately equal to

package/esm/constants/negative_infinity.js.map

@@ -1 +1 @@
-{"version":3,"file":"negative_infinity.js","sourceRoot":"","sources":["../../src/constants/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAsB,CAAC,CAAC,GAAG,CAAsB,CAAC"}
+{"version":3,"file":"negative_infinity.js","sourceRoot":"","sources":["../../src/constants/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAsB,CAAC,CAAC,GAAG,CAAsB,CAAC"}

package/esm/constants/pi.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `PI` constant, matching `Math.PI`.
+ *
+ * @example
+ * ```ts
+ * import { PI } from "@nick/math/constants/pi";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(PI, Math.PI);
+ * ```
+ * @category Constants
+ * @module pi
+ */
 /**
  * Represents the mathematical constant `π` (pi), the ratio of a circle's
  * circumference to its diameter, approximately equal to `3.141592653589793`.

package/esm/constants/pi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../src/constants/pi.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,EAAE,EAAE,EAAsB,CAAC;AACxC,MAAM,MAAM,EAAE,GAAG,iBAAiB,CAAC"}
+{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../src/constants/pi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,EAAE,EAAE,EAAsB,CAAC;AACxC,MAAM,MAAM,EAAE,GAAG,iBAAiB,CAAC"}

package/esm/constants/pi.js

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `PI` constant, matching `Math.PI`.
+ *
+ * @example
+ * ```ts
+ * import { PI } from "@nick/math/constants/pi";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(PI, Math.PI);
+ * ```
+ * @category Constants
+ * @module pi
+ */
 /**
  * Represents the mathematical constant `π` (pi), the ratio of a circle's
  * circumference to its diameter, approximately equal to `3.141592653589793`.

package/esm/constants/pi.js.map

@@ -1 +1 @@
-{"version":3,"file":"pi.js","sourceRoot":"","sources":["../../src/constants/pi.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,EAAE,GAAO,iBAAiB,CAAC"}
+{"version":3,"file":"pi.js","sourceRoot":"","sources":["../../src/constants/pi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,EAAE,GAAO,iBAAiB,CAAC"}

package/esm/constants/positive_infinity.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `POSITIVE_INFINITY` constant, matching `Number.POSITIVE_INFINITY`.
+ *
+ * @example
+ * ```ts
+ * import { POSITIVE_INFINITY } from "@nick/math/constants/positive-infinity";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+ * ```
+ * @category Constants
+ * @module positive-infinity
+ */
 /**
  * Positive Infinity is a special value representing positive infinity, which
  * is greater than any other number. It is approximately equal to

package/esm/constants/positive_infinity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"positive_infinity.d.ts","sourceRoot":"","sources":["../../src/constants/positive_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAA8C,CAAC;AAE/E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC;AAEtC,OAAO,EAAE,iBAAiB,IAAI,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"positive_infinity.d.ts","sourceRoot":"","sources":["../../src/constants/positive_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAA8C,CAAC;AAE/E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC;AAEtC,OAAO,EAAE,iBAAiB,IAAI,QAAQ,EAAE,CAAC"}

package/esm/constants/positive_infinity.js

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `POSITIVE_INFINITY` constant, matching `Number.POSITIVE_INFINITY`.
+ *
+ * @example
+ * ```ts
+ * import { POSITIVE_INFINITY } from "@nick/math/constants/positive-infinity";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+ * ```
+ * @category Constants
+ * @module positive-infinity
+ */
 /**
  * Positive Infinity is a special value representing positive infinity, which
  * is greater than any other number. It is approximately equal to

package/esm/constants/positive_infinity.js.map

@@ -1 +1 @@
-{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/constants/positive_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAsB,CAAC,GAAG,CAAsB,CAAC;AAmB/E,OAAO,EAAE,iBAAiB,IAAI,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/constants/positive_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAsB,CAAC,GAAG,CAAsB,CAAC;AAmB/E,OAAO,EAAE,iBAAiB,IAAI,QAAQ,EAAE,CAAC"}

package/esm/constants/positive_zero.d.ts

@@ -4,6 +4,13 @@
  * native JavaScript language, provided for stronger type-safety when working
  * with positive zero values.
  *
+ * @example
+ * ```ts
+ * import { POSITIVE_ZERO } from "@nick/math/constants/positive-zero";
+ * import assert from "node:assert";
+ *
+ * assert.ok(Object.is(POSITIVE_ZERO, 0));
+ * ```
  * @module positive-zero
  */
 declare const PositiveZero: unique symbol;

package/esm/constants/positive_zero.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"positive_zero.d.ts","sourceRoot":"","sources":["../../src/constants/positive_zero.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,QAAA,MAAM,YAAY,EAAE,OAAO,MAAoB,CAAC;AAEhD,UAAU,YAAY;IACpB,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,EAAE,aAAkC,CAAC;AAE/D,kBAAkB;AAClB,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,YAAY,CAAC"}
+{"version":3,"file":"positive_zero.d.ts","sourceRoot":"","sources":["../../src/constants/positive_zero.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,QAAA,MAAM,YAAY,EAAE,OAAO,MAAoB,CAAC;AAEhD,UAAU,YAAY;IACpB,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,EAAE,aAAkC,CAAC;AAE/D,kBAAkB;AAClB,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,YAAY,CAAC"}

package/esm/constants/positive_zero.js

@@ -4,6 +4,13 @@
  * native JavaScript language, provided for stronger type-safety when working
  * with positive zero values.
  *
+ * @example
+ * ```ts
+ * import { POSITIVE_ZERO } from "@nick/math/constants/positive-zero";
+ * import assert from "node:assert";
+ *
+ * assert.ok(Object.is(POSITIVE_ZERO, 0));
+ * ```
  * @module positive-zero
  */
 // deno-lint-ignore no-unused-vars

package/esm/constants/positive_zero.js.map

@@ -1 +1 @@
-{"version":3,"file":"positive_zero.js","sourceRoot":"","sources":["../../src/constants/positive_zero.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,kCAAkC;AAClC,MAAM,YAAY,GAAkB,MAAM,CAAC,GAAG,CAAC,CAAC;AAMhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAkB,CAAkB,CAAC"}
+{"version":3,"file":"positive_zero.js","sourceRoot":"","sources":["../../src/constants/positive_zero.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,kCAAkC;AAClC,MAAM,YAAY,GAAkB,MAAM,CAAC,GAAG,CAAC,CAAC;AAMhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAkB,CAAkB,CAAC"}

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

@@ -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/esm/constants/sqrt1_2.js.map

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

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

@@ -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/esm/constants/sqrt2.js.map

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

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

@@ -1,6 +1,13 @@
 /**
  * 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
  */
 import { abs } from "./abs.js";

package/esm/cos.js.map

@@ -1 +1 @@
-{"version":3,"file":"cos.js","sourceRoot":"","sources":["../src/cos.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,UAAU,GAAG,CAAC,CAAS;IAC3B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAAE,OAAO,GAAG,CAAC;IAE7B,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC7B,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,OAAO,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":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,UAAU,GAAG,CAAC,CAAS;IAC3B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAAE,OAAO,GAAG,CAAC;IAE7B,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC7B,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,OAAO,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/esm/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/esm/cosh.js

@@ -1,6 +1,13 @@
 /**
  * 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
  */
 import { exp } from "./exp.js";

package/esm/cosh.js.map

@@ -1 +1 @@
-{"version":3,"file":"cosh.js","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAAC,CAAS;IAC5B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAChC,CAAC"}
+{"version":3,"file":"cosh.js","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAAC,CAAS;IAC5B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAChC,CAAC"}

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

@@ -1,4 +1,14 @@
 /**
+ * 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/esm/exp.js.map

@@ -1 +1 @@
-{"version":3,"file":"exp.js","sourceRoot":"","sources":["../src/exp.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,GAAG,CAAC,CAAS;IAC3B,IAAI,kBAAkB,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,kBAAkB,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAChD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAEtB,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACjB,IAAI,MAAM,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC;IAExC,mDAAmD;IACnD,OAAO,IAAI,GAAG,OAAO,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":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,GAAG,CAAC,CAAS;IAC3B,IAAI,kBAAkB,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,kBAAkB,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAChD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAEtB,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACjB,IAAI,MAAM,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC;IAExC,mDAAmD;IACnD,OAAO,IAAI,GAAG,OAAO,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/esm/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/esm/expm1.js

@@ -2,6 +2,13 @@
  * 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
  */
 import { EPSILON } from "./constants/epsilon.js";

package/esm/expm1.js.map

@@ -1 +1 @@
-{"version":3,"file":"expm1.js","sourceRoot":"","sources":["../src/expm1.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;;;GAQG;AACH,MAAM,UAAU,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,iBAAiB;QAAE,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,KAAK,iBAAiB;QAAE,OAAO,CAAC,CAAC,CAAC;IACvC,qEAAqE;IACrE,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO;QAAE,OAAO,CAAC,CAAC;IAC/B,oDAAoD;IACpD,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC"}
+{"version":3,"file":"expm1.js","sourceRoot":"","sources":["../src/expm1.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;;;GAQG;AACH,MAAM,UAAU,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,iBAAiB;QAAE,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,KAAK,iBAAiB;QAAE,OAAO,CAAC,CAAC,CAAC;IACvC,qEAAqE;IACrE,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO;QAAE,OAAO,CAAC,CAAC;IAC/B,oDAAoD;IACpD,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC"}

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

@@ -8,6 +8,13 @@
  *
  * [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
  */
 import { roundFloat16 } from "./float16/round.js";

package/esm/f16round.js.map

@@ -1 +1 @@
-{"version":3,"file":"f16round.js","sourceRoot":"","sources":["../src/f16round.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,QAAQ,CAAC,CAAS;IAChC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;AACzB,CAAC"}
+{"version":3,"file":"f16round.js","sourceRoot":"","sources":["../src/f16round.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,QAAQ,CAAC,CAAS;IAChC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;AACzB,CAAC"}

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

@@ -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/esm/float16/constants.js.map

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

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

@@ -13,6 +13,13 @@
  * 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
  */
 import float16 from "./constants.js";

package/esm/float16/decode.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/float16/decode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/float16/decode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC/B,CAAC"}

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

@@ -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
  */
 import float16 from "./constants.js";

package/esm/float16/encode.js.map

@@ -1 +1 @@
-{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float16/encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AAChC,CAAC"}
+{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float16/encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AAChC,CAAC"}

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

@@ -2,6 +2,14 @@
  * 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
  */
 import { isNaN } from "../guards/nan.js";

package/esm/float16/guards.js.map

@@ -1 +1 @@
-{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float16/guards.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAsB1C,MAAM,UAAU,SAAS,CAAC,EAAW;IACnC,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,YAAY,CAAC,EAAE,CAAC,CAAC;AACzE,CAAC"}
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float16/guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAsB1C,MAAM,UAAU,SAAS,CAAC,EAAW;IACnC,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,YAAY,CAAC,EAAE,CAAC,CAAC;AACzE,CAAC"}

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

@@ -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/esm/float16/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","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.js","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/esm/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/esm/float16/round.js

@@ -10,6 +10,13 @@
  *
  * [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
  */
 import { encodeFloat16 } from "./encode.js";

package/esm/float16/round.js.map

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

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