@nberlette/math 0.7.0 → 0.7.2

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

@@ -1 +1 @@
-{"version":3,"file":"ln10.d.ts","sourceRoot":"","sources":["../../src/constants/ln10.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,IAAwB,CAAC;AAC5C,MAAM,MAAM,IAAI,GAAG,iBAAiB,CAAC"}
+{"version":3,"file":"ln10.d.ts","sourceRoot":"","sources":["../../src/constants/ln10.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE,IAAwB,CAAC;AAE5C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,IAAI,GAAG,iBAAiB,CAAC"}

package/cjs/constants/ln10.js

@@ -1,11 +1,41 @@
 "use strict";
+/**
+ * This module provides runtime and type-level implementations of the `LN10`
+ * constant found in the native `Math` namespace, which represents the natural
+ * logarithm of the number `10` (approximately equal to `2.302585092994046`).
+ *
+ * The `LN10` constant exported by this module can be imported using a standard
+ * named import (i.e., at the _value_ level), or via a type-only import for a
+ * compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import { LN10 } from "@nick/math/constants/ln10";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(LN10, 2.302585092994046);
+ * ```
+ * @example
+ * ```ts
+ * import type { LN10 } from "@nick/math/constants/ln10";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<LN10>(2.302585092994046);
+ * ```
+ * @module ln10
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LN10 = void 0;
 /**
- * Represents the natural logarithm of `10`, approximately equal to
- * `2.302585092994046`.
+ * Represents the natural logarithm of the number `10`, approximately equal to
+ * `2.302585092994046`. This corresponds to the native `Math.LN10` constant.
+ * @example
+ * ```ts
+ * import { LN10 } from "@nick/math/constants/ln10";
+ * import assert from "node:assert";
  *
- * This is a local implementation of the native `Math.LN10` constant.
+ * assert.strictEqual(LN10, 2.302585092994046);
+ * ```
  * @category Constants
  */
 exports.LN10 = 2.302585092994046;

package/cjs/constants/ln10.js.map

@@ -1 +1 @@
-{"version":3,"file":"ln10.js","sourceRoot":"","sources":["../../src/constants/ln10.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACU,QAAA,IAAI,GAAS,iBAAiB,CAAC"}
+{"version":3,"file":"ln10.js","sourceRoot":"","sources":["../../src/constants/ln10.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAEH;;;;;;;;;;;GAWG;AACU,QAAA,IAAI,GAAS,iBAAiB,CAAC"}

package/cjs/constants/ln2.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `LN2` constant, the natural logarithm of 2.
+ *
+ * @example
+ * ```ts
+ * import { LN2 } from "@nick/math/constants/ln2";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(LN2, Math.LN2);
+ * ```
+ * @category Constants
+ * @module ln2
+ */
 /**
  * Represents the natural logarithm of `2`, approximately equal to
  * `0.6931471805599453`.

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

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

package/cjs/constants/ln2.js

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

package/cjs/constants/ln2.js.map

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

package/cjs/constants/log10e.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `LOG10E` constant, the base-10 logarithm of e.
+ *
+ * @example
+ * ```ts
+ * import { LOG10E } from "@nick/math/constants/log10e";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(LOG10E, Math.LOG10E);
+ * ```
+ * @category Constants
+ * @module log10e
+ */
 /**
  * Represents the base-10 logarithm of `e` (Euler's number), approximately
  * equal to `0.4342944819032518`.

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

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

package/cjs/constants/log10e.js

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

package/cjs/constants/log10e.js.map

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

package/cjs/constants/log2e.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `LOG2E` constant, the base-2 logarithm of e.
+ *
+ * @example
+ * ```ts
+ * import { LOG2E } from "@nick/math/constants/log2e";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(LOG2E, Math.LOG2E);
+ * ```
+ * @category Constants
+ * @module log2e
+ */
 /**
  * Represents the base-2 logarithm of `e` (Euler's number), approximately equal
  * to `1.4426950408889634`.

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

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

package/cjs/constants/log2e.js

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

package/cjs/constants/log2e.js.map

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

package/cjs/constants/max_safe_integer.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `MAX_SAFE_INTEGER` constant, matching `Number.MAX_SAFE_INTEGER`.
+ *
+ * @example
+ * ```ts
+ * import { MAX_SAFE_INTEGER } from "@nick/math/constants/max-safe-integer";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+ * ```
+ * @category Constants
+ * @module max-safe-integer
+ */
 /**
  * Represents the largest integer that can be represented in JavaScript without
  * losing precision, which is approximately equal to `9007199254740991`.

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

@@ -1 +1 @@
-{"version":3,"file":"max_safe_integer.d.ts","sourceRoot":"","sources":["../../src/constants/max_safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAAmC,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,CAAC"}
+{"version":3,"file":"max_safe_integer.d.ts","sourceRoot":"","sources":["../../src/constants/max_safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAAmC,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,CAAC"}

package/cjs/constants/max_safe_integer.js

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

package/cjs/constants/max_safe_integer.js.map

@@ -1 +1 @@
-{"version":3,"file":"max_safe_integer.js","sourceRoot":"","sources":["../../src/constants/max_safe_integer.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACU,QAAA,gBAAgB,GAAqB,gBAAgB,CAAC"}
+{"version":3,"file":"max_safe_integer.js","sourceRoot":"","sources":["../../src/constants/max_safe_integer.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH;;;;;;;GAOG;AACU,QAAA,gBAAgB,GAAqB,gBAAgB,CAAC"}

package/cjs/constants/max_value.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `MAX_VALUE` constant, matching `Number.MAX_VALUE`.
+ *
+ * @example
+ * ```ts
+ * import { MAX_VALUE } from "@nick/math/constants/max-value";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(MAX_VALUE, Number.MAX_VALUE);
+ * ```
+ * @category Constants
+ * @module max-value
+ */
 /**
  * Represents the largest positive finite number that can be represented in
  * JavaScript, which is approximately equal to `1.7976931348623157e+308`.

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

@@ -1 +1 @@
-{"version":3,"file":"max_value.d.ts","sourceRoot":"","sources":["../../src/constants/max_value.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,SAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,sBAAsB,CAAC"}
+{"version":3,"file":"max_value.d.ts","sourceRoot":"","sources":["../../src/constants/max_value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,SAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,sBAAsB,CAAC"}

package/cjs/constants/max_value.js

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

package/cjs/constants/max_value.js.map

@@ -1 +1 @@
-{"version":3,"file":"max_value.js","sourceRoot":"","sources":["../../src/constants/max_value.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACU,QAAA,SAAS,GAAc,sBAAsB,CAAC"}
+{"version":3,"file":"max_value.js","sourceRoot":"","sources":["../../src/constants/max_value.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH;;;;;;GAMG;AACU,QAAA,SAAS,GAAc,sBAAsB,CAAC"}

package/cjs/constants/min_safe_integer.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `MIN_SAFE_INTEGER` constant, matching `Number.MIN_SAFE_INTEGER`.
+ *
+ * @example
+ * ```ts
+ * import { MIN_SAFE_INTEGER } from "@nick/math/constants/min-safe-integer";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+ * ```
+ * @category Constants
+ * @module min-safe-integer
+ */
 /**
  * Represents the smallest integer that can be represented in JavaScript
  * without losing precision, which is approximately equal to

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

@@ -1 +1 @@
-{"version":3,"file":"min_safe_integer.d.ts","sourceRoot":"","sources":["../../src/constants/min_safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAAoC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,gBAAgB,CAAC"}
+{"version":3,"file":"min_safe_integer.d.ts","sourceRoot":"","sources":["../../src/constants/min_safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAAoC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,gBAAgB,CAAC"}

package/cjs/constants/min_safe_integer.js

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

package/cjs/constants/min_safe_integer.js.map

@@ -1 +1 @@
-{"version":3,"file":"min_safe_integer.js","sourceRoot":"","sources":["../../src/constants/min_safe_integer.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACU,QAAA,gBAAgB,GAAqB,CAAC,gBAAgB,CAAC"}
+{"version":3,"file":"min_safe_integer.js","sourceRoot":"","sources":["../../src/constants/min_safe_integer.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH;;;;;;;;GAQG;AACU,QAAA,gBAAgB,GAAqB,CAAC,gBAAgB,CAAC"}

package/cjs/constants/min_value.d.ts

@@ -1,3 +1,17 @@
+/**
+ * This module provides runtime and type-level implementations of the
+ * `MIN_VALUE` constant, matching `Number.MIN_VALUE`.
+ *
+ * @example
+ * ```ts
+ * import { MIN_VALUE } from "@nick/math/constants/min-value";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(MIN_VALUE, Number.MIN_VALUE);
+ * ```
+ * @category Constants
+ * @module min-value
+ */
 /**
  * Represents the smallest positive number that is greater than zero, which is
  * approximately equal to `5e-324`.

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

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

package/cjs/constants/min_value.js

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

package/cjs/constants/min_value.js.map

@@ -1 +1 @@
-{"version":3,"file":"min_value.js","sourceRoot":"","sources":["../../src/constants/min_value.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACU,QAAA,SAAS,GAAc,MAAM,CAAC"}
+{"version":3,"file":"min_value.js","sourceRoot":"","sources":["../../src/constants/min_value.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH;;;;;;GAMG;AACU,QAAA,SAAS,GAAc,MAAM,CAAC"}

package/cjs/constants/nan.d.ts

@@ -8,6 +8,13 @@
  * mathematical operations, such as dividing zero by zero, or parsing a string
  * that does not represent a valid number with `parseInt` or `parseFloat`.
  *
+ * @example
+ * ```ts
+ * import { NAN } from "@nick/math/constants/nan";
+ * import assert from "node:assert";
+ *
+ * assert.ok(Number.isNaN(NAN));
+ * ```
  * @module nan
  */
 declare const Not_a_Number: unique symbol;

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

@@ -1 +1 @@
-{"version":3,"file":"nan.d.ts","sourceRoot":"","sources":["../../src/constants/nan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,QAAA,MAAM,YAAY,EAAE,OAAO,MAAyB,CAAC;AACrD,KAAK,YAAY,GAAG,OAAO,YAAY,CAAC;AAExC;;;;;;;;;;;;GAYG;AAKH,UAAU,GAAG;IACX,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG,EAAE,GAAkB,CAAC;AAErC;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG,GAAG,CAAC;AAE/B,OAAO,EAAE,GAAG,IAAI,GAAG,EAAE,CAAC"}
+{"version":3,"file":"nan.d.ts","sourceRoot":"","sources":["../../src/constants/nan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,QAAA,MAAM,YAAY,EAAE,OAAO,MAAyB,CAAC;AACrD,KAAK,YAAY,GAAG,OAAO,YAAY,CAAC;AAExC;;;;;;;;;;;;GAYG;AAKH,UAAU,GAAG;IACX,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG,EAAE,GAAkB,CAAC;AAErC;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG,GAAG,CAAC;AAE/B,OAAO,EAAE,GAAG,IAAI,GAAG,EAAE,CAAC"}

package/cjs/constants/nan.js

@@ -9,6 +9,13 @@
  * mathematical operations, such as dividing zero by zero, or parsing a string
  * that does not represent a valid number with `parseInt` or `parseFloat`.
  *
+ * @example
+ * ```ts
+ * import { NAN } from "@nick/math/constants/nan";
+ * import assert from "node:assert";
+ *
+ * assert.ok(Number.isNaN(NAN));
+ * ```
  * @module nan
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/constants/nan.js.map

@@ -1 +1 @@
-{"version":3,"file":"nan.js","sourceRoot":"","sources":["../../src/constants/nan.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEH,4EAA4E;AAC5E,4CAA4C;AAC5C,MAAM,YAAY,GAAkB,MAAM,CAAC,QAAQ,CAAC,CAAC;AAwBrD;;;;;;;;GAQG;AACU,QAAA,GAAG,GAAQ,CAAC,GAAG,CAAQ,CAAC;AAQrB,cARH,WAAG,CAQG"}
+{"version":3,"file":"nan.js","sourceRoot":"","sources":["../../src/constants/nan.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAEH,4EAA4E;AAC5E,4CAA4C;AAC5C,MAAM,YAAY,GAAkB,MAAM,CAAC,QAAQ,CAAC,CAAC;AAwBrD;;;;;;;;GAQG;AACU,QAAA,GAAG,GAAQ,CAAC,GAAG,CAAQ,CAAC;AAQrB,cARH,WAAG,CAQG"}

package/cjs/constants/negative_infinity.d.ts

@@ -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/cjs/constants/negative_infinity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"negative_infinity.d.ts","sourceRoot":"","sources":["../../src/constants/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAA+C,CAAC;AAEhF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC"}
+{"version":3,"file":"negative_infinity.d.ts","sourceRoot":"","sources":["../../src/constants/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAA+C,CAAC;AAEhF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC"}

package/cjs/constants/negative_infinity.js

@@ -1,4 +1,18 @@
 "use strict";
+/**
+ * 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
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NEGATIVE_INFINITY = void 0;
 /**

package/cjs/constants/negative_infinity.js.map

@@ -1 +1 @@
-{"version":3,"file":"negative_infinity.js","sourceRoot":"","sources":["../../src/constants/negative_infinity.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACU,QAAA,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;AACU,QAAA,iBAAiB,GAAsB,CAAC,CAAC,GAAG,CAAsB,CAAC"}

package/cjs/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/cjs/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/cjs/constants/pi.js

@@ -1,4 +1,18 @@
 "use strict";
+/**
+ * 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
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PI = void 0;
 /**

package/cjs/constants/pi.js.map

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

package/cjs/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/cjs/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/cjs/constants/positive_infinity.js

@@ -1,4 +1,18 @@
 "use strict";
+/**
+ * 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
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Infinity = exports.POSITIVE_INFINITY = void 0;
 /**

package/cjs/constants/positive_infinity.js.map

@@ -1 +1 @@
-{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/constants/positive_infinity.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACU,QAAA,iBAAiB,GAAsB,CAAC,GAAG,CAAsB,CAAC;AAmBjD,mBAnBjB,yBAAiB,CAmBQ"}
+{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/constants/positive_infinity.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH;;;;;;;;;GASG;AACU,QAAA,iBAAiB,GAAsB,CAAC,GAAG,CAAsB,CAAC;AAmBjD,mBAnBjB,yBAAiB,CAmBQ"}

package/cjs/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/cjs/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/cjs/constants/positive_zero.js

@@ -5,6 +5,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
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/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;AACU,QAAA,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;AACU,QAAA,aAAa,GAAkB,CAAkB,CAAC"}