effect 2.0.0-next.50 → 2.0.0-next.51

package/BigDecimal/dist/effect-BigDecimal.cjs.dev.js

@@ -0,0 +1,914 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Equal_dist_effectEqual = require('../../Equal/dist/effect-Equal.cjs.dev.js');
+var Equivalence_dist_effectEquivalence = require('../../Equivalence/dist/effect-Equivalence.cjs.dev.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.dev.js');
+var Hash_dist_effectHash = require('../../Hash/dist/effect-Hash.cjs.dev.js');
+var Inspectable_dist_effectInspectable = require('../../Inspectable/dist/effect-Inspectable.cjs.dev.js');
+var Option_dist_effectOption = require('../../Option/dist/effect-Option.cjs.dev.js');
+var Order_dist_effectOrder = require('../../Order/dist/effect-Order.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
+require('../../Utils/dist/effect-Utils.cjs.dev.js');
+require('../../Predicate/dist/effect-Predicate.cjs.dev.js');
+require('../../dist/Either-e7500e90.cjs.dev.js');
+require('../../dist/Option-01caa9d4.cjs.dev.js');
+require('../../dist/Effectable-71c10ab9.cjs.dev.js');
+
+/**
+ * This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript.
+ * It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`.
+ *
+ * A `BigDecimal` allows storing any real number to arbitrary precision; which avoids common floating point errors
+ * (such as 0.1 + 0.2 ≠ 0.3) at the cost of complexity.
+ *
+ * Internally, `BigDecimal` uses a `BigInt` object, paired with a 64-bit integer which determines the position of the
+ * decimal point. Therefore, the precision *is not* actually arbitrary, but limited to 2<sup>63</sup> decimal places.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly, as the floating point representation
+ * may be unexpected.
+ *
+ * @since 2.0.0
+ */
+const DEFAULT_PRECISION = 100;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const TypeId = /*#__PURE__*/Symbol.for("effect/BigDecimal");
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+const BigDecimalProto = {
+  [TypeId]: TypeId,
+  [Hash_dist_effectHash.symbol]() {
+    const normalized = normalize(this);
+    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(normalized.value), Hash_dist_effectHash.combine(Hash_dist_effectHash.number(normalized.scale)));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isBigDecimal(that) && equals(this, that);
+  },
+  toString() {
+    return toString(this);
+  },
+  toJSON() {
+    return toString(this);
+  },
+  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
+    return toString(this);
+  },
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+};
+
+/**
+ * Checks if a given value is a `BigDecimal`.
+ *
+ * @param u - The value to check.
+ *
+ * @since 2.0.0
+ * @category guards
+ */
+const isBigDecimal = u => typeof u === "object" && u !== null && TypeId in u;
+
+/**
+ * Creates a `BigDecimal` from a `bigint` value and a scale.
+ *
+ * @param value - The `bigint` value to create a `BigDecimal` from.
+ * @param scale - The scale of the `BigDecimal`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = (value, scale) => {
+  const o = Object.create(BigDecimalProto);
+  o.value = value;
+  o.scale = scale;
+  return o;
+};
+const bigint0 = /*#__PURE__*/BigInt(0);
+const bigint1 = /*#__PURE__*/BigInt(1);
+const bigint10 = /*#__PURE__*/BigInt(10);
+const zero = /*#__PURE__*/make(bigint0, 0);
+
+/**
+ * Normalizes a given `BigDecimal` by removing trailing zeros.
+ *
+ * @param self - The `BigDecimal` to normalize.
+ *
+ * @example
+ * import { normalize, make, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(normalize(unsafeFromString("123.00000")), make(123n, 0))
+ * assert.deepStrictEqual(normalize(unsafeFromString("12300000")), make(123n, -5))
+ *
+ * @since 2.0.0
+ * @category scaling
+ */
+const normalize = self => {
+  if (self.normalized === undefined) {
+    if (self.value === bigint0) {
+      self.normalized = zero;
+    } else {
+      const digits = `${self.value}`;
+      let trail = 0;
+      for (let i = digits.length - 1; i >= 0; i--) {
+        if (digits[i] === "0") {
+          trail++;
+        } else {
+          break;
+        }
+      }
+      if (trail === 0) {
+        self.normalized = self;
+      }
+      const value = BigInt(digits.substring(0, digits.length - trail));
+      const scale = self.scale - trail;
+      self.normalized = make(value, scale);
+    }
+  }
+  return self.normalized;
+};
+
+/**
+ * Scales a given `BigDecimal` to the specified scale.
+ *
+ * If the given scale is smaller than the current scale, the value will be rounded down to
+ * the nearest integer.
+ *
+ * @param self - The `BigDecimal` to scale.
+ * @param scale - The scale to scale to.
+ *
+ * @since 2.0.0
+ * @category scaling
+ */
+const scale = (self, scale) => {
+  if (scale > self.scale) {
+    return make(self.value * bigint10 ** BigInt(scale - self.scale), scale);
+  }
+  if (scale < self.scale) {
+    return make(self.value / bigint10 ** BigInt(self.scale - scale), scale);
+  }
+  return self;
+};
+
+/**
+ * Provides an addition operation on `BigDecimal`s.
+ *
+ * @param self - The first operand.
+ * @param that - The second operand.
+ *
+ * @example
+ * import { sum, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(sum(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("5"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const sum = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
+  if (that.value === bigint0) {
+    return self;
+  }
+  if (self.value === bigint0) {
+    return that;
+  }
+  if (self.scale > that.scale) {
+    return make(scale(that, self.scale).value + self.value, self.scale);
+  }
+  if (self.scale < that.scale) {
+    return make(scale(self, that.scale).value + that.value, that.scale);
+  }
+  return make(self.value + that.value, self.scale);
+});
+
+/**
+ * Provides a multiplication operation on `BigDecimal`s.
+ *
+ * @param self - The first operand.
+ * @param that - The second operand.
+ *
+ * @example
+ * import { multiply, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(multiply(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("6"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const multiply = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
+  if (that.value === bigint0 || self.value === bigint0) {
+    return zero;
+  }
+  return make(self.value * that.value, self.scale + that.scale);
+});
+
+/**
+ * Provides a subtraction operation on `BigDecimal`s.
+ *
+ * @param self - The first operand.
+ * @param that - The second operand.
+ *
+ * @example
+ * import { subtract, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(subtract(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("-1"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const subtract = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
+  if (that.value === bigint0) {
+    return self;
+  }
+  if (self.value === bigint0) {
+    return make(-that.value, that.scale);
+  }
+  if (self.scale > that.scale) {
+    return make(self.value - scale(that, self.scale).value, self.scale);
+  }
+  if (self.scale < that.scale) {
+    return make(scale(self, that.scale).value - that.value, that.scale);
+  }
+  return make(self.value - that.value, self.scale);
+});
+
+/**
+ * Internal function used for arbitrary precision division.
+ */
+const divideWithPrecision = (num, den, scale, precision) => {
+  if (num === bigint0) {
+    return zero;
+  }
+  const numNegative = num < bigint0;
+  const denNegative = den < bigint0;
+  const negateResult = numNegative !== denNegative;
+  num = numNegative ? -num : num;
+  den = denNegative ? -den : den;
+
+  // Shift digits until numerator is larger than denominator (set scale appropriately).
+  while (num < den) {
+    num *= bigint10;
+    scale++;
+  }
+
+  // First division.
+  let quotient = num / den;
+  let remainder = num % den;
+  if (remainder === bigint0) {
+    // No remainder, return immediately.
+    return make(negateResult ? -quotient : quotient, scale);
+  }
+
+  // The quotient is guaranteed to be non-negative at this point. No need to consider sign.
+  let count = `${quotient}`.length;
+
+  // Shift the remainder by 1 decimal; The quotient will be 1 digit upon next division.
+  remainder *= bigint10;
+  while (remainder !== bigint0 && count < precision) {
+    const q = remainder / den;
+    const r = remainder % den;
+    quotient = quotient * bigint10 + q;
+    remainder = r * bigint10;
+    count++;
+    scale++;
+  }
+  if (remainder !== bigint0) {
+    // Round final number with remainder.
+    quotient += roundTerminal(remainder / den);
+  }
+  return make(negateResult ? -quotient : quotient, scale);
+};
+
+/**
+ * Internal function used for rounding.
+ *
+ * Returns 1 if the most significant digit is >= 5, otherwise 0.
+ *
+ * This is used after dividing a number by a power of ten and rounding the last digit.
+ */
+const roundTerminal = n => {
+  if (n === bigint0) {
+    return bigint0;
+  }
+  const pos = n > bigint0 ? 0 : 1;
+  return Number(`${n}`[pos]) < 5 ? bigint0 : bigint1;
+};
+
+/**
+ * Provides a division operation on `BigDecimal`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * If the divisor is `0`, the result will be `None`.
+ *
+ * @param self - The dividend operand.
+ * @param that - The divisor operand.
+ *
+ * @example
+ * import { divide, unsafeFromString } from "effect/BigDecimal"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("3")), some(unsafeFromString("2")))
+ * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("4")), some(unsafeFromString("1.5")))
+ * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("0")), none())
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const divide = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
+  if (that.value === bigint0) {
+    return Option_dist_effectOption.none();
+  }
+  if (self.value === bigint0) {
+    return Option_dist_effectOption.some(zero);
+  }
+  const scale = self.scale - that.scale;
+  if (self.value === that.value) {
+    return Option_dist_effectOption.some(make(bigint1, scale));
+  }
+  return Option_dist_effectOption.some(divideWithPrecision(self.value, that.value, scale, DEFAULT_PRECISION));
+});
+
+/**
+ * Provides an unsafe division operation on `BigDecimal`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * @param self - The dividend operand.
+ * @param that - The divisor operand.as
+ *
+ * @example
+ * import { unsafeDivide, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("3")), unsafeFromString("2"))
+ * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("4")), unsafeFromString("1.5"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const unsafeDivide = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
+  if (that.value === bigint0) {
+    throw new RangeError("Division by zero");
+  }
+  if (self.value === bigint0) {
+    return zero;
+  }
+  const scale = self.scale - that.scale;
+  if (self.value === that.value) {
+    return make(bigint1, scale);
+  }
+  return divideWithPrecision(self.value, that.value, scale, DEFAULT_PRECISION);
+});
+
+/**
+ * @since 2.0.0
+ * @category instances
+ */
+const Order = /*#__PURE__*/Order_dist_effectOrder.make((self, that) => {
+  const scmp = Order_dist_effectOrder.number(sign(self), sign(that));
+  if (scmp !== 0) {
+    return scmp;
+  }
+  if (self.scale > that.scale) {
+    return Order_dist_effectOrder.bigint(self.value, scale(that, self.scale).value);
+  }
+  if (self.scale < that.scale) {
+    return Order_dist_effectOrder.bigint(scale(self, that.scale).value, that.value);
+  }
+  return Order_dist_effectOrder.bigint(self.value, that.value);
+});
+
+/**
+ * Returns `true` if the first argument is less than the second, otherwise `false`.
+ *
+ * @param self - The first argument.
+ * @param that - The second argument.
+ *
+ * @example
+ * import { lessThan, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(lessThan(unsafeFromString("2"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThan(unsafeFromString("3"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(lessThan(unsafeFromString("4"), unsafeFromString("3")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const lessThan = /*#__PURE__*/Order_dist_effectOrder.lessThan(Order);
+
+/**
+ * Checks if a given `BigDecimal` is less than or equal to the provided one.
+ *
+ * @param self - The first `BigDecimal` to compare with.
+ * @param that - The second `BigDecimal` to compare with.
+ *
+ * @example
+ * import { lessThanOrEqualTo, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const lessThanOrEqualTo = /*#__PURE__*/Order_dist_effectOrder.lessThanOrEqualTo(Order);
+
+/**
+ * Returns `true` if the first argument is greater than the second, otherwise `false`.
+ *
+ * @param self - The first argument.
+ * @param that - The second argument.
+ *
+ * @example
+ * import { greaterThan, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("2"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("3"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("4"), unsafeFromString("3")), true)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const greaterThan = /*#__PURE__*/Order_dist_effectOrder.greaterThan(Order);
+
+/**
+ * Checks if a given `BigDecimal` is greater than or equal to the provided one.
+ *
+ * @param self - The first `BigDecimal` to compare with.
+ * @param that - The second `BigDecimal` to compare with.
+ *
+ * @example
+ * import { greaterThanOrEqualTo, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), true)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const greaterThanOrEqualTo = /*#__PURE__*/Order_dist_effectOrder.greaterThanOrEqualTo(Order);
+
+/**
+ * Checks if a `BigDecimal` is between a `minimum` and `maximum` value (inclusive).
+ *
+ * @param self - The `number` to check.
+ * @param minimum - The `minimum` value to check.
+ * @param maximum - The `maximum` value to check.
+ *
+ * @example
+ * import { between, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(between(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("3")), true)
+ * assert.deepStrictEqual(between(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("-1")), false)
+ * assert.deepStrictEqual(between(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("6")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const between = /*#__PURE__*/Order_dist_effectOrder.between(Order);
+
+/**
+ * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values.
+ *
+ * - If the `BigDecimal` is less than the `minimum` value, the function returns the `minimum` value.
+ * - If the `BigDecimal` is greater than the `maximum` value, the function returns the `maximum` value.
+ * - Otherwise, it returns the original `BigDecimal`.
+ *
+ * @param self - The `BigDecimal` to be clamped.
+ * @param minimum - The lower end of the range.
+ * @param maximum - The upper end of the range.
+ *
+ * @example
+ * import { clamp, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(clamp(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("3")), unsafeFromString("3"))
+ * assert.deepStrictEqual(clamp(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("-1")), unsafeFromString("0"))
+ * assert.deepStrictEqual(clamp(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("6")), unsafeFromString("5"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const clamp = /*#__PURE__*/Order_dist_effectOrder.clamp(Order);
+
+/**
+ * Returns the minimum between two `BigDecimal`s.
+ *
+ * @param self - The first `BigDecimal`.
+ * @param that - The second `BigDecimal`.
+ *
+ * @example
+ * import { min, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(min(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("2"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const min = /*#__PURE__*/Order_dist_effectOrder.min(Order);
+
+/**
+ * Returns the maximum between two `BigDecimal`s.
+ *
+ * @param self - The first `BigDecimal`.
+ * @param that - The second `BigDecimal`.
+ *
+ * @example
+ * import { max, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(max(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("3"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const max = /*#__PURE__*/Order_dist_effectOrder.max(Order);
+
+/**
+ * Determines the sign of a given `BigDecimal`.
+ *
+ * @param n - The `BigDecimal` to determine the sign of.
+ *
+ * @example
+ * import { sign, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(sign(unsafeFromString("-5")), -1)
+ * assert.deepStrictEqual(sign(unsafeFromString("0")), 0)
+ * assert.deepStrictEqual(sign(unsafeFromString("5")), 1)
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const sign = n => n.value === bigint0 ? 0 : n.value < bigint0 ? -1 : 1;
+
+/**
+ * Determines the absolute value of a given `BigDecimal`.
+ *
+ * @param n - The `BigDecimal` to determine the absolute value of.
+ *
+ * @example
+ * import { abs, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(abs(unsafeFromString("-5")), unsafeFromString("5"))
+ * assert.deepStrictEqual(abs(unsafeFromString("0")), unsafeFromString("0"))
+ * assert.deepStrictEqual(abs(unsafeFromString("5")), unsafeFromString("5"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const abs = n => n.value < bigint0 ? make(-n.value, n.scale) : n;
+
+/**
+ * Provides a negate operation on `BigDecimal`s.
+ *
+ * @param n - The `BigDecimal` to negate.
+ *
+ * @example
+ * import { negate, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(negate(unsafeFromString("3")), unsafeFromString("-3"))
+ * assert.deepStrictEqual(negate(unsafeFromString("-6")), unsafeFromString("6"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const negate = n => make(-n.value, n.scale);
+
+/**
+ * Returns the remainder left over when one operand is divided by a second operand.
+ *
+ * If the divisor is `0`, the result will be `None`.
+ *
+ * @param self - The dividend.
+ * @param divisor - The divisor.
+ *
+ * @example
+ * import { remainder, unsafeFromString } from "effect/BigDecimal"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(remainder(unsafeFromString("2"), unsafeFromString("2")), some(unsafeFromString("0")))
+ * assert.deepStrictEqual(remainder(unsafeFromString("3"), unsafeFromString("2")), some(unsafeFromString("1")))
+ * assert.deepStrictEqual(remainder(unsafeFromString("-4"), unsafeFromString("2")), some(unsafeFromString("0")))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const remainder = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, divisor) => {
+  if (divisor.value === bigint0) {
+    return Option_dist_effectOption.none();
+  }
+  const max = Math.max(self.scale, divisor.scale);
+  return Option_dist_effectOption.some(make(scale(self, max).value % scale(divisor, max).value, max));
+});
+
+/**
+ * Returns the remainder left over when one operand is divided by a second operand.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * @param self - The dividend.
+ * @param divisor - The divisor.
+ *
+ * @example
+ * import { unsafeRemainder, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("2"), unsafeFromString("2")), unsafeFromString("0"))
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("3"), unsafeFromString("2")), unsafeFromString("1"))
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("-4"), unsafeFromString("2")), unsafeFromString("0"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const unsafeRemainder = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, divisor) => {
+  if (divisor.value === bigint0) {
+    throw new RangeError("Division by zero");
+  }
+  const max = Math.max(self.scale, divisor.scale);
+  return make(scale(self, max).value % scale(divisor, max).value, max);
+});
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Equivalence = /*#__PURE__*/Equivalence_dist_effectEquivalence.make((self, that) => {
+  if (self.scale > that.scale) {
+    return scale(that, self.scale).value === self.value;
+  }
+  if (self.scale < that.scale) {
+    return scale(self, that.scale).value === that.value;
+  }
+  return self.value === that.value;
+});
+
+/**
+ * Checks if two `BigDecimal`s are equal.
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const equals = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Equivalence(self, that));
+
+/**
+ * Creates a `BigDecimal` from a `bigint` value.
+ *
+ * @param value - The `bigint` value to create a `BigDecimal` from.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromBigInt = n => make(n, 0);
+
+/**
+ * Creates a `BigDecimal` from a `number` value.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly,
+ * as the floating point representation may be unexpected.
+ *
+ * @param value - The `number` value to create a `BigDecimal` from.
+ *
+ * @example
+ * import { fromNumber, make } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(fromNumber(123), make(123n, 0))
+ * assert.deepStrictEqual(fromNumber(123.456), make(123456n, 3))
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromNumber = n => {
+  const [lead, trail = ""] = `${n}`.split(".");
+  return make(BigInt(`${lead}${trail}`), trail.length);
+};
+
+/**
+ * Parses a numerical `string` into a `BigDecimal`.
+ *
+ * @param s - The `string` to parse.
+ *
+ * @example
+ * import { fromString, make } from "effect/BigDecimal"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(fromString("123"), some(make(123n, 0)))
+ * assert.deepStrictEqual(fromString("123.456"), some(make(123456n, 3)))
+ * assert.deepStrictEqual(fromString("123.abc"), none())
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromString = s => {
+  let digits;
+  let scale;
+  const dot = s.search(/\./);
+  if (dot !== -1) {
+    const lead = s.slice(0, dot);
+    const trail = s.slice(dot + 1);
+    digits = `${lead}${trail}`;
+    scale = trail.length;
+  } else {
+    digits = s;
+    scale = 0;
+  }
+  if (digits === "") {
+    // TODO: This mimics the BigInt constructor behavior. Should this be `Option.none()`?
+    return Option_dist_effectOption.some(zero);
+  }
+  if (!/^(?:\+|-)?\d+$/.test(digits)) {
+    return Option_dist_effectOption.none();
+  }
+  return Option_dist_effectOption.some(make(BigInt(digits), scale));
+};
+
+/**
+ * Parses a numerical `string` into a `BigDecimal`.
+ *
+ * @param s - The `string` to parse.
+ *
+ * @example
+ * import { unsafeFromString, make } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeFromString("123"), make(123n, 0))
+ * assert.deepStrictEqual(unsafeFromString("123.456"), make(123456n, 3))
+ * assert.throws(() => unsafeFromString("123.abc"))
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unsafeFromString = s => Option_dist_effectOption.getOrThrowWith(fromString(s), () => new Error("Invalid numerical string"));
+
+/**
+ * Formats a given `BigDecimal` as a `string`.
+ *
+ * @param normalized - The `BigDecimal` to format.
+ *
+ * @example
+ * import { toString, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(toString(unsafeFromString("-5")), "-5")
+ * assert.deepStrictEqual(toString(unsafeFromString("123.456")), "123.456")
+ * assert.deepStrictEqual(toString(unsafeFromString("-0.00000123")), "-0.00000123")
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+const toString = n => {
+  const negative = n.value < bigint0;
+  const absolute = negative ? `${n.value}`.substring(1) : `${n.value}`;
+  let before;
+  let after;
+  if (n.scale >= absolute.length) {
+    before = "0";
+    after = "0".repeat(n.scale - absolute.length) + absolute;
+  } else {
+    const location = absolute.length - n.scale;
+    if (location > absolute.length) {
+      const zeros = location - absolute.length;
+      before = `${absolute}${"0".repeat(zeros)}`;
+      after = "";
+    } else {
+      after = absolute.slice(location);
+      before = absolute.slice(0, location);
+    }
+  }
+  const complete = after === "" ? before : `${before}.${after}`;
+  return negative ? `-${complete}` : complete;
+};
+
+/**
+ * Converts a `BigDecimal` to a `number`.
+ *
+ * This function will produce incorrect results if the `BigDecimal` exceeds the 64-bit range of a `number`.
+ *
+ * @param n - The `BigDecimal` to convert.
+ *
+ * @example
+ * import { unsafeToNumber, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeToNumber(unsafeFromString("123.456")), 123.456)
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+const unsafeToNumber = n => Number(toString(n));
+
+/**
+ * Checks if a given `BigDecimal` is an integer.
+ *
+ * @param n - The `BigDecimal` to check.
+ *
+ * @example
+ * import { isInteger, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isInteger(unsafeFromString("0")), true)
+ * assert.deepStrictEqual(isInteger(unsafeFromString("1")), true)
+ * assert.deepStrictEqual(isInteger(unsafeFromString("1.1")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const isInteger = n => normalize(n).scale <= 0;
+
+/**
+ * Checks if a given `BigDecimal` is `0`.
+ *
+ * @param n - The `BigDecimal` to check.
+ *
+ * @example
+ * import { isZero, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isZero(unsafeFromString("0")), true)
+ * assert.deepStrictEqual(isZero(unsafeFromString("1")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const isZero = n => n.value === bigint0;
+
+/**
+ * Checks if a given `BigDecimal` is negative.
+ *
+ * @param n - The `BigDecimal` to check.
+ *
+ * @example
+ * import { isNegative, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isNegative(unsafeFromString("-1")), true)
+ * assert.deepStrictEqual(isNegative(unsafeFromString("0")), false)
+ * assert.deepStrictEqual(isNegative(unsafeFromString("1")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const isNegative = n => n.value < bigint0;
+
+/**
+ * Checks if a given `BigDecimal` is positive.
+ *
+ * @param n - The `BigDecimal` to check.
+ *
+ * @example
+ * import { isPositive, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isPositive(unsafeFromString("-1")), false)
+ * assert.deepStrictEqual(isPositive(unsafeFromString("0")), false)
+ * assert.deepStrictEqual(isPositive(unsafeFromString("1")), true)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const isPositive = n => n.value > bigint0;
+
+exports.Equivalence = Equivalence;
+exports.Order = Order;
+exports.TypeId = TypeId;
+exports.abs = abs;
+exports.between = between;
+exports.clamp = clamp;
+exports.divide = divide;
+exports.equals = equals;
+exports.fromBigInt = fromBigInt;
+exports.fromNumber = fromNumber;
+exports.fromString = fromString;
+exports.greaterThan = greaterThan;
+exports.greaterThanOrEqualTo = greaterThanOrEqualTo;
+exports.isBigDecimal = isBigDecimal;
+exports.isInteger = isInteger;
+exports.isNegative = isNegative;
+exports.isPositive = isPositive;
+exports.isZero = isZero;
+exports.lessThan = lessThan;
+exports.lessThanOrEqualTo = lessThanOrEqualTo;
+exports.make = make;
+exports.max = max;
+exports.min = min;
+exports.multiply = multiply;
+exports.negate = negate;
+exports.normalize = normalize;
+exports.remainder = remainder;
+exports.scale = scale;
+exports.sign = sign;
+exports.subtract = subtract;
+exports.sum = sum;
+exports.toString = toString;
+exports.unsafeDivide = unsafeDivide;
+exports.unsafeFromString = unsafeFromString;
+exports.unsafeRemainder = unsafeRemainder;
+exports.unsafeToNumber = unsafeToNumber;