serializable-bptree 4.0.5 → 5.0.0

package/README.md

@@ -59,10 +59,10 @@ tree.insert('c', 3)
 
 tree.delete('b', 2)
 
-tree.where({ equal: 1 }) // [{ key: 'a', value: 1 }]
-tree.where({ gt: 1 }) // [{ key: 'c', value: 3 }]
-tree.where({ lt: 2 }) // [{ key: 'a', value: 1 }]
-tree.where({ gt: 0, lt: 4 }) // [{ key: 'a', value: 1 }, { key: 'c', value: 3 }]
+tree.where({ equal: 1 }) // Map([{ key: 'a', value: 1 }])
+tree.where({ gt: 1 }) // Map([{ key: 'c', value: 3 }])
+tree.where({ lt: 2 }) // Map([{ key: 'a', value: 1 }])
+tree.where({ gt: 0, lt: 4 }) // Map([{ key: 'a', value: 1 }, { key: 'c', value: 3 }])
 ```
 
 ## Why use a `serializable-bptree`?
@@ -102,7 +102,7 @@ import {
     ValueComparator,
     NumericComparator,
     StringComparator
-  } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@4.x.x/dist/esm/index.min.js'
+  } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@5.x.x/dist/esm/index.min.js'
 </script>
 ```
 
@@ -417,10 +417,10 @@ await tree.insert('c', 3)
 
 await tree.delete('b', 2)
 
-await tree.where({ equal: 1 }) // [{ key: 'a', value: 1 }]
-await tree.where({ gt: 1 }) // [{ key: 'c', value: 3 }]
-await tree.where({ lt: 2 }) // [{ key: 'a', value: 1 }]
-await tree.where({ gt: 0, lt: 4 }) // [{ key: 'a', value: 1 }, { key: 'c', value: 3 }]
+await tree.where({ equal: 1 }) // Map([{ key: 'a', value: 1 }])
+await tree.where({ gt: 1 }) // Map([{ key: 'c', value: 3 }])
+await tree.where({ lt: 2 }) // Map([{ key: 'a', value: 1 }])
+await tree.where({ gt: 0, lt: 4 }) // Map([{ key: 'a', value: 1 }, { key: 'c', value: 3 }])
 ```
 
 The implementation method for asynchronous operations is not significantly different. The **-Async** suffix is used instead of the **-Sync** suffix in the **BPTree** and **SerializeStrategy** classes. The only difference is that the methods become asynchronous. The **ValueComparator** class and similar value comparators do not use asynchronous operations.

package/dist/cjs/index.cjs

@@ -211,7 +211,7 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  _getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -225,7 +225,7 @@ var BPTreeSync = class extends BPTree {
           found = true;
           let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push([keys[j], nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -238,9 +238,9 @@ var BPTreeSync = class extends BPTree {
       }
       node = this.getNode(node.prev);
     }
-    return pairs.reverse();
+    return new Map(pairs.reverse());
   }
-  _getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -251,8 +251,9 @@ var BPTreeSync = class extends BPTree {
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
+            const key = keys[j];
+            pairs.push([key, nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -265,14 +266,14 @@ var BPTreeSync = class extends BPTree {
       }
       node = this.getNode(node.next);
     }
-    return pairs;
+    return new Map(pairs);
   }
   getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return this._getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return this.getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return this._getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return this.getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -634,11 +635,11 @@ var BPTreeSync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (!filterValues) {
-        filterValues = new Set(pairs.map((pair) => pair.key));
+        filterValues = new Set(pairs.keys());
       } else {
         const intersections = /* @__PURE__ */ new Set();
         for (const key2 of filterValues) {
-          const has = pairs.some((pair) => pair.key === key2);
+          const has = pairs.has(key2);
           if (has) {
             intersections.add(key2);
           }
@@ -661,16 +662,16 @@ var BPTreeSync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        const intersection = [];
-        for (const pair of pairs) {
-          if (result.find((p) => p.key === pair.key)) {
-            intersection.push(pair);
+        const intersection = /* @__PURE__ */ new Map();
+        for (const [k2, v] of pairs) {
+          if (result.has(k2)) {
+            intersection.set(k2, v);
           }
         }
         result = intersection;
       }
     }
-    return result ?? [];
+    return result ?? /* @__PURE__ */ new Map();
   }
   insert(key, value) {
     const before = this.insertableNode(value);
@@ -766,7 +767,7 @@ var BPTreeAsync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  async _getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  async getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -780,7 +781,7 @@ var BPTreeAsync = class extends BPTree {
           found = true;
           let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push([keys[j], nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -793,9 +794,9 @@ var BPTreeAsync = class extends BPTree {
       }
       node = await this.getNode(node.prev);
     }
-    return pairs.reverse();
+    return new Map(pairs.reverse());
   }
-  async _getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  async getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -806,8 +807,9 @@ var BPTreeAsync = class extends BPTree {
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
+            const key = keys[j];
+            pairs.push([key, nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -820,14 +822,14 @@ var BPTreeAsync = class extends BPTree {
       }
       node = await this.getNode(node.next);
     }
-    return pairs;
+    return new Map(pairs);
   }
   async getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return await this._getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return await this.getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return await this._getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return await this.getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -1189,11 +1191,11 @@ var BPTreeAsync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (!filterValues) {
-        filterValues = new Set(pairs.map((pair) => pair.key));
+        filterValues = new Set(pairs.keys());
       } else {
         const intersections = /* @__PURE__ */ new Set();
         for (const key2 of filterValues) {
-          const has = pairs.some((pair) => pair.key === key2);
+          const has = pairs.has(key2);
           if (has) {
             intersections.add(key2);
           }
@@ -1216,16 +1218,16 @@ var BPTreeAsync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        const intersection = [];
-        for (const pair of pairs) {
-          if (result.find((p) => p.key === pair.key)) {
-            intersection.push(pair);
+        const intersection = /* @__PURE__ */ new Map();
+        for (const [k2, v] of pairs) {
+          if (result.has(k2)) {
+            intersection.set(k2, v);
           }
         }
         result = intersection;
       }
     }
-    return result ?? [];
+    return result ?? /* @__PURE__ */ new Map();
   }
   async insert(key, value) {
     const before = await this.insertableNode(value);

package/dist/esm/index.mjs

@@ -177,7 +177,7 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  _getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -191,7 +191,7 @@ var BPTreeSync = class extends BPTree {
           found = true;
           let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push([keys[j], nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -204,9 +204,9 @@ var BPTreeSync = class extends BPTree {
       }
       node = this.getNode(node.prev);
     }
-    return pairs.reverse();
+    return new Map(pairs.reverse());
   }
-  _getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -217,8 +217,9 @@ var BPTreeSync = class extends BPTree {
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
+            const key = keys[j];
+            pairs.push([key, nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -231,14 +232,14 @@ var BPTreeSync = class extends BPTree {
       }
       node = this.getNode(node.next);
     }
-    return pairs;
+    return new Map(pairs);
   }
   getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return this._getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return this.getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return this._getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return this.getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -600,11 +601,11 @@ var BPTreeSync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (!filterValues) {
-        filterValues = new Set(pairs.map((pair) => pair.key));
+        filterValues = new Set(pairs.keys());
       } else {
         const intersections = /* @__PURE__ */ new Set();
         for (const key2 of filterValues) {
-          const has = pairs.some((pair) => pair.key === key2);
+          const has = pairs.has(key2);
           if (has) {
             intersections.add(key2);
           }
@@ -627,16 +628,16 @@ var BPTreeSync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        const intersection = [];
-        for (const pair of pairs) {
-          if (result.find((p) => p.key === pair.key)) {
-            intersection.push(pair);
+        const intersection = /* @__PURE__ */ new Map();
+        for (const [k2, v] of pairs) {
+          if (result.has(k2)) {
+            intersection.set(k2, v);
           }
         }
         result = intersection;
       }
     }
-    return result ?? [];
+    return result ?? /* @__PURE__ */ new Map();
   }
   insert(key, value) {
     const before = this.insertableNode(value);
@@ -732,7 +733,7 @@ var BPTreeAsync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  async _getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  async getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -746,7 +747,7 @@ var BPTreeAsync = class extends BPTree {
           found = true;
           let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push([keys[j], nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -759,9 +760,9 @@ var BPTreeAsync = class extends BPTree {
       }
       node = await this.getNode(node.prev);
     }
-    return pairs.reverse();
+    return new Map(pairs.reverse());
   }
-  async _getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  async getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -772,8 +773,9 @@ var BPTreeAsync = class extends BPTree {
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
+            const key = keys[j];
+            pairs.push([key, nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -786,14 +788,14 @@ var BPTreeAsync = class extends BPTree {
       }
       node = await this.getNode(node.next);
     }
-    return pairs;
+    return new Map(pairs);
   }
   async getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return await this._getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return await this.getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return await this._getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return await this.getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -1155,11 +1157,11 @@ var BPTreeAsync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (!filterValues) {
-        filterValues = new Set(pairs.map((pair) => pair.key));
+        filterValues = new Set(pairs.keys());
       } else {
         const intersections = /* @__PURE__ */ new Set();
         for (const key2 of filterValues) {
-          const has = pairs.some((pair) => pair.key === key2);
+          const has = pairs.has(key2);
           if (has) {
             intersections.add(key2);
           }
@@ -1182,16 +1184,16 @@ var BPTreeAsync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        const intersection = [];
-        for (const pair of pairs) {
-          if (result.find((p) => p.key === pair.key)) {
-            intersection.push(pair);
+        const intersection = /* @__PURE__ */ new Map();
+        for (const [k2, v] of pairs) {
+          if (result.has(k2)) {
+            intersection.set(k2, v);
           }
         }
         result = intersection;
       }
     }
-    return result ?? [];
+    return result ?? /* @__PURE__ */ new Map();
   }
   async insert(key, value) {
     const before = await this.insertableNode(value);

package/dist/types/BPTreeAsync.d.ts

@@ -5,9 +5,9 @@ import { SerializableData } from './base/SerializeStrategy';
 export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected readonly strategy: SerializeStrategyAsync<K, V>;
     constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>);
-    protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
-    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
-    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): Promise<BPTreePair<K, V>[]>;
+    protected getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>>;
+    protected getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>>;
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): Promise<BPTreePair<K, V>>;
     protected _createNodeId(isLeaf: boolean): Promise<string>;
     protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): Promise<BPTreeUnknownNode<K, V>>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<void>;
@@ -21,7 +21,7 @@ export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected commitNodeUpdateBuffer(): Promise<void>;
     protected commitNodeDeleteBuffer(): Promise<void>;
     keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Promise<Set<K>>;
-    where(condition: BPTreeCondition<V>): Promise<BPTreePair<K, V>[]>;
+    where(condition: BPTreeCondition<V>): Promise<BPTreePair<K, V>>;
     insert(key: K, value: V): Promise<void>;
     delete(key: K, value: V): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;

package/dist/types/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>, 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 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(isLeaf: boolean): string;
     protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): BPTreeUnknownNode<K, V>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): void;
@@ -21,7 +21,7 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected commitNodeUpdateBuffer(): void;
     protected commitNodeDeleteBuffer(): void;
     keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Set<K>;
-    where(condition: BPTreeCondition<V>): BPTreePair<K, V>[];
+    where(condition: BPTreeCondition<V>): BPTreePair<K, V>;
     insert(key: K, value: V): void;
     delete(key: K, value: V): void;
     exists(key: K, value: V): boolean;

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

@@ -21,10 +21,7 @@ export type BPTreeCondition<V> = Partial<{
     /** Searches for values matching the given pattern. '%' matches zero or more characters, and '_' matches exactly one character. */
     like: Partial<V>;
 }>;
-export type BPTreePair<K, V> = {
-    key: K;
-    value: V;
-};
+export type BPTreePair<K, V> = Map<K, V>;
 export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
 export interface BPTreeNode<K, V> {
     id: string;
@@ -58,9 +55,9 @@ export declare abstract class BPTree<K, V> {
     protected readonly verifierDirection: Record<keyof BPTreeCondition<V>, -1 | 1>;
     protected readonly verifierFullScan: Record<keyof BPTreeCondition<V>, boolean>;
     protected constructor(strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>);
-    protected abstract _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
-    protected abstract _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
-    protected abstract getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): Deferred<BPTreePair<K, V>[]>;
+    protected abstract getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>>;
+    protected abstract getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>>;
+    protected abstract getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): Deferred<BPTreePair<K, V>>;
     protected abstract _createNodeId(isLeaf: boolean): Deferred<string>;
     protected abstract _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;
@@ -92,7 +89,7 @@ export declare abstract class BPTree<K, V> {
      * 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.
      */
-    abstract where(condition: BPTreeCondition<V>): Deferred<BPTreePair<K, V>[]>;
+    abstract where(condition: BPTreeCondition<V>): Deferred<BPTreePair<K, V>>;
     /**
      * 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "4.0.5",
+  "version": "5.0.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",