@certik/skynet 0.22.0 → 0.22.1

package/dist/availability.js

@@ -1,926 +1,63 @@
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
+import pThrottle from "p-throttle";
+import pMemoize from "p-memoize";
+import QuickLRU from "quick-lru";
+import { getHash } from "./object-hash";
+export async function wait(time) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, time);
     });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// node_modules/@node-rs/xxhash-win32-x64-msvc/xxhash.win32-x64-msvc.node
-var require_xxhash_win32_x64_msvc = __commonJS((exports, module) => {
-  module.exports = __require("./xxhash.win32-x64-msvc-hrdz34v7.node");
-});
-
-// node_modules/@node-rs/xxhash/index.js
-var require_xxhash = __commonJS((exports, module) => {
-  var __filename = "G:\\certik\\certik-skynet\\lib-skynet\\node_modules\\@node-rs\\xxhash\\index.js";
-  var { createRequire } = __require("module");
-  __require = createRequire(__filename);
-  var { readFileSync } = __require("fs");
-  var nativeBinding = null;
-  var loadErrors = [];
-  var isMusl = () => {
-    let musl = false;
-    if (process.platform === "linux") {
-      musl = isMuslFromFilesystem();
-      if (musl === null) {
-        musl = isMuslFromReport();
-      }
-      if (musl === null) {
-        musl = isMuslFromChildProcess();
-      }
-    }
-    return musl;
-  };
-  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
-  var isMuslFromFilesystem = () => {
-    try {
-      return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
-    } catch {
-      return null;
-    }
-  };
-  var isMuslFromReport = () => {
-    const report = typeof process.report.getReport === "function" ? process.report.getReport() : null;
-    if (!report) {
-      return null;
-    }
-    if (report.header && report.header.glibcVersionRuntime) {
-      return false;
-    }
-    if (Array.isArray(report.sharedObjects)) {
-      if (report.sharedObjects.some(isFileMusl)) {
-        return true;
-      }
-    }
-    return false;
-  };
-  var isMuslFromChildProcess = () => {
-    try {
-      return __require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
-    } catch (e) {
-      return false;
-    }
-  };
-  function requireNative() {
-    if (process.platform === "android") {
-      if (process.arch === "arm64") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.android-arm64.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-android-arm64");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else if (process.arch === "arm") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.android-arm-eabi.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-android-arm-eabi");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
-      }
-    } else if (process.platform === "win32") {
-      if (process.arch === "x64") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.win32-x64-msvc.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return require_xxhash_win32_x64_msvc();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else if (process.arch === "ia32") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.win32-ia32-msvc.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-win32-ia32-msvc");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else if (process.arch === "arm64") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.win32-arm64-msvc.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-win32-arm64-msvc");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
-      }
-    } else if (process.platform === "darwin") {
-      try {
-        return (()=>{throw new Error("Cannot require module "+"./xxhash.darwin-universal.node");})();
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-darwin-universal");})();
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      if (process.arch === "x64") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.darwin-x64.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-darwin-x64");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else if (process.arch === "arm64") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.darwin-arm64.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-darwin-arm64");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
-      }
-    } else if (process.platform === "freebsd") {
-      if (process.arch === "x64") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.freebsd-x64.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-freebsd-x64");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else if (process.arch === "arm64") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.freebsd-arm64.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-freebsd-arm64");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
-      }
-    } else if (process.platform === "linux") {
-      if (process.arch === "x64") {
-        if (isMusl()) {
-          try {
-            return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-x64-musl.node");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-          try {
-            return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-x64-musl");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-        } else {
-          try {
-            return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-x64-gnu.node");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-          try {
-            return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-x64-gnu");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-        }
-      } else if (process.arch === "arm64") {
-        if (isMusl()) {
-          try {
-            return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-arm64-musl.node");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-          try {
-            return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-arm64-musl");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-        } else {
-          try {
-            return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-arm64-gnu.node");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-          try {
-            return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-arm64-gnu");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-        }
-      } else if (process.arch === "arm") {
-        if (isMusl()) {
-          try {
-            return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-arm-musleabihf.node");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-          try {
-            return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-arm-musleabihf");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-        } else {
-          try {
-            return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-arm-gnueabihf.node");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-          try {
-            return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-arm-gnueabihf");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-        }
-      } else if (process.arch === "riscv64") {
-        if (isMusl()) {
-          try {
-            return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-riscv64-musl.node");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-          try {
-            return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-riscv64-musl");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-        } else {
-          try {
-            return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-riscv64-gnu.node");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-          try {
-            return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-riscv64-gnu");})();
-          } catch (e) {
-            loadErrors.push(e);
-          }
-        }
-      } else if (process.arch === "ppc64") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-ppc64-gnu.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-ppc64-gnu");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else if (process.arch === "s390x") {
-        try {
-          return (()=>{throw new Error("Cannot require module "+"./xxhash.linux-s390x-gnu.node");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          return (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-linux-s390x-gnu");})();
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
-    }
-  }
-  nativeBinding = requireNative();
-  if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
-    try {
-      nativeBinding = (()=>{throw new Error("Cannot require module "+"./xxhash.wasi.cjs");})();
-    } catch (err) {
-      if (process.env.NAPI_RS_FORCE_WASI) {
-        loadErrors.push(err);
-      }
-    }
-    if (!nativeBinding) {
-      try {
-        nativeBinding = (()=>{throw new Error("Cannot require module "+"@node-rs/xxhash-wasm32-wasi");})();
-      } catch (err) {
-        if (process.env.NAPI_RS_FORCE_WASI) {
-          loadErrors.push(err);
-        }
-      }
-    }
-  }
-  if (!nativeBinding) {
-    if (loadErrors.length > 0) {
-      throw new Error("Failed to load native binding", { cause: loadErrors });
-    }
-    throw new Error(`Failed to load native binding`);
-  }
-  exports.Xxh32 = nativeBinding.Xxh32;
-  exports.Xxh64 = nativeBinding.Xxh64;
-  exports.xxh32 = nativeBinding.xxh32;
-  exports.xxh64 = nativeBinding.xxh64;
-  exports.xxh3 = nativeBinding.xxh3;
-});
-
-// object-hash.ts
-var import_xxhash = __toESM(require_xxhash(), 1);
-function getHash(obj) {
-  const xxh3 = import_xxhash.default.xxh3.Xxh3.withSeed();
-  hash(obj, xxh3);
-  return xxh3.digest().toString(16);
-}
-function hash(obj, xxh3) {
-  if (obj === null) {
-    xxh3.update("null");
-  } else if (obj === undefined) {
-    xxh3.update("undefined");
-  } else if (typeof obj === "string") {
-    xxh3.update(obj);
-  } else if (typeof obj === "number") {
-    xxh3.update(obj.toString());
-  } else if (typeof obj === "boolean") {
-    xxh3.update(obj.toString());
-  } else if (typeof obj === "bigint") {
-    xxh3.update(obj.toString());
-  } else if (obj instanceof Date) {
-    xxh3.update(obj.toISOString());
-  } else if (Array.isArray(obj)) {
-    arrayHash(obj, xxh3);
-  } else if (obj instanceof Set) {
-    setHash(obj, xxh3);
-  } else if (obj instanceof Map) {
-    mapHash(obj, xxh3);
-  } else if (typeof obj === "object") {
-    objectHash(obj, xxh3);
-  } else {
-    throw new Error(`Unsupported type: ${obj}`);
-  }
-}
-function arrayHash(array, xxh3) {
-  xxh3.update("[");
-  for (const obj of array) {
-    hash(obj, xxh3);
-  }
-  xxh3.update("]");
-}
-function setHash(_set, _xxh3) {
-  throw new Error("Set hashing not implemented");
-}
-function mapHash(map, xxh3) {
-  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-  for (const [key, value] of array) {
-    hash(key, xxh3);
-    hash(value, xxh3);
-  }
-}
-function objectHash(obj, xxh3) {
-  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-  for (const [key, value] of array) {
-    hash(key, xxh3);
-    hash(value, xxh3);
-  }
 }
-
-// node_modules/p-throttle/index.js
-var registry = new FinalizationRegistry(({ signal, aborted }) => {
-  signal?.removeEventListener("abort", aborted);
-});
-function pThrottle({ limit, interval, strict, signal, onDelay }) {
-  if (!Number.isFinite(limit)) {
-    throw new TypeError("Expected `limit` to be a finite number");
-  }
-  if (!Number.isFinite(interval)) {
-    throw new TypeError("Expected `interval` to be a finite number");
-  }
-  const queue = new Map;
-  let currentTick = 0;
-  let activeCount = 0;
-  function windowedDelay() {
-    const now = Date.now();
-    if (now - currentTick > interval) {
-      activeCount = 1;
-      currentTick = now;
-      return 0;
-    }
-    if (activeCount < limit) {
-      activeCount++;
-    } else {
-      currentTick += interval;
-      activeCount = 1;
-    }
-    return currentTick - now;
-  }
-  const strictTicks = [];
-  function strictDelay() {
-    const now = Date.now();
-    if (strictTicks.length > 0 && now - strictTicks.at(-1) > interval) {
-      strictTicks.length = 0;
-    }
-    if (strictTicks.length < limit) {
-      strictTicks.push(now);
-      return 0;
-    }
-    const nextExecutionTime = strictTicks[0] + interval;
-    strictTicks.shift();
-    strictTicks.push(nextExecutionTime);
-    return Math.max(0, nextExecutionTime - now);
-  }
-  const getDelay = strict ? strictDelay : windowedDelay;
-  return (function_) => {
-    const throttled = function(...arguments_) {
-      if (!throttled.isEnabled) {
-        return (async () => function_.apply(this, arguments_))();
-      }
-      let timeoutId;
-      return new Promise((resolve, reject) => {
-        const execute = () => {
-          resolve(function_.apply(this, arguments_));
-          queue.delete(timeoutId);
-        };
-        const delay = getDelay();
-        if (delay > 0) {
-          timeoutId = setTimeout(execute, delay);
-          queue.set(timeoutId, reject);
-          onDelay?.(...arguments_);
-        } else {
-          execute();
+export async function exponentialRetry(func, { maxRetry, initialDuration, growFactor, test, verbose, }) {
+    let retries = maxRetry;
+    let duration = initialDuration || 5000;
+    const growFactorFinal = growFactor || 2;
+    let result = await func();
+    while (!test(result) && retries > 0) {
+        if (verbose) {
+            console.log("failed attempt result", result);
+            console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
         }
-      });
-    };
-    const aborted = () => {
-      for (const timeout of queue.keys()) {
-        clearTimeout(timeout);
-        queue.get(timeout)(signal.reason);
-      }
-      queue.clear();
-      strictTicks.splice(0, strictTicks.length);
-    };
-    registry.register(throttled, { signal, aborted });
-    signal?.throwIfAborted();
-    signal?.addEventListener("abort", aborted, { once: true });
-    throttled.isEnabled = true;
-    Object.defineProperty(throttled, "queueSize", {
-      get() {
-        return queue.size;
-      }
-    });
-    return throttled;
-  };
-}
-
-// node_modules/mimic-fn/index.js
-var copyProperty = (to, from, property, ignoreNonConfigurable) => {
-  if (property === "length" || property === "prototype") {
-    return;
-  }
-  if (property === "arguments" || property === "caller") {
-    return;
-  }
-  const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
-  const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
-  if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
-    return;
-  }
-  Object.defineProperty(to, property, fromDescriptor);
-};
-var canCopyProperty = function(toDescriptor, fromDescriptor) {
-  return toDescriptor === undefined || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
-};
-var changePrototype = (to, from) => {
-  const fromPrototype = Object.getPrototypeOf(from);
-  if (fromPrototype === Object.getPrototypeOf(to)) {
-    return;
-  }
-  Object.setPrototypeOf(to, fromPrototype);
-};
-var wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
-${fromBody}`;
-var toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
-var toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
-var changeToString = (to, from, name) => {
-  const withName = name === "" ? "" : `with ${name.trim()}() `;
-  const newToString = wrappedToString.bind(null, withName, from.toString());
-  Object.defineProperty(newToString, "name", toStringName);
-  Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
-};
-function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
-  const { name } = to;
-  for (const property of Reflect.ownKeys(from)) {
-    copyProperty(to, from, property, ignoreNonConfigurable);
-  }
-  changePrototype(to, from);
-  changeToString(to, from, name);
-  return to;
-}
-
-// node_modules/p-memoize/dist/index.js
-var cacheStore = new WeakMap;
-function pMemoize(fn, { cacheKey = ([firstArgument]) => firstArgument, cache = new Map } = {}) {
-  const promiseCache = new Map;
-  const memoized = function(...arguments_) {
-    const key = cacheKey(arguments_);
-    if (promiseCache.has(key)) {
-      return promiseCache.get(key);
+        retries = retries - 1;
+        await wait(duration);
+        result = await func();
+        duration = duration * growFactorFinal;
     }
-    const promise = (async () => {
-      try {
-        if (cache && await cache.has(key)) {
-          return await cache.get(key);
-        }
-        const promise2 = fn.apply(this, arguments_);
-        const result = await promise2;
-        try {
-          return result;
-        } finally {
-          if (cache) {
-            await cache.set(key, result);
-          }
-        }
-      } finally {
-        promiseCache.delete(key);
-      }
-    })();
-    promiseCache.set(key, promise);
-    return promise;
-  };
-  mimicFunction(memoized, fn, {
-    ignoreNonConfigurable: true
-  });
-  cacheStore.set(memoized, cache);
-  return memoized;
+    if (verbose) {
+        console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
+    }
+    return result;
+}
+export function withRetry(func, options) {
+    let retries = options?.maxRetry || 3;
+    let duration = options?.initialDuration || 500;
+    const growFactorFinal = options?.growFactor || 2;
+    return (async (...args) => {
+        do {
+            try {
+                return await func(...args);
+            }
+            catch (error) {
+                retries = retries - 1;
+                if (retries <= 0) {
+                    throw error;
+                }
+                await wait(duration);
+                duration = duration * growFactorFinal;
+            }
+        } while (retries > 0);
+        throw new Error("unreachable");
+    });
 }
-
-// node_modules/quick-lru/index.js
-class QuickLRU extends Map {
-  #size = 0;
-  #cache = new Map;
-  #oldCache = new Map;
-  #maxSize;
-  #maxAge;
-  #onEviction;
-  constructor(options = {}) {
-    super();
-    if (!(options.maxSize && options.maxSize > 0)) {
-      throw new TypeError("`maxSize` must be a number greater than 0");
-    }
-    if (typeof options.maxAge === "number" && options.maxAge === 0) {
-      throw new TypeError("`maxAge` must be a number greater than 0");
-    }
-    this.#maxSize = options.maxSize;
-    this.#maxAge = options.maxAge || Number.POSITIVE_INFINITY;
-    this.#onEviction = options.onEviction;
-  }
-  get __oldCache() {
-    return this.#oldCache;
-  }
-  #emitEvictions(cache) {
-    if (typeof this.#onEviction !== "function") {
-      return;
-    }
-    for (const [key, item] of cache) {
-      this.#onEviction(key, item.value);
-    }
-  }
-  #deleteIfExpired(key, item) {
-    if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
-      if (typeof this.#onEviction === "function") {
-        this.#onEviction(key, item.value);
-      }
-      return this.delete(key);
-    }
-    return false;
-  }
-  #getOrDeleteIfExpired(key, item) {
-    const deleted = this.#deleteIfExpired(key, item);
-    if (deleted === false) {
-      return item.value;
-    }
-  }
-  #getItemValue(key, item) {
-    return item.expiry ? this.#getOrDeleteIfExpired(key, item) : item.value;
-  }
-  #peek(key, cache) {
-    const item = cache.get(key);
-    return this.#getItemValue(key, item);
-  }
-  #set(key, value) {
-    this.#cache.set(key, value);
-    this.#size++;
-    if (this.#size >= this.#maxSize) {
-      this.#size = 0;
-      this.#emitEvictions(this.#oldCache);
-      this.#oldCache = this.#cache;
-      this.#cache = new Map;
-    }
-  }
-  #moveToRecent(key, item) {
-    this.#oldCache.delete(key);
-    this.#set(key, item);
-  }
-  *#entriesAscending() {
-    for (const item of this.#oldCache) {
-      const [key, value] = item;
-      if (!this.#cache.has(key)) {
-        const deleted = this.#deleteIfExpired(key, value);
-        if (deleted === false) {
-          yield item;
-        }
-      }
-    }
-    for (const item of this.#cache) {
-      const [key, value] = item;
-      const deleted = this.#deleteIfExpired(key, value);
-      if (deleted === false) {
-        yield item;
-      }
-    }
-  }
-  get(key) {
-    if (this.#cache.has(key)) {
-      const item = this.#cache.get(key);
-      return this.#getItemValue(key, item);
-    }
-    if (this.#oldCache.has(key)) {
-      const item = this.#oldCache.get(key);
-      if (this.#deleteIfExpired(key, item) === false) {
-        this.#moveToRecent(key, item);
-        return item.value;
-      }
-    }
-  }
-  set(key, value, { maxAge = this.#maxAge } = {}) {
-    const expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : undefined;
-    if (this.#cache.has(key)) {
-      this.#cache.set(key, {
-        value,
-        expiry
-      });
-    } else {
-      this.#set(key, { value, expiry });
-    }
-    return this;
-  }
-  has(key) {
-    if (this.#cache.has(key)) {
-      return !this.#deleteIfExpired(key, this.#cache.get(key));
-    }
-    if (this.#oldCache.has(key)) {
-      return !this.#deleteIfExpired(key, this.#oldCache.get(key));
-    }
-    return false;
-  }
-  peek(key) {
-    if (this.#cache.has(key)) {
-      return this.#peek(key, this.#cache);
-    }
-    if (this.#oldCache.has(key)) {
-      return this.#peek(key, this.#oldCache);
+export function memoize(func, options) {
+    if (!options) {
+        options = {};
     }
-  }
-  delete(key) {
-    const deleted = this.#cache.delete(key);
-    if (deleted) {
-      this.#size--;
+    if (!options.cache) {
+        options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 10000 });
     }
-    return this.#oldCache.delete(key) || deleted;
-  }
-  clear() {
-    this.#cache.clear();
-    this.#oldCache.clear();
-    this.#size = 0;
-  }
-  resize(newSize) {
-    if (!(newSize && newSize > 0)) {
-      throw new TypeError("`maxSize` must be a number greater than 0");
+    if (!options.cacheKey) {
+        options.cacheKey = (args) => getHash(args);
     }
-    const items = [...this.#entriesAscending()];
-    const removeCount = items.length - newSize;
-    if (removeCount < 0) {
-      this.#cache = new Map(items);
-      this.#oldCache = new Map;
-      this.#size = items.length;
-    } else {
-      if (removeCount > 0) {
-        this.#emitEvictions(items.slice(0, removeCount));
-      }
-      this.#oldCache = new Map(items.slice(removeCount));
-      this.#cache = new Map;
-      this.#size = 0;
-    }
-    this.#maxSize = newSize;
-  }
-  *keys() {
-    for (const [key] of this) {
-      yield key;
-    }
-  }
-  *values() {
-    for (const [, value] of this) {
-      yield value;
-    }
-  }
-  *[Symbol.iterator]() {
-    for (const item of this.#cache) {
-      const [key, value] = item;
-      const deleted = this.#deleteIfExpired(key, value);
-      if (deleted === false) {
-        yield [key, value.value];
-      }
-    }
-    for (const item of this.#oldCache) {
-      const [key, value] = item;
-      if (!this.#cache.has(key)) {
-        const deleted = this.#deleteIfExpired(key, value);
-        if (deleted === false) {
-          yield [key, value.value];
-        }
-      }
-    }
-  }
-  *entriesDescending() {
-    let items = [...this.#cache];
-    for (let i = items.length - 1;i >= 0; --i) {
-      const item = items[i];
-      const [key, value] = item;
-      const deleted = this.#deleteIfExpired(key, value);
-      if (deleted === false) {
-        yield [key, value.value];
-      }
-    }
-    items = [...this.#oldCache];
-    for (let i = items.length - 1;i >= 0; --i) {
-      const item = items[i];
-      const [key, value] = item;
-      if (!this.#cache.has(key)) {
-        const deleted = this.#deleteIfExpired(key, value);
-        if (deleted === false) {
-          yield [key, value.value];
-        }
-      }
-    }
-  }
-  *entriesAscending() {
-    for (const [key, value] of this.#entriesAscending()) {
-      yield [key, value.value];
-    }
-  }
-  get size() {
-    if (!this.#size) {
-      return this.#oldCache.size;
-    }
-    let oldCacheSize = 0;
-    for (const key of this.#oldCache.keys()) {
-      if (!this.#cache.has(key)) {
-        oldCacheSize++;
-      }
-    }
-    return Math.min(this.#size + oldCacheSize, this.#maxSize);
-  }
-  get maxSize() {
-    return this.#maxSize;
-  }
-  entries() {
-    return this.entriesAscending();
-  }
-  forEach(callbackFunction, thisArgument = this) {
-    for (const [key, value] of this.entriesAscending()) {
-      callbackFunction.call(thisArgument, value, key, this);
-    }
-  }
-  get [Symbol.toStringTag]() {
-    return JSON.stringify([...this.entriesAscending()]);
-  }
-}
-
-// availability.ts
-async function wait(time) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, time);
-  });
-}
-async function exponentialRetry(func, {
-  maxRetry,
-  initialDuration,
-  growFactor,
-  test,
-  verbose
-}) {
-  let retries = maxRetry;
-  let duration = initialDuration || 5000;
-  const growFactorFinal = growFactor || 2;
-  let result = await func();
-  while (!test(result) && retries > 0) {
-    if (verbose) {
-      console.log("failed attempt result", result);
-      console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
-    }
-    retries = retries - 1;
-    await wait(duration);
-    result = await func();
-    duration = duration * growFactorFinal;
-  }
-  if (verbose) {
-    console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
-  }
-  return result;
-}
-function withRetry(func, options) {
-  let retries = options?.maxRetry || 3;
-  let duration = options?.initialDuration || 500;
-  const growFactorFinal = options?.growFactor || 2;
-  return async (...args) => {
-    do {
-      try {
-        return await func(...args);
-      } catch (error) {
-        retries = retries - 1;
-        if (retries <= 0) {
-          throw error;
-        }
-        await wait(duration);
-        duration = duration * growFactorFinal;
-      }
-    } while (retries > 0);
-    throw new Error("unreachable");
-  };
-}
-function memoize(func, options) {
-  if (!options) {
-    options = {};
-  }
-  if (!options.cache) {
-    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 1e4 });
-  }
-  if (!options.cacheKey) {
-    options.cacheKey = (args) => getHash(args);
-  }
-  return pMemoize(func, options);
+    return pMemoize(func, options);
 }
-export {
-  withRetry,
-  wait,
-  pThrottle as throttle,
-  memoize,
-  exponentialRetry
-};
+export { pThrottle as throttle };