atomic-fns 1.1.7 → 1.2.0

package/dist/collections/index.js

@@ -3,9 +3,9 @@
  *
  * @module collections
  */
-import { call, get, isArray, isArrayLike, isBool, isEmpty, isFunction, isIterable, isNull, isNumber, isObject, isString, keys } from '../globals/index.js';
+import { call, get, isArrayLike, isDate, isEmpty, isFunction, isIterable, isNull, isObject, isRegExp } from '../globals/index.js';
 import { enumerate } from '../itertools/index.js';
-import { compare, eq, id } from '../operators/index.js';
+import { compare, eq, identity } from '../operators/index.js';
 export * from './abc.js';
 export * from './BTree.js';
 export * from './deque.js';
@@ -17,15 +17,30 @@ export * from './SortedSet.js';
 export * from './SortedTree.js';
 export * from './SplayTree.js';
 export * from './Trie.js';
+/** Assigns `key`, defining it where a plain write would set the prototype instead. */
+function setOwn(obj, key, value) {
+    if (typeof key === 'string' && key !== '__proto__') {
+        obj[key] = value;
+    }
+    else {
+        Object.defineProperty(obj, key, { value, enumerable: true, writable: true, configurable: true });
+    }
+}
+/** `isEmpty` counts declared parameters and keys, which says nothing about these values. */
+function isBlank(x) {
+    if (isPlainObject(x))
+        return Object.keys(x).length === 0;
+    return isEmpty(x) && typeof x !== 'function' && !isDate(x) && !isRegExp(x);
+}
 export function compact(arr) {
     if (!arr)
         return;
     if (Array.isArray(arr))
-        return arr.filter((x) => !isEmpty(x));
+        return arr.filter((x) => !isBlank(x));
     const result = {};
     for (const key of Object.keys(arr)) {
-        if (!isEmpty(arr[key])) {
-            result[key] = arr[key];
+        if (!isBlank(arr[key])) {
+            setOwn(result, key, arr[key]);
         }
     }
     return result;
@@ -34,7 +49,7 @@ export function count(obj, func) {
     const counters = {};
     forEach(obj, (value, key) => {
         const result = func(value, key);
-        counters[result] = get(result, counters, 0) + 1;
+        setOwn(counters, result, Object.hasOwn(counters, result) ? counters[result] + 1 : 1);
     });
     return counters;
 }
@@ -54,6 +69,12 @@ export function find(arr, fn) {
     if (Array.isArray(arr)) {
         return arr.find(it);
     }
+    else if (isIterable(arr)) {
+        for (const [index, value] of enumerate(arr)) {
+            if (it(value, index, arr))
+                return value;
+        }
+    }
     else if (isObject(arr)) {
         for (const key of Object.keys(arr)) {
             if (it(arr[key], key, arr)) {
@@ -94,17 +115,34 @@ filter(objects, matches({ a: 4, c: 6 }))
  * @returns
  */
 export function matches(shape) {
-    return function (obj) {
+    return (obj) => {
         if (!shape || !obj)
             return false;
+        const seen = new Map();
         for (const key in shape) {
-            if (obj[key] !== shape[key])
+            if (!isPartialMatch(shape[key], obj[key], seen))
                 return false;
         }
         return true;
     };
 }
+function isPartialMatch(shape, value, seen) {
+    if (shape === value)
+        return true;
+    const isList = Array.isArray(shape);
+    if (!isList && !isPlainObject(shape))
+        return false;
+    if (value === null || typeof value !== 'object' || isList !== Array.isArray(value))
+        return false;
+    const visited = seen.get(shape) ?? new Set();
+    if (visited.has(value))
+        return true;
+    seen.set(shape, visited.add(value));
+    return Object.keys(shape).every((key) => isPartialMatch(shape[key], value[key], seen));
+}
 export function forEach(collection, fn) {
+    if (collection == null)
+        return;
     if (Array.isArray(collection)) {
         for (let i = 0; i < collection.length; i++) {
             const res = fn(collection[i], i, collection);
@@ -120,7 +158,7 @@ export function forEach(collection, fn) {
         }
     }
     else {
-        for (const key of keys(collection)) {
+        for (const key of Object.keys(collection)) {
             const res = fn(collection[key], key, collection);
             if (res === false)
                 return;
@@ -129,7 +167,7 @@ export function forEach(collection, fn) {
 }
 export function findLast(arr, fn) {
     let result;
-    const it = isFunction(fn) ? fn : matches(fn);
+    const it = isFunction(fn) ? fn : isObject(fn) ? matches(fn) : (obj) => get(fn, obj);
     forEachRight(arr, (val, key) => {
         if (it(val, key, arr)) {
             result = val;
@@ -147,6 +185,14 @@ export function forEachRight(collection, fn) {
                 return;
         }
     }
+    else if (isIterable(collection)) {
+        const items = Array.from(collection);
+        for (let i = items.length - 1; i >= 0; i--) {
+            const res = fn(items[i], i, collection);
+            if (res === false)
+                return;
+        }
+    }
     else if (isObject(collection)) {
         const keys = Object.keys(collection);
         for (let i = keys.length - 1; i >= 0; i--) {
@@ -163,7 +209,7 @@ export function flatten(arr, depth = 1) {
         return arr;
     if (Array.isArray(arr))
         return flattenArray(arr, depth, []);
-    if (isObject(arr))
+    if (isFlattenable(arr))
         return flattenObj(arr);
     return arr;
 }
@@ -178,15 +224,19 @@ function flattenArray(arr, depth = 1, result = []) {
     }
     return result;
 }
+/** A `Date` or `RegExp` has no keys to walk, so `flatten` keeps it as a leaf. */
+function isFlattenable(x) {
+    return Array.isArray(x) || (isObject(x) && !isDate(x) && !isRegExp(x));
+}
 function flattenObj(obj, prefix = '', result = {}, keepNull = false) {
-    if (isString(obj) || isNumber(obj) || isBool(obj) || (keepNull && isNull(obj))) {
-        result[prefix] = obj;
+    if (isNull(obj) ? keepNull : !isFlattenable(obj)) {
+        setOwn(result, prefix, obj);
         return result;
     }
-    if (isArray(obj) || isObject(obj)) {
+    if (Array.isArray(obj) || isObject(obj)) {
         for (const i of Object.keys(obj)) {
             let pref = prefix;
-            if (isArray(obj)) {
+            if (Array.isArray(obj)) {
                 pref = `${pref}[${i}]`;
             }
             else {
@@ -208,6 +258,9 @@ export function map(arr, fn) {
     if (Array.isArray(arr)) {
         return arr.map((x, i) => it(x, i, arr));
     }
+    if (isIterable(arr)) {
+        return Array.from(arr, (x, i) => it(x, i, arr));
+    }
     if (isObject(arr)) {
         return Object.keys(arr).map((key) => it(arr[key], key, arr));
     }
@@ -219,13 +272,16 @@ export function pick(obj, paths) {
     if (isFunction(paths)) {
         for (const key of Object.keys(obj)) {
             if (paths(obj[key], key)) {
-                result[key] = obj[key];
+                setOwn(result, key, obj[key]);
             }
         }
         return result;
     }
-    for (const key of paths) {
-        result[key] = get(key, obj);
+    for (const path of paths) {
+        const key = typeof path === 'symbol' ? path : String(path);
+        const value = get(path, obj);
+        if (key !== '__proto__' && (value !== undefined || key in Object(obj)))
+            result[key] = value;
     }
     return result;
 }
@@ -236,16 +292,16 @@ export function omit(obj, paths) {
     if (isFunction(paths)) {
         for (const key of Object.keys(obj)) {
             if (!paths(obj[key], key)) {
-                result[key] = obj[key];
+                setOwn(result, key, obj[key]);
             }
         }
         return result;
     }
-    Object.assign(result, obj);
+    const kept = { ...obj };
     for (const key of paths) {
-        delete result[key];
+        delete kept[key];
     }
-    return result;
+    return kept;
 }
 export function findIndex(obj, fn, start = 0) {
     if (!obj)
@@ -303,8 +359,7 @@ export function findLastIndex(arr, fn, start) {
     if (arr == null)
         return -1;
     const length = arr.length;
-    if (start == null)
-        start = length - 1;
+    start = Math.min(start ?? length - 1, length - 1);
     if (!length || start < 0)
         return -1;
     const it = isFunction(fn) ? fn : isObject(fn) ? matches(fn) : (obj) => get(fn, obj);
@@ -335,12 +390,11 @@ lastIndexOf([1, 2, 1, 2], 2, 2)
 export function lastIndexOf(obj, value, start) {
     if (obj == null)
         return -1;
-    const op = call(obj, 'lastIndexOf', value, start);
+    const op = call(obj, 'lastIndexOf', ...(start === undefined ? [value] : [value, start]));
     if (op != null)
         return op;
     const length = obj.length;
-    if (start == null)
-        start = length - 1;
+    start = Math.min(start ?? length - 1, length - 1);
     if (!length || start < 0)
         return -1;
     for (; start >= 0; start--) {
@@ -350,29 +404,62 @@ export function lastIndexOf(obj, value, start) {
     return -1;
 }
 export function clone(value, deep = false) {
-    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    return cloneValue(value, deep, new Map());
+}
+function cloneValue(value, deep, copies) {
+    if (copies.has(value))
+        return copies.get(value);
+    if (value instanceof ArrayBuffer)
+        return value.slice(0);
+    if (ArrayBuffer.isView(value)) {
         return cloneTypedArray(value, deep);
     }
-    if (isArray(value) || isArrayLike(value)) {
-        return cloneArray(value, deep);
+    if (isObject(value) && isFunction(value.clone)) {
+        return value.clone();
+    }
+    if (Array.isArray(value) || hasElements(value)) {
+        return cloneArray(value, deep, copies);
+    }
+    if (value?.constructor === Map) {
+        const map = new Map();
+        copies.set(value, map);
+        for (const [key, item] of value)
+            map.set(key, deep ? cloneValue(item, deep, copies) : item);
+        return map;
+    }
+    if (value?.constructor === Set) {
+        const set = new Set();
+        copies.set(value, set);
+        for (const item of value)
+            set.add(deep ? cloneValue(item, deep, copies) : item);
+        return set;
     }
     if (isObject(value)) {
-        if (isFunction(value.clone)) {
-            return value.clone();
+        if (isDate(value))
+            return new Date(value.getTime());
+        if (isRegExp(value)) {
+            const regex = new RegExp(value.source, value.flags);
+            regex.lastIndex = value.lastIndex;
+            return regex;
         }
         const copy = {};
+        copies.set(value, copy);
         for (const key in value) {
             if (deep) {
-                copy[key] = clone(value[key], deep);
+                setOwn(copy, key, cloneValue(value[key], deep, copies));
             }
             else {
-                copy[key] = value[key];
+                setOwn(copy, key, value[key]);
             }
         }
         return copy;
     }
     return value;
 }
+/** `isArrayLike` accepts any numeric `length`, so this also looks for the elements. */
+function hasElements(x) {
+    return isArrayLike(x) && (isIterable(x) || x.length - 1 in x);
+}
 /**
  * Clones an array. If `deep` is `false` (default) the clone will be shallow. Otherwise {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone} is used.
  * @param arr The array to clone
@@ -380,10 +467,20 @@ export function clone(value, deep = false) {
  * @returns The new array
  * @see {@link clone}
  */
-export function cloneArray(arr, deep = false) {
+function cloneArray(arr, deep, copies) {
     if (!deep)
         return Array.from(arr);
-    return structuredClone(arr);
+    try {
+        return structuredClone(arr);
+    }
+    catch {
+        const copy = Array.from(arr);
+        copies.set(arr, copy);
+        copy.forEach((item, index) => {
+            copy[index] = cloneValue(item, deep, copies);
+        });
+        return copy;
+    }
 }
 /**
  * Clones a typed array. If `deep` is `false` (default) the clone will be shallow. Otherwise {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone} is used.
@@ -392,40 +489,56 @@ export function cloneArray(arr, deep = false) {
  * @returns The new array
  * @see {@link clone}
  */
-export function cloneTypedArray(typedArray, isDeep = false) {
+function cloneTypedArray(typedArray, isDeep = false) {
+    if (typedArray instanceof DataView) {
+        const viewed = isDeep ? typedArray.buffer.slice(0) : typedArray.buffer;
+        return new DataView(viewed, typedArray.byteOffset, typedArray.byteLength);
+    }
     const buffer = isDeep ? structuredClone(typedArray) : typedArray.buffer;
     return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
 }
-export function uniq(arr, fn = id) {
+export function uniq(arr, fn = identity) {
     const keys = new Set();
+    const results = [];
     const it = isFunction(fn) ? fn : (x) => get(fn, x);
-    for (const x of arr) {
-        keys.add(it(x));
+    for (const x of arr ?? []) {
+        const key = it(x);
+        if (keys.has(key))
+            continue;
+        keys.add(key);
+        results.push(Object.is(x, -0) ? 0 : x);
     }
-    return Array.from(keys.values());
+    return results;
+}
+export function sortedUniq(arr, fn = identity) {
+    const it = isFunction(fn) ? fn : (x) => get(fn, x);
+    return uniq(arr, it).sort((x, y) => compare(it(x), it(y)));
 }
-export function sortedUniq(arr, fn = id) {
-    const values = uniq(arr, fn);
-    values.sort(compare);
-    return values;
+/** True for an object made by `{}`, `JSON.parse` or `Object.create(null)`, in any realm. */
+function isPlainObject(x) {
+    if (Object.prototype.toString.call(x) !== '[object Object]')
+        return false;
+    const proto = Object.getPrototypeOf(x);
+    return proto === null || Object.getPrototypeOf(proto) === null;
 }
-function baseMergeDeep(obj, source, key, stack) {
+function baseMergeDeep(obj, source, key, stack, copies, merged) {
     const objValue = obj[key];
     const srcValue = source[key];
     const stacked = stack.get(srcValue);
-    if (stacked && (objValue !== stacked || !(key in obj))) {
+    if (stacked) {
         obj[key] = stacked;
         return;
     }
     let newValue;
     let isCommon = newValue === undefined;
+    let isCopy = false;
     const isArray = Array.isArray(srcValue);
     const isTyped = ArrayBuffer.isView(srcValue);
     if (isArray || isTyped) {
         if (Array.isArray(objValue)) {
             newValue = objValue;
         }
-        else if (isArrayLike(objValue)) {
+        else if (hasElements(objValue)) {
             newValue = Array.from(objValue);
         }
         else if (isTyped) {
@@ -434,42 +547,52 @@ function baseMergeDeep(obj, source, key, stack) {
         }
         else {
             newValue = [];
+            isCopy = true;
         }
     }
-    else if (isObject(srcValue)) {
-        newValue = objValue;
-        if (!isObject(objValue)) {
-            newValue = srcValue;
-        }
+    else if (isPlainObject(srcValue)) {
+        isCopy = !isObject(objValue);
+        newValue = isCopy ? {} : objValue;
     }
     else {
         isCommon = false;
+        newValue = srcValue;
     }
-    if (isCommon) {
+    if (isCopy && copies.has(srcValue)) {
+        obj[key] = copies.get(srcValue);
+        return;
+    }
+    const targets = merged.get(srcValue) ?? new WeakSet();
+    if (isCommon && !targets.has(newValue)) {
+        merged.set(srcValue, targets.add(newValue));
         stack.set(srcValue, newValue);
-        baseMerge(newValue, srcValue, stack);
+        baseMerge(newValue, srcValue, stack, copies, merged);
         stack.delete(srcValue);
     }
+    if (isCopy)
+        copies.set(srcValue, newValue);
     obj[key] = newValue;
 }
-function baseMerge(obj, source, stack) {
+function baseMerge(obj, source, stack, copies, merged) {
     if (obj === source)
         return obj;
     for (const key of Object.keys(source)) {
+        if (key === '__proto__')
+            continue;
         const srcValue = source[key];
         const objValue = obj[key];
         if (typeof srcValue === 'object' && srcValue !== null) {
-            baseMergeDeep(obj, source, key, stack || new WeakMap());
+            baseMergeDeep(obj, source, key, stack, copies, merged);
         }
         else {
-            if (objValue !== srcValue) {
+            if (srcValue !== undefined && objValue !== srcValue) {
                 obj[key] = srcValue;
             }
         }
     }
 }
 /**
- * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. Source properties that resolve to `undefined` are skipped if a destination value exists. Array and plain object properties are merged recursively. Other objects and value types are overridden by assignment. Source objects are applied from left to right. Subsequent sources overwrite property assignments of previous sources.
+ * Recursively merges own enumerable string keyed properties of source objects into the destination object. Source properties that resolve to `undefined` are skipped if a destination value exists. Array and plain object properties are merged recursively. Other objects and value types are overridden by assignment. Source objects are applied from left to right. Subsequent sources overwrite property assignments of previous sources.
  *
  * Note: this method mutates `object`
  *
@@ -494,7 +617,8 @@ merge(object, other)
  */
 export function merge(object, ...sources) {
     for (const source of sources) {
-        baseMerge(object, source);
+        if (source != null)
+            baseMerge(object, source, new WeakMap(), new WeakMap(), new WeakMap());
     }
     return object;
 }
@@ -534,11 +658,10 @@ export function defaults(object, ...sources) {
  */
 export function* difference(...args) {
     const sets = args.map((arr) => new Set(arr));
-    const setA = sets[0];
+    const setA = sets[0] ?? new Set();
     for (let i = 1; i < sets.length; i++) {
         for (const x of sets[i].values()) {
-            if (!setA.delete(x))
-                setA.add(x);
+            setA.delete(x);
         }
     }
     for (const x of setA.values()) {
@@ -586,7 +709,7 @@ export function* intersection(...args) {
 export function* union(...args) {
     const results = new Set();
     for (const arr of args) {
-        for (const item of arr) {
+        for (const item of arr ?? []) {
             results.add(item);
         }
     }
@@ -594,18 +717,18 @@ export function* union(...args) {
         yield item;
     }
 }
-export function groupBy(arr, func = id) {
+export function groupBy(arr, func = identity) {
     const useKey = isFunction(func) ? func : (obj) => get(func, obj);
     const results = {};
     forEach(arr, (value) => {
         const groupKey = useKey(value);
-        const values = results[groupKey] || [];
-        values.push(value);
-        results[groupKey] = values;
+        if (!Object.hasOwn(results, groupKey))
+            setOwn(results, groupKey, []);
+        results[groupKey].push(value);
     });
     return results;
 }
-export function groupByMap(arr, func = id) {
+export function groupByMap(arr, func = identity) {
     const results = new Map();
     const useKey = isFunction(func) ? func : (obj) => get(func, obj);
     forEach(arr, (value) => {
@@ -617,13 +740,17 @@ export function groupByMap(arr, func = id) {
     return results;
 }
 export function remove(arr, func) {
-    const it = isFunction(func) ? func : isArray(func) ? (x) => func.includes(x) : (x) => func === x;
+    const it = isFunction(func)
+        ? func
+        : Array.isArray(func)
+            ? (x) => func.includes(x)
+            : (x) => func === x;
     return arr.filter((x, i) => !it(x, i, arr));
 }
 /**
  * Returns the index of `x` in a **sorted** array if found, in `O(log n)` using binary search.
- * If the element is not found, returns a negative integer.
- * @param arr The array to sort
+ * If the element is not found, returns `-n - 1`, where `n` is the index to insert `x` at.
+ * @param arr The sorted array
  * @param x The element to find
  * @param lo The starting index
  * @param hi The end index to search within
@@ -631,7 +758,7 @@ export function remove(arr, func) {
  * @returns {number} The index if the element is found or a negative integer.
  */
 export function binarySearch(arr, x, lo = 0, hi, comp = compare) {
-    hi = hi ?? arr.length - 1;
+    hi ??= arr.length - 1;
     while (lo < hi) {
         const mid = (lo + hi) >> 1;
         const check = comp(x, arr[mid]);
@@ -642,14 +769,15 @@ export function binarySearch(arr, x, lo = 0, hi, comp = compare) {
         else
             hi = mid - 1;
     }
-    if (comp(x, arr[lo]) === 0)
+    const check = lo <= hi ? comp(x, arr[lo]) : -1;
+    if (check === 0)
         return lo;
-    // Returns (-lo - 1) where n is the insertion point for new element in the range
-    return -lo - 1;
+    // Returns (-n - 1) where n is the insertion point for new element in the range
+    return check > 0 ? -lo - 2 : -lo - 1;
 }
 /**
  * Returns an insertion index which comes after any existing entries of `x` in a **sorted** array, using binary search.
- * @param arr The array to sort
+ * @param arr The sorted array
  * @param x The element to find
  * @param lo The starting index
  * @param hi The end index to search within
@@ -657,20 +785,20 @@ export function binarySearch(arr, x, lo = 0, hi, comp = compare) {
  * @returns {number}
  */
 export function bisect(arr, x, lo = 0, hi, comp = compare) {
-    hi = hi ?? arr.length;
+    hi ??= arr.length;
     while (lo < hi) {
         const mid = (lo + hi) >> 1;
         const check = comp(x, arr[mid]);
         if (check >= 0)
             lo = mid + 1;
         else
-            hi = mid - 1;
+            hi = mid;
     }
     return lo;
 }
 /**
  * Returns an insertion index which comes before any existing entries of `x` in a **sorted** array, using binary search.
- * @param arr The array to sort
+ * @param arr The sorted array
  * @param x The element to find
  * @param lo The starting index
  * @param hi The end index to search within
@@ -678,12 +806,12 @@ export function bisect(arr, x, lo = 0, hi, comp = compare) {
  * @returns {number}
  */
 export function bisectLeft(arr, x, lo = 0, hi, comp = compare) {
-    hi = hi ?? arr.length;
+    hi ??= arr.length;
     while (lo < hi) {
         const mid = (lo + hi) >> 1;
         const check = comp(x, arr[mid]);
         if (check <= 0)
-            hi = mid - 1;
+            hi = mid;
         else
             lo = mid + 1;
     }

package/dist/decimal/index.d.ts

@@ -20,6 +20,8 @@ export declare 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?: any);
     /**
@@ -75,14 +77,15 @@ export declare class Decimal {
   ```js
   let a = decimal('1')
   let b = decimal('3')
-  a.div(b)  // 0.333333333333333333333333333333
+  a.div(b)  // 0.33333333333333333333
   ```
      * @returns {Decimal}
      */
     div(x: Decimal | string | number): Decimal;
     /**
      * Returns the square root of this `Decimal`.
-     * @returns {TDecimal}
+     * @returns {Decimal}
+     * @throws {ValueError} if this value is negative.
      */
     sqrt(): Decimal;
     /** Returns a new copy of this Decimal value. */