@nberlette/math 0.7.1 → 0.7.3

package/esm/constants/max_safe_integer.d.ts

@@ -21,5 +21,19 @@
  * @category Constants
  */
 export declare const MAX_SAFE_INTEGER: MAX_SAFE_INTEGER;
+/**
+ * Type-level alias of the `MAX_SAFE_INTEGER` constant exported by this module. This allows
+ * `MAX_SAFE_INTEGER` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { MAX_SAFE_INTEGER } from "@nick/math/constants/max-safe-integer";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<MAX_SAFE_INTEGER>(9007199254740991);
+ * ```
+ * @category Constants
+ */
 export type MAX_SAFE_INTEGER = 9007199254740991;
 //# sourceMappingURL=max_safe_integer.d.ts.map

package/esm/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;;;;;;;;;;;;;GAaG;AAEH;;;;;;;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;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,CAAC"}

package/esm/constants/max_value.d.ts

@@ -20,5 +20,19 @@
  * @category Constants
  */
 export declare const MAX_VALUE: MAX_VALUE;
+/**
+ * Type-level alias of the `MAX_VALUE` constant exported by this module. This allows
+ * `MAX_VALUE` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { MAX_VALUE } from "@nick/math/constants/max-value";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<MAX_VALUE>(1.7976931348623157e308);
+ * ```
+ * @category Constants
+ */
 export type MAX_VALUE = 1.7976931348623157e308;
 //# sourceMappingURL=max_value.d.ts.map

package/esm/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;;;;;;;;;;;;;GAaG;AAEH;;;;;;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;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,SAAS,GAAG,sBAAsB,CAAC"}

package/esm/constants/min_safe_integer.d.ts

@@ -22,5 +22,19 @@
  * @category Constants
  */
 export declare const MIN_SAFE_INTEGER: MIN_SAFE_INTEGER;
+/**
+ * Type-level alias of the `MIN_SAFE_INTEGER` constant exported by this module. This allows
+ * `MIN_SAFE_INTEGER` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { MIN_SAFE_INTEGER } from "@nick/math/constants/min-safe-integer";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<MIN_SAFE_INTEGER>(-9007199254740991);
+ * ```
+ * @category Constants
+ */
 export type MIN_SAFE_INTEGER = -9007199254740991;
 //# sourceMappingURL=min_safe_integer.d.ts.map

package/esm/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;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;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;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,gBAAgB,CAAC"}

package/esm/constants/min_value.d.ts

@@ -20,5 +20,19 @@
  * @category Constants
  */
 export declare const MIN_VALUE: MIN_VALUE;
+/**
+ * Type-level alias of the `MIN_VALUE` constant exported by this module. This allows
+ * `MIN_VALUE` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { MIN_VALUE } from "@nick/math/constants/min-value";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<MIN_VALUE>(5e-324);
+ * ```
+ * @category Constants
+ */
 export type MIN_VALUE = 5e-324;
 //# sourceMappingURL=min_value.d.ts.map

package/esm/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;;;;;;;;;;;;;GAaG;AAEH;;;;;;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;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC"}

package/esm/constants/pi.d.ts

@@ -20,5 +20,19 @@
  * @category Constants
  */
 export declare const PI: PI;
+/**
+ * Type-level alias of the `PI` constant exported by this module. This allows
+ * `PI` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { PI } from "@nick/math/constants/pi";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<PI>(3.141592653589793);
+ * ```
+ * @category Constants
+ */
 export type PI = 3.141592653589793;
 //# sourceMappingURL=pi.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,EAAE,GAAG,iBAAiB,CAAC"}

package/esm/constants/sqrt1_2.d.ts

@@ -19,5 +19,19 @@
  * @category Constants
  */
 export declare const SQRT1_2: SQRT1_2;
+/**
+ * Type-level alias of the `SQRT1_2` constant exported by this module. This allows
+ * `SQRT1_2` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { SQRT1_2 } from "@nick/math/constants/sqrt1_2";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<SQRT1_2>(0.7071067811865476);
+ * ```
+ * @category Constants
+ */
 export type SQRT1_2 = 0.7071067811865476;
 //# sourceMappingURL=sqrt1_2.d.ts.map

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;;;;;;;;;;;;;GAaG;AAEH;;;;;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;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,OAAO,GAAG,kBAAkB,CAAC"}

package/esm/constants/sqrt2.d.ts

@@ -19,5 +19,19 @@
  * @category Constants
  */
 export declare const SQRT2: SQRT2;
+/**
+ * Type-level alias of the `SQRT2` constant exported by this module. This allows
+ * `SQRT2` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { SQRT2 } from "@nick/math/constants/sqrt2";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<SQRT2>(1.4142135623730951);
+ * ```
+ * @category Constants
+ */
 export type SQRT2 = 1.4142135623730951;
 //# sourceMappingURL=sqrt2.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,KAAK,GAAG,kBAAkB,CAAC"}

package/esm/float16/guards.d.ts

@@ -18,5 +18,6 @@ import type { Float16 } from "../types/float.js";
  * @tags float16
  */
 export declare function isFloat16<N extends number>(it: N): it is Float16<N>;
+/** @inheritDoc */
 export declare function isFloat16(it: unknown): it is Float16<number>;
 //# sourceMappingURL=guards.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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,kBAAkB;AAClB,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/esm/float16/guards.js

@@ -14,6 +14,7 @@
  */
 import { isNaN } from "../guards/nan.js";
 import { roundFloat16 } from "./round.js";
+/** @inheritDoc */
 export function isFloat16(it) {
     return typeof it === "number" && !isNaN(it) && it === roundFloat16(it);
 }

package/esm/float16/guards.js.map

@@ -1 +1 @@
-{"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"}
+{"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;AAuB1C,kBAAkB;AAClB,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/float32/guards.d.ts

@@ -19,6 +19,7 @@ import type { Float32 } from "../types/float.js";
  * @tags float32
  */
 export declare function isFloat32<N extends number>(it: N): it is Float32<N>;
+/** @inheritDoc */
 export declare function isFloat32(it: unknown): it is Float32<number>;
 /**
  * Checks if the given value is a finite float32 number, as per the IEEE
@@ -33,5 +34,6 @@ export declare function isFloat32(it: unknown): it is Float32<number>;
  * @tags float32
  */
 export declare function isFiniteFloat32<N extends number>(it: N): it is Finite<N> & Float32<N>;
+/** @inheritDoc */
 export declare function isFiniteFloat32(it: unknown): it is Float32<number>;
 //# sourceMappingURL=guards.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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,kBAAkB;AAClB,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;AAM9D;;;;;;;;;;;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,kBAAkB;AAClB,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/esm/float32/guards.js

@@ -16,9 +16,11 @@
 import { isNaN } from "../guards/nan.js";
 import { isFinite } from "../guards/finite.js";
 import { roundFloat32 } from "./round.js";
+/** @inheritDoc */
 export function isFloat32(it) {
     return typeof it === "number" && !isNaN(it) && it === roundFloat32(it);
 }
+/** @inheritDoc */
 export function isFiniteFloat32(it) {
     return isFloat32(it) && isFinite(it);
 }

package/esm/float32/guards.js.map

@@ -1 +1 @@
-{"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"}
+{"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;AAuB1C,kBAAkB;AAClB,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;AAmBD,kBAAkB;AAClB,MAAM,UAAU,eAAe,CAAC,EAAW;IACzC,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;AACvC,CAAC"}

package/esm/guards/integer.js

@@ -1,7 +1,7 @@
-/** @internal */
-// deno-lint-ignore no-explicit-any
+/** @inheritDoc */
 export function isInteger(number) {
-    return (number = +number) % 1 === 0;
+    const value = +number;
+    return value % 1 === 0;
 }
 /**
  * Checks if a given number is a whole number (integer), in a way that is

package/esm/guards/integer.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/guards/integer.ts"],"names":[],"mappings":"AA+CA,kBAAkB;AAClB,MAAM,UAAU,SAAS,CAAC,MAAe;IACvC,MAAM,KAAK,GAAG,CAAE,MAAiB,CAAC;IAClC,OAAO,KAAK,GAAG,CAAC,KAAK,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAS;IAET,OAAO,MAAM,GAAG,CAAC,KAAK,CAAC,CAAC;AAC1B,CAAC"}

package/esm/types/finite.d.ts

@@ -5,7 +5,7 @@
  * @example
  * ```ts
  * import type { Finite } from "@nick/math/types/finite";
- * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";;
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
  *
  * const value = 42 as Finite;
  * expectType<Finite>(value);

package/esm/types/finite.js

@@ -5,7 +5,7 @@
  * @example
  * ```ts
  * import type { Finite } from "@nick/math/types/finite";
- * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";;
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
  *
  * const value = 42 as Finite;
  * expectType<Finite>(value);

package/esm/types/float.d.ts

@@ -10,7 +10,7 @@
  * @example
  * ```ts
  * import type { Float32 } from "@nick/math/types/float";
- * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";;
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
  *
  * const value = 1 as Float32;
  * expectType<Float32>(value);

package/esm/types/integer.d.ts

@@ -5,7 +5,7 @@
  * @example
  * ```ts
  * import type { Int32 } from "@nick/math/types/integer";
- * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";;
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
  *
  * const value = 42 as Int32;
  * expectType<Int32>(value);

package/esm/types/precision.d.ts

@@ -5,7 +5,7 @@
  * @example
  * ```ts
  * import type { P32, Precision } from "@nick/math/types/precision";
- * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";;
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
  *
  * expectType<P32>(32);
  * expectType<Precision>(32);

package/esm/types/precision.js

@@ -5,7 +5,7 @@
  * @example
  * ```ts
  * import type { P32, Precision } from "@nick/math/types/precision";
- * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";;
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
  *
  * expectType<P32>(32);
  * expectType<Precision>(32);

package/esm/types/safe_integer.d.ts

@@ -6,7 +6,7 @@
  * ```ts
  * import { isSafeInteger } from "@nick/math/is/safe-integer";
  * import type { SafeInteger } from "@nick/math/types/safe-integer";
- * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";;
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
  *
  * let user_input: number = 42;
  * if (isSafeInteger(user_input)) {

package/esm/types/safe_integer.js

@@ -6,7 +6,7 @@
  * ```ts
  * import { isSafeInteger } from "@nick/math/is/safe-integer";
  * import type { SafeInteger } from "@nick/math/types/safe-integer";
- * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";;
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
  *
  * let user_input: number = 42;
  * if (isSafeInteger(user_input)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nberlette/math",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Standalone implementation of the entire native Math interface, along with other useful type guards, constants, and utilities. Zero dependencies.",
   "keywords": [
     "math",

package/src/constants/e.ts

@@ -22,4 +22,18 @@
  */
 export const E: E = 2.718281828459045;
 
+/**
+ * Type-level alias of the `E` constant exported by this module. This allows
+ * `E` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { E } from "@nick/math/constants/e";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<E>(2.718281828459045);
+ * ```
+ * @category Constants
+ */
 export type E = 2.718281828459045;

package/src/constants/epsilon.ts

@@ -29,4 +29,18 @@
  */
 export const EPSILON: EPSILON = 2.220446049250313e-16;
 
+/**
+ * Type-level alias of the `EPSILON` constant exported by this module. This allows
+ * `EPSILON` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { EPSILON } from "@nick/math/constants/epsilon";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<EPSILON>(2.220446049250313e-16);
+ * ```
+ * @category Constants
+ */
 export type EPSILON = 2.220446049250313e-16;

package/src/constants/ln2.ts

@@ -21,4 +21,18 @@
  * @category Constants
  */
 export const LN2: LN2 = 0.6931471805599453;
+/**
+ * Type-level alias of the `LN2` constant exported by this module. This allows
+ * `LN2` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { LN2 } from "@nick/math/constants/ln2";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<LN2>(0.6931471805599453);
+ * ```
+ * @category Constants
+ */
 export type LN2 = 0.6931471805599453;

package/src/constants/log10e.ts

@@ -21,4 +21,18 @@
  * @category Constants
  */
 export const LOG10E: LOG10E = 0.4342944819032518;
+/**
+ * Type-level alias of the `LOG10E` constant exported by this module. This allows
+ * `LOG10E` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { LOG10E } from "@nick/math/constants/log10e";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<LOG10E>(0.4342944819032518);
+ * ```
+ * @category Constants
+ */
 export type LOG10E = 0.4342944819032518;

package/src/constants/log2e.ts

@@ -21,4 +21,18 @@
  * @category Constants
  */
 export const LOG2E: LOG2E = 1.4426950408889634;
+/**
+ * Type-level alias of the `LOG2E` constant exported by this module. This allows
+ * `LOG2E` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { LOG2E } from "@nick/math/constants/log2e";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<LOG2E>(1.4426950408889634);
+ * ```
+ * @category Constants
+ */
 export type LOG2E = 1.4426950408889634;

package/src/constants/max_safe_integer.ts

@@ -22,4 +22,18 @@
  * @category Constants
  */
 export const MAX_SAFE_INTEGER: MAX_SAFE_INTEGER = 9007199254740991;
+/**
+ * Type-level alias of the `MAX_SAFE_INTEGER` constant exported by this module. This allows
+ * `MAX_SAFE_INTEGER` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { MAX_SAFE_INTEGER } from "@nick/math/constants/max-safe-integer";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<MAX_SAFE_INTEGER>(9007199254740991);
+ * ```
+ * @category Constants
+ */
 export type MAX_SAFE_INTEGER = 9007199254740991;

package/src/constants/max_value.ts

@@ -21,4 +21,18 @@
  * @category Constants
  */
 export const MAX_VALUE: MAX_VALUE = 1.7976931348623157e308;
+/**
+ * Type-level alias of the `MAX_VALUE` constant exported by this module. This allows
+ * `MAX_VALUE` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { MAX_VALUE } from "@nick/math/constants/max-value";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<MAX_VALUE>(1.7976931348623157e308);
+ * ```
+ * @category Constants
+ */
 export type MAX_VALUE = 1.7976931348623157e308;

package/src/constants/min_safe_integer.ts

@@ -23,4 +23,18 @@
  * @category Constants
  */
 export const MIN_SAFE_INTEGER: MIN_SAFE_INTEGER = -9007199254740991;
+/**
+ * Type-level alias of the `MIN_SAFE_INTEGER` constant exported by this module. This allows
+ * `MIN_SAFE_INTEGER` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { MIN_SAFE_INTEGER } from "@nick/math/constants/min-safe-integer";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<MIN_SAFE_INTEGER>(-9007199254740991);
+ * ```
+ * @category Constants
+ */
 export type MIN_SAFE_INTEGER = -9007199254740991;

package/src/constants/min_value.ts

@@ -21,4 +21,18 @@
  * @category Constants
  */
 export const MIN_VALUE: MIN_VALUE = 5e-324;
+/**
+ * Type-level alias of the `MIN_VALUE` constant exported by this module. This allows
+ * `MIN_VALUE` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { MIN_VALUE } from "@nick/math/constants/min-value";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<MIN_VALUE>(5e-324);
+ * ```
+ * @category Constants
+ */
 export type MIN_VALUE = 5e-324;

package/src/constants/pi.ts

@@ -21,4 +21,18 @@
  * @category Constants
  */
 export const PI: PI = 3.141592653589793;
+/**
+ * Type-level alias of the `PI` constant exported by this module. This allows
+ * `PI` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { PI } from "@nick/math/constants/pi";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<PI>(3.141592653589793);
+ * ```
+ * @category Constants
+ */
 export type PI = 3.141592653589793;

package/src/constants/sqrt1_2.ts

@@ -20,4 +20,18 @@
  * @category Constants
  */
 export const SQRT1_2: SQRT1_2 = 0.7071067811865476;
+/**
+ * Type-level alias of the `SQRT1_2` constant exported by this module. This allows
+ * `SQRT1_2` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { SQRT1_2 } from "@nick/math/constants/sqrt1_2";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<SQRT1_2>(0.7071067811865476);
+ * ```
+ * @category Constants
+ */
 export type SQRT1_2 = 0.7071067811865476;

package/src/constants/sqrt2.ts

@@ -20,4 +20,18 @@
  * @category Constants
  */
 export const SQRT2: SQRT2 = 1.4142135623730951;
+/**
+ * Type-level alias of the `SQRT2` constant exported by this module. This allows
+ * `SQRT2` to be imported using a standard named import (i.e. the _value_ level)
+ * or via type-only import for a compile-time only reference to the same value.
+ *
+ * @example
+ * ```ts
+ * import type { SQRT2 } from "@nick/math/constants/sqrt2";
+ * import { expectType } from "jsr:@nick/is@0.2.0-rc.6/type/expect";
+ *
+ * expectType<SQRT2>(1.4142135623730951);
+ * ```
+ * @category Constants
+ */
 export type SQRT2 = 1.4142135623730951;

package/src/float16/guards.ts

@@ -35,7 +35,9 @@ import { roundFloat16 } from "./round.js";
  * @tags float16
  */
 export function isFloat16<N extends number>(it: N): it is Float16<N>;
+/** @inheritDoc */
 export function isFloat16(it: unknown): it is Float16<number>;
+/** @inheritDoc */
 export function isFloat16(it: unknown): it is Float16 {
   return typeof it === "number" && !isNaN(it) && it === roundFloat16(it);
 }

package/src/float32/guards.ts

@@ -37,7 +37,9 @@ import { roundFloat32 } from "./round.js";
  * @tags float32
  */
 export function isFloat32<N extends number>(it: N): it is Float32<N>;
+/** @inheritDoc */
 export function isFloat32(it: unknown): it is Float32<number>;
+/** @inheritDoc */
 export function isFloat32(it: unknown): it is Float32 {
   return typeof it === "number" && !isNaN(it) && it === roundFloat32(it);
 }
@@ -57,7 +59,9 @@ export function isFloat32(it: unknown): it is Float32 {
 export function isFiniteFloat32<N extends number>(
   it: N,
 ): it is Finite<N> & Float32<N>;
+/** @inheritDoc */
 export function isFiniteFloat32(it: unknown): it is Float32<number>;
+/** @inheritDoc */
 export function isFiniteFloat32(it: unknown): it is Float32 {
   return isFloat32(it) && isFinite(it);
 }