'use strict';
Object.defineProperty(exports, '__esModule', { value: !0 });
exports.LRUCache = void 0;
var T =
    (
      typeof performance == 'object' &&
      performance &&
      typeof performance.now == 'function'
    ) ?
      performance
    : Date,
  U = new Set(),
  W = typeof process == 'object' && process ? process : {},
  I = (a, t, e, i) => {
    typeof W.emitWarning == 'function' ?
      W.emitWarning(a, t, e, i)
    : console.error(`[${e}] ${t}: ${a}`);
  },
  C = globalThis.AbortController,
  x = globalThis.AbortSignal;
if (typeof C > 'u') {
  (x = class {
    onabort;
    _onabort = [];
    reason;
    aborted = !1;
    addEventListener(i, s) {
      this._onabort.push(s);
    }
  }),
    (C = class {
      constructor() {
        t();
      }
      signal = new x();
      abort(i) {
        if (!this.signal.aborted) {
          (this.signal.reason = i), (this.signal.aborted = !0);
          for (let s of this.signal._onabort) s(i);
          this.signal.onabort?.(i);
        }
      }
    });
  let a = W.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1',
    t = () => {
      a &&
        ((a = !1),
        I(
          'AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.',
          'NO_ABORT_CONTROLLER',
          'ENOTSUP',
          t
        ));
    };
}
var G = (a) => !U.has(a),
  P = Symbol('type'),
  y = (a) => a && a === Math.floor(a) && a > 0 && isFinite(a),
  M = (a) =>
    y(a) ?
      a <= Math.pow(2, 8) ? Uint8Array
      : a <= Math.pow(2, 16) ? Uint16Array
      : a <= Math.pow(2, 32) ? Uint32Array
      : a <= Number.MAX_SAFE_INTEGER ? E
      : null
    : null,
  E = class extends Array {
    constructor(t) {
      super(t), this.fill(0);
    }
  },
  D = class a {
    heap;
    length;
    static #l = !1;
    static create(t) {
      let e = M(t);
      if (!e) return [];
      a.#l = !0;
      let i = new a(t, e);
      return (a.#l = !1), i;
    }
    constructor(t, e) {
      if (!a.#l) throw new TypeError('instantiate Stack using Stack.create(n)');
      (this.heap = new e(t)), (this.length = 0);
    }
    push(t) {
      this.heap[this.length++] = t;
    }
    pop() {
      return this.heap[--this.length];
    }
  },
  L = class a {
    #l;
    #c;
    #p;
    #z;
    #w;
    #W;
    #D;
    ttl;
    ttlResolution;
    ttlAutopurge;
    updateAgeOnGet;
    updateAgeOnHas;
    allowStale;
    noDisposeOnSet;
    noUpdateTTL;
    maxEntrySize;
    sizeCalculation;
    noDeleteOnFetchRejection;
    noDeleteOnStaleGet;
    allowStaleOnFetchAbort;
    allowStaleOnFetchRejection;
    ignoreFetchAbort;
    #n;
    #S;
    #s;
    #i;
    #t;
    #a;
    #u;
    #o;
    #h;
    #_;
    #r;
    #b;
    #m;
    #d;
    #y;
    #E;
    #f;
    #L;
    static unsafeExposeInternals(t) {
      return {
        starts: t.#m,
        ttls: t.#d,
        sizes: t.#b,
        keyMap: t.#s,
        keyList: t.#i,
        valList: t.#t,
        next: t.#a,
        prev: t.#u,
        get head() {
          return t.#o;
        },
        get tail() {
          return t.#h;
        },
        free: t.#_,
        isBackgroundFetch: (e) => t.#e(e),
        backgroundFetch: (e, i, s, n) => t.#I(e, i, s, n),
        moveToTail: (e) => t.#R(e),
        indexes: (e) => t.#A(e),
        rindexes: (e) => t.#F(e),
        isStale: (e) => t.#g(e),
      };
    }
    get max() {
      return this.#l;
    }
    get maxSize() {
      return this.#c;
    }
    get calculatedSize() {
      return this.#S;
    }
    get size() {
      return this.#n;
    }
    get fetchMethod() {
      return this.#W;
    }
    get memoMethod() {
      return this.#D;
    }
    get dispose() {
      return this.#p;
    }
    get onInsert() {
      return this.#z;
    }
    get disposeAfter() {
      return this.#w;
    }
    constructor(t) {
      let {
        max: e = 0,
        ttl: i,
        ttlResolution: s = 1,
        ttlAutopurge: n,
        updateAgeOnGet: h,
        updateAgeOnHas: o,
        allowStale: r,
        dispose: g,
        onInsert: _,
        disposeAfter: f,
        noDisposeOnSet: c,
        noUpdateTTL: u,
        maxSize: A = 0,
        maxEntrySize: d = 0,
        sizeCalculation: b,
        fetchMethod: l,
        memoMethod: w,
        noDeleteOnFetchRejection: m,
        noDeleteOnStaleGet: p,
        allowStaleOnFetchRejection: S,
        allowStaleOnFetchAbort: z,
        ignoreFetchAbort: F,
      } = t;
      if (e !== 0 && !y(e))
        throw new TypeError('max option must be a nonnegative integer');
      let v = e ? M(e) : Array;
      if (!v) throw new Error('invalid max value: ' + e);
      if (
        ((this.#l = e),
        (this.#c = A),
        (this.maxEntrySize = d || this.#c),
        (this.sizeCalculation = b),
        this.sizeCalculation)
      ) {
        if (!this.#c && !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');
      }
      if (w !== void 0 && typeof w != 'function')
        throw new TypeError('memoMethod must be a function if defined');
      if (((this.#D = w), l !== void 0 && typeof l != 'function'))
        throw new TypeError('fetchMethod must be a function if specified');
      if (
        ((this.#W = l),
        (this.#E = !!l),
        (this.#s = new Map()),
        (this.#i = new Array(e).fill(void 0)),
        (this.#t = new Array(e).fill(void 0)),
        (this.#a = new v(e)),
        (this.#u = new v(e)),
        (this.#o = 0),
        (this.#h = 0),
        (this.#_ = D.create(e)),
        (this.#n = 0),
        (this.#S = 0),
        typeof g == 'function' && (this.#p = g),
        typeof _ == 'function' && (this.#z = _),
        typeof f == 'function' ?
          ((this.#w = f), (this.#r = []))
        : ((this.#w = void 0), (this.#r = void 0)),
        (this.#y = !!this.#p),
        (this.#L = !!this.#z),
        (this.#f = !!this.#w),
        (this.noDisposeOnSet = !!c),
        (this.noUpdateTTL = !!u),
        (this.noDeleteOnFetchRejection = !!m),
        (this.allowStaleOnFetchRejection = !!S),
        (this.allowStaleOnFetchAbort = !!z),
        (this.ignoreFetchAbort = !!F),
        this.maxEntrySize !== 0)
      ) {
        if (this.#c !== 0 && !y(this.#c))
          throw new TypeError(
            'maxSize must be a positive integer if specified'
          );
        if (!y(this.maxEntrySize))
          throw new TypeError(
            'maxEntrySize must be a positive integer if specified'
          );
        this.#k();
      }
      if (
        ((this.allowStale = !!r),
        (this.noDeleteOnStaleGet = !!p),
        (this.updateAgeOnGet = !!h),
        (this.updateAgeOnHas = !!o),
        (this.ttlResolution = y(s) || s === 0 ? s : 1),
        (this.ttlAutopurge = !!n),
        (this.ttl = i || 0),
        this.ttl)
      ) {
        if (!y(this.ttl))
          throw new TypeError('ttl must be a positive integer if specified');
        this.#M();
      }
      if (this.#l === 0 && this.ttl === 0 && this.#c === 0)
        throw new TypeError('At least one of max, maxSize, or ttl is required');
      if (!this.ttlAutopurge && !this.#l && !this.#c) {
        let O = 'LRU_CACHE_UNBOUNDED';
        G(O) &&
          (U.add(O),
          I(
            'TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.',
            'UnboundedCacheWarning',
            O,
            a
          ));
      }
    }
    getRemainingTTL(t) {
      return this.#s.has(t) ? 1 / 0 : 0;
    }
    #M() {
      let t = new E(this.#l),
        e = new E(this.#l);
      (this.#d = t),
        (this.#m = e),
        (this.#G = (n, h, o = T.now()) => {
          if (
            ((e[n] = h !== 0 ? o : 0), (t[n] = h), h !== 0 && this.ttlAutopurge)
          ) {
            let r = setTimeout(() => {
              this.#g(n) && this.#O(this.#i[n], 'expire');
            }, h + 1);
            r.unref && r.unref();
          }
        }),
        (this.#v = (n) => {
          e[n] = t[n] !== 0 ? T.now() : 0;
        }),
        (this.#T = (n, h) => {
          if (t[h]) {
            let o = t[h],
              r = e[h];
            if (!o || !r) return;
            (n.ttl = o), (n.start = r), (n.now = i || s());
            let g = n.now - r;
            n.remainingTTL = o - g;
          }
        });
      let i = 0,
        s = () => {
          let n = T.now();
          if (this.ttlResolution > 0) {
            i = n;
            let h = setTimeout(() => (i = 0), this.ttlResolution);
            h.unref && h.unref();
          }
          return n;
        };
      (this.getRemainingTTL = (n) => {
        let h = this.#s.get(n);
        if (h === void 0) return 0;
        let o = t[h],
          r = e[h];
        if (!o || !r) return 1 / 0;
        let g = (i || s()) - r;
        return o - g;
      }),
        (this.#g = (n) => {
          let h = e[n],
            o = t[n];
          return !!o && !!h && (i || s()) - h > o;
        });
    }
    #v = () => {};
    #T = () => {};
    #G = () => {};
    #g = () => !1;
    #k() {
      let t = new E(this.#l);
      (this.#S = 0),
        (this.#b = t),
        (this.#C = (e) => {
          (this.#S -= t[e]), (t[e] = 0);
        }),
        (this.#j = (e, i, s, n) => {
          if (this.#e(i)) return 0;
          if (!y(s))
            if (n) {
              if (typeof n != 'function')
                throw new TypeError('sizeCalculation must be a function');
              if (((s = n(i, e)), !y(s)))
                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 s;
        }),
        (this.#x = (e, i, s) => {
          if (((t[e] = i), this.#c)) {
            let n = this.#c - t[e];
            for (; this.#S > n; ) this.#U(!0);
          }
          (this.#S += t[e]),
            s && ((s.entrySize = i), (s.totalCalculatedSize = this.#S));
        });
    }
    #C = (t) => {};
    #x = (t, e, i) => {};
    #j = (t, e, i, s) => {
      if (i || s)
        throw new TypeError(
          'cannot set size without setting maxSize or maxEntrySize on cache'
        );
      return 0;
    };
    *#A({ allowStale: t = this.allowStale } = {}) {
      if (this.#n)
        for (
          let e = this.#h;
          !(!this.#N(e) || ((t || !this.#g(e)) && (yield e), e === this.#o));

        )
          e = this.#u[e];
    }
    *#F({ allowStale: t = this.allowStale } = {}) {
      if (this.#n)
        for (
          let e = this.#o;
          !(!this.#N(e) || ((t || !this.#g(e)) && (yield e), e === this.#h));

        )
          e = this.#a[e];
    }
    #N(t) {
      return t !== void 0 && this.#s.get(this.#i[t]) === t;
    }
    *entries() {
      for (let t of this.#A())
        this.#t[t] !== void 0 &&
          this.#i[t] !== void 0 &&
          !this.#e(this.#t[t]) &&
          (yield [this.#i[t], this.#t[t]]);
    }
    *rentries() {
      for (let t of this.#F())
        this.#t[t] !== void 0 &&
          this.#i[t] !== void 0 &&
          !this.#e(this.#t[t]) &&
          (yield [this.#i[t], this.#t[t]]);
    }
    *keys() {
      for (let t of this.#A()) {
        let e = this.#i[t];
        e !== void 0 && !this.#e(this.#t[t]) && (yield e);
      }
    }
    *rkeys() {
      for (let t of this.#F()) {
        let e = this.#i[t];
        e !== void 0 && !this.#e(this.#t[t]) && (yield e);
      }
    }
    *values() {
      for (let t of this.#A())
        this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
    }
    *rvalues() {
      for (let t of this.#F())
        this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
    }
    [Symbol.iterator]() {
      return this.entries();
    }
    [Symbol.toStringTag] = 'LRUCache';
    find(t, e = {}) {
      for (let i of this.#A()) {
        let s = this.#t[i],
          n = this.#e(s) ? s.__staleWhileFetching : s;
        if (n !== void 0 && t(n, this.#i[i], this))
          return this.get(this.#i[i], e);
      }
    }
    forEach(t, e = this) {
      for (let i of this.#A()) {
        let s = this.#t[i],
          n = this.#e(s) ? s.__staleWhileFetching : s;
        n !== void 0 && t.call(e, n, this.#i[i], this);
      }
    }
    rforEach(t, e = this) {
      for (let i of this.#F()) {
        let s = this.#t[i],
          n = this.#e(s) ? s.__staleWhileFetching : s;
        n !== void 0 && t.call(e, n, this.#i[i], this);
      }
    }
    purgeStale() {
      let t = !1;
      for (let e of this.#F({ allowStale: !0 }))
        this.#g(e) && (this.#O(this.#i[e], 'expire'), (t = !0));
      return t;
    }
    info(t) {
      let e = this.#s.get(t);
      if (e === void 0) return;
      let i = this.#t[e],
        s = this.#e(i) ? i.__staleWhileFetching : i;
      if (s === void 0) return;
      let n = { value: s };
      if (this.#d && this.#m) {
        let h = this.#d[e],
          o = this.#m[e];
        if (h && o) {
          let r = h - (T.now() - o);
          (n.ttl = r), (n.start = Date.now());
        }
      }
      return this.#b && (n.size = this.#b[e]), n;
    }
    dump() {
      let t = [];
      for (let e of this.#A({ allowStale: !0 })) {
        let i = this.#i[e],
          s = this.#t[e],
          n = this.#e(s) ? s.__staleWhileFetching : s;
        if (n === void 0 || i === void 0) continue;
        let h = { value: n };
        if (this.#d && this.#m) {
          h.ttl = this.#d[e];
          let o = T.now() - this.#m[e];
          h.start = Math.floor(Date.now() - o);
        }
        this.#b && (h.size = this.#b[e]), t.unshift([i, h]);
      }
      return t;
    }
    load(t) {
      this.clear();
      for (let [e, i] of t) {
        if (i.start) {
          let s = Date.now() - i.start;
          i.start = T.now() - s;
        }
        this.set(e, i.value, i);
      }
    }
    set(t, e, i = {}) {
      if (e === void 0) return this.delete(t), this;
      let {
          ttl: s = this.ttl,
          start: n,
          noDisposeOnSet: h = this.noDisposeOnSet,
          sizeCalculation: o = this.sizeCalculation,
          status: r,
        } = i,
        { noUpdateTTL: g = this.noUpdateTTL } = i,
        _ = this.#j(t, e, i.size || 0, o);
      if (this.maxEntrySize && _ > this.maxEntrySize)
        return (
          r && ((r.set = 'miss'), (r.maxEntrySizeExceeded = !0)),
          this.#O(t, 'set'),
          this
        );
      let f = this.#n === 0 ? void 0 : this.#s.get(t);
      if (f === void 0)
        (f =
          this.#n === 0 ? this.#h
          : this.#_.length !== 0 ? this.#_.pop()
          : this.#n === this.#l ? this.#U(!1)
          : this.#n),
          (this.#i[f] = t),
          (this.#t[f] = e),
          this.#s.set(t, f),
          (this.#a[this.#h] = f),
          (this.#u[f] = this.#h),
          (this.#h = f),
          this.#n++,
          this.#x(f, _, r),
          r && (r.set = 'add'),
          (g = !1),
          this.#L && this.#z?.(e, t, 'add');
      else {
        this.#R(f);
        let c = this.#t[f];
        if (e !== c) {
          if (this.#E && this.#e(c)) {
            c.__abortController.abort(new Error('replaced'));
            let { __staleWhileFetching: u } = c;
            u !== void 0 &&
              !h &&
              (this.#y && this.#p?.(u, t, 'set'),
              this.#f && this.#r?.push([u, t, 'set']));
          } else
            h ||
              (this.#y && this.#p?.(c, t, 'set'),
              this.#f && this.#r?.push([c, t, 'set']));
          if ((this.#C(f), this.#x(f, _, r), (this.#t[f] = e), r)) {
            r.set = 'replace';
            let u = c && this.#e(c) ? c.__staleWhileFetching : c;
            u !== void 0 && (r.oldValue = u);
          }
        } else r && (r.set = 'update');
        this.#L && this.onInsert?.(e, t, e === c ? 'update' : 'replace');
      }
      if (
        (s !== 0 && !this.#d && this.#M(),
        this.#d && (g || this.#G(f, s, n), r && this.#T(r, f)),
        !h && this.#f && this.#r)
      ) {
        let c = this.#r,
          u;
        for (; (u = c?.shift()); ) this.#w?.(...u);
      }
      return this;
    }
    pop() {
      try {
        for (; this.#n; ) {
          let t = this.#t[this.#o];
          if ((this.#U(!0), this.#e(t))) {
            if (t.__staleWhileFetching) return t.__staleWhileFetching;
          } else if (t !== void 0) return t;
        }
      } finally {
        if (this.#f && this.#r) {
          let t = this.#r,
            e;
          for (; (e = t?.shift()); ) this.#w?.(...e);
        }
      }
    }
    #U(t) {
      let e = this.#o,
        i = this.#i[e],
        s = this.#t[e];
      return (
        this.#E && this.#e(s) ?
          s.__abortController.abort(new Error('evicted'))
        : (this.#y || this.#f) &&
          (this.#y && this.#p?.(s, i, 'evict'),
          this.#f && this.#r?.push([s, i, 'evict'])),
        this.#C(e),
        t && ((this.#i[e] = void 0), (this.#t[e] = void 0), this.#_.push(e)),
        this.#n === 1 ?
          ((this.#o = this.#h = 0), (this.#_.length = 0))
        : (this.#o = this.#a[e]),
        this.#s.delete(i),
        this.#n--,
        e
      );
    }
    has(t, e = {}) {
      let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = e,
        n = this.#s.get(t);
      if (n !== void 0) {
        let h = this.#t[n];
        if (this.#e(h) && h.__staleWhileFetching === void 0) return !1;
        if (this.#g(n)) s && ((s.has = 'stale'), this.#T(s, n));
        else return i && this.#v(n), s && ((s.has = 'hit'), this.#T(s, n)), !0;
      } else s && (s.has = 'miss');
      return !1;
    }
    peek(t, e = {}) {
      let { allowStale: i = this.allowStale } = e,
        s = this.#s.get(t);
      if (s === void 0 || (!i && this.#g(s))) return;
      let n = this.#t[s];
      return this.#e(n) ? n.__staleWhileFetching : n;
    }
    #I(t, e, i, s) {
      let n = e === void 0 ? void 0 : this.#t[e];
      if (this.#e(n)) return n;
      let h = new C(),
        { signal: o } = i;
      o?.addEventListener('abort', () => h.abort(o.reason), {
        signal: h.signal,
      });
      let r = { signal: h.signal, options: i, context: s },
        g = (d, b = !1) => {
          let { aborted: l } = h.signal,
            w = i.ignoreFetchAbort && d !== void 0;
          if (
            (i.status &&
              (l && !b ?
                ((i.status.fetchAborted = !0),
                (i.status.fetchError = h.signal.reason),
                w && (i.status.fetchAbortIgnored = !0))
              : (i.status.fetchResolved = !0)),
            l && !w && !b)
          )
            return f(h.signal.reason);
          let m = u;
          return (
            this.#t[e] === u &&
              (d === void 0 ?
                m.__staleWhileFetching ?
                  (this.#t[e] = m.__staleWhileFetching)
                : this.#O(t, 'fetch')
              : (i.status && (i.status.fetchUpdated = !0),
                this.set(t, d, r.options))),
            d
          );
        },
        _ = (d) => (
          i.status &&
            ((i.status.fetchRejected = !0), (i.status.fetchError = d)),
          f(d)
        ),
        f = (d) => {
          let { aborted: b } = h.signal,
            l = b && i.allowStaleOnFetchAbort,
            w = l || i.allowStaleOnFetchRejection,
            m = w || i.noDeleteOnFetchRejection,
            p = u;
          if (
            (this.#t[e] === u &&
              (!m || p.__staleWhileFetching === void 0 ?
                this.#O(t, 'fetch')
              : l || (this.#t[e] = p.__staleWhileFetching)),
            w)
          )
            return (
              i.status &&
                p.__staleWhileFetching !== void 0 &&
                (i.status.returnedStale = !0),
              p.__staleWhileFetching
            );
          if (p.__returned === p) throw d;
        },
        c = (d, b) => {
          let l = this.#W?.(t, n, r);
          l &&
            l instanceof Promise &&
            l.then((w) => d(w === void 0 ? void 0 : w), b),
            h.signal.addEventListener('abort', () => {
              (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) &&
                (d(void 0), i.allowStaleOnFetchAbort && (d = (w) => g(w, !0)));
            });
        };
      i.status && (i.status.fetchDispatched = !0);
      let u = new Promise(c).then(g, _),
        A = Object.assign(u, {
          __abortController: h,
          __staleWhileFetching: n,
          __returned: void 0,
        });
      return (
        e === void 0 ?
          (this.set(t, A, { ...r.options, status: void 0 }),
          (e = this.#s.get(t)))
        : (this.#t[e] = A),
        A
      );
    }
    #e(t) {
      if (!this.#E) return !1;
      let e = t;
      return (
        !!e &&
        e instanceof Promise &&
        e.hasOwnProperty('__staleWhileFetching') &&
        e.__abortController instanceof C
      );
    }
    async fetch(t, e = {}) {
      let {
        allowStale: i = this.allowStale,
        updateAgeOnGet: s = this.updateAgeOnGet,
        noDeleteOnStaleGet: n = this.noDeleteOnStaleGet,
        ttl: h = this.ttl,
        noDisposeOnSet: o = this.noDisposeOnSet,
        size: r = 0,
        sizeCalculation: g = this.sizeCalculation,
        noUpdateTTL: _ = this.noUpdateTTL,
        noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection,
        allowStaleOnFetchRejection: c = this.allowStaleOnFetchRejection,
        ignoreFetchAbort: u = this.ignoreFetchAbort,
        allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort,
        context: d,
        forceRefresh: b = !1,
        status: l,
        signal: w,
      } = e;
      if (!this.#E)
        return (
          l && (l.fetch = 'get'),
          this.get(t, {
            allowStale: i,
            updateAgeOnGet: s,
            noDeleteOnStaleGet: n,
            status: l,
          })
        );
      let m = {
          allowStale: i,
          updateAgeOnGet: s,
          noDeleteOnStaleGet: n,
          ttl: h,
          noDisposeOnSet: o,
          size: r,
          sizeCalculation: g,
          noUpdateTTL: _,
          noDeleteOnFetchRejection: f,
          allowStaleOnFetchRejection: c,
          allowStaleOnFetchAbort: A,
          ignoreFetchAbort: u,
          status: l,
          signal: w,
        },
        p = this.#s.get(t);
      if (p === void 0) {
        l && (l.fetch = 'miss');
        let S = this.#I(t, p, m, d);
        return (S.__returned = S);
      } else {
        let S = this.#t[p];
        if (this.#e(S)) {
          let R = i && S.__staleWhileFetching !== void 0;
          return (
            l && ((l.fetch = 'inflight'), R && (l.returnedStale = !0)),
            R ? S.__staleWhileFetching : (S.__returned = S)
          );
        }
        let z = this.#g(p);
        if (!b && !z)
          return (
            l && (l.fetch = 'hit'),
            this.#R(p),
            s && this.#v(p),
            l && this.#T(l, p),
            S
          );
        let F = this.#I(t, p, m, d),
          O = F.__staleWhileFetching !== void 0 && i;
        return (
          l &&
            ((l.fetch = z ? 'stale' : 'refresh'),
            O && z && (l.returnedStale = !0)),
          O ? F.__staleWhileFetching : (F.__returned = F)
        );
      }
    }
    async forceFetch(t, e = {}) {
      let i = await this.fetch(t, e);
      if (i === void 0) throw new Error('fetch() returned undefined');
      return i;
    }
    memo(t, e = {}) {
      let i = this.#D;
      if (!i) throw new Error('no memoMethod provided to constructor');
      let { context: s, forceRefresh: n, ...h } = e,
        o = this.get(t, h);
      if (!n && o !== void 0) return o;
      let r = i(t, o, { options: h, context: s });
      return this.set(t, r, h), r;
    }
    get(t, e = {}) {
      let {
          allowStale: i = this.allowStale,
          updateAgeOnGet: s = this.updateAgeOnGet,
          noDeleteOnStaleGet: n = this.noDeleteOnStaleGet,
          status: h,
        } = e,
        o = this.#s.get(t);
      if (o !== void 0) {
        let r = this.#t[o],
          g = this.#e(r);
        return (
          h && this.#T(h, o),
          this.#g(o) ?
            (h && (h.get = 'stale'),
            g ?
              (h &&
                i &&
                r.__staleWhileFetching !== void 0 &&
                (h.returnedStale = !0),
              i ? r.__staleWhileFetching : void 0)
            : (n || this.#O(t, 'expire'),
              h && i && (h.returnedStale = !0),
              i ? r : void 0))
          : (h && (h.get = 'hit'),
            g ? r.__staleWhileFetching : (this.#R(o), s && this.#v(o), r))
        );
      } else h && (h.get = 'miss');
    }
    #P(t, e) {
      (this.#u[e] = t), (this.#a[t] = e);
    }
    #R(t) {
      t !== this.#h &&
        (t === this.#o ?
          (this.#o = this.#a[t])
        : this.#P(this.#u[t], this.#a[t]),
        this.#P(this.#h, t),
        (this.#h = t));
    }
    delete(t) {
      return this.#O(t, 'delete');
    }
    #O(t, e) {
      let i = !1;
      if (this.#n !== 0) {
        let s = this.#s.get(t);
        if (s !== void 0)
          if (((i = !0), this.#n === 1)) this.#H(e);
          else {
            this.#C(s);
            let n = this.#t[s];
            if (
              (this.#e(n) ?
                n.__abortController.abort(new Error('deleted'))
              : (this.#y || this.#f) &&
                (this.#y && this.#p?.(n, t, e),
                this.#f && this.#r?.push([n, t, e])),
              this.#s.delete(t),
              (this.#i[s] = void 0),
              (this.#t[s] = void 0),
              s === this.#h)
            )
              this.#h = this.#u[s];
            else if (s === this.#o) this.#o = this.#a[s];
            else {
              let h = this.#u[s];
              this.#a[h] = this.#a[s];
              let o = this.#a[s];
              this.#u[o] = this.#u[s];
            }
            this.#n--, this.#_.push(s);
          }
      }
      if (this.#f && this.#r?.length) {
        let s = this.#r,
          n;
        for (; (n = s?.shift()); ) this.#w?.(...n);
      }
      return i;
    }
    clear() {
      return this.#H('delete');
    }
    #H(t) {
      for (let e of this.#F({ allowStale: !0 })) {
        let i = this.#t[e];
        if (this.#e(i)) i.__abortController.abort(new Error('deleted'));
        else {
          let s = this.#i[e];
          this.#y && this.#p?.(i, s, t), this.#f && this.#r?.push([i, s, t]);
        }
      }
      if (
        (this.#s.clear(),
        this.#t.fill(void 0),
        this.#i.fill(void 0),
        this.#d && this.#m && (this.#d.fill(0), this.#m.fill(0)),
        this.#b && this.#b.fill(0),
        (this.#o = 0),
        (this.#h = 0),
        (this.#_.length = 0),
        (this.#S = 0),
        (this.#n = 0),
        this.#f && this.#r)
      ) {
        let e = this.#r,
          i;
        for (; (i = e?.shift()); ) this.#w?.(...i);
      }
    }
  };
exports.LRUCache = L;
//# sourceMappingURL=index.min.js.map