@nberlette/math 0.7.0 → 0.7.1

package/esm/float32/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 { 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.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/float32/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;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/float32/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;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/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/esm/float32/decode.js

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

package/esm/float32/decode.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/float32/decode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;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/float32/decode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC/B,CAAC"}

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

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

package/esm/float32/encode.js.map

@@ -1 +1 @@
-{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float32/encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,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/float32/encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,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/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/esm/float32/guards.js

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

package/esm/float32/guards.js.map

@@ -1 +1 @@
-{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float32/guards.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAe,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE5D,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;AAkBD,MAAM,UAAU,eAAe,CAAC,EAAW;IACzC,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;AACvC,CAAC"}
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float32/guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAe,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE5D,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;AAkBD,MAAM,UAAU,eAAe,CAAC,EAAW;IACzC,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;AACvC,CAAC"}

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

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

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

package/esm/float32/round.js

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

package/esm/float32/round.js.map

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

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

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

package/esm/floor.js.map

@@ -1 +1 @@
-{"version":3,"file":"floor.js","sourceRoot":"","sources":["../src/floor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAC,CAAS;IAC7B,CAAC,GAAG,CAAC,CAAC,CAAC;IACP,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,iBAAiB,IAAI,CAAC,KAAK,iBAAiB;QAAE,OAAO,CAAC,CAAC;IAC5E,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACtB,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,SAAS,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,SAAS,GAAG,CAAC,GAAG,SAAS,CAAC;IAChC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3C,CAAC"}
+{"version":3,"file":"floor.js","sourceRoot":"","sources":["../src/floor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAC,CAAS;IAC7B,CAAC,GAAG,CAAC,CAAC,CAAC;IACP,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,iBAAiB,IAAI,CAAC,KAAK,iBAAiB;QAAE,OAAO,CAAC,CAAC;IAC5E,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACtB,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,SAAS,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,SAAS,GAAG,CAAC,GAAG,SAAS,CAAC;IAChC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3C,CAAC"}

package/esm/fround.d.ts.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/esm/fround.js

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

package/esm/fround.js.map

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

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

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

package/esm/guards/finite.js.map

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

package/esm/guards/index.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","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/esm/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/esm/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/esm/guards/infinity.js

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

package/esm/guards/infinity.js.map

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

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

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

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

@@ -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/esm/guards/negative_infinity.js.map

@@ -1 +1 @@
-{"version":3,"file":"negative_infinity.js","sourceRoot":"","sources":["../../src/guards/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,EAAU;IAC3C,OAAO,CAAC,EAAE,KAAK,iBAAiB,CAAC;AACnC,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"negative_infinity.js","sourceRoot":"","sources":["../../src/guards/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,EAAU;IAC3C,OAAO,CAAC,EAAE,KAAK,iBAAiB,CAAC;AACnC,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

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

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

package/esm/guards/negative_zero.js.map

@@ -1 +1 @@
-{"version":3,"file":"negative_zero.js","sourceRoot":"","sources":["../../src/guards/negative_zero.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,EAAU;IACvC,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;AACxD,CAAC;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"negative_zero.js","sourceRoot":"","sources":["../../src/guards/negative_zero.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,EAAU;IACvC,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;AACxD,CAAC;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

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

@@ -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/esm/guards/positive_infinity.js.map

@@ -1 +1 @@
-{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/guards/positive_infinity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,EAAU;IAC3C,OAAO,CAAC,EAAE,KAAK,iBAAiB,CAAC;AACnC,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/guards/positive_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,EAAU;IAC3C,OAAO,CAAC,EAAE,KAAK,iBAAiB,CAAC;AACnC,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

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

@@ -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/esm/guards/positive_zero.js.map

@@ -1 +1 @@
-{"version":3,"file":"positive_zero.js","sourceRoot":"","sources":["../../src/guards/positive_zero.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,+BAA+B,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,UAAU,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":"AAAA;;;;;;;;;;;;;GAaG;AACH,cAAc,+BAA+B,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,UAAU,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/esm/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/esm/guards/safe_integer.js

@@ -8,6 +8,14 @@
  * 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
  */
 import { isFinite } from "./finite.js";

package/esm/guards/safe_integer.js.map

@@ -1 +1 @@
-{"version":3,"file":"safe_integer.js","sourceRoot":"","sources":["../../src/guards/safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAmCpE,gBAAgB;AAChB,MAAM,UAAU,aAAa,CAAC,MAAe;IAC3C,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;QACzE,MAAM,IAAI,gBAAgB,IAAI,MAAM,IAAI,gBAAgB,CAAC;AAC7D,CAAC;AAED,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAoB,CAAC"}
+{"version":3,"file":"safe_integer.js","sourceRoot":"","sources":["../../src/guards/safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAmCpE,gBAAgB;AAChB,MAAM,UAAU,aAAa,CAAC,MAAe;IAC3C,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;QACzE,MAAM,IAAI,gBAAgB,IAAI,MAAM,IAAI,gBAAgB,CAAC;AAC7D,CAAC;AAED,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAoB,CAAC"}

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

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

package/esm/hypot.js.map

@@ -1 +1 @@
-{"version":3,"file":"hypot.js","sourceRoot":"","sources":["../src/hypot.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,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,GAAG,CAAC,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,IAAI,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC"}
+{"version":3,"file":"hypot.js","sourceRoot":"","sources":["../src/hypot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,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,GAAG,CAAC,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,IAAI,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC"}

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