serializable-bptree 5.0.5 → 5.1.0

package/README.md

@@ -63,6 +63,7 @@ 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 }])
+tree.where({ or: [3, 1] }) // Map([{ key: 'a', value: 1 }, { key: 'c', value: 3 }])
 ```
 
 ## Why use a `serializable-bptree`?
@@ -320,32 +321,64 @@ import {
 
 ## Data Query Condition Clause
 
-This library supports various conditional clauses. Currently, it supports **gte**, **gt**, **lte**, **lt**, **equal**, **notEqual**, and **like** conditions. Each condition is as follows:
+This library supports various conditional clauses. Currently, it supports **gte**, **gt**, **lte**, **lt**, **equal**, **notEqual**, **or**, and **like** conditions. Each condition is as follows:
 
 ### `gte`
 
 Queries values that are greater than or equal to the given value.
 
+```typescript
+tree.where({ gte: 1 })
+```
+
 ### `gt`
 
 Queries values that are greater than the given value.
 
+```typescript
+tree.where({ gt: 1 })
+```
+
 ### `lte`
 
 Queries values that are less than or equal to the given value.
 
+```typescript
+tree.where({ lte: 5 })
+```
+
 ### `lt`
 
 Queries values that are less than the given value.
 
+```typescript
+tree.where({ lt: 5 })
+```
+
 ### `equal`
 
 Queries values that match the given value.
 
+```typescript
+tree.where({ equal: 3 })
+```
+
 ### `notEqual`
 
 Queries values that do not match the given value.
 
+```typescript
+tree.where({ notEqual: 3 })
+```
+
+### `or`
+
+Queries values that satisfy at least one of the given conditions. It accepts an array of conditions, and if any of these conditions are met, the data is included in the result.
+
+```typescript
+tree.where({ or:  [1, 2, 3] })
+```
+
 ### `like`
 
 Queries values that contain the given value in a manner similar to regular expressions. Special characters such as % and _ can be used.
@@ -357,6 +390,13 @@ Using **p_t**, it can match any string where the underscore is replaced by any c
 
 You can obtain matching data by combining these condition clauses. If there are multiple conditions, an **AND** operation is used to retrieve only the data that satisfies all conditions.
 
+```typescript
+tree.where({ like: 'hello%' })
+tree.where({ like: 'he__o%' })
+tree.where({ like: '%world!' })
+tree.where({ like: '%lo, wor%' })
+```
+
 ## Using Asynchronously
 
 Support for asynchronous trees has been available since version 3.0.0. Asynchronous is useful for operations with delays, such as file input/output and remote storage. Here is an example of how to use it:

package/dist/cjs/index.cjs

@@ -120,6 +120,7 @@ var BPTree = class {
     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,
+    or: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isSame(nv, v2)),
     like: (nv, v) => {
       const nodeValue = this.comparator.match(nv);
       const value = this.comparator.match(v);
@@ -139,8 +140,22 @@ var BPTree = class {
     lte: (v) => this.insertableNode(v),
     equal: (v) => this.insertableNode(v),
     notEqual: (v) => this.leftestNode(),
+    or: (v) => this.insertableNode(this.lowestValue(this.ensureValues(v))),
     like: (v) => this.leftestNode()
   };
+  verifierEndNode = {
+    gt: (v) => null,
+    gte: (v) => null,
+    lt: (v) => null,
+    lte: (v) => null,
+    equal: (v) => this.insertableEndNode(v, this.verifierDirection.equal),
+    notEqual: (v) => null,
+    or: (v) => this.insertableEndNode(
+      this.highestValue(this.ensureValues(v)),
+      this.verifierDirection.or
+    ),
+    like: (v) => null
+  };
   verifierDirection = {
     gt: 1,
     gte: 1,
@@ -148,17 +163,9 @@ var BPTree = class {
     lte: -1,
     equal: 1,
     notEqual: 1,
+    or: 1,
     like: 1
   };
-  verifierFullScan = {
-    gt: false,
-    gte: false,
-    lt: false,
-    lte: false,
-    equal: false,
-    notEqual: true,
-    like: true
-  };
   constructor(strategy, comparator) {
     this._strategyDirty = false;
     this._cachedRegexp = new InvertedWeakMap();
@@ -169,12 +176,31 @@ var BPTree = class {
     this.strategy = strategy;
     this.comparator = comparator;
   }
+  ensureValues(v) {
+    if (!Array.isArray(v)) {
+      v = [v];
+    }
+    return v;
+  }
+  lowestValue(v) {
+    const i = 0;
+    return [...v].sort((a, b) => this.comparator.asc(a, b))[i];
+  }
+  highestValue(v) {
+    const i = v.length - 1;
+    return [...v].sort((a, b) => this.comparator.asc(a, b))[i];
+  }
   _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];
+          if (keys.includes(key)) {
+            throw new Error("The key already exists.", {
+              cause: { key, value }
+            });
+          }
           keys.push(key);
           this.bufferForNodeUpdate(node);
           break;
@@ -229,25 +255,24 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  getPairsRightToLeft(value, startNode, endNode, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
-    let found = false;
     while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
       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([keys[j], nValue]);
           }
-        } else if (found && !fullScan) {
-          done = true;
-          break;
         }
       }
       if (!node.prev) {
@@ -258,24 +283,23 @@ var BPTreeSync = class extends BPTree {
     }
     return new Map(pairs.reverse());
   }
-  getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  getPairsLeftToRight(value, startNode, endNode, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
-    let found = false;
     while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
       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 (let j = 0, len2 = keys.length; j < len2; j++) {
             const key = keys[j];
             pairs.push([key, nValue]);
           }
-        } else if (found && !fullScan) {
-          done = true;
-          break;
         }
       }
       if (!node.next) {
@@ -286,12 +310,12 @@ var BPTreeSync = class extends BPTree {
     }
     return new Map(pairs);
   }
-  getPairs(value, startNode, fullScan, comparator, direction) {
+  getPairs(value, startNode, endNode, comparator, direction) {
     switch (direction) {
       case -1:
-        return this.getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return this.getPairsRightToLeft(value, startNode, endNode, comparator);
       case 1:
-        return this.getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return this.getPairsLeftToRight(value, startNode, endNode, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -615,6 +639,25 @@ var BPTreeSync = class extends BPTree {
     }
     return node;
   }
+  insertableEndNode(value, direction) {
+    const insertableNode = this.insertableNode(value);
+    let key;
+    switch (direction) {
+      case -1:
+        key = "prev";
+        break;
+      case 1:
+        key = "next";
+        break;
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
+    }
+    const guessNode = insertableNode[key];
+    if (!guessNode) {
+      return null;
+    }
+    return this.getNode(guessNode);
+  }
   leftestNode() {
     let node = this.root;
     while (!node.leaf) {
@@ -623,6 +666,14 @@ var BPTreeSync = class extends BPTree {
     }
     return node;
   }
+  rightestNode() {
+    let node = this.root;
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = this.getNode(keys[keys.length - 1]);
+    }
+    return node;
+  }
   commitHeadBuffer() {
     if (!this._strategyDirty) {
       return;
@@ -653,10 +704,10 @@ var BPTreeSync = class extends BPTree {
       const key = k;
       const value = condition[key];
       const startNode = this.verifierStartNode[key](value);
+      const endNode = this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
+      const pairs = this.getPairs(value, startNode, endNode, comparator, direction);
       if (!filterValues) {
         filterValues = new Set(pairs.keys());
       } else {
@@ -678,10 +729,10 @@ var BPTreeSync = class extends BPTree {
       const key = k;
       const value = condition[key];
       const startNode = this.verifierStartNode[key](value);
+      const endNode = this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
+      const pairs = this.getPairs(value, startNode, endNode, comparator, direction);
       if (result === null) {
         result = pairs;
       } else {
@@ -791,25 +842,24 @@ var BPTreeAsync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  async getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  async getPairsRightToLeft(value, startNode, endNode, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
-    let found = false;
     while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
       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([keys[j], nValue]);
           }
-        } else if (found && !fullScan) {
-          done = true;
-          break;
         }
       }
       if (!node.prev) {
@@ -820,24 +870,23 @@ var BPTreeAsync = class extends BPTree {
     }
     return new Map(pairs.reverse());
   }
-  async getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  async getPairsLeftToRight(value, startNode, endNode, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
-    let found = false;
     while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
       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 (let j = 0, len2 = keys.length; j < len2; j++) {
             const key = keys[j];
             pairs.push([key, nValue]);
           }
-        } else if (found && !fullScan) {
-          done = true;
-          break;
         }
       }
       if (!node.next) {
@@ -848,12 +897,12 @@ var BPTreeAsync = class extends BPTree {
     }
     return new Map(pairs);
   }
-  async getPairs(value, startNode, fullScan, comparator, direction) {
+  async getPairs(value, startNode, endNode, comparator, direction) {
     switch (direction) {
       case -1:
-        return await this.getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return await this.getPairsRightToLeft(value, startNode, endNode, comparator);
       case 1:
-        return await this.getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return await this.getPairsLeftToRight(value, startNode, endNode, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -1177,6 +1226,25 @@ var BPTreeAsync = class extends BPTree {
     }
     return node;
   }
+  async insertableEndNode(value, direction) {
+    const insertableNode = await this.insertableNode(value);
+    let key;
+    switch (direction) {
+      case -1:
+        key = "prev";
+        break;
+      case 1:
+        key = "next";
+        break;
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
+    }
+    const guessNode = insertableNode[key];
+    if (!guessNode) {
+      return null;
+    }
+    return await this.getNode(guessNode);
+  }
   async leftestNode() {
     let node = this.root;
     while (!node.leaf) {
@@ -1185,6 +1253,14 @@ var BPTreeAsync = class extends BPTree {
     }
     return node;
   }
+  async rightestNode() {
+    let node = this.root;
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = await this.getNode(keys[keys.length - 1]);
+    }
+    return node;
+  }
   async commitHeadBuffer() {
     if (!this._strategyDirty) {
       return;
@@ -1215,10 +1291,10 @@ var BPTreeAsync = class extends BPTree {
       const key = k;
       const value = condition[key];
       const startNode = await this.verifierStartNode[key](value);
+      const endNode = await this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
+      const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
       if (!filterValues) {
         filterValues = new Set(pairs.keys());
       } else {
@@ -1240,10 +1316,10 @@ var BPTreeAsync = class extends BPTree {
       const key = k;
       const value = condition[key];
       const startNode = await this.verifierStartNode[key](value);
+      const endNode = await this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
+      const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
       if (result === null) {
         result = pairs;
       } else {

package/dist/esm/index.mjs

@@ -86,6 +86,7 @@ var BPTree = class {
     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,
+    or: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isSame(nv, v2)),
     like: (nv, v) => {
       const nodeValue = this.comparator.match(nv);
       const value = this.comparator.match(v);
@@ -105,8 +106,22 @@ var BPTree = class {
     lte: (v) => this.insertableNode(v),
     equal: (v) => this.insertableNode(v),
     notEqual: (v) => this.leftestNode(),
+    or: (v) => this.insertableNode(this.lowestValue(this.ensureValues(v))),
     like: (v) => this.leftestNode()
   };
+  verifierEndNode = {
+    gt: (v) => null,
+    gte: (v) => null,
+    lt: (v) => null,
+    lte: (v) => null,
+    equal: (v) => this.insertableEndNode(v, this.verifierDirection.equal),
+    notEqual: (v) => null,
+    or: (v) => this.insertableEndNode(
+      this.highestValue(this.ensureValues(v)),
+      this.verifierDirection.or
+    ),
+    like: (v) => null
+  };
   verifierDirection = {
     gt: 1,
     gte: 1,
@@ -114,17 +129,9 @@ var BPTree = class {
     lte: -1,
     equal: 1,
     notEqual: 1,
+    or: 1,
     like: 1
   };
-  verifierFullScan = {
-    gt: false,
-    gte: false,
-    lt: false,
-    lte: false,
-    equal: false,
-    notEqual: true,
-    like: true
-  };
   constructor(strategy, comparator) {
     this._strategyDirty = false;
     this._cachedRegexp = new InvertedWeakMap();
@@ -135,12 +142,31 @@ var BPTree = class {
     this.strategy = strategy;
     this.comparator = comparator;
   }
+  ensureValues(v) {
+    if (!Array.isArray(v)) {
+      v = [v];
+    }
+    return v;
+  }
+  lowestValue(v) {
+    const i = 0;
+    return [...v].sort((a, b) => this.comparator.asc(a, b))[i];
+  }
+  highestValue(v) {
+    const i = v.length - 1;
+    return [...v].sort((a, b) => this.comparator.asc(a, b))[i];
+  }
   _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];
+          if (keys.includes(key)) {
+            throw new Error("The key already exists.", {
+              cause: { key, value }
+            });
+          }
           keys.push(key);
           this.bufferForNodeUpdate(node);
           break;
@@ -195,25 +221,24 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  getPairsRightToLeft(value, startNode, endNode, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
-    let found = false;
     while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
       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([keys[j], nValue]);
           }
-        } else if (found && !fullScan) {
-          done = true;
-          break;
         }
       }
       if (!node.prev) {
@@ -224,24 +249,23 @@ var BPTreeSync = class extends BPTree {
     }
     return new Map(pairs.reverse());
   }
-  getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  getPairsLeftToRight(value, startNode, endNode, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
-    let found = false;
     while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
       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 (let j = 0, len2 = keys.length; j < len2; j++) {
             const key = keys[j];
             pairs.push([key, nValue]);
           }
-        } else if (found && !fullScan) {
-          done = true;
-          break;
         }
       }
       if (!node.next) {
@@ -252,12 +276,12 @@ var BPTreeSync = class extends BPTree {
     }
     return new Map(pairs);
   }
-  getPairs(value, startNode, fullScan, comparator, direction) {
+  getPairs(value, startNode, endNode, comparator, direction) {
     switch (direction) {
       case -1:
-        return this.getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return this.getPairsRightToLeft(value, startNode, endNode, comparator);
       case 1:
-        return this.getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return this.getPairsLeftToRight(value, startNode, endNode, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -581,6 +605,25 @@ var BPTreeSync = class extends BPTree {
     }
     return node;
   }
+  insertableEndNode(value, direction) {
+    const insertableNode = this.insertableNode(value);
+    let key;
+    switch (direction) {
+      case -1:
+        key = "prev";
+        break;
+      case 1:
+        key = "next";
+        break;
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
+    }
+    const guessNode = insertableNode[key];
+    if (!guessNode) {
+      return null;
+    }
+    return this.getNode(guessNode);
+  }
   leftestNode() {
     let node = this.root;
     while (!node.leaf) {
@@ -589,6 +632,14 @@ var BPTreeSync = class extends BPTree {
     }
     return node;
   }
+  rightestNode() {
+    let node = this.root;
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = this.getNode(keys[keys.length - 1]);
+    }
+    return node;
+  }
   commitHeadBuffer() {
     if (!this._strategyDirty) {
       return;
@@ -619,10 +670,10 @@ var BPTreeSync = class extends BPTree {
       const key = k;
       const value = condition[key];
       const startNode = this.verifierStartNode[key](value);
+      const endNode = this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
+      const pairs = this.getPairs(value, startNode, endNode, comparator, direction);
       if (!filterValues) {
         filterValues = new Set(pairs.keys());
       } else {
@@ -644,10 +695,10 @@ var BPTreeSync = class extends BPTree {
       const key = k;
       const value = condition[key];
       const startNode = this.verifierStartNode[key](value);
+      const endNode = this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
+      const pairs = this.getPairs(value, startNode, endNode, comparator, direction);
       if (result === null) {
         result = pairs;
       } else {
@@ -757,25 +808,24 @@ var BPTreeAsync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  async getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  async getPairsRightToLeft(value, startNode, endNode, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
-    let found = false;
     while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
       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([keys[j], nValue]);
           }
-        } else if (found && !fullScan) {
-          done = true;
-          break;
         }
       }
       if (!node.prev) {
@@ -786,24 +836,23 @@ var BPTreeAsync = class extends BPTree {
     }
     return new Map(pairs.reverse());
   }
-  async getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  async getPairsLeftToRight(value, startNode, endNode, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
-    let found = false;
     while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
       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 (let j = 0, len2 = keys.length; j < len2; j++) {
             const key = keys[j];
             pairs.push([key, nValue]);
           }
-        } else if (found && !fullScan) {
-          done = true;
-          break;
         }
       }
       if (!node.next) {
@@ -814,12 +863,12 @@ var BPTreeAsync = class extends BPTree {
     }
     return new Map(pairs);
   }
-  async getPairs(value, startNode, fullScan, comparator, direction) {
+  async getPairs(value, startNode, endNode, comparator, direction) {
     switch (direction) {
       case -1:
-        return await this.getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return await this.getPairsRightToLeft(value, startNode, endNode, comparator);
       case 1:
-        return await this.getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return await this.getPairsLeftToRight(value, startNode, endNode, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -1143,6 +1192,25 @@ var BPTreeAsync = class extends BPTree {
     }
     return node;
   }
+  async insertableEndNode(value, direction) {
+    const insertableNode = await this.insertableNode(value);
+    let key;
+    switch (direction) {
+      case -1:
+        key = "prev";
+        break;
+      case 1:
+        key = "next";
+        break;
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
+    }
+    const guessNode = insertableNode[key];
+    if (!guessNode) {
+      return null;
+    }
+    return await this.getNode(guessNode);
+  }
   async leftestNode() {
     let node = this.root;
     while (!node.leaf) {
@@ -1151,6 +1219,14 @@ var BPTreeAsync = class extends BPTree {
     }
     return node;
   }
+  async rightestNode() {
+    let node = this.root;
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = await this.getNode(keys[keys.length - 1]);
+    }
+    return node;
+  }
   async commitHeadBuffer() {
     if (!this._strategyDirty) {
       return;
@@ -1181,10 +1257,10 @@ var BPTreeAsync = class extends BPTree {
       const key = k;
       const value = condition[key];
       const startNode = await this.verifierStartNode[key](value);
+      const endNode = await this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
+      const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
       if (!filterValues) {
         filterValues = new Set(pairs.keys());
       } else {
@@ -1206,10 +1282,10 @@ var BPTreeAsync = class extends BPTree {
       const key = k;
       const value = condition[key];
       const startNode = await this.verifierStartNode[key](value);
+      const endNode = await this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
+      const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
       if (result === null) {
         result = pairs;
       } else {

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>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>>;
+    protected getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>>;
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, 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>;
@@ -15,7 +15,9 @@ export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     init(): Promise<void>;
     protected getNode(id: string): Promise<BPTreeUnknownNode<K, V>>;
     protected insertableNode(value: V): Promise<BPTreeLeafNode<K, V>>;
+    protected insertableEndNode(value: V, direction: 1 | -1): Promise<BPTreeLeafNode<K, V> | null>;
     protected leftestNode(): Promise<BPTreeLeafNode<K, V>>;
+    protected rightestNode(): Promise<BPTreeLeafNode<K, V>>;
     protected commitHeadBuffer(): Promise<void>;
     protected commitNodeCreateBuffer(): Promise<void>;
     protected commitNodeUpdateBuffer(): Promise<void>;

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>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>;
+    protected getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>;
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, 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;
@@ -15,7 +15,9 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     init(): void;
     protected getNode(id: string): BPTreeUnknownNode<K, V>;
     protected insertableNode(value: V): BPTreeLeafNode<K, V>;
+    protected insertableEndNode(value: V, direction: 1 | -1): BPTreeLeafNode<K, V> | null;
     protected leftestNode(): BPTreeLeafNode<K, V>;
+    protected rightestNode(): BPTreeLeafNode<K, V>;
     protected commitHeadBuffer(): void;
     protected commitNodeCreateBuffer(): void;
     protected commitNodeUpdateBuffer(): void;

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

@@ -18,6 +18,8 @@ export type BPTreeCondition<V> = Partial<{
     equal: Partial<V>;
     /** Searches for pairs not equal to the given value. */
     notEqual: Partial<V>;
+    /** Searches for pairs that satisfy at least one of the conditions. */
+    or: Partial<V>[];
     /** Searches for values matching the given pattern. '%' matches zero or more characters, and '_' matches exactly one character. */
     like: Partial<V>;
 }>;
@@ -51,21 +53,23 @@ export declare abstract class BPTree<K, V> {
     protected readonly _nodeCreateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
     protected readonly _nodeUpdateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
     protected readonly _nodeDeleteBuffer: Map<string, BPTreeUnknownNode<K, V>>;
-    protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V) => boolean>;
+    protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>;
     protected readonly verifierStartNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V>>>;
+    protected readonly verifierEndNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V> | null>>;
     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>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>>;
+    protected abstract getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>>;
+    protected abstract getPairs(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, 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>;
     protected abstract _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Deferred<void>;
     protected abstract getNode(id: string): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract insertableNode(value: V): Deferred<BPTreeLeafNode<K, V>>;
+    protected abstract insertableEndNode(value: V, direction: 1 | -1): Deferred<BPTreeLeafNode<K, V> | null>;
     protected abstract leftestNode(): Deferred<BPTreeLeafNode<K, V>>;
+    protected abstract rightestNode(): Deferred<BPTreeLeafNode<K, V>>;
     protected abstract commitHeadBuffer(): Deferred<void>;
     protected abstract commitNodeCreateBuffer(): Deferred<void>;
     protected abstract commitNodeUpdateBuffer(): Deferred<void>;
@@ -123,6 +127,9 @@ export declare abstract class BPTree<K, V> {
      * @returns The return value is the total number of nodes updated.
      */
     abstract forceUpdate(): Deferred<number>;
+    protected ensureValues(v: V | V[]): V[];
+    protected lowestValue(v: V[]): V;
+    protected highestValue(v: V[]): V;
     protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
     protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): void;
     protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "5.0.5",
+  "version": "5.1.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",
@@ -37,9 +37,9 @@
   "license": "MIT",
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "esbuild": "^0.24.0",
+    "esbuild": "^0.25.4",
     "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
-    "typescript": "^5.6.3"
+    "ts-jest": "^29.3.3",
+    "typescript": "^5.8.3"
   }
 }