effect 4.0.0-beta.66 → 4.0.0-beta.68

package/dist/BigInt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BigInt.d.ts","sourceRoot":"","sources":["../src/BigInt.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"BigInt.d.ts","sourceRoot":"","sources":["../src/BigInt.ts"],"names":[],"mappings":"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"}

package/dist/BigInt.js

@@ -14,9 +14,10 @@ import * as Reducer from "./Reducer.js";
 /**
  * Reference to the global BigInt constructor.
  *
- * @example
+ * **Example** (Constructing bigints)
+ *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  *
  * const bigInt = BigInt.BigInt(123)
  * console.log(bigInt) // 123n
@@ -35,13 +36,14 @@ const bigint2 = /*#__PURE__*/BigInt(2);
 /**
  * Tests if a value is a `bigint`.
  *
- * @example
+ * **Example** (Checking for bigints)
+ *
  * ```ts
- * import { isBigInt } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isBigInt(1n), true)
- * assert.deepStrictEqual(isBigInt(1), false)
+ * assert.deepStrictEqual(BigInt.isBigInt(1n), true)
+ * assert.deepStrictEqual(BigInt.isBigInt(1), false)
  * ```
  *
  * @category guards
@@ -51,12 +53,13 @@ export const isBigInt = predicate.isBigInt;
 /**
  * Provides an addition operation on `bigint`s.
  *
- * @example
+ * **Example** (Adding bigints)
+ *
  * ```ts
- * import { sum } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sum(2n, 3n), 5n)
+ * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
  * ```
  *
  * @category math
@@ -66,12 +69,13 @@ export const sum = /*#__PURE__*/dual(2, (self, that) => self + that);
 /**
  * Provides a multiplication operation on `bigint`s.
  *
- * @example
+ * **Example** (Multiplying bigints)
+ *
  * ```ts
- * import { multiply } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+ * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
  * ```
  *
  * @category math
@@ -81,12 +85,13 @@ export const multiply = /*#__PURE__*/dual(2, (self, that) => self * that);
 /**
  * Provides a subtraction operation on `bigint`s.
  *
- * @example
+ * **Example** (Subtracting bigints)
+ *
  * ```ts
- * import { subtract } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+ * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
  * ```
  *
  * @category math
@@ -94,22 +99,19 @@ export const multiply = /*#__PURE__*/dual(2, (self, that) => self * that);
  */
 export const subtract = /*#__PURE__*/dual(2, (self, that) => self - that);
 /**
- * Provides a division operation on `bigint`s.
+ * Safely divides one `bigint` by another.
  *
- * If the dividend is not a multiple of the divisor the result will be a `bigint` value
- * which represents the integer division rounded down to the nearest integer.
+ * Uses JavaScript `bigint` division, so non-exact quotients are truncated
+ * toward zero. Returns `Option.none()` when the divisor is `0n`.
  *
- * Returns `Option.none()` if the divisor is `0n`.
+ * **Example** (Dividing bigints safely)
  *
- * @example
  * ```ts
- * import { divide } from "effect/BigInt"
+ * import { BigInt, Option } from "effect"
  * import * as assert from "node:assert"
  *
- * import { Option } from "effect"
- *
- * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
- * assert.deepStrictEqual(divide(6n, 0n), Option.none())
+ * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
  * ```
  *
  * @category math
@@ -117,35 +119,35 @@ export const subtract = /*#__PURE__*/dual(2, (self, that) => self - that);
  */
 export const divide = /*#__PURE__*/dual(2, (self, that) => that === bigint0 ? Option.none() : Option.some(self / that));
 /**
- * Provides a division operation on `bigint`s.
+ * Divides one `bigint` by another, throwing if the divisor is zero.
  *
- * If the dividend is not a multiple of the divisor the result will be a `bigint` value
- * which represents the integer division rounded down to the nearest integer.
+ * Uses JavaScript `bigint` division, so non-exact quotients are truncated
+ * toward zero. Throws a `RangeError` when the divisor is `0n`.
  *
- * Throws a `RangeError` if the divisor is `0n`.
+ * **Example** (Dividing bigints unsafely)
  *
- * @example
  * ```ts
- * import { divideUnsafe } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(divideUnsafe(6n, 3n), 2n)
- * assert.deepStrictEqual(divideUnsafe(6n, 4n), 1n)
+ * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
+ * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const divideUnsafe = /*#__PURE__*/dual(2, (self, that) => self / that);
 /**
- * Returns the result of adding `1n` to a given number.
+ * Returns the result of adding `1n` to a `bigint`.
+ *
+ * **Example** (Incrementing a bigint)
  *
- * @example
  * ```ts
- * import { increment } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(increment(2n), 3n)
+ * assert.deepStrictEqual(BigInt.increment(2n), 3n)
  * ```
  *
  * @category math
@@ -153,14 +155,15 @@ export const divideUnsafe = /*#__PURE__*/dual(2, (self, that) => self / that);
  */
 export const increment = n => n + bigint1;
 /**
- * Decrements a number by `1n`.
+ * Returns the result of subtracting `1n` from a `bigint`.
+ *
+ * **Example** (Decrementing a bigint)
  *
- * @example
  * ```ts
- * import { decrement } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(decrement(3n), 2n)
+ * assert.deepStrictEqual(BigInt.decrement(3n), 2n)
  * ```
  *
  * @category math
@@ -170,9 +173,10 @@ export const decrement = n => n - bigint1;
 /**
  * Provides an `Order` instance for `bigint` that allows comparing and sorting BigInt values.
  *
- * @example
+ * **Example** (Comparing bigints with Order)
+ *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  *
  * const a = 123n
  * const b = 456n
@@ -190,7 +194,8 @@ export const Order = order.BigInt;
 /**
  * An `Equivalence` instance for bigints using strict equality (`===`).
  *
- * @example
+ * **Example** (Comparing bigints for equivalence)
+ *
  * ```ts
  * import { BigInt } from "effect"
  *
@@ -199,83 +204,88 @@ export const Order = order.BigInt;
  * ```
  *
  * @category instances
- * @since 4.0.0
+ * @since 2.0.0
  */
 export const Equivalence = Equ.BigInt;
 /**
  * Returns `true` if the first argument is less than the second, otherwise `false`.
  *
- * @example
+ * **Example** (Checking less-than comparisons)
+ *
  * ```ts
- * import { isLessThan } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThan(2n, 3n), true)
- * assert.deepStrictEqual(isLessThan(3n, 3n), false)
- * assert.deepStrictEqual(isLessThan(4n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isLessThan = /*#__PURE__*/order.isLessThan(Order);
 /**
  * Returns a function that checks if a given `bigint` is less than or equal to the provided one.
  *
- * @example
+ * **Example** (Checking less-than-or-equal comparisons)
+ *
  * ```ts
- * import { isLessThanOrEqualTo } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThanOrEqualTo(2n, 3n), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(3n, 3n), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(4n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order);
 /**
  * Returns `true` if the first argument is greater than the second, otherwise `false`.
  *
- * @example
+ * **Example** (Checking greater-than comparisons)
+ *
  * ```ts
- * import { isGreaterThan } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThan(2n, 3n), false)
- * assert.deepStrictEqual(isGreaterThan(3n, 3n), false)
- * assert.deepStrictEqual(isGreaterThan(4n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);
 /**
  * Returns a function that checks if a given `bigint` is greater than or equal to the provided one.
  *
- * @example
+ * **Example** (Checking greater-than-or-equal comparisons)
+ *
  * ```ts
- * import { isGreaterThanOrEqualTo } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(2n, 3n), false)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(3n, 3n), true)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(4n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(Order);
 /**
  * Checks if a `bigint` is between a `minimum` and `maximum` value (inclusive).
  *
- * @example
+ * **Example** (Checking whether a bigint is within bounds)
+ *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
  * const between = BigInt.between({ minimum: 0n, maximum: 5n })
@@ -296,9 +306,10 @@ export const between = /*#__PURE__*/order.isBetween(Order);
  * - If the `bigint` is greater than the `maximum` value, the function returns the `maximum` value.
  * - Otherwise, it returns the original `bigint`.
  *
- * @example
+ * **Example** (Clamping a bigint to bounds)
+ *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
  * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
@@ -315,12 +326,13 @@ export const clamp = /*#__PURE__*/order.clamp(Order);
 /**
  * Returns the minimum between two `bigint`s.
  *
- * @example
+ * **Example** (Finding the minimum bigint)
+ *
  * ```ts
- * import { min } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(min(2n, 3n), 2n)
+ * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
  * ```
  *
  * @category math
@@ -330,12 +342,13 @@ export const min = /*#__PURE__*/order.min(Order);
 /**
  * Returns the maximum between two `bigint`s.
  *
- * @example
+ * **Example** (Finding the maximum bigint)
+ *
  * ```ts
- * import { max } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(max(2n, 3n), 3n)
+ * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
  * ```
  *
  * @category math
@@ -345,14 +358,15 @@ export const max = /*#__PURE__*/order.max(Order);
 /**
  * Determines the sign of a given `bigint`.
  *
- * @example
+ * **Example** (Determining bigint signs)
+ *
  * ```ts
- * import { sign } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sign(-5n), -1)
- * assert.deepStrictEqual(sign(0n), 0)
- * assert.deepStrictEqual(sign(5n), 1)
+ * assert.deepStrictEqual(BigInt.sign(-5n), -1)
+ * assert.deepStrictEqual(BigInt.sign(0n), 0)
+ * assert.deepStrictEqual(BigInt.sign(5n), 1)
  * ```
  *
  * @category math
@@ -362,14 +376,15 @@ export const sign = n => order.BigInt(n, bigint0);
 /**
  * Determines the absolute value of a given `bigint`.
  *
- * @example
+ * **Example** (Calculating absolute values)
+ *
  * ```ts
- * import { abs } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(abs(-5n), 5n)
- * assert.deepStrictEqual(abs(0n), 0n)
- * assert.deepStrictEqual(abs(5n), 5n)
+ * assert.deepStrictEqual(BigInt.abs(-5n), 5n)
+ * assert.deepStrictEqual(BigInt.abs(0n), 0n)
+ * assert.deepStrictEqual(BigInt.abs(5n), 5n)
  * ```
  *
  * @category math
@@ -379,14 +394,15 @@ export const abs = n => n < bigint0 ? -n : n;
 /**
  * Determines the greatest common divisor of two `bigint`s.
  *
- * @example
+ * **Example** (Calculating greatest common divisors)
+ *
  * ```ts
- * import { gcd } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(gcd(2n, 3n), 1n)
- * assert.deepStrictEqual(gcd(2n, 4n), 2n)
- * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+ * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
+ * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
+ * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
  * ```
  *
  * @category math
@@ -403,14 +419,15 @@ export const gcd = /*#__PURE__*/dual(2, (self, that) => {
 /**
  * Determines the least common multiple of two `bigint`s.
  *
- * @example
+ * **Example** (Calculating least common multiples)
+ *
  * ```ts
- * import { lcm } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(lcm(2n, 3n), 6n)
- * assert.deepStrictEqual(lcm(2n, 4n), 4n)
- * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+ * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
+ * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
+ * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
  * ```
  *
  * @category math
@@ -418,20 +435,24 @@ export const gcd = /*#__PURE__*/dual(2, (self, that) => {
  */
 export const lcm = /*#__PURE__*/dual(2, (self, that) => self * that / gcd(self, that));
 /**
- * Determines the square root of a given `bigint` unsafely. Throws if the given `bigint` is negative.
+ * Returns the integer square root of a non-negative `bigint`.
+ *
+ * For non-perfect squares, returns the largest `bigint` whose square is less
+ * than or equal to the input. Throws a `RangeError` if the input is negative.
+ *
+ * **Example** (Calculating square roots unsafely)
  *
- * @example
  * ```ts
- * import { sqrtUnsafe } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sqrtUnsafe(4n), 2n)
- * assert.deepStrictEqual(sqrtUnsafe(9n), 3n)
- * assert.deepStrictEqual(sqrtUnsafe(16n), 4n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(4n), 2n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(9n), 3n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(16n), 4n)
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const sqrtUnsafe = n => {
   if (n < bigint0) {
@@ -447,10 +468,13 @@ export const sqrtUnsafe = n => {
   return x;
 };
 /**
- * Determines the square root of a given `bigint` safely. Returns `Option.none()` if
- * the given `bigint` is negative.
+ * Safely returns the integer square root of a `bigint`.
  *
- * **Example**
+ * For non-perfect squares, returns the largest `bigint` whose square is less
+ * than or equal to the input. Returns `Option.none()` when the input is
+ * negative.
+ *
+ * **Example** (Calculating square roots safely)
  *
  * ```ts
  * import { BigInt } from "effect"
@@ -466,14 +490,17 @@ export const sqrtUnsafe = n => {
  */
 export const sqrt = n => isGreaterThanOrEqualTo(n, bigint0) ? Option.some(sqrtUnsafe(n)) : Option.none();
 /**
- * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint
+ * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint`.
+ *
+ * Returns `0n` for an empty iterable.
+ *
+ * **Example** (Summing iterable bigints)
  *
- * @example
  * ```ts
- * import { sumAll } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sumAll([2n, 3n, 4n]), 9n)
+ * assert.deepStrictEqual(BigInt.sumAll([2n, 3n, 4n]), 9n)
  * ```
  *
  * @category math
@@ -487,14 +514,18 @@ export const sumAll = collection => {
   return out;
 };
 /**
- * Takes an `Iterable` of `bigint`s and returns their multiplication as a single `number`.
+ * Takes an `Iterable` of `bigint`s and returns their product as a single
+ * `bigint`.
+ *
+ * Returns `1n` for an empty iterable.
+ *
+ * **Example** (Multiplying iterable bigints)
  *
- * @example
  * ```ts
- * import { multiplyAll } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiplyAll([2n, 3n, 4n]), 24n)
+ * assert.deepStrictEqual(BigInt.multiplyAll([2n, 3n, 4n]), 24n)
  * ```
  *
  * @category math
@@ -516,7 +547,8 @@ export const multiplyAll = collection => {
  * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
  * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`.
  *
- * @example
+ * **Example** (Converting bigints to numbers)
+ *
  * ```ts
  * import { BigInt as BI } from "effect"
  *
@@ -525,7 +557,7 @@ export const multiplyAll = collection => {
  * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.0.0
  */
 export const toNumber = b => {
@@ -540,7 +572,8 @@ export const toNumber = b => {
  * If the string is empty or contains characters that cannot be converted into a
  * `bigint`, it returns `Option.none()`.
  *
- * @example
+ * **Example** (Parsing strings as bigints)
+ *
  * ```ts
  * import { BigInt } from "effect"
  *
@@ -549,7 +582,7 @@ export const toNumber = b => {
  * BigInt.fromString("a") // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.4.12
  */
 export const fromString = s => {
@@ -566,7 +599,8 @@ export const fromString = s => {
  * (`Number.MAX_SAFE_INTEGER` and `Number.MIN_SAFE_INTEGER`) or if the number is
  * not a valid `bigint`, it returns `Option.none()`.
  *
- * @example
+ * **Example** (Converting numbers to bigints)
+ *
  * ```ts
  * import { BigInt } from "effect"
  *
@@ -576,7 +610,7 @@ export const fromString = s => {
  * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.4.12
  */
 export function fromNumber(n) {
@@ -590,9 +624,13 @@ export function fromNumber(n) {
   }
 }
 /**
- * Returns the remainder of dividing the first `bigint` by the second `bigint`.
+ * Returns the JavaScript remainder of dividing one `bigint` by another.
+ *
+ * The result follows JavaScript `%` semantics, including the sign of the
+ * dividend. Throws a `RangeError` when the divisor is `0n`.
+ *
+ * **Example** (Calculating remainders)
  *
- * @example
  * ```ts
  * import { BigInt } from "effect"
  *
@@ -608,12 +646,14 @@ export const remainder = /*#__PURE__*/dual(2, (self, divisor) => self % divisor)
 /**
  * A `Reducer` for combining `bigint`s using addition.
  *
+ * @category math
  * @since 4.0.0
  */
 export const ReducerSum = /*#__PURE__*/Reducer.make((a, b) => a + b, bigint0);
 /**
  * A `Reducer` for combining `bigint`s using multiplication.
  *
+ * @category math
  * @since 4.0.0
  */
 export const ReducerMultiply = /*#__PURE__*/Reducer.make((a, b) => a * b, bigint1, collection => {
@@ -627,12 +667,14 @@ export const ReducerMultiply = /*#__PURE__*/Reducer.make((a, b) => a * b, bigint
 /**
  * A `Combiner` that returns the maximum `bigint`.
  *
+ * @category math
  * @since 4.0.0
  */
 export const CombinerMax = /*#__PURE__*/Combiner.max(Order);
 /**
  * A `Combiner` that returns the minimum `bigint`.
  *
+ * @category math
  * @since 4.0.0
  */
 export const CombinerMin = /*#__PURE__*/Combiner.min(Order);