btree-core 3.2.1

package/extended/index.js

@@ -0,0 +1,200 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BTreeEx = void 0;
+var b_tree_1 = __importStar(require("../b+tree"));
+var diffAgainst_1 = __importDefault(require("./diffAgainst"));
+var forEachKeyInBoth_1 = __importDefault(require("./forEachKeyInBoth"));
+var forEachKeyNotIn_1 = __importDefault(require("./forEachKeyNotIn"));
+var intersect_1 = __importDefault(require("./intersect"));
+var subtract_1 = __importDefault(require("./subtract"));
+var union_1 = __importDefault(require("./union"));
+var bulkLoad_1 = require("./bulkLoad");
+/**
+ * An extended version of the `BTree` class that includes additional functionality
+ * such as bulk loading, set operations, and diffing.
+ * It is separated to keep the core BTree class small from a bundle size perspective.
+ * Note: each additional functionality piece is available as a standalone function from the extended folder.
+ * @extends BTree
+ */
+var BTreeEx = /** @class */ (function (_super) {
+    __extends(BTreeEx, _super);
+    function BTreeEx() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Bulk loads a new `BTreeEx` from parallel arrays of sorted entries.
+     * This reuses the same algorithm as `extended/bulkLoad`, but produces a `BTreeEx`.
+     * Time and space complexity are O(n).
+     * @param keys Keys to load, sorted by key in strictly ascending order.
+     * @param values Values aligned with the supplied keys.
+     * @param maxNodeSize The branching factor (maximum number of children per node).
+     * @param compare Comparator to use. Defaults to the standard comparator if omitted.
+     * @returns A fully built tree containing the supplied entries.
+     * @throws Error if the entries are not strictly sorted or contain duplicate keys.
+     */
+    BTreeEx.bulkLoad = function (keys, values, maxNodeSize, compare) {
+        var cmp = compare !== null && compare !== void 0 ? compare : b_tree_1.defaultComparator;
+        var root = (0, bulkLoad_1.bulkLoadRoot)(keys, values, maxNodeSize, cmp);
+        var tree = new BTreeEx(undefined, cmp, maxNodeSize);
+        var target = tree;
+        target._root = root;
+        return tree;
+    };
+    /** See {@link BTree.clone}. */
+    BTreeEx.prototype.clone = function () {
+        var source = this;
+        source._root.isShared = true;
+        var result = new BTreeEx(undefined, this._compare, this._maxNodeSize);
+        var target = result;
+        target._root = source._root;
+        return result;
+    };
+    /** See {@link BTree.greedyClone}. */
+    BTreeEx.prototype.greedyClone = function (force) {
+        var source = this;
+        var result = new BTreeEx(undefined, this._compare, this._maxNodeSize);
+        var target = result;
+        target._root = source._root.greedyClone(force);
+        return result;
+    };
+    /**
+     * Computes the differences between `this` and `other`.
+     * For efficiency, the diff is returned via invocations of supplied handlers.
+     * The computation is optimized for the case in which the two trees have large amounts of shared data
+     * (obtained by calling the `clone` or `with` APIs) and will avoid any iteration of shared state.
+     * The handlers can cause computation to early exit by returning `{ break: R }`.
+     * Neither collection should be mutated during the comparison (inside your callbacks), as this method assumes they remain stable.
+     * @param other The tree to compute a diff against.
+     * @param onlyThis Callback invoked for all keys only present in `this`.
+     * @param onlyOther Callback invoked for all keys only present in `other`.
+     * @param different Callback invoked for all keys with differing values.
+     * @returns The first `break` payload returned by a handler, or `undefined` if no handler breaks.
+     * @throws Error if the supplied trees were created with different comparators.
+     */
+    BTreeEx.prototype.diffAgainst = function (other, onlyThis, onlyOther, different) {
+        return (0, diffAgainst_1.default)(this, other, onlyThis, onlyOther, different);
+    };
+    /**
+     * Calls the supplied `callback` for each key/value pair shared by this tree and `other`, in sorted key order.
+     * Neither tree is modified.
+     *
+     * Complexity is O(N + M) when the trees overlap heavily, and additionally bounded by O(log(N + M) * D)
+     * where `D` is the number of disjoint key ranges between the trees, because disjoint subtrees are skipped.
+     * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+     * numbers of non-overlapping key ranges it is much faster.
+     * @param other The other tree to compare with this one.
+     * @param callback Called for keys that appear in both trees. It can cause iteration to early exit by returning `{ break: R }`.
+     * @returns The first `break` payload returned by the callback, or `undefined` if the walk finishes.
+     * @throws Error if the two trees were created with different comparators.
+     */
+    BTreeEx.prototype.forEachKeyInBoth = function (other, callback) {
+        return (0, forEachKeyInBoth_1.default)(this, other, callback);
+    };
+    /**
+     * Calls the supplied `callback` for each key/value pair that exists in this tree but not in `other`
+     * (set subtraction). The callback runs in sorted key order and neither tree is modified.
+     *
+     * Complexity is O(N + M) when the key ranges overlap heavily, and additionally bounded by O(log(N + M) * D)
+     * where `D` is the number of disjoint ranges between the trees, because non-overlapping subtrees are skipped.
+     * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+     * numbers of non-overlapping key ranges it is much faster.
+     * @param other Keys present in this tree will be omitted from the callback.
+     * @param callback Invoked for keys unique to `this`. It can cause iteration to early exit by returning `{ break: R }`.
+     * @returns The first `break` payload returned by the callback, or `undefined` if all qualifying keys are visited.
+     * @throws Error if the trees were created with different comparators.
+     */
+    BTreeEx.prototype.forEachKeyNotIn = function (other, callback) {
+        return (0, forEachKeyNotIn_1.default)(this, other, callback);
+    };
+    /**
+     * Returns a new tree containing only keys present in both trees.
+     * Neither tree is modified.
+     *
+     * Complexity is O(N + M) in the fully overlapping case and additionally bounded by O(log(N + M) * D),
+     * where `D` is the number of disjoint key ranges, because disjoint subtrees are skipped entirely.
+     * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+     * numbers of non-overlapping key ranges it is much faster.
+     * @param other The other tree to intersect with this one.
+     * @param combineFn Called for keys that appear in both trees. Return the desired value.
+     * @returns A new `BTreeEx` populated with the intersection.
+     * @throws Error if the trees were created with different comparators.
+     */
+    BTreeEx.prototype.intersect = function (other, combineFn) {
+        return (0, intersect_1.default)(this, other, combineFn);
+    };
+    /**
+     * Efficiently unions this tree with `other`, reusing subtrees wherever possible without modifying either input.
+     *
+     * Complexity is O(N + M) in the fully overlapping case, and additionally bounded by O(log(N + M) * D)
+     * where `D` is the number of disjoint key ranges, because disjoint subtrees are skipped entirely.
+     * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+     * numbers of non-overlapping key ranges it is much faster.
+     * @param other The other tree to union with this one.
+     * @param combineFn Called for keys that appear in both trees. Return the desired value, or `undefined` to omit the key.
+     * @returns A new `BTreeEx` that contains the unioned key/value pairs.
+     * @throws Error if the trees were created with different comparators or max node sizes.
+     */
+    BTreeEx.prototype.union = function (other, combineFn) {
+        return (0, union_1.default)(this, other, combineFn);
+    };
+    /**
+     * Returns a new tree containing only the keys that are present in this tree but not `other` (set subtraction).
+     * Neither input tree is modified.
+     *
+     * Complexity is O(N + M) for time and O(N) for allocations in the worst case. Additionally, time is bounded by
+     * O(log(N + M) * D1) and space by O(log N * D2) where `D1` is the number of disjoint key ranges between the trees
+     * and `D2` is the number of disjoint ranges inside this tree.
+     * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+     * numbers of non-overlapping key ranges it is much faster.
+     * @param other The tree whose keys will be removed from the result.
+     * @returns A new `BTreeEx` representing `this \ other`.
+     * @throws Error if the trees were created with different comparators or max node sizes.
+     */
+    BTreeEx.prototype.subtract = function (other) {
+        return (0, subtract_1.default)(this, other);
+    };
+    return BTreeEx;
+}(b_tree_1.default));
+exports.BTreeEx = BTreeEx;
+exports.default = BTreeEx;

package/extended/index.min.js

@@ -0,0 +1 @@
+"use strict";var __extends=this&&this.__extends||function(){var o=function(t,e){return(o=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var r in e)Object.prototype.hasOwnProperty.call(e,r)&&(t[r]=e[r])})(t,e)};return function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Class extends value "+String(e)+" is not a constructor or null");function r(){this.constructor=t}o(t,e),t.prototype=null===e?Object.create(e):(r.prototype=e.prototype,new r)}}(),__createBinding=this&&this.__createBinding||(Object.create?function(t,e,r,o){void 0===o&&(o=r);var n=Object.getOwnPropertyDescriptor(e,r);n&&("get"in n?e.__esModule:!n.writable&&!n.configurable)||(n={enumerable:!0,get:function(){return e[r]}}),Object.defineProperty(t,o,n)}:function(t,e,r,o){void 0===o&&(o=r),t[o]=e[r]}),__setModuleDefault=this&&this.__setModuleDefault||(Object.create?function(t,e){Object.defineProperty(t,"default",{enumerable:!0,value:e})}:function(t,e){t.default=e}),__importStar=this&&this.__importStar||function(t){if(t&&t.__esModule)return t;var e={};if(null!=t)for(var r in t)"default"!==r&&Object.prototype.hasOwnProperty.call(t,r)&&__createBinding(e,t,r);return __setModuleDefault(e,t),e},__importDefault=this&&this.__importDefault||function(t){return t&&t.__esModule?t:{default:t}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.BTreeEx=void 0;var b_tree_1=__importStar(require("../b+tree")),diffAgainst_1=__importDefault(require("./diffAgainst")),forEachKeyInBoth_1=__importDefault(require("./forEachKeyInBoth")),forEachKeyNotIn_1=__importDefault(require("./forEachKeyNotIn")),intersect_1=__importDefault(require("./intersect")),subtract_1=__importDefault(require("./subtract")),union_1=__importDefault(require("./union")),bulkLoad_1=require("./bulkLoad"),BTreeEx=function(t){function n(){return null!==t&&t.apply(this,arguments)||this}return __extends(n,t),n.bulkLoad=function(t,e,r,o){o=null!=o?o:b_tree_1.defaultComparator,e=(0,bulkLoad_1.bulkLoadRoot)(t,e,r,o),r=new n(void 0,o,r);return r._root=e,r},n.prototype.clone=function(){this._root.isShared=!0;var t=new n(void 0,this._compare,this._maxNodeSize);return t._root=this._root,t},n.prototype.greedyClone=function(t){var e=new n(void 0,this._compare,this._maxNodeSize);return e._root=this._root.greedyClone(t),e},n.prototype.diffAgainst=function(t,e,r,o){return(0,diffAgainst_1.default)(this,t,e,r,o)},n.prototype.forEachKeyInBoth=function(t,e){return(0,forEachKeyInBoth_1.default)(this,t,e)},n.prototype.forEachKeyNotIn=function(t,e){return(0,forEachKeyNotIn_1.default)(this,t,e)},n.prototype.intersect=function(t,e){return(0,intersect_1.default)(this,t,e)},n.prototype.union=function(t,e){return(0,union_1.default)(this,t,e)},n.prototype.subtract=function(t){return(0,subtract_1.default)(this,t)},n}(b_tree_1.default);exports.BTreeEx=BTreeEx,exports.default=BTreeEx;

package/extended/intersect.d.ts

@@ -0,0 +1,16 @@
+import BTree from '../b+tree';
+/**
+ * Returns a new tree containing only keys present in both input trees.
+ * Neither tree is modified.
+ *
+ * Complexity is O(N + M) in the fully overlapping case and additionally bounded by O(log(N + M) * D),
+ * where `D` is the number of disjoint key ranges, because disjoint subtrees are skipped entirely.
+ * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+ * numbers of non-overlapping key ranges it is much faster.
+ * @param treeA First tree to intersect.
+ * @param treeB Second tree to intersect.
+ * @param combineFn Called for keys that appear in both trees. Return the desired value.
+ * @returns A new tree populated with the intersection.
+ * @throws Error if the trees were created with different comparators.
+ */
+export default function intersect<TBTree extends BTree<K, V>, K, V>(treeA: TBTree, treeB: TBTree, combineFn: (key: K, leftValue: V, rightValue: V) => V): TBTree;

package/extended/intersect.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var shared_1 = require("./shared");
+var forEachKeyInBoth_1 = __importDefault(require("./forEachKeyInBoth"));
+var bulkLoad_1 = require("./bulkLoad");
+/**
+ * Returns a new tree containing only keys present in both input trees.
+ * Neither tree is modified.
+ *
+ * Complexity is O(N + M) in the fully overlapping case and additionally bounded by O(log(N + M) * D),
+ * where `D` is the number of disjoint key ranges, because disjoint subtrees are skipped entirely.
+ * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+ * numbers of non-overlapping key ranges it is much faster.
+ * @param treeA First tree to intersect.
+ * @param treeB Second tree to intersect.
+ * @param combineFn Called for keys that appear in both trees. Return the desired value.
+ * @returns A new tree populated with the intersection.
+ * @throws Error if the trees were created with different comparators.
+ */
+function intersect(treeA, treeB, combineFn) {
+    var _treeA = treeA;
+    var _treeB = treeB;
+    var branchingFactor = (0, shared_1.checkCanDoSetOperation)(_treeA, _treeB, true);
+    if (_treeA._root.size() === 0)
+        return treeA.clone();
+    if (_treeB._root.size() === 0)
+        return treeB.clone();
+    var intersectedKeys = [];
+    var intersectedValues = [];
+    (0, forEachKeyInBoth_1.default)(treeA, treeB, function (key, leftValue, rightValue) {
+        var mergedValue = combineFn(key, leftValue, rightValue);
+        intersectedKeys.push(key);
+        intersectedValues.push(mergedValue);
+    });
+    // Intersected keys are guaranteed to be in order, so we can bulk load
+    var constructor = treeA.constructor;
+    var resultTree = new constructor(undefined, treeA._compare, branchingFactor);
+    resultTree._root = (0, bulkLoad_1.bulkLoadRoot)(intersectedKeys, intersectedValues, branchingFactor, treeA._compare);
+    return resultTree;
+}
+exports.default = intersect;

package/extended/intersect.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});var shared_1=require("./shared"),forEachKeyInBoth_1=__importDefault(require("./forEachKeyInBoth")),bulkLoad_1=require("./bulkLoad");function intersect(e,r,o){var t=e,u=r,a=(0,shared_1.checkCanDoSetOperation)(t,u,!0);if(0===t._root.size())return e.clone();if(0===u._root.size())return r.clone();var n=[],i=[];(0,forEachKeyInBoth_1.default)(e,r,function(e,r,t){t=o(e,r,t);n.push(e),i.push(t)});r=new e.constructor(void 0,e._compare,a);return r._root=(0,bulkLoad_1.bulkLoadRoot)(n,i,a,e._compare),r}exports.default=intersect;

package/extended/parallelWalk.d.ts

@@ -0,0 +1 @@
+export {};

package/extended/parallelWalk.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = exports.moveTo = exports.getKey = exports.createCursor = exports.moveForwardOne = void 0;
+/**
+ * Walks the cursor forward by one key.
+ * Returns true if end-of-tree was reached (cursor not structurally mutated).
+ * Optimized for this case over the more general `moveTo` function.
+ * @internal
+ */
+function moveForwardOne(cur, other) {
+    var leaf = cur.leaf;
+    var nextIndex = cur.leafIndex + 1;
+    if (nextIndex < leaf.keys.length) {
+        // Still within current leaf
+        cur.onMoveInLeaf(leaf, cur.leafPayload, cur.leafIndex, nextIndex, true);
+        cur.leafIndex = nextIndex;
+        return false;
+    }
+    // If our optimized step within leaf failed, use full moveTo logic
+    // Pass isInclusive=false to ensure we walk forward to the key exactly after the current
+    return moveTo(cur, other, getKey(cur), false, true)[0];
+}
+exports.moveForwardOne = moveForwardOne;
+/**
+ * Create a cursor pointing to the leftmost key of the supplied tree.
+ * @internal
+ */
+function createCursor(tree, makePayload, onEnterLeaf, onMoveInLeaf, onExitLeaf, onStepUp, onStepDown) {
+    var spine = [];
+    var n = tree._root;
+    while (!n.isLeaf) {
+        var ni = n;
+        var payload = makePayload();
+        spine.push({ node: ni, childIndex: 0, payload: payload });
+        n = ni.children[0];
+    }
+    var leafPayload = makePayload();
+    var cur = {
+        tree: tree,
+        leaf: n, leafIndex: 0,
+        spine: spine,
+        leafPayload: leafPayload,
+        makePayload: makePayload,
+        onEnterLeaf: onEnterLeaf,
+        onMoveInLeaf: onMoveInLeaf,
+        onExitLeaf: onExitLeaf,
+        onStepUp: onStepUp,
+        onStepDown: onStepDown
+    };
+    return cur;
+}
+exports.createCursor = createCursor;
+/**
+ * Gets the key at the current cursor position.
+ * @internal
+ */
+function getKey(c) {
+    return c.leaf.keys[c.leafIndex];
+}
+exports.getKey = getKey;
+/**
+ * Move cursor strictly forward to the first key >= (inclusive) or > (exclusive) target.
+ * Returns a boolean indicating if end-of-tree was reached (cursor not structurally mutated).
+ * Also returns a boolean indicating if the target key was landed on exactly.
+ * @internal
+ */
+function moveTo(cur, other, targetKey, isInclusive, startedEqual) {
+    // Cache for perf
+    var cmp = cur.tree._compare;
+    var onMoveInLeaf = cur.onMoveInLeaf;
+    // Fast path: destination within current leaf
+    var leaf = cur.leaf;
+    var leafPayload = cur.leafPayload;
+    var i = leaf.indexOf(targetKey, -1, cmp);
+    var destInLeaf;
+    var targetExactlyReached;
+    if (i < 0) {
+        destInLeaf = ~i;
+        targetExactlyReached = false;
+    }
+    else {
+        if (isInclusive) {
+            destInLeaf = i;
+            targetExactlyReached = true;
+        }
+        else {
+            destInLeaf = i + 1;
+            targetExactlyReached = false;
+        }
+    }
+    var leafKeyCount = leaf.keys.length;
+    if (destInLeaf < leafKeyCount) {
+        onMoveInLeaf(leaf, leafPayload, cur.leafIndex, destInLeaf, startedEqual);
+        cur.leafIndex = destInLeaf;
+        return [false, targetExactlyReached];
+    }
+    // Find first ancestor with a viable right step
+    var spine = cur.spine;
+    var initialSpineLength = spine.length;
+    var descentLevel = -1;
+    var descentIndex = -1;
+    for (var s = initialSpineLength - 1; s >= 0; s--) {
+        var parent = spine[s].node;
+        var indexOf = parent.indexOf(targetKey, -1, cmp);
+        var stepDownIndex = void 0;
+        if (indexOf < 0) {
+            stepDownIndex = ~indexOf;
+        }
+        else {
+            stepDownIndex = isInclusive ? indexOf : indexOf + 1;
+        }
+        // Note: when key not found, indexOf with failXor=0 already returns insertion index
+        if (stepDownIndex < parent.keys.length) {
+            descentLevel = s;
+            descentIndex = stepDownIndex;
+            break;
+        }
+    }
+    // Exit leaf; even if no spine, we did walk out of it conceptually
+    var startIndex = cur.leafIndex;
+    cur.onExitLeaf(leaf, leafPayload, startIndex, startedEqual, cur);
+    var onStepUp = cur.onStepUp;
+    if (descentLevel < 0) {
+        // No descent point; step up all the way; last callback gets infinity
+        for (var depth = initialSpineLength - 1; depth >= 0; depth--) {
+            var entry_1 = spine[depth];
+            var sd = depth === 0 ? Number.POSITIVE_INFINITY : Number.NaN;
+            onStepUp(entry_1.node, initialSpineLength - depth, entry_1.payload, entry_1.childIndex, depth, sd, cur, other);
+        }
+        return [true, false];
+    }
+    // Step up through ancestors above the descentLevel
+    for (var depth = initialSpineLength - 1; depth > descentLevel; depth--) {
+        var entry_2 = spine[depth];
+        onStepUp(entry_2.node, initialSpineLength - depth, entry_2.payload, entry_2.childIndex, depth, Number.NaN, cur, other);
+    }
+    var entry = spine[descentLevel];
+    onStepUp(entry.node, initialSpineLength - descentLevel, entry.payload, entry.childIndex, descentLevel, descentIndex, cur, other);
+    entry.childIndex = descentIndex;
+    var onStepDown = cur.onStepDown;
+    var makePayload = cur.makePayload;
+    // Descend, invoking onStepDown and creating payloads
+    var height = initialSpineLength - descentLevel - 1; // calculate height before changing length
+    spine.length = descentLevel + 1;
+    var node = spine[descentLevel].node.children[descentIndex];
+    while (!node.isLeaf) {
+        var ni = node;
+        var keys = ni.keys;
+        var stepDownIndex = ni.indexOf(targetKey, 0, cmp);
+        if (!isInclusive && stepDownIndex < keys.length && cmp(keys[stepDownIndex], targetKey) === 0)
+            stepDownIndex++;
+        var payload = makePayload();
+        var spineIndex = spine.length;
+        spine.push({ node: ni, childIndex: stepDownIndex, payload: payload });
+        onStepDown(ni, height, spineIndex, stepDownIndex, cur, other);
+        node = ni.children[stepDownIndex];
+        height -= 1;
+    }
+    // Enter destination leaf
+    var idx = node.indexOf(targetKey, -1, cmp);
+    var destIndex;
+    if (idx < 0) {
+        destIndex = ~idx;
+        targetExactlyReached = false;
+    }
+    else {
+        if (isInclusive) {
+            destIndex = idx;
+            targetExactlyReached = true;
+        }
+        else {
+            destIndex = idx + 1;
+            targetExactlyReached = false;
+        }
+    }
+    cur.leaf = node;
+    cur.leafPayload = makePayload();
+    cur.leafIndex = destIndex;
+    cur.onEnterLeaf(node, destIndex, cur, other);
+    return [false, targetExactlyReached];
+}
+exports.moveTo = moveTo;
+/**
+ * A no-operation function.
+ * @internal
+ */
+function noop() { }
+exports.noop = noop;

package/extended/parallelWalk.min.js

@@ -0,0 +1 @@
+"use strict";function moveForwardOne(e,o){var n=e.leaf,a=e.leafIndex+1;return a<n.keys.length?(e.onMoveInLeaf(n,e.leafPayload,e.leafIndex,a,!0),e.leafIndex=a,!1):moveTo(e,o,getKey(e),!1,!0)[0]}function createCursor(e,o,n,a,r,d,t){for(var l=[],f=e._root;!f.isLeaf;){var p=f,x=o();l.push({node:p,childIndex:0,payload:x}),f=p.children[0]}return{tree:e,leaf:f,leafIndex:0,spine:l,leafPayload:o(),makePayload:o,onEnterLeaf:n,onMoveInLeaf:a,onExitLeaf:r,onStepUp:d,onStepDown:t}}function getKey(e){return e.leaf.keys[e.leafIndex]}function moveTo(e,o,n,a,r){var d=e.tree._compare,t=e.onMoveInLeaf,l=e.leaf,f=e.leafPayload,p=l.indexOf(n,-1,d),p=p<0?(h=~p,!1):a?(h=p,!0):(h=p+1,!1);if(h<l.keys.length)return t(l,f,e.leafIndex,h,r),e.leafIndex=h,[!1,p];for(var x=e.spine,i=x.length,v=-1,s=-1,u=i-1;0<=u;u--){var I=x[u].node,y=I.indexOf(n,-1,d),c=void 0;if((c=y<0?~y:a?y:y+1)<I.keys.length){v=u,s=c;break}}var h=e.leafIndex;e.onExitLeaf(l,f,h,r,e);var m=e.onStepUp;if(v<0){for(var g=i-1;0<=g;g--){var O=x[g],L=0===g?Number.POSITIVE_INFINITY:Number.NaN;m(O.node,i-g,O.payload,O.childIndex,g,L,e,o)}return[!0,!1]}for(g=i-1;v<g;g--){var N=x[g];m(N.node,i-g,N.payload,N.childIndex,g,Number.NaN,e,o)}r=x[v];m(r.node,i-v,r.payload,r.childIndex,v,s,e,o),r.childIndex=s;var k=e.onStepDown,P=e.makePayload,T=i-v-1;x.length=v+1;for(var w=x[v].node.children[s];!w.isLeaf;){var b=w,E=b.keys,c=b.indexOf(n,0,d);!a&&c<E.length&&0===d(E[c],n)&&c++;var F=P(),E=x.length;x.push({node:b,childIndex:c,payload:F}),k(b,T,E,c,e,o),w=b.children[c],--T}var K,r=w.indexOf(n,-1,d);return p=r<0?(K=~r,!1):a?(K=r,!0):(K=r+1,!1),e.leaf=w,e.leafPayload=P(),e.leafIndex=K,e.onEnterLeaf(w,K,e,o),[!1,p]}function noop(){}Object.defineProperty(exports,"__esModule",{value:!0}),exports.noop=exports.moveTo=exports.getKey=exports.createCursor=exports.moveForwardOne=void 0,exports.moveForwardOne=moveForwardOne,exports.createCursor=createCursor,exports.getKey=getKey,exports.moveTo=moveTo,exports.noop=noop;

package/extended/shared.d.ts

@@ -0,0 +1 @@
+export {};

package/extended/shared.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCanDoSetOperation = exports.branchingFactorErrorMsg = exports.comparatorErrorMsg = exports.makeLeavesFrom = void 0;
+var b_tree_1 = require("../b+tree");
+/**
+ * Builds leaves from the given parallel arrays of entries.
+ * The supplied load factor will be respected if possible, but may be exceeded
+ * to ensure the 50% full rule is maintained.
+ * Note: if < maxNodeSize entries are provided, only one leaf will be created, which may be underfilled.
+ * @param keys The list of keys to build leaves from.
+ * @param values The list of values to build leaves from.
+ * @param maxNodeSize The maximum node size (branching factor) for the resulting leaves.
+ * @param onLeafCreation Called when a new leaf is created.
+ * @param loadFactor Desired load factor for created leaves. Must be between 0.5 and 1.0.
+ * @internal
+ */
+function makeLeavesFrom(keys, values, maxNodeSize, loadFactor, onLeafCreation) {
+    if (keys.length !== values.length)
+        throw new Error("makeLeavesFrom: keys and values arrays must be the same length");
+    var totalPairs = keys.length;
+    if (totalPairs === 0)
+        return 0;
+    var targetSize = Math.ceil(maxNodeSize * loadFactor);
+    // This method creates as many evenly filled leaves as possible from
+    // the pending entries. All will be > 50% full if we are creating more than one leaf.
+    var remaining = totalPairs;
+    var pairIndex = 0;
+    var remainingLeaves = totalPairs <= maxNodeSize ? 1 : Math.ceil(totalPairs / targetSize);
+    for (; remainingLeaves > 0; remainingLeaves--) {
+        var chunkSize = Math.ceil(remaining / remainingLeaves);
+        var nextIndex = pairIndex + chunkSize;
+        var chunkKeys = keys.slice(pairIndex, nextIndex);
+        var chunkVals = values.slice(pairIndex, nextIndex);
+        pairIndex = nextIndex;
+        remaining -= chunkSize;
+        var leaf = new b_tree_1.BNode(chunkKeys, chunkVals);
+        onLeafCreation(leaf);
+    }
+}
+exports.makeLeavesFrom = makeLeavesFrom;
+;
+/**
+ * Error message used when comparators differ between trees.
+ * @internal
+ */
+exports.comparatorErrorMsg = "Cannot perform set operations on BTrees with different comparators.";
+/**
+ * Error message used when branching factors differ between trees.
+ * @internal
+ */
+exports.branchingFactorErrorMsg = "Cannot perform set operations on BTrees with different max node sizes.";
+/**
+ * Checks that two trees can be used together in a set operation.
+ * @internal
+ */
+function checkCanDoSetOperation(treeA, treeB, supportsDifferentBranchingFactors) {
+    if (treeA._compare !== treeB._compare)
+        throw new Error(exports.comparatorErrorMsg);
+    var branchingFactor = treeA._maxNodeSize;
+    if (!supportsDifferentBranchingFactors && branchingFactor !== treeB._maxNodeSize)
+        throw new Error(exports.branchingFactorErrorMsg);
+    return branchingFactor;
+}
+exports.checkCanDoSetOperation = checkCanDoSetOperation;

package/extended/shared.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.checkCanDoSetOperation=exports.branchingFactorErrorMsg=exports.comparatorErrorMsg=exports.makeLeavesFrom=void 0;var b_tree_1=require("../b+tree");function makeLeavesFrom(e,r,o,t,a){if(e.length!==r.length)throw new Error("makeLeavesFrom: keys and values arrays must be the same length");var n=e.length;if(0===n)return 0;for(var t=Math.ceil(o*t),s=n,i=0,c=n<=o?1:Math.ceil(n/t);0<c;c--){var p=Math.ceil(s/c),m=i+p,h=e.slice(i,m),f=r.slice(i,m),i=m;s-=p,a(new b_tree_1.BNode(h,f))}}function checkCanDoSetOperation(e,r,o){if(e._compare!==r._compare)throw new Error(exports.comparatorErrorMsg);e=e._maxNodeSize;if(!o&&e!==r._maxNodeSize)throw new Error(exports.branchingFactorErrorMsg);return e}exports.makeLeavesFrom=makeLeavesFrom,exports.comparatorErrorMsg="Cannot perform set operations on BTrees with different comparators.",exports.branchingFactorErrorMsg="Cannot perform set operations on BTrees with different max node sizes.",exports.checkCanDoSetOperation=checkCanDoSetOperation;

package/extended/subtract.d.ts

@@ -0,0 +1,16 @@
+import BTree from '../b+tree';
+/**
+ * Returns a new tree containing only the keys that are present in `targetTree` but not `subtractTree` (set subtraction).
+ * Neither tree is modified.
+ *
+ * Complexity is O(N + M) for time and O(N) for allocations in the worst case. Additionally, time is bounded by
+ * O(log(N + M) * D1) and space by O(log N * D2), where `D1` is the number of disjoint key ranges between the trees
+ * and `D2` is the number of disjoint ranges inside `targetTree`, because disjoint subtrees are skipped entirely.
+ * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+ * numbers of non-overlapping key ranges it is much faster.
+ * @param targetTree The tree to subtract from.
+ * @param subtractTree The tree whose keys will be removed from the result.
+ * @returns A new tree that contains the subtraction result.
+ * @throws Error if the trees were created with different comparators or max node sizes.
+ */
+export default function subtract<TBTree extends BTree<K, V>, K, V>(targetTree: TBTree, subtractTree: TBTree): TBTree;

package/extended/subtract.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var shared_1 = require("./shared");
+var decompose_1 = require("./decompose");
+/**
+ * Returns a new tree containing only the keys that are present in `targetTree` but not `subtractTree` (set subtraction).
+ * Neither tree is modified.
+ *
+ * Complexity is O(N + M) for time and O(N) for allocations in the worst case. Additionally, time is bounded by
+ * O(log(N + M) * D1) and space by O(log N * D2), where `D1` is the number of disjoint key ranges between the trees
+ * and `D2` is the number of disjoint ranges inside `targetTree`, because disjoint subtrees are skipped entirely.
+ * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+ * numbers of non-overlapping key ranges it is much faster.
+ * @param targetTree The tree to subtract from.
+ * @param subtractTree The tree whose keys will be removed from the result.
+ * @returns A new tree that contains the subtraction result.
+ * @throws Error if the trees were created with different comparators or max node sizes.
+ */
+function subtract(targetTree, subtractTree) {
+    var _targetTree = targetTree;
+    var _subtractTree = subtractTree;
+    var branchingFactor = (0, shared_1.checkCanDoSetOperation)(_targetTree, _subtractTree, false);
+    if (_targetTree._root.size() === 0 || _subtractTree._root.size() === 0)
+        return targetTree.clone();
+    // Decompose target tree into disjoint subtrees leaves.
+    // As many of these as possible will be reused from the original trees, and the remaining
+    // will be leaves that are exploded (and filtered) due to intersecting leaves in subtractTree.
+    var decomposed = (0, decompose_1.decompose)(_targetTree, _subtractTree, function () { return undefined; }, true);
+    var constructor = targetTree.constructor;
+    if (decomposed.heights.length === 0) {
+        return new constructor(undefined, targetTree._compare, targetTree._maxNodeSize);
+    }
+    return (0, decompose_1.buildFromDecomposition)(constructor, branchingFactor, decomposed, targetTree._compare, targetTree._maxNodeSize);
+}
+exports.default = subtract;

package/extended/subtract.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var shared_1=require("./shared"),decompose_1=require("./decompose");function subtract(e,o){var r=e,t=o,o=(0,shared_1.checkCanDoSetOperation)(r,t,!1);if(0===r._root.size()||0===t._root.size())return e.clone();r=(0,decompose_1.decompose)(r,t,function(){},!0),t=e.constructor;return 0===r.heights.length?new t(void 0,e._compare,e._maxNodeSize):(0,decompose_1.buildFromDecomposition)(t,o,r,e._compare,e._maxNodeSize)}exports.default=subtract;

package/extended/union.d.ts

@@ -0,0 +1,16 @@
+import BTree from '../b+tree';
+/**
+ * Efficiently unions two trees, reusing subtrees wherever possible without mutating either input.
+ *
+ * Complexity is O(N + M) when the trees overlap heavily, and additionally bounded by O(log(N + M) * D)
+ * where `D` is the number of disjoint key ranges, because disjoint subtrees are skipped entirely.
+ * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+ * numbers of non-overlapping key ranges it is much faster.
+ * @param treeA First tree to union.
+ * @param treeB Second tree to union.
+ * @param combineFn Called for keys that appear in both trees. Return the desired value, or
+ *        `undefined` to omit the key from the result. Note: symmetric difference can be achieved by always returning `undefined`.
+ * @returns A new BTree that contains the unioned key/value pairs.
+ * @throws Error if the trees were created with different comparators or max node sizes.
+ */
+export default function union<TBTree extends BTree<K, V>, K, V>(treeA: TBTree, treeB: TBTree, combineFn: (key: K, leftValue: V, rightValue: V) => V | undefined): TBTree;

package/extended/union.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var shared_1 = require("./shared");
+var decompose_1 = require("./decompose");
+/**
+ * Efficiently unions two trees, reusing subtrees wherever possible without mutating either input.
+ *
+ * Complexity is O(N + M) when the trees overlap heavily, and additionally bounded by O(log(N + M) * D)
+ * where `D` is the number of disjoint key ranges, because disjoint subtrees are skipped entirely.
+ * In practice, that means for keys of random distribution the performance is linear and for keys with significant
+ * numbers of non-overlapping key ranges it is much faster.
+ * @param treeA First tree to union.
+ * @param treeB Second tree to union.
+ * @param combineFn Called for keys that appear in both trees. Return the desired value, or
+ *        `undefined` to omit the key from the result. Note: symmetric difference can be achieved by always returning `undefined`.
+ * @returns A new BTree that contains the unioned key/value pairs.
+ * @throws Error if the trees were created with different comparators or max node sizes.
+ */
+function union(treeA, treeB, combineFn) {
+    if (treeA === treeB)
+        return treeA.clone();
+    var _treeA = treeA;
+    var _treeB = treeB;
+    var branchingFactor = (0, shared_1.checkCanDoSetOperation)(_treeA, _treeB, false);
+    if (_treeA._root.size() === 0)
+        return treeB.clone();
+    if (_treeB._root.size() === 0)
+        return treeA.clone();
+    // Decompose both trees into disjoint subtrees leaves.
+    // As many of these as possible will be reused from the original trees, and the remaining
+    // will be leaves that are the result of merging intersecting leaves.
+    var decomposed = (0, decompose_1.decompose)(_treeA, _treeB, combineFn);
+    var constructor = treeA.constructor;
+    return (0, decompose_1.buildFromDecomposition)(constructor, branchingFactor, decomposed, _treeA._compare, _treeA._maxNodeSize);
+}
+exports.default = union;