serializable-bptree 1.1.0 → 3.0.0

package/dist/esm/index.js

@@ -1,71 +1,191 @@
-// src/utils/BinarySearch.ts
-var BinarySearch = class {
+// src/base/BPTree.ts
+var BPTree = class {
+  strategy;
   comparator;
-  constructor(comparator) {
+  nodes;
+  order;
+  data;
+  root;
+  _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),
+    lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
+    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);
+    }
+  };
+  verifierStartNode = {
+    gt: (v) => this.insertableNode(v),
+    gte: (v) => this.insertableNode(v),
+    lt: (v) => this.insertableNode(v),
+    lte: (v) => this.insertableNode(v),
+    equal: (v) => this.insertableNode(v),
+    notEqual: (v) => this.leftestNode(),
+    like: (v) => this.leftestNode()
+  };
+  verifierDirection = {
+    gt: 1,
+    gte: 1,
+    lt: -1,
+    lte: -1,
+    equal: 1,
+    notEqual: 1,
+    like: 1
+  };
+  verifierFullSearch = {
+    gt: false,
+    gte: false,
+    lt: false,
+    lte: false,
+    equal: false,
+    notEqual: true,
+    like: true
+  };
+  get headState() {
+    const root = this.root.id;
+    const order = this.order;
+    const data = this.data;
+    return {
+      root,
+      order,
+      data
+    };
+  }
+  constructor(strategy, comparator) {
+    this._headBuffer = null;
+    this._nodeCreateBuffer = /* @__PURE__ */ new Map();
+    this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
+    this.nodes = /* @__PURE__ */ new Map();
+    this.strategy = strategy;
     this.comparator = comparator;
   }
-  _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;
+  _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);
     }
-    return -1;
   }
-  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)) {
+  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 = [];
+    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;
       }
-      i--;
+      node = this.getNode(node.prev);
     }
-    return i;
+    return pairs.reverse();
   }
-  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)) {
+  _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;
       }
-      i++;
+      node = this.getNode(node.next);
     }
-    return i;
+    return pairs;
   }
-  range(array, value) {
-    const left = this.leftest(array, value);
-    const right = this.rightest(array, value) + 1;
-    return [left, right];
+  getPairs(value, startNode, fullSearch, comparator, direction) {
+    switch (direction) {
+      case -1:
+        return this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+      case 1:
+        return this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
+    }
   }
-};
-
-// src/BPTree.ts
-var BPTree = class {
-  strategy;
-  comparator;
-  search;
-  order;
-  nodes;
-  data;
-  root;
-  _creates;
-  _updates;
-  _updatedHead;
   _createNodeId() {
     const id = this.strategy.id();
     if (id === 0) {
@@ -73,7 +193,7 @@ var BPTree = class {
     }
     return id;
   }
-  _createNode(keys, values, leaf = false, parent = 0, next = 0) {
+  _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
     const id = this._createNodeId();
     const node = {
       id,
@@ -81,128 +201,209 @@ var BPTree = class {
       values,
       leaf,
       parent,
-      next
+      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() {
-    const root = this.root.id;
-    const order = this.order;
-    const data = this.data;
-    return {
-      root,
-      order,
-      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) {
+  _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];
-        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]);
+          node.values.splice(i, 1);
+          this.bufferForNodeUpdate(node);
           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);
+    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);
+          }
+        }
       }
     }
-    return false;
   }
   _insertAtLeaf(node, key, value) {
     if (node.values.length) {
@@ -211,24 +412,24 @@ 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) {
@@ -237,10 +438,10 @@ var BPTree = class {
       this.root = root;
       node.parent = root.id;
       pointer.parent = root.id;
-      this._setHeadUpdate(this._headState);
-      this._setCreates(root);
-      this._setUpdates(node);
-      this._setUpdates(pointer);
+      this.bufferForHeadUpdate(this.headState);
+      this.bufferForNodeCreate(root);
+      this.bufferForNodeUpdate(node);
+      this.bufferForNodeUpdate(pointer);
       return;
     }
     const parentNode = this.getNode(node.parent);
@@ -249,7 +450,7 @@ var BPTree = class {
       if (nKeys === node.id) {
         parentNode.values.splice(i, 0, value);
         parentNode.keys.splice(i + 1, 0, pointer.id);
-        this._setUpdates(parentNode);
+        this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
           const parentPointer = this._createNode([], []);
           parentPointer.parent = parentNode.parent;
@@ -266,259 +467,264 @@ var BPTree = class {
           for (const k of parentNode.keys) {
             const node2 = this.getNode(k);
             node2.parent = parentNode.id;
-            this._setUpdates(node2);
+            this.bufferForNodeUpdate(node2);
           }
           for (const k of parentPointer.keys) {
             const node2 = this.getNode(k);
             node2.parent = parentPointer.id;
-            this._setUpdates(node2);
+            this.bufferForNodeUpdate(node2);
           }
           this._insertInParent(parentNode, midValue, parentPointer);
-          this._setCreates(parentPointer);
-          this._setUpdates(parentNode);
+          this.bufferForNodeCreate(parentPointer);
+          this.bufferForNodeUpdate(parentNode);
         }
       }
     }
   }
-  _equalCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "equal");
-  }
-  _notEqualCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "notEqual");
-  }
-  _onlyGtCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "gt") && !Object.prototype.hasOwnProperty.call(condition, "lt");
-  }
-  _onlyLtCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "lt") && !Object.prototype.hasOwnProperty.call(condition, "gt");
-  }
-  _rangeCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "gt") && Object.prototype.hasOwnProperty.call(condition, "lt");
-  }
-  _getKeysFromValue(value) {
-    const keys = /* @__PURE__ */ new Set();
-    const node = this._insertableNode(value);
-    const [start, end] = this.search.range(node.values, value);
-    if (start === -1) {
-      return keys;
+  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);
     }
-    for (let i = start; i < end; i++) {
-      const pairKeys = node.keys[i];
-      for (const key of pairKeys) {
-        keys.add(key);
-      }
+    if (this.order < 3) {
+      throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
     }
-    return keys;
   }
-  _getKeysFromNEValue(value) {
-    const keys = /* @__PURE__ */ new Set();
-    let node = this.leftestNode();
-    let done = false;
-    while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const pairKeys = node.keys[i];
-        if (this.comparator.isSame(nValue, value) === false) {
-          for (const key of pairKeys) {
-            keys.add(key);
-          }
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
+  getNode(id) {
+    if (!this.nodes.has(id)) {
+      this.nodes.set(id, this.strategy.read(id));
     }
-    return keys;
+    return this.nodes.get(id);
   }
-  _getKeysFromRange(gt, lt) {
-    const keys = /* @__PURE__ */ new Set();
-    let node = this._insertableNode(gt);
-    let done = false;
-    let found = false;
-    while (!done) {
+  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 localKeys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
-          found = true;
-          for (const key of localKeys) {
-            keys.add(key);
-          }
-        } else if (found) {
-          done = true;
+        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;
         }
       }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
     }
-    return keys;
+    return node;
   }
-  _getKeysFromGt(gt) {
-    const keys = /* @__PURE__ */ new Set();
-    let node = this._insertableNode(gt);
-    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 localKeys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt)) {
-          found = true;
-          for (const key of localKeys) {
-            keys.add(key);
-          }
-        } else if (found) {
-          done = true;
-          break;
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
+  leftestNode() {
+    let node = this.root;
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = this.getNode(keys[0]);
     }
-    return keys;
+    return node;
   }
-  _getKeysFromLt(lt) {
-    const keys = /* @__PURE__ */ new Set();
-    let node = this.leftestNode();
-    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 localKeys = node.keys[i];
-        if (this.comparator.isLower(nValue, lt)) {
-          found = true;
-          for (const key of localKeys) {
-            keys.add(key);
-          }
-        } else if (found) {
-          done = true;
-          break;
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
+  commitHeadBuffer() {
+    if (this._headBuffer !== null) {
+      this.strategy.writeHead(this._headBuffer);
     }
-    return keys;
+    this.bufferForHeadUpdate(null);
   }
-  _getPairsFromValue(value) {
-    const node = this._insertableNode(value);
-    const [start, end] = this.search.range(node.values, value);
-    if (start === -1) {
-      return [];
+  commitNodeCreateBuffer() {
+    for (const node of this._nodeCreateBuffer.values()) {
+      this.strategy.write(node.id, node);
     }
-    const pairs = [];
-    for (let i = start; i < end; i++) {
-      const keys = node.keys[i];
-      for (const key of keys) {
-        pairs.push({ key, value });
+    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 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));
       }
     }
-    return pairs;
+    return new Set(result ?? []);
   }
-  _getPairsFromNEValue(value) {
-    const pairs = [];
-    let node = this.leftestNode();
-    let done = 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 (this.comparator.isSame(nValue, value) === false) {
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
-          }
-        }
+  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));
       }
-      if (!node.next) {
-        done = true;
-        break;
+    }
+    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(
+        [],
+        [],
+        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 = this.getNode(beforeNext);
+        node.prev = after.id;
+        this.bufferForNodeUpdate(node);
       }
-      node = this.getNode(node.next);
+      this._insertInParent(before, after.values[0], after);
+      this.bufferForNodeCreate(after);
+      this.bufferForNodeUpdate(before);
     }
-    return pairs;
+    this.commitHeadBuffer();
+    this.commitNodeCreateBuffer();
+    this.commitNodeUpdateBuffer();
   }
-  _getPairsFromRange(gt, lt) {
-    const pairs = [];
-    let node = this._insertableNode(gt);
-    let done = false;
-    let found = false;
-    while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
+  delete(key, value) {
+    const node = 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 (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
-          found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+        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);
+            this._deleteEntry(node, key, value);
+            this.bufferForNodeUpdate(node);
           }
-        } else if (found) {
-          done = true;
-          break;
         }
       }
-      if (!node.next) {
-        done = true;
-        break;
+    }
+    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);
       }
-      node = this.getNode(node.next);
     }
-    return pairs;
+    return false;
+  }
+  setHeadData(data) {
+    this.data = data;
+    this.bufferForHeadUpdate(this.headState);
+    this.commitHeadBuffer();
+  }
+  forceUpdate(nodeId = null) {
+    const ids = nodeId === null ? [...this.nodes.keys()] : [nodeId];
+    for (const id of ids) {
+      this.nodes.delete(id);
+      this.getNode(id);
+    }
+    return ids.length;
+  }
+};
+
+// src/BPTreeAsync.ts
+var BPTreeAsync = class extends BPTree {
+  constructor(strategy, comparator) {
+    super(strategy, comparator);
   }
-  _getPairsFromGt(gt) {
+  async _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
     const pairs = [];
-    let node = this._insertableNode(gt);
+    let node = startNode;
     let done = false;
     let found = false;
     while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
+      let i = node.values.length;
+      while (i--) {
         const nValue = node.values[i];
         const keys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt)) {
+        if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          let j = keys.length;
+          while (j--) {
+            pairs.push({ key: keys[j], value: nValue });
           }
-        } else if (found) {
+        } else if (found && !fullSearch) {
           done = true;
           break;
         }
       }
-      if (!node.next) {
+      if (!node.prev) {
         done = true;
         break;
       }
-      node = this.getNode(node.next);
+      node = await this.getNode(node.prev);
     }
-    return pairs;
+    return pairs.reverse();
   }
-  _getPairsFromLt(lt) {
+  async _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
     const pairs = [];
-    let node = this.leftestNode();
+    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 (this.comparator.isLower(nValue, lt)) {
+        if (comparator(nValue, value)) {
           found = true;
           for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found) {
+        } else if (found && !fullSearch) {
           done = true;
           break;
         }
@@ -527,125 +733,48 @@ var BPTree = class {
         done = true;
         break;
       }
-      node = this.getNode(node.next);
+      node = await this.getNode(node.next);
     }
     return pairs;
   }
-  /**
-   * 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`, `equal`, `notEqual` 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`, `equal`, `notEqual` condition statements.
-   */
-  keys(condition) {
-    if (this._equalCondition(condition)) {
-      return this._getKeysFromValue(condition.equal);
-    } else if (this._notEqualCondition(condition)) {
-      return this._getKeysFromNEValue(condition.notEqual);
-    } else if (this._rangeCondition(condition)) {
-      const { gt, lt } = condition;
-      return this._getKeysFromRange(gt, lt);
-    } else if (this._onlyGtCondition(condition)) {
-      return this._getKeysFromGt(condition.gt);
-    } else if (this._onlyLtCondition(condition)) {
-      return this._getKeysFromLt(condition.lt);
-    } else {
-      throw new Error(`The 'condition' parameter is invalid.`);
-    }
-  }
-  /**
-   * 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`, `equal`, `notEqual` condition statements.
-   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
-   */
-  where(condition) {
-    if (this._equalCondition(condition)) {
-      return this._getPairsFromValue(condition.equal);
-    } else if (this._notEqualCondition(condition)) {
-      return this._getPairsFromNEValue(condition.notEqual);
-    } else if (this._rangeCondition(condition)) {
-      const { gt, lt } = condition;
-      return this._getPairsFromRange(gt, lt);
-    } else if (this._onlyGtCondition(condition)) {
-      return this._getPairsFromGt(condition.gt);
-    } else if (this._onlyLtCondition(condition)) {
-      return this._getPairsFromLt(condition.lt);
-    } else {
-      throw new Error(`The 'condition' parameter is invalid.`);
+  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}`);
     }
   }
-  /**
-   * 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) {
-      const after = this._createNode(
-        [],
-        [],
-        true,
-        before.parent,
-        before.next
-      );
-      const mid = Math.ceil(this.order / 2) - 1;
-      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;
-      this._insertInParent(before, after.values[0], after);
-      this._setCreates(after);
-      this._setUpdates(before);
+  async _createNodeId() {
+    const id = await this.strategy.id();
+    if (id === 0) {
+      throw new Error(`The node's id should never be 0.`);
     }
-    this._emitHeadUpdates();
-    this._emitCreates();
-    this._emitUpdates();
+    return id;
   }
-  /**
-   * 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;
-    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._setUpdates(node);
-          } else if (node === this.root) {
-            node.values.splice(i, 1);
-            node.keys.splice(i, 1);
-            this._setUpdates(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._emitHeadUpdates();
-    this._emitCreates();
-    this._emitUpdates();
+  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;
   }
-  _deleteEntry(node, key, value) {
+  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;
         }
       }
@@ -653,37 +782,37 @@ 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 prevK = null;
-      let postK = 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]);
-            prevK = parentNode.values[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]);
-            postK = parentNode.values[i];
+            nextNode = await this.getNode(parentNode.keys[i + 1]);
+            postValue = parentNode.values[i];
           }
         }
       }
@@ -691,19 +820,19 @@ var BPTree = class {
       let guess;
       if (prevNode === null) {
         pointer = nextNode;
-        guess = postK;
+        guess = postValue;
       } else if (nextNode === null) {
         isPredecessor = true;
         pointer = prevNode;
-        guess = prevK;
+        guess = prevValue;
       } else {
         if (node.values.length + nextNode.values.length < this.order) {
           pointer = nextNode;
-          guess = postK;
+          guess = postValue;
         } else {
           isPredecessor = true;
           pointer = prevNode;
-          guess = prevK;
+          guess = prevValue;
         }
       }
       if (node.values.length + pointer.values.length < this.order) {
@@ -717,18 +846,32 @@ var BPTree = class {
           pointer.values.push(guess);
         } else {
           pointer.next = node.next;
+          pointer.prev = node.id;
+          if (pointer.next) {
+            const n = await this.getNode(node.next);
+            n.prev = pointer.id;
+            this.bufferForNodeUpdate(n);
+          }
+          if (pointer.prev) {
+            const n = await 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);
+            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;
@@ -738,12 +881,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;
               }
             }
@@ -752,18 +895,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;
@@ -772,12 +915,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;
               }
             }
@@ -786,72 +929,299 @@ 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 fullSearch = this.verifierFullSearch[key];
+      const comparator = this.verifierMap[key];
+      const pairs = await 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));
+      }
+    }
+    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 fullSearch = this.verifierFullSearch[key];
+      const comparator = this.verifierMap[key];
+      const pairs = await this.getPairs(value, startNode, fullSearch, 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(nodeId = null) {
+    const ids = nodeId === null ? [...this.nodes.keys()] : [nodeId];
+    for (const id of ids) {
+      this.nodes.delete(id);
+      await this.getNode(id);
+    }
+    return ids.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);
@@ -880,6 +1250,38 @@ var InMemoryStoreStrategy = class extends SerializeStrategy {
   }
 };
 
+// src/SerializeStrategyAsync.ts
+var SerializeStrategyAsync = class extends SerializeStrategy {
+};
+var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
+  data;
+  constructor(order) {
+    super(order);
+    this.data = {
+      head: null,
+      node: {}
+    };
+  }
+  async id() {
+    return Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER - 1);
+  }
+  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];
+  }
+  async write(id, node) {
+    this.data.node[id] = node;
+  }
+  async readHead() {
+    return this.data.head;
+  }
+  async writeHead(head) {
+    this.data.head = head;
+  }
+};
+
 // src/ValueComparator.ts
 var ValueComparator = class {
   isLower(value, than) {
@@ -903,10 +1305,13 @@ var StringComparator = class extends ValueComparator {
   }
 };
 export {
-  BPTree,
-  InMemoryStoreStrategy,
+  BPTreeAsync,
+  BPTreeSync,
+  InMemoryStoreStrategyAsync,
+  InMemoryStoreStrategySync,
   NumericComparator,
-  SerializeStrategy,
+  SerializeStrategyAsync,
+  SerializeStrategySync,
   StringComparator,
   ValueComparator
 };