btree-core 3.2.1

package/extended/decompose.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.buildFromDecomposition=exports.decompose=void 0;var b_tree_1=require("../b+tree"),shared_1=require("./shared"),parallelWalk_1=require("./parallelWalk"),decomposeLoadFactor=.7;function decompose(e,a,n,r){void 0===r&&(r=!1);var i=e._maxNodeSize,s=e._compare;(0,b_tree_1.check)(0<e._root.size()&&0<a._root.size(),"decompose requires non-empty inputs");function t(e){var a=e.keys.length<K?-1:0;_.push(a),k.push(e)}function u(e,a){(0,shared_1.makeLeavesFrom)(x,I,i,decomposeLoadFactor,t),x.length=0,I.length=0,e.isLeaf&&e.keys.length<K?(_.push(-1),k.push(e.clone())):(e.isShared=!0,_.push(a),k.push(e)),L<a&&(b=_.length-1,L=a)}function f(){void 0!==S&&(u(S.node,S.height),S=void 0)}function h(e,a){for(var n=e.spine,r=a;0<=r;--r){var i=n[r].payload;if(i.disqualified)break;i.disqualified=!0}}function l(){return{disqualified:!1}}function o(e,a,n){for(var r=e.keys,i=e.values,t=a;t<n;++t)x.push(r[t]),I.push(i[t])}function d(e,a,n,r,i){(0,b_tree_1.check)(!0===a.disqualified,"onMoveInLeaf: leaf must be disqualified"),(n=i?n+1:n)<r&&o(e,n,r)}function p(e,a,n,r,i){S=void 0,a.disqualified?(r=r?n+1:n)<(n=e.keys.length)&&o(e,r,n):(S={node:e,height:0},0===i.spine.length&&f())}function c(e,a,n,r,i,t,l){var s=e.children,o=a-1;if(t!=t||t===Number.POSITIVE_INFINITY)if(n.disqualified){f();for(var d=s.length,p=r+1;p<d;++p)u(s[p],o)}else if(t===Number.POSITIVE_INFINITY){if(e.keys.length<K)for(var p=r;p<s.length;++p)u(s[p],o);else u(e,a);S=void 0}else S={node:e,height:a};else{0<t&&h(l,i),f();for(p=r+1;p<t;++p)u(s[p],o)}}function v(e,a,n,r,i){if(0<r){h(i,n);for(var t=e.children,l=a-1,s=0;s<r;++s)u(t[s],l)}}function g(e,a,n,r){(0<a||(0,b_tree_1.areOverlapping)(e.minKey(),e.maxKey(),(0,parallelWalk_1.getKey)(r),r.leaf.maxKey(),s))&&(n.leafPayload.disqualified=!0,r.leafPayload.disqualified=!0,h(n,n.spine.length-1),h(r,r.spine.length-1),o(e,0,a))}var y,m,_=[],k=[],x=[],I=[],b=-1,L=-1,S=void 0,K=Math.floor(i/2),W=e._root.maxKey(),F=a._root.maxKey(),N=0<=s(W,F)?W:F,O=(0,parallelWalk_1.createCursor)(e,l,g,d,p,c,v),e=function(e,a){var n=(0,parallelWalk_1.getKey)(e),r=(0,parallelWalk_1.getKey)(a),i=a.leaf.maxKey();(0,b_tree_1.areOverlapping)(n,e.leaf.maxKey(),r,i,s)&&(e.leafPayload.disqualified=!0);for(var t=0;t<e.spine.length;++t){var l=e.spine[t];(0,b_tree_1.areOverlapping)(n,l.node.maxKey(),r,i,s)&&(l.payload.disqualified=!0)}};e(O,m=r?(y={disqualified:!0},(0,parallelWalk_1.createCursor)(a,function(){return y},function(e,a,n,r){(0<a||(0,b_tree_1.areOverlapping)(e.minKey(),e.maxKey(),(0,parallelWalk_1.getKey)(r),r.leaf.maxKey(),s))&&(r.leafPayload.disqualified=!0,h(r,r.spine.length-1))},parallelWalk_1.noop,parallelWalk_1.noop,function(e,a,n,r,i,t,l){0<t&&h(l,i)},function(e,a,n,r,i){0<r&&h(i,n)})):(0,parallelWalk_1.createCursor)(a,l,g,d,p,c,v)),e(m,O);for(var q=O,M=m,R=s((0,parallelWalk_1.getKey)(q),(0,parallelWalk_1.getKey)(M));;){var z=0===R;if(z){var w=(0,parallelWalk_1.getKey)(q),C=n(w,O.leaf.values[O.leafIndex],m.leaf.values[m.leafIndex]);void 0!==C&&(x.push(w),I.push(C));w=(0,parallelWalk_1.moveForwardOne)(M,q),C=(0,parallelWalk_1.moveForwardOne)(q,M);if(w||C){w&&C||(w?(0,parallelWalk_1.moveTo)(q,M,N,!1,!1):(0,parallelWalk_1.moveTo)(M,q,N,!1,!1));break}R=s((0,parallelWalk_1.getKey)(q),(0,parallelWalk_1.getKey)(M))}else{R<0&&(E=M,M=q,q=E);var w=(0,parallelWalk_1.moveTo)(M,q,(0,parallelWalk_1.getKey)(q),!0,z),E=w[0],w=w[1];if(E){(0,parallelWalk_1.moveTo)(q,M,N,!1,z);break}R=w?0:-1}}return(0,shared_1.makeLeavesFrom)(x,I,i,decomposeLoadFactor,t),L<0&&0<_.length&&(b=0),{heights:_,nodes:k,tallestIndex:b}}function buildFromDecomposition(e,a,n,r,i){var t=n.heights,l=n.nodes,s=n.tallestIndex;(0,b_tree_1.check)(t.length===l.length,"Decompose result has mismatched heights and nodes.");var o=t.length,d=[l[s]],n={branchingFactor:a,spine:d,sideIndex:getRightmostIndex,sideInsertionIndex:getRightInsertionIndex,splitOffSide:splitOffRightSide,balanceLeaves:balanceLeavesRight,updateMax:updateRightMax,mergeLeaves:mergeRightEntries};s+1<=o-1&&(updateFrontier(n,0),processSide(t,l,s+1,o,1,n));a={branchingFactor:a,spine:d,sideIndex:getLeftmostIndex,sideInsertionIndex:getLeftmostIndex,splitOffSide:splitOffLeftSide,balanceLeaves:balanceLeavesLeft,updateMax:parallelWalk_1.noop,mergeLeaves:mergeLeftEntries};0<=s-1&&(updateFrontier(a,0),processSide(t,l,s-1,-1,-1,a));i=new e(void 0,r,i);return i._root=d[0],i}function processSide(e,a,n,r,i,t){for(var l=t.spine,s=t.sideIndex,o=0,d=l[0];!d.isShared&&o<l.length-1;)o++,d=d.children[s(d)];for(var p=new Array(l.length).fill(0),u=n;u!=r;u+=i){var f=l.length-1,h=a[u],c=e[u],v=-1===c;(0,b_tree_1.check)(c<=f,"Subtree taller than spine during reconstruction.");var g=f-(c+1);ensureNotShared(t,o,g);var y=void 0,m=void 0;v?((0,b_tree_1.check)(!0!==h.isShared),y=m=h.keys.length):(y=1,m=h.size());f=findSplitCascadeEndDepth(t,g,y),c=Math.max(0,f);updateSizeAndMax(t,p,o,c);y=void 0,f=void 0,f=v?(y=splitUpwardsAndInsertEntries(t,g,h),g-1):(y=splitUpwardsAndInsert(t,g,h)[0],g);y&&(l[0]=y,p.push(0),f++),o=f+1,p[f]+=m,updateFrontier(t,c),(0,b_tree_1.check)(o===l.length-1||!0===l[o].isShared,"Non-leaf subtrees must be shared."),(0,b_tree_1.check)(p.length===l.length,"Unflushed sizes length mismatch after root split.")}updateSizeAndMax(t,p,o,0)}function splitUpwardsAndInsert(e,a,n){var r=e.spine,i=e.branchingFactor,t=e.sideIndex,l=e.sideInsertionIndex,s=e.splitOffSide,o=e.updateMax;if(0<=a){var d=void 0,e=r[a];e.keys.length===i&&(e=d=s(e));for(var p=a-1;d&&0<=p;){var u=r[p],f=t(u);o(u,u.children[f].maxKey()),d=u.keys.length<i?void insertNoCount(u,l(u),d):(insertNoCount(u=s(u),l(u),d),u),p--}var h=void 0;return void 0!==d&&(c=r[0],insertNoCount(h=new b_tree_1.BNodeInternal([c],c.size()+d.size()),l(h),d)),insertNoCount(e,l(e),n),[h,e]}var c=r[0];return insertNoCount(h=new b_tree_1.BNodeInternal([c],c.size()),l(h),n),[h,h]}function splitUpwardsAndInsertEntries(e,a,n){var r=e.branchingFactor,i=e.spine,t=e.balanceLeaves,l=e.mergeLeaves,s=n.keys.length,i=i[a];if(!(i.keys.length+s<=r)){e=splitUpwardsAndInsert(e,a-1,n),a=e[0];return t(e[1],n,Math.floor(r/2)-s),a}l(i,n)}function ensureNotShared(e,a,n){var r=e.spine,i=e.sideIndex;if(!(n<0)){0===a&&(e=r[0],r[0]=e.clone());for(var t=Math.max(a,1);t<=n;t++){var l=r[t-1],s=i(l),o=l.children[s].clone();l.children[s]=o,r[t]=o}}}function updateSizeAndMax(e,a,n,r){for(var i=e.spine,t=e.updateMax,l=i[n].maxKey(),s=n-1;r<=s;s--){var o=a[s];(a[s]=0)<s&&(a[s-1]+=o);var d=i[s];d._size+=o,t(d,l)}}function updateFrontier(e,a){var n=e.spine,r=e.sideIndex;(0,b_tree_1.check)(n.length>a,"updateFrontier: depthLastValid exceeds frontier height");e=n[a];if(!e.isLeaf){for(var i=e.children[r(e)],t=a+1;!i.isLeaf;){var l=i,i=(n[t]=l).children[r(l)];t++}n[t]=i}}function findSplitCascadeEndDepth(e,a,n){var r=e.spine,i=e.branchingFactor;if(0<=a){var t=a;if(r[t].keys.length+n<=i)return t;for(t--;0<=t;){if(r[t].keys.length<i)return t;t--}}return-1}function insertNoCount(e,a,n){e.children.splice(a,0,n),e.keys.splice(a,0,n.maxKey())}function getLeftmostIndex(){return 0}function getRightmostIndex(e){return e.children.length-1}function getRightInsertionIndex(e){return e.children.length}function splitOffRightSide(e){return e.splitOffRightSide()}function splitOffLeftSide(e){return e.splitOffLeftSide()}function balanceLeavesRight(e,a,n){var r=e.children.length-2,i=e.children[r],t=i.keys.length-n,n=i.keys.splice(t),t=i.values.splice(t);a.keys.unshift.apply(a.keys,n),a.values.unshift.apply(a.values,t),e.keys[r]=i.maxKey()}function balanceLeavesLeft(e,a,n){var r=e.children[1],i=r.keys.splice(0,n),n=r.values.splice(0,n);a.keys.push.apply(a.keys,i),a.values.push.apply(a.values,n),e.keys[0]=a.maxKey()}function updateRightMax(e,a){e.keys[e.keys.length-1]=a}function mergeRightEntries(e,a){e.keys.push.apply(e.keys,a.keys),e.values.push.apply(e.values,a.values)}function mergeLeftEntries(e,a){e.keys.unshift.apply(e.keys,a.keys),e.values.unshift.apply(e.values,a.values)}exports.decompose=decompose,exports.buildFromDecomposition=buildFromDecomposition;

package/extended/diffAgainst.d.ts

@@ -0,0 +1,23 @@
+import BTree from '../b+tree';
+/**
+ * Computes the differences between `treeA` and `treeB`.
+ * 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 treeA The tree whose differences will be reported via the callbacks.
+ * @param treeB The tree to compute a diff against.
+ * @param onlyA Callback invoked for all keys only present in `treeA`.
+ * @param onlyB Callback invoked for all keys only present in `treeB`.
+ * @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.
+ */
+export default function diffAgainst<K, V, R>(_treeA: BTree<K, V>, _treeB: BTree<K, V>, onlyA?: (k: K, v: V) => {
+    break?: R;
+} | void, onlyB?: (k: K, v: V) => {
+    break?: R;
+} | void, different?: (k: K, vThis: V, vOther: V) => {
+    break?: R;
+} | void): R | undefined;

package/extended/diffAgainst.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var b_tree_1 = require("../b+tree");
+/**
+ * Computes the differences between `treeA` and `treeB`.
+ * 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 treeA The tree whose differences will be reported via the callbacks.
+ * @param treeB The tree to compute a diff against.
+ * @param onlyA Callback invoked for all keys only present in `treeA`.
+ * @param onlyB Callback invoked for all keys only present in `treeB`.
+ * @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.
+ */
+function diffAgainst(_treeA, _treeB, onlyA, onlyB, different) {
+    var treeA = _treeA;
+    var treeB = _treeB;
+    if (treeB._compare !== treeA._compare) {
+        throw new Error('Tree comparators are not the same.');
+    }
+    if (treeA.isEmpty || treeB.isEmpty) {
+        if (_treeA.isEmpty && treeB.isEmpty)
+            return undefined;
+        if (treeA.isEmpty) {
+            return onlyB === undefined
+                ? undefined
+                : stepToEnd(makeDiffCursor(treeB), onlyB);
+        }
+        return onlyA === undefined
+            ? undefined
+            : stepToEnd(makeDiffCursor(treeA), onlyA);
+    }
+    // Cursor-based diff algorithm is as follows:
+    // - Until neither cursor has navigated to the end of the tree, do the following:
+    //   - If the `treeThis` cursor is "behind" the `treeOther` cursor (strictly <, via compare), advance it.
+    //   - Otherwise, advance the `treeOther` cursor.
+    //   - Any time a cursor is stepped, perform the following:
+    //     - If either cursor points to a key/value pair:
+    //       - If thisCursor === otherCursor and the values differ, it is a Different.
+    //       - If thisCursor > otherCursor and otherCursor is at a key/value pair, it is an OnlyB.
+    //       - If thisCursor < otherCursor and thisCursor is at a key/value pair, it is an OnlyA as long as the most recent
+    //         cursor step was *not* otherCursor advancing from a tie. The extra condition avoids erroneous OnlyB calls
+    //         that would occur due to otherCursor being the "leader".
+    //     - Otherwise, if both cursors point to nodes, compare them. If they are equal by reference (shared), skip
+    //       both cursors to the next node in the walk.
+    // - Once one cursor has finished stepping, any remaining steps (if any) are taken and key/value pairs are logged
+    //   as OnlyB (if otherCursor is stepping) or OnlyA (if thisCursor is stepping).
+    // This algorithm gives the critical guarantee that all locations (both nodes and key/value pairs) in both trees that
+    // are identical by value (and possibly by reference) will be visited *at the same time* by the cursors.
+    // This removes the possibility of emitting incorrect diffs, as well as allowing for skipping shared nodes.
+    var compareKeys = treeA._compare;
+    var thisCursor = makeDiffCursor(treeA);
+    var otherCursor = makeDiffCursor(treeB);
+    var thisSuccess = true;
+    var otherSuccess = true;
+    // It doesn't matter how thisSteppedLast is initialized.
+    // Step order is only used when either cursor is at a leaf, and cursors always start at a node.
+    var prevCursorOrder = compareDiffCursors(thisCursor, otherCursor, compareKeys);
+    while (thisSuccess && otherSuccess) {
+        var cursorOrder = compareDiffCursors(thisCursor, otherCursor, compareKeys);
+        var thisLeaf = thisCursor.leaf, thisInternalSpine = thisCursor.internalSpine, thisLevelIndices = thisCursor.levelIndices;
+        var otherLeaf = otherCursor.leaf, otherInternalSpine = otherCursor.internalSpine, otherLevelIndices = otherCursor.levelIndices;
+        if (thisLeaf || otherLeaf) {
+            // If the cursors were at the same location last step, then there is no work to be done.
+            if (prevCursorOrder !== 0) {
+                if (cursorOrder === 0) {
+                    if (thisLeaf && otherLeaf && different) {
+                        // Equal keys, check for modifications
+                        var valThis = thisLeaf.values[thisLevelIndices[thisLevelIndices.length - 1]];
+                        var valOther = otherLeaf.values[otherLevelIndices[otherLevelIndices.length - 1]];
+                        if (!Object.is(valThis, valOther)) {
+                            var result = different(thisCursor.currentKey, valThis, valOther);
+                            if (result && result.break)
+                                return result.break;
+                        }
+                    }
+                }
+                else if (cursorOrder > 0) {
+                    // If this is the case, we know that either:
+                    // 1. otherCursor stepped last from a starting position that trailed thisCursor, and is still behind, or
+                    // 2. thisCursor stepped last and leapfrogged otherCursor
+                    // Either of these cases is an "only other"
+                    if (otherLeaf && onlyB) {
+                        var otherVal = otherLeaf.values[otherLevelIndices[otherLevelIndices.length - 1]];
+                        var result = onlyB(otherCursor.currentKey, otherVal);
+                        if (result && result.break)
+                            return result.break;
+                    }
+                }
+                else if (onlyA) {
+                    if (thisLeaf && prevCursorOrder !== 0) {
+                        var valThis = thisLeaf.values[thisLevelIndices[thisLevelIndices.length - 1]];
+                        var result = onlyA(thisCursor.currentKey, valThis);
+                        if (result && result.break)
+                            return result.break;
+                    }
+                }
+            }
+        }
+        else if (!thisLeaf && !otherLeaf && cursorOrder === 0) {
+            var lastThis = thisInternalSpine.length - 1;
+            var lastOther = otherInternalSpine.length - 1;
+            var nodeThis = thisInternalSpine[lastThis][thisLevelIndices[lastThis]];
+            var nodeOther = otherInternalSpine[lastOther][otherLevelIndices[lastOther]];
+            if (nodeOther === nodeThis) {
+                prevCursorOrder = 0;
+                thisSuccess = stepDiffCursor(thisCursor, true);
+                otherSuccess = stepDiffCursor(otherCursor, true);
+                continue;
+            }
+        }
+        prevCursorOrder = cursorOrder;
+        if (cursorOrder < 0) {
+            thisSuccess = stepDiffCursor(thisCursor);
+        }
+        else {
+            otherSuccess = stepDiffCursor(otherCursor);
+        }
+    }
+    if (thisSuccess && onlyA)
+        return finishCursorWalk(thisCursor, otherCursor, compareKeys, onlyA);
+    if (otherSuccess && onlyB)
+        return finishCursorWalk(otherCursor, thisCursor, compareKeys, onlyB);
+    return undefined;
+}
+exports.default = diffAgainst;
+/**
+ * Finishes walking `cursor` once the other cursor has already completed its walk.
+ */
+function finishCursorWalk(cursor, cursorFinished, compareKeys, callback) {
+    var compared = compareDiffCursors(cursor, cursorFinished, compareKeys);
+    if (compared === 0) {
+        if (!stepDiffCursor(cursor))
+            return undefined;
+    }
+    else if (compared < 0) {
+        (0, b_tree_1.check)(false, 'cursor walk terminated early');
+    }
+    return stepToEnd(cursor, callback);
+}
+/**
+ * Walks the cursor to the end of the tree, invoking the callback for each key/value pair.
+ */
+function stepToEnd(cursor, callback) {
+    var canStep = true;
+    while (canStep) {
+        var leaf = cursor.leaf, levelIndices = cursor.levelIndices, currentKey = cursor.currentKey;
+        if (leaf) {
+            var value = leaf.values[levelIndices[levelIndices.length - 1]];
+            var result = callback(currentKey, value);
+            if (result && result.break)
+                return result.break;
+        }
+        canStep = stepDiffCursor(cursor);
+    }
+    return undefined;
+}
+function makeDiffCursor(internal) {
+    var root = internal._root;
+    return {
+        height: internal.height,
+        internalSpine: [[root]],
+        levelIndices: [0],
+        leaf: undefined,
+        currentKey: root.maxKey()
+    };
+}
+/**
+ * Advances the cursor to the next step in the walk of its tree.
+ * Cursors are walked backwards in sort order, as this allows them to leverage maxKey() in order to be compared in O(1).
+ */
+function stepDiffCursor(cursor, stepToNode) {
+    var internalSpine = cursor.internalSpine, levelIndices = cursor.levelIndices, leaf = cursor.leaf;
+    if (stepToNode === true || leaf) {
+        var levelsLength = levelIndices.length;
+        // Step to the next node only if:
+        // - We are explicitly directed to via stepToNode, or
+        // - There are no key/value pairs left to step to in this leaf
+        if (stepToNode === true || levelIndices[levelsLength - 1] === 0) {
+            var spineLength = internalSpine.length;
+            if (spineLength === 0)
+                return false;
+            // Walk back up the tree until we find a new subtree to descend into
+            var nodeLevelIndex = spineLength - 1;
+            var levelIndexWalkBack = nodeLevelIndex;
+            while (levelIndexWalkBack >= 0) {
+                if (levelIndices[levelIndexWalkBack] > 0) {
+                    if (levelIndexWalkBack < levelsLength - 1) {
+                        // Remove leaf state from cursor
+                        cursor.leaf = undefined;
+                        levelIndices.pop();
+                    }
+                    // If we walked upwards past any internal node, slice them out
+                    if (levelIndexWalkBack < nodeLevelIndex)
+                        cursor.internalSpine = internalSpine.slice(0, levelIndexWalkBack + 1);
+                    cursor.currentKey = internalSpine[levelIndexWalkBack][--levelIndices[levelIndexWalkBack]].maxKey();
+                    return true;
+                }
+                levelIndexWalkBack--;
+            }
+            // Cursor is in the far left leaf of the tree, no more nodes to enumerate
+            return false;
+        }
+        else {
+            // Move to new leaf value
+            var valueIndex = --levelIndices[levelsLength - 1];
+            cursor.currentKey = leaf.keys[valueIndex];
+            return true;
+        }
+    }
+    else { // Cursor does not point to a value in a leaf, so move downwards
+        var nextLevel = internalSpine.length;
+        var currentLevel = nextLevel - 1;
+        var node = internalSpine[currentLevel][levelIndices[currentLevel]];
+        if (node.isLeaf) {
+            cursor.leaf = node;
+            var valueIndex = (levelIndices[nextLevel] = node.values.length - 1);
+            cursor.currentKey = node.keys[valueIndex];
+        }
+        else {
+            var children = node.children;
+            internalSpine[nextLevel] = children;
+            var childIndex = children.length - 1;
+            levelIndices[nextLevel] = childIndex;
+            cursor.currentKey = children[childIndex].maxKey();
+        }
+        return true;
+    }
+}
+/**
+ * Compares two cursors and returns which cursor is ahead in the traversal.
+ * Note that cursors advance in reverse sort order.
+ */
+function compareDiffCursors(cursorA, cursorB, compareKeys) {
+    var heightA = cursorA.height, currentKeyA = cursorA.currentKey, levelIndicesA = cursorA.levelIndices;
+    var heightB = cursorB.height, currentKeyB = cursorB.currentKey, levelIndicesB = cursorB.levelIndices;
+    // Reverse the comparison order, as cursors are advanced in reverse sorting order
+    var keyComparison = compareKeys(currentKeyB, currentKeyA);
+    if (keyComparison !== 0)
+        return keyComparison;
+    // Normalize depth values relative to the shortest tree.
+    // This ensures that concurrent cursor walks of trees of differing heights can reliably land on shared nodes at the same time.
+    // To accomplish this, a cursor that is on an internal node at depth D1 with maxKey X is considered "behind" a cursor on an
+    // internal node at depth D2 with maxKey Y, when D1 < D2. Thus, always walking the cursor that is "behind" will allow the cursor
+    // at shallower depth (but equal maxKey) to "catch up" and land on shared nodes.
+    var heightMin = heightA < heightB ? heightA : heightB;
+    var depthANormalized = levelIndicesA.length - (heightA - heightMin);
+    var depthBNormalized = levelIndicesB.length - (heightB - heightMin);
+    return depthANormalized - depthBNormalized;
+}

package/extended/diffAgainst.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var b_tree_1=require("../b+tree");function diffAgainst(e,r,i,t,n){var f=e,r=r;if(r._compare!==f._compare)throw new Error("Tree comparators are not the same.");if(f.isEmpty||r.isEmpty)return e.isEmpty&&r.isEmpty?void 0:f.isEmpty?void 0===t?void 0:stepToEnd(makeDiffCursor(r),t):void 0===i?void 0:stepToEnd(makeDiffCursor(f),i);for(var s=f._compare,a=makeDiffCursor(f),u=makeDiffCursor(r),o=!0,l=!0,c=compareDiffCursors(a,u,s);o&&l;){var v=compareDiffCursors(a,u,s),p=a.leaf,h=a.internalSpine,d=a.levelIndices,m=u.leaf,y=u.internalSpine,g=u.levelIndices;if(p||m){if(0!==c)if(0===v){if(p&&m&&n){var k=p.values[d[d.length-1]],C=m.values[g[g.length-1]];if(!Object.is(k,C))if((D=n(a.currentKey,k,C))&&D.break)return D.break}}else if(0<v){if(m&&t){C=m.values[g[g.length-1]];if((D=t(u.currentKey,C))&&D.break)return D.break}}else if(i&&p&&0!==c){var D,k=p.values[d[d.length-1]];if((D=i(a.currentKey,k))&&D.break)return D.break}}else if(!p&&!m&&0===v){p=h.length-1,m=y.length-1,p=h[p][d[p]];if(y[m][g[m]]===p){o=stepDiffCursor(a,!(c=0)),l=stepDiffCursor(u,!0);continue}}(c=v)<0?o=stepDiffCursor(a):l=stepDiffCursor(u)}return o&&i?finishCursorWalk(a,u,s,i):l&&t?finishCursorWalk(u,a,s,t):void 0}function finishCursorWalk(e,r,i,t){i=compareDiffCursors(e,r,i);if(0===i){if(!stepDiffCursor(e))return}else i<0&&(0,b_tree_1.check)(!1,"cursor walk terminated early");return stepToEnd(e,t)}function stepToEnd(e,r){for(var i=!0;i;){var t=e.leaf,n=e.levelIndices,f=e.currentKey;if(t){n=r(f,t.values[n[n.length-1]]);if(n&&n.break)return n.break}i=stepDiffCursor(e)}}function makeDiffCursor(e){var r=e._root;return{height:e.height,internalSpine:[[r]],levelIndices:[0],leaf:void 0,currentKey:r.maxKey()}}function stepDiffCursor(e,r){var i=e.internalSpine,t=e.levelIndices,n=e.leaf;if(!0===r||n){var f=t.length;if(!0===r||0===t[f-1]){var s=i.length;if(0===s)return!1;for(var a=s-1,u=a;0<=u;){if(0<t[u])return u<f-1&&(e.leaf=void 0,t.pop()),u<a&&(e.internalSpine=i.slice(0,u+1)),e.currentKey=i[u][--t[u]].maxKey(),!0;u--}return!1}var o=--t[f-1];return e.currentKey=n.keys[o],!0}s=i.length,n=s-1,n=i[n][t[n]];return n.isLeaf?(e.leaf=n,o=t[s]=n.values.length-1,e.currentKey=n.keys[o]):(o=n.children,n=(i[s]=o).length-1,t[s]=n,e.currentKey=o[n].maxKey()),!0}function compareDiffCursors(e,r,i){var t=e.height,n=e.currentKey,f=e.levelIndices,s=r.height,e=r.currentKey,r=r.levelIndices,n=i(e,n);if(0!==n)return n;n=t<s?t:s;return f.length-(t-n)-(r.length-(s-n))}exports.default=diffAgainst;

package/extended/forEachKeyInBoth.d.ts

@@ -0,0 +1,19 @@
+import BTree from '../b+tree';
+/**
+ * Calls the supplied `callback` for each key/value pair shared by both trees, 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 whole non-intersecting 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 treeA First tree to compare.
+ * @param treeB Second tree to compare.
+ * @param callback Invoked 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 trees were built with different comparators.
+ */
+export default function forEachKeyInBoth<K, V, R = void>(treeA: BTree<K, V>, treeB: BTree<K, V>, callback: (key: K, leftValue: V, rightValue: V) => {
+    break?: R;
+} | void): R | undefined;

package/extended/forEachKeyInBoth.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var shared_1 = require("./shared");
+var parallelWalk_1 = require("./parallelWalk");
+/**
+ * Calls the supplied `callback` for each key/value pair shared by both trees, 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 whole non-intersecting 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 treeA First tree to compare.
+ * @param treeB Second tree to compare.
+ * @param callback Invoked 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 trees were built with different comparators.
+ */
+function forEachKeyInBoth(treeA, treeB, callback) {
+    var _treeA = treeA;
+    var _treeB = treeB;
+    (0, shared_1.checkCanDoSetOperation)(_treeA, _treeB, true);
+    if (treeB.size === 0 || treeA.size === 0)
+        return;
+    var cmp = treeA._compare;
+    var makePayload = function () { return undefined; };
+    var cursorA = (0, parallelWalk_1.createCursor)(_treeA, makePayload, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop);
+    var cursorB = (0, parallelWalk_1.createCursor)(_treeB, makePayload, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop);
+    var leading = cursorA;
+    var trailing = cursorB;
+    var order = cmp((0, parallelWalk_1.getKey)(leading), (0, parallelWalk_1.getKey)(trailing));
+    // This walk is somewhat similar to a merge walk in that it does an alternating hop walk with cursors.
+    // However, the only thing we care about is when the two cursors are equal (equality is intersection).
+    // When they are not equal we just advance the trailing cursor.
+    while (true) {
+        var areEqual = order === 0;
+        if (areEqual) {
+            var key = (0, parallelWalk_1.getKey)(leading);
+            var vA = cursorA.leaf.values[cursorA.leafIndex];
+            var vB = cursorB.leaf.values[cursorB.leafIndex];
+            var result = callback(key, vA, vB);
+            if (result && result.break) {
+                return result.break;
+            }
+            var outT = (0, parallelWalk_1.moveForwardOne)(trailing, leading);
+            var outL = (0, parallelWalk_1.moveForwardOne)(leading, trailing);
+            if (outT && outL)
+                break;
+            order = cmp((0, parallelWalk_1.getKey)(leading), (0, parallelWalk_1.getKey)(trailing));
+        }
+        else {
+            if (order < 0) {
+                var tmp = trailing;
+                trailing = leading;
+                leading = tmp;
+            }
+            // At this point, leading is guaranteed to be ahead of trailing.
+            var _a = (0, parallelWalk_1.moveTo)(trailing, leading, (0, parallelWalk_1.getKey)(leading), true, areEqual), out = _a[0], nowEqual = _a[1];
+            if (out) {
+                // We've reached the end of one tree, so intersections are guaranteed to be done.
+                break;
+            }
+            else if (nowEqual) {
+                order = 0;
+            }
+            else {
+                order = -1; // trailing is ahead of leading
+            }
+        }
+    }
+}
+exports.default = forEachKeyInBoth;

package/extended/forEachKeyInBoth.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var shared_1=require("./shared"),parallelWalk_1=require("./parallelWalk");function forEachKeyInBoth(l,a,e){var r=l,o=a;if((0,shared_1.checkCanDoSetOperation)(r,o,!0),0!==a.size&&0!==l.size)for(var p=l._compare,l=function(){},k=(0,parallelWalk_1.createCursor)(r,l,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop),_=(0,parallelWalk_1.createCursor)(o,l,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop),n=k,W=_,t=p((0,parallelWalk_1.getKey)(n),(0,parallelWalk_1.getKey)(W));;){var f=0===t;if(f){var s=e((0,parallelWalk_1.getKey)(n),k.leaf.values[k.leafIndex],_.leaf.values[_.leafIndex]);if(s&&s.break)return s.break;var i=(0,parallelWalk_1.moveForwardOne)(W,n),s=(0,parallelWalk_1.moveForwardOne)(n,W);if(i&&s)break;t=p((0,parallelWalk_1.getKey)(n),(0,parallelWalk_1.getKey)(W))}else{t<0&&(u=W,W=n,n=u);var u=(0,parallelWalk_1.moveTo)(W,n,(0,parallelWalk_1.getKey)(n),!0,f),f=u[0],u=u[1];if(f)break;t=u?0:-1}}}exports.default=forEachKeyInBoth;

package/extended/forEachKeyNotIn.d.ts

@@ -0,0 +1,18 @@
+import BTree from '../b+tree';
+/**
+ * Calls the supplied `callback` for each key/value pair that is in `includeTree` but not in `excludeTree`
+ * (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 includeTree The tree to iterate keys from.
+ * @param excludeTree Keys present in this tree are omitted from the callback.
+ * @param callback Invoked for keys that are in `includeTree` but not `excludeTree`. 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 built with different comparators.
+ */
+export default function forEachKeyNotIn<K, V, R = void>(includeTree: BTree<K, V>, excludeTree: BTree<K, V>, callback: (key: K, value: V) => {
+    break?: R;
+} | void): R | undefined;

package/extended/forEachKeyNotIn.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var shared_1 = require("./shared");
+var parallelWalk_1 = require("./parallelWalk");
+/**
+ * Calls the supplied `callback` for each key/value pair that is in `includeTree` but not in `excludeTree`
+ * (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 includeTree The tree to iterate keys from.
+ * @param excludeTree Keys present in this tree are omitted from the callback.
+ * @param callback Invoked for keys that are in `includeTree` but not `excludeTree`. 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 built with different comparators.
+ */
+function forEachKeyNotIn(includeTree, excludeTree, callback) {
+    var _includeTree = includeTree;
+    var _excludeTree = excludeTree;
+    (0, shared_1.checkCanDoSetOperation)(_includeTree, _excludeTree, true);
+    if (includeTree.size === 0) {
+        return;
+    }
+    var finishWalk = function () {
+        var out = false;
+        do {
+            var key = (0, parallelWalk_1.getKey)(cursorInclude);
+            var value = cursorInclude.leaf.values[cursorInclude.leafIndex];
+            var result = callback(key, value);
+            if (result && result.break) {
+                return result.break;
+            }
+            out = (0, parallelWalk_1.moveForwardOne)(cursorInclude, cursorExclude);
+        } while (!out);
+        return undefined;
+    };
+    var cmp = includeTree._compare;
+    var makePayload = function () { return undefined; };
+    var cursorInclude = (0, parallelWalk_1.createCursor)(_includeTree, makePayload, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop);
+    if (excludeTree.size === 0) {
+        return finishWalk();
+    }
+    var cursorExclude = (0, parallelWalk_1.createCursor)(_excludeTree, makePayload, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop, parallelWalk_1.noop);
+    var order = cmp((0, parallelWalk_1.getKey)(cursorInclude), (0, parallelWalk_1.getKey)(cursorExclude));
+    while (true) {
+        var areEqual = order === 0;
+        if (areEqual) {
+            // Keys are equal, so this key is in both trees and should be skipped.
+            var outInclude = (0, parallelWalk_1.moveForwardOne)(cursorInclude, cursorExclude);
+            if (outInclude)
+                break;
+            order = 1; // include is now ahead of exclude
+        }
+        else {
+            if (order < 0) {
+                var key = (0, parallelWalk_1.getKey)(cursorInclude);
+                var value = cursorInclude.leaf.values[cursorInclude.leafIndex];
+                var result = callback(key, value);
+                if (result && result.break) {
+                    return result.break;
+                }
+                var outInclude = (0, parallelWalk_1.moveForwardOne)(cursorInclude, cursorExclude);
+                if (outInclude) {
+                    break;
+                }
+                order = cmp((0, parallelWalk_1.getKey)(cursorInclude), (0, parallelWalk_1.getKey)(cursorExclude));
+            }
+            else {
+                // At this point, include is guaranteed to be ahead of exclude.
+                var _a = (0, parallelWalk_1.moveTo)(cursorExclude, cursorInclude, (0, parallelWalk_1.getKey)(cursorInclude), true, areEqual), out = _a[0], nowEqual = _a[1];
+                if (out) {
+                    // We've reached the end of exclude, so call for all remaining keys in include
+                    return finishWalk();
+                }
+                else if (nowEqual) {
+                    order = 0;
+                }
+                else {
+                    order = -1;
+                }
+            }
+        }
+    }
+}
+exports.default = forEachKeyNotIn;

package/extended/forEachKeyNotIn.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var shared_1=require("./shared"),parallelWalk_1=require("./parallelWalk");function forEachKeyNotIn(l,a,e){var r=l,o=a;if((0,shared_1.checkCanDoSetOperation)(r,o,!0),0!==l.size){var p=function(){do{var l=(0,parallelWalk_1.getKey)(n),a=n.leaf.values[n.leafIndex],a=e(l,a);if(a&&a.break)return a.break}while(!(0,parallelWalk_1.moveForwardOne)(n,_))},k=l._compare,l=function(){},n=(0,parallelWalk_1.createCursor)(r,l,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop);if(0===a.size)return p();for(var _=(0,parallelWalk_1.createCursor)(o,l,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop,parallelWalk_1.noop),t=k((0,parallelWalk_1.getKey)(n),(0,parallelWalk_1.getKey)(_));;){var W=0===t;if(W){if((0,parallelWalk_1.moveForwardOne)(n,_))break;t=1}else if(t<0){var f=(0,parallelWalk_1.getKey)(n),i=n.leaf.values[n.leafIndex],i=e(f,i);if(i&&i.break)return i.break;if((0,parallelWalk_1.moveForwardOne)(n,_))break;t=k((0,parallelWalk_1.getKey)(n),(0,parallelWalk_1.getKey)(_))}else{i=(0,parallelWalk_1.moveTo)(_,n,(0,parallelWalk_1.getKey)(n),!0,W),W=i[0],i=i[1];if(W)return p();t=i?0:-1}}}}exports.default=forEachKeyNotIn;

package/extended/index.d.ts

@@ -0,0 +1,133 @@
+import BTree from '../b+tree';
+/**
+ * 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
+ */
+export declare class BTreeEx<K = any, V = any> extends BTree<K, V> {
+    /**
+     * 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.
+     */
+    static bulkLoad<K, V>(keys: K[], values: V[], maxNodeSize: number, compare?: (a: K, b: K) => number): BTreeEx<K, V>;
+    /** See {@link BTree.clone}. */
+    clone(): this;
+    /** See {@link BTree.greedyClone}. */
+    greedyClone(force?: boolean): this;
+    /**
+     * 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.
+     */
+    diffAgainst<R>(other: BTree<K, V>, onlyThis?: (k: K, v: V) => {
+        break?: R;
+    } | void, onlyOther?: (k: K, v: V) => {
+        break?: R;
+    } | void, different?: (k: K, vThis: V, vOther: V) => {
+        break?: R;
+    } | void): R | undefined;
+    /**
+     * 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.
+     */
+    forEachKeyInBoth<R = void>(other: BTree<K, V>, callback: (key: K, leftValue: V, rightValue: V) => {
+        break?: R;
+    } | void): R | undefined;
+    /**
+     * 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.
+     */
+    forEachKeyNotIn<R = void>(other: BTree<K, V>, callback: (key: K, value: V) => {
+        break?: R;
+    } | void): R | undefined;
+    /**
+     * 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.
+     */
+    intersect(other: BTreeEx<K, V>, combineFn: (key: K, leftValue: V, rightValue: V) => V): BTreeEx<K, V>;
+    /**
+     * 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.
+     */
+    union(other: BTreeEx<K, V>, combineFn: (key: K, leftValue: V, rightValue: V) => V | undefined): BTreeEx<K, V>;
+    /**
+     * 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.
+     */
+    subtract(other: BTreeEx<K, V>): BTreeEx<K, V>;
+}
+export interface BTreeEx<K = any, V = any> {
+    /** See {@link BTree.with}. */
+    with(key: K): BTreeEx<K, V | undefined>;
+    with<V2>(key: K, value: V2, overwrite?: boolean): BTreeEx<K, V | V2>;
+    with<V2>(key: K, value?: V2, overwrite?: boolean): BTreeEx<K, V | V2 | undefined>;
+    /** See {@link BTree.withPairs}. */
+    withPairs<V2>(pairs: [K, V | V2][], overwrite: boolean): BTreeEx<K, V | V2>;
+    /** See {@link BTree.withKeys}. */
+    withKeys(keys: K[], returnThisIfUnchanged?: boolean): BTreeEx<K, V | undefined>;
+    /** See {@link BTree.mapValues}. */
+    mapValues<R>(callback: (v: V, k: K, counter: number) => R): BTreeEx<K, R>;
+}
+export default BTreeEx;