serializable-bptree 5.1.6 → 5.2.1

package/dist/esm/index.mjs

@@ -28,232 +28,132 @@ var StringComparator = class extends ValueComparator {
 };
 
 // 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;
-  _lifespan;
-  constructor(option) {
-    const { lifespan } = option;
-    this._lifespan = lifespan;
-    this._map = /* @__PURE__ */ new Map();
-    this._keepAlive = /* @__PURE__ */ new Map();
-    this._timeouts = /* @__PURE__ */ new Map();
-    this._registry = new FinalizationRegistry((key) => {
-      this._stopExpire(key, true);
-      this._map.delete(key);
-    });
-  }
-  clear() {
-    this._keepAlive.clear();
-    this._map.clear();
+var LRUMap = class {
+  capacity;
+  map;
+  head = null;
+  tail = null;
+  /**
+   * Creates an instance of LRUMap.
+   * @param capacity The maximum number of items the cache can hold.
+   */
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.map = /* @__PURE__ */ new Map();
   }
-  delete(key) {
-    const ref = this._map.get(key);
-    if (ref) {
-      const raw = ref.deref();
-      if (raw !== void 0) {
-        this._registry.unregister(raw);
-      }
-    }
-    this._stopExpire(key, true);
-    this._keepAlive.delete(key);
-    return this._map.delete(key);
+  /**
+   * Promotes a node to the head of the linked list (marks as most recently used).
+   * @param node The node to promote.
+   */
+  promote(node) {
+    this.extract(node);
+    this.prepend(node);
   }
-  get(key) {
-    return this._map.get(key)?.deref();
+  /**
+   * Disconnects a node from the doubly linked list.
+   * @param node The node to extract.
+   */
+  extract(node) {
+    if (node.prev) node.prev.next = node.next;
+    else this.head = node.next;
+    if (node.next) node.next.prev = node.prev;
+    else this.tail = node.prev;
+    node.prev = null;
+    node.next = null;
   }
-  has(key) {
-    return this._map.has(key) && this.get(key) !== void 0;
+  /**
+   * Inserts a node at the head of the doubly linked list.
+   * @param node The node to prepend.
+   */
+  prepend(node) {
+    node.next = this.head;
+    if (this.head) this.head.prev = node;
+    this.head = node;
+    if (!this.tail) this.tail = node;
   }
+  /**
+   * Stores or updates a value by key.
+   * If the capacity is exceeded, the least recently used item (tail) is removed.
+   * @param key The key to store.
+   * @param value The value to store.
+   */
   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)) {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      this.promote(existing);
       return;
     }
-    if (!this._keepAlive.has(key)) {
-      return;
+    const newNode = { key, value, prev: null, next: null };
+    this.map.set(key, newNode);
+    this.prepend(newNode);
+    if (this.map.size > this.capacity && this.tail) {
+      this.map.delete(this.tail.key);
+      this.extract(this.tail);
     }
-    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));
+  /**
+   * Retrieves a value by key.
+   * Accessing the item moves it to the "most recently used" position.
+   * @param key The key to look for.
+   * @returns The value associated with the key, or undefined if not found.
+   */
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    this.promote(node);
+    return node.value;
   }
-  _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);
+  /**
+   * Checks if a key exists in the cache without changing its access order.
+   * @param key The key to check.
+   * @returns True if the key exists, false otherwise.
+   */
+  has(key) {
+    return this.map.has(key);
+  }
+  /**
+   * Removes a key and its associated value from the cache.
+   * @param key The key to remove.
+   * @returns True if the key was found and removed, false otherwise.
+   */
+  delete(key) {
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.extract(node);
+    this.map.delete(key);
+    return true;
+  }
+  /**
+   * Returns an iterator of keys in the order of most recently used to least recently used.
+   * @returns An iterable iterator of keys.
+   */
+  *keys() {
+    let current = this.head;
+    while (current) {
+      yield current.key;
+      current = current.next;
     }
   }
+  /**
+   * Returns the current number of items in the cache.
+   */
   get size() {
-    return this._map.size;
+    return this.map.size;
   }
-  keys() {
-    return this._map.keys();
+  /**
+   * Clears all items from the cache.
+   */
+  clear() {
+    this.map.clear();
+    this.head = null;
+    this.tail = null;
   }
 };
 var CacheEntanglement = class {
   creation;
   beforeUpdateHook;
-  lifespan;
+  capacity;
   dependencies;
   caches;
   parameters;
@@ -264,15 +164,15 @@ var CacheEntanglement = class {
     option = option ?? {};
     const {
       dependencies,
-      lifespan,
+      capacity,
       beforeUpdateHook
     } = option;
     this.creation = creation;
     this.beforeUpdateHook = beforeUpdateHook ?? (() => {
     });
-    this.lifespan = this._normalizeMs(lifespan ?? 0);
+    this.capacity = capacity ?? 100;
     this.assignments = [];
-    this.caches = new InvertedWeakMap({ lifespan: this.lifespan });
+    this.caches = new LRUMap(this.capacity);
     this.parameters = /* @__PURE__ */ new Map();
     this.dependencies = dependencies ?? {};
     this.dependencyProperties = Object.keys(this.dependencies);
@@ -284,12 +184,6 @@ var CacheEntanglement = class {
       }
     }
   }
-  _normalizeMs(time) {
-    if (typeof time === "string") {
-      return (0, import_ms.default)(time);
-    }
-    return time;
-  }
   bubbleUpdateSignal(key) {
     this.updateRequirements.add(key);
     for (let i = 0, len = this.assignments.length; i < len; i++) {
@@ -446,8 +340,6 @@ var CacheEntanglementSync = class extends CacheEntanglement {
   cache(key, ...parameter) {
     if (!this.caches.has(key) || this.updateRequirements.has(key)) {
       this.resolve(key, ...parameter);
-    } else {
-      this.caches.extendExpire(key);
     }
     return this.caches.get(key);
   }
@@ -502,8 +394,6 @@ var CacheEntanglementAsync = class extends CacheEntanglement {
   async cache(key, ...parameter) {
     if (!this.caches.has(key) || this.updateRequirements.has(key)) {
       await this.update(key, ...parameter);
-    } else {
-      this.caches.extendExpire(key);
     }
     return this.caches.get(key);
   }
@@ -591,7 +481,7 @@ var BPTree = class {
       const regexp = new RegExp(`^${pattern}$`, "i");
       return regexp;
     }, {
-      lifespan: this.option.lifespan ?? "3m"
+      capacity: this.option.capacity ?? 1e3
     });
   }
   ensureValues(v) {
@@ -684,7 +574,7 @@ var BPTreeSync = class extends BPTree {
     return new CacheEntanglementSync((key) => {
       return this.strategy.read(key);
     }, {
-      lifespan: this.option.lifespan ?? "3m"
+      capacity: this.option.capacity ?? 1e3
     });
   }
   getPairsRightToLeft(value, startNode, endNode, comparator) {
@@ -1266,17 +1156,295 @@ var BPTreeSync = class extends BPTree {
   }
 };
 
+// node_modules/ryoiki/dist/esm/index.mjs
+var Ryoiki = class _Ryoiki {
+  readings;
+  writings;
+  readQueue;
+  writeQueue;
+  static async CatchError(promise) {
+    return await promise.then((v) => [void 0, v]).catch((err) => [err]);
+  }
+  static IsRangeOverlap(a, b) {
+    const [start1, end1] = a;
+    const [start2, end2] = b;
+    if (end1 <= start2 || end2 <= start1) {
+      return false;
+    }
+    return true;
+  }
+  static ERR_ALREADY_EXISTS(lockId) {
+    return new Error(`The '${lockId}' task already existing in queue or running.`);
+  }
+  static ERR_NOT_EXISTS(lockId) {
+    return new Error(`The '${lockId}' task not existing in task queue.`);
+  }
+  static ERR_TIMEOUT(lockId, timeout) {
+    return new Error(`The task with ID '${lockId}' failed to acquire the lock within the timeout(${timeout}ms).`);
+  }
+  /**
+   * Constructs a new instance of the Ryoiki class.
+   */
+  constructor() {
+    this.readings = /* @__PURE__ */ new Map();
+    this.writings = /* @__PURE__ */ new Map();
+    this.readQueue = /* @__PURE__ */ new Map();
+    this.writeQueue = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Creates a range based on a start value and length.
+   * @param start - The starting value of the range.
+   * @param length - The length of the range.
+   * @returns A range tuple [start, start + length].
+   */
+  range(start, length) {
+    return [start, start + length];
+  }
+  rangeOverlapping(tasks, range) {
+    return Array.from(tasks.values()).some((t) => _Ryoiki.IsRangeOverlap(t.range, range));
+  }
+  isSameRange(a, b) {
+    const [a1, a2] = a;
+    const [b1, b2] = b;
+    return a1 === b1 && a2 === b2;
+  }
+  fetchUnitAndRun(queue, workspaces) {
+    for (const [id, unit] of queue) {
+      if (!unit.condition()) {
+        continue;
+      }
+      this._alloc(queue, workspaces, id);
+    }
+  }
+  _handleOverload(args, handlers, argPatterns) {
+    for (const [key, pattern] of Object.entries(argPatterns)) {
+      if (this._matchArgs(args, pattern)) {
+        return handlers[key](...args);
+      }
+    }
+    throw new Error("Invalid arguments");
+  }
+  _matchArgs(args, pattern) {
+    return args.every((arg, index) => {
+      const expectedType = pattern[index];
+      if (expectedType === void 0) return typeof arg === "undefined";
+      if (expectedType === Function) return typeof arg === "function";
+      if (expectedType === Number) return typeof arg === "number";
+      if (expectedType === Array) return Array.isArray(arg);
+      return false;
+    });
+  }
+  _createRandomId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2);
+    return `${timestamp}${random}`;
+  }
+  _alloc(queue, workspaces, lockId) {
+    const unit = queue.get(lockId);
+    if (!unit) {
+      throw _Ryoiki.ERR_NOT_EXISTS(lockId);
+    }
+    workspaces.set(lockId, unit);
+    queue.delete(lockId);
+    unit.alloc();
+  }
+  _free(workspaces, lockId) {
+    const unit = workspaces.get(lockId);
+    if (!unit) {
+      throw _Ryoiki.ERR_NOT_EXISTS(lockId);
+    }
+    workspaces.delete(lockId);
+    unit.free();
+  }
+  _lock(queue, range, timeout, task, condition) {
+    return new Promise((resolve, reject) => {
+      let timeoutId = null;
+      if (timeout >= 0) {
+        timeoutId = setTimeout(() => {
+          reject(_Ryoiki.ERR_TIMEOUT(id, timeout));
+        }, timeout);
+      }
+      const id = this._createRandomId();
+      const alloc = async () => {
+        if (timeoutId !== null) {
+          clearTimeout(timeoutId);
+        }
+        const [err, v] = await _Ryoiki.CatchError(task(id));
+        if (err) reject(err);
+        else resolve(v);
+      };
+      const fetch = () => {
+        this.fetchUnitAndRun(this.readQueue, this.readings);
+        this.fetchUnitAndRun(this.writeQueue, this.writings);
+      };
+      queue.set(id, { id, range, condition, alloc, free: fetch });
+      fetch();
+    });
+  }
+  _checkWorking(range, workspaces) {
+    let isLocked = false;
+    for (const lock of workspaces.values()) {
+      if (_Ryoiki.IsRangeOverlap(range, lock.range)) {
+        isLocked = true;
+        break;
+      }
+    }
+    return isLocked;
+  }
+  /**
+   * Checks if there is any active read lock within the specified range.
+   * @param range The range to check for active read locks.
+   * @returns `true` if there is an active read lock within the range, `false` otherwise.
+   */
+  isReading(range) {
+    return this._checkWorking(range, this.readings);
+  }
+  /**
+   * Checks if there is any active write lock within the specified range.
+   * @param range The range to check for active write locks.
+   * @returns `true` if there is an active write lock within the range, `false` otherwise.
+   */
+  isWriting(range) {
+    return this._checkWorking(range, this.writings);
+  }
+  /**
+   * Checks if a read lock can be acquired within the specified range.
+   * @param range The range to check for read lock availability.
+   * @returns `true` if a read lock can be acquired, `false` otherwise.
+   */
+  canRead(range) {
+    const writing = this.isWriting(range);
+    return !writing;
+  }
+  /**
+   * Checks if a write lock can be acquired within the specified range.
+   * @param range The range to check for write lock availability.
+   * @returns `true` if a write lock can be acquired, `false` otherwise.
+   */
+  canWrite(range) {
+    const reading = this.isReading(range);
+    const writing = this.isWriting(range);
+    return !reading && !writing;
+  }
+  /**
+   * Internal implementation of the read lock. Handles both overloads.
+   * @template T - The return type of the task.
+   * @param arg0 - Either a range or a task callback.
+   * If a range is provided, the task is the second argument.
+   * @param arg1 - The task to execute, required if a range is provided.
+   * @param arg2 - The timeout for acquiring the lock.
+   * If the lock cannot be acquired within this period, an error will be thrown.
+   * If this value is not provided, no timeout will be set.
+   * @returns A promise resolving to the result of the task execution.
+   */
+  readLock(arg0, arg1, arg2) {
+    const [range, task, timeout] = this._handleOverload(
+      [arg0, arg1, arg2],
+      {
+        rangeTask: (range2, task2) => [range2, task2, -1],
+        rangeTaskTimeout: (range2, task2, timeout2) => [range2, task2, timeout2],
+        task: (task2) => [[-Infinity, Infinity], task2, -1],
+        taskTimeout: (task2, timeout2) => [[-Infinity, Infinity], task2, timeout2]
+      },
+      {
+        task: [Function],
+        taskTimeout: [Function, Number],
+        rangeTask: [Array, Function],
+        rangeTaskTimeout: [Array, Function, Number]
+      }
+    );
+    return this._lock(
+      this.readQueue,
+      range,
+      timeout,
+      task,
+      () => !this.rangeOverlapping(this.writings, range)
+    );
+  }
+  /**
+   * Internal implementation of the write lock. Handles both overloads.
+   * @template T - The return type of the task.
+   * @param arg0 - Either a range or a task callback.
+   * If a range is provided, the task is the second argument.
+   * @param arg1 - The task to execute, required if a range is provided.
+   * @param arg2 - The timeout for acquiring the lock.
+   * If the lock cannot be acquired within this period, an error will be thrown.
+   * If this value is not provided, no timeout will be set.
+   * @returns A promise resolving to the result of the task execution.
+   */
+  writeLock(arg0, arg1, arg2) {
+    const [range, task, timeout] = this._handleOverload(
+      [arg0, arg1, arg2],
+      {
+        rangeTask: (range2, task2) => [range2, task2, -1],
+        rangeTaskTimeout: (range2, task2, timeout2) => [range2, task2, timeout2],
+        task: (task2) => [[-Infinity, Infinity], task2, -1],
+        taskTimeout: (task2, timeout2) => [[-Infinity, Infinity], task2, timeout2]
+      },
+      {
+        task: [Function],
+        taskTimeout: [Function, Number],
+        rangeTask: [Array, Function],
+        rangeTaskTimeout: [Array, Function, Number]
+      }
+    );
+    return this._lock(
+      this.writeQueue,
+      range,
+      timeout,
+      task,
+      () => {
+        return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+      }
+    );
+  }
+  /**
+   * Releases a read lock by its lock ID.
+   * @param lockId - The unique identifier for the lock to release.
+   */
+  readUnlock(lockId) {
+    this._free(this.readings, lockId);
+  }
+  /**
+   * Releases a write lock by its lock ID.
+   * @param lockId - The unique identifier for the lock to release.
+   */
+  writeUnlock(lockId) {
+    this._free(this.writings, lockId);
+  }
+};
+
 // src/BPTreeAsync.ts
 var BPTreeAsync = class extends BPTree {
+  lock;
   constructor(strategy, comparator, option) {
     super(strategy, comparator, option);
     this.nodes = this._createCachedNode();
+    this.lock = new Ryoiki();
   }
   _createCachedNode() {
     return new CacheEntanglementAsync(async (key) => {
       return await this.strategy.read(key);
     }, {
-      lifespan: this.option.lifespan ?? "3m"
+      capacity: this.option.capacity ?? 1e3
+    });
+  }
+  async readLock(callback) {
+    let lockId;
+    return await this.lock.readLock(async (_lockId) => {
+      lockId = _lockId;
+      return await callback();
+    }).finally(() => {
+      this.lock.readUnlock(lockId);
+    });
+  }
+  async writeLock(callback) {
+    let lockId;
+    return await this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      return await callback();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
     });
   }
   async getPairsRightToLeft(value, startNode, endNode, comparator) {
@@ -1722,139 +1890,153 @@ var BPTreeAsync = class extends BPTree {
     this._nodeDeleteBuffer.clear();
   }
   async keys(condition, filterValues) {
-    for (const k in condition) {
-      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 comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
-      if (!filterValues) {
-        filterValues = new Set(pairs.keys());
-      } else {
-        const intersections = /* @__PURE__ */ new Set();
-        for (const key2 of filterValues) {
-          const has = pairs.has(key2);
-          if (has) {
-            intersections.add(key2);
+    return this.readLock(async () => {
+      for (const k in condition) {
+        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 comparator = this.verifierMap[key];
+        const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
+        if (!filterValues) {
+          filterValues = new Set(pairs.keys());
+        } else {
+          const intersections = /* @__PURE__ */ new Set();
+          for (const key2 of filterValues) {
+            const has = pairs.has(key2);
+            if (has) {
+              intersections.add(key2);
+            }
           }
+          filterValues = intersections;
         }
-        filterValues = intersections;
       }
-    }
-    return filterValues ?? /* @__PURE__ */ new Set([]);
+      return filterValues ?? /* @__PURE__ */ new Set([]);
+    });
   }
   async where(condition) {
-    let result = null;
-    for (const k in condition) {
-      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 comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
-      if (result === null) {
-        result = pairs;
-      } else {
-        const intersection = /* @__PURE__ */ new Map();
-        for (const [k2, v] of pairs) {
-          if (result.has(k2)) {
-            intersection.set(k2, v);
+    return this.readLock(async () => {
+      let result = null;
+      for (const k in condition) {
+        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 comparator = this.verifierMap[key];
+        const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
+        if (result === null) {
+          result = pairs;
+        } else {
+          const intersection = /* @__PURE__ */ new Map();
+          for (const [k2, v] of pairs) {
+            if (result.has(k2)) {
+              intersection.set(k2, v);
+            }
           }
+          result = intersection;
         }
-        result = intersection;
       }
-    }
-    return result ?? /* @__PURE__ */ new Map();
+      return result ?? /* @__PURE__ */ new Map();
+    });
   }
   async insert(key, value) {
-    const before = await this.insertableNode(value);
-    this._insertAtLeaf(before, key, value);
-    if (before.values.length === this.order) {
-      const after = await this._createNode(
-        true,
-        [],
-        [],
-        true,
-        before.parent,
-        before.next,
-        before.id
-      );
-      const mid = Math.ceil(this.order / 2) - 1;
-      const beforeNext = before.next;
-      after.values = before.values.slice(mid + 1);
-      after.keys = before.keys.slice(mid + 1);
-      before.values = before.values.slice(0, mid + 1);
-      before.keys = before.keys.slice(0, mid + 1);
-      before.next = after.id;
-      if (beforeNext) {
-        const node = await this.getNode(beforeNext);
-        node.prev = after.id;
-        this.bufferForNodeUpdate(node);
+    return this.writeLock(async () => {
+      const before = await this.insertableNode(value);
+      this._insertAtLeaf(before, key, value);
+      if (before.values.length === this.order) {
+        const after = await this._createNode(
+          true,
+          [],
+          [],
+          true,
+          before.parent,
+          before.next,
+          before.id
+        );
+        const mid = Math.ceil(this.order / 2) - 1;
+        const beforeNext = before.next;
+        after.values = before.values.slice(mid + 1);
+        after.keys = before.keys.slice(mid + 1);
+        before.values = before.values.slice(0, mid + 1);
+        before.keys = before.keys.slice(0, mid + 1);
+        before.next = after.id;
+        if (beforeNext) {
+          const node = await this.getNode(beforeNext);
+          node.prev = after.id;
+          this.bufferForNodeUpdate(node);
+        }
+        await this._insertInParent(before, after.values[0], after);
+        this.bufferForNodeUpdate(before);
       }
-      await this._insertInParent(before, after.values[0], after);
-      this.bufferForNodeUpdate(before);
-    }
-    await this.commitHeadBuffer();
-    await this.commitNodeCreateBuffer();
-    await this.commitNodeUpdateBuffer();
+      await this.commitHeadBuffer();
+      await this.commitNodeCreateBuffer();
+      await this.commitNodeUpdateBuffer();
+    });
   }
   async delete(key, value) {
-    const node = await this.insertableNode(value);
-    let i = node.values.length;
-    while (i--) {
-      const nValue = node.values[i];
-      if (this.comparator.isSame(value, nValue)) {
-        const keys = node.keys[i];
-        if (keys.includes(key)) {
-          if (keys.length > 1) {
-            keys.splice(keys.indexOf(key), 1);
-            this.bufferForNodeUpdate(node);
-          } else if (node.id === this.root.id) {
-            node.values.splice(i, 1);
-            node.keys.splice(i, 1);
-            this.bufferForNodeUpdate(node);
-          } else {
-            keys.splice(keys.indexOf(key), 1);
-            node.keys.splice(i, 1);
-            node.values.splice(node.values.indexOf(value), 1);
-            await this._deleteEntry(node, key, value);
-            this.bufferForNodeUpdate(node);
+    return this.writeLock(async () => {
+      const node = await this.insertableNode(value);
+      let i = node.values.length;
+      while (i--) {
+        const nValue = node.values[i];
+        if (this.comparator.isSame(value, nValue)) {
+          const keys = node.keys[i];
+          if (keys.includes(key)) {
+            if (keys.length > 1) {
+              keys.splice(keys.indexOf(key), 1);
+              this.bufferForNodeUpdate(node);
+            } else if (node.id === this.root.id) {
+              node.values.splice(i, 1);
+              node.keys.splice(i, 1);
+              this.bufferForNodeUpdate(node);
+            } else {
+              keys.splice(keys.indexOf(key), 1);
+              node.keys.splice(i, 1);
+              node.values.splice(node.values.indexOf(value), 1);
+              await this._deleteEntry(node, key, value);
+              this.bufferForNodeUpdate(node);
+            }
           }
         }
       }
-    }
-    await this.commitHeadBuffer();
-    await this.commitNodeCreateBuffer();
-    await this.commitNodeUpdateBuffer();
-    await this.commitNodeDeleteBuffer();
+      await this.commitHeadBuffer();
+      await this.commitNodeCreateBuffer();
+      await this.commitNodeUpdateBuffer();
+      await this.commitNodeDeleteBuffer();
+    });
   }
   async exists(key, value) {
-    const node = await this.insertableNode(value);
-    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];
-        return keys.includes(key);
+    return this.readLock(async () => {
+      const node = await this.insertableNode(value);
+      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];
+          return keys.includes(key);
+        }
       }
-    }
-    return false;
+      return false;
+    });
   }
   async setHeadData(data) {
-    this.strategy.head.data = data;
-    this._strategyDirty = true;
-    await this.commitHeadBuffer();
+    return this.writeLock(async () => {
+      this.strategy.head.data = data;
+      this._strategyDirty = true;
+      await this.commitHeadBuffer();
+    });
   }
   async forceUpdate() {
-    const keys = [...this.nodes.keys()];
-    this.nodes.clear();
-    await this.init();
-    for (const key of keys) {
-      await this.getNode(key);
-    }
-    return keys.length;
+    return this.readLock(async () => {
+      const keys = [...this.nodes.keys()];
+      this.nodes.clear();
+      await this.init();
+      for (const key of keys) {
+        await this.getNode(key);
+      }
+      return keys.length;
+    });
   }
 };