@slicemachine/init 1.1.19 → 2.0.1

package/dist/_node_modules/meow/_node_modules/lru-cache/index.js

@@ -0,0 +1,1015 @@
+const perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const hasAbortController = typeof AbortController === "function";
+const AC = hasAbortController ? AbortController : class AbortController2 {
+  constructor() {
+    this.signal = new AS();
+  }
+  abort(reason = new Error("This operation was aborted")) {
+    this.signal.reason = this.signal.reason || reason;
+    this.signal.aborted = true;
+    this.signal.dispatchEvent({
+      type: "abort",
+      target: this.signal
+    });
+  }
+};
+const hasAbortSignal = typeof AbortSignal === "function";
+const hasACAbortSignal = typeof AC.AbortSignal === "function";
+const AS = hasAbortSignal ? AbortSignal : hasACAbortSignal ? AC.AbortController : class AbortSignal2 {
+  constructor() {
+    this.reason = void 0;
+    this.aborted = false;
+    this._listeners = [];
+  }
+  dispatchEvent(e) {
+    if (e.type === "abort") {
+      this.aborted = true;
+      this.onabort(e);
+      this._listeners.forEach((f) => f(e), this);
+    }
+  }
+  onabort() {
+  }
+  addEventListener(ev, fn) {
+    if (ev === "abort") {
+      this._listeners.push(fn);
+    }
+  }
+  removeEventListener(ev, fn) {
+    if (ev === "abort") {
+      this._listeners = this._listeners.filter((f) => f !== fn);
+    }
+  }
+};
+const warned = /* @__PURE__ */ new Set();
+const deprecatedOption = (opt, instead) => {
+  const code = `LRU_CACHE_OPTION_${opt}`;
+  if (shouldWarn(code)) {
+    warn(code, `${opt} option`, `options.${instead}`, LRUCache);
+  }
+};
+const deprecatedMethod = (method, instead) => {
+  const code = `LRU_CACHE_METHOD_${method}`;
+  if (shouldWarn(code)) {
+    const { prototype } = LRUCache;
+    const { get } = Object.getOwnPropertyDescriptor(prototype, method);
+    warn(code, `${method} method`, `cache.${instead}()`, get);
+  }
+};
+const deprecatedProperty = (field, instead) => {
+  const code = `LRU_CACHE_PROPERTY_${field}`;
+  if (shouldWarn(code)) {
+    const { prototype } = LRUCache;
+    const { get } = Object.getOwnPropertyDescriptor(prototype, field);
+    warn(code, `${field} property`, `cache.${instead}`, get);
+  }
+};
+const emitWarning = (...a) => {
+  typeof process === "object" && process && typeof process.emitWarning === "function" ? process.emitWarning(...a) : console.error(...a);
+};
+const shouldWarn = (code) => !warned.has(code);
+const warn = (code, what, instead, fn) => {
+  warned.add(code);
+  const msg = `The ${what} is deprecated. Please use ${instead} instead.`;
+  emitWarning(msg, "DeprecationWarning", code, fn);
+};
+const isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+const getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+class ZeroArray extends Array {
+  constructor(size) {
+    super(size);
+    this.fill(0);
+  }
+}
+class Stack {
+  constructor(max) {
+    if (max === 0) {
+      return [];
+    }
+    const UintArray = getUintArray(max);
+    this.heap = new UintArray(max);
+    this.length = 0;
+  }
+  push(n) {
+    this.heap[this.length++] = n;
+  }
+  pop() {
+    return this.heap[--this.length];
+  }
+}
+class LRUCache {
+  constructor(options = {}) {
+    const {
+      max = 0,
+      ttl,
+      ttlResolution = 1,
+      ttlAutopurge,
+      updateAgeOnGet,
+      updateAgeOnHas,
+      allowStale,
+      dispose,
+      disposeAfter,
+      noDisposeOnSet,
+      noUpdateTTL,
+      maxSize = 0,
+      maxEntrySize = 0,
+      sizeCalculation,
+      fetchMethod,
+      fetchContext,
+      noDeleteOnFetchRejection,
+      noDeleteOnStaleGet,
+      allowStaleOnFetchRejection,
+      allowStaleOnFetchAbort,
+      ignoreFetchAbort
+    } = options;
+    const { length, maxAge, stale } = options instanceof LRUCache ? {} : options;
+    if (max !== 0 && !isPosInt(max)) {
+      throw new TypeError("max option must be a nonnegative integer");
+    }
+    const UintArray = max ? getUintArray(max) : Array;
+    if (!UintArray) {
+      throw new Error("invalid max value: " + max);
+    }
+    this.max = max;
+    this.maxSize = maxSize;
+    this.maxEntrySize = maxEntrySize || this.maxSize;
+    this.sizeCalculation = sizeCalculation || length;
+    if (this.sizeCalculation) {
+      if (!this.maxSize && !this.maxEntrySize) {
+        throw new TypeError(
+          "cannot set sizeCalculation without setting maxSize or maxEntrySize"
+        );
+      }
+      if (typeof this.sizeCalculation !== "function") {
+        throw new TypeError("sizeCalculation set to non-function");
+      }
+    }
+    this.fetchMethod = fetchMethod || null;
+    if (this.fetchMethod && typeof this.fetchMethod !== "function") {
+      throw new TypeError(
+        "fetchMethod must be a function if specified"
+      );
+    }
+    this.fetchContext = fetchContext;
+    if (!this.fetchMethod && fetchContext !== void 0) {
+      throw new TypeError(
+        "cannot set fetchContext without fetchMethod"
+      );
+    }
+    this.keyMap = /* @__PURE__ */ new Map();
+    this.keyList = new Array(max).fill(null);
+    this.valList = new Array(max).fill(null);
+    this.next = new UintArray(max);
+    this.prev = new UintArray(max);
+    this.head = 0;
+    this.tail = 0;
+    this.free = new Stack(max);
+    this.initialFill = 1;
+    this.size = 0;
+    if (typeof dispose === "function") {
+      this.dispose = dispose;
+    }
+    if (typeof disposeAfter === "function") {
+      this.disposeAfter = disposeAfter;
+      this.disposed = [];
+    } else {
+      this.disposeAfter = null;
+      this.disposed = null;
+    }
+    this.noDisposeOnSet = !!noDisposeOnSet;
+    this.noUpdateTTL = !!noUpdateTTL;
+    this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+    this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+    this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+    this.ignoreFetchAbort = !!ignoreFetchAbort;
+    if (this.maxEntrySize !== 0) {
+      if (this.maxSize !== 0) {
+        if (!isPosInt(this.maxSize)) {
+          throw new TypeError(
+            "maxSize must be a positive integer if specified"
+          );
+        }
+      }
+      if (!isPosInt(this.maxEntrySize)) {
+        throw new TypeError(
+          "maxEntrySize must be a positive integer if specified"
+        );
+      }
+      this.initializeSizeTracking();
+    }
+    this.allowStale = !!allowStale || !!stale;
+    this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+    this.updateAgeOnGet = !!updateAgeOnGet;
+    this.updateAgeOnHas = !!updateAgeOnHas;
+    this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+    this.ttlAutopurge = !!ttlAutopurge;
+    this.ttl = ttl || maxAge || 0;
+    if (this.ttl) {
+      if (!isPosInt(this.ttl)) {
+        throw new TypeError(
+          "ttl must be a positive integer if specified"
+        );
+      }
+      this.initializeTTLTracking();
+    }
+    if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) {
+      throw new TypeError(
+        "At least one of max, maxSize, or ttl is required"
+      );
+    }
+    if (!this.ttlAutopurge && !this.max && !this.maxSize) {
+      const code = "LRU_CACHE_UNBOUNDED";
+      if (shouldWarn(code)) {
+        warned.add(code);
+        const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
+        emitWarning(msg, "UnboundedCacheWarning", code, LRUCache);
+      }
+    }
+    if (stale) {
+      deprecatedOption("stale", "allowStale");
+    }
+    if (maxAge) {
+      deprecatedOption("maxAge", "ttl");
+    }
+    if (length) {
+      deprecatedOption("length", "sizeCalculation");
+    }
+  }
+  getRemainingTTL(key) {
+    return this.has(key, { updateAgeOnHas: false }) ? Infinity : 0;
+  }
+  initializeTTLTracking() {
+    this.ttls = new ZeroArray(this.max);
+    this.starts = new ZeroArray(this.max);
+    this.setItemTTL = (index, ttl, start = perf.now()) => {
+      this.starts[index] = ttl !== 0 ? start : 0;
+      this.ttls[index] = ttl;
+      if (ttl !== 0 && this.ttlAutopurge) {
+        const t = setTimeout(() => {
+          if (this.isStale(index)) {
+            this.delete(this.keyList[index]);
+          }
+        }, ttl + 1);
+        if (t.unref) {
+          t.unref();
+        }
+      }
+    };
+    this.updateItemAge = (index) => {
+      this.starts[index] = this.ttls[index] !== 0 ? perf.now() : 0;
+    };
+    this.statusTTL = (status, index) => {
+      if (status) {
+        status.ttl = this.ttls[index];
+        status.start = this.starts[index];
+        status.now = cachedNow || getNow();
+        status.remainingTTL = status.now + status.ttl - status.start;
+      }
+    };
+    let cachedNow = 0;
+    const getNow = () => {
+      const n = perf.now();
+      if (this.ttlResolution > 0) {
+        cachedNow = n;
+        const t = setTimeout(
+          () => cachedNow = 0,
+          this.ttlResolution
+        );
+        if (t.unref) {
+          t.unref();
+        }
+      }
+      return n;
+    };
+    this.getRemainingTTL = (key) => {
+      const index = this.keyMap.get(key);
+      if (index === void 0) {
+        return 0;
+      }
+      return this.ttls[index] === 0 || this.starts[index] === 0 ? Infinity : this.starts[index] + this.ttls[index] - (cachedNow || getNow());
+    };
+    this.isStale = (index) => {
+      return this.ttls[index] !== 0 && this.starts[index] !== 0 && (cachedNow || getNow()) - this.starts[index] > this.ttls[index];
+    };
+  }
+  updateItemAge(_index) {
+  }
+  statusTTL(_status, _index) {
+  }
+  setItemTTL(_index, _ttl, _start) {
+  }
+  isStale(_index) {
+    return false;
+  }
+  initializeSizeTracking() {
+    this.calculatedSize = 0;
+    this.sizes = new ZeroArray(this.max);
+    this.removeItemSize = (index) => {
+      this.calculatedSize -= this.sizes[index];
+      this.sizes[index] = 0;
+    };
+    this.requireSize = (k, v, size, sizeCalculation) => {
+      if (this.isBackgroundFetch(v)) {
+        return 0;
+      }
+      if (!isPosInt(size)) {
+        if (sizeCalculation) {
+          if (typeof sizeCalculation !== "function") {
+            throw new TypeError("sizeCalculation must be a function");
+          }
+          size = sizeCalculation(v, k);
+          if (!isPosInt(size)) {
+            throw new TypeError(
+              "sizeCalculation return invalid (expect positive integer)"
+            );
+          }
+        } else {
+          throw new TypeError(
+            "invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set."
+          );
+        }
+      }
+      return size;
+    };
+    this.addItemSize = (index, size, status) => {
+      this.sizes[index] = size;
+      if (this.maxSize) {
+        const maxSize = this.maxSize - this.sizes[index];
+        while (this.calculatedSize > maxSize) {
+          this.evict(true);
+        }
+      }
+      this.calculatedSize += this.sizes[index];
+      if (status) {
+        status.entrySize = size;
+        status.totalCalculatedSize = this.calculatedSize;
+      }
+    };
+  }
+  removeItemSize(_index) {
+  }
+  addItemSize(_index, _size) {
+  }
+  requireSize(_k, _v, size, sizeCalculation) {
+    if (size || sizeCalculation) {
+      throw new TypeError(
+        "cannot set size without setting maxSize or maxEntrySize on cache"
+      );
+    }
+  }
+  *indexes({ allowStale = this.allowStale } = {}) {
+    if (this.size) {
+      for (let i = this.tail; true; ) {
+        if (!this.isValidIndex(i)) {
+          break;
+        }
+        if (allowStale || !this.isStale(i)) {
+          yield i;
+        }
+        if (i === this.head) {
+          break;
+        } else {
+          i = this.prev[i];
+        }
+      }
+    }
+  }
+  *rindexes({ allowStale = this.allowStale } = {}) {
+    if (this.size) {
+      for (let i = this.head; true; ) {
+        if (!this.isValidIndex(i)) {
+          break;
+        }
+        if (allowStale || !this.isStale(i)) {
+          yield i;
+        }
+        if (i === this.tail) {
+          break;
+        } else {
+          i = this.next[i];
+        }
+      }
+    }
+  }
+  isValidIndex(index) {
+    return index !== void 0 && this.keyMap.get(this.keyList[index]) === index;
+  }
+  *entries() {
+    for (const i of this.indexes()) {
+      if (this.valList[i] !== void 0 && this.keyList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) {
+        yield [this.keyList[i], this.valList[i]];
+      }
+    }
+  }
+  *rentries() {
+    for (const i of this.rindexes()) {
+      if (this.valList[i] !== void 0 && this.keyList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) {
+        yield [this.keyList[i], this.valList[i]];
+      }
+    }
+  }
+  *keys() {
+    for (const i of this.indexes()) {
+      if (this.keyList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) {
+        yield this.keyList[i];
+      }
+    }
+  }
+  *rkeys() {
+    for (const i of this.rindexes()) {
+      if (this.keyList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) {
+        yield this.keyList[i];
+      }
+    }
+  }
+  *values() {
+    for (const i of this.indexes()) {
+      if (this.valList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) {
+        yield this.valList[i];
+      }
+    }
+  }
+  *rvalues() {
+    for (const i of this.rindexes()) {
+      if (this.valList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) {
+        yield this.valList[i];
+      }
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  find(fn, getOptions) {
+    for (const i of this.indexes()) {
+      const v = this.valList[i];
+      const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+      if (value === void 0)
+        continue;
+      if (fn(value, this.keyList[i], this)) {
+        return this.get(this.keyList[i], getOptions);
+      }
+    }
+  }
+  forEach(fn, thisp = this) {
+    for (const i of this.indexes()) {
+      const v = this.valList[i];
+      const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+      if (value === void 0)
+        continue;
+      fn.call(thisp, value, this.keyList[i], this);
+    }
+  }
+  rforEach(fn, thisp = this) {
+    for (const i of this.rindexes()) {
+      const v = this.valList[i];
+      const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+      if (value === void 0)
+        continue;
+      fn.call(thisp, value, this.keyList[i], this);
+    }
+  }
+  get prune() {
+    deprecatedMethod("prune", "purgeStale");
+    return this.purgeStale;
+  }
+  purgeStale() {
+    let deleted = false;
+    for (const i of this.rindexes({ allowStale: true })) {
+      if (this.isStale(i)) {
+        this.delete(this.keyList[i]);
+        deleted = true;
+      }
+    }
+    return deleted;
+  }
+  dump() {
+    const arr = [];
+    for (const i of this.indexes({ allowStale: true })) {
+      const key = this.keyList[i];
+      const v = this.valList[i];
+      const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+      if (value === void 0)
+        continue;
+      const entry = { value };
+      if (this.ttls) {
+        entry.ttl = this.ttls[i];
+        const age = perf.now() - this.starts[i];
+        entry.start = Math.floor(Date.now() - age);
+      }
+      if (this.sizes) {
+        entry.size = this.sizes[i];
+      }
+      arr.unshift([key, entry]);
+    }
+    return arr;
+  }
+  load(arr) {
+    this.clear();
+    for (const [key, entry] of arr) {
+      if (entry.start) {
+        const age = Date.now() - entry.start;
+        entry.start = perf.now() - age;
+      }
+      this.set(key, entry.value, entry);
+    }
+  }
+  dispose(_v, _k, _reason) {
+  }
+  set(k, v, {
+    ttl = this.ttl,
+    start,
+    noDisposeOnSet = this.noDisposeOnSet,
+    size = 0,
+    sizeCalculation = this.sizeCalculation,
+    noUpdateTTL = this.noUpdateTTL,
+    status
+  } = {}) {
+    size = this.requireSize(k, v, size, sizeCalculation);
+    if (this.maxEntrySize && size > this.maxEntrySize) {
+      if (status) {
+        status.set = "miss";
+        status.maxEntrySizeExceeded = true;
+      }
+      this.delete(k);
+      return this;
+    }
+    let index = this.size === 0 ? void 0 : this.keyMap.get(k);
+    if (index === void 0) {
+      index = this.newIndex();
+      this.keyList[index] = k;
+      this.valList[index] = v;
+      this.keyMap.set(k, index);
+      this.next[this.tail] = index;
+      this.prev[index] = this.tail;
+      this.tail = index;
+      this.size++;
+      this.addItemSize(index, size, status);
+      if (status) {
+        status.set = "add";
+      }
+      noUpdateTTL = false;
+    } else {
+      this.moveToTail(index);
+      const oldVal = this.valList[index];
+      if (v !== oldVal) {
+        if (this.isBackgroundFetch(oldVal)) {
+          oldVal.__abortController.abort(new Error("replaced"));
+        } else {
+          if (!noDisposeOnSet) {
+            this.dispose(oldVal, k, "set");
+            if (this.disposeAfter) {
+              this.disposed.push([oldVal, k, "set"]);
+            }
+          }
+        }
+        this.removeItemSize(index);
+        this.valList[index] = v;
+        this.addItemSize(index, size, status);
+        if (status) {
+          status.set = "replace";
+          const oldValue = oldVal && this.isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
+          if (oldValue !== void 0)
+            status.oldValue = oldValue;
+        }
+      } else if (status) {
+        status.set = "update";
+      }
+    }
+    if (ttl !== 0 && this.ttl === 0 && !this.ttls) {
+      this.initializeTTLTracking();
+    }
+    if (!noUpdateTTL) {
+      this.setItemTTL(index, ttl, start);
+    }
+    this.statusTTL(status, index);
+    if (this.disposeAfter) {
+      while (this.disposed.length) {
+        this.disposeAfter(...this.disposed.shift());
+      }
+    }
+    return this;
+  }
+  newIndex() {
+    if (this.size === 0) {
+      return this.tail;
+    }
+    if (this.size === this.max && this.max !== 0) {
+      return this.evict(false);
+    }
+    if (this.free.length !== 0) {
+      return this.free.pop();
+    }
+    return this.initialFill++;
+  }
+  pop() {
+    if (this.size) {
+      const val = this.valList[this.head];
+      this.evict(true);
+      return val;
+    }
+  }
+  evict(free) {
+    const head = this.head;
+    const k = this.keyList[head];
+    const v = this.valList[head];
+    if (this.isBackgroundFetch(v)) {
+      v.__abortController.abort(new Error("evicted"));
+    } else {
+      this.dispose(v, k, "evict");
+      if (this.disposeAfter) {
+        this.disposed.push([v, k, "evict"]);
+      }
+    }
+    this.removeItemSize(head);
+    if (free) {
+      this.keyList[head] = null;
+      this.valList[head] = null;
+      this.free.push(head);
+    }
+    this.head = this.next[head];
+    this.keyMap.delete(k);
+    this.size--;
+    return head;
+  }
+  has(k, { updateAgeOnHas = this.updateAgeOnHas, status } = {}) {
+    const index = this.keyMap.get(k);
+    if (index !== void 0) {
+      if (!this.isStale(index)) {
+        if (updateAgeOnHas) {
+          this.updateItemAge(index);
+        }
+        if (status)
+          status.has = "hit";
+        this.statusTTL(status, index);
+        return true;
+      } else if (status) {
+        status.has = "stale";
+        this.statusTTL(status, index);
+      }
+    } else if (status) {
+      status.has = "miss";
+    }
+    return false;
+  }
+  // like get(), but without any LRU updating or TTL expiration
+  peek(k, { allowStale = this.allowStale } = {}) {
+    const index = this.keyMap.get(k);
+    if (index !== void 0 && (allowStale || !this.isStale(index))) {
+      const v = this.valList[index];
+      return this.isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+    }
+  }
+  backgroundFetch(k, index, options, context) {
+    const v = index === void 0 ? void 0 : this.valList[index];
+    if (this.isBackgroundFetch(v)) {
+      return v;
+    }
+    const ac = new AC();
+    if (options.signal) {
+      options.signal.addEventListener(
+        "abort",
+        () => ac.abort(options.signal.reason)
+      );
+    }
+    const fetchOpts = {
+      signal: ac.signal,
+      options,
+      context
+    };
+    const cb = (v2, updateCache = false) => {
+      const { aborted } = ac.signal;
+      const ignoreAbort = options.ignoreFetchAbort && v2 !== void 0;
+      if (options.status) {
+        if (aborted && !updateCache) {
+          options.status.fetchAborted = true;
+          options.status.fetchError = ac.signal.reason;
+          if (ignoreAbort)
+            options.status.fetchAbortIgnored = true;
+        } else {
+          options.status.fetchResolved = true;
+        }
+      }
+      if (aborted && !ignoreAbort && !updateCache) {
+        return fetchFail(ac.signal.reason);
+      }
+      if (this.valList[index] === p) {
+        if (v2 === void 0) {
+          if (p.__staleWhileFetching) {
+            this.valList[index] = p.__staleWhileFetching;
+          } else {
+            this.delete(k);
+          }
+        } else {
+          if (options.status)
+            options.status.fetchUpdated = true;
+          this.set(k, v2, fetchOpts.options);
+        }
+      }
+      return v2;
+    };
+    const eb = (er) => {
+      if (options.status) {
+        options.status.fetchRejected = true;
+        options.status.fetchError = er;
+      }
+      return fetchFail(er);
+    };
+    const fetchFail = (er) => {
+      const { aborted } = ac.signal;
+      const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+      const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+      const noDelete = allowStale || options.noDeleteOnFetchRejection;
+      if (this.valList[index] === p) {
+        const del = !noDelete || p.__staleWhileFetching === void 0;
+        if (del) {
+          this.delete(k);
+        } else if (!allowStaleAborted) {
+          this.valList[index] = p.__staleWhileFetching;
+        }
+      }
+      if (allowStale) {
+        if (options.status && p.__staleWhileFetching !== void 0) {
+          options.status.returnedStale = true;
+        }
+        return p.__staleWhileFetching;
+      } else if (p.__returned === p) {
+        throw er;
+      }
+    };
+    const pcall = (res, rej) => {
+      this.fetchMethod(k, v, fetchOpts).then((v2) => res(v2), rej);
+      ac.signal.addEventListener("abort", () => {
+        if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+          res();
+          if (options.allowStaleOnFetchAbort) {
+            res = (v2) => cb(v2, true);
+          }
+        }
+      });
+    };
+    if (options.status)
+      options.status.fetchDispatched = true;
+    const p = new Promise(pcall).then(cb, eb);
+    p.__abortController = ac;
+    p.__staleWhileFetching = v;
+    p.__returned = null;
+    if (index === void 0) {
+      this.set(k, p, { ...fetchOpts.options, status: void 0 });
+      index = this.keyMap.get(k);
+    } else {
+      this.valList[index] = p;
+    }
+    return p;
+  }
+  isBackgroundFetch(p) {
+    return p && typeof p === "object" && typeof p.then === "function" && Object.prototype.hasOwnProperty.call(
+      p,
+      "__staleWhileFetching"
+    ) && Object.prototype.hasOwnProperty.call(p, "__returned") && (p.__returned === p || p.__returned === null);
+  }
+  // this takes the union of get() and set() opts, because it does both
+  async fetch(k, {
+    // get options
+    allowStale = this.allowStale,
+    updateAgeOnGet = this.updateAgeOnGet,
+    noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+    // set options
+    ttl = this.ttl,
+    noDisposeOnSet = this.noDisposeOnSet,
+    size = 0,
+    sizeCalculation = this.sizeCalculation,
+    noUpdateTTL = this.noUpdateTTL,
+    // fetch exclusive options
+    noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
+    allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
+    ignoreFetchAbort = this.ignoreFetchAbort,
+    allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
+    fetchContext = this.fetchContext,
+    forceRefresh = false,
+    status,
+    signal
+  } = {}) {
+    if (!this.fetchMethod) {
+      if (status)
+        status.fetch = "get";
+      return this.get(k, {
+        allowStale,
+        updateAgeOnGet,
+        noDeleteOnStaleGet,
+        status
+      });
+    }
+    const options = {
+      allowStale,
+      updateAgeOnGet,
+      noDeleteOnStaleGet,
+      ttl,
+      noDisposeOnSet,
+      size,
+      sizeCalculation,
+      noUpdateTTL,
+      noDeleteOnFetchRejection,
+      allowStaleOnFetchRejection,
+      allowStaleOnFetchAbort,
+      ignoreFetchAbort,
+      status,
+      signal
+    };
+    let index = this.keyMap.get(k);
+    if (index === void 0) {
+      if (status)
+        status.fetch = "miss";
+      const p = this.backgroundFetch(k, index, options, fetchContext);
+      return p.__returned = p;
+    } else {
+      const v = this.valList[index];
+      if (this.isBackgroundFetch(v)) {
+        const stale = allowStale && v.__staleWhileFetching !== void 0;
+        if (status) {
+          status.fetch = "inflight";
+          if (stale)
+            status.returnedStale = true;
+        }
+        return stale ? v.__staleWhileFetching : v.__returned = v;
+      }
+      const isStale = this.isStale(index);
+      if (!forceRefresh && !isStale) {
+        if (status)
+          status.fetch = "hit";
+        this.moveToTail(index);
+        if (updateAgeOnGet) {
+          this.updateItemAge(index);
+        }
+        this.statusTTL(status, index);
+        return v;
+      }
+      const p = this.backgroundFetch(k, index, options, fetchContext);
+      const hasStale = p.__staleWhileFetching !== void 0;
+      const staleVal = hasStale && allowStale;
+      if (status) {
+        status.fetch = hasStale && isStale ? "stale" : "refresh";
+        if (staleVal && isStale)
+          status.returnedStale = true;
+      }
+      return staleVal ? p.__staleWhileFetching : p.__returned = p;
+    }
+  }
+  get(k, {
+    allowStale = this.allowStale,
+    updateAgeOnGet = this.updateAgeOnGet,
+    noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+    status
+  } = {}) {
+    const index = this.keyMap.get(k);
+    if (index !== void 0) {
+      const value = this.valList[index];
+      const fetching = this.isBackgroundFetch(value);
+      this.statusTTL(status, index);
+      if (this.isStale(index)) {
+        if (status)
+          status.get = "stale";
+        if (!fetching) {
+          if (!noDeleteOnStaleGet) {
+            this.delete(k);
+          }
+          if (status)
+            status.returnedStale = allowStale;
+          return allowStale ? value : void 0;
+        } else {
+          if (status) {
+            status.returnedStale = allowStale && value.__staleWhileFetching !== void 0;
+          }
+          return allowStale ? value.__staleWhileFetching : void 0;
+        }
+      } else {
+        if (status)
+          status.get = "hit";
+        if (fetching) {
+          return value.__staleWhileFetching;
+        }
+        this.moveToTail(index);
+        if (updateAgeOnGet) {
+          this.updateItemAge(index);
+        }
+        return value;
+      }
+    } else if (status) {
+      status.get = "miss";
+    }
+  }
+  connect(p, n) {
+    this.prev[n] = p;
+    this.next[p] = n;
+  }
+  moveToTail(index) {
+    if (index !== this.tail) {
+      if (index === this.head) {
+        this.head = this.next[index];
+      } else {
+        this.connect(this.prev[index], this.next[index]);
+      }
+      this.connect(this.tail, index);
+      this.tail = index;
+    }
+  }
+  get del() {
+    deprecatedMethod("del", "delete");
+    return this.delete;
+  }
+  delete(k) {
+    let deleted = false;
+    if (this.size !== 0) {
+      const index = this.keyMap.get(k);
+      if (index !== void 0) {
+        deleted = true;
+        if (this.size === 1) {
+          this.clear();
+        } else {
+          this.removeItemSize(index);
+          const v = this.valList[index];
+          if (this.isBackgroundFetch(v)) {
+            v.__abortController.abort(new Error("deleted"));
+          } else {
+            this.dispose(v, k, "delete");
+            if (this.disposeAfter) {
+              this.disposed.push([v, k, "delete"]);
+            }
+          }
+          this.keyMap.delete(k);
+          this.keyList[index] = null;
+          this.valList[index] = null;
+          if (index === this.tail) {
+            this.tail = this.prev[index];
+          } else if (index === this.head) {
+            this.head = this.next[index];
+          } else {
+            this.next[this.prev[index]] = this.next[index];
+            this.prev[this.next[index]] = this.prev[index];
+          }
+          this.size--;
+          this.free.push(index);
+        }
+      }
+    }
+    if (this.disposed) {
+      while (this.disposed.length) {
+        this.disposeAfter(...this.disposed.shift());
+      }
+    }
+    return deleted;
+  }
+  clear() {
+    for (const index of this.rindexes({ allowStale: true })) {
+      const v = this.valList[index];
+      if (this.isBackgroundFetch(v)) {
+        v.__abortController.abort(new Error("deleted"));
+      } else {
+        const k = this.keyList[index];
+        this.dispose(v, k, "delete");
+        if (this.disposeAfter) {
+          this.disposed.push([v, k, "delete"]);
+        }
+      }
+    }
+    this.keyMap.clear();
+    this.valList.fill(null);
+    this.keyList.fill(null);
+    if (this.ttls) {
+      this.ttls.fill(0);
+      this.starts.fill(0);
+    }
+    if (this.sizes) {
+      this.sizes.fill(0);
+    }
+    this.head = 0;
+    this.tail = 0;
+    this.initialFill = 1;
+    this.free.length = 0;
+    this.calculatedSize = 0;
+    this.size = 0;
+    if (this.disposed) {
+      while (this.disposed.length) {
+        this.disposeAfter(...this.disposed.shift());
+      }
+    }
+  }
+  get reset() {
+    deprecatedMethod("reset", "clear");
+    return this.clear;
+  }
+  get length() {
+    deprecatedProperty("length", "size");
+    return this.size;
+  }
+  static get AbortController() {
+    return AC;
+  }
+  static get AbortSignal() {
+    return AS;
+  }
+}
+var lruCache = LRUCache;
+export {
+  lruCache as default
+};
+//# sourceMappingURL=index.js.map