serializable-bptree 5.0.5 → 5.1.1

package/dist/cjs/index.cjs

@@ -61,16 +61,167 @@ var StringComparator = class extends ValueComparator {
   }
 };
 
-// src/utils/InvertedWeakMap.ts
+// node_modules/cache-entanglement/dist/esm/index.mjs
+var __create = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var require_ms = __commonJS({
+  "node_modules/ms/index.js"(exports, module2) {
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module2.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms2) {
+      var msAbs = Math.abs(ms2);
+      if (msAbs >= d) {
+        return Math.round(ms2 / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms2 / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms2 / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms2 / s) + "s";
+      }
+      return ms2 + "ms";
+    }
+    function fmtLong(ms2) {
+      var msAbs = Math.abs(ms2);
+      if (msAbs >= d) {
+        return plural(ms2, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms2, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms2, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms2, msAbs, s, "second");
+      }
+      return ms2 + " ms";
+    }
+    function plural(ms2, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+var import_ms = __toESM(require_ms());
 var InvertedWeakMap = class {
   _map;
+  _keepAlive;
+  _timeouts;
   _registry;
-  constructor() {
+  _lifespan;
+  constructor(option) {
+    const { lifespan } = option;
+    this._lifespan = lifespan;
     this._map = /* @__PURE__ */ new Map();
-    this._registry = new FinalizationRegistry((key) => this._map.delete(key));
+    this._keepAlive = /* @__PURE__ */ new Map();
+    this._timeouts = /* @__PURE__ */ new Map();
+    this._registry = new FinalizationRegistry((key) => {
+      this._stopExpire(key, true);
+      this._map.delete(key);
+    });
   }
   clear() {
-    return this._map.clear();
+    this._keepAlive.clear();
+    this._map.clear();
   }
   delete(key) {
     const ref = this._map.get(key);
@@ -80,6 +231,8 @@ var InvertedWeakMap = class {
         this._registry.unregister(raw);
       }
     }
+    this._stopExpire(key, true);
+    this._keepAlive.delete(key);
     return this._map.delete(key);
   }
   get(key) {
@@ -91,8 +244,39 @@ var InvertedWeakMap = class {
   set(key, value) {
     this._map.set(key, new WeakRef(value));
     this._registry.register(value, key);
+    if (this._lifespan > 0) {
+      this._stopExpire(key, true);
+      this._startExpire(key, value);
+    }
     return this;
   }
+  extendExpire(key) {
+    if (!(this._lifespan > 0)) {
+      return;
+    }
+    if (!this._keepAlive.has(key)) {
+      return;
+    }
+    this._stopExpire(key, false);
+    this._startExpire(key, this._keepAlive.get(key));
+  }
+  _startExpire(key, value) {
+    this._keepAlive.set(key, value);
+    this._timeouts.set(key, setTimeout(() => {
+      this._keepAlive.delete(key);
+    }, this._lifespan));
+  }
+  _stopExpire(key, removeKeepAlive) {
+    if (!this._timeouts.has(key)) {
+      return;
+    }
+    const timeout = this._timeouts.get(key);
+    this._timeouts.delete(key);
+    clearTimeout(timeout);
+    if (removeKeepAlive) {
+      this._keepAlive.delete(key);
+    }
+  }
   get size() {
     return this._map.size;
   }
@@ -100,13 +284,226 @@ var InvertedWeakMap = class {
     return this._map.keys();
   }
 };
+var CacheEntanglement = class {
+  creation;
+  beforeUpdateHook;
+  lifespan;
+  dependencies;
+  caches;
+  assignments;
+  parameters;
+  constructor(creation, option) {
+    option = option ?? {};
+    const {
+      dependencies,
+      lifespan,
+      beforeUpdateHook
+    } = option;
+    this.creation = creation;
+    this.beforeUpdateHook = beforeUpdateHook ?? (() => {
+    });
+    this.lifespan = this._normalizeMs(lifespan ?? 0);
+    this.assignments = [];
+    this.caches = new InvertedWeakMap({ lifespan: this.lifespan });
+    this.dependencies = dependencies ?? {};
+    this.parameters = {};
+    for (const name in this.dependencies) {
+      const dependency = this.dependencies[name];
+      if (!dependency.assignments.includes(this)) {
+        dependency.assignments.push(this);
+      }
+    }
+  }
+  _normalizeMs(time) {
+    if (typeof time === "string") {
+      return (0, import_ms.default)(time);
+    }
+    return time;
+  }
+  dependencyKey(key) {
+    const tokens = key.split("/");
+    tokens.pop();
+    return tokens.join("/");
+  }
+  /**
+   * Returns all keys stored in the instance.
+   */
+  keys() {
+    return this.caches.keys();
+  }
+  /**
+   * Deletes all cache values stored in the instance.
+   */
+  clear() {
+    for (const key of this.keys()) {
+      this.delete(key);
+    }
+  }
+  /**
+   * Checks if there is a cache value stored in the key within the instance.
+   * @param key The key to search.
+   */
+  exists(key) {
+    return this.caches.has(key);
+  }
+  /**
+   * Returns the cache value stored in the key within the instance. If the cached value is not present, an error is thrown.
+   * @param key The key to search.
+   */
+  get(key) {
+    if (!this.caches.has(key)) {
+      throw new Error(`Cache value not found: ${key}`);
+    }
+    return this.caches.get(key);
+  }
+  /**
+   * Deletes the cache value stored in the key within the instance.
+   * @param key The key to delete.
+   */
+  delete(key) {
+    this.caches.delete(key);
+  }
+};
+var CacheData = class _CacheData {
+  static StructuredClone = globalThis.structuredClone.bind(globalThis);
+  _value;
+  constructor(value) {
+    this._value = value;
+  }
+  /**
+   * This is cached data.
+   * It was generated at the time of caching, so there is a risk of modification if it's an object due to shallow copying.
+   * Therefore, if it's not a primitive type, please avoid using this value directly and use the `clone` method to use a copied version of the data.
+   */
+  get raw() {
+    return this._value;
+  }
+  /**
+   * The method returns a copied value of the cached data.
+   * You can pass a function as a parameter to copy the value. This parameter function should return the copied value.
+   * 
+   * If no parameter is passed, it defaults to using Javascript's or \@ungap/structured-clone's `structuredClone` function to copy the value.
+   * If you prefer shallow copying instead of deep copying,
+   * you can use the default options `array-shallow-copy`, `object-shallow-copy` and `deep-copy`,
+   * which are replaced with functions to shallow copy arrays and objects, respectively. This is a syntactic sugar.
+   * @param strategy The function that returns the copied value.
+   * If you want to perform a shallow copy, simply pass the strings `array-shallow-copy` or `object-shallow-copy` for easy use.
+   * The default is `structuredClone`.
+   */
+  clone(strategy = "deep-copy") {
+    if (strategy && typeof strategy !== "string") {
+      return strategy(this.raw);
+    }
+    switch (strategy) {
+      case "array-shallow-copy":
+        return [].concat(this.raw);
+      case "object-shallow-copy":
+        return Object.assign({}, this.raw);
+      case "deep-copy":
+      default:
+        return _CacheData.StructuredClone(this.raw);
+    }
+  }
+};
+var CacheEntanglementSync = class extends CacheEntanglement {
+  constructor(creation, option) {
+    super(creation, option);
+  }
+  resolve(key, ...parameter) {
+    const resolved = {};
+    const dependencyKey = this.dependencyKey(key);
+    this.beforeUpdateHook(key, dependencyKey, ...parameter);
+    for (const name in this.dependencies) {
+      const dependency = this.dependencies[name];
+      if (!dependency.caches.has(key) && !dependency.caches.has(dependencyKey)) {
+        throw new Error(`The key '${key}' or '${dependencyKey}' has not been assigned yet in dependency '${name}'.`, {
+          cause: {
+            from: this
+          }
+        });
+      }
+      const dependencyValue = dependency.caches.get(key) ?? dependency.caches.get(dependencyKey);
+      resolved[name] = dependencyValue;
+    }
+    this.parameters[key] = parameter;
+    const value = new CacheData(this.creation(key, resolved, ...parameter));
+    this.caches.set(key, value);
+    return value;
+  }
+  cache(key, ...parameter) {
+    if (!this.caches.has(key)) {
+      this.resolve(key, ...parameter);
+    } else {
+      this.caches.extendExpire(key);
+    }
+    return this.caches.get(key);
+  }
+  update(key, ...parameter) {
+    this.resolve(key, ...parameter);
+    for (const t of this.assignments) {
+      const instance = t;
+      for (const cacheKey of instance.caches.keys()) {
+        if (cacheKey === key || cacheKey.startsWith(`${key}/`)) {
+          instance.update(cacheKey, ...instance.parameters[cacheKey]);
+        }
+      }
+    }
+    return this.caches.get(key);
+  }
+};
+var CacheEntanglementAsync = class extends CacheEntanglement {
+  constructor(creation, option) {
+    super(creation, option);
+  }
+  async resolve(key, ...parameter) {
+    const resolved = {};
+    const dependencyKey = this.dependencyKey(key);
+    await this.beforeUpdateHook(key, dependencyKey, ...parameter);
+    for (const name in this.dependencies) {
+      const dependency = this.dependencies[name];
+      if (!dependency.caches.has(key) && !dependency.caches.has(dependencyKey)) {
+        throw new Error(`The key '${key}' or '${dependencyKey}' has not been assigned yet in dependency '${name}'.`, {
+          cause: {
+            from: this
+          }
+        });
+      }
+      const dependencyValue = dependency.caches.get(key) ?? dependency.caches.get(dependencyKey);
+      resolved[name] = dependencyValue;
+    }
+    this.parameters[key] = parameter;
+    const value = new CacheData(await this.creation(key, resolved, ...parameter));
+    this.caches.set(key, value);
+    return value;
+  }
+  async cache(key, ...parameter) {
+    if (!this.caches.has(key)) {
+      await this.resolve(key, ...parameter);
+    } else {
+      this.caches.extendExpire(key);
+    }
+    return this.caches.get(key);
+  }
+  async update(key, ...parameter) {
+    await this.resolve(key, ...parameter);
+    for (const t of this.assignments) {
+      const instance = t;
+      for (const cacheKey of instance.caches.keys()) {
+        if (cacheKey === key || cacheKey.startsWith(`${key}/`)) {
+          await instance.update(cacheKey, ...instance.parameters[cacheKey]);
+        }
+      }
+    }
+    return this.caches.get(key);
+  }
+};
 
 // src/base/BPTree.ts
 var BPTree = class {
   _cachedRegexp;
   strategy;
   comparator;
-  nodes;
+  option;
   order;
   root;
   _strategyDirty;
@@ -120,15 +517,12 @@ 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);
-      if (!this._cachedRegexp.has(value)) {
-        const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
-        const regexp2 = new RegExp(`^${pattern}$`, "i");
-        this._cachedRegexp.set(value, regexp2);
-      }
-      const regexp = this._cachedRegexp.get(value);
+      const cache = this._cachedRegexp.cache(value);
+      const regexp = cache.raw;
       return regexp.test(nodeValue);
     }
   };
@@ -139,8 +533,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,26 +556,41 @@ 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) {
+  constructor(strategy, comparator, option) {
+    this.strategy = strategy;
+    this.comparator = comparator;
+    this.option = option ?? {};
     this._strategyDirty = false;
-    this._cachedRegexp = new InvertedWeakMap();
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
     this._nodeDeleteBuffer = /* @__PURE__ */ new Map();
-    this.nodes = new InvertedWeakMap();
-    this.strategy = strategy;
-    this.comparator = comparator;
+    this._cachedRegexp = this._createCachedRegexp();
+  }
+  _createCachedRegexp() {
+    return new CacheEntanglementSync((key) => {
+      const pattern = key.replace(/%/g, ".*").replace(/_/g, ".");
+      const regexp = new RegExp(`^${pattern}$`, "i");
+      return regexp;
+    }, {
+      lifespan: this.option.lifespan ?? "3m"
+    });
+  }
+  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) {
@@ -175,6 +598,11 @@ var BPTree = class {
         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;
@@ -222,32 +650,47 @@ var BPTree = class {
   getHeadData() {
     return this.strategy.head.data;
   }
+  /**
+   * Clears all cached nodes.
+   * This method is useful for freeing up memory when the tree is no longer needed.
+   */
+  clear() {
+    this._cachedRegexp.clear();
+    this.nodes.clear();
+  }
 };
 
 // src/BPTreeSync.ts
 var BPTreeSync = class extends BPTree {
-  constructor(strategy, comparator) {
-    super(strategy, comparator);
-  }
-  getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  constructor(strategy, comparator, option) {
+    super(strategy, comparator, option);
+    this.nodes = this._createCachedNode();
+  }
+  _createCachedNode() {
+    return new CacheEntanglementSync((key) => {
+      return this.strategy.read(key);
+    }, {
+      lifespan: this.option.lifespan ?? "3m"
+    });
+  }
+  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 +701,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 +728,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}`);
     }
@@ -314,7 +756,7 @@ var BPTreeSync = class extends BPTree {
       next,
       prev
     };
-    this.nodes.set(id, node);
+    this._nodeCreateBuffer.set(id, node);
     return node;
   }
   _deleteEntry(node, key, value) {
@@ -528,7 +970,6 @@ var BPTreeSync = class extends BPTree {
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
       return;
@@ -564,7 +1005,6 @@ var BPTreeSync = class extends BPTree {
             this.bufferForNodeUpdate(node2);
           }
           this._insertInParent(parentNode, midValue, parentPointer);
-          this.bufferForNodeCreate(parentPointer);
           this.bufferForNodeUpdate(parentNode);
         }
       }
@@ -576,7 +1016,6 @@ var BPTreeSync = class extends BPTree {
       this.order = this.strategy.order;
       this.root = this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
-      this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
@@ -590,10 +1029,11 @@ var BPTreeSync = class extends BPTree {
     }
   }
   getNode(id) {
-    if (!this.nodes.has(id)) {
-      this.nodes.set(id, this.strategy.read(id));
+    if (this._nodeCreateBuffer.has(id)) {
+      return this._nodeCreateBuffer.get(id);
     }
-    return this.nodes.get(id);
+    const cache = this.nodes.cache(id);
+    return cache.raw;
   }
   insertableNode(value) {
     let node = this.root;
@@ -615,6 +1055,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 +1082,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 +1120,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 +1145,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 {
@@ -722,7 +1189,6 @@ var BPTreeSync = class extends BPTree {
         this.bufferForNodeUpdate(node);
       }
       this._insertInParent(before, after.values[0], after);
-      this.bufferForNodeCreate(after);
       this.bufferForNodeUpdate(before);
     }
     this.commitHeadBuffer();
@@ -788,28 +1254,35 @@ var BPTreeSync = class extends BPTree {
 
 // src/BPTreeAsync.ts
 var BPTreeAsync = class extends BPTree {
-  constructor(strategy, comparator) {
-    super(strategy, comparator);
-  }
-  async getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  constructor(strategy, comparator, option) {
+    super(strategy, comparator, option);
+    this.nodes = this._createCachedNode();
+  }
+  _createCachedNode() {
+    return new CacheEntanglementAsync(async (key) => {
+      return await this.strategy.read(key);
+    }, {
+      lifespan: this.option.lifespan ?? "3m"
+    });
+  }
+  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 +1293,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 +1320,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}`);
     }
@@ -876,7 +1348,7 @@ var BPTreeAsync = class extends BPTree {
       next,
       prev
     };
-    this.nodes.set(id, node);
+    this._nodeCreateBuffer.set(id, node);
     return node;
   }
   async _deleteEntry(node, key, value) {
@@ -1090,7 +1562,6 @@ var BPTreeAsync = class extends BPTree {
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
       return;
@@ -1126,7 +1597,6 @@ var BPTreeAsync = class extends BPTree {
             this.bufferForNodeUpdate(node2);
           }
           await this._insertInParent(parentNode, midValue, parentPointer);
-          this.bufferForNodeCreate(parentPointer);
           this.bufferForNodeUpdate(parentNode);
         }
       }
@@ -1138,7 +1608,6 @@ var BPTreeAsync = class extends BPTree {
       this.order = this.strategy.order;
       this.root = await this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
-      this.bufferForNodeCreate(this.root);
       await this.commitHeadBuffer();
       await this.commitNodeCreateBuffer();
     } else {
@@ -1152,10 +1621,11 @@ var BPTreeAsync = class extends BPTree {
     }
   }
   async getNode(id) {
-    if (!this.nodes.has(id)) {
-      this.nodes.set(id, await this.strategy.read(id));
+    if (this._nodeCreateBuffer.has(id)) {
+      return this._nodeCreateBuffer.get(id);
     }
-    return this.nodes.get(id);
+    const cache = await this.nodes.cache(id);
+    return cache.raw;
   }
   async insertableNode(value) {
     let node = this.root;
@@ -1177,6 +1647,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 +1674,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 +1712,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 +1737,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 {
@@ -1284,7 +1781,6 @@ var BPTreeAsync = class extends BPTree {
         this.bufferForNodeUpdate(node);
       }
       await this._insertInParent(before, after.values[0], after);
-      this.bufferForNodeCreate(after);
       this.bufferForNodeUpdate(before);
     }
     await this.commitHeadBuffer();