effect 4.0.0-beta.67 → 4.0.0-beta.69

package/dist/BigDecimal.js

@@ -123,16 +123,16 @@ const one = /*#__PURE__*/makeNormalizedUnsafe(bigint1, 0);
  * **Example** (Normalizing trailing zeros)
  *
  * ```ts
- * import { fromStringUnsafe, make, normalize } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   normalize(fromStringUnsafe("123.00000")),
- *   normalize(make(123n, 0))
+ *   BigDecimal.normalize(BigDecimal.fromStringUnsafe("123.00000")),
+ *   BigDecimal.normalize(BigDecimal.make(123n, 0))
  * )
  * assert.deepStrictEqual(
- *   normalize(fromStringUnsafe("12300000")),
- *   normalize(make(123n, -5))
+ *   BigDecimal.normalize(BigDecimal.fromStringUnsafe("12300000")),
+ *   BigDecimal.normalize(BigDecimal.make(123n, -5))
  * )
  * ```
  *
@@ -204,12 +204,12 @@ export const scale = /*#__PURE__*/dual(2, (self, scale) => {
  * **Example** (Adding decimals)
  *
  * ```ts
- * import { fromStringUnsafe, sum } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   sum(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("5")
+ *   BigDecimal.sum(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("5")
  * )
  * ```
  *
@@ -237,17 +237,17 @@ export const sum = /*#__PURE__*/dual(2, (self, that) => {
  * **Example** (Adding multiple decimals)
  *
  * ```ts
- * import { fromStringUnsafe, sumAll } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   sumAll([fromStringUnsafe("2"), fromStringUnsafe("3"), fromStringUnsafe("4")]),
- *   fromStringUnsafe("9")
+ *   BigDecimal.sumAll([BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("4")]),
+ *   BigDecimal.fromStringUnsafe("9")
  * )
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const sumAll = collection => {
   let out = zero;
@@ -262,12 +262,12 @@ export const sumAll = collection => {
  * **Example** (Multiplying decimals)
  *
  * ```ts
- * import { fromStringUnsafe, multiply } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   multiply(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("6")
+ *   BigDecimal.multiply(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("6")
  * )
  * ```
  *
@@ -286,12 +286,12 @@ export const multiply = /*#__PURE__*/dual(2, (self, that) => {
  * **Example** (Multiplying multiple decimals)
  *
  * ```ts
- * import { fromStringUnsafe, multiplyAll } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   multiplyAll([fromStringUnsafe("2"), fromStringUnsafe("3"), fromStringUnsafe("4")]),
- *   fromStringUnsafe("24")
+ *   BigDecimal.multiplyAll([BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("4")]),
+ *   BigDecimal.fromStringUnsafe("24")
  * )
  * ```
  *
@@ -314,12 +314,12 @@ export const multiplyAll = collection => {
  * **Example** (Subtracting decimals)
  *
  * ```ts
- * import { fromStringUnsafe, subtract } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   subtract(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("-1")
+ *   BigDecimal.subtract(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("-1")
  * )
  * ```
  *
@@ -459,14 +459,14 @@ export const divide = /*#__PURE__*/dual(2, (self, that) => {
  * **Example** (Dividing decimals unsafely)
  *
  * ```ts
- * import { divideUnsafe, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  *
- * console.log(divideUnsafe(fromStringUnsafe("6"), fromStringUnsafe("3"))) // BigDecimal(2)
- * console.log(divideUnsafe(fromStringUnsafe("6"), fromStringUnsafe("4"))) // BigDecimal(1.5)
+ * console.log(BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("3"))) // BigDecimal(2)
+ * console.log(BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("4"))) // BigDecimal(1.5)
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const divideUnsafe = /*#__PURE__*/dual(2, (self, that) => {
   if (that.value === bigint0) {
@@ -520,25 +520,25 @@ export const Order = /*#__PURE__*/order.make((self, that) => {
  * **Example** (Checking less-than comparisons)
  *
  * ```ts
- * import { fromStringUnsafe, isLessThan } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   isLessThan(fromStringUnsafe("2"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * assert.deepStrictEqual(
- *   isLessThan(fromStringUnsafe("3"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * assert.deepStrictEqual(
- *   isLessThan(fromStringUnsafe("4"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isLessThan = /*#__PURE__*/order.isLessThan(Order);
 /**
@@ -547,25 +547,25 @@ export const isLessThan = /*#__PURE__*/order.isLessThan(Order);
  * **Example** (Checking less-than-or-equal comparisons)
  *
  * ```ts
- * import { fromStringUnsafe, isLessThanOrEqualTo } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   isLessThanOrEqualTo(fromStringUnsafe("2"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * assert.deepStrictEqual(
- *   isLessThanOrEqualTo(fromStringUnsafe("3"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * assert.deepStrictEqual(
- *   isLessThanOrEqualTo(fromStringUnsafe("4"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order);
 /**
@@ -574,25 +574,25 @@ export const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order)
  * **Example** (Checking greater-than comparisons)
  *
  * ```ts
- * import { fromStringUnsafe, isGreaterThan } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   isGreaterThan(fromStringUnsafe("2"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * assert.deepStrictEqual(
- *   isGreaterThan(fromStringUnsafe("3"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * assert.deepStrictEqual(
- *   isGreaterThan(fromStringUnsafe("4"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);
 /**
@@ -601,25 +601,25 @@ export const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);
  * **Example** (Checking greater-than-or-equal comparisons)
  *
  * ```ts
- * import { fromStringUnsafe, isGreaterThanOrEqualTo } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   isGreaterThanOrEqualTo(fromStringUnsafe("2"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * assert.deepStrictEqual(
- *   isGreaterThanOrEqualTo(fromStringUnsafe("3"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * assert.deepStrictEqual(
- *   isGreaterThanOrEqualTo(fromStringUnsafe("4"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(Order);
 /**
@@ -687,12 +687,12 @@ export const clamp = /*#__PURE__*/order.clamp(Order);
  * **Example** (Selecting the smaller decimal)
  *
  * ```ts
- * import { fromStringUnsafe, min } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   min(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("2")
+ *   BigDecimal.min(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("2")
  * )
  * ```
  *
@@ -706,12 +706,12 @@ export const min = /*#__PURE__*/order.min(Order);
  * **Example** (Selecting the larger decimal)
  *
  * ```ts
- * import { fromStringUnsafe, max } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   max(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("3")
+ *   BigDecimal.max(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("3")
  * )
  * ```
  *
@@ -725,12 +725,12 @@ export const max = /*#__PURE__*/order.max(Order);
  * **Example** (Reading decimal signs)
  *
  * ```ts
- * import { fromStringUnsafe, sign } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sign(fromStringUnsafe("-5")), -1)
- * assert.deepStrictEqual(sign(fromStringUnsafe("0")), 0)
- * assert.deepStrictEqual(sign(fromStringUnsafe("5")), 1)
+ * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("-5")), -1)
+ * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("0")), 0)
+ * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("5")), 1)
  * ```
  *
  * @category math
@@ -743,12 +743,12 @@ export const sign = n => n.value === bigint0 ? 0 : n.value < bigint0 ? -1 : 1;
  * **Example** (Calculating absolute values)
  *
  * ```ts
- * import { abs, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(abs(fromStringUnsafe("-5")), fromStringUnsafe("5"))
- * assert.deepStrictEqual(abs(fromStringUnsafe("0")), fromStringUnsafe("0"))
- * assert.deepStrictEqual(abs(fromStringUnsafe("5")), fromStringUnsafe("5"))
+ * assert.deepStrictEqual(BigDecimal.abs(BigDecimal.fromStringUnsafe("-5")), BigDecimal.fromStringUnsafe("5"))
+ * assert.deepStrictEqual(BigDecimal.abs(BigDecimal.fromStringUnsafe("0")), BigDecimal.fromStringUnsafe("0"))
+ * assert.deepStrictEqual(BigDecimal.abs(BigDecimal.fromStringUnsafe("5")), BigDecimal.fromStringUnsafe("5"))
  * ```
  *
  * @category math
@@ -761,11 +761,11 @@ export const abs = n => n.value < bigint0 ? make(-n.value, n.scale) : n;
  * **Example** (Negating decimals)
  *
  * ```ts
- * import { fromStringUnsafe, negate } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(negate(fromStringUnsafe("3")), fromStringUnsafe("-3"))
- * assert.deepStrictEqual(negate(fromStringUnsafe("-6")), fromStringUnsafe("6"))
+ * assert.deepStrictEqual(BigDecimal.negate(BigDecimal.fromStringUnsafe("3")), BigDecimal.fromStringUnsafe("-3"))
+ * assert.deepStrictEqual(BigDecimal.negate(BigDecimal.fromStringUnsafe("-6")), BigDecimal.fromStringUnsafe("6"))
  * ```
  *
  * @category math
@@ -824,25 +824,25 @@ export const remainder = /*#__PURE__*/dual(2, (self, divisor) => {
  * **Example** (Computing remainders unsafely)
  *
  * ```ts
- * import { fromStringUnsafe, remainderUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   remainderUnsafe(fromStringUnsafe("2"), fromStringUnsafe("2")),
- *   fromStringUnsafe("0")
+ *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("2")),
+ *   BigDecimal.fromStringUnsafe("0")
  * )
  * assert.deepStrictEqual(
- *   remainderUnsafe(fromStringUnsafe("3"), fromStringUnsafe("2")),
- *   fromStringUnsafe("1")
+ *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("2")),
+ *   BigDecimal.fromStringUnsafe("1")
  * )
  * assert.deepStrictEqual(
- *   remainderUnsafe(fromStringUnsafe("-4"), fromStringUnsafe("2")),
- *   fromStringUnsafe("0")
+ *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("-4"), BigDecimal.fromStringUnsafe("2")),
+ *   BigDecimal.fromStringUnsafe("0")
  * )
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const remainderUnsafe = /*#__PURE__*/dual(2, (self, divisor) => {
   if (divisor.value === bigint0) {
@@ -929,11 +929,11 @@ export const fromBigInt = n => make(n, 0);
  * **Example** (Creating decimals from finite numbers)
  *
  * ```ts
- * import { fromNumberUnsafe, make } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(fromNumberUnsafe(123), make(123n, 0))
- * assert.deepStrictEqual(fromNumberUnsafe(123.456), make(123456n, 3))
+ * assert.deepStrictEqual(BigDecimal.fromNumberUnsafe(123), BigDecimal.make(123n, 0))
+ * assert.deepStrictEqual(BigDecimal.fromNumberUnsafe(123.456), BigDecimal.make(123456n, 3))
  * ```
  *
  * @category constructors
@@ -965,7 +965,7 @@ export const fromNumberUnsafe = n => {
  * ```
  *
  * @category constructors
- * @since 4.0.0
+ * @since 2.0.0
  */
 export const fromNumber = n => {
   if (!Number.isFinite(n)) {
@@ -1051,16 +1051,16 @@ export const fromString = s => {
  * **Example** (Parsing decimal strings unsafely)
  *
  * ```ts
- * import { fromStringUnsafe, make } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(fromStringUnsafe("123"), make(123n, 0))
- * assert.deepStrictEqual(fromStringUnsafe("123.456"), make(123456n, 3))
- * assert.throws(() => fromStringUnsafe("123.abc"))
+ * assert.deepStrictEqual(BigDecimal.fromStringUnsafe("123"), BigDecimal.make(123n, 0))
+ * assert.deepStrictEqual(BigDecimal.fromStringUnsafe("123.456"), BigDecimal.make(123456n, 3))
+ * assert.throws(() => BigDecimal.fromStringUnsafe("123.abc"))
  * ```
  *
  * @category constructors
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const fromStringUnsafe = s => {
   return Option.getOrThrowWith(fromString(s), () => new Error(`Invalid numerical string: ${s}`));
@@ -1075,15 +1075,15 @@ export const fromStringUnsafe = s => {
  * **Example** (Formatting decimals)
  *
  * ```ts
- * import { format, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(format(fromStringUnsafe("-5")), "-5")
- * assert.deepStrictEqual(format(fromStringUnsafe("123.456")), "123.456")
- * assert.deepStrictEqual(format(fromStringUnsafe("-0.00000123")), "-0.00000123")
+ * assert.deepStrictEqual(BigDecimal.format(BigDecimal.fromStringUnsafe("-5")), "-5")
+ * assert.deepStrictEqual(BigDecimal.format(BigDecimal.fromStringUnsafe("123.456")), "123.456")
+ * assert.deepStrictEqual(BigDecimal.format(BigDecimal.fromStringUnsafe("-0.00000123")), "-0.00000123")
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.0.0
  */
 export const format = n => {
@@ -1118,14 +1118,14 @@ export const format = n => {
  * **Example** (Formatting decimals exponentially)
  *
  * ```ts
- * import { make, toExponential } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(toExponential(make(123456n, -5)), "1.23456e+10")
+ * assert.deepStrictEqual(BigDecimal.toExponential(BigDecimal.make(123456n, -5)), "1.23456e+10")
  * ```
  *
- * @category conversions
- * @since 4.0.0
+ * @category converting
+ * @since 3.11.0
  */
 export const toExponential = n => {
   if (isZero(n)) {
@@ -1152,14 +1152,14 @@ export const toExponential = n => {
  * **Example** (Converting decimals to numbers)
  *
  * ```ts
- * import { fromStringUnsafe, toNumberUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(toNumberUnsafe(fromStringUnsafe("123.456")), 123.456)
+ * assert.deepStrictEqual(BigDecimal.toNumberUnsafe(BigDecimal.fromStringUnsafe("123.456")), 123.456)
  * ```
  *
- * @category conversions
- * @since 2.0.0
+ * @category converting
+ * @since 4.0.0
  */
 export const toNumberUnsafe = n => Number(format(n));
 /**
@@ -1168,12 +1168,12 @@ export const toNumberUnsafe = n => Number(format(n));
  * **Example** (Checking integer decimals)
  *
  * ```ts
- * import { fromStringUnsafe, isInteger } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isInteger(fromStringUnsafe("0")), true)
- * assert.deepStrictEqual(isInteger(fromStringUnsafe("1")), true)
- * assert.deepStrictEqual(isInteger(fromStringUnsafe("1.1")), false)
+ * assert.deepStrictEqual(BigDecimal.isInteger(BigDecimal.fromStringUnsafe("0")), true)
+ * assert.deepStrictEqual(BigDecimal.isInteger(BigDecimal.fromStringUnsafe("1")), true)
+ * assert.deepStrictEqual(BigDecimal.isInteger(BigDecimal.fromStringUnsafe("1.1")), false)
  * ```
  *
  * @category predicates
@@ -1186,11 +1186,11 @@ export const isInteger = n => normalize(n).scale <= 0;
  * **Example** (Checking zero decimals)
  *
  * ```ts
- * import { fromStringUnsafe, isZero } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isZero(fromStringUnsafe("0")), true)
- * assert.deepStrictEqual(isZero(fromStringUnsafe("1")), false)
+ * assert.deepStrictEqual(BigDecimal.isZero(BigDecimal.fromStringUnsafe("0")), true)
+ * assert.deepStrictEqual(BigDecimal.isZero(BigDecimal.fromStringUnsafe("1")), false)
  * ```
  *
  * @category predicates
@@ -1203,12 +1203,12 @@ export const isZero = n => n.value === bigint0;
  * **Example** (Checking negative decimals)
  *
  * ```ts
- * import { fromStringUnsafe, isNegative } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isNegative(fromStringUnsafe("-1")), true)
- * assert.deepStrictEqual(isNegative(fromStringUnsafe("0")), false)
- * assert.deepStrictEqual(isNegative(fromStringUnsafe("1")), false)
+ * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("-1")), true)
+ * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("0")), false)
+ * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("1")), false)
  * ```
  *
  * @category predicates
@@ -1221,12 +1221,12 @@ export const isNegative = n => n.value < bigint0;
  * **Example** (Checking positive decimals)
  *
  * ```ts
- * import { fromStringUnsafe, isPositive } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isPositive(fromStringUnsafe("-1")), false)
- * assert.deepStrictEqual(isPositive(fromStringUnsafe("0")), false)
- * assert.deepStrictEqual(isPositive(fromStringUnsafe("1")), true)
+ * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("-1")), false)
+ * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("0")), false)
+ * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("1")), true)
  * ```
  *
  * @category predicates
@@ -1240,21 +1240,21 @@ const isBigDecimalArgs = args => isBigDecimal(args[0]);
  * **Example** (Rounding decimals)
  *
  * ```ts
- * import { fromStringUnsafe, round } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   round(fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
- *   fromStringUnsafe("150")
+ *   BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
+ *   BigDecimal.fromStringUnsafe("150")
  * )
  * assert.deepStrictEqual(
- *   round(fromStringUnsafe("-14.5")),
- *   fromStringUnsafe("-15")
+ *   BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5")),
+ *   BigDecimal.fromStringUnsafe("-15")
  * )
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const round = /*#__PURE__*/dual(isBigDecimalArgs, (self, options) => {
   const mode = options?.mode ?? "half-from-zero";
@@ -1294,14 +1294,14 @@ export const round = /*#__PURE__*/dual(isBigDecimalArgs, (self, options) => {
  * **Example** (Truncating decimals)
  *
  * ```ts
- * import { fromStringUnsafe, truncate } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  *
- * console.log(truncate(fromStringUnsafe("145"), -1)) // BigDecimal(140)
- * console.log(truncate(fromStringUnsafe("-14.5"))) // BigDecimal(-14)
+ * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1)) // BigDecimal(140)
+ * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5"))) // BigDecimal(-14)
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const truncate = /*#__PURE__*/dual(isBigDecimalArgs, (self, scale = 0) => {
   if (self.scale <= scale) {
@@ -1316,18 +1316,18 @@ export const truncate = /*#__PURE__*/dual(isBigDecimalArgs, (self, scale = 0) =>
  * **Example** (Rounding decimals up)
  *
  * ```ts
- * import { ceil, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   ceil(fromStringUnsafe("145"), -1),
- *   fromStringUnsafe("150")
+ *   BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1),
+ *   BigDecimal.fromStringUnsafe("150")
  * )
- * assert.deepStrictEqual(ceil(fromStringUnsafe("-14.5")), fromStringUnsafe("-14"))
+ * assert.deepStrictEqual(BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")), BigDecimal.fromStringUnsafe("-14"))
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const ceil = /*#__PURE__*/dual(isBigDecimalArgs, (self, scale = 0) => {
   const truncated = truncate(self, scale);
@@ -1356,21 +1356,21 @@ export const digitAt = /*#__PURE__*/dual(2, (self, scale) => {
  * **Example** (Rounding decimals down)
  *
  * ```ts
- * import { floor, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   floor(fromStringUnsafe("145"), -1),
- *   fromStringUnsafe("140")
+ *   BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1),
+ *   BigDecimal.fromStringUnsafe("140")
  * )
  * assert.deepStrictEqual(
- *   floor(fromStringUnsafe("-14.5")),
- *   fromStringUnsafe("-15")
+ *   BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")),
+ *   BigDecimal.fromStringUnsafe("-15")
  * )
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const floor = /*#__PURE__*/dual(isBigDecimalArgs, (self, scale = 0) => {
   const truncated = truncate(self, scale);