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

package/dist/BigInt.d.ts

@@ -32,14 +32,11 @@ import * as Reducer from "./Reducer.ts";
  *
  * **Example** (Constructing bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
  *
- * const bigInt = BigInt.BigInt(123)
- * console.log(bigInt) // 123n
- *
- * const fromString = BigInt.BigInt("456")
- * console.log(fromString) // 456n
+ * BigInt.BigInt(123) // => 123n
+ * BigInt.BigInt("456") // => 456n
  * ```
  *
  * @category constructors
@@ -55,12 +52,11 @@ export declare const BigInt: BigIntConstructor;
  *
  * **Example** (Checking for bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.isBigInt(1n), true)
- * assert.deepStrictEqual(BigInt.isBigInt(1), false)
+ * BigInt.isBigInt(1n) // => true
+ * BigInt.isBigInt(1) // => false
  * ```
  *
  * @category guards
@@ -77,11 +73,10 @@ export declare const isBigInt: (u: unknown) => u is bigint;
  *
  * **Example** (Adding bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
+ * BigInt.sum(2n, 3n) // => 5n
  * ```
  *
  * @see {@link sumAll} for summing an iterable of `bigint` values
@@ -100,11 +95,10 @@ export declare const sum: {
      *
      * **Example** (Adding bigints)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
+     * BigInt.sum(2n, 3n) // => 5n
      * ```
      *
      * @see {@link sumAll} for summing an iterable of `bigint` values
@@ -123,11 +117,10 @@ export declare const sum: {
      *
      * **Example** (Adding bigints)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
+     * BigInt.sum(2n, 3n) // => 5n
      * ```
      *
      * @see {@link sumAll} for summing an iterable of `bigint` values
@@ -146,11 +139,10 @@ export declare const sum: {
  *
  * **Example** (Multiplying bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
+ * BigInt.multiply(2n, 3n) // => 6n
  * ```
  *
  * @see {@link multiplyAll} for multiplying an iterable of `bigint` values
@@ -168,11 +160,10 @@ export declare const multiply: {
      *
      * **Example** (Multiplying bigints)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
+     * BigInt.multiply(2n, 3n) // => 6n
      * ```
      *
      * @see {@link multiplyAll} for multiplying an iterable of `bigint` values
@@ -190,11 +181,10 @@ export declare const multiply: {
      *
      * **Example** (Multiplying bigints)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
+     * BigInt.multiply(2n, 3n) // => 6n
      * ```
      *
      * @see {@link multiplyAll} for multiplying an iterable of `bigint` values
@@ -213,11 +203,10 @@ export declare const multiply: {
  *
  * **Example** (Subtracting bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
+ * BigInt.subtract(2n, 3n) // => -1n
  * ```
  *
  * @category math
@@ -233,11 +222,10 @@ export declare const subtract: {
      *
      * **Example** (Subtracting bigints)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
+     * BigInt.subtract(2n, 3n) // => -1n
      * ```
      *
      * @category math
@@ -253,11 +241,10 @@ export declare const subtract: {
      *
      * **Example** (Subtracting bigints)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
+     * BigInt.subtract(2n, 3n) // => -1n
      * ```
      *
      * @category math
@@ -280,12 +267,11 @@ export declare const subtract: {
  *
  * **Example** (Dividing bigints safely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt, Option } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
- * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
+ * BigInt.divide(6n, 3n) // => Option.some(2n)
+ * BigInt.divide(6n, 0n) // => Option.none()
  * ```
  *
  * @see {@link divideUnsafe} for division that throws when the divisor is `0n`
@@ -310,12 +296,11 @@ export declare const divide: {
      *
      * **Example** (Dividing bigints safely)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt, Option } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
-     * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
+     * BigInt.divide(6n, 3n) // => Option.some(2n)
+     * BigInt.divide(6n, 0n) // => Option.none()
      * ```
      *
      * @see {@link divideUnsafe} for division that throws when the divisor is `0n`
@@ -340,12 +325,11 @@ export declare const divide: {
      *
      * **Example** (Dividing bigints safely)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt, Option } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
-     * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
+     * BigInt.divide(6n, 3n) // => Option.some(2n)
+     * BigInt.divide(6n, 0n) // => Option.none()
      * ```
      *
      * @see {@link divideUnsafe} for division that throws when the divisor is `0n`
@@ -375,12 +359,11 @@ export declare const divide: {
  *
  * **Example** (Dividing bigints unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
- * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
+ * BigInt.divideUnsafe(6n, 3n) // => 2n
+ * BigInt.divideUnsafe(6n, 4n) // => 1n
  * ```
  *
  * @see {@link divide} for division that returns `Option.none` when the divisor is `0n`
@@ -408,12 +391,11 @@ export declare const divideUnsafe: {
      *
      * **Example** (Dividing bigints unsafely)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
-     * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
+     * BigInt.divideUnsafe(6n, 3n) // => 2n
+     * BigInt.divideUnsafe(6n, 4n) // => 1n
      * ```
      *
      * @see {@link divide} for division that returns `Option.none` when the divisor is `0n`
@@ -441,12 +423,11 @@ export declare const divideUnsafe: {
      *
      * **Example** (Dividing bigints unsafely)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
-     * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
+     * BigInt.divideUnsafe(6n, 3n) // => 2n
+     * BigInt.divideUnsafe(6n, 4n) // => 1n
      * ```
      *
      * @see {@link divide} for division that returns `Option.none` when the divisor is `0n`
@@ -465,11 +446,10 @@ export declare const divideUnsafe: {
  *
  * **Example** (Incrementing a bigint)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.increment(2n), 3n)
+ * BigInt.increment(2n) // => 3n
  * ```
  *
  * @category math
@@ -485,11 +465,10 @@ export declare const increment: (n: bigint) => bigint;
  *
  * **Example** (Decrementing a bigint)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.decrement(3n), 2n)
+ * BigInt.decrement(3n) // => 2n
  * ```
  *
  * @category math
@@ -506,16 +485,16 @@ export declare const decrement: (n: bigint) => bigint;
  *
  * **Example** (Comparing bigints with Order)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
  *
  * const a = 123n
  * const b = 456n
  * const c = 123n
  *
- * console.log(BigInt.Order(a, b)) // -1 (a < b)
- * console.log(BigInt.Order(b, a)) // 1 (b > a)
- * console.log(BigInt.Order(a, c)) // 0 (a === c)
+ * BigInt.Order(a, b) // => -1
+ * BigInt.Order(b, a) // => 1
+ * BigInt.Order(a, c) // => 0
  * ```
  *
  * @category instances
@@ -532,11 +511,11 @@ export declare const Order: order.Order<bigint>;
  *
  * **Example** (Comparing bigints for equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
  *
- * console.log(BigInt.Equivalence(1n, 1n)) // true
- * console.log(BigInt.Equivalence(1n, 2n)) // false
+ * BigInt.Equivalence(1n, 1n) // => true
+ * BigInt.Equivalence(1n, 2n) // => false
  * ```
  *
  * @category instances
@@ -552,13 +531,12 @@ export declare const Equivalence: Equ.Equivalence<bigint>;
  *
  * **Example** (Checking less-than comparisons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
- * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
- * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
+ * BigInt.isLessThan(2n, 3n) // => true
+ * BigInt.isLessThan(3n, 3n) // => false
+ * BigInt.isLessThan(4n, 3n) // => false
  * ```
  *
  * @category predicates
@@ -574,13 +552,12 @@ export declare const isLessThan: {
      *
      * **Example** (Checking less-than comparisons)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
-     * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
-     * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
+     * BigInt.isLessThan(2n, 3n) // => true
+     * BigInt.isLessThan(3n, 3n) // => false
+     * BigInt.isLessThan(4n, 3n) // => false
      * ```
      *
      * @category predicates
@@ -596,13 +573,12 @@ export declare const isLessThan: {
      *
      * **Example** (Checking less-than comparisons)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
-     * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
-     * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
+     * BigInt.isLessThan(2n, 3n) // => true
+     * BigInt.isLessThan(3n, 3n) // => false
+     * BigInt.isLessThan(4n, 3n) // => false
      * ```
      *
      * @category predicates
@@ -619,13 +595,12 @@ export declare const isLessThan: {
  *
  * **Example** (Checking less-than-or-equal comparisons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
- * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
- * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
+ * BigInt.isLessThanOrEqualTo(2n, 3n) // => true
+ * BigInt.isLessThanOrEqualTo(3n, 3n) // => true
+ * BigInt.isLessThanOrEqualTo(4n, 3n) // => false
  * ```
  *
  * @category predicates
@@ -641,13 +616,12 @@ export declare const isLessThanOrEqualTo: {
      *
      * **Example** (Checking less-than-or-equal comparisons)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
-     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
-     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
+     * BigInt.isLessThanOrEqualTo(2n, 3n) // => true
+     * BigInt.isLessThanOrEqualTo(3n, 3n) // => true
+     * BigInt.isLessThanOrEqualTo(4n, 3n) // => false
      * ```
      *
      * @category predicates
@@ -663,13 +637,12 @@ export declare const isLessThanOrEqualTo: {
      *
      * **Example** (Checking less-than-or-equal comparisons)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
-     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
-     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
+     * BigInt.isLessThanOrEqualTo(2n, 3n) // => true
+     * BigInt.isLessThanOrEqualTo(3n, 3n) // => true
+     * BigInt.isLessThanOrEqualTo(4n, 3n) // => false
      * ```
      *
      * @category predicates
@@ -686,13 +659,12 @@ export declare const isLessThanOrEqualTo: {
  *
  * **Example** (Checking greater-than comparisons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
- * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
- * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
+ * BigInt.isGreaterThan(2n, 3n) // => false
+ * BigInt.isGreaterThan(3n, 3n) // => false
+ * BigInt.isGreaterThan(4n, 3n) // => true
  * ```
  *
  * @category predicates
@@ -708,13 +680,12 @@ export declare const isGreaterThan: {
      *
      * **Example** (Checking greater-than comparisons)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
-     * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
-     * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
+     * BigInt.isGreaterThan(2n, 3n) // => false
+     * BigInt.isGreaterThan(3n, 3n) // => false
+     * BigInt.isGreaterThan(4n, 3n) // => true
      * ```
      *
      * @category predicates
@@ -730,13 +701,12 @@ export declare const isGreaterThan: {
      *
      * **Example** (Checking greater-than comparisons)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
-     * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
-     * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
+     * BigInt.isGreaterThan(2n, 3n) // => false
+     * BigInt.isGreaterThan(3n, 3n) // => false
+     * BigInt.isGreaterThan(4n, 3n) // => true
      * ```
      *
      * @category predicates
@@ -753,13 +723,12 @@ export declare const isGreaterThan: {
  *
  * **Example** (Checking greater-than-or-equal comparisons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
- * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
- * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
+ * BigInt.isGreaterThanOrEqualTo(2n, 3n) // => false
+ * BigInt.isGreaterThanOrEqualTo(3n, 3n) // => true
+ * BigInt.isGreaterThanOrEqualTo(4n, 3n) // => true
  * ```
  *
  * @category predicates
@@ -775,13 +744,12 @@ export declare const isGreaterThanOrEqualTo: {
      *
      * **Example** (Checking greater-than-or-equal comparisons)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
-     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
-     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
+     * BigInt.isGreaterThanOrEqualTo(2n, 3n) // => false
+     * BigInt.isGreaterThanOrEqualTo(3n, 3n) // => true
+     * BigInt.isGreaterThanOrEqualTo(4n, 3n) // => true
      * ```
      *
      * @category predicates
@@ -797,13 +765,12 @@ export declare const isGreaterThanOrEqualTo: {
      *
      * **Example** (Checking greater-than-or-equal comparisons)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
-     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
-     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
+     * BigInt.isGreaterThanOrEqualTo(2n, 3n) // => false
+     * BigInt.isGreaterThanOrEqualTo(3n, 3n) // => true
+     * BigInt.isGreaterThanOrEqualTo(4n, 3n) // => true
      * ```
      *
      * @category predicates
@@ -820,15 +787,14 @@ export declare const isGreaterThanOrEqualTo: {
  *
  * **Example** (Checking whether a bigint is within bounds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
  * const between = BigInt.between({ minimum: 0n, maximum: 5n })
  *
- * assert.deepStrictEqual(between(3n), true)
- * assert.deepStrictEqual(between(-1n), false)
- * assert.deepStrictEqual(between(6n), false)
+ * between(3n) // => true
+ * between(-1n) // => false
+ * between(6n) // => false
  * ```
  *
  * @see {@link clamp} for forcing a `bigint` into an inclusive range
@@ -846,15 +812,14 @@ export declare const between: {
      *
      * **Example** (Checking whether a bigint is within bounds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
      * const between = BigInt.between({ minimum: 0n, maximum: 5n })
      *
-     * assert.deepStrictEqual(between(3n), true)
-     * assert.deepStrictEqual(between(-1n), false)
-     * assert.deepStrictEqual(between(6n), false)
+     * between(3n) // => true
+     * between(-1n) // => false
+     * between(6n) // => false
      * ```
      *
      * @see {@link clamp} for forcing a `bigint` into an inclusive range
@@ -875,15 +840,14 @@ export declare const between: {
      *
      * **Example** (Checking whether a bigint is within bounds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
      * const between = BigInt.between({ minimum: 0n, maximum: 5n })
      *
-     * assert.deepStrictEqual(between(3n), true)
-     * assert.deepStrictEqual(between(-1n), false)
-     * assert.deepStrictEqual(between(6n), false)
+     * between(3n) // => true
+     * between(-1n) // => false
+     * between(6n) // => false
      * ```
      *
      * @see {@link clamp} for forcing a `bigint` into an inclusive range
@@ -911,15 +875,14 @@ export declare const between: {
  *
  * **Example** (Clamping a bigint to bounds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
  * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
  *
- * assert.equal(clamp(3n), 3n)
- * assert.equal(clamp(0n), 1n)
- * assert.equal(clamp(6n), 5n)
+ * clamp(3n) // => 3n
+ * clamp(0n) // => 1n
+ * clamp(6n) // => 5n
  * ```
  *
  * @see {@link between} for checking whether a `bigint` is already inside a range
@@ -943,15 +906,14 @@ export declare const clamp: {
      *
      * **Example** (Clamping a bigint to bounds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
      * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
      *
-     * assert.equal(clamp(3n), 3n)
-     * assert.equal(clamp(0n), 1n)
-     * assert.equal(clamp(6n), 5n)
+     * clamp(3n) // => 3n
+     * clamp(0n) // => 1n
+     * clamp(6n) // => 5n
      * ```
      *
      * @see {@link between} for checking whether a `bigint` is already inside a range
@@ -978,15 +940,14 @@ export declare const clamp: {
      *
      * **Example** (Clamping a bigint to bounds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
      * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
      *
-     * assert.equal(clamp(3n), 3n)
-     * assert.equal(clamp(0n), 1n)
-     * assert.equal(clamp(6n), 5n)
+     * clamp(3n) // => 3n
+     * clamp(0n) // => 1n
+     * clamp(6n) // => 5n
      * ```
      *
      * @see {@link between} for checking whether a `bigint` is already inside a range
@@ -1008,11 +969,10 @@ export declare const clamp: {
  *
  * **Example** (Finding the minimum bigint)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
+ * BigInt.min(2n, 3n) // => 2n
  * ```
  *
  * @see {@link max} for selecting the larger value
@@ -1030,11 +990,10 @@ export declare const min: {
      *
      * **Example** (Finding the minimum bigint)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
+     * BigInt.min(2n, 3n) // => 2n
      * ```
      *
      * @see {@link max} for selecting the larger value
@@ -1052,11 +1011,10 @@ export declare const min: {
      *
      * **Example** (Finding the minimum bigint)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
+     * BigInt.min(2n, 3n) // => 2n
      * ```
      *
      * @see {@link max} for selecting the larger value
@@ -1075,11 +1033,10 @@ export declare const min: {
  *
  * **Example** (Finding the maximum bigint)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
+ * BigInt.max(2n, 3n) // => 3n
  * ```
  *
  * @see {@link min} for selecting the smaller value
@@ -1097,11 +1054,10 @@ export declare const max: {
      *
      * **Example** (Finding the maximum bigint)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
+     * BigInt.max(2n, 3n) // => 3n
      * ```
      *
      * @see {@link min} for selecting the smaller value
@@ -1119,11 +1075,10 @@ export declare const max: {
      *
      * **Example** (Finding the maximum bigint)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
+     * BigInt.max(2n, 3n) // => 3n
      * ```
      *
      * @see {@link min} for selecting the smaller value
@@ -1142,13 +1097,12 @@ export declare const max: {
  *
  * **Example** (Determining bigint signs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.sign(-5n), -1)
- * assert.deepStrictEqual(BigInt.sign(0n), 0)
- * assert.deepStrictEqual(BigInt.sign(5n), 1)
+ * BigInt.sign(-5n) // => -1
+ * BigInt.sign(0n) // => 0
+ * BigInt.sign(5n) // => 1
  * ```
  *
  * @category math
@@ -1164,13 +1118,12 @@ export declare const sign: (n: bigint) => Ordering;
  *
  * **Example** (Calculating absolute values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.abs(-5n), 5n)
- * assert.deepStrictEqual(BigInt.abs(0n), 0n)
- * assert.deepStrictEqual(BigInt.abs(5n), 5n)
+ * BigInt.abs(-5n) // => 5n
+ * BigInt.abs(0n) // => 0n
+ * BigInt.abs(5n) // => 5n
  * ```
  *
  * @category math
@@ -1186,13 +1139,12 @@ export declare const abs: (n: bigint) => bigint;
  *
  * **Example** (Calculating greatest common divisors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
- * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
- * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
+ * BigInt.gcd(2n, 3n) // => 1n
+ * BigInt.gcd(2n, 4n) // => 2n
+ * BigInt.gcd(16n, 24n) // => 8n
  * ```
  *
  * @see {@link lcm} for computing the least common multiple
@@ -1210,13 +1162,12 @@ export declare const gcd: {
      *
      * **Example** (Calculating greatest common divisors)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
-     * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
-     * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
+     * BigInt.gcd(2n, 3n) // => 1n
+     * BigInt.gcd(2n, 4n) // => 2n
+     * BigInt.gcd(16n, 24n) // => 8n
      * ```
      *
      * @see {@link lcm} for computing the least common multiple
@@ -1234,13 +1185,12 @@ export declare const gcd: {
      *
      * **Example** (Calculating greatest common divisors)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
-     * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
-     * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
+     * BigInt.gcd(2n, 3n) // => 1n
+     * BigInt.gcd(2n, 4n) // => 2n
+     * BigInt.gcd(16n, 24n) // => 8n
      * ```
      *
      * @see {@link lcm} for computing the least common multiple
@@ -1259,13 +1209,12 @@ export declare const gcd: {
  *
  * **Example** (Calculating least common multiples)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
- * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
- * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
+ * BigInt.lcm(2n, 3n) // => 6n
+ * BigInt.lcm(2n, 4n) // => 4n
+ * BigInt.lcm(16n, 24n) // => 48n
  * ```
  *
  * @see {@link gcd} for computing the greatest common divisor
@@ -1283,13 +1232,12 @@ export declare const lcm: {
      *
      * **Example** (Calculating least common multiples)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
-     * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
-     * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
+     * BigInt.lcm(2n, 3n) // => 6n
+     * BigInt.lcm(2n, 4n) // => 4n
+     * BigInt.lcm(16n, 24n) // => 48n
      * ```
      *
      * @see {@link gcd} for computing the greatest common divisor
@@ -1307,13 +1255,12 @@ export declare const lcm: {
      *
      * **Example** (Calculating least common multiples)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
-     * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
-     * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
-     * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
+     * BigInt.lcm(2n, 3n) // => 6n
+     * BigInt.lcm(2n, 4n) // => 4n
+     * BigInt.lcm(16n, 24n) // => 48n
      * ```
      *
      * @see {@link gcd} for computing the greatest common divisor
@@ -1343,13 +1290,12 @@ export declare const lcm: {
  *
  * **Example** (Calculating square roots unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.sqrtUnsafe(4n), 2n)
- * assert.deepStrictEqual(BigInt.sqrtUnsafe(9n), 3n)
- * assert.deepStrictEqual(BigInt.sqrtUnsafe(16n), 4n)
+ * BigInt.sqrtUnsafe(4n) // => 2n
+ * BigInt.sqrtUnsafe(9n) // => 3n
+ * BigInt.sqrtUnsafe(16n) // => 4n
  * ```
  *
  * @see {@link sqrt} for returning `Option.none` when the input is negative
@@ -1374,13 +1320,13 @@ export declare const sqrtUnsafe: (n: bigint) => bigint;
  *
  * **Example** (Calculating square roots safely)
  *
- * ```ts
- * import { BigInt } from "effect"
+ * ```ts import.meta.vitest
+ * import { BigInt, Option } from "effect"
  *
- * BigInt.sqrt(4n) // Option.some(2n)
- * BigInt.sqrt(9n) // Option.some(3n)
- * BigInt.sqrt(16n) // Option.some(4n)
- * BigInt.sqrt(-1n) // Option.none()
+ * BigInt.sqrt(4n) // => Option.some(2n)
+ * BigInt.sqrt(9n) // => Option.some(3n)
+ * BigInt.sqrt(16n) // => Option.some(4n)
+ * BigInt.sqrt(-1n) // => Option.none()
  * ```
  *
  * @see {@link sqrtUnsafe} for square root computation that throws on negative input
@@ -1399,11 +1345,10 @@ export declare const sqrt: (n: bigint) => Option.Option<bigint>;
  *
  * **Example** (Summing iterable bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.sumAll([2n, 3n, 4n]), 9n)
+ * BigInt.sumAll([2n, 3n, 4n]) // => 9n
  * ```
  *
  * @see {@link sum} for adding two `bigint` values
@@ -1422,11 +1367,10 @@ export declare const sumAll: (collection: Iterable<bigint>) => bigint;
  *
  * **Example** (Multiplying iterable bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigInt.multiplyAll([2n, 3n, 4n]), 24n)
+ * BigInt.multiplyAll([2n, 3n, 4n]) // => 24n
  * ```
  *
  * @see {@link multiply} for multiplying two `bigint` values
@@ -1451,12 +1395,12 @@ export declare const multiplyAll: (collection: Iterable<bigint>) => bigint;
  *
  * **Example** (Converting bigints to numbers)
  *
- * ```ts
- * import { BigInt as BI } from "effect"
+ * ```ts import.meta.vitest
+ * import { BigInt as BI, Option } from "effect"
  *
- * BI.toNumber(42n) // Option.some(42)
- * BI.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + 1n) // Option.none()
- * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // Option.none()
+ * BI.toNumber(42n) // => Option.some(42)
+ * BI.toNumber(9007199254740992n) // => Option.none()
+ * BI.toNumber(-9007199254740992n) // => Option.none()
  * ```
  *
  * @see {@link fromNumber} for converting a safe integer number to `bigint`
@@ -1479,12 +1423,12 @@ export declare const toNumber: (b: bigint) => Option.Option<number>;
  *
  * **Example** (Parsing strings as bigints)
  *
- * ```ts
- * import { BigInt } from "effect"
+ * ```ts import.meta.vitest
+ * import { BigInt, Option } from "effect"
  *
- * BigInt.fromString("42") // Option.some(42n)
- * BigInt.fromString(" ") // Option.none()
- * BigInt.fromString("a") // Option.none()
+ * BigInt.fromString("42") // => Option.some(42n)
+ * BigInt.fromString(" ") // => Option.none()
+ * BigInt.fromString("a") // => Option.none()
  * ```
  *
  * @see {@link BigInt} for native constructor coercion that throws on invalid input
@@ -1508,13 +1452,12 @@ export declare const fromString: (s: string) => Option.Option<bigint>;
  *
  * **Example** (Converting numbers to bigints)
  *
- * ```ts
- * import { BigInt } from "effect"
- *
- * BigInt.fromNumber(42) // Option.some(42n)
+ * ```ts import.meta.vitest
+ * import { BigInt, Option } from "effect"
  *
- * BigInt.fromNumber(Number.MAX_SAFE_INTEGER + 1) // Option.none()
- * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // Option.none()
+ * BigInt.fromNumber(42) // => Option.some(42n)
+ * BigInt.fromNumber(Number.MAX_SAFE_INTEGER + 1) // => Option.none()
+ * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // => Option.none()
  * ```
  *
  * @see {@link toNumber} for converting `bigint` values back to safe integer numbers
@@ -1538,12 +1481,11 @@ export declare function fromNumber(n: number): Option.Option<bigint>;
  *
  * **Example** (Calculating remainders)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { BigInt } from "effect"
  *
- * BigInt.remainder(10n, 3n) // 1n
- *
- * BigInt.remainder(15n, 4n) // 3n
+ * BigInt.remainder(10n, 3n) // => 1n
+ * BigInt.remainder(15n, 4n) // => 3n
  * ```
  *
  * @see {@link divide} for quotient calculation with division-by-zero represented as `Option.none`
@@ -1566,12 +1508,11 @@ export declare const remainder: {
      *
      * **Example** (Calculating remainders)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
      *
-     * BigInt.remainder(10n, 3n) // 1n
-     *
-     * BigInt.remainder(15n, 4n) // 3n
+     * BigInt.remainder(10n, 3n) // => 1n
+     * BigInt.remainder(15n, 4n) // => 3n
      * ```
      *
      * @see {@link divide} for quotient calculation with division-by-zero represented as `Option.none`
@@ -1594,12 +1535,11 @@ export declare const remainder: {
      *
      * **Example** (Calculating remainders)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { BigInt } from "effect"
      *
-     * BigInt.remainder(10n, 3n) // 1n
-     *
-     * BigInt.remainder(15n, 4n) // 3n
+     * BigInt.remainder(10n, 3n) // => 1n
+     * BigInt.remainder(15n, 4n) // => 3n
      * ```
      *
      * @see {@link divide} for quotient calculation with division-by-zero represented as `Option.none`