effect 4.0.0-beta.99 → 4.0.0-rc.109

package/dist/BigDecimal.js

@@ -54,13 +54,14 @@ const BigDecimalProto = {
  *
  * **Example** (Checking BigDecimal values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
  * const decimal = BigDecimal.fromNumber(123.45)
- * console.log(BigDecimal.isBigDecimal(decimal)) // true
- * console.log(BigDecimal.isBigDecimal(123.45)) // false
- * console.log(BigDecimal.isBigDecimal("123.45")) // false
+ * BigDecimal.isBigDecimal(decimal) // => false
+ * BigDecimal.isBigDecimal(BigDecimal.fromStringUnsafe("123.45")) // => true
+ * BigDecimal.isBigDecimal(123.45) // => false
+ * BigDecimal.isBigDecimal("123.45") // => false
  * ```
  *
  * @category guards
@@ -77,16 +78,16 @@ export const isBigDecimal = u => hasProperty(u, TypeId);
  *
  * **Example** (Creating decimals from bigint and scale)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
  * // Create 123.45 (12345 with scale 2)
  * const decimal = BigDecimal.make(12345n, 2)
- * console.log(BigDecimal.format(decimal)) // "123.45"
+ * decimal // => BigDecimal.fromStringUnsafe("123.45")
  *
  * // Create 42 (42 with scale 0)
  * const integer = BigDecimal.make(42n, 0)
- * console.log(BigDecimal.format(integer)) // "42"
+ * integer // => BigDecimal.fromBigInt(42n)
  * ```
  *
  * @see {@link fromBigInt} for constructing an integer decimal from a `bigint`
@@ -132,18 +133,14 @@ const one = /*#__PURE__*/makeNormalizedUnsafe(bigint1, 0);
  *
  * **Example** (Normalizing trailing zeros)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.normalize(BigDecimal.fromStringUnsafe("123.00000")),
- *   BigDecimal.normalize(BigDecimal.make(123n, 0))
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.normalize(BigDecimal.fromStringUnsafe("12300000")),
- *   BigDecimal.normalize(BigDecimal.make(123n, -5))
- * )
+ *
+ * const decimal = BigDecimal.normalize(BigDecimal.fromStringUnsafe("123.00000"))
+ * const decimalStorage = [decimal.value, decimal.scale] // => [123n, 0]
+ *
+ * const largeDecimal = BigDecimal.normalize(BigDecimal.fromStringUnsafe("12300000"))
+ * const largeDecimalStorage = [largeDecimal.value, largeDecimal.scale] // => [123n, -5]
  * ```
  *
  * @see {@link format} for rendering normalized decimals as strings
@@ -190,18 +187,18 @@ export const normalize = self => {
  *
  * **Example** (Scaling decimal precision)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
  * const decimal = BigDecimal.fromNumberUnsafe(123.45)
  *
  * // Increase scale (add more precision)
  * const scaled = BigDecimal.scale(decimal, 4)
- * console.log(BigDecimal.format(scaled)) // "123.4500"
+ * const scaledStorage = [scaled.value, scaled.scale] // => [1234500n, 4]
  *
- * // Decrease scale (reduce precision, rounds down)
+ * // Decrease scale (reduce precision, truncating toward zero)
  * const reduced = BigDecimal.scale(decimal, 1)
- * console.log(BigDecimal.format(reduced)) // "123.4"
+ * reduced // => BigDecimal.fromStringUnsafe("123.4")
  * ```
  *
  * @see {@link round} for changing scale with configurable rounding
@@ -228,14 +225,13 @@ export const scale = /*#__PURE__*/dual(2, (self, scale) => {
  *
  * **Example** (Adding decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   BigDecimal.sum(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
- *   BigDecimal.fromStringUnsafe("5")
- * )
+ * const result = BigDecimal.sum(
+ *   BigDecimal.fromStringUnsafe("2"),
+ *   BigDecimal.fromStringUnsafe("3")
+ * ) // => BigDecimal.fromBigInt(5n)
  * ```
  *
  * @see {@link sumAll} for summing an iterable of `BigDecimal` values
@@ -268,14 +264,14 @@ export const sum = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **Example** (Adding multiple decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   BigDecimal.sumAll([BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("4")]),
- *   BigDecimal.fromStringUnsafe("9")
- * )
+ * const result = BigDecimal.sumAll([
+ *   BigDecimal.fromStringUnsafe("2"),
+ *   BigDecimal.fromStringUnsafe("3"),
+ *   BigDecimal.fromStringUnsafe("4")
+ * ]) // => BigDecimal.fromBigInt(9n)
  * ```
  *
  * @see {@link sum} for adding two `BigDecimal` values
@@ -299,14 +295,13 @@ export const sumAll = collection => {
  *
  * **Example** (Multiplying decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   BigDecimal.multiply(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
- *   BigDecimal.fromStringUnsafe("6")
- * )
+ * const result = BigDecimal.multiply(
+ *   BigDecimal.fromStringUnsafe("2"),
+ *   BigDecimal.fromStringUnsafe("3")
+ * ) // => BigDecimal.fromBigInt(6n)
  * ```
  *
  * @see {@link multiplyAll} for multiplying an iterable of `BigDecimal` values
@@ -329,14 +324,14 @@ export const multiply = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **Example** (Multiplying multiple decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   BigDecimal.multiplyAll([BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("4")]),
- *   BigDecimal.fromStringUnsafe("24")
- * )
+ * const result = BigDecimal.multiplyAll([
+ *   BigDecimal.fromStringUnsafe("2"),
+ *   BigDecimal.fromStringUnsafe("3"),
+ *   BigDecimal.fromStringUnsafe("4")
+ * ]) // => BigDecimal.fromBigInt(24n)
  * ```
  *
  * @see {@link multiply} for multiplying two `BigDecimal` values
@@ -363,14 +358,13 @@ export const multiplyAll = collection => {
  *
  * **Example** (Subtracting decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   BigDecimal.subtract(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
- *   BigDecimal.fromStringUnsafe("-1")
- * )
+ * const result = BigDecimal.subtract(
+ *   BigDecimal.fromStringUnsafe("2"),
+ *   BigDecimal.fromStringUnsafe("3")
+ * ) // => BigDecimal.fromBigInt(-1n)
  * ```
  *
  * @category math
@@ -459,33 +453,14 @@ export const roundTerminal = n => {
  *
  * **Example** (Dividing decimals safely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal, Option } from "effect"
  *
- * console.log(
- *   Option.getOrThrow(
- *     BigDecimal.divide(
- *       BigDecimal.fromStringUnsafe("6"),
- *       BigDecimal.fromStringUnsafe("3")
- *     )
- *   )
- * ) // BigDecimal(2)
- * console.log(
- *   Option.getOrThrow(
- *     BigDecimal.divide(
- *       BigDecimal.fromStringUnsafe("6"),
- *       BigDecimal.fromStringUnsafe("4")
- *     )
- *   )
- * ) // BigDecimal(1.5)
- * console.log(
- *   Option.isNone(
- *     BigDecimal.divide(
- *       BigDecimal.fromStringUnsafe("6"),
- *       BigDecimal.fromStringUnsafe("0")
- *     )
- *   )
- * ) // true
+ * const six = BigDecimal.fromBigInt(6n)
+ *
+ * BigDecimal.divide(six, BigDecimal.fromBigInt(3n)) // => Option.some(BigDecimal.fromBigInt(2n))
+ * BigDecimal.divide(six, BigDecimal.fromBigInt(4n)) // => Option.some(BigDecimal.fromStringUnsafe("1.5"))
+ * BigDecimal.divide(six, BigDecimal.fromBigInt(0n)) // => Option.none()
  * ```
  *
  * @see {@link divideUnsafe} for division that throws when the divisor is zero
@@ -526,11 +501,11 @@ export const divide = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **Example** (Dividing decimals unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
- * 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)
+ * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(2n)
+ * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("4")) // => BigDecimal.fromStringUnsafe("1.5")
  * ```
  *
  * @see {@link divide} for division that returns `Option.none` when the divisor is zero
@@ -561,16 +536,16 @@ export const divideUnsafe = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **Example** (Comparing decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
  * const a = BigDecimal.fromNumberUnsafe(1.5)
  * const b = BigDecimal.fromNumberUnsafe(2.3)
  * const c = BigDecimal.fromNumberUnsafe(1.5)
  *
- * console.log(BigDecimal.Order(a, b)) // -1 (a < b)
- * console.log(BigDecimal.Order(b, a)) // 1 (b > a)
- * console.log(BigDecimal.Order(a, c)) // 0 (a === c)
+ * BigDecimal.Order(a, b) // => -1
+ * BigDecimal.Order(b, a) // => 1
+ * BigDecimal.Order(a, c) // => 0
  * ```
  *
  * @category instances
@@ -598,22 +573,16 @@ export const Order = /*#__PURE__*/order.make((self, that) => {
  *
  * **Example** (Checking less-than comparisons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
- *   true
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
- *   false
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
- *   false
- * )
+ *
+ * const two = BigDecimal.fromStringUnsafe("2")
+ * const three = BigDecimal.fromStringUnsafe("3")
+ * const four = BigDecimal.fromStringUnsafe("4")
+ *
+ * BigDecimal.isLessThan(two, three) // => true
+ * BigDecimal.isLessThan(three, three) // => false
+ * BigDecimal.isLessThan(four, three) // => false
  * ```
  *
  * @category predicates
@@ -629,22 +598,16 @@ export const isLessThan = /*#__PURE__*/order.isLessThan(Order);
  *
  * **Example** (Checking less-than-or-equal comparisons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
- *   true
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
- *   true
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
- *   false
- * )
+ *
+ * const two = BigDecimal.fromStringUnsafe("2")
+ * const three = BigDecimal.fromStringUnsafe("3")
+ * const four = BigDecimal.fromStringUnsafe("4")
+ *
+ * BigDecimal.isLessThanOrEqualTo(two, three) // => true
+ * BigDecimal.isLessThanOrEqualTo(three, three) // => true
+ * BigDecimal.isLessThanOrEqualTo(four, three) // => false
  * ```
  *
  * @category predicates
@@ -660,22 +623,16 @@ export const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order)
  *
  * **Example** (Checking greater-than comparisons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
- *   false
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
- *   false
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
- *   true
- * )
+ *
+ * const two = BigDecimal.fromStringUnsafe("2")
+ * const three = BigDecimal.fromStringUnsafe("3")
+ * const four = BigDecimal.fromStringUnsafe("4")
+ *
+ * BigDecimal.isGreaterThan(two, three) // => false
+ * BigDecimal.isGreaterThan(three, three) // => false
+ * BigDecimal.isGreaterThan(four, three) // => true
  * ```
  *
  * @category predicates
@@ -691,22 +648,16 @@ export const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);
  *
  * **Example** (Checking greater-than-or-equal comparisons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
- *   false
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
- *   true
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
- *   true
- * )
+ *
+ * const two = BigDecimal.fromStringUnsafe("2")
+ * const three = BigDecimal.fromStringUnsafe("3")
+ * const four = BigDecimal.fromStringUnsafe("4")
+ *
+ * BigDecimal.isGreaterThanOrEqualTo(two, three) // => false
+ * BigDecimal.isGreaterThanOrEqualTo(three, three) // => true
+ * BigDecimal.isGreaterThanOrEqualTo(four, three) // => true
  * ```
  *
  * @category predicates
@@ -722,18 +673,17 @@ export const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(
  *
  * **Example** (Checking decimal ranges)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
  * const between = BigDecimal.between({
  *   minimum: BigDecimal.fromStringUnsafe("1"),
  *   maximum: BigDecimal.fromStringUnsafe("5")
  * })
  *
- * assert.deepStrictEqual(between(BigDecimal.fromStringUnsafe("3")), true)
- * assert.deepStrictEqual(between(BigDecimal.fromStringUnsafe("0")), false)
- * assert.deepStrictEqual(between(BigDecimal.fromStringUnsafe("6")), false)
+ * between(BigDecimal.fromStringUnsafe("3")) // => true
+ * between(BigDecimal.fromStringUnsafe("0")) // => false
+ * between(BigDecimal.fromStringUnsafe("6")) // => false
  * ```
  *
  * @see {@link clamp} for forcing a `BigDecimal` into an inclusive range
@@ -757,27 +707,17 @@ export const between = /*#__PURE__*/order.isBetween(Order);
  *
  * **Example** (Clamping decimals to a range)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
  * const clamp = BigDecimal.clamp({
  *   minimum: BigDecimal.fromStringUnsafe("1"),
  *   maximum: BigDecimal.fromStringUnsafe("5")
  * })
  *
- * assert.deepStrictEqual(
- *   clamp(BigDecimal.fromStringUnsafe("3")),
- *   BigDecimal.fromStringUnsafe("3")
- * )
- * assert.deepStrictEqual(
- *   clamp(BigDecimal.fromStringUnsafe("0")),
- *   BigDecimal.fromStringUnsafe("1")
- * )
- * assert.deepStrictEqual(
- *   clamp(BigDecimal.fromStringUnsafe("6")),
- *   BigDecimal.fromStringUnsafe("5")
- * )
+ * clamp(BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(3n)
+ * clamp(BigDecimal.fromStringUnsafe("0")) // => BigDecimal.fromBigInt(1n)
+ * clamp(BigDecimal.fromStringUnsafe("6")) // => BigDecimal.fromBigInt(5n)
  * ```
  *
  * @see {@link between} for checking whether a `BigDecimal` is already inside a range
@@ -795,14 +735,13 @@ export const clamp = /*#__PURE__*/order.clamp(Order);
  *
  * **Example** (Selecting the smaller decimal)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   BigDecimal.min(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
- *   BigDecimal.fromStringUnsafe("2")
- * )
+ * const result = BigDecimal.min(
+ *   BigDecimal.fromStringUnsafe("2"),
+ *   BigDecimal.fromStringUnsafe("3")
+ * ) // => BigDecimal.fromBigInt(2n)
  * ```
  *
  * @see {@link max} for selecting the larger value
@@ -820,14 +759,13 @@ export const min = /*#__PURE__*/order.min(Order);
  *
  * **Example** (Selecting the larger decimal)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   BigDecimal.max(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ * const result = BigDecimal.max(
+ *   BigDecimal.fromStringUnsafe("2"),
  *   BigDecimal.fromStringUnsafe("3")
- * )
+ * ) // => BigDecimal.fromBigInt(3n)
  * ```
  *
  * @see {@link min} for selecting the smaller value
@@ -845,13 +783,12 @@ export const max = /*#__PURE__*/order.max(Order);
  *
  * **Example** (Reading decimal signs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("-5")), -1)
- * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("0")), 0)
- * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("5")), 1)
+ * BigDecimal.sign(BigDecimal.fromStringUnsafe("-5")) // => -1
+ * BigDecimal.sign(BigDecimal.fromStringUnsafe("0")) // => 0
+ * BigDecimal.sign(BigDecimal.fromStringUnsafe("5")) // => 1
  * ```
  *
  * @category math
@@ -867,13 +804,12 @@ export const sign = n => n.value === bigint0 ? 0 : n.value < bigint0 ? -1 : 1;
  *
  * **Example** (Calculating absolute values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * 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"))
+ * BigDecimal.abs(BigDecimal.fromStringUnsafe("-5")) // => BigDecimal.fromBigInt(5n)
+ * BigDecimal.abs(BigDecimal.fromStringUnsafe("0")) // => BigDecimal.fromBigInt(0n)
+ * BigDecimal.abs(BigDecimal.fromStringUnsafe("5")) // => BigDecimal.fromBigInt(5n)
  * ```
  *
  * @category math
@@ -889,12 +825,11 @@ export const abs = n => n.value < bigint0 ? make(-n.value, n.scale) : n;
  *
  * **Example** (Negating decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.negate(BigDecimal.fromStringUnsafe("3")), BigDecimal.fromStringUnsafe("-3"))
- * assert.deepStrictEqual(BigDecimal.negate(BigDecimal.fromStringUnsafe("-6")), BigDecimal.fromStringUnsafe("6"))
+ * BigDecimal.negate(BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(-3n)
+ * BigDecimal.negate(BigDecimal.fromStringUnsafe("-6")) // => BigDecimal.fromBigInt(6n)
  * ```
  *
  * @category math
@@ -916,31 +851,15 @@ export const negate = n => make(-n.value, n.scale);
  *
  * **Example** (Computing remainders safely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal, Option } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.remainder(
- *     BigDecimal.fromStringUnsafe("2"),
- *     BigDecimal.fromStringUnsafe("2")
- *   ),
- *   Option.some(BigDecimal.fromStringUnsafe("0"))
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.remainder(
- *     BigDecimal.fromStringUnsafe("3"),
- *     BigDecimal.fromStringUnsafe("2")
- *   ),
- *   Option.some(BigDecimal.fromStringUnsafe("1"))
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.remainder(
- *     BigDecimal.fromStringUnsafe("-4"),
- *     BigDecimal.fromStringUnsafe("2")
- *   ),
- *   Option.some(BigDecimal.fromStringUnsafe("0"))
- * )
+ *
+ * const two = BigDecimal.fromStringUnsafe("2")
+ * const three = BigDecimal.fromStringUnsafe("3")
+ * const zero = BigDecimal.fromStringUnsafe("0")
+ *
+ * BigDecimal.remainder(three, two) // => Option.some(BigDecimal.fromBigInt(1n))
+ * BigDecimal.remainder(two, zero) // => Option.none()
  * ```
  *
  * @see {@link remainderUnsafe} for remainder calculation that throws when the divisor is zero
@@ -971,22 +890,13 @@ export const remainder = /*#__PURE__*/dual(2, (self, divisor) => {
  *
  * **Example** (Computing remainders unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("2")),
- *   BigDecimal.fromStringUnsafe("0")
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("2")),
- *   BigDecimal.fromStringUnsafe("1")
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("-4"), BigDecimal.fromStringUnsafe("2")),
- *   BigDecimal.fromStringUnsafe("0")
- * )
+ *
+ * BigDecimal.remainderUnsafe(
+ *   BigDecimal.fromStringUnsafe("3"),
+ *   BigDecimal.fromStringUnsafe("2")
+ * ) // => BigDecimal.fromBigInt(1n)
  * ```
  *
  * @see {@link remainder} for returning `Option.none` when the divisor is zero
@@ -1011,15 +921,15 @@ export const remainderUnsafe = /*#__PURE__*/dual(2, (self, divisor) => {
  *
  * **Example** (Checking decimal equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
  * const a = BigDecimal.fromStringUnsafe("1.50")
  * const b = BigDecimal.fromStringUnsafe("1.5")
  * const c = BigDecimal.fromStringUnsafe("2.0")
  *
- * console.log(BigDecimal.Equivalence(a, b)) // true (1.50 === 1.5)
- * console.log(BigDecimal.Equivalence(a, c)) // false (1.50 !== 2.0)
+ * BigDecimal.Equivalence(a, b) // => true
+ * BigDecimal.Equivalence(a, c) // => false
  * ```
  *
  * @category instances
@@ -1043,15 +953,15 @@ export const Equivalence = /*#__PURE__*/Equ.make((self, that) => {
  *
  * **Example** (Checking decimal equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
  * const a = BigDecimal.fromStringUnsafe("1.5")
  * const b = BigDecimal.fromStringUnsafe("1.50")
  * const c = BigDecimal.fromStringUnsafe("2.0")
  *
- * console.log(BigDecimal.equals(a, b)) // true
- * console.log(BigDecimal.equals(a, c)) // false
+ * BigDecimal.equals(a, b) // => true
+ * BigDecimal.equals(a, c) // => false
  * ```
  *
  * @see {@link Equivalence} for passing decimal equality to APIs that require an `Equivalence`
@@ -1069,14 +979,14 @@ export const equals = /*#__PURE__*/dual(2, (self, that) => Equivalence(self, tha
  *
  * **Example** (Creating decimals from bigint)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
  * const decimal = BigDecimal.fromBigInt(123n)
- * console.log(BigDecimal.format(decimal)) // "123"
+ * decimal // => BigDecimal.fromStringUnsafe("123")
  *
  * const largeBigInt = BigDecimal.fromBigInt(9007199254740991n)
- * console.log(BigDecimal.format(largeBigInt)) // "9007199254740991"
+ * largeBigInt // => BigDecimal.fromStringUnsafe("9007199254740991")
  * ```
  *
  * @see {@link make} for constructing a decimal with an explicit scale
@@ -1101,12 +1011,11 @@ export const fromBigInt = n => make(n, 0);
  *
  * **Example** (Creating decimals from finite numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.fromNumberUnsafe(123), BigDecimal.make(123n, 0))
- * assert.deepStrictEqual(BigDecimal.fromNumberUnsafe(123.456), BigDecimal.make(123456n, 3))
+ * BigDecimal.fromNumberUnsafe(123) // => BigDecimal.fromBigInt(123n)
+ * BigDecimal.fromNumberUnsafe(123.456) // => BigDecimal.fromStringUnsafe("123.456")
  * ```
  *
  * @see {@link fromNumber} for returning `Option.none` when the number is not finite
@@ -1136,16 +1045,11 @@ export const fromNumberUnsafe = n => {
  *
  * **Example** (Creating decimals from numbers safely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal, Option } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(BigDecimal.fromNumber(123), Option.some(BigDecimal.make(123n, 0)))
- * assert.deepStrictEqual(
- *   BigDecimal.fromNumber(123.456),
- *   Option.some(BigDecimal.make(123456n, 3))
- * )
- * assert.deepStrictEqual(BigDecimal.fromNumber(Infinity), Option.none())
+ *
+ * BigDecimal.fromNumber(123.456) // => Option.some(BigDecimal.fromStringUnsafe("123.456"))
+ * BigDecimal.fromNumber(Infinity) // => Option.none()
  * ```
  *
  * @see {@link fromNumberUnsafe} for throwing when the number is not finite
@@ -1180,16 +1084,11 @@ export const fromNumber = n => {
  *
  * **Example** (Parsing decimal strings safely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal, Option } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(BigDecimal.fromString("123"), Option.some(BigDecimal.make(123n, 0)))
- * assert.deepStrictEqual(
- *   BigDecimal.fromString("123.456"),
- *   Option.some(BigDecimal.make(123456n, 3))
- * )
- * assert.deepStrictEqual(BigDecimal.fromString("123.abc"), Option.none())
+ *
+ * BigDecimal.fromString("123.456") // => Option.some(BigDecimal.make(123456n, 3))
+ * BigDecimal.fromString("123.abc") // => Option.none()
  * ```
  *
  * @see {@link fromStringUnsafe} for parsing that throws on invalid input
@@ -1252,13 +1151,11 @@ export const fromString = s => {
  *
  * **Example** (Parsing decimal strings unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * 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"))
+ * BigDecimal.fromStringUnsafe("123") // => BigDecimal.fromBigInt(123n)
+ * BigDecimal.fromStringUnsafe("123.456") // => BigDecimal.make(123456n, 3)
  * ```
  *
  * @see {@link fromString} for returning `Option.none` on invalid input
@@ -1284,13 +1181,12 @@ export const fromStringUnsafe = s => {
  *
  * **Example** (Formatting decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * 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")
+ * BigDecimal.format(BigDecimal.fromStringUnsafe("-5")) // => "-5"
+ * BigDecimal.format(BigDecimal.fromStringUnsafe("123.456")) // => "123.456"
+ * BigDecimal.format(BigDecimal.fromStringUnsafe("-0.00000123")) // => "-0.00000123"
  * ```
  *
  * @see {@link toExponential} for always rendering scientific notation
@@ -1333,11 +1229,10 @@ export const format = n => {
  *
  * **Example** (Formatting decimals exponentially)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.toExponential(BigDecimal.make(123456n, -5)), "1.23456e+10")
+ * BigDecimal.toExponential(BigDecimal.make(123456n, -5)) // => "1.23456e+10"
  * ```
  *
  * @see {@link format} for plain decimal formatting when possible
@@ -1376,11 +1271,10 @@ export const toExponential = n => {
  *
  * **Example** (Converting decimals to numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.toNumberUnsafe(BigDecimal.fromStringUnsafe("123.456")), 123.456)
+ * BigDecimal.toNumberUnsafe(BigDecimal.fromStringUnsafe("123.456")) // => 123.456
  * ```
  *
  * @see {@link format} for preserving decimal precision as text
@@ -1398,13 +1292,12 @@ export const toNumberUnsafe = n => Number(format(n));
  *
  * **Example** (Checking integer decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * 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)
+ * BigDecimal.isInteger(BigDecimal.fromStringUnsafe("0")) // => true
+ * BigDecimal.isInteger(BigDecimal.fromStringUnsafe("1")) // => true
+ * BigDecimal.isInteger(BigDecimal.fromStringUnsafe("1.1")) // => false
  * ```
  *
  * @category predicates
@@ -1420,12 +1313,11 @@ export const isInteger = n => normalize(n).scale <= 0;
  *
  * **Example** (Checking zero decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.isZero(BigDecimal.fromStringUnsafe("0")), true)
- * assert.deepStrictEqual(BigDecimal.isZero(BigDecimal.fromStringUnsafe("1")), false)
+ * BigDecimal.isZero(BigDecimal.fromStringUnsafe("0")) // => true
+ * BigDecimal.isZero(BigDecimal.fromStringUnsafe("1")) // => false
  * ```
  *
  * @category predicates
@@ -1441,13 +1333,12 @@ export const isZero = n => n.value === bigint0;
  *
  * **Example** (Checking negative decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("-1")), true)
- * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("0")), false)
- * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("1")), false)
+ * BigDecimal.isNegative(BigDecimal.fromStringUnsafe("-1")) // => true
+ * BigDecimal.isNegative(BigDecimal.fromStringUnsafe("0")) // => false
+ * BigDecimal.isNegative(BigDecimal.fromStringUnsafe("1")) // => false
  * ```
  *
  * @category predicates
@@ -1463,13 +1354,12 @@ export const isNegative = n => n.value < bigint0;
  *
  * **Example** (Checking positive decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("-1")), false)
- * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("0")), false)
- * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("1")), true)
+ * BigDecimal.isPositive(BigDecimal.fromStringUnsafe("-1")) // => false
+ * BigDecimal.isPositive(BigDecimal.fromStringUnsafe("0")) // => false
+ * BigDecimal.isPositive(BigDecimal.fromStringUnsafe("1")) // => true
  * ```
  *
  * @category predicates
@@ -1486,18 +1376,14 @@ const isBigDecimalArgs = args => isBigDecimal(args[0]);
  *
  * **Example** (Rounding decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
- *   BigDecimal.fromStringUnsafe("150")
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5")),
- *   BigDecimal.fromStringUnsafe("-15")
- * )
+ *
+ * const positive = BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 })
+ * positive // => BigDecimal.fromBigInt(150n)
+ *
+ * const negative = BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5"))
+ * negative // => BigDecimal.fromBigInt(-15n)
  * ```
  *
  * @see {@link ceil} for fixed rounding toward positive infinity
@@ -1549,11 +1435,11 @@ export const round = /*#__PURE__*/dual(isBigDecimalArgs, (self, options) => {
  *
  * **Example** (Truncating decimals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
- * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1)) // BigDecimal(140)
- * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5"))) // BigDecimal(-14)
+ * BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(140n)
+ * BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-14n)
  * ```
  *
  * @see {@link round} for configurable rounding modes
@@ -1589,15 +1475,11 @@ export const truncate = /*#__PURE__*/dual(isBigDecimalArgs, (self, scale = 0) =>
  *
  * **Example** (Rounding decimals up)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1),
- *   BigDecimal.fromStringUnsafe("150")
- * )
- * assert.deepStrictEqual(BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")), BigDecimal.fromStringUnsafe("-14"))
+ * BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(150n)
+ * BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-14n)
  * ```
  *
  * @category math
@@ -1633,18 +1515,11 @@ export const digitAt = /*#__PURE__*/dual(2, (self, scale) => {
  *
  * **Example** (Rounding decimals down)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1),
- *   BigDecimal.fromStringUnsafe("140")
- * )
- * assert.deepStrictEqual(
- *   BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")),
- *   BigDecimal.fromStringUnsafe("-15")
- * )
+ *
+ * BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(140n)
+ * BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-15n)
  * ```
  *
  * @see {@link ceil} for rounding toward positive infinity