serializable-bptree 5.1.0 → 5.1.1

package/dist/esm/index.mjs

@@ -27,16 +27,167 @@ var StringComparator = class extends ValueComparator {
   }
 };
 
-// src/utils/InvertedWeakMap.ts
+// node_modules/cache-entanglement/dist/esm/index.mjs
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // 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 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var require_ms = __commonJS({
+  "node_modules/ms/index.js"(exports, module) {
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.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);
@@ -46,6 +197,8 @@ var InvertedWeakMap = class {
         this._registry.unregister(raw);
       }
     }
+    this._stopExpire(key, true);
+    this._keepAlive.delete(key);
     return this._map.delete(key);
   }
   get(key) {
@@ -57,8 +210,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;
   }
@@ -66,13 +250,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;
@@ -90,12 +487,8 @@ var BPTree = class {
     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);
     }
   };
@@ -132,15 +525,24 @@ var BPTree = class {
     or: 1,
     like: 1
   };
-  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)) {
@@ -214,12 +616,28 @@ 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);
+  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 = [];
@@ -304,7 +722,7 @@ var BPTreeSync = class extends BPTree {
       next,
       prev
     };
-    this.nodes.set(id, node);
+    this._nodeCreateBuffer.set(id, node);
     return node;
   }
   _deleteEntry(node, key, value) {
@@ -518,7 +936,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;
@@ -554,7 +971,6 @@ var BPTreeSync = class extends BPTree {
             this.bufferForNodeUpdate(node2);
           }
           this._insertInParent(parentNode, midValue, parentPointer);
-          this.bufferForNodeCreate(parentPointer);
           this.bufferForNodeUpdate(parentNode);
         }
       }
@@ -566,7 +982,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 {
@@ -580,10 +995,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;
@@ -739,7 +1155,6 @@ var BPTreeSync = class extends BPTree {
         this.bufferForNodeUpdate(node);
       }
       this._insertInParent(before, after.values[0], after);
-      this.bufferForNodeCreate(after);
       this.bufferForNodeUpdate(before);
     }
     this.commitHeadBuffer();
@@ -805,8 +1220,16 @@ var BPTreeSync = class extends BPTree {
 
 // src/BPTreeAsync.ts
 var BPTreeAsync = class extends BPTree {
-  constructor(strategy, comparator) {
-    super(strategy, 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 = [];
@@ -891,7 +1314,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) {
@@ -1105,7 +1528,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;
@@ -1141,7 +1563,6 @@ var BPTreeAsync = class extends BPTree {
             this.bufferForNodeUpdate(node2);
           }
           await this._insertInParent(parentNode, midValue, parentPointer);
-          this.bufferForNodeCreate(parentPointer);
           this.bufferForNodeUpdate(parentNode);
         }
       }
@@ -1153,7 +1574,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 {
@@ -1167,10 +1587,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;
@@ -1326,7 +1747,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();

package/dist/types/BPTreeAsync.d.ts

@@ -1,10 +1,12 @@
-import { BPTree, BPTreeCondition, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
+import { BPTree, BPTreeCondition, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode, BPTreeConstructorOption } from './base/BPTree';
 import { SerializeStrategyAsync } from './SerializeStrategyAsync';
 import { ValueComparator } from './base/ValueComparator';
 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 readonly nodes: ReturnType<BPTreeAsync<K, V>['_createCachedNode']>;
+    constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
+    private _createCachedNode;
     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>>;

package/dist/types/BPTreeSync.d.ts

@@ -1,10 +1,12 @@
-import { BPTree, BPTreeCondition, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
+import { BPTree, BPTreeCondition, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode, BPTreeConstructorOption } from './base/BPTree';
 import { SerializeStrategySync } from './SerializeStrategySync';
 import { ValueComparator } from './base/ValueComparator';
 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 readonly nodes: ReturnType<BPTreeSync<K, V>['_createCachedNode']>;
+    constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
+    private _createCachedNode;
     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>;