serializable-bptree 2.0.0 → 3.1.0

package/dist/cjs/index.js

@@ -20,84 +20,70 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  BPTree: () => BPTree,
-  InMemoryStoreStrategy: () => InMemoryStoreStrategy,
+  BPTreeAsync: () => BPTreeAsync,
+  BPTreeSync: () => BPTreeSync,
+  InMemoryStoreStrategyAsync: () => InMemoryStoreStrategyAsync,
+  InMemoryStoreStrategySync: () => InMemoryStoreStrategySync,
   NumericComparator: () => NumericComparator,
-  SerializeStrategy: () => SerializeStrategy,
+  SerializeStrategyAsync: () => SerializeStrategyAsync,
+  SerializeStrategySync: () => SerializeStrategySync,
   StringComparator: () => StringComparator,
   ValueComparator: () => ValueComparator
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/utils/BinarySearch.ts
-var BinarySearch = class {
-  comparator;
-  constructor(comparator) {
-    this.comparator = comparator;
+// src/base/ValueComparator.ts
+var ValueComparator = class {
+  isLower(value, than) {
+    return this.asc(value, than) < 0;
   }
-  _withRange(array, value, left = 0, right = array.length - 1) {
-    while (left <= right) {
-      const mid = Math.floor((left + right) / 2);
-      const guess = array[mid];
-      if (this.comparator.isSame(guess, value)) {
-        return mid;
-      } else if (this.comparator.isLower(guess, value)) {
-        left = mid + 1;
-        continue;
-      } else {
-        right = mid - 1;
-        continue;
-      }
-    }
-    return -1;
+  isSame(value, than) {
+    return this.asc(value, than) === 0;
   }
-  leftest(array, value) {
-    let i = this._withRange(array, value);
-    if (i === -1) {
-      return -1;
-    }
-    while (i > 0) {
-      if (!this.comparator.isSame(array[i - 1], value)) {
-        break;
-      }
-      i--;
-    }
-    return i;
+  isHigher(value, than) {
+    return this.asc(value, than) > 0;
   }
-  rightest(array, value) {
-    let i = this._withRange(array, value);
-    if (i === -1) {
-      return -1;
-    }
-    const max = array.length - 1;
-    while (i < max) {
-      if (!this.comparator.isSame(array[i + 1], value)) {
-        break;
-      }
-      i++;
-    }
-    return i;
+};
+var NumericComparator = class extends ValueComparator {
+  asc(a, b) {
+    return a - b;
   }
-  range(array, value) {
-    const left = this.leftest(array, value);
-    const right = this.rightest(array, value) + 1;
-    return [left, right];
+  match(value) {
+    return value.toString();
+  }
+};
+var StringComparator = class extends ValueComparator {
+  asc(a, b) {
+    return a.localeCompare(b);
+  }
+  match(value) {
+    return value;
+  }
+};
+
+// src/utils/CacheStorage.ts
+var CacheStorage = class extends Map {
+  ensure(key, generator) {
+    if (!this.has(key)) {
+      this.set(key, generator());
+    }
+    return this.get(key);
   }
 };
 
-// src/BPTree.ts
+// src/base/BPTree.ts
 var BPTree = class {
+  _regexpCache;
   strategy;
   comparator;
-  search;
-  order;
   nodes;
+  order;
   data;
   root;
-  _creates;
-  _updates;
-  _updatedHead;
-  _verifierMap = {
+  _nodeCreateBuffer;
+  _nodeUpdateBuffer;
+  _headBuffer;
+  verifierMap = {
     gt: (nv, v) => this.comparator.isHigher(nv, v),
     gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
     lt: (nv, v) => this.comparator.isLower(nv, v),
@@ -105,26 +91,25 @@ var BPTree = class {
     equal: (nv, v) => this.comparator.isSame(nv, v),
     notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
     like: (nv, v) => {
-      const nodeValue = nv.toString();
-      const value = v.toString();
-      const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
-      const regex = new RegExp(`^${pattern}$`, "i");
-      return regex.test(nodeValue);
+      const nodeValue = this.comparator.match(nv);
+      const value = this.comparator.match(v);
+      const regexp = this._regexpCache.ensure(value, () => {
+        const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
+        return new RegExp(`^${pattern}$`, "i");
+      });
+      return regexp.test(nodeValue);
     }
   };
-  _verifierStartNode = {
+  verifierStartNode = {
     gt: (v) => this.insertableNode(v),
     gte: (v) => this.insertableNode(v),
-    // todo
     lt: (v) => this.insertableNode(v),
     lte: (v) => this.insertableNode(v),
-    // todo
     equal: (v) => this.insertableNode(v),
     notEqual: (v) => this.leftestNode(),
     like: (v) => this.leftestNode()
-    // todo
   };
-  _verifierDirection = {
+  verifierDirection = {
     gt: 1,
     gte: 1,
     lt: -1,
@@ -133,7 +118,7 @@ var BPTree = class {
     notEqual: 1,
     like: 1
   };
-  _verifierFullSearch = {
+  verifierFullScan = {
     gt: false,
     gte: false,
     lt: false,
@@ -142,59 +127,7 @@ var BPTree = class {
     notEqual: true,
     like: true
   };
-  _createNodeId() {
-    const id = this.strategy.id();
-    if (id === 0) {
-      throw new Error(`The node's id should never be 0.`);
-    }
-    return id;
-  }
-  _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = this._createNodeId();
-    const node = {
-      id,
-      keys,
-      values,
-      leaf,
-      parent,
-      next,
-      prev
-    };
-    this.nodes.set(id, node);
-    return node;
-  }
-  /**
-   * @param strategy An instance of a strategy that manages the read/write state of a node.
-   * @param comparator An instance of a comparator that compares the size of values.
-   */
-  constructor(strategy, comparator) {
-    const head = strategy.readHead();
-    this._creates = /* @__PURE__ */ new Map();
-    this._updates = /* @__PURE__ */ new Map();
-    this._updatedHead = null;
-    this.nodes = /* @__PURE__ */ new Map();
-    this.search = new BinarySearch(comparator);
-    this.strategy = strategy;
-    this.comparator = comparator;
-    if (head === null) {
-      this.order = strategy.order;
-      this.data = {};
-      this.root = this._createNode([], [], true);
-      this._setHeadUpdate(this._headState);
-      this._setCreates(this.root);
-      this._emitHeadUpdates();
-      this._emitCreates();
-    } else {
-      const { root, order, data } = head;
-      this.order = order;
-      this.data = data ?? {};
-      this.root = this.getNode(root);
-    }
-    if (this.order < 3) {
-      throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
-    }
-  }
-  get _headState() {
+  get headState() {
     const root = this.root.id;
     const order = this.order;
     const data = this.data;
@@ -204,82 +137,14 @@ var BPTree = class {
       data
     };
   }
-  _setHeadUpdate(head) {
-    this._updatedHead = head;
-  }
-  _setCreates(node) {
-    this._creates.set(node.id, node);
-  }
-  _setUpdates(node) {
-    this._updates.set(node.id, node);
-  }
-  _emitHeadUpdates() {
-    if (this._updatedHead !== null) {
-      this.strategy.writeHead(this._updatedHead);
-    }
-    this._updatedHead = null;
-  }
-  _emitCreates() {
-    for (const node of this._creates.values()) {
-      this.strategy.write(node.id, node);
-    }
-    this._creates.clear();
-  }
-  _emitUpdates() {
-    for (const node of this._updates.values()) {
-      this.strategy.write(node.id, node);
-    }
-    this._updates.clear();
-  }
-  getNode(id) {
-    if (!this.nodes.has(id)) {
-      this.nodes.set(id, this.strategy.read(id));
-    }
-    return this.nodes.get(id);
-  }
-  leftestNode() {
-    let node = this.root;
-    while (!node.leaf) {
-      const keys = node.keys;
-      node = this.getNode(keys[0]);
-    }
-    return node;
-  }
-  insertableNode(value) {
-    let node = this.root;
-    while (!node.leaf) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const k = node.keys;
-        if (this.comparator.isSame(value, nValue)) {
-          node = this.getNode(k[i + 1]);
-          break;
-        } else if (this.comparator.isLower(value, nValue)) {
-          node = this.getNode(k[i]);
-          break;
-        } else if (i + 1 === node.values.length) {
-          node = this.getNode(k[i + 1]);
-          break;
-        }
-      }
-    }
-    return node;
-  }
-  /**
-   * It returns whether there is a value in the tree.
-   * @param key The key value to search for.
-   * @param value The value to search for.
-   */
-  exists(key, value) {
-    const node = this.insertableNode(value);
-    for (let i = 0, len = node.values.length; i < len; i++) {
-      const nValue = node.values[i];
-      if (this.comparator.isSame(value, nValue)) {
-        const keys = node.keys[i];
-        return keys.includes(key);
-      }
-    }
-    return false;
+  constructor(strategy, comparator) {
+    this._regexpCache = new CacheStorage();
+    this._headBuffer = null;
+    this._nodeCreateBuffer = /* @__PURE__ */ new Map();
+    this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
+    this.nodes = /* @__PURE__ */ new Map();
+    this.strategy = strategy;
+    this.comparator = comparator;
   }
   _insertAtLeaf(node, key, value) {
     if (node.values.length) {
@@ -288,74 +153,49 @@ var BPTree = class {
         if (this.comparator.isSame(value, nValue)) {
           const keys = node.keys[i];
           keys.push(key);
-          this._setUpdates(node);
+          this.bufferForNodeUpdate(node);
           break;
         } else if (this.comparator.isLower(value, nValue)) {
           node.values.splice(i, 0, value);
           node.keys.splice(i, 0, [key]);
-          this._setUpdates(node);
+          this.bufferForNodeUpdate(node);
           break;
         } else if (i + 1 === node.values.length) {
           node.values.push(value);
           node.keys.push([key]);
-          this._setUpdates(node);
+          this.bufferForNodeUpdate(node);
           break;
         }
       }
     } else {
       node.values = [value];
       node.keys = [[key]];
-      this._setUpdates(node);
+      this.bufferForNodeUpdate(node);
     }
   }
-  _insertInParent(node, value, pointer) {
-    if (this.root === node) {
-      const root = this._createNode([node.id, pointer.id], [value]);
-      this.root = root;
-      node.parent = root.id;
-      pointer.parent = root.id;
-      this._setHeadUpdate(this._headState);
-      this._setCreates(root);
-      this._setUpdates(node);
-      this._setUpdates(pointer);
-      return;
-    }
-    const parentNode = this.getNode(node.parent);
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      const nKeys = parentNode.keys[i];
-      if (nKeys === node.id) {
-        parentNode.values.splice(i, 0, value);
-        parentNode.keys.splice(i + 1, 0, pointer.id);
-        this._setUpdates(parentNode);
-        if (parentNode.keys.length > this.order) {
-          const parentPointer = this._createNode([], []);
-          parentPointer.parent = parentNode.parent;
-          const mid = Math.ceil(this.order / 2) - 1;
-          parentPointer.values = parentNode.values.slice(mid + 1);
-          parentPointer.keys = parentNode.keys.slice(mid + 1);
-          const midValue = parentNode.values[mid];
-          if (mid === 0) {
-            parentNode.values = parentNode.values.slice(0, mid + 1);
-          } else {
-            parentNode.values = parentNode.values.slice(0, mid);
-          }
-          parentNode.keys = parentNode.keys.slice(0, mid + 1);
-          for (const k of parentNode.keys) {
-            const node2 = this.getNode(k);
-            node2.parent = parentNode.id;
-            this._setUpdates(node2);
-          }
-          for (const k of parentPointer.keys) {
-            const node2 = this.getNode(k);
-            node2.parent = parentPointer.id;
-            this._setUpdates(node2);
-          }
-          this._insertInParent(parentNode, midValue, parentPointer);
-          this._setCreates(parentPointer);
-          this._setUpdates(parentNode);
-        }
-      }
-    }
+  bufferForHeadUpdate(head) {
+    this._headBuffer = head;
+  }
+  bufferForNodeCreate(node) {
+    this._nodeCreateBuffer.set(node.id, node);
+  }
+  bufferForNodeUpdate(node) {
+    this._nodeUpdateBuffer.set(node.id, node);
+  }
+  /**
+   * Returns the user-defined data stored in the head of the tree.
+   * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.
+   * @returns User-defined data stored in the head of the tree.
+   */
+  getHeadData() {
+    return this.data;
+  }
+};
+
+// src/BPTreeSync.ts
+var BPTreeSync = class extends BPTree {
+  constructor(strategy, comparator) {
+    super(strategy, comparator);
   }
   _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
     const pairs = [];
@@ -423,63 +263,413 @@ var BPTree = class {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  /**
-   * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.  
-   * The result is key set instance, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
-   * This method operates much faster than first searching with `where` and then retrieving only the key list.
-   * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
-   */
-  keys(condition) {
-    let result = null;
-    for (const k in condition) {
-      const key = k;
-      const value = condition[key];
-      const startNode = this._verifierStartNode[key](value);
-      const direction = this._verifierDirection[key];
-      const fullSearch = this._verifierFullSearch[key];
-      const comparator = this._verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
-      if (result === null) {
-        result = pairs.map((pair) => pair.key);
-      } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
-      }
+  _createNodeId() {
+    const id = this.strategy.id();
+    if (id === 0) {
+      throw new Error(`The node's id should never be 0.`);
     }
-    return new Set(result ?? []);
+    return id;
   }
-  /**
-   * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.  
-   * The result includes the key and value attributes, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
-   * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
-   */
-  where(condition) {
-    let result = null;
-    for (const k in condition) {
-      const key = k;
-      const value = condition[key];
-      const startNode = this._verifierStartNode[key](value);
-      const direction = this._verifierDirection[key];
-      const fullSearch = this._verifierFullSearch[key];
-      const comparator = this._verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
-      if (result === null) {
-        result = pairs;
-      } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+  _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = this._createNodeId();
+    const node = {
+      id,
+      keys,
+      values,
+      leaf,
+      parent,
+      next,
+      prev
+    };
+    this.nodes.set(id, node);
+    return node;
+  }
+  _deleteEntry(node, key, value) {
+    if (!node.leaf) {
+      for (let i = 0, len = node.keys.length; i < len; i++) {
+        const nKey = node.keys[i];
+        if (nKey === key) {
+          node.keys.splice(i, 1);
+          this.bufferForNodeUpdate(node);
+          break;
+        }
+      }
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        if (this.comparator.isSame(value, nValue)) {
+          node.values.splice(i, 1);
+          this.bufferForNodeUpdate(node);
+          break;
+        }
       }
     }
-    return result ?? [];
-  }
-  /**
-   * You enter the key and value as a pair. You can later search for the pair by value.
-   * This data is stored in the tree, sorted in ascending order of value.
-   * @param key The key of the pair.
-   * @param value The value of the pair.
-   */
-  insert(key, value) {
-    const before = this.insertableNode(value);
-    this._insertAtLeaf(before, key, value);
-    if (before.values.length === this.order) {
+    if (this.root === node && node.keys.length === 1) {
+      const keys = node.keys;
+      this.root = this.getNode(keys[0]);
+      this.root.parent = 0;
+      this.bufferForHeadUpdate(this.headState);
+      this.bufferForNodeUpdate(this.root);
+      return;
+    } else if (this.root === node) {
+      return;
+    } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
+      let isPredecessor = false;
+      let parentNode = this.getNode(node.parent);
+      let prevNode = null;
+      let nextNode = null;
+      let prevValue = null;
+      let postValue = null;
+      for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+        const nKey = parentNode.keys[i];
+        if (nKey === node.id) {
+          if (i > 0) {
+            prevNode = this.getNode(parentNode.keys[i - 1]);
+            prevValue = parentNode.values[i - 1];
+          }
+          if (i < parentNode.keys.length - 1) {
+            nextNode = this.getNode(parentNode.keys[i + 1]);
+            postValue = parentNode.values[i];
+          }
+        }
+      }
+      let pointer;
+      let guess;
+      if (prevNode === null) {
+        pointer = nextNode;
+        guess = postValue;
+      } else if (nextNode === null) {
+        isPredecessor = true;
+        pointer = prevNode;
+        guess = prevValue;
+      } else {
+        if (node.values.length + nextNode.values.length < this.order) {
+          pointer = nextNode;
+          guess = postValue;
+        } else {
+          isPredecessor = true;
+          pointer = prevNode;
+          guess = prevValue;
+        }
+      }
+      if (node.values.length + pointer.values.length < this.order) {
+        if (!isPredecessor) {
+          const pTemp = pointer;
+          pointer = node;
+          node = pTemp;
+        }
+        pointer.keys.push(...node.keys);
+        if (!node.leaf) {
+          pointer.values.push(guess);
+        } else {
+          pointer.next = node.next;
+          pointer.prev = node.id;
+          if (pointer.next) {
+            const n = this.getNode(node.next);
+            n.prev = pointer.id;
+            this.bufferForNodeUpdate(n);
+          }
+          if (pointer.prev) {
+            const n = this.getNode(node.id);
+            n.next = pointer.id;
+            this.bufferForNodeUpdate(n);
+          }
+          if (isPredecessor) {
+            pointer.prev = 0;
+          }
+        }
+        pointer.values.push(...node.values);
+        if (!pointer.leaf) {
+          const keys = pointer.keys;
+          for (const key2 of keys) {
+            const node2 = this.getNode(key2);
+            node2.parent = pointer.id;
+            this.bufferForNodeUpdate(node2);
+          }
+        }
+        this._deleteEntry(this.getNode(node.parent), node.id, guess);
+        this.bufferForNodeUpdate(pointer);
+      } else {
+        if (isPredecessor) {
+          let pointerPm;
+          let pointerKm;
+          if (!node.leaf) {
+            pointerPm = pointer.keys.splice(-1)[0];
+            pointerKm = pointer.values.splice(-1)[0];
+            node.keys = [pointerPm, ...node.keys];
+            node.values = [guess, ...node.values];
+            parentNode = this.getNode(node.parent);
+            for (let i = 0, len = parentNode.values.length; i < len; i++) {
+              const nValue = parentNode.values[i];
+              if (this.comparator.isSame(guess, nValue)) {
+                parentNode.values[i] = pointerKm;
+                this.bufferForNodeUpdate(parentNode);
+                break;
+              }
+            }
+          } else {
+            pointerPm = pointer.keys.splice(-1)[0];
+            pointerKm = pointer.values.splice(-1)[0];
+            node.keys = [pointerPm, ...node.keys];
+            node.values = [pointerKm, ...node.values];
+            parentNode = this.getNode(node.parent);
+            for (let i = 0, len = parentNode.values.length; i < len; i++) {
+              const nValue = parentNode.values[i];
+              if (this.comparator.isSame(guess, nValue)) {
+                parentNode.values[i] = pointerKm;
+                this.bufferForNodeUpdate(parentNode);
+                break;
+              }
+            }
+          }
+          this.bufferForNodeUpdate(node);
+          this.bufferForNodeUpdate(pointer);
+        } else {
+          let pointerP0;
+          let pointerK0;
+          if (!node.leaf) {
+            pointerP0 = pointer.keys.splice(0, 1)[0];
+            pointerK0 = pointer.values.splice(0, 1)[0];
+            node.keys = [...node.keys, pointerP0];
+            node.values = [...node.values, guess];
+            parentNode = this.getNode(node.parent);
+            for (let i = 0, len = parentNode.values.length; i < len; i++) {
+              const nValue = parentNode.values[i];
+              if (this.comparator.isSame(guess, nValue)) {
+                parentNode.values[i] = pointerK0;
+                this.bufferForNodeUpdate(parentNode);
+                break;
+              }
+            }
+          } else {
+            pointerP0 = pointer.keys.splice(0, 1)[0];
+            pointerK0 = pointer.values.splice(0, 1)[0];
+            node.keys = [...node.keys, pointerP0];
+            node.values = [...node.values, pointerK0];
+            parentNode = this.getNode(node.parent);
+            for (let i = 0, len = parentNode.values.length; i < len; i++) {
+              const nValue = parentNode.values[i];
+              if (this.comparator.isSame(guess, nValue)) {
+                parentNode.values[i] = pointer.values[0];
+                this.bufferForNodeUpdate(parentNode);
+                break;
+              }
+            }
+          }
+          this.bufferForNodeUpdate(node);
+          this.bufferForNodeUpdate(pointer);
+        }
+        if (!pointer.leaf) {
+          for (const key2 of pointer.keys) {
+            const n = this.getNode(key2);
+            n.parent = pointer.id;
+            this.bufferForNodeUpdate(n);
+          }
+        }
+        if (!node.leaf) {
+          for (const key2 of node.keys) {
+            const n = this.getNode(key2);
+            n.parent = node.id;
+            this.bufferForNodeUpdate(n);
+          }
+        }
+        if (!parentNode.leaf) {
+          for (const key2 of parentNode.keys) {
+            const n = this.getNode(key2);
+            n.parent = parentNode.id;
+            this.bufferForNodeUpdate(n);
+          }
+        }
+      }
+    }
+  }
+  _insertAtLeaf(node, key, value) {
+    if (node.values.length) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        if (this.comparator.isSame(value, nValue)) {
+          const keys = node.keys[i];
+          keys.push(key);
+          this.bufferForNodeUpdate(node);
+          break;
+        } else if (this.comparator.isLower(value, nValue)) {
+          node.values.splice(i, 0, value);
+          node.keys.splice(i, 0, [key]);
+          this.bufferForNodeUpdate(node);
+          break;
+        } else if (i + 1 === node.values.length) {
+          node.values.push(value);
+          node.keys.push([key]);
+          this.bufferForNodeUpdate(node);
+          break;
+        }
+      }
+    } else {
+      node.values = [value];
+      node.keys = [[key]];
+      this.bufferForNodeUpdate(node);
+    }
+  }
+  _insertInParent(node, value, pointer) {
+    if (this.root === node) {
+      const root = this._createNode([node.id, pointer.id], [value]);
+      this.root = root;
+      node.parent = root.id;
+      pointer.parent = root.id;
+      this.bufferForHeadUpdate(this.headState);
+      this.bufferForNodeCreate(root);
+      this.bufferForNodeUpdate(node);
+      this.bufferForNodeUpdate(pointer);
+      return;
+    }
+    const parentNode = this.getNode(node.parent);
+    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+      const nKeys = parentNode.keys[i];
+      if (nKeys === node.id) {
+        parentNode.values.splice(i, 0, value);
+        parentNode.keys.splice(i + 1, 0, pointer.id);
+        this.bufferForNodeUpdate(parentNode);
+        if (parentNode.keys.length > this.order) {
+          const parentPointer = this._createNode([], []);
+          parentPointer.parent = parentNode.parent;
+          const mid = Math.ceil(this.order / 2) - 1;
+          parentPointer.values = parentNode.values.slice(mid + 1);
+          parentPointer.keys = parentNode.keys.slice(mid + 1);
+          const midValue = parentNode.values[mid];
+          if (mid === 0) {
+            parentNode.values = parentNode.values.slice(0, mid + 1);
+          } else {
+            parentNode.values = parentNode.values.slice(0, mid);
+          }
+          parentNode.keys = parentNode.keys.slice(0, mid + 1);
+          for (const k of parentNode.keys) {
+            const node2 = this.getNode(k);
+            node2.parent = parentNode.id;
+            this.bufferForNodeUpdate(node2);
+          }
+          for (const k of parentPointer.keys) {
+            const node2 = this.getNode(k);
+            node2.parent = parentPointer.id;
+            this.bufferForNodeUpdate(node2);
+          }
+          this._insertInParent(parentNode, midValue, parentPointer);
+          this.bufferForNodeCreate(parentPointer);
+          this.bufferForNodeUpdate(parentNode);
+        }
+      }
+    }
+  }
+  init() {
+    const head = this.strategy.readHead();
+    if (head === null) {
+      this.order = this.strategy.order;
+      this.data = {};
+      this.root = this._createNode([], [], true);
+      this.bufferForHeadUpdate(this.headState);
+      this.bufferForNodeCreate(this.root);
+      this.commitHeadBuffer();
+      this.commitNodeCreateBuffer();
+    } else {
+      const { root, order, data } = head;
+      this.order = order;
+      this.data = data ?? {};
+      this.root = this.getNode(root);
+    }
+    if (this.order < 3) {
+      throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
+    }
+  }
+  getNode(id) {
+    if (!this.nodes.has(id)) {
+      this.nodes.set(id, this.strategy.read(id));
+    }
+    return this.nodes.get(id);
+  }
+  insertableNode(value) {
+    let node = this.root;
+    while (!node.leaf) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const k = node.keys;
+        if (this.comparator.isSame(value, nValue)) {
+          node = this.getNode(k[i + 1]);
+          break;
+        } else if (this.comparator.isLower(value, nValue)) {
+          node = this.getNode(k[i]);
+          break;
+        } else if (i + 1 === node.values.length) {
+          node = this.getNode(k[i + 1]);
+          break;
+        }
+      }
+    }
+    return node;
+  }
+  leftestNode() {
+    let node = this.root;
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = this.getNode(keys[0]);
+    }
+    return node;
+  }
+  commitHeadBuffer() {
+    if (this._headBuffer !== null) {
+      this.strategy.writeHead(this._headBuffer);
+    }
+    this.bufferForHeadUpdate(null);
+  }
+  commitNodeCreateBuffer() {
+    for (const node of this._nodeCreateBuffer.values()) {
+      this.strategy.write(node.id, node);
+    }
+    this._nodeCreateBuffer.clear();
+  }
+  commitNodeUpdateBuffer() {
+    for (const node of this._nodeUpdateBuffer.values()) {
+      this.strategy.write(node.id, node);
+    }
+    this._nodeUpdateBuffer.clear();
+  }
+  keys(condition) {
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = this.verifierStartNode[key](value);
+      const direction = this.verifierDirection[key];
+      const fullScan = this.verifierFullScan[key];
+      const comparator = this.verifierMap[key];
+      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
+      if (result === null) {
+        result = pairs.map((pair) => pair.key);
+      } else {
+        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+      }
+    }
+    return new Set(result ?? []);
+  }
+  where(condition) {
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = this.verifierStartNode[key](value);
+      const direction = this.verifierDirection[key];
+      const fullScan = this.verifierFullScan[key];
+      const comparator = this.verifierMap[key];
+      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
+      if (result === null) {
+        result = pairs;
+      } else {
+        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+      }
+    }
+    return result ?? [];
+  }
+  insert(key, value) {
+    const before = this.insertableNode(value);
+    this._insertAtLeaf(before, key, value);
+    if (before.values.length === this.order) {
       const after = this._createNode(
         [],
         [],
@@ -498,21 +688,16 @@ var BPTree = class {
       if (beforeNext) {
         const node = this.getNode(beforeNext);
         node.prev = after.id;
-        this._setUpdates(node);
+        this.bufferForNodeUpdate(node);
       }
       this._insertInParent(before, after.values[0], after);
-      this._setCreates(after);
-      this._setUpdates(before);
+      this.bufferForNodeCreate(after);
+      this.bufferForNodeUpdate(before);
     }
-    this._emitHeadUpdates();
-    this._emitCreates();
-    this._emitUpdates();
+    this.commitHeadBuffer();
+    this.commitNodeCreateBuffer();
+    this.commitNodeUpdateBuffer();
   }
-  /**
-   * Deletes the pair that matches the key and value.
-   * @param key The key of the pair.
-   * @param value The value of the pair.
-   */
   delete(key, value) {
     const node = this.insertableNode(value);
     let i = node.values.length;
@@ -523,32 +708,151 @@ var BPTree = class {
         if (keys.includes(key)) {
           if (keys.length > 1) {
             keys.splice(keys.indexOf(key), 1);
-            this._setUpdates(node);
+            this.bufferForNodeUpdate(node);
           } else if (node === this.root) {
             node.values.splice(i, 1);
             node.keys.splice(i, 1);
-            this._setUpdates(node);
+            this.bufferForNodeUpdate(node);
           } else {
             keys.splice(keys.indexOf(key), 1);
             node.keys.splice(i, 1);
             node.values.splice(node.values.indexOf(value), 1);
             this._deleteEntry(node, key, value);
-            this._setUpdates(node);
+            this.bufferForNodeUpdate(node);
+          }
+        }
+      }
+    }
+    this.commitHeadBuffer();
+    this.commitNodeCreateBuffer();
+    this.commitNodeUpdateBuffer();
+  }
+  exists(key, value) {
+    const node = this.insertableNode(value);
+    for (let i = 0, len = node.values.length; i < len; i++) {
+      const nValue = node.values[i];
+      if (this.comparator.isSame(value, nValue)) {
+        const keys = node.keys[i];
+        return keys.includes(key);
+      }
+    }
+    return false;
+  }
+  setHeadData(data) {
+    this.data = data;
+    this.bufferForHeadUpdate(this.headState);
+    this.commitHeadBuffer();
+  }
+  forceUpdate() {
+    const keys = [...this.nodes.keys()];
+    this.nodes.clear();
+    this.init();
+    for (const key of keys) {
+      this.getNode(key);
+    }
+    return keys.length;
+  }
+};
+
+// src/BPTreeAsync.ts
+var BPTreeAsync = class extends BPTree {
+  constructor(strategy, comparator) {
+    super(strategy, comparator);
+  }
+  async _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
+    const pairs = [];
+    let node = startNode;
+    let done = false;
+    let found = false;
+    while (!done) {
+      let i = node.values.length;
+      while (i--) {
+        const nValue = node.values[i];
+        const keys = node.keys[i];
+        if (comparator(nValue, value)) {
+          found = true;
+          let j = keys.length;
+          while (j--) {
+            pairs.push({ key: keys[j], value: nValue });
+          }
+        } else if (found && !fullSearch) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.prev) {
+        done = true;
+        break;
+      }
+      node = await this.getNode(node.prev);
+    }
+    return pairs.reverse();
+  }
+  async _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
+    const pairs = [];
+    let node = startNode;
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const keys = node.keys[i];
+        if (comparator(nValue, value)) {
+          found = true;
+          for (const key of keys) {
+            pairs.push({ key, value: nValue });
           }
+        } else if (found && !fullSearch) {
+          done = true;
+          break;
         }
       }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = await this.getNode(node.next);
     }
-    this._emitHeadUpdates();
-    this._emitCreates();
-    this._emitUpdates();
+    return pairs;
   }
-  _deleteEntry(node, key, value) {
+  async getPairs(value, startNode, fullSearch, comparator, direction) {
+    switch (direction) {
+      case -1:
+        return await this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+      case 1:
+        return await this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
+    }
+  }
+  async _createNodeId() {
+    const id = await this.strategy.id();
+    if (id === 0) {
+      throw new Error(`The node's id should never be 0.`);
+    }
+    return id;
+  }
+  async _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = await this._createNodeId();
+    const node = {
+      id,
+      keys,
+      values,
+      leaf,
+      parent,
+      next,
+      prev
+    };
+    this.nodes.set(id, node);
+    return node;
+  }
+  async _deleteEntry(node, key, value) {
     if (!node.leaf) {
       for (let i = 0, len = node.keys.length; i < len; i++) {
         const nKey = node.keys[i];
         if (nKey === key) {
           node.keys.splice(i, 1);
-          this._setUpdates(node);
+          this.bufferForNodeUpdate(node);
           break;
         }
       }
@@ -556,23 +860,23 @@ var BPTree = class {
         const nValue = node.values[i];
         if (this.comparator.isSame(value, nValue)) {
           node.values.splice(i, 1);
-          this._setUpdates(node);
+          this.bufferForNodeUpdate(node);
           break;
         }
       }
     }
     if (this.root === node && node.keys.length === 1) {
       const keys = node.keys;
-      this.root = this.getNode(keys[0]);
+      this.root = await this.getNode(keys[0]);
       this.root.parent = 0;
-      this._setHeadUpdate(this._headState);
-      this._setUpdates(this.root);
+      this.bufferForHeadUpdate(this.headState);
+      this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
       return;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       let isPredecessor = false;
-      let parentNode = this.getNode(node.parent);
+      let parentNode = await this.getNode(node.parent);
       let prevNode = null;
       let nextNode = null;
       let prevValue = null;
@@ -581,11 +885,11 @@ var BPTree = class {
         const nKey = parentNode.keys[i];
         if (nKey === node.id) {
           if (i > 0) {
-            prevNode = this.getNode(parentNode.keys[i - 1]);
+            prevNode = await this.getNode(parentNode.keys[i - 1]);
             prevValue = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = this.getNode(parentNode.keys[i + 1]);
+            nextNode = await this.getNode(parentNode.keys[i + 1]);
             postValue = parentNode.values[i];
           }
         }
@@ -622,14 +926,14 @@ var BPTree = class {
           pointer.next = node.next;
           pointer.prev = node.id;
           if (pointer.next) {
-            const n = this.getNode(node.next);
+            const n = await this.getNode(node.next);
             n.prev = pointer.id;
-            this._setUpdates(n);
+            this.bufferForNodeUpdate(n);
           }
           if (pointer.prev) {
-            const n = this.getNode(node.id);
+            const n = await this.getNode(node.id);
             n.next = pointer.id;
-            this._setUpdates(n);
+            this.bufferForNodeUpdate(n);
           }
           if (isPredecessor) {
             pointer.prev = 0;
@@ -639,13 +943,13 @@ var BPTree = class {
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
-            const node2 = this.getNode(key2);
+            const node2 = await this.getNode(key2);
             node2.parent = pointer.id;
-            this._setUpdates(node2);
+            this.bufferForNodeUpdate(node2);
           }
         }
-        this._deleteEntry(this.getNode(node.parent), node.id, guess);
-        this._setUpdates(pointer);
+        await this._deleteEntry(await this.getNode(node.parent), node.id, guess);
+        this.bufferForNodeUpdate(pointer);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -655,12 +959,12 @@ var BPTree = class {
             pointerKm = pointer.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
-            parentNode = this.getNode(node.parent);
+            parentNode = await this.getNode(node.parent);
             for (let i = 0, len = parentNode.values.length; i < len; i++) {
               const nValue = parentNode.values[i];
               if (this.comparator.isSame(guess, nValue)) {
                 parentNode.values[i] = pointerKm;
-                this._setUpdates(parentNode);
+                this.bufferForNodeUpdate(parentNode);
                 break;
               }
             }
@@ -669,18 +973,18 @@ var BPTree = class {
             pointerKm = pointer.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
-            parentNode = this.getNode(node.parent);
+            parentNode = await this.getNode(node.parent);
             for (let i = 0, len = parentNode.values.length; i < len; i++) {
               const nValue = parentNode.values[i];
               if (this.comparator.isSame(guess, nValue)) {
                 parentNode.values[i] = pointerKm;
-                this._setUpdates(parentNode);
+                this.bufferForNodeUpdate(parentNode);
                 break;
               }
             }
           }
-          this._setUpdates(node);
-          this._setUpdates(pointer);
+          this.bufferForNodeUpdate(node);
+          this.bufferForNodeUpdate(pointer);
         } else {
           let pointerP0;
           let pointerK0;
@@ -689,12 +993,12 @@ var BPTree = class {
             pointerK0 = pointer.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
-            parentNode = this.getNode(node.parent);
+            parentNode = await this.getNode(node.parent);
             for (let i = 0, len = parentNode.values.length; i < len; i++) {
               const nValue = parentNode.values[i];
               if (this.comparator.isSame(guess, nValue)) {
                 parentNode.values[i] = pointerK0;
-                this._setUpdates(parentNode);
+                this.bufferForNodeUpdate(parentNode);
                 break;
               }
             }
@@ -703,72 +1007,300 @@ var BPTree = class {
             pointerK0 = pointer.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
-            parentNode = this.getNode(node.parent);
+            parentNode = await this.getNode(node.parent);
             for (let i = 0, len = parentNode.values.length; i < len; i++) {
               const nValue = parentNode.values[i];
               if (this.comparator.isSame(guess, nValue)) {
                 parentNode.values[i] = pointer.values[0];
-                this._setUpdates(parentNode);
+                this.bufferForNodeUpdate(parentNode);
                 break;
               }
             }
           }
-          this._setUpdates(node);
-          this._setUpdates(pointer);
+          this.bufferForNodeUpdate(node);
+          this.bufferForNodeUpdate(pointer);
         }
         if (!pointer.leaf) {
           for (const key2 of pointer.keys) {
-            const n = this.getNode(key2);
+            const n = await this.getNode(key2);
             n.parent = pointer.id;
-            this._setUpdates(n);
+            this.bufferForNodeUpdate(n);
           }
         }
         if (!node.leaf) {
           for (const key2 of node.keys) {
-            const n = this.getNode(key2);
+            const n = await this.getNode(key2);
             n.parent = node.id;
-            this._setUpdates(n);
+            this.bufferForNodeUpdate(n);
           }
         }
         if (!parentNode.leaf) {
           for (const key2 of parentNode.keys) {
-            const n = this.getNode(key2);
+            const n = await this.getNode(key2);
             n.parent = parentNode.id;
-            this._setUpdates(n);
+            this.bufferForNodeUpdate(n);
           }
         }
       }
     }
   }
-  /**
-   * Returns the user-defined data stored in the head of the tree.
-   * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.
-   * @returns User-defined data stored in the head of the tree.
-   */
-  getHeadData() {
-    return this.data;
+  async _insertInParent(node, value, pointer) {
+    if (this.root === node) {
+      const root = await this._createNode([node.id, pointer.id], [value]);
+      this.root = root;
+      node.parent = root.id;
+      pointer.parent = root.id;
+      this.bufferForHeadUpdate(this.headState);
+      this.bufferForNodeCreate(root);
+      this.bufferForNodeUpdate(node);
+      this.bufferForNodeUpdate(pointer);
+      return;
+    }
+    const parentNode = await this.getNode(node.parent);
+    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+      const nKeys = parentNode.keys[i];
+      if (nKeys === node.id) {
+        parentNode.values.splice(i, 0, value);
+        parentNode.keys.splice(i + 1, 0, pointer.id);
+        this.bufferForNodeUpdate(parentNode);
+        if (parentNode.keys.length > this.order) {
+          const parentPointer = await this._createNode([], []);
+          parentPointer.parent = parentNode.parent;
+          const mid = Math.ceil(this.order / 2) - 1;
+          parentPointer.values = parentNode.values.slice(mid + 1);
+          parentPointer.keys = parentNode.keys.slice(mid + 1);
+          const midValue = parentNode.values[mid];
+          if (mid === 0) {
+            parentNode.values = parentNode.values.slice(0, mid + 1);
+          } else {
+            parentNode.values = parentNode.values.slice(0, mid);
+          }
+          parentNode.keys = parentNode.keys.slice(0, mid + 1);
+          for (const k of parentNode.keys) {
+            const node2 = await this.getNode(k);
+            node2.parent = parentNode.id;
+            this.bufferForNodeUpdate(node2);
+          }
+          for (const k of parentPointer.keys) {
+            const node2 = await this.getNode(k);
+            node2.parent = parentPointer.id;
+            this.bufferForNodeUpdate(node2);
+          }
+          await this._insertInParent(parentNode, midValue, parentPointer);
+          this.bufferForNodeCreate(parentPointer);
+          this.bufferForNodeUpdate(parentNode);
+        }
+      }
+    }
   }
-  /**
-   * Inserts user-defined data into the head of the tree.
-   * This feature is useful when you need to store separate, non-volatile information in the tree.
-   * For example, you can store information such as the last update time and the number of insertions.
-   * @param data User-defined data to be stored in the head of the tree.
-   */
-  setHeadData(data) {
+  async init() {
+    const head = await this.strategy.readHead();
+    if (head === null) {
+      this.order = this.strategy.order;
+      this.data = {};
+      this.root = await this._createNode([], [], true);
+      this.bufferForHeadUpdate(this.headState);
+      this.bufferForNodeCreate(this.root);
+      this.commitHeadBuffer();
+      this.commitNodeCreateBuffer();
+    } else {
+      const { root, order, data } = head;
+      this.order = order;
+      this.data = data ?? {};
+      this.root = await this.getNode(root);
+    }
+    if (this.order < 3) {
+      throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
+    }
+  }
+  async getNode(id) {
+    if (!this.nodes.has(id)) {
+      this.nodes.set(id, await this.strategy.read(id));
+    }
+    return this.nodes.get(id);
+  }
+  async insertableNode(value) {
+    let node = this.root;
+    while (!node.leaf) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const k = node.keys;
+        if (this.comparator.isSame(value, nValue)) {
+          node = await this.getNode(k[i + 1]);
+          break;
+        } else if (this.comparator.isLower(value, nValue)) {
+          node = await this.getNode(k[i]);
+          break;
+        } else if (i + 1 === node.values.length) {
+          node = await this.getNode(k[i + 1]);
+          break;
+        }
+      }
+    }
+    return node;
+  }
+  async leftestNode() {
+    let node = this.root;
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = await this.getNode(keys[0]);
+    }
+    return node;
+  }
+  async commitHeadBuffer() {
+    if (this._headBuffer !== null) {
+      await this.strategy.writeHead(this._headBuffer);
+    }
+    this.bufferForHeadUpdate(null);
+  }
+  async commitNodeCreateBuffer() {
+    for (const node of this._nodeCreateBuffer.values()) {
+      await this.strategy.write(node.id, node);
+    }
+    this._nodeCreateBuffer.clear();
+  }
+  async commitNodeUpdateBuffer() {
+    for (const node of this._nodeUpdateBuffer.values()) {
+      await this.strategy.write(node.id, node);
+    }
+    this._nodeUpdateBuffer.clear();
+  }
+  async keys(condition) {
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = await this.verifierStartNode[key](value);
+      const direction = this.verifierDirection[key];
+      const fullScan = this.verifierFullScan[key];
+      const comparator = this.verifierMap[key];
+      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
+      if (result === null) {
+        result = pairs.map((pair) => pair.key);
+      } else {
+        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+      }
+    }
+    return new Set(result ?? []);
+  }
+  async where(condition) {
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = await this.verifierStartNode[key](value);
+      const direction = this.verifierDirection[key];
+      const fullScan = this.verifierFullScan[key];
+      const comparator = this.verifierMap[key];
+      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
+      if (result === null) {
+        result = pairs;
+      } else {
+        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+      }
+    }
+    return result ?? [];
+  }
+  async insert(key, value) {
+    const before = await this.insertableNode(value);
+    this._insertAtLeaf(before, key, value);
+    if (before.values.length === this.order) {
+      const after = await this._createNode(
+        [],
+        [],
+        true,
+        before.parent,
+        before.next,
+        before.id
+      );
+      const mid = Math.ceil(this.order / 2) - 1;
+      const beforeNext = before.next;
+      after.values = before.values.slice(mid + 1);
+      after.keys = before.keys.slice(mid + 1);
+      before.values = before.values.slice(0, mid + 1);
+      before.keys = before.keys.slice(0, mid + 1);
+      before.next = after.id;
+      if (beforeNext) {
+        const node = await this.getNode(beforeNext);
+        node.prev = after.id;
+        this.bufferForNodeUpdate(node);
+      }
+      await this._insertInParent(before, after.values[0], after);
+      this.bufferForNodeCreate(after);
+      this.bufferForNodeUpdate(before);
+    }
+    await this.commitHeadBuffer();
+    await this.commitNodeCreateBuffer();
+    await this.commitNodeUpdateBuffer();
+  }
+  async delete(key, value) {
+    const node = await this.insertableNode(value);
+    let i = node.values.length;
+    while (i--) {
+      const nValue = node.values[i];
+      if (this.comparator.isSame(value, nValue)) {
+        const keys = node.keys[i];
+        if (keys.includes(key)) {
+          if (keys.length > 1) {
+            keys.splice(keys.indexOf(key), 1);
+            this.bufferForNodeUpdate(node);
+          } else if (node === this.root) {
+            node.values.splice(i, 1);
+            node.keys.splice(i, 1);
+            this.bufferForNodeUpdate(node);
+          } else {
+            keys.splice(keys.indexOf(key), 1);
+            node.keys.splice(i, 1);
+            node.values.splice(node.values.indexOf(value), 1);
+            await this._deleteEntry(node, key, value);
+            this.bufferForNodeUpdate(node);
+          }
+        }
+      }
+    }
+    await this.commitHeadBuffer();
+    await this.commitNodeCreateBuffer();
+    await this.commitNodeUpdateBuffer();
+  }
+  async exists(key, value) {
+    const node = await this.insertableNode(value);
+    for (let i = 0, len = node.values.length; i < len; i++) {
+      const nValue = node.values[i];
+      if (this.comparator.isSame(value, nValue)) {
+        const keys = node.keys[i];
+        return keys.includes(key);
+      }
+    }
+    return false;
+  }
+  async setHeadData(data) {
     this.data = data;
-    this._updatedHead = this._headState;
-    this._emitHeadUpdates();
+    this.bufferForHeadUpdate(this.headState);
+    await this.commitHeadBuffer();
+  }
+  async forceUpdate() {
+    const keys = [...this.nodes.keys()];
+    this.nodes.clear();
+    await this.init();
+    for (const key of keys) {
+      await this.getNode(key);
+    }
+    return keys.length;
   }
 };
 
-// src/SerializeStrategy.ts
+// src/base/SerializeStrategy.ts
 var SerializeStrategy = class {
   order;
   constructor(order) {
     this.order = order;
   }
 };
-var InMemoryStoreStrategy = class extends SerializeStrategy {
+
+// src/SerializeStrategySync.ts
+var SerializeStrategySync = class extends SerializeStrategy {
+};
+var InMemoryStoreStrategySync = class extends SerializeStrategySync {
   data;
   constructor(order) {
     super(order);
@@ -797,25 +1329,34 @@ var InMemoryStoreStrategy = class extends SerializeStrategy {
   }
 };
 
-// src/ValueComparator.ts
-var ValueComparator = class {
-  isLower(value, than) {
-    return this.asc(value, than) < 0;
+// src/SerializeStrategyAsync.ts
+var SerializeStrategyAsync = class extends SerializeStrategy {
+};
+var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
+  data;
+  constructor(order) {
+    super(order);
+    this.data = {
+      head: null,
+      node: {}
+    };
   }
-  isSame(value, than) {
-    return this.asc(value, than) === 0;
+  async id() {
+    return Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER - 1);
   }
-  isHigher(value, than) {
-    return this.asc(value, than) > 0;
+  async read(id) {
+    if (!Object.prototype.hasOwnProperty.call(this.data.node, id)) {
+      throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
+    }
+    return this.data.node[id];
   }
-};
-var NumericComparator = class extends ValueComparator {
-  asc(a, b) {
-    return a - b;
+  async write(id, node) {
+    this.data.node[id] = node;
   }
-};
-var StringComparator = class extends ValueComparator {
-  asc(a, b) {
-    return a.localeCompare(b);
+  async readHead() {
+    return this.data.head;
+  }
+  async writeHead(head) {
+    this.data.head = head;
   }
 };