atomic-fns 1.1.2 → 1.1.4

package/dist/globals/decimal.js

@@ -1,371 +0,0 @@
-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.
- */
-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.minus()  // -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.
-     * @returns {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;
-}

package/dist/i18n/date/format.d.ts

@@ -1,16 +0,0 @@
-/**
- * Returns a new Date from the given arguments.
- * @param {string | number | Date} date The date value
- * @param {?boolean} [utc=false] Interprets the given value as a UTC date
- * @returns {Date} The new date object
- */
-export declare function getDate(date: string | number | Date, utc?: boolean): Date;
-/**
- * Formats a date using a formatting string in the {@link https://strftime.org/ strftime} format, in any given locale.
- * @param {string} fmt The format string to apply
- * @param {number | Date} date The date value
- * @param {?string} locale The locale to use when formatting (default is system locale).
- * @returns {string} The string representation of date
- * @see {@link https://strftime.org/ strftime format}
- */
-export declare function format(fmt: string, date: number | Date, locale?: any): string;

package/dist/i18n/date/format.js

@@ -1,313 +0,0 @@
-const NATIVE_DATE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
-/**
- * Returns a new Date from the given arguments.
- * @param {string | number | Date} date The date value
- * @param {?boolean} [utc=false] Interprets the given value as a UTC date
- * @returns {Date} The new date object
- */
-export function getDate(date, utc = false) {
-    if (date === null)
-        return new Date(NaN);
-    if (!date)
-        return new Date();
-    if (date instanceof Date)
-        return new Date(date);
-    if (typeof date === 'string' && !/Z$/i.test(date)) {
-        const d = date.match(NATIVE_DATE);
-        if (d) {
-            const m = d[2] - 1 || 0;
-            const ms = (d[7] || '0').slice(0, 3);
-            if (utc) {
-                return new Date(Date.UTC(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms));
-            }
-            return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
-        }
-    }
-    return new Date(date);
-}
-const n = 'numeric';
-const s = 'short';
-const l = 'long';
-const dd = '2-digit';
-const TOKEN_MAP = {
-    // weekday
-    '%A': { weekday: l },
-    '%a': { weekday: s },
-    '%aa': { weekday: n },
-    // day
-    '%d': { day: dd },
-    '%-d': { day: n },
-    // month
-    '%m': { month: dd },
-    '%-m': { month: n },
-    '%B': { month: l },
-    '%b': { month: s },
-    '%bb': { month: n },
-    // year
-    '%y': { year: n },
-    '%Y': { year: dd },
-    // hour
-    '%K': { hourCycle: 'h11', hour: dd },
-    '%I': { hourCycle: 'h12', hour: dd },
-    '%-I': { hourCycle: 'h12', hour: n },
-    '%H': { hourCycle: 'h23', hour: dd },
-    '%-H': { hourCycle: 'h23', hour: n },
-    '%k': { hourCycle: 'h24', hour: n },
-    // minutes
-    '%M': { minute: dd },
-    '%-M': { minute: n },
-    // seconds
-    '%S': { second: dd },
-    '%-S': { second: n },
-    // day period
-    '%P': { dayPeriod: l },
-    '%p': { dayPeriod: s },
-    '%pp': { dayPeriod: 'narrow' },
-    // era
-    '%N': { era: l, year: dd },
-    '%n': { era: s, year: dd },
-    '%nn': { era: n, year: 'narrow' },
-    // timeZoneName
-    '%Z': { timeZoneName: 'longGeneric', year: dd },
-    '%-Z': { timeZoneName: 'shortGeneric', year: dd },
-    '%z': { timeZoneName: 'longOffset', year: dd },
-    '%-z': { timeZoneName: 'shortOffset', year: dd },
-    '%ZZ': { timeZoneName: l, year: dd },
-    '%-ZZ': { timeZoneName: s, year: dd }
-};
-const HOUR_PARTS = { '%I': 1, '%-I': 1, '%K': 1, '%k': 1 };
-const ERA_PARTS = { '%n': 1, '%N': 1, '%nn': 1 };
-const TZ_PARTS = { '%ZZ': 1, '%-ZZ': 1, '%-z': 1, '%z': 1, '%-Z': 1, '%Z': 1 };
-const formatter = (locale, opts) => new Intl.DateTimeFormat(locale, opts);
-/**
- * Formats a date using a formatting string in the {@link https://strftime.org/ strftime} format, in any given locale.
- * @param {string} fmt The format string to apply
- * @param {number | Date} date The date value
- * @param {?string} locale The locale to use when formatting (default is system locale).
- * @returns {string} The string representation of date
- * @see {@link https://strftime.org/ strftime format}
- */
-export function format(fmt, date, locale) {
-    const results = [];
-    let dayPeriod = '';
-    let dayPeriodIndex = -1;
-    for (let i = 0; i < fmt.length; i++) {
-        let part = fmt[i];
-        if (part === '%') {
-            // check for escaped '%'
-            if (fmt[++i] === '%') {
-                results.push('%');
-                continue;
-            }
-            if (fmt[i] === '-') {
-                part += fmt[i++];
-            }
-            part += fmt[i];
-            // add any repeated characters that come after
-            while (i < fmt.length - 1 && fmt[i + 1] === fmt[i])
-                part += fmt[++i];
-            if (HOUR_PARTS[part]) {
-                const res = formatter(locale, TOKEN_MAP[part]).format(date).split(' ');
-                // save the AM/PM for the correct spot
-                results.push(res[0]);
-                dayPeriod = res[1];
-                continue;
-            }
-            if (part === '%P' || part === '%p') {
-                // leave this flag in place for later
-                dayPeriodIndex = results.length;
-                results.push(part);
-                continue;
-            }
-            if (ERA_PARTS[part] || TZ_PARTS[part]) {
-                // the formatting includes the date/year so we take what comes after
-                const res = formatter(locale, TOKEN_MAP[part]).format(date).split(' ');
-                results.push(res.slice(1).join(' '));
-                continue;
-            }
-            // format any other parts
-            let res = formatter(locale, TOKEN_MAP[part]).format(date);
-            if (part === '%S' && res.length === 1)
-                res = '0' + res;
-            results.push(res);
-        }
-        else {
-            // output as literal
-            results.push(part);
-        }
-    }
-    // insert the AM/PM at the correct spot
-    if (dayPeriodIndex >= 0)
-        results[dayPeriodIndex] = dayPeriod || '';
-    return results.join('');
-}
-const DATETIME_DEFAULT = {};
-/** 10/14/1983 */
-const DATE_SHORT = {
-    year: n,
-    month: n,
-    day: n
-};
-/** Oct 14, 1983 */
-const DATE_MED = {
-    year: n,
-    month: s,
-    day: n
-};
-/** Fri, Oct 14, 1983 */
-const DATE_MED_WITH_WEEKDAY = {
-    year: n,
-    month: s,
-    day: n,
-    weekday: s
-};
-/** October 14, 1983 */
-const DATE_FULL = {
-    year: n,
-    month: l,
-    day: n
-};
-/** Tuesday, October 14, 1983 */
-const DATE_HUGE = {
-    year: n,
-    month: l,
-    day: n,
-    weekday: l
-};
-/** 09:30 AM */
-const TIME_SIMPLE = {
-    hour: n,
-    minute: n
-};
-/** 09:30:23 AM */
-const TIME_WITH_SECONDS = {
-    hour: n,
-    minute: n,
-    second: n
-};
-/** 09:30:23 AM EDT */
-const TIME_WITH_SHORT_OFFSET = {
-    hour: n,
-    minute: n,
-    second: n,
-    timeZoneName: s
-};
-/** 09:30:23 AM Eastern Daylight Time */
-const TIME_WITH_LONG_OFFSET = {
-    hour: n,
-    minute: n,
-    second: n,
-    timeZoneName: l
-};
-/** 09:30 */
-const TIME_24_SIMPLE = {
-    hour: n,
-    minute: n,
-    hourCycle: 'h23'
-};
-/** 09:30:23 */
-const TIME_24_WITH_SECONDS = {
-    hour: n,
-    minute: n,
-    second: n,
-    hourCycle: 'h23'
-};
-/** 09:30:23 EDT */
-const TIME_24_WITH_SHORT_OFFSET = {
-    hour: n,
-    minute: n,
-    second: n,
-    hourCycle: 'h23',
-    timeZoneName: s
-};
-/** 09:30:23 Eastern Daylight Time */
-const TIME_24_WITH_LONG_OFFSET = {
-    hour: n,
-    minute: n,
-    second: n,
-    hourCycle: 'h23',
-    timeZoneName: l
-};
-/** 10/14/1983, 9:30 AM */
-const DATETIME_SHORT = {
-    year: n,
-    month: n,
-    day: n,
-    hour: n,
-    minute: n
-};
-/** 10/14/1983, 9:30:33 AM */
-const DATETIME_SHORT_WITH_SECONDS = {
-    year: n,
-    month: n,
-    day: n,
-    hour: n,
-    minute: n,
-    second: n
-};
-/** Oct 14, 1983, 9:30 AM */
-const DATETIME_MED = {
-    year: n,
-    month: s,
-    day: n,
-    hour: n,
-    minute: n
-};
-/** Oct 14, 1983, 9:30:33 AM */
-const DATETIME_MED_WITH_SECONDS = {
-    year: n,
-    month: s,
-    day: n,
-    hour: n,
-    minute: n,
-    second: n
-};
-/** Fri, 14 Oct 1983, 9:30 AM */
-const DATETIME_MED_WITH_WEEKDAY = {
-    year: n,
-    month: s,
-    day: n,
-    weekday: s,
-    hour: n,
-    minute: n
-};
-/** October 14, 1983, 9:30 AM EDT */
-const DATETIME_FULL = {
-    year: n,
-    month: l,
-    day: n,
-    hour: n,
-    minute: n,
-    timeZoneName: s
-};
-/** October 14, 1983, 9:30:33 AM EDT */
-const DATETIME_FULL_WITH_SECONDS = {
-    year: n,
-    month: l,
-    day: n,
-    hour: n,
-    minute: n,
-    second: n,
-    timeZoneName: s
-};
-/** Friday, October 14, 1983, 9:30 AM Eastern Daylight Time */
-const DATETIME_HUGE = {
-    year: n,
-    month: l,
-    day: n,
-    weekday: l,
-    hour: n,
-    minute: n,
-    timeZoneName: l
-};
-/** Friday, October 14, 1983, 9:30:33 AM Eastern Daylight Time */
-const DATETIME_HUGE_WITH_SECONDS = {
-    year: n,
-    month: l,
-    day: n,
-    weekday: l,
-    hour: n,
-    minute: n,
-    second: n,
-    timeZoneName: l
-};