atomic-fns 1.1.7 → 1.2.0

package/dist/decimal/index.js

@@ -3,7 +3,10 @@
  *
  * @module decimal
  */
-const NUMBER_REGEX = /^(-?)([0-9]+)(\.([0-9]+))?$/;
+import { ValueError } from '../globals/index.js';
+const NUMBER_REGEX = /^\s*([+-]?)(?=\.?[0-9])([0-9]*)(\.([0-9]*))?(?:[eE]([+-]?[0-9]+))?\s*$/;
+/** Largest power of ten an exponent may reach, so a short string cannot freeze the page. */
+const MAX_EXPONENT = 10_000;
 /**
  * Casts the given value as a {@link Decimal}.
  */
@@ -23,6 +26,8 @@ export class Decimal {
      * Returns a new `Decimal` instance from the value or `0`.
      * @param {*} value
      * @returns {Decimal}
+     * @throws {ValueError} if the value is not numeric.
+     * @throws {RangeError} if the value is infinite or its exponent is past 10,000.
      */
     constructor(value) {
         if (value == null) {
@@ -35,7 +40,8 @@ export class Decimal {
             this._normalize();
             return this;
         }
-        const result = NUMBER_REGEX.exec(value.toString());
+        const text = value.toString();
+        const result = NUMBER_REGEX.exec(text);
         if (result) {
             // console.log(result);
             // Construct from string if possible
@@ -45,11 +51,22 @@ export class Decimal {
             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.e = Number(result[5] ?? 0) - result[4].length;
             this._normalize();
+            if (result[5]) {
+                const magnitude = this.e + (this.i < 0n ? -this.i : this.i).toString().length - 1;
+                if (this.i === 0n)
+                    this.e = 0;
+                else if (Math.abs(magnitude) > MAX_EXPONENT)
+                    throw new RangeError('exponent out of range');
+            }
         }
         else {
             // Conversion to string failed, so construct from number
+            value = Number(value);
+            if (Number.isNaN(value) || (value === 0 && text.trim() === '')) {
+                throw new ValueError('Decimal value must be numeric');
+            }
             let m = 1n;
             if (value < 0) {
                 value = -value;
@@ -63,7 +80,7 @@ export class Decimal {
                 // 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);
+                    value *= 10 ** e;
                 }
                 else {
                     e = 0;
@@ -169,7 +186,7 @@ export class Decimal {
   ```js
   let a = decimal('1')
   let b = decimal('3')
-  a.div(b)  // 0.333333333333333333333333333333
+  a.div(b)  // 0.33333333333333333333
   ```
      * @returns {Decimal}
      */
@@ -179,8 +196,8 @@ export class Decimal {
         // 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);
+        // The quotient needs precision + a.e - b.e, and a negative a.e keeps the digits it always had
+        const increaseA = Math.max(Decimal.precision + Math.abs(a.e) - b.e, 0);
         const intIncrease = new Decimal();
         intIncrease.i = exp(a.i, increaseA);
         const quotient = new Decimal();
@@ -192,14 +209,17 @@ export class Decimal {
     }
     /**
      * Returns the square root of this `Decimal`.
-     * @returns {TDecimal}
+     * @returns {Decimal}
+     * @throws {ValueError} if this value is negative.
      */
     sqrt() {
+        if (this.i < 0n)
+            throw new ValueError('square root of a negative number');
         Decimal.PRECISION++;
-        // Let the guess value be 10^(e/2), where e is this.e
+        // Let the guess value be 10^(m/2), where m is the magnitude of this value
         let x = new Decimal();
         x.i = 1n;
-        x.e = Math.floor(this.e / 2);
+        x.e = Math.floor((this.e + this.i.toString().length) / 2);
         const onehalf = new Decimal('0.5');
         let xt = x.clone();
         xt._truncate();
@@ -221,6 +241,13 @@ export class Decimal {
         Decimal.PRECISION--;
         xt._truncate();
         xt._normalize();
+        // Rounding twice can leave the last digit one too high, so check it against the exact square
+        const half = new Decimal();
+        half.i = 5n;
+        half.e = -Decimal.PRECISION - 1;
+        const low = xt.sub(half);
+        if (low.gt(0) && low.mul(low).gt(this))
+            return low.sub(half);
         return xt;
     }
     /** Returns a new copy of this Decimal value. */
@@ -234,10 +261,16 @@ export class Decimal {
      * Remove zeroes in the least-significant digit of this `Decimal`
      */
     _normalize() {
-        while (this.i % 10n === 0n && this.i !== 0n) {
-            this.i /= 10n;
-            this.e++;
-        }
+        if (this.i === 0n)
+            this.e = Math.min(this.e, 0);
+        if (this.i === 0n || this.i % 10n !== 0n)
+            return this;
+        const digits = this.i.toString();
+        let end = digits.length;
+        while (digits[end - 1] === '0')
+            end--;
+        this.i = BigInt(digits.slice(0, end));
+        this.e += digits.length - end;
         return this;
     }
     /**
@@ -277,9 +310,9 @@ export class Decimal {
         }
         else if (this.e < 0) {
             if (-this.e >= s.length) {
-                return m + '0.' + '0'.repeat(-this.e - s.length) + s;
+                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);
+            return `${m}${s.slice(0, s.length + this.e)}.${s.slice(s.length + this.e, s.length)}`;
         }
         else {
             return m + s;
@@ -307,8 +340,16 @@ export class Decimal {
      * @returns {boolean}
      */
     eq(x) {
-        const other = decimal(x);
-        return this.i === other.i && this.e === other.e;
+        if (x == null || typeof x === 'boolean')
+            return false;
+        let other;
+        try {
+            other = decimal(x);
+        }
+        catch {
+            return false;
+        }
+        return this.i === other.i && (this.e === other.e || this.i === 0n);
     }
     /**
      * Returns `true` if this value is less than the value of `x`, otherwise `false`.
@@ -334,9 +375,10 @@ export class Decimal {
      * @returns {number}
      */
     compare(x) {
-        if (this.eq(x))
+        const other = x == null || typeof x === 'boolean' ? decimal(x) : x;
+        if (this.eq(other))
             return 0;
-        if (this.lt(x))
+        if (this.lt(other))
             return -1;
         return 1;
     }
@@ -367,11 +409,5 @@ export class Decimal {
 }
 /** 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;
+    return i * 10n ** BigInt(e);
 }

package/dist/functools/index.d.ts

@@ -3,25 +3,16 @@
  *
  * @module functools
  */
-import { Function } from '../globals/index.js';
+import type { Function } from '../globals/index.js';
 /**
- * Creates a function that invokes `fn` with the this binding of `thisArg` and `partials` as partially applied arguments.
- * @param {Function} fn The function to bind.
- * @param {*} thisArg The `this` value of `fn`.
- * @param {...*} [partials] The arguments to prepend to `fn`.
- * @returns {Function} Returns the new bound function.
- * @see {@link partial}
- */
-export declare function bind(fn: Function, thisArg: any, ...partials: any[]): Function;
-/**
- * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The arity of `func` may be specified if `func.length` is not sufficient.
+ * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least `func.length` arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on.
  * @param {Function} func The function to curry.
  * @returns Returns the new curried function.
  */
 export declare function curry(func: Function): Function<ReturnType<typeof func>>;
 /**
  * Creates a function that invokes `fn` with partials prepended to the arguments it receives.
- * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider {@link bind} instead.
+ * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider `Function.prototype.bind` instead.
  * @param {Function} fn The function to bind.
  * @param {...*} [args] The arguments to apply to `fn`.
  * @returns {Function} Returns the new partially applied function
@@ -52,15 +43,6 @@ export declare function compose(...args: Function[]): Function;
  * @return {Function} Returns the new memoized function.
  */
 export declare function memoize<T>(func: Function<T>, resolver?: Function): Function<T>;
-/**
- * Can be used as a decorator on any function or method to memoize its results.
- * **NOTE:** By default the given function is memoized using it's first argument, regardless of others.
- * @param target
- * @param name
- * @param descriptor
- * @returns A memoized version of the given function
- */
-export declare function cache(target: any, name: any, descriptor: any): any;
 /**
  * Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time the debounced function was invoked. Subsequent calls to the debounced function return the result of the last successful invocation. Provide options to set the `maxWait` milliseconds, regardless of when the function was last invoked.
  *
@@ -97,9 +79,9 @@ single(3) // 1
 ```
  */
 export declare function once<T>(func: Function<T>): Function<T>;
-export declare type Maybe<T> = T | undefined;
-export declare type Result<T, E = any> = [Maybe<T>, Maybe<E>];
-export declare type Optional<T> = Maybe<T>;
+export type Maybe<T> = T | undefined;
+export type Result<T, E = any> = [Maybe<T>, Maybe<E>];
+export type Optional<T> = Maybe<T>;
 /**
  * Wraps a function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
  * @template T,E
@@ -122,9 +104,3 @@ export declare function resultAsync<T = any, E = unknown>(fn: Function<Promise<T
  * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a `Promise`.
  */
 export declare function promisify<T>(fun: Function, thisArg?: any): Function<Promise<T>>;
-/**
- * Invokes a given function that accepts callback arguments for success, error and returns a `Promise` of the results.
- * @param {Function} fn A function that accepts callback arguments for success, error.
- * @returns {Promise<T>} A `Promise` that will be resolved when `successCallback` is called or rejected when `errorCallback` is called.
- */
-export declare function callAsync<T = any>(fn: (successCallback: (data: T) => any, errorCallback: Function) => any): Promise<T>;

package/dist/functools/index.js

@@ -4,18 +4,7 @@
  * @module functools
  */
 /**
- * Creates a function that invokes `fn` with the this binding of `thisArg` and `partials` as partially applied arguments.
- * @param {Function} fn The function to bind.
- * @param {*} thisArg The `this` value of `fn`.
- * @param {...*} [partials] The arguments to prepend to `fn`.
- * @returns {Function} Returns the new bound function.
- * @see {@link partial}
- */
-export function bind(fn, thisArg, ...partials) {
-    return fn.bind(thisArg, ...partials);
-}
-/**
- * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The arity of `func` may be specified if `func.length` is not sufficient.
+ * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least `func.length` arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on.
  * @param {Function} func The function to curry.
  * @returns Returns the new curried function.
  */
@@ -31,13 +20,13 @@ export function curry(func) {
 }
 /**
  * Creates a function that invokes `fn` with partials prepended to the arguments it receives.
- * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider {@link bind} instead.
+ * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider `Function.prototype.bind` instead.
  * @param {Function} fn The function to bind.
  * @param {...*} [args] The arguments to apply to `fn`.
  * @returns {Function} Returns the new partially applied function
  */
 export function partial(fn, ...args) {
-    return bind(fn, undefined, ...args);
+    return fn.bind(undefined, ...args);
 }
 /**
  * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from left to right.
@@ -74,31 +63,15 @@ export function compose(...args) {
  */
 export function memoize(func, resolver) {
     const cache = new Map();
-    return (...args) => {
-        const key = resolver ? resolver(...args) : args[0];
-        const prev = cache.get(key);
-        if (prev !== undefined)
-            return prev;
-        const value = func(...args);
+    return function (...args) {
+        const key = resolver ? resolver.apply(this, args) : args[0];
+        if (cache.has(key))
+            return cache.get(key);
+        const value = func.apply(this, args);
         cache.set(key, value);
         return value;
     };
 }
-/**
- * Can be used as a decorator on any function or method to memoize its results.
- * **NOTE:** By default the given function is memoized using it's first argument, regardless of others.
- * @param target
- * @param name
- * @param descriptor
- * @returns A memoized version of the given function
- */
-export function cache(target, name, descriptor) {
-    const original = descriptor.value;
-    if (typeof original === 'function') {
-        descriptor.value = memoize(original);
-    }
-    return descriptor;
-}
 /**
  * Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time the debounced function was invoked. Subsequent calls to the debounced function return the result of the last successful invocation. Provide options to set the `maxWait` milliseconds, regardless of when the function was last invoked.
  *
@@ -108,20 +81,21 @@ export function cache(target, name, descriptor) {
  * @returns Returns the new debounced function.
  */
 export function debounce(func, wait, { maxWait } = {}) {
-    let timer, maxTimer, lastResult;
-    return (...args) => {
+    let timer, maxTimer, lastResult, latestCall;
+    return function (...args) {
+        latestCall = () => func.apply(this, args);
         if (timer)
             clearTimeout(timer);
         timer = setTimeout(() => {
             clearTimeout(maxTimer);
             maxTimer = null;
-            lastResult = func(...args);
+            lastResult = func.apply(this, args);
         }, wait);
         if (maxWait && !maxTimer) {
             maxTimer = setTimeout(() => {
                 clearTimeout(timer);
                 maxTimer = null;
-                lastResult = func(...args);
+                lastResult = latestCall();
             }, maxWait);
         }
         return lastResult;
@@ -136,14 +110,16 @@ export function debounce(func, wait, { maxWait } = {}) {
  */
 export function throttle(func, wait) {
     let pending = false;
-    return (...args) => {
+    let lastResult;
+    return function (...args) {
         if (pending)
-            return;
-        func(...args);
+            return lastResult;
+        lastResult = func.apply(this, args);
         pending = true;
         setTimeout(() => {
             pending = false;
         }, wait);
+        return lastResult;
     };
 }
 /**
@@ -164,9 +140,9 @@ single(3) // 1
  */
 export function once(func) {
     let result, isCalled;
-    return (...args) => {
+    return function (...args) {
         if (!isCalled) {
-            result = func(...args);
+            result = func.apply(this, args);
             isCalled = true;
         }
         return result;
@@ -179,10 +155,10 @@ export function once(func) {
  * @returns {Function} A new function that wraps `fn` and returns the result tuple.
  */
 export function result(fn) {
-    return (...args) => {
+    return function (...args) {
         let value, err;
         try {
-            value = fn(...args);
+            value = fn.apply(this, args);
         }
         catch (error) {
             err = error;
@@ -197,10 +173,10 @@ export function result(fn) {
  * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the given function and returns the result tuple.
  */
 export function resultAsync(fn) {
-    return async (...args) => {
+    return async function (...args) {
         let value, err;
         try {
-            value = await fn(...args);
+            value = await fn.apply(this, args);
         }
         catch (error) {
             err = error;
@@ -225,11 +201,3 @@ export function promisify(fun, thisArg) {
         }));
     };
 }
-/**
- * Invokes a given function that accepts callback arguments for success, error and returns a `Promise` of the results.
- * @param {Function} fn A function that accepts callback arguments for success, error.
- * @returns {Promise<T>} A `Promise` that will be resolved when `successCallback` is called or rejected when `errorCallback` is called.
- */
-export async function callAsync(fn) {
-    return await new Promise(fn);
-}

package/dist/globals/index.d.ts

@@ -6,7 +6,7 @@
 /**
  * A generic function type with arbitrary arguments and return.
  */
-export declare type Function<TReturn = any> = (...args: any) => TReturn;
+export type Function<TReturn = any> = (...args: any) => TReturn;
 /** This is just a noop function. */
 export declare function noop(): void;
 /** A function that always returns `true`. */
@@ -22,9 +22,10 @@ export declare class CustomError extends Error {
     /**
      * Returns a new CustomError with the specified message.
      * @param {string} message
+     * @param {ErrorOptions} [options] Standard error options such as `cause`.
      * @constructor
      */
-    constructor(message?: string);
+    constructor(message?: string, options?: ErrorOptions);
 }
 /**
  * Custom error to signal an invalid index access.
@@ -89,8 +90,6 @@ export declare function isDate(x: any): x is Date;
 export declare function isObject(x: any): x is Object;
 /** Check if value is a string type. */
 export declare function isString(x: any): x is string;
-/** Check if value is an Array type. */
-export declare function isArray(x: any): x is any[];
 /**
  * Check if value is Array-like type.
  * A value is considered array-like if it's not a function and has a `.length` number property.
@@ -98,8 +97,6 @@ export declare function isArray(x: any): x is any[];
 export declare function isArrayLike(x: any): boolean;
 /** Check if value is a number type. */
 export declare function isNumber(x: any): x is number;
-/** Check if value is an integer number type. */
-export declare function isInteger(x: any): x is number;
 /** Check if value is a bigint type. */
 export declare function isBigint(x: any): x is BigInt;
 /** Check if value is a Promise type. */
@@ -175,20 +172,6 @@ export declare function call<T = any>(obj: any, key: PropertyKey, ...args: any[]
 export declare function chr(x: number): string;
 /** Convert character to Unicode code point */
 export declare function ord(x: string): number;
-/**
- * Returns an array of the own enumerable property names of `object`.
- * @param object The given object.
- * @returns The array of object keys.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys Object.keys()}
- */
-export declare function keys<T>(object: T): Array<keyof T>;
-/**
- * Returns an array of the own enumerable property values of `object`.
- * @param object The given object.
- * @returns The array of object keys.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values Object.values()}
- */
-export declare function values<T = any>(object: any): T[];
 /**
  * Check if a given property is present in a given object.
  * @param obj The object to check.

package/dist/globals/index.js

@@ -18,13 +18,16 @@ export class CustomError extends Error {
     /**
      * Returns a new CustomError with the specified message.
      * @param {string} message
+     * @param {ErrorOptions} [options] Standard error options such as `cause`.
      * @constructor
      */
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
         this.name = this.constructor.name;
-        if (typeof Error.captureStackTrace === 'function') {
-            Error.captureStackTrace(this, this.constructor);
+        // V8 and Bun have it, and only Node's types declare it, which JSR's type check does not load
+        const errorType = Error;
+        if (typeof errorType.captureStackTrace === 'function') {
+            errorType.captureStackTrace(this, this.constructor);
         }
         else {
             this.stack = new Error(message).stack;
@@ -90,7 +93,7 @@ export function type(value) {
                 return 'error';
             if (value[Symbol.toStringTag])
                 return value[Symbol.toStringTag];
-            const className = str(value);
+            const className = Object.prototype.toString.call(value);
             if (className === '[object Window]')
                 return 'object';
             if (className.endsWith('Array]') || Array.isArray(value)) {
@@ -150,10 +153,6 @@ export function isObject(x) {
 export function isString(x) {
     return type(x) === 'string';
 }
-/** Check if value is an Array type. */
-export function isArray(x) {
-    return Array.isArray(x);
-}
 /**
  * Check if value is Array-like type.
  * A value is considered array-like if it's not a function and has a `.length` number property.
@@ -166,10 +165,6 @@ export function isArrayLike(x) {
 export function isNumber(x) {
     return type(x) === 'number';
 }
-/** Check if value is an integer number type. */
-export function isInteger(x) {
-    return type(x) === 'number' && Math.trunc(x) === x;
-}
 /** Check if value is a bigint type. */
 export function isBigint(x) {
     return type(x) === 'bigint';
@@ -180,15 +175,15 @@ export function isPromise(x) {
 }
 /** Check if value is a function type. */
 export function isFunction(x) {
-    return x?.constructor === Function;
+    return typeof x === 'function';
 }
 /** Check if value is an async function type. */
 export function isAsyncFunction(x) {
-    return x?.constructor.name === 'AsyncFunction';
+    return x?.constructor?.name === 'AsyncFunction';
 }
 /** Check if value is a generator function type. */
 export function isGenerator(x) {
-    return x?.constructor.constructor?.name === 'GeneratorFunction';
+    return x?.constructor?.constructor?.name === 'GeneratorFunction';
 }
 /** Check if value is `null` or `undefined`. */
 export function isNull(x) {
@@ -282,7 +277,7 @@ uuid()
  */
 export function uuid() {
     const u = Date.now().toString(16) + Math.random().toString(16) + '0'.repeat(16);
-    return [u.substr(0, 8), u.substr(8, 4), '4000-8' + u.substr(13, 3), u.substr(16, 12)].join('-');
+    return [u.slice(0, 8), u.slice(8, 12), `4000-8${u.slice(13, 16)}`, u.slice(16, 28)].join('-');
 }
 /**
  * Checks if `obj.key` is a function, and calls it with any given `args`.
@@ -292,7 +287,7 @@ export function uuid() {
  * @return `obj.key(...args)` or `undefined`.
  */
 export function call(obj, key, ...args) {
-    if (isFunction(get(key, obj))) {
+    if (isFunction(get([key], obj))) {
         return obj[key](...args);
     }
 }
@@ -302,25 +297,7 @@ export function chr(x) {
 }
 /** Convert character to Unicode code point */
 export function ord(x) {
-    return x.charCodeAt(0);
-}
-/**
- * Returns an array of the own enumerable property names of `object`.
- * @param object The given object.
- * @returns The array of object keys.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys Object.keys()}
- */
-export function keys(object) {
-    return Object.keys(object);
-}
-/**
- * Returns an array of the own enumerable property values of `object`.
- * @param object The given object.
- * @returns The array of object keys.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values Object.values()}
- */
-export function values(object) {
-    return Object.values(object);
+    return x.codePointAt(0) ?? Number.NaN;
 }
 /**
  * Check if a given property is present in a given object.
@@ -329,7 +306,7 @@ export function values(object) {
  * @returns `true` if the object has the property name.
  */
 export function has(obj, attr) {
-    return obj && attr in obj;
+    return obj != null && attr in Object(obj);
 }
 export function get(key, obj, value) {
     if (obj == null)
@@ -372,19 +349,26 @@ export function del(attr, x) {
 export function set(attr, obj, value, writable = false, enumerable = false) {
     return Object.defineProperty(obj, attr, {
         value,
+        configurable: true,
         enumerable,
         writable
     });
 }
 export const HASH_KEY = Symbol.for('HASH_KEY');
+const sealedHashes = new WeakMap();
 export function hash(obj) {
     if (typeof obj === 'string') {
         return hashCode(obj);
     }
-    if (typeof obj === 'object') {
+    if (typeof obj === 'object' && obj !== null) {
         if (get(HASH_KEY, obj) != null) {
             return obj[HASH_KEY];
         }
+        if (!Object.isExtensible(obj)) {
+            if (!sealedHashes.has(obj))
+                sealedHashes.set(obj, uniqueId());
+            return sealedHashes.get(obj);
+        }
         obj[HASH_KEY] = uniqueId();
         return obj[HASH_KEY];
     }

package/dist/i18n/currency.d.ts

@@ -6,6 +6,7 @@ export declare class Currency extends Decimal {
     private readonly locale;
     private readonly currency;
     private readonly numberFormat;
+    private readonly overrides;
     private readonly options;
     constructor(amount: any, currency: string, locale?: string, opts?: Intl.NumberFormatOptions);
     clone(n: Currency): Currency;
@@ -15,6 +16,8 @@ export declare class Currency extends Decimal {
     div(x: Currency | Decimal | string | number): Currency;
     mul(x: Currency | Decimal): Currency;
     toDecimal(): Decimal;
+    /** `Intl` reads a decimal string exactly, while a `Number` past 2^53 has lost digits. */
+    private formattable;
     toString(): string;
     format(opts?: Intl.NumberFormatOptions, locale?: string): string;
     displayName(): string;