atomic-fns 1.1.7 → 1.2.0

package/README.md

@@ -1,6 +1,6 @@
 # atomic-fns
 
-[Read the Docs](https://atomic-stack.github.io/atomic-fns/)
+[Read the Docs](https://jsr.io/@atomic-stack/atomic-fns/doc)
 
 ## Like Lodash, but in TypeScript and for ESNext.
 
@@ -17,7 +17,7 @@ You may prefer this library because:
 
 ## Docs
 
-📖 Available at [atomic-fns](https://atomic-stack.github.io/atomic-fns/)
+📖 Available at [atomic-fns](https://jsr.io/@atomic-stack/atomic-fns/doc)
 
 ## Get Started
 
@@ -29,6 +29,12 @@ To install the package you need to have [npm](https://www.npmjs.com/get-npm) (or
 npm install atomic-fns
 ```
 
+It is also on [JSR](https://jsr.io/@atomic-stack/atomic-fns), for Deno and other runtimes that read TypeScript directly:
+
+```bash
+npx jsr add @atomic-stack/atomic-fns
+```
+
 ## How to use
 
 Just import any function or class you need.
@@ -36,7 +42,7 @@ Just import any function or class you need.
 ```js
 import { sorted, times, uniqueId } from 'atomic-fns'
 
-times(5, (i) => i)
+[...times(5, (i) => i)]
 // -> [0, 1, 2, 3, 4]
 
 sorted([4, 3, 2, 1])
@@ -47,7 +53,7 @@ uniqueId('user_')
 ...
 ```
 
-See the full list of [modules](https://atomic-stack.github.io/atomic-fns/modules.html).
+See the full list of [modules](https://jsr.io/@atomic-stack/atomic-fns/doc).
 
 ## Data model
 This library features a data model similar to [Python](https://docs.python.org/3/reference/datamodel.html#special-method-names) but not always. Only the missing parts have been implemented, while respecting the JS standards.
@@ -67,7 +73,7 @@ When working with objects, functions in this library use these custom operators
 
 ## New Types
 
-[`Decimal`](https://atomic-stack.github.io/atomic-fns/classes/decimal.Decimal.html) provides support for correct rounded floating point arithmetic, with arbitrary precision.
+[`Decimal`](https://jsr.io/@atomic-stack/atomic-fns/doc/decimal/~/Decimal) provides support for correct rounded floating point arithmetic, with arbitrary precision.
 
 This fixes precision issues with float arithmetic, for example:
 ```
@@ -81,15 +87,48 @@ decimal('0.1').add('0.1').add('0.1').toNumber()
 Some common base interfaces and typing patterns you may have seen like `Optional`, `Result`, `Comparable`, `Iterator`, and others.
 
 ### Sorted Containers
-  - [SortedSet](https://atomic-stack.github.io/atomic-fns/classes/collections.SortedSet.html)
-  - [SortedMap](https://atomic-stack.github.io/atomic-fns/classes/collections.SortedMap.html)
-  - [SortedTree](https://atomic-stack.github.io/atomic-fns/classes/collections.SortedTree.html)
+  - [SortedSet](https://jsr.io/@atomic-stack/atomic-fns/doc/collections/~/SortedSet)
+  - [SortedMap](https://jsr.io/@atomic-stack/atomic-fns/doc/collections/~/SortedMap)
+  - [SortedTree](https://jsr.io/@atomic-stack/atomic-fns/doc/collections/~/SortedTree)
 
 ### Other Containers
-  - [Deque](https://atomic-stack.github.io/atomic-fns/classes/collections.Deque.html)
-  - [FrozenSet](https://atomic-stack.github.io/atomic-fns/classes/collections.FrozenSet.html)
-  - [LRUCache](https://atomic-stack.github.io/atomic-fns/classes/collections.LRUCache.html)
-
+  - [Deque](https://jsr.io/@atomic-stack/atomic-fns/doc/collections/~/Deque)
+  - [FrozenSet](https://jsr.io/@atomic-stack/atomic-fns/doc/collections/~/FrozenSet)
+  - [LRUCache](https://jsr.io/@atomic-stack/atomic-fns/doc/collections/~/LRUCache)
+
+
+## Upgrading to 1.2
+
+1.2 removes the exports that only repeated a native function, along with the deprecated `id` and the experimental `cache` decorator.
+
+| Removed                         | Use instead                            |
+| ------------------------------- | -------------------------------------- |
+| `isArray`                       | `Array.isArray`                        |
+| `isInteger`                     | `Number.isInteger`                     |
+| `keys`, `values`                | `Object.keys`, `Object.values`         |
+| `bind`                          | `Function.prototype.bind`              |
+| `callAsync`                     | `new Promise`                          |
+| `floor`, `ceil`, `log2`         | `Math.floor`, `Math.ceil`, `Math.log2` |
+| `cloneArray`, `cloneTypedArray` | `clone`, `structuredClone`, `slice`    |
+| `IterableIterator`              | `Iterator.from`                        |
+| `id`                            | `identity`                             |
+| `cache`                         | `memoize`                              |
+
+The rest of 1.2 fixes bugs. These fixes change results that code may have worked around:
+
+- `eq`, `lt`, `lte`, `gt` and `gte` now ask an object's own method first and honor a `false` answer, so comparing two `Decimal` values gives the right answer. `eq(0, -0)` is `true`.
+- `deepEqual` and `shallowEqual` tell kinds apart, and compare Dates, RegExps and typed arrays by value.
+- `merge` copies plain objects from its sources and skips `__proto__`, so it no longer changes a source or `Object.prototype`.
+- `difference` removes the values of the other arrays, where it returned a symmetric difference.
+- `uniq` with an iteratee returns the original elements, not the computed keys, and `sortedUniq` sorts them by that key.
+- `memoize` caches an `undefined` result.
+- `divmod` follows Python, so the quotient and remainder add back up to the input.
+- `bisect` and `insort` find the right position in every case.
+- `Deque.set` throws `KeyError` past the end, where the value was lost.
+- A frozen `BTree` refuses `remove`, as it does `set`.
+- `IntlDate` adds months with a clamp to the last day of the month, keeps the wall clock across DST for calendar units, and `diff` counts calendar months, quarters and years. `exact` keeps the averaged result.
+- `addDuration` and `subDuration` read a date-only string as local time, as `IntlDate` does.
+- `format('Z')` prints the numeric offset, such as `-05:00`.
 
 ## Contributing
 If you want to contribute to the project and make it better, your help is very welcome. Contributing is also a great way to learn more about social coding on Github, new technologies and and their ecosystems and how to make constructive, helpful bug reports, feature requests and the noblest of all contributions: a good, clean pull request. You will be listed as a **Champion** on the official site as well.

package/dist/collections/BTree.d.ts

@@ -1,6 +1,6 @@
-import { Comparer } from '../operators/index.js';
+import { type Comparer } from '../operators/index.js';
 import { Mapping } from './abc.js';
-import { Iteratee } from '../types';
+import type { Iteratee } from '../types.js';
 export declare class BTree<K = any, V = any> extends Mapping<K, V> {
     private root;
     count: number;
@@ -14,8 +14,7 @@ export declare class BTree<K = any, V = any> extends Mapping<K, V> {
      * Initializes an empty B+ tree.
      * @param {?Iterable<[K, V]>} [entries] The initial key value pairs.
      * @param compareFn Custom function to compare pairs of elements in the tree.
-     *   If not specified, defaultComparator will be used which is valid as long as K extends DefaultComparable.
-     * @param entries A set of key-value pairs to initialize the tree
+     *   If not specified, {@link operators.compare} is used.
      * @param {number} [maxNodeSize=64] Branching factor (maximum items or children per node)
      *   Must be in range 4..256. If undefined or <4 then default is used; if >256 then 256.
      */
@@ -64,6 +63,7 @@ export declare class BTree<K = any, V = any> extends Mapping<K, V> {
      *         starts at the next higher key (according to the comparator).
      *  @param reusedArray Optional array used repeatedly to store key-value
      *         pairs, to avoid creating a new array on every iteration.
+     *  Note: changing the tree during iteration may skip or repeat keys.
      */
     entries(lowestKey?: K, reusedArray?: Array<K | V>): IterableIterator<[K, V]>;
     /** Returns an iterator that provides items in reversed order.
@@ -74,6 +74,7 @@ export declare class BTree<K = any, V = any> extends Mapping<K, V> {
      *         pairs, to avoid creating a new array on every iteration.
      *  @param skipHighest Iff this flag is true and the highestKey exists in the
      *         collection, the pair matching highestKey is skipped, not iterated.
+     *  Note: changing the tree during iteration may skip or repeat keys.
      */
     reversed(highestKey?: K, reusedArray?: Array<K | V>, skipHighest?: boolean): IterableIterator<[K, V]>;
     private findPath;
@@ -128,8 +129,8 @@ export declare class BTree<K = any, V = any> extends Mapping<K, V> {
      * */
     floor(key: K, reusedArray?: [K, V]): [K, V] | undefined;
     /** Returns the key-value pair associated with the supplied key if it exists
-     *  or the pair associated with the next lower pair otherwise. If there is no
-     *  next lower pair, undefined is returned.
+     *  or the next higher pair otherwise. If there is no next higher pair,
+     *  undefined is returned.
      * @param key The key to search for.
      * @param reusedArray Optional array used repeatedly to store key-value pairs, to
      *        avoid creating a new array each time you call this method.
@@ -142,8 +143,9 @@ export declare class BTree<K = any, V = any> extends Mapping<K, V> {
      * @param high This method returns when a key larger than this is reached.
      * @param includeHigh If the `high` key is present, its pair will be included
      *        in the output if and only if this parameter is true. Note: if the
-     *        `low` key is present, it is always included in the output.
-     * @param maxLength Length limit. getRange will stop scanning the tree when
+     *        `low` key is present, it is included in the output unless `low`
+     *        equals `high` and this parameter is false.
+     * @param maxLength Length limit. keysRange will stop scanning the tree when
      *                  the array reaches this size.
      * @description Computational complexity: O(result.length + log size)
      */
@@ -191,7 +193,7 @@ export declare class BTree<K = any, V = any> extends Mapping<K, V> {
      *        function can return `{value:v}` to change the value associated
      *        with the current key, `{delete:true}` to delete the current pair,
      *        `{done:R}` to stop early with result R, or it can return nothing
-     *        (undefined or {}) to cause no effect and continue iterating.
+     *        (undefined, null or {}) to cause no effect and continue iterating.
      *        `{done:R}` can be combined with one of the other two commands.
      *        The third argument `counter` is the number of items iterated
      *        previously; it equals 0 when `onFound` is called the first time.
@@ -219,7 +221,6 @@ export declare class BTree<K = any, V = any> extends Mapping<K, V> {
      *  BTree object and its leaf nodes (zero if there are no internal nodes). */
     get height(): number;
     /** Makes the object read-only to ensure it is not accidentally modified.
-     *  Freezing does not have to be permanent; unfreeze() reverses the effect.
      *  This is accomplished by replacing mutator functions with a function
      *  that throws an Error. Compared to using a property (e.g. this.isFrozen)
      *  this implementation gives better performance in non-frozen BTrees.

package/dist/collections/BTree.js

@@ -43,7 +43,7 @@ class BNode {
     /// ////////////////////////////////////////////////////////////////////////
     // Shared methods /////////////////////////////////////////////////////////
     maxKey() {
-        return this.keys[this.keys.length - 1];
+        return this.keys.at(-1);
     }
     // If key not found, returns i^failXor where i is the insertion index.
     // Callers that don't care whether there was a match will set failXor=0.
@@ -62,11 +62,9 @@ class BNode {
                 return mid;
             else {
                 // c is NaN or otherwise invalid
-                // eslint-disable-next-line
                 if (key === key)
                     // at least the search key is not NaN
-                    return keys.length;
-                // eslint-disable-next-line
+                    return keys.length ^ failXor;
                 else
                     throw new KeyError(`Btree found an invalid key: ${key}`);
             }
@@ -152,7 +150,6 @@ class BNode {
             else {
                 // This leaf node is full and must split
                 const newRightSibling = this.splitOffRightSide();
-                // eslint-disable-next-line
                 let target = this;
                 if (i > this.keys.length) {
                     i -= this.keys.length;
@@ -205,10 +202,8 @@ class BNode {
         }
         else {
             v = this.reifyValues();
-            // eslint-disable-next-line
             v.push(rhs.values.shift());
         }
-        // eslint-disable-next-line
         this.keys.push(rhs.keys.shift());
     }
     takeFromLeft(lhs) {
@@ -222,10 +217,8 @@ class BNode {
         }
         else {
             v = this.reifyValues();
-            // eslint-disable-next-line
             v.unshift(lhs.values.pop());
         }
-        // eslint-disable-next-line
         this.keys.unshift(lhs.keys.pop());
     }
     splitOffRightSide() {
@@ -256,14 +249,13 @@ class BNode {
                 iHigh++;
         }
         const keys = this.keys;
-        const values = this.values;
         if (onFound !== undefined) {
             for (let i = iLow; i < iHigh; i++) {
                 const key = keys[i];
-                const result = onFound(key, values[i], count++);
-                if (result !== undefined) {
+                const result = onFound(key, this.values[i], count++);
+                if (result != null) {
                     if (editMode) {
-                        if (key !== keys[i] || this.isShared)
+                        if (!Object.is(key, keys[i]) || this.isShared)
                             throw new Error('BTree illegally changed or cloned in editRange');
                         if (result.delete) {
                             this.keys.splice(i, 1);
@@ -273,8 +265,8 @@ class BNode {
                             i--;
                             iHigh--;
                         }
-                        else if (result.value) {
-                            values[i] = result.value;
+                        else if ('value' in Object(result)) {
+                            this.reifyValues()[i] = result.value;
                         }
                     }
                     if (result.done !== undefined)
@@ -283,7 +275,7 @@ class BNode {
             }
         }
         else
-            count += iHigh - iLow;
+            count += Math.max(iHigh - iLow, 0);
         return count;
     }
     /** Adds entire contents of right-hand sibling (rhs is left unchanged) */
@@ -292,7 +284,7 @@ class BNode {
         if (this.values === undefVals) {
             if (rhs.values === undefVals)
                 return;
-            this.values = this.values.slice(0, this.keys.length);
+            this.values = this.values.slice(0, this.keys.length - rhs.keys.length);
         }
         this.values.push.apply(this.values, rhs.reifyValues());
     }
@@ -318,8 +310,7 @@ export class BTree extends Mapping {
      * Initializes an empty B+ tree.
      * @param {?Iterable<[K, V]>} [entries] The initial key value pairs.
      * @param compareFn Custom function to compare pairs of elements in the tree.
-     *   If not specified, defaultComparator will be used which is valid as long as K extends DefaultComparable.
-     * @param entries A set of key-value pairs to initialize the tree
+     *   If not specified, {@link operators.compare} is used.
      * @param {number} [maxNodeSize=64] Branching factor (maximum items or children per node)
      *   Must be in range 4..256. If undefined or <4 then default is used; if >256 then 256.
      */
@@ -365,7 +356,7 @@ export class BTree extends Mapping {
     // private forEachPair<R = number>(callback: Iteratee<K, V>, initialCounter?: number): R | number {
     //   const low = this.minKey()
     //   const high = this.maxKey()
-    //   // eslint-disable-next-line
+    //
     //   return this.rangeForEach(low!, high, true, callback, initialCounter)
     // }
     /**
@@ -399,7 +390,7 @@ export class BTree extends Mapping {
         return true;
     }
     add(key) {
-        return this.set(key, null);
+        return this.set(key, this.get(key, null));
     }
     /**
      * Returns true if the key exists in the B+ tree, false if not.
@@ -407,7 +398,7 @@ export class BTree extends Mapping {
      * @description Computational complexity: O(log size)
      */
     contains(key) {
-        return this.get(key) !== undefined;
+        return this.rangeForEach(key, key, true) !== 0;
     }
     /**
      * Removes a single key-value pair from the B+ tree.
@@ -425,6 +416,7 @@ export class BTree extends Mapping {
      *         starts at the next higher key (according to the comparator).
      *  @param reusedArray Optional array used repeatedly to store key-value
      *         pairs, to avoid creating a new array on every iteration.
+     *  Note: changing the tree during iteration may skip or repeat keys.
      */
     entries(lowestKey, reusedArray) {
         const info = this.findPath(lowestKey);
@@ -434,7 +426,6 @@ export class BTree extends Mapping {
         let state = reusedArray !== undefined ? 1 : 0;
         let i = lowestKey === undefined ? -1 : leaf.indexOf(lowestKey, 0, this._compare) - 1;
         return iterator(() => {
-            // eslint-disable-next-line
             jump: while (true) {
                 switch (state) {
                     case 0:
@@ -444,32 +435,29 @@ export class BTree extends Mapping {
                         continue;
                     case 1:
                         if (++i < leaf.keys.length) {
-                            // eslint-disable-next-line
                             reusedArray[0] = leaf.keys[i];
-                            // eslint-disable-next-line
                             reusedArray[1] = leaf.values[i];
                             return { done: false, value: reusedArray };
                         }
                         state = 2;
-                    // eslint-disable-next-line
                     case 2:
                         // Advance to the next leaf node
-                        // eslint-disable-next-line
                         let level = -1;
                         while (true) {
                             if (++level >= nodequeue.length) {
                                 state = 3;
-                                // eslint-disable-next-line
                                 continue jump;
                             }
                             if (++nodeindex[level] < nodequeue[level].length)
                                 break;
                         }
+                        // Keys removed during iteration can leave this path empty.
                         for (; level > 0; level--) {
-                            nodequeue[level - 1] = nodequeue[level][nodeindex[level]].children;
+                            const parent = nodequeue[level][nodeindex[level]];
+                            nodequeue[level - 1] = parent?.children ?? EmptyArray;
                             nodeindex[level - 1] = 0;
                         }
-                        leaf = nodequeue[0][nodeindex[0]];
+                        leaf = nodequeue[0][nodeindex[0]] ?? EmptyLeaf;
                         i = -1;
                         state = reusedArray !== undefined ? 1 : 0;
                         continue;
@@ -487,58 +475,53 @@ export class BTree extends Mapping {
      *         pairs, to avoid creating a new array on every iteration.
      *  @param skipHighest Iff this flag is true and the highestKey exists in the
      *         collection, the pair matching highestKey is skipped, not iterated.
+     *  Note: changing the tree during iteration may skip or repeat keys.
      */
     reversed(highestKey, reusedArray, skipHighest) {
-        if (highestKey === undefined) {
-            highestKey = this.maxKey();
-            skipHighest = undefined;
-            if (highestKey === undefined)
-                return iterator(); // collection is empty
-        }
-        // eslint-disable-next-line
-        let { nodequeue, nodeindex, leaf } = this.findPath(highestKey) || this.findPath(this.maxKey());
+        let { nodequeue, nodeindex, leaf } = this.findPath(highestKey, true) || this.findPath(undefined, true);
         assert(!nodequeue[0] || leaf === nodequeue[0][nodeindex[0]], 'wat!');
-        let i = leaf.indexOf(highestKey, 0, this._compare);
-        if (!skipHighest && i < leaf.keys.length && this._compare(leaf.keys[i], highestKey) <= 0)
-            i++;
+        let i = leaf.keys.length;
+        if (highestKey !== undefined) {
+            i = leaf.indexOf(highestKey, 0, this._compare);
+            if (!skipHighest && i < leaf.keys.length && this._compare(leaf.keys[i], highestKey) <= 0)
+                i++;
+        }
         let state = reusedArray !== undefined ? 1 : 0;
         return iterator(() => {
-            // eslint-disable-next-line
             jump: while (true) {
                 switch (state) {
                     case 0:
-                        if (--i >= 0)
+                        i = Math.min(i, leaf.keys.length) - 1;
+                        if (i >= 0)
                             return { done: false, value: [leaf.keys[i], leaf.values[i]] };
                         state = 2;
                         continue;
                     case 1:
-                        if (--i >= 0) {
-                            // eslint-disable-next-line
+                        i = Math.min(i, leaf.keys.length) - 1;
+                        if (i >= 0) {
                             reusedArray[0] = leaf.keys[i];
-                            // eslint-disable-next-line
                             reusedArray[1] = leaf.values[i];
                             return { done: false, value: reusedArray };
                         }
                         state = 2;
-                    // eslint-disable-next-line
                     case 2:
                         // Advance to the next leaf node
-                        // eslint-disable-next-line
                         let level = -1;
                         while (true) {
                             if (++level >= nodequeue.length) {
                                 state = 3;
-                                // eslint-disable-next-line
                                 continue jump;
                             }
                             if (--nodeindex[level] >= 0)
                                 break;
                         }
+                        // Keys removed during iteration can leave this path empty.
                         for (; level > 0; level--) {
-                            nodequeue[level - 1] = nodequeue[level][nodeindex[level]].children;
+                            const parent = nodequeue[level][nodeindex[level]];
+                            nodequeue[level - 1] = parent?.children ?? EmptyArray;
                             nodeindex[level - 1] = nodequeue[level - 1].length - 1;
                         }
-                        leaf = nodequeue[0][nodeindex[0]];
+                        leaf = nodequeue[0][nodeindex[0]] ?? EmptyLeaf;
                         i = leaf.keys.length;
                         state = reusedArray !== undefined ? 1 : 0;
                         continue;
@@ -548,7 +531,7 @@ export class BTree extends Mapping {
             }
         });
     }
-    /* Used by entries() and entriesReversed() to prepare to start iterating.
+    /* Used by entries() and reversed() to prepare to start iterating.
      * It develops a "node queue" for each non-leaf level of the tree.
      * Levels are numbered "bottom-up" so that level 0 is a list of leaf
      * nodes from a low-level non-leaf node. The queue at a given level L
@@ -558,7 +541,7 @@ export class BTree extends Mapping {
      * (However inside this function the order is reversed.)
      * @private
      */
-    findPath(key) {
+    findPath(key, fromEnd = false) {
         let nextnode = this.root;
         let nodequeue, nodeindex;
         if (nextnode.isLeaf) {
@@ -571,7 +554,10 @@ export class BTree extends Mapping {
             nodeindex = [];
             for (let d = 0; !nextnode.isLeaf; d++) {
                 nodequeue[d] = nextnode.children;
-                nodeindex[d] = key === undefined ? 0 : nextnode.indexOf(key, 0, this._compare);
+                if (key !== undefined)
+                    nodeindex[d] = nextnode.indexOf(key, 0, this._compare);
+                else
+                    nodeindex[d] = fromEnd ? nodequeue[d].length - 1 : 0;
                 if (nodeindex[d] >= nodequeue[d].length)
                     return; // first key > maxKey()
                 nextnode = nodequeue[d][nodeindex[d]];
@@ -642,12 +628,7 @@ export class BTree extends Mapping {
     }
     /** Gets an array filled with the contents of the tree, sorted by key */
     toArray() {
-        const min = this.minKey();
-        const max = this.maxKey();
-        const maxLength = 2147483647;
-        if (min !== undefined)
-            return this.keysRange(min, max, true, maxLength);
-        return [];
+        return [...this.entries()];
     }
     /** Gets a string representing the tree's data based on toArray(). */
     toString() {
@@ -660,7 +641,7 @@ export class BTree extends Mapping {
      * avoid creating a new array on every iteration.
      */
     lowerBound(key, reusedArray) {
-        reusedArray = reusedArray || [];
+        reusedArray ||= [];
         if (key === undefined) {
             return this.root.minPair(reusedArray);
         }
@@ -680,7 +661,7 @@ export class BTree extends Mapping {
      *        avoid creating a new array each time you call this method.
      */
     upperBound(key, reusedArray) {
-        reusedArray = reusedArray || [];
+        reusedArray ||= [];
         if (key === undefined) {
             return this.root.maxPair(reusedArray);
         }
@@ -704,8 +685,8 @@ export class BTree extends Mapping {
         return this.root.getPairOrNextLower(key, this._compare, true, reusedArray || []);
     }
     /** Returns the key-value pair associated with the supplied key if it exists
-     *  or the pair associated with the next lower pair otherwise. If there is no
-     *  next lower pair, undefined is returned.
+     *  or the next higher pair otherwise. If there is no next higher pair,
+     *  undefined is returned.
      * @param key The key to search for.
      * @param reusedArray Optional array used repeatedly to store key-value pairs, to
      *        avoid creating a new array each time you call this method.
@@ -720,16 +701,18 @@ export class BTree extends Mapping {
      * @param high This method returns when a key larger than this is reached.
      * @param includeHigh If the `high` key is present, its pair will be included
      *        in the output if and only if this parameter is true. Note: if the
-     *        `low` key is present, it is always included in the output.
-     * @param maxLength Length limit. getRange will stop scanning the tree when
+     *        `low` key is present, it is included in the output unless `low`
+     *        equals `high` and this parameter is false.
+     * @param maxLength Length limit. keysRange will stop scanning the tree when
      *                  the array reaches this size.
      * @description Computational complexity: O(result.length + log size)
      */
     keysRange(low, high, includeHigh, maxLength = 0x3ffffff) {
         const results = [];
         this.root.forRange(low, high, includeHigh, false, this, 0, (k, v) => {
+            if (results.length >= maxLength)
+                return Break;
             results.push([k, v]);
-            return results.length > maxLength ? Break : undefined;
         });
         return results;
     }
@@ -743,8 +726,8 @@ export class BTree extends Mapping {
     extend(entries) {
         let added = 0;
         for (const pair of entries) {
-            this.set(pair[0], pair[1] ?? null);
-            added++;
+            if (this.set(pair[0], pair[1] ?? null))
+                added++;
         }
         return added;
     }
@@ -786,7 +769,7 @@ export class BTree extends Mapping {
      *        function can return `{value:v}` to change the value associated
      *        with the current key, `{delete:true}` to delete the current pair,
      *        `{done:R}` to stop early with result R, or it can return nothing
-     *        (undefined or {}) to cause no effect and continue iterating.
+     *        (undefined, null or {}) to cause no effect and continue iterating.
      *        `{done:R}` can be combined with one of the other two commands.
      *        The third argument `counter` is the number of items iterated
      *        previously; it equals 0 when `onFound` is called the first time.
@@ -850,18 +833,17 @@ export class BTree extends Mapping {
         return height;
     }
     /** Makes the object read-only to ensure it is not accidentally modified.
-     *  Freezing does not have to be permanent; unfreeze() reverses the effect.
      *  This is accomplished by replacing mutator functions with a function
      *  that throws an Error. Compared to using a property (e.g. this.isFrozen)
      *  this implementation gives better performance in non-frozen BTrees.
      */
     freeze() {
         const t = this;
-        // Note: all other mutators ultimately call set() or editRange()
+        // Note: all other mutators ultimately call set() or rangeUpdate()
         //       so we don't need to override those others.
         t.clear =
             t.set =
-                t.editRange =
+                t.rangeUpdate =
                     () => {
                         throw TypeError('Attempted to modify a frozen BTree');
                     };
@@ -918,12 +900,12 @@ class BNodeInternal extends BNode {
         return this.children[0].minPair(reusedArray);
     }
     maxPair(reusedArray) {
-        return this.children[this.children.length - 1].maxPair(reusedArray);
+        return this.children.at(-1).maxPair(reusedArray);
     }
     get(key, defaultValue, tree) {
         const i = this.indexOf(key, 0, tree._compare);
         const children = this.children;
-        return i < children.length ? children[i].get(key, defaultValue, tree) : undefined;
+        return i < children.length ? children[i].get(key, defaultValue, tree) : defaultValue;
     }
     getPairOrNextLower(key, compare, inclusive, reusedArray) {
         const i = this.indexOf(key, 0, compare);
@@ -1006,9 +988,9 @@ class BNodeInternal extends BNode {
             }
         }
         const result = child.set(key, value, overwrite, tree);
+        this.keys[i] = child.maxKey();
         if (result === false)
             return false;
-        this.keys[i] = child.maxKey();
         if (result === true)
             return true;
         // The child has split and `result` is a new right child... does it fit?
@@ -1051,18 +1033,14 @@ class BNodeInternal extends BNode {
         // Reminder: parent node must update its copy of key for this node
         // assert: neither node is shared
         // assert rhs.keys.length > (maxNodeSize/2 && this.keys.length<maxNodeSize)
-        // eslint-disable-next-line
         this.keys.push(rhs.keys.shift());
-        // eslint-disable-next-line
         this.children.push(rhs.children.shift());
     }
     takeFromLeft(lhs) {
         // Reminder: parent node must update its copy of key for this node
         // assert: neither node is shared
         // assert rhs.keys.length > (maxNodeSize/2 && this.keys.length<maxNodeSize)
-        // eslint-disable-next-line
         this.keys.unshift(lhs.keys.pop());
-        // eslint-disable-next-line
         this.children.unshift(lhs.children.pop());
     }
     /// //////////////////////////////////////////////////////////////////////////

package/dist/collections/Heap.js

@@ -87,7 +87,7 @@ export class Heap extends Collection {
      * @return `true` if the item was removed.
      */
     remove(item) {
-        const index = this.heap.indexOf(item);
+        const index = Number.isNaN(item) ? this.heap.findIndex(Number.isNaN) : this.heap.indexOf(item);
         if (index < 0)
             return false;
         if (index === 0) {