serializable-bptree 3.2.0 → 3.2.2

package/dist/cjs/index.js

@@ -81,7 +81,6 @@ var BPTree = class {
   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),
@@ -126,19 +125,8 @@ var BPTree = class {
     notEqual: true,
     like: true
   };
-  get headState() {
-    const root = this.root.id;
-    const order = this.order;
-    const data = this.strategy.head.data;
-    return {
-      root,
-      order,
-      data
-    };
-  }
   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();
@@ -172,9 +160,6 @@ var BPTree = class {
       this.bufferForNodeUpdate(node);
     }
   }
-  bufferForHeadUpdate(head) {
-    this._headBuffer = head;
-  }
   bufferForNodeCreate(node) {
     this._nodeCreateBuffer.set(node.id, node);
   }
@@ -196,7 +181,7 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
+  _getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -212,7 +197,7 @@ var BPTreeSync = class extends BPTree {
           while (j--) {
             pairs.push({ key: keys[j], value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -225,7 +210,7 @@ var BPTreeSync = class extends BPTree {
     }
     return pairs.reverse();
   }
-  _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
+  _getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -239,7 +224,7 @@ var BPTreeSync = class extends BPTree {
           for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -252,12 +237,12 @@ var BPTreeSync = class extends BPTree {
     }
     return pairs;
   }
-  getPairs(value, startNode, fullSearch, comparator, direction) {
+  getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+        return this._getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+        return this._getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -306,7 +291,7 @@ var BPTreeSync = class extends BPTree {
       const keys = node.keys;
       this.root = this.getNode(keys[0]);
       this.root.parent = 0;
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -512,9 +497,9 @@ var BPTreeSync = class extends BPTree {
     if (this.root === node) {
       const root = this._createNode([node.id, pointer.id], [value]);
       this.root = root;
+      this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForHeadUpdate(this.headState);
       this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
@@ -562,12 +547,13 @@ var BPTreeSync = class extends BPTree {
     if (head === null) {
       this.order = this.strategy.order;
       this.root = this._createNode([], [], true);
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
+      this.strategy.head = head;
       this.order = order;
       this.root = this.getNode(root);
     }
@@ -610,10 +596,7 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   commitHeadBuffer() {
-    if (this._headBuffer !== null) {
-      this.strategy.writeHead(this._headBuffer);
-    }
-    this.bufferForHeadUpdate(null);
+    this.strategy.writeHead(this.strategy.head);
   }
   commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -638,12 +621,18 @@ var BPTreeSync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
-        result = pairs.map((pair) => pair.key);
+        result = new Set(pairs.map((pair) => pair.key));
       } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+        const intersections = /* @__PURE__ */ new Set();
+        for (const pair of pairs) {
+          if (result.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        result = intersections;
       }
     }
-    return new Set(result ?? []);
+    return result ?? /* @__PURE__ */ new Set([]);
   }
   where(condition) {
     let result = null;
@@ -658,7 +647,13 @@ var BPTreeSync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+        const intersection = [];
+        for (const pair of pairs) {
+          if (result.find((p) => p.key === pair.key)) {
+            intersection.push(pair);
+          }
+        }
+        result = intersection;
       }
     }
     return result ?? [];
@@ -737,7 +732,6 @@ var BPTreeSync = class extends BPTree {
   }
   setHeadData(data) {
     this.strategy.head.data = data;
-    this.bufferForHeadUpdate(this.headState);
     this.commitHeadBuffer();
   }
   forceUpdate() {
@@ -866,7 +860,7 @@ var BPTreeAsync = class extends BPTree {
       const keys = node.keys;
       this.root = await this.getNode(keys[0]);
       this.root.parent = 0;
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -1045,9 +1039,9 @@ var BPTreeAsync = class extends BPTree {
     if (this.root === node) {
       const root = await this._createNode([node.id, pointer.id], [value]);
       this.root = root;
+      this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForHeadUpdate(this.headState);
       this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
@@ -1095,12 +1089,13 @@ var BPTreeAsync = class extends BPTree {
     if (head === null) {
       this.order = this.strategy.order;
       this.root = await this._createNode([], [], true);
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
+      this.strategy.head = head;
       this.order = order;
       this.root = await this.getNode(root);
     }
@@ -1143,10 +1138,7 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async commitHeadBuffer() {
-    if (this._headBuffer !== null) {
-      await this.strategy.writeHead(this._headBuffer);
-    }
-    this.bufferForHeadUpdate(null);
+    await this.strategy.writeHead(this.strategy.head);
   }
   async commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -1171,12 +1163,18 @@ var BPTreeAsync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
-        result = pairs.map((pair) => pair.key);
+        result = new Set(pairs.map((pair) => pair.key));
       } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+        const intersections = /* @__PURE__ */ new Set();
+        for (const pair of pairs) {
+          if (result.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        result = intersections;
       }
     }
-    return new Set(result ?? []);
+    return result ?? /* @__PURE__ */ new Set([]);
   }
   async where(condition) {
     let result = null;
@@ -1191,7 +1189,13 @@ var BPTreeAsync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+        const intersection = [];
+        for (const pair of pairs) {
+          if (result.find((p) => p.key === pair.key)) {
+            intersection.push(pair);
+          }
+        }
+        result = intersection;
       }
     }
     return result ?? [];
@@ -1270,7 +1274,6 @@ var BPTreeAsync = class extends BPTree {
   }
   async setHeadData(data) {
     this.strategy.head.data = data;
-    this.bufferForHeadUpdate(this.headState);
     await this.commitHeadBuffer();
   }
   async forceUpdate() {

package/dist/esm/index.js

@@ -47,7 +47,6 @@ var BPTree = class {
   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),
@@ -92,19 +91,8 @@ var BPTree = class {
     notEqual: true,
     like: true
   };
-  get headState() {
-    const root = this.root.id;
-    const order = this.order;
-    const data = this.strategy.head.data;
-    return {
-      root,
-      order,
-      data
-    };
-  }
   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();
@@ -138,9 +126,6 @@ var BPTree = class {
       this.bufferForNodeUpdate(node);
     }
   }
-  bufferForHeadUpdate(head) {
-    this._headBuffer = head;
-  }
   bufferForNodeCreate(node) {
     this._nodeCreateBuffer.set(node.id, node);
   }
@@ -162,7 +147,7 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
+  _getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -178,7 +163,7 @@ var BPTreeSync = class extends BPTree {
           while (j--) {
             pairs.push({ key: keys[j], value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -191,7 +176,7 @@ var BPTreeSync = class extends BPTree {
     }
     return pairs.reverse();
   }
-  _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
+  _getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -205,7 +190,7 @@ var BPTreeSync = class extends BPTree {
           for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -218,12 +203,12 @@ var BPTreeSync = class extends BPTree {
     }
     return pairs;
   }
-  getPairs(value, startNode, fullSearch, comparator, direction) {
+  getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+        return this._getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+        return this._getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -272,7 +257,7 @@ var BPTreeSync = class extends BPTree {
       const keys = node.keys;
       this.root = this.getNode(keys[0]);
       this.root.parent = 0;
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -478,9 +463,9 @@ var BPTreeSync = class extends BPTree {
     if (this.root === node) {
       const root = this._createNode([node.id, pointer.id], [value]);
       this.root = root;
+      this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForHeadUpdate(this.headState);
       this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
@@ -528,12 +513,13 @@ var BPTreeSync = class extends BPTree {
     if (head === null) {
       this.order = this.strategy.order;
       this.root = this._createNode([], [], true);
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
+      this.strategy.head = head;
       this.order = order;
       this.root = this.getNode(root);
     }
@@ -576,10 +562,7 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   commitHeadBuffer() {
-    if (this._headBuffer !== null) {
-      this.strategy.writeHead(this._headBuffer);
-    }
-    this.bufferForHeadUpdate(null);
+    this.strategy.writeHead(this.strategy.head);
   }
   commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -604,12 +587,18 @@ var BPTreeSync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
-        result = pairs.map((pair) => pair.key);
+        result = new Set(pairs.map((pair) => pair.key));
       } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+        const intersections = /* @__PURE__ */ new Set();
+        for (const pair of pairs) {
+          if (result.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        result = intersections;
       }
     }
-    return new Set(result ?? []);
+    return result ?? /* @__PURE__ */ new Set([]);
   }
   where(condition) {
     let result = null;
@@ -624,7 +613,13 @@ var BPTreeSync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+        const intersection = [];
+        for (const pair of pairs) {
+          if (result.find((p) => p.key === pair.key)) {
+            intersection.push(pair);
+          }
+        }
+        result = intersection;
       }
     }
     return result ?? [];
@@ -703,7 +698,6 @@ var BPTreeSync = class extends BPTree {
   }
   setHeadData(data) {
     this.strategy.head.data = data;
-    this.bufferForHeadUpdate(this.headState);
     this.commitHeadBuffer();
   }
   forceUpdate() {
@@ -832,7 +826,7 @@ var BPTreeAsync = class extends BPTree {
       const keys = node.keys;
       this.root = await this.getNode(keys[0]);
       this.root.parent = 0;
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -1011,9 +1005,9 @@ var BPTreeAsync = class extends BPTree {
     if (this.root === node) {
       const root = await this._createNode([node.id, pointer.id], [value]);
       this.root = root;
+      this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForHeadUpdate(this.headState);
       this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
@@ -1061,12 +1055,13 @@ var BPTreeAsync = class extends BPTree {
     if (head === null) {
       this.order = this.strategy.order;
       this.root = await this._createNode([], [], true);
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
+      this.strategy.head = head;
       this.order = order;
       this.root = await this.getNode(root);
     }
@@ -1109,10 +1104,7 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async commitHeadBuffer() {
-    if (this._headBuffer !== null) {
-      await this.strategy.writeHead(this._headBuffer);
-    }
-    this.bufferForHeadUpdate(null);
+    await this.strategy.writeHead(this.strategy.head);
   }
   async commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -1137,12 +1129,18 @@ var BPTreeAsync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
-        result = pairs.map((pair) => pair.key);
+        result = new Set(pairs.map((pair) => pair.key));
       } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+        const intersections = /* @__PURE__ */ new Set();
+        for (const pair of pairs) {
+          if (result.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        result = intersections;
       }
     }
-    return new Set(result ?? []);
+    return result ?? /* @__PURE__ */ new Set([]);
   }
   async where(condition) {
     let result = null;
@@ -1157,7 +1155,13 @@ var BPTreeAsync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+        const intersection = [];
+        for (const pair of pairs) {
+          if (result.find((p) => p.key === pair.key)) {
+            intersection.push(pair);
+          }
+        }
+        result = intersection;
       }
     }
     return result ?? [];
@@ -1236,7 +1240,6 @@ var BPTreeAsync = class extends BPTree {
   }
   async setHeadData(data) {
     this.strategy.head.data = data;
-    this.bufferForHeadUpdate(this.headState);
     await this.commitHeadBuffer();
   }
   async forceUpdate() {

package/dist/typings/BPTreeSync.d.ts

@@ -5,9 +5,9 @@ import { SerializableData } from './base/SerializeStrategy';
 export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected readonly strategy: SerializeStrategySync<K, V>;
     constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>);
-    protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
-    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
-    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): BPTreePair<K, V>[];
+    protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
+    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): BPTreePair<K, V>[];
     protected _createNodeId(): number;
     protected _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): BPTreeUnknownNode<K, V>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): void;

package/dist/typings/base/BPTree.d.ts

@@ -1,5 +1,5 @@
 import { ValueComparator } from './ValueComparator';
-import { SerializableData, SerializeStrategy, SerializeStrategyHead } from './SerializeStrategy';
+import { SerializableData, SerializeStrategy } from './SerializeStrategy';
 type Sync<T> = T;
 type Async<T> = Promise<T>;
 type Deferred<T> = Sync<T> | Async<T>;
@@ -51,12 +51,10 @@ export declare abstract class BPTree<K, V> {
     protected root: BPTreeUnknownNode<K, V>;
     protected readonly _nodeCreateBuffer: Map<number, BPTreeUnknownNode<K, V>>;
     protected readonly _nodeUpdateBuffer: Map<number, BPTreeUnknownNode<K, V>>;
-    protected _headBuffer: SerializeStrategyHead | null;
     protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V) => boolean>;
     protected readonly verifierStartNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V>>>;
     protected readonly verifierDirection: Record<keyof BPTreeCondition<V>, -1 | 1>;
     protected readonly verifierFullScan: Record<keyof BPTreeCondition<V>, boolean>;
-    protected get headState(): SerializeStrategyHead;
     protected constructor(strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>);
     protected abstract _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
     protected abstract _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
@@ -123,7 +121,6 @@ export declare abstract class BPTree<K, V> {
      */
     abstract forceUpdate(nodeId: number): Deferred<number>;
     protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
-    protected bufferForHeadUpdate(head: SerializeStrategyHead | null): Deferred<void>;
     protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
     protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
     /**

package/dist/typings/index.d.ts

@@ -1,5 +1,5 @@
-export type { BPTreeNode } from './base/BPTree';
-export type { SerializeStrategyHead } from './base/SerializeStrategy';
+export type { BPTreeNode, BPTreeCondition } from './base/BPTree';
+export type { SerializeStrategyHead, SerializableData } from './base/SerializeStrategy';
 export { ValueComparator, NumericComparator, StringComparator } from './base/ValueComparator';
 export { BPTreeSync } from './BPTreeSync';
 export { BPTreeAsync } from './BPTreeAsync';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",