atomic-fns 1.1.7 → 2.0.0

package/dist/decimal/index.d.ts

@@ -1,148 +1,14 @@
 /**
- * `Decimal` provides support for correct rounded floating point arithmetic.
+ * Exact decimal arithmetic shaped after the TC39 Decimal draft, with Currency.
  *
- * @module decimal
- */
-/**
- * Casts the given value as a {@link Decimal}.
- */
-export declare function decimal(x: any): Decimal;
-/**
- * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard
- * `Number` type. It also supports user-defined precision (default is 20 decimal places), which
- * can be as large as needed.
+ * @example
+ * ```ts
+ * import { Decimal } from 'atomic-fns/decimal'
+ *
+ * new Decimal('0.1').add('0.2').toString() // '0.3'
+ * ```
+ * @module
  */
-export declare class Decimal {
-    static PRECISION: number;
-    private i;
-    private e;
-    /**
-     * Returns a new `Decimal` instance from the value or `0`.
-     * @param {*} value
-     * @returns {Decimal}
-     */
-    constructor(value?: any);
-    /**
-     * Returns a new `Decimal` that has the opposite sign of this `Decimal`.
-     * @example
-  ```js
-  let a = decimal('5')
-  a.negated()  // -5
-  ```
-     * @returns {Decimal}
-     */
-    negated(): Decimal;
-    /**
-     * Returns a new `Decimal` that is the sum of this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('50000000000')
-  let b = decimal('0.000000005')
-  a.add(b)  // 50000000000.000000005
-  ```
-     * @returns {Decimal}
-     */
-    add(x: any): Decimal;
-    /**
-     * Returns a new `Decimal` that is the difference between this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('1')
-  let b = decimal('0.0000000000000000001')
-  a.sub(b)  // 0.9999999999999999999
-  ```
-     * @returns {Decimal}
-     */
-    sub(x: any): Decimal;
-    /**
-     * Returns a new `Decimal` that is the product of this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('0.0000000000000000000025')
-  let b = decimal('400000000000000000000')
-  a.mul(b)  // 1
-  ```
-     * @returns {Decimal}
-     */
-    mul(x: any): Decimal;
-    /**
-     * Returns a new `Decimal` that is the quotient of this and `x`
-     * @param x
-     * @example
-  ```js
-  let a = decimal('1')
-  let b = decimal('3')
-  a.div(b)  // 0.333333333333333333333333333333
-  ```
-     * @returns {Decimal}
-     */
-    div(x: Decimal | string | number): Decimal;
-    /**
-     * Returns the square root of this `Decimal`.
-     * @returns {TDecimal}
-     */
-    sqrt(): Decimal;
-    /** Returns a new copy of this Decimal value. */
-    clone(): Decimal;
-    /**
-     * Remove zeroes in the least-significant digit of this `Decimal`
-     */
-    private _normalize;
-    /**
-     * Truncate this `Decimal` to the configured precision
-     */
-    private _truncate;
-    /**
-     * Returns a string representation of this decimal.
-     */
-    toString(): string;
-    /**
-     * Converts this decimal to the `Number` value
-     * @returns {number}
-     */
-    toNumber(): number;
-    static get precision(): number;
-    static set precision(value: number);
-    /**
-     * Returns `true` if this value is equal to the value of `x`, otherwise `false`.
-     * @param {*} x other
-     * @returns {boolean}
-     */
-    eq(x: any): boolean;
-    /**
-     * Returns `true` if this value is less than the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    lt(x: any): boolean;
-    /**
-     * Returns a comparison value representing the ordering of this value in respect to `x`.
-     *   * `-1` if this < x
-     *   * `1` if this > x
-     *   * `0` if this == x
-     * @param {*} x
-     * @returns {number}
-     */
-    compare(x: any): 0 | 1 | -1;
-    /**
-     * Returns `true` if this value is greater than the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    gt(x: any): boolean;
-    /**
-     * Returns `true` if this value is less than or equal to the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    lte(x: any): boolean;
-    /**
-     * Returns `true` if this value is greater than or equal to the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    gte(x: any): boolean;
-}
+export { Currency } from './currency.js';
+export { Decimal } from './decimal.js';
+export type { DecimalInput, DivideOptions, RoundingMode } from './decimal.js';

package/dist/decimal/index.js

@@ -1,377 +1,13 @@
 /**
- * `Decimal` provides support for correct rounded floating point arithmetic.
+ * Exact decimal arithmetic shaped after the TC39 Decimal draft, with Currency.
  *
- * @module decimal
- */
-const NUMBER_REGEX = /^(-?)([0-9]+)(\.([0-9]+))?$/;
-/**
- * Casts the given value as a {@link Decimal}.
- */
-export function decimal(x) {
-    return new Decimal(x);
-}
-/**
- * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard
- * `Number` type. It also supports user-defined precision (default is 20 decimal places), which
- * can be as large as needed.
+ * @example
+ * ```ts
+ * import { Decimal } from 'atomic-fns/decimal'
+ *
+ * new Decimal('0.1').add('0.2').toString() // '0.3'
+ * ```
+ * @module
  */
-export class Decimal {
-    static PRECISION = 20;
-    i = 0n;
-    e = 0;
-    /**
-     * Returns a new `Decimal` instance from the value or `0`.
-     * @param {*} value
-     * @returns {Decimal}
-     */
-    constructor(value) {
-        if (value == null) {
-            return this;
-        }
-        // Check if value is a Decimal like
-        if (typeof value?.i === 'bigint' && typeof value.e === 'number') {
-            this.i = value.i;
-            this.e = value.e;
-            this._normalize();
-            return this;
-        }
-        const result = NUMBER_REGEX.exec(value.toString());
-        if (result) {
-            // console.log(result);
-            // Construct from string if possible
-            // this.i = parseInt(result[1] + result[2] + result[4]);
-            if (typeof result[2] === 'undefined')
-                result[2] = '';
-            if (typeof result[4] === 'undefined')
-                result[4] = '';
-            this.i = BigInt(result[1] + result[2] + result[4]);
-            this.e = result[4] ? -result[4].length : 0;
-            this._normalize();
-        }
-        else {
-            // Conversion to string failed, so construct from number
-            let m = 1n;
-            if (value < 0) {
-                value = -value;
-                m = -1n;
-            }
-            if (value === 0) {
-                this.i = 0n;
-                this.e = 0;
-            }
-            else {
-                // Multiply the number by 10 until it is an integer
-                let e = -Math.floor(Math.log10(value));
-                if (e > 0) {
-                    value *= Math.pow(10, e);
-                }
-                else {
-                    e = 0;
-                }
-                while (value !== Math.round(value)) {
-                    e++;
-                    value *= 10;
-                }
-                // Divide the number by 10 until the one's digit is non-zero
-                while (value % 10 === 0 && value > 0) {
-                    e--;
-                    value /= 10;
-                }
-                value = BigInt(value);
-                this.i = value * m;
-                this.e = -e;
-            }
-        }
-    }
-    /**
-     * Returns a new `Decimal` that has the opposite sign of this `Decimal`.
-     * @example
-  ```js
-  let a = decimal('5')
-  a.negated()  // -5
-  ```
-     * @returns {Decimal}
-     */
-    negated() {
-        const negated = new Decimal();
-        negated.i = -this.i;
-        negated.e = this.e;
-        return negated;
-    }
-    /**
-     * Returns a new `Decimal` that is the sum of this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('50000000000')
-  let b = decimal('0.000000005')
-  a.add(b)  // 50000000000.000000005
-  ```
-     * @returns {Decimal}
-     */
-    add(x) {
-        let a = new Decimal(this);
-        let b = new Decimal(x);
-        // a+b = a.i * 10^a.e + b.i * 10^b.e
-        // a+b = ( a.i * 10^(a.e-b.e) + b.i ) * 10^b.e
-        const result = new Decimal();
-        // Order arguments so that a.e >= b.e
-        if (a.e < b.e) {
-            const c = a;
-            a = b;
-            b = c;
-        }
-        const intPart = exp(a.i, a.e - b.e);
-        result.i = intPart + b.i;
-        result.e = b.e;
-        result._normalize();
-        return result;
-    }
-    /**
-     * Returns a new `Decimal` that is the difference between this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('1')
-  let b = decimal('0.0000000000000000001')
-  a.sub(b)  // 0.9999999999999999999
-  ```
-     * @returns {Decimal}
-     */
-    sub(x) {
-        return this.add(decimal(x).negated());
-    }
-    /**
-     * Returns a new `Decimal` that is the product of this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('0.0000000000000000000025')
-  let b = decimal('400000000000000000000')
-  a.mul(b)  // 1
-  ```
-     * @returns {Decimal}
-     */
-    mul(x) {
-        const a = new Decimal(this);
-        const b = new Decimal(x);
-        // a * b = (a.i * b.i) * 10^(a.e + b.e)
-        const result = new Decimal();
-        result.i = a.i * b.i;
-        result.e = a.e + b.e;
-        result._normalize();
-        return result;
-    }
-    /**
-     * Returns a new `Decimal` that is the quotient of this and `x`
-     * @param x
-     * @example
-  ```js
-  let a = decimal('1')
-  let b = decimal('3')
-  a.div(b)  // 0.333333333333333333333333333333
-  ```
-     * @returns {Decimal}
-     */
-    div(x) {
-        const a = new Decimal(this);
-        const b = new Decimal(x);
-        // We need to increase the number of digits of a and b so that a / b will have the desired precision.
-        // In order for the integer quotient to have the correct precision, a.e - b.e must be greater than that precision.
-        // So we need only to increase a.e.
-        // TODO: Revisit the value of increaseA. Is it correct in every circumstance?
-        const increaseA = Math.max(Decimal.precision - (a.e + b.e), 0);
-        const intIncrease = new Decimal();
-        intIncrease.i = exp(a.i, increaseA);
-        const quotient = new Decimal();
-        quotient.i = intIncrease.i / b.i;
-        quotient.e = a.e - b.e - increaseA;
-        // No need to truncate since we already increased the number of digits before dividing
-        quotient._normalize();
-        return quotient;
-    }
-    /**
-     * Returns the square root of this `Decimal`.
-     * @returns {TDecimal}
-     */
-    sqrt() {
-        Decimal.PRECISION++;
-        // Let the guess value be 10^(e/2), where e is this.e
-        let x = new Decimal();
-        x.i = 1n;
-        x.e = Math.floor(this.e / 2);
-        const onehalf = new Decimal('0.5');
-        let xt = x.clone();
-        xt._truncate();
-        xt._normalize();
-        let lastxt;
-        let i;
-        for (i = 0; i < 100; i++) {
-            lastxt = xt;
-            x = this.div(x).add(x).mul(onehalf);
-            xt = x.clone();
-            xt._truncate();
-            xt._normalize();
-            if (xt.i === lastxt.i && xt.e === lastxt.e)
-                break;
-        }
-        if (i >= 100) {
-            console.log('Warning: sqrt exceeded maximum iterations. (Did it enter a cycle?)');
-        }
-        Decimal.PRECISION--;
-        xt._truncate();
-        xt._normalize();
-        return xt;
-    }
-    /** Returns a new copy of this Decimal value. */
-    clone() {
-        const a = new Decimal();
-        a.i = this.i;
-        a.e = this.e;
-        return a;
-    }
-    /**
-     * Remove zeroes in the least-significant digit of this `Decimal`
-     */
-    _normalize() {
-        while (this.i % 10n === 0n && this.i !== 0n) {
-            this.i /= 10n;
-            this.e++;
-        }
-        return this;
-    }
-    /**
-     * Truncate this `Decimal` to the configured precision
-     */
-    _truncate() {
-        // TODO: Make this better
-        // TODO: Rounding
-        const trunc = -this.e - Decimal.PRECISION;
-        if (trunc > 0) {
-            this.i /= 10n ** BigInt(trunc - 1);
-            this.e += trunc;
-            const nextDigit = this.i % 10n;
-            if (nextDigit >= 5) {
-                this.i += 10n;
-            }
-            this.i /= 10n;
-        }
-        // while(-this.e > Decimal.PRECISION) {
-        //   this.i /= 10n;
-        //   this.e++;
-        // }
-        return this;
-    }
-    /**
-     * Returns a string representation of this decimal.
-     */
-    toString() {
-        let s = this.i.toString();
-        let m = '';
-        if (s[0] === '-') {
-            s = s.substring(1, s.length);
-            m = '-';
-        }
-        if (this.e > 0) {
-            return m + s + '0'.repeat(this.e);
-        }
-        else if (this.e < 0) {
-            if (-this.e >= s.length) {
-                return m + '0.' + '0'.repeat(-this.e - s.length) + s;
-            }
-            return m + s.slice(0, s.length + this.e) + '.' + s.slice(s.length + this.e, s.length);
-        }
-        else {
-            return m + s;
-        }
-    }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.toString();
-    }
-    /**
-     * Converts this decimal to the `Number` value
-     * @returns {number}
-     */
-    toNumber() {
-        return Number(Decimal.prototype.toString.call(this));
-    }
-    static get precision() {
-        return Decimal.PRECISION;
-    }
-    static set precision(value) {
-        Decimal.PRECISION = value;
-    }
-    /**
-     * Returns `true` if this value is equal to the value of `x`, otherwise `false`.
-     * @param {*} x other
-     * @returns {boolean}
-     */
-    eq(x) {
-        const other = decimal(x);
-        return this.i === other.i && this.e === other.e;
-    }
-    /**
-     * Returns `true` if this value is less than the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    lt(x) {
-        const other = decimal(x);
-        if (this.e === other.e)
-            return this.i < other.i;
-        const e = this.e - other.e;
-        if (e > 0) {
-            return exp(this.i, e) < other.i;
-        }
-        return this.i < exp(other.i, -e);
-    }
-    /**
-     * Returns a comparison value representing the ordering of this value in respect to `x`.
-     *   * `-1` if this < x
-     *   * `1` if this > x
-     *   * `0` if this == x
-     * @param {*} x
-     * @returns {number}
-     */
-    compare(x) {
-        if (this.eq(x))
-            return 0;
-        if (this.lt(x))
-            return -1;
-        return 1;
-    }
-    /**
-     * Returns `true` if this value is greater than the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    gt(x) {
-        return this.compare(x) > 0;
-    }
-    /**
-     * Returns `true` if this value is less than or equal to the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    lte(x) {
-        return this.compare(x) <= 0;
-    }
-    /**
-     * Returns `true` if this value is greater than or equal to the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    gte(x) {
-        return this.compare(x) >= 0;
-    }
-}
-/** Returns a BigInt that is equal to `i` times `10^e` */
-function exp(i, e) {
-    // TODO: Make this better
-    // The implementation is faster than 10n ** BigInt(e). But could we make it faster still?
-    let ii = i;
-    for (let j = 0; j < e; j++) {
-        ii *= 10n;
-    }
-    return ii;
-}
+export { Currency } from './currency.js';
+export { Decimal } from './decimal.js';

package/dist/decimal/internal/bits.d.ts

@@ -0,0 +1,2 @@
+/** Bit length of a non-negative bigint (0 for 0n), read from its hex form, not its binary one. */
+export declare function bitLength(n: bigint): number;

package/dist/decimal/internal/bits.js

@@ -0,0 +1,7 @@
+/** Bit length of a non-negative bigint (0 for 0n), read from its hex form, not its binary one. */
+export function bitLength(n) {
+    if (n === 0n)
+        return 0;
+    const hex = n.toString(16);
+    return (hex.length - 1) * 4 + (32 - Math.clz32(parseInt(hex[0], 16)));
+}

package/dist/decimal/internal/echo.d.ts

@@ -0,0 +1,4 @@
+/** UTF-16 units of bad input an error message repeats. */
+export declare const MAX_ECHO = 40;
+/** `value` quoted and cut to {@link MAX_ECHO} units. */
+export declare function quoteForError(value: string): string;

package/dist/decimal/internal/echo.js

@@ -0,0 +1,6 @@
+/** UTF-16 units of bad input an error message repeats. */
+export const MAX_ECHO = 40;
+/** `value` quoted and cut to {@link MAX_ECHO} units. */
+export function quoteForError(value) {
+    return `${JSON.stringify(value.slice(0, MAX_ECHO))}${value.length > MAX_ECHO ? '...' : ''}`;
+}

package/dist/decimal/internal/isqrt.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Floor integer square root via precision doubling.
+ * Below 2^52 uses `Math.sqrt` with an exact fix-up; larger n recurse on
+ * `n >> 2k` then one Newton step and one +-1 correction.
+ */
+export declare function isqrtRoot(n: bigint): {
+    root: bigint;
+    exact: boolean;
+};

package/dist/decimal/internal/isqrt.js

@@ -0,0 +1,34 @@
+import { bitLength } from './bits.js';
+/**
+ * Adjust `x` so `x*x <= n < (x+1)*(x+1)` (one +-1 step).
+ * Returns the root and whether `x*x === n` (avoids a second full square in callers).
+ */
+function isqrtFix(x, n) {
+    let y = x;
+    let y2 = y * y;
+    // Newton / Math.sqrt estimate is within 1 of the true floor root.
+    if (y2 > n) {
+        y--;
+        y2 = y * y;
+    }
+    else if (y2 + ((y << 1n) + 1n) <= n) {
+        y++;
+        y2 = y * y;
+    }
+    return { root: y, exact: y2 === n };
+}
+/**
+ * Floor integer square root via precision doubling.
+ * Below 2^52 uses `Math.sqrt` with an exact fix-up; larger n recurse on
+ * `n >> 2k` then one Newton step and one +-1 correction.
+ */
+export function isqrtRoot(n) {
+    if (n <= 1n)
+        return { root: n, exact: true };
+    if (n < 1n << 52n) {
+        return isqrtFix(BigInt(Math.floor(Math.sqrt(Number(n)))), n);
+    }
+    const k = Math.floor(bitLength(n) / 4);
+    const r = isqrtRoot(n >> BigInt(2 * k)).root << BigInt(k);
+    return isqrtFix((r + n / r) >> 1n, n);
+}

package/dist/decimal/internal/locale.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Canonical tags for `locales`; an empty list means the runtime's locale.
+ * @throws {TypeError} for an entry that is neither a string nor an `Intl.Locale`.
+ * @throws {RangeError} for a list longer than 255 characters, which the engine canonicalizes in
+ * quadratic time, or a malformed tag.
+ */
+export declare function canonicalLocales(locales: Intl.LocalesArgument): string[];

package/dist/decimal/internal/locale.js

@@ -0,0 +1,24 @@
+/** Longest locale list, joined, that `Intl` is asked to canonicalize. */
+const MAX_LOCALE_LENGTH = 255;
+/**
+ * Canonical tags for `locales`; an empty list means the runtime's locale.
+ * @throws {TypeError} for an entry that is neither a string nor an `Intl.Locale`.
+ * @throws {RangeError} for a list longer than 255 characters, which the engine canonicalizes in
+ * quadratic time, or a malformed tag.
+ */
+export function canonicalLocales(locales) {
+    if (locales === undefined)
+        return [];
+    const entries = Array.isArray(locales) ? locales : [locales];
+    const tags = entries.map((entry) => {
+        if (typeof entry === 'string')
+            return entry;
+        if (entry instanceof Intl.Locale)
+            return entry.toString();
+        throw new TypeError('locale must be a string or an Intl.Locale');
+    });
+    if (tags.join().length > MAX_LOCALE_LENGTH) {
+        throw new RangeError(`locale is longer than ${String(MAX_LOCALE_LENGTH)} characters`);
+    }
+    return Intl.getCanonicalLocales(tags);
+}

package/dist/decimal/internal/minor-units.d.ts

@@ -0,0 +1,2 @@
+/** The ISO 4217 minor-unit digits of an upper-case `code`, or undefined when it has none. */
+export declare function isoMinorUnits(code: string): number | undefined;

package/dist/decimal/internal/minor-units.js

@@ -0,0 +1,33 @@
+/**
+ * Active ISO 4217 codes by minor-unit digits, from the ISO 4217 list one published 2026-09-17.
+ * Codes the list gives no minor unit (XAU, XDR, XXX and the other funds and metals) are absent.
+ * `Intl` cannot stand in: it reports CLDR display digits, which differ from ISO 4217 (0 for IQD
+ * and HUF) and change with the runtime's ICU version.
+ */
+const CODES_BY_MINOR_UNITS = [
+    [0, 'BIF CLP DJF GNF ISK JPY KMF KRW PYG RWF UGX UYI VND VUV XAF XOF XPF'],
+    [
+        2,
+        'AED AFN ALL AMD AOA ARS AUD AWG AZN BAM BBD BDT BMD BND BOB BOV BRL BSD BTN BWP BYN ' +
+            'BZD CAD CDF CHE CHF CHW CNY COP COU CRC CUP CVE CZK DKK DOP DZD EGP ERN ETB EUR FJD ' +
+            'FKP GBP GEL GHS GIP GMD GTQ GYD HKD HNL HTG HUF IDR ILS INR IRR JMD KES KGS KHR KPW ' +
+            'KYD KZT LAK LBP LKR LRD LSL MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR MWK MXN MXV MYR ' +
+            'MZN NAD NGN NIO NOK NPR NZD PAB PEN PGK PHP PKR PLN QAR RON RSD RUB SAR SBD SCR SDG ' +
+            'SEK SGD SHP SLE SOS SRD SSP STN SVC SYP SZL THB TJS TMT TOP TRY TTD TWD TZS UAH USD ' +
+            'USN UYU UZS VED VES WST XAD XCD XCG YER ZAR ZMW ZWG'
+    ],
+    [3, 'BHD IQD JOD KWD LYD OMR TND'],
+    [4, 'CLF UYW']
+];
+let minorUnits;
+/** The ISO 4217 minor-unit digits of an upper-case `code`, or undefined when it has none. */
+export function isoMinorUnits(code) {
+    if (minorUnits === undefined) {
+        minorUnits = new Map();
+        for (const [digits, codes] of CODES_BY_MINOR_UNITS) {
+            for (const listed of codes.split(' '))
+                minorUnits.set(listed, digits);
+        }
+    }
+    return minorUnits.get(code);
+}