effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/BigDecimal.d.ts

@@ -25,13 +25,13 @@ declare const TypeId = "~effect/BigDecimal";
  *
  * **Example** (Inspecting BigDecimal storage)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigDecimal } from "effect"
  *
  * const d = BigDecimal.fromStringUnsafe("123.45")
  *
- * console.log(d.value) // 12345n
- * console.log(d.scale) // 2
+ * d.value // => 12345n
+ * d.scale // => 2
  * ```
  *
  * @category models
@@ -51,13 +51,14 @@ export interface BigDecimal extends Equal.Equal, Pipeable, Inspectable {
  *
  * **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
@@ -74,16 +75,16 @@ export declare const isBigDecimal: (u: unknown) => u is BigDecimal;
  *
  * **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`
@@ -102,18 +103,14 @@ export declare const make: (value: bigint, scale: number) => BigDecimal;
  *
  * **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
@@ -137,18 +134,18 @@ export declare const normalize: (self: BigDecimal) => BigDecimal;
  *
  * **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
@@ -172,18 +169,18 @@ export declare const scale: {
      *
      * **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
@@ -207,18 +204,18 @@ export declare const scale: {
      *
      * **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
@@ -238,14 +235,13 @@ export declare const 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
@@ -264,14 +260,13 @@ export declare const sum: {
      *
      * **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
@@ -290,14 +285,13 @@ export declare const sum: {
      *
      * **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
@@ -317,14 +311,14 @@ export declare const sum: {
  *
  * **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
@@ -342,14 +336,13 @@ export declare const sumAll: (collection: Iterable<BigDecimal>) => BigDecimal;
  *
  * **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
@@ -367,14 +360,13 @@ export declare const multiply: {
      *
      * **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
@@ -392,14 +384,13 @@ export declare const multiply: {
      *
      * **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
@@ -418,14 +409,14 @@ export declare const multiply: {
  *
  * **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
@@ -443,14 +434,13 @@ export declare const multiplyAll: (collection: Iterable<BigDecimal>) => BigDecim
  *
  * **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
@@ -466,14 +456,13 @@ export declare const subtract: {
      *
      * **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
@@ -489,14 +478,13 @@ export declare const subtract: {
      *
      * **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
@@ -520,33 +508,14 @@ export declare const subtract: {
  *
  * **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
@@ -572,33 +541,14 @@ export declare const divide: {
      *
      * **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
@@ -624,33 +574,14 @@ export declare const divide: {
      *
      * **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
@@ -680,11 +611,11 @@ export declare const divide: {
  *
  * **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
@@ -712,11 +643,11 @@ export declare const divideUnsafe: {
      *
      * **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
@@ -744,11 +675,11 @@ export declare const divideUnsafe: {
      *
      * **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
@@ -768,16 +699,16 @@ export declare const divideUnsafe: {
  *
  * **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
@@ -793,22 +724,16 @@ export declare const Order: order.Order<BigDecimal>;
  *
  * **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
@@ -824,22 +749,16 @@ export declare const isLessThan: {
      *
      * **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
@@ -855,22 +774,16 @@ export declare const isLessThan: {
      *
      * **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
@@ -887,22 +800,16 @@ export declare const isLessThan: {
  *
  * **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
@@ -918,22 +825,16 @@ export declare const isLessThanOrEqualTo: {
      *
      * **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
@@ -949,22 +850,16 @@ export declare const isLessThanOrEqualTo: {
      *
      * **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
@@ -981,22 +876,16 @@ export declare const isLessThanOrEqualTo: {
  *
  * **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
@@ -1012,22 +901,16 @@ export declare const isGreaterThan: {
      *
      * **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
@@ -1043,22 +926,16 @@ export declare const isGreaterThan: {
      *
      * **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
@@ -1075,22 +952,16 @@ export declare const isGreaterThan: {
  *
  * **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
@@ -1106,22 +977,16 @@ export declare const isGreaterThanOrEqualTo: {
      *
      * **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
@@ -1137,22 +1002,16 @@ export declare const isGreaterThanOrEqualTo: {
      *
      * **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
@@ -1169,18 +1028,17 @@ export declare const 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
@@ -1198,18 +1056,17 @@ export declare const between: {
      *
      * **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
@@ -1230,18 +1087,17 @@ export declare const between: {
      *
      * **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
@@ -1269,27 +1125,17 @@ export declare const between: {
  *
  * **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
@@ -1313,27 +1159,17 @@ export declare const clamp: {
      *
      * **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
@@ -1360,27 +1196,17 @@ export declare const clamp: {
      *
      * **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
@@ -1402,14 +1228,13 @@ export declare const clamp: {
  *
  * **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
@@ -1427,14 +1252,13 @@ export declare const min: {
      *
      * **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
@@ -1452,14 +1276,13 @@ export declare const min: {
      *
      * **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
@@ -1478,14 +1301,13 @@ export declare const min: {
  *
  * **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
@@ -1503,14 +1325,13 @@ export declare const max: {
      *
      * **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
@@ -1528,14 +1349,13 @@ export declare const max: {
      *
      * **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
@@ -1554,13 +1374,12 @@ export declare const max: {
  *
  * **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
@@ -1576,13 +1395,12 @@ export declare const sign: (n: BigDecimal) => Ordering;
  *
  * **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
@@ -1598,12 +1416,11 @@ export declare const abs: (n: BigDecimal) => BigDecimal;
  *
  * **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
@@ -1625,31 +1442,15 @@ export declare const negate: (n: BigDecimal) => BigDecimal;
  *
  * **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
@@ -1674,31 +1475,15 @@ export declare const remainder: {
      *
      * **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
@@ -1723,31 +1508,15 @@ export declare const remainder: {
      *
      * **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
@@ -1773,22 +1542,13 @@ export declare const remainder: {
  *
  * **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
@@ -1812,22 +1572,13 @@ export declare const remainderUnsafe: {
      *
      * **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
@@ -1851,22 +1602,13 @@ export declare const remainderUnsafe: {
      *
      * **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
@@ -1886,15 +1628,15 @@ export declare const remainderUnsafe: {
  *
  * **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
@@ -1910,15 +1652,15 @@ export declare const Equivalence: Equ.Equivalence<BigDecimal>;
  *
  * **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`
@@ -1936,15 +1678,15 @@ export declare const equals: {
      *
      * **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`
@@ -1962,15 +1704,15 @@ export declare const equals: {
      *
      * **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`
@@ -1989,14 +1731,14 @@ export declare const equals: {
  *
  * **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
@@ -2021,12 +1763,11 @@ export declare const fromBigInt: (n: bigint) => BigDecimal;
  *
  * **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
@@ -2054,16 +1795,11 @@ export declare const fromNumberUnsafe: (n: number) => BigDecimal;
  *
  * **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
@@ -2088,16 +1824,11 @@ export declare const fromNumber: (n: number) => Option.Option<BigDecimal>;
  *
  * **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
@@ -2122,13 +1853,11 @@ export declare const fromString: (s: string) => Option.Option<BigDecimal>;
  *
  * **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
@@ -2152,13 +1881,12 @@ export declare const fromStringUnsafe: (s: string) => BigDecimal;
  *
  * **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
@@ -2176,11 +1904,10 @@ export declare const format: (n: BigDecimal) => string;
  *
  * **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
@@ -2205,11 +1932,10 @@ export declare const toExponential: (n: BigDecimal) => string;
  *
  * **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
@@ -2227,13 +1953,12 @@ export declare const toNumberUnsafe: (n: BigDecimal) => number;
  *
  * **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
@@ -2249,12 +1974,11 @@ export declare const isInteger: (n: BigDecimal) => boolean;
  *
  * **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
@@ -2270,13 +1994,12 @@ export declare const isZero: (n: BigDecimal) => boolean;
  *
  * **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
@@ -2292,13 +2015,12 @@ export declare const isNegative: (n: BigDecimal) => boolean;
  *
  * **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
@@ -2344,18 +2066,14 @@ export type RoundingMode = "ceil" | "floor" | "to-zero" | "from-zero" | "half-ce
  *
  * **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
@@ -2375,18 +2093,14 @@ export declare const round: {
      *
      * **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
@@ -2409,18 +2123,14 @@ export declare const round: {
      *
      * **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
@@ -2446,11 +2156,11 @@ export declare const round: {
  *
  * **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
@@ -2472,11 +2182,11 @@ export declare const truncate: {
      *
      * **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
@@ -2498,11 +2208,11 @@ export declare const truncate: {
      *
      * **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
@@ -2533,15 +2243,11 @@ export declare const truncate: {
  *
  * **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
@@ -2567,15 +2273,11 @@ export declare const ceil: {
      *
      * **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
@@ -2601,15 +2303,11 @@ export declare const ceil: {
      *
      * **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
@@ -2626,18 +2324,11 @@ export declare const ceil: {
  *
  * **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
@@ -2657,18 +2348,11 @@ export declare const floor: {
      *
      * **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
@@ -2688,18 +2372,11 @@ export declare const floor: {
      *
      * **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