semantic-release-lerna 2.18.1 → 2.18.2

package/dist/index.js

@@ -2465,1411 +2465,559 @@ var require_semver2 = __commonJS({
   }
 });
 
-// node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/index.js
-var require_commonjs = __commonJS({
-  "node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/index.js"(exports) {
+// node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/index.min.js
+var require_index_min = __commonJS({
+  "node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/index.min.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.LRUCache = void 0;
-    var defaultPerf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
-    var warned = /* @__PURE__ */ new Set();
-    var PROCESS = typeof process === "object" && !!process ? process : {};
-    var emitWarning = (msg, type2, code, fn) => {
-      typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type2, code, fn) : console.error(`[${code}] ${type2}: ${msg}`);
-    };
-    var AC = globalThis.AbortController;
-    var AS = globalThis.AbortSignal;
-    if (typeof AC === "undefined") {
-      AS = class AbortSignal {
+    var G = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+    var U = /* @__PURE__ */ new Set();
+    var R = typeof process == "object" && process ? process : {};
+    var I = (c3, t, e, i2) => {
+      typeof R.emitWarning == "function" ? R.emitWarning(c3, t, e, i2) : console.error(`[${e}] ${t}: ${c3}`);
+    };
+    var C = globalThis.AbortController;
+    var L = globalThis.AbortSignal;
+    if (typeof C > "u") {
+      L = class {
         onabort;
         _onabort = [];
         reason;
         aborted = false;
-        addEventListener(_, fn) {
-          this._onabort.push(fn);
+        addEventListener(i2, s) {
+          this._onabort.push(s);
         }
-      };
-      AC = class AbortController {
+      }, C = class {
         constructor() {
-          warnACPolyfill();
+          t();
         }
-        signal = new AS();
-        abort(reason) {
-          if (this.signal.aborted)
-            return;
-          this.signal.reason = reason;
-          this.signal.aborted = true;
-          for (const fn of this.signal._onabort) {
-            fn(reason);
+        signal = new L();
+        abort(i2) {
+          if (!this.signal.aborted) {
+            this.signal.reason = i2, this.signal.aborted = true;
+            for (let s of this.signal._onabort) s(i2);
+            this.signal.onabort?.(i2);
           }
-          this.signal.onabort?.(reason);
         }
       };
-      let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
-      const warnACPolyfill = () => {
-        if (!printACPolyfillWarning)
-          return;
-        printACPolyfillWarning = false;
-        emitWarning("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", warnACPolyfill);
+      let c3 = R.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+        c3 && (c3 = false, 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 shouldWarn = (code) => !warned.has(code);
-    var isPosInt = (n2) => n2 && n2 === Math.floor(n2) && n2 > 0 && isFinite(n2);
-    var 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;
-    var ZeroArray = class extends Array {
-      constructor(size) {
-        super(size);
-        this.fill(0);
+    var x = (c3) => !U.has(c3);
+    var y = (c3) => c3 && c3 === Math.floor(c3) && c3 > 0 && isFinite(c3);
+    var M = (c3) => y(c3) ? c3 <= Math.pow(2, 8) ? Uint8Array : c3 <= Math.pow(2, 16) ? Uint16Array : c3 <= Math.pow(2, 32) ? Uint32Array : c3 <= Number.MAX_SAFE_INTEGER ? z : null : null;
+    var z = class extends Array {
+      constructor(t) {
+        super(t), this.fill(0);
       }
     };
-    var Stack = class _Stack {
+    var W = class c3 {
       heap;
       length;
-      // private constructor
-      static #constructing = false;
-      static create(max) {
-        const HeapCls = getUintArray(max);
-        if (!HeapCls)
-          return [];
-        _Stack.#constructing = true;
-        const s = new _Stack(max, HeapCls);
-        _Stack.#constructing = false;
-        return s;
-      }
-      constructor(max, HeapCls) {
-        if (!_Stack.#constructing) {
-          throw new TypeError("instantiate Stack using Stack.create(n)");
-        }
-        this.heap = new HeapCls(max);
-        this.length = 0;
-      }
-      push(n2) {
-        this.heap[this.length++] = n2;
+      static #o = false;
+      static create(t) {
+        let e = M(t);
+        if (!e) return [];
+        c3.#o = true;
+        let i2 = new c3(t, e);
+        return c3.#o = false, i2;
+      }
+      constructor(t, e) {
+        if (!c3.#o) 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];
       }
     };
-    var LRUCache = class _LRUCache {
-      // options that cannot be changed without disaster
-      #max;
-      #maxSize;
-      #dispose;
-      #onInsert;
-      #disposeAfter;
-      #fetchMethod;
-      #memoMethod;
-      #perf;
-      /**
-       * {@link LRUCache.OptionsBase.perf}
-       */
+    var D = class c3 {
+      #o;
+      #c;
+      #w;
+      #C;
+      #S;
+      #L;
+      #U;
+      #m;
       get perf() {
-        return this.#perf;
+        return this.#m;
       }
-      /**
-       * {@link LRUCache.OptionsBase.ttl}
-       */
       ttl;
-      /**
-       * {@link LRUCache.OptionsBase.ttlResolution}
-       */
       ttlResolution;
-      /**
-       * {@link LRUCache.OptionsBase.ttlAutopurge}
-       */
       ttlAutopurge;
-      /**
-       * {@link LRUCache.OptionsBase.updateAgeOnGet}
-       */
       updateAgeOnGet;
-      /**
-       * {@link LRUCache.OptionsBase.updateAgeOnHas}
-       */
       updateAgeOnHas;
-      /**
-       * {@link LRUCache.OptionsBase.allowStale}
-       */
       allowStale;
-      /**
-       * {@link LRUCache.OptionsBase.noDisposeOnSet}
-       */
       noDisposeOnSet;
-      /**
-       * {@link LRUCache.OptionsBase.noUpdateTTL}
-       */
       noUpdateTTL;
-      /**
-       * {@link LRUCache.OptionsBase.maxEntrySize}
-       */
       maxEntrySize;
-      /**
-       * {@link LRUCache.OptionsBase.sizeCalculation}
-       */
       sizeCalculation;
-      /**
-       * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
-       */
       noDeleteOnFetchRejection;
-      /**
-       * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
-       */
       noDeleteOnStaleGet;
-      /**
-       * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
-       */
       allowStaleOnFetchAbort;
-      /**
-       * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
-       */
       allowStaleOnFetchRejection;
-      /**
-       * {@link LRUCache.OptionsBase.ignoreFetchAbort}
-       */
       ignoreFetchAbort;
-      // computed properties
-      #size;
-      #calculatedSize;
-      #keyMap;
-      #keyList;
-      #valList;
-      #next;
-      #prev;
-      #head;
-      #tail;
-      #free;
-      #disposed;
-      #sizes;
-      #starts;
-      #ttls;
-      #hasDispose;
-      #hasFetchMethod;
-      #hasDisposeAfter;
-      #hasOnInsert;
-      /**
-       * Do not call this method unless you need to inspect the
-       * inner workings of the cache.  If anything returned by this
-       * object is modified in any way, strange breakage may occur.
-       *
-       * These fields are private for a reason!
-       *
-       * @internal
-       */
-      static unsafeExposeInternals(c3) {
-        return {
-          // properties
-          starts: c3.#starts,
-          ttls: c3.#ttls,
-          sizes: c3.#sizes,
-          keyMap: c3.#keyMap,
-          keyList: c3.#keyList,
-          valList: c3.#valList,
-          next: c3.#next,
-          prev: c3.#prev,
-          get head() {
-            return c3.#head;
-          },
-          get tail() {
-            return c3.#tail;
-          },
-          free: c3.#free,
-          // methods
-          isBackgroundFetch: (p) => c3.#isBackgroundFetch(p),
-          backgroundFetch: (k, index, options, context) => c3.#backgroundFetch(k, index, options, context),
-          moveToTail: (index) => c3.#moveToTail(index),
-          indexes: (options) => c3.#indexes(options),
-          rindexes: (options) => c3.#rindexes(options),
-          isStale: (index) => c3.#isStale(index)
-        };
+      #n;
+      #_;
+      #s;
+      #i;
+      #t;
+      #a;
+      #u;
+      #l;
+      #h;
+      #b;
+      #r;
+      #y;
+      #A;
+      #d;
+      #g;
+      #T;
+      #v;
+      #f;
+      #I;
+      static unsafeExposeInternals(t) {
+        return { starts: t.#A, ttls: t.#d, autopurgeTimers: t.#g, sizes: t.#y, keyMap: t.#s, keyList: t.#i, valList: t.#t, next: t.#a, prev: t.#u, get head() {
+          return t.#l;
+        }, get tail() {
+          return t.#h;
+        }, free: t.#b, isBackgroundFetch: (e) => t.#e(e), backgroundFetch: (e, i2, s, n2) => t.#x(e, i2, s, n2), moveToTail: (e) => t.#D(e), indexes: (e) => t.#F(e), rindexes: (e) => t.#O(e), isStale: (e) => t.#p(e) };
       }
-      // Protected read-only members
-      /**
-       * {@link LRUCache.OptionsBase.max} (read-only)
-       */
       get max() {
-        return this.#max;
+        return this.#o;
       }
-      /**
-       * {@link LRUCache.OptionsBase.maxSize} (read-only)
-       */
       get maxSize() {
-        return this.#maxSize;
+        return this.#c;
       }
-      /**
-       * The total computed size of items in the cache (read-only)
-       */
       get calculatedSize() {
-        return this.#calculatedSize;
+        return this.#_;
       }
-      /**
-       * The number of items stored in the cache (read-only)
-       */
       get size() {
-        return this.#size;
+        return this.#n;
       }
-      /**
-       * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
-       */
       get fetchMethod() {
-        return this.#fetchMethod;
+        return this.#L;
       }
       get memoMethod() {
-        return this.#memoMethod;
+        return this.#U;
       }
-      /**
-       * {@link LRUCache.OptionsBase.dispose} (read-only)
-       */
       get dispose() {
-        return this.#dispose;
+        return this.#w;
       }
-      /**
-       * {@link LRUCache.OptionsBase.onInsert} (read-only)
-       */
       get onInsert() {
-        return this.#onInsert;
+        return this.#C;
       }
-      /**
-       * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
-       */
       get disposeAfter() {
-        return this.#disposeAfter;
-      }
-      constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, perf } = options;
-        if (perf !== void 0) {
-          if (typeof perf?.now !== "function") {
-            throw new TypeError("perf option must have a now() method if specified");
-          }
-        }
-        this.#perf = perf ?? defaultPerf;
-        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;
-        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");
-          }
-        }
-        if (memoMethod !== void 0 && typeof memoMethod !== "function") {
-          throw new TypeError("memoMethod must be a function if defined");
-        }
-        this.#memoMethod = memoMethod;
-        if (fetchMethod !== void 0 && typeof fetchMethod !== "function") {
-          throw new TypeError("fetchMethod must be a function if specified");
-        }
-        this.#fetchMethod = fetchMethod;
-        this.#hasFetchMethod = !!fetchMethod;
-        this.#keyMap = /* @__PURE__ */ new Map();
-        this.#keyList = new Array(max).fill(void 0);
-        this.#valList = new Array(max).fill(void 0);
-        this.#next = new UintArray(max);
-        this.#prev = new UintArray(max);
-        this.#head = 0;
-        this.#tail = 0;
-        this.#free = Stack.create(max);
-        this.#size = 0;
-        this.#calculatedSize = 0;
-        if (typeof dispose === "function") {
-          this.#dispose = dispose;
-        }
-        if (typeof onInsert === "function") {
-          this.#onInsert = onInsert;
-        }
-        if (typeof disposeAfter === "function") {
-          this.#disposeAfter = disposeAfter;
-          this.#disposed = [];
-        } else {
-          this.#disposeAfter = void 0;
-          this.#disposed = void 0;
-        }
-        this.#hasDispose = !!this.#dispose;
-        this.#hasOnInsert = !!this.#onInsert;
-        this.#hasDisposeAfter = !!this.#disposeAfter;
-        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;
-        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
-        this.updateAgeOnGet = !!updateAgeOnGet;
-        this.updateAgeOnHas = !!updateAgeOnHas;
-        this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
-        this.ttlAutopurge = !!ttlAutopurge;
-        this.ttl = ttl || 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);
-          }
-        }
-      }
-      /**
-       * Return the number of ms left in the item's TTL. If item is not in cache,
-       * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
-       */
-      getRemainingTTL(key) {
-        return this.#keyMap.has(key) ? Infinity : 0;
-      }
-      #initializeTTLTracking() {
-        const ttls = new ZeroArray(this.#max);
-        const starts = new ZeroArray(this.#max);
-        this.#ttls = ttls;
-        this.#starts = starts;
-        this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
-          starts[index] = ttl !== 0 ? start : 0;
-          ttls[index] = ttl;
-          if (ttl !== 0 && this.ttlAutopurge) {
-            const t = setTimeout(() => {
-              if (this.#isStale(index)) {
-                this.#delete(this.#keyList[index], "expire");
-              }
-            }, ttl + 1);
-            if (t.unref) {
-              t.unref();
-            }
-          }
+        return this.#S;
+      }
+      constructor(t) {
+        let { max: e = 0, ttl: i2, ttlResolution: s = 1, ttlAutopurge: n2, updateAgeOnGet: o2, updateAgeOnHas: h2, allowStale: r, dispose: a2, onInsert: w, disposeAfter: f, noDisposeOnSet: d, noUpdateTTL: g, maxSize: A = 0, maxEntrySize: p = 0, sizeCalculation: _, fetchMethod: l, memoMethod: S, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: m, allowStaleOnFetchRejection: u2, allowStaleOnFetchAbort: T, ignoreFetchAbort: F, perf: v } = t;
+        if (v !== void 0 && typeof v?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+        if (this.#m = v ?? G, e !== 0 && !y(e)) throw new TypeError("max option must be a nonnegative integer");
+        let O = e ? M(e) : Array;
+        if (!O) throw new Error("invalid max value: " + e);
+        if (this.#o = e, this.#c = A, this.maxEntrySize = p || this.#c, this.sizeCalculation = _, 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 (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
+        if (this.#U = S, l !== void 0 && typeof l != "function") throw new TypeError("fetchMethod must be a function if specified");
+        if (this.#L = l, this.#v = !!l, this.#s = /* @__PURE__ */ new Map(), this.#i = new Array(e).fill(void 0), this.#t = new Array(e).fill(void 0), this.#a = new O(e), this.#u = new O(e), this.#l = 0, this.#h = 0, this.#b = W.create(e), this.#n = 0, this.#_ = 0, typeof a2 == "function" && (this.#w = a2), typeof w == "function" && (this.#C = w), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#w, this.#I = !!this.#C, this.#f = !!this.#S, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!g, this.noDeleteOnFetchRejection = !!b, this.allowStaleOnFetchRejection = !!u2, this.allowStaleOnFetchAbort = !!T, 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.#B();
+        }
+        if (this.allowStale = !!r, this.noDeleteOnStaleGet = !!m, this.updateAgeOnGet = !!o2, this.updateAgeOnHas = !!h2, this.ttlResolution = y(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n2, this.ttl = i2 || 0, this.ttl) {
+          if (!y(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+          this.#j();
+        }
+        if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+        if (!this.ttlAutopurge && !this.#o && !this.#c) {
+          let E = "LRU_CACHE_UNBOUNDED";
+          x(E) && (U.add(E), I("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, c3));
+        }
+      }
+      getRemainingTTL(t) {
+        return this.#s.has(t) ? 1 / 0 : 0;
+      }
+      #j() {
+        let t = new z(this.#o), e = new z(this.#o);
+        this.#d = t, this.#A = e;
+        let i2 = this.ttlAutopurge ? new Array(this.#o) : void 0;
+        this.#g = i2, this.#N = (h2, r, a2 = this.#m.now()) => {
+          e[h2] = r !== 0 ? a2 : 0, t[h2] = r, s(h2, r);
+        }, this.#R = (h2) => {
+          e[h2] = t[h2] !== 0 ? this.#m.now() : 0, s(h2, t[h2]);
         };
-        this.#updateItemAge = (index) => {
-          starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0;
+        let s = this.ttlAutopurge ? (h2, r) => {
+          if (i2?.[h2] && (clearTimeout(i2[h2]), i2[h2] = void 0), r && r !== 0 && i2) {
+            let a2 = setTimeout(() => {
+              this.#p(h2) && this.#E(this.#i[h2], "expire");
+            }, r + 1);
+            a2.unref && a2.unref(), i2[h2] = a2;
+          }
+        } : () => {
         };
-        this.#statusTTL = (status, index) => {
-          if (ttls[index]) {
-            const ttl = ttls[index];
-            const start = starts[index];
-            if (!ttl || !start)
-              return;
-            status.ttl = ttl;
-            status.start = start;
-            status.now = cachedNow || getNow();
-            const age = status.now - start;
-            status.remainingTTL = ttl - age;
+        this.#z = (h2, r) => {
+          if (t[r]) {
+            let a2 = t[r], w = e[r];
+            if (!a2 || !w) return;
+            h2.ttl = a2, h2.start = w, h2.now = n2 || o2();
+            let f = h2.now - w;
+            h2.remainingTTL = a2 - f;
           }
         };
-        let cachedNow = 0;
-        const getNow = () => {
-          const n2 = this.#perf.now();
+        let n2 = 0, o2 = () => {
+          let h2 = this.#m.now();
           if (this.ttlResolution > 0) {
-            cachedNow = n2;
-            const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
-            if (t.unref) {
-              t.unref();
-            }
-          }
-          return n2;
-        };
-        this.getRemainingTTL = (key) => {
-          const index = this.#keyMap.get(key);
-          if (index === void 0) {
-            return 0;
+            n2 = h2;
+            let r = setTimeout(() => n2 = 0, this.ttlResolution);
+            r.unref && r.unref();
           }
-          const ttl = ttls[index];
-          const start = starts[index];
-          if (!ttl || !start) {
-            return Infinity;
-          }
-          const age = (cachedNow || getNow()) - start;
-          return ttl - age;
+          return h2;
         };
-        this.#isStale = (index) => {
-          const s = starts[index];
-          const t = ttls[index];
-          return !!t && !!s && (cachedNow || getNow()) - s > t;
+        this.getRemainingTTL = (h2) => {
+          let r = this.#s.get(h2);
+          if (r === void 0) return 0;
+          let a2 = t[r], w = e[r];
+          if (!a2 || !w) return 1 / 0;
+          let f = (n2 || o2()) - w;
+          return a2 - f;
+        }, this.#p = (h2) => {
+          let r = e[h2], a2 = t[h2];
+          return !!a2 && !!r && (n2 || o2()) - r > a2;
         };
       }
-      // conditionally set private methods related to TTL
-      #updateItemAge = () => {
+      #R = () => {
       };
-      #statusTTL = () => {
+      #z = () => {
       };
-      #setItemTTL = () => {
+      #N = () => {
       };
-      /* c8 ignore stop */
-      #isStale = () => false;
-      #initializeSizeTracking() {
-        const sizes = new ZeroArray(this.#max);
-        this.#calculatedSize = 0;
-        this.#sizes = sizes;
-        this.#removeItemSize = (index) => {
-          this.#calculatedSize -= sizes[index];
-          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) => {
-          sizes[index] = size;
-          if (this.#maxSize) {
-            const maxSize = this.#maxSize - sizes[index];
-            while (this.#calculatedSize > maxSize) {
-              this.#evict(true);
-            }
-          }
-          this.#calculatedSize += sizes[index];
-          if (status) {
-            status.entrySize = size;
-            status.totalCalculatedSize = this.#calculatedSize;
-          }
+      #p = () => false;
+      #B() {
+        let t = new z(this.#o);
+        this.#_ = 0, this.#y = t, this.#W = (e) => {
+          this.#_ -= t[e], t[e] = 0;
+        }, this.#P = (e, i2, s, n2) => {
+          if (this.#e(i2)) return 0;
+          if (!y(s)) if (n2) {
+            if (typeof n2 != "function") throw new TypeError("sizeCalculation must be a function");
+            if (s = n2(i2, 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.#M = (e, i2, s) => {
+          if (t[e] = i2, this.#c) {
+            let n2 = this.#c - t[e];
+            for (; this.#_ > n2; ) this.#G(true);
+          }
+          this.#_ += t[e], s && (s.entrySize = i2, s.totalCalculatedSize = this.#_);
         };
       }
-      #removeItemSize = (_i) => {
+      #W = (t) => {
       };
-      #addItemSize = (_i, _s, _st) => {
+      #M = (t, e, i2) => {
       };
-      #requireSize = (_k, _v, size, sizeCalculation) => {
-        if (size || sizeCalculation) {
-          throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
-        }
+      #P = (t, e, i2, s) => {
+        if (i2 || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
         return 0;
       };
-      *#indexes({ allowStale = this.allowStale } = {}) {
-        if (this.#size) {
-          for (let i2 = this.#tail; true; ) {
-            if (!this.#isValidIndex(i2)) {
-              break;
-            }
-            if (allowStale || !this.#isStale(i2)) {
-              yield i2;
-            }
-            if (i2 === this.#head) {
-              break;
-            } else {
-              i2 = this.#prev[i2];
-            }
-          }
-        }
+      *#F({ allowStale: t = this.allowStale } = {}) {
+        if (this.#n) for (let e = this.#h; !(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#l)); ) e = this.#u[e];
       }
-      *#rindexes({ allowStale = this.allowStale } = {}) {
-        if (this.#size) {
-          for (let i2 = this.#head; true; ) {
-            if (!this.#isValidIndex(i2)) {
-              break;
-            }
-            if (allowStale || !this.#isStale(i2)) {
-              yield i2;
-            }
-            if (i2 === this.#tail) {
-              break;
-            } else {
-              i2 = this.#next[i2];
-            }
-          }
-        }
+      *#O({ allowStale: t = this.allowStale } = {}) {
+        if (this.#n) for (let e = this.#l; !(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#h)); ) e = this.#a[e];
       }
-      #isValidIndex(index) {
-        return index !== void 0 && this.#keyMap.get(this.#keyList[index]) === index;
+      #H(t) {
+        return t !== void 0 && this.#s.get(this.#i[t]) === t;
       }
-      /**
-       * Return a generator yielding `[key, value]` pairs,
-       * in order from most recently used to least recently used.
-       */
       *entries() {
-        for (const i2 of this.#indexes()) {
-          if (this.#valList[i2] !== void 0 && this.#keyList[i2] !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
-            yield [this.#keyList[i2], this.#valList[i2]];
-          }
-        }
+        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]]);
       }
-      /**
-       * Inverse order version of {@link LRUCache.entries}
-       *
-       * Return a generator yielding `[key, value]` pairs,
-       * in order from least recently used to most recently used.
-       */
       *rentries() {
-        for (const i2 of this.#rindexes()) {
-          if (this.#valList[i2] !== void 0 && this.#keyList[i2] !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
-            yield [this.#keyList[i2], this.#valList[i2]];
-          }
-        }
+        for (let t of this.#O()) this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
       }
-      /**
-       * Return a generator yielding the keys in the cache,
-       * in order from most recently used to least recently used.
-       */
       *keys() {
-        for (const i2 of this.#indexes()) {
-          const k = this.#keyList[i2];
-          if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
-            yield k;
-          }
+        for (let t of this.#F()) {
+          let e = this.#i[t];
+          e !== void 0 && !this.#e(this.#t[t]) && (yield e);
         }
       }
-      /**
-       * Inverse order version of {@link LRUCache.keys}
-       *
-       * Return a generator yielding the keys in the cache,
-       * in order from least recently used to most recently used.
-       */
       *rkeys() {
-        for (const i2 of this.#rindexes()) {
-          const k = this.#keyList[i2];
-          if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
-            yield k;
-          }
+        for (let t of this.#O()) {
+          let e = this.#i[t];
+          e !== void 0 && !this.#e(this.#t[t]) && (yield e);
         }
       }
-      /**
-       * Return a generator yielding the values in the cache,
-       * in order from most recently used to least recently used.
-       */
       *values() {
-        for (const i2 of this.#indexes()) {
-          const v = this.#valList[i2];
-          if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
-            yield this.#valList[i2];
-          }
-        }
+        for (let t of this.#F()) this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
       }
-      /**
-       * Inverse order version of {@link LRUCache.values}
-       *
-       * Return a generator yielding the values in the cache,
-       * in order from least recently used to most recently used.
-       */
       *rvalues() {
-        for (const i2 of this.#rindexes()) {
-          const v = this.#valList[i2];
-          if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
-            yield this.#valList[i2];
-          }
-        }
+        for (let t of this.#O()) this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
       }
-      /**
-       * Iterating over the cache itself yields the same results as
-       * {@link LRUCache.entries}
-       */
       [Symbol.iterator]() {
         return this.entries();
       }
-      /**
-       * A String value that is used in the creation of the default string
-       * description of an object. Called by the built-in method
-       * `Object.prototype.toString`.
-       */
       [Symbol.toStringTag] = "LRUCache";
-      /**
-       * Find a value for which the supplied fn method returns a truthy value,
-       * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
-       */
-      find(fn, getOptions = {}) {
-        for (const i2 of this.#indexes()) {
-          const v = this.#valList[i2];
-          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-          if (value === void 0)
-            continue;
-          if (fn(value, this.#keyList[i2], this)) {
-            return this.get(this.#keyList[i2], getOptions);
-          }
+      find(t, e = {}) {
+        for (let i2 of this.#F()) {
+          let s = this.#t[i2], n2 = this.#e(s) ? s.__staleWhileFetching : s;
+          if (n2 !== void 0 && t(n2, this.#i[i2], this)) return this.get(this.#i[i2], e);
         }
       }
-      /**
-       * Call the supplied function on each item in the cache, in order from most
-       * recently used to least recently used.
-       *
-       * `fn` is called as `fn(value, key, cache)`.
-       *
-       * If `thisp` is provided, function will be called in the `this`-context of
-       * the provided object, or the cache if no `thisp` object is provided.
-       *
-       * Does not update age or recenty of use, or iterate over stale values.
-       */
-      forEach(fn, thisp = this) {
-        for (const i2 of this.#indexes()) {
-          const v = this.#valList[i2];
-          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-          if (value === void 0)
-            continue;
-          fn.call(thisp, value, this.#keyList[i2], this);
+      forEach(t, e = this) {
+        for (let i2 of this.#F()) {
+          let s = this.#t[i2], n2 = this.#e(s) ? s.__staleWhileFetching : s;
+          n2 !== void 0 && t.call(e, n2, this.#i[i2], this);
         }
       }
-      /**
-       * The same as {@link LRUCache.forEach} but items are iterated over in
-       * reverse order.  (ie, less recently used items are iterated over first.)
-       */
-      rforEach(fn, thisp = this) {
-        for (const i2 of this.#rindexes()) {
-          const v = this.#valList[i2];
-          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-          if (value === void 0)
-            continue;
-          fn.call(thisp, value, this.#keyList[i2], this);
+      rforEach(t, e = this) {
+        for (let i2 of this.#O()) {
+          let s = this.#t[i2], n2 = this.#e(s) ? s.__staleWhileFetching : s;
+          n2 !== void 0 && t.call(e, n2, this.#i[i2], this);
         }
       }
-      /**
-       * Delete any stale entries. Returns true if anything was removed,
-       * false otherwise.
-       */
       purgeStale() {
-        let deleted = false;
-        for (const i2 of this.#rindexes({ allowStale: true })) {
-          if (this.#isStale(i2)) {
-            this.#delete(this.#keyList[i2], "expire");
-            deleted = true;
-          }
-        }
-        return deleted;
+        let t = false;
+        for (let e of this.#O({ allowStale: true })) this.#p(e) && (this.#E(this.#i[e], "expire"), t = true);
+        return t;
       }
-      /**
-       * Get the extended info about a given entry, to get its value, size, and
-       * TTL info simultaneously. Returns `undefined` if the key is not present.
-       *
-       * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
-       * serialization, the `start` value is always the current timestamp, and the
-       * `ttl` is a calculated remaining time to live (negative if expired).
-       *
-       * Always returns stale values, if their info is found in the cache, so be
-       * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
-       * if relevant.
-       */
-      info(key) {
-        const i2 = this.#keyMap.get(key);
-        if (i2 === void 0)
-          return void 0;
-        const v = this.#valList[i2];
-        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-        if (value === void 0)
-          return void 0;
-        const entry = { value };
-        if (this.#ttls && this.#starts) {
-          const ttl = this.#ttls[i2];
-          const start = this.#starts[i2];
-          if (ttl && start) {
-            const remain = ttl - (this.#perf.now() - start);
-            entry.ttl = remain;
-            entry.start = Date.now();
+      info(t) {
+        let e = this.#s.get(t);
+        if (e === void 0) return;
+        let i2 = this.#t[e], s = this.#e(i2) ? i2.__staleWhileFetching : i2;
+        if (s === void 0) return;
+        let n2 = { value: s };
+        if (this.#d && this.#A) {
+          let o2 = this.#d[e], h2 = this.#A[e];
+          if (o2 && h2) {
+            let r = o2 - (this.#m.now() - h2);
+            n2.ttl = r, n2.start = Date.now();
           }
         }
-        if (this.#sizes) {
-          entry.size = this.#sizes[i2];
-        }
-        return entry;
+        return this.#y && (n2.size = this.#y[e]), n2;
       }
-      /**
-       * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-       * passed to {@link LRUCache#load}.
-       *
-       * The `start` fields are calculated relative to a portable `Date.now()`
-       * timestamp, even if `performance.now()` is available.
-       *
-       * Stale entries are always included in the `dump`, even if
-       * {@link LRUCache.OptionsBase.allowStale} is false.
-       *
-       * Note: this returns an actual array, not a generator, so it can be more
-       * easily passed around.
-       */
       dump() {
-        const arr = [];
-        for (const i2 of this.#indexes({ allowStale: true })) {
-          const key = this.#keyList[i2];
-          const v = this.#valList[i2];
-          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-          if (value === void 0 || key === void 0)
-            continue;
-          const entry = { value };
-          if (this.#ttls && this.#starts) {
-            entry.ttl = this.#ttls[i2];
-            const age = this.#perf.now() - this.#starts[i2];
-            entry.start = Math.floor(Date.now() - age);
-          }
-          if (this.#sizes) {
-            entry.size = this.#sizes[i2];
+        let t = [];
+        for (let e of this.#F({ allowStale: true })) {
+          let i2 = this.#i[e], s = this.#t[e], n2 = this.#e(s) ? s.__staleWhileFetching : s;
+          if (n2 === void 0 || i2 === void 0) continue;
+          let o2 = { value: n2 };
+          if (this.#d && this.#A) {
+            o2.ttl = this.#d[e];
+            let h2 = this.#m.now() - this.#A[e];
+            o2.start = Math.floor(Date.now() - h2);
           }
-          arr.unshift([key, entry]);
+          this.#y && (o2.size = this.#y[e]), t.unshift([i2, o2]);
         }
-        return arr;
+        return t;
       }
-      /**
-       * Reset the cache and load in the items in entries in the order listed.
-       *
-       * The shape of the resulting cache may be different if the same options are
-       * not used in both caches.
-       *
-       * The `start` fields are assumed to be calculated relative to a portable
-       * `Date.now()` timestamp, even if `performance.now()` is available.
-       */
-      load(arr) {
+      load(t) {
         this.clear();
-        for (const [key, entry] of arr) {
-          if (entry.start) {
-            const age = Date.now() - entry.start;
-            entry.start = this.#perf.now() - age;
-          }
-          this.set(key, entry.value, entry);
-        }
-      }
-      /**
-       * Add a value to the cache.
-       *
-       * Note: if `undefined` is specified as a value, this is an alias for
-       * {@link LRUCache#delete}
-       *
-       * Fields on the {@link LRUCache.SetOptions} options param will override
-       * their corresponding values in the constructor options for the scope
-       * of this single `set()` operation.
-       *
-       * If `start` is provided, then that will set the effective start
-       * time for the TTL calculation. Note that this must be a previous
-       * value of `performance.now()` if supported, or a previous value of
-       * `Date.now()` if not.
-       *
-       * Options object may also include `size`, which will prevent
-       * calling the `sizeCalculation` function and just use the specified
-       * number if it is a positive integer, and `noDisposeOnSet` which
-       * will prevent calling a `dispose` function in the case of
-       * overwrites.
-       *
-       * If the `size` (or return value of `sizeCalculation`) for a given
-       * entry is greater than `maxEntrySize`, then the item will not be
-       * added to the cache.
-       *
-       * Will update the recency of the entry.
-       *
-       * If the value is `undefined`, then this is an alias for
-       * `cache.delete(key)`. `undefined` is never stored in the cache.
-       */
-      set(k, v, setOptions = {}) {
-        if (v === void 0) {
-          this.delete(k);
-          return this;
-        }
-        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
-        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
-        if (this.maxEntrySize && size > this.maxEntrySize) {
-          if (status) {
-            status.set = "miss";
-            status.maxEntrySizeExceeded = true;
-          }
-          this.#delete(k, "set");
-          return this;
-        }
-        let index = this.#size === 0 ? void 0 : this.#keyMap.get(k);
-        if (index === void 0) {
-          index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
-          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;
-          if (this.#hasOnInsert) {
-            this.#onInsert?.(v, k, "add");
-          }
-        } else {
-          this.#moveToTail(index);
-          const oldVal = this.#valList[index];
-          if (v !== oldVal) {
-            if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-              oldVal.__abortController.abort(new Error("replaced"));
-              const { __staleWhileFetching: s } = oldVal;
-              if (s !== void 0 && !noDisposeOnSet) {
-                if (this.#hasDispose) {
-                  this.#dispose?.(s, k, "set");
-                }
-                if (this.#hasDisposeAfter) {
-                  this.#disposed?.push([s, k, "set"]);
-                }
-              }
-            } else if (!noDisposeOnSet) {
-              if (this.#hasDispose) {
-                this.#dispose?.(oldVal, k, "set");
-              }
-              if (this.#hasDisposeAfter) {
-                this.#disposed?.push([oldVal, k, "set"]);
-              }
-            }
-            this.#removeItemSize(index);
-            this.#addItemSize(index, size, status);
-            this.#valList[index] = v;
-            if (status) {
-              status.set = "replace";
-              const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
-              if (oldValue !== void 0)
-                status.oldValue = oldValue;
+        for (let [e, i2] of t) {
+          if (i2.start) {
+            let s = Date.now() - i2.start;
+            i2.start = this.#m.now() - s;
+          }
+          this.set(e, i2.value, i2);
+        }
+      }
+      set(t, e, i2 = {}) {
+        if (e === void 0) return this.delete(t), this;
+        let { ttl: s = this.ttl, start: n2, noDisposeOnSet: o2 = this.noDisposeOnSet, sizeCalculation: h2 = this.sizeCalculation, status: r } = i2, { noUpdateTTL: a2 = this.noUpdateTTL } = i2, w = this.#P(t, e, i2.size || 0, h2);
+        if (this.maxEntrySize && w > this.maxEntrySize) return r && (r.set = "miss", r.maxEntrySizeExceeded = true), this.#E(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.#b.length !== 0 ? this.#b.pop() : this.#n === this.#o ? this.#G(false) : 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.#M(f, w, r), r && (r.set = "add"), a2 = false, this.#I && this.#C?.(e, t, "add");
+        else {
+          this.#D(f);
+          let d = this.#t[f];
+          if (e !== d) {
+            if (this.#v && this.#e(d)) {
+              d.__abortController.abort(new Error("replaced"));
+              let { __staleWhileFetching: g } = d;
+              g !== void 0 && !o2 && (this.#T && this.#w?.(g, t, "set"), this.#f && this.#r?.push([g, t, "set"]));
+            } else o2 || (this.#T && this.#w?.(d, t, "set"), this.#f && this.#r?.push([d, t, "set"]));
+            if (this.#W(f), this.#M(f, w, r), this.#t[f] = e, r) {
+              r.set = "replace";
+              let g = d && this.#e(d) ? d.__staleWhileFetching : d;
+              g !== void 0 && (r.oldValue = g);
             }
-          } else if (status) {
-            status.set = "update";
-          }
-          if (this.#hasOnInsert) {
-            this.onInsert?.(v, k, v === oldVal ? "update" : "replace");
-          }
-        }
-        if (ttl !== 0 && !this.#ttls) {
-          this.#initializeTTLTracking();
-        }
-        if (this.#ttls) {
-          if (!noUpdateTTL) {
-            this.#setItemTTL(index, ttl, start);
-          }
-          if (status)
-            this.#statusTTL(status, index);
+          } else r && (r.set = "update");
+          this.#I && this.onInsert?.(e, t, e === d ? "update" : "replace");
         }
-        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
-          const dt = this.#disposed;
-          let task;
-          while (task = dt?.shift()) {
-            this.#disposeAfter?.(...task);
-          }
+        if (s !== 0 && !this.#d && this.#j(), this.#d && (a2 || this.#N(f, s, n2), r && this.#z(r, f)), !o2 && this.#f && this.#r) {
+          let d = this.#r, g;
+          for (; g = d?.shift(); ) this.#S?.(...g);
         }
         return this;
       }
-      /**
-       * Evict the least recently used item, returning its value or
-       * `undefined` if cache is empty.
-       */
       pop() {
         try {
-          while (this.#size) {
-            const val = this.#valList[this.#head];
-            this.#evict(true);
-            if (this.#isBackgroundFetch(val)) {
-              if (val.__staleWhileFetching) {
-                return val.__staleWhileFetching;
-              }
-            } else if (val !== void 0) {
-              return val;
-            }
+          for (; this.#n; ) {
+            let t = this.#t[this.#l];
+            if (this.#G(true), this.#e(t)) {
+              if (t.__staleWhileFetching) return t.__staleWhileFetching;
+            } else if (t !== void 0) return t;
           }
         } finally {
-          if (this.#hasDisposeAfter && this.#disposed) {
-            const dt = this.#disposed;
-            let task;
-            while (task = dt?.shift()) {
-              this.#disposeAfter?.(...task);
-            }
+          if (this.#f && this.#r) {
+            let t = this.#r, e;
+            for (; e = t?.shift(); ) this.#S?.(...e);
           }
         }
       }
-      #evict(free) {
-        const head2 = this.#head;
-        const k = this.#keyList[head2];
-        const v = this.#valList[head2];
-        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
-          v.__abortController.abort(new Error("evicted"));
-        } else if (this.#hasDispose || this.#hasDisposeAfter) {
-          if (this.#hasDispose) {
-            this.#dispose?.(v, k, "evict");
-          }
-          if (this.#hasDisposeAfter) {
-            this.#disposed?.push([v, k, "evict"]);
-          }
-        }
-        this.#removeItemSize(head2);
-        if (free) {
-          this.#keyList[head2] = void 0;
-          this.#valList[head2] = void 0;
-          this.#free.push(head2);
-        }
-        if (this.#size === 1) {
-          this.#head = this.#tail = 0;
-          this.#free.length = 0;
-        } else {
-          this.#head = this.#next[head2];
-        }
-        this.#keyMap.delete(k);
-        this.#size--;
-        return head2;
+      #G(t) {
+        let e = this.#l, i2 = this.#i[e], s = this.#t[e];
+        return this.#v && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#w?.(s, i2, "evict"), this.#f && this.#r?.push([s, i2, "evict"])), this.#W(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = void 0), t && (this.#i[e] = void 0, this.#t[e] = void 0, this.#b.push(e)), this.#n === 1 ? (this.#l = this.#h = 0, this.#b.length = 0) : this.#l = this.#a[e], this.#s.delete(i2), this.#n--, e;
       }
-      /**
-       * Check if a key is in the cache, without updating the recency of use.
-       * Will return false if the item is stale, even though it is technically
-       * in the cache.
-       *
-       * Check if a key is in the cache, without updating the recency of
-       * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
-       * to `true` in either the options or the constructor.
-       *
-       * Will return `false` if the item is stale, even though it is technically in
-       * the cache. The difference can be determined (if it matters) by using a
-       * `status` argument, and inspecting the `has` field.
-       *
-       * Will not update item age unless
-       * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
-       */
-      has(k, hasOptions = {}) {
-        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== void 0) {
-          const v = this.#valList[index];
-          if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === void 0) {
-            return false;
-          }
-          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";
-        }
+      has(t, e = {}) {
+        let { updateAgeOnHas: i2 = this.updateAgeOnHas, status: s } = e, n2 = this.#s.get(t);
+        if (n2 !== void 0) {
+          let o2 = this.#t[n2];
+          if (this.#e(o2) && o2.__staleWhileFetching === void 0) return false;
+          if (this.#p(n2)) s && (s.has = "stale", this.#z(s, n2));
+          else return i2 && this.#R(n2), s && (s.has = "hit", this.#z(s, n2)), true;
+        } else s && (s.has = "miss");
         return false;
       }
-      /**
-       * Like {@link LRUCache#get} but doesn't update recency or delete stale
-       * items.
-       *
-       * Returns `undefined` if the item is stale, unless
-       * {@link LRUCache.OptionsBase.allowStale} is set.
-       */
-      peek(k, peekOptions = {}) {
-        const { allowStale = this.allowStale } = peekOptions;
-        const index = this.#keyMap.get(k);
-        if (index === void 0 || !allowStale && this.#isStale(index)) {
-          return;
-        }
-        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();
-        const { signal } = options;
-        signal?.addEventListener("abort", () => ac.abort(signal.reason), {
-          signal: ac.signal
-        });
-        const fetchOpts = {
-          signal: ac.signal,
-          options,
-          context
-        };
-        const cb = (v2, updateCache = false) => {
-          const { aborted: aborted2 } = ac.signal;
-          const ignoreAbort = options.ignoreFetchAbort && v2 !== void 0;
-          if (options.status) {
-            if (aborted2 && !updateCache) {
-              options.status.fetchAborted = true;
-              options.status.fetchError = ac.signal.reason;
-              if (ignoreAbort)
-                options.status.fetchAbortIgnored = true;
-            } else {
-              options.status.fetchResolved = true;
-            }
-          }
-          if (aborted2 && !ignoreAbort && !updateCache) {
-            return fetchFail(ac.signal.reason);
-          }
-          const bf2 = p;
-          const vl = this.#valList[index];
-          if (vl === p || ignoreAbort && updateCache && vl === void 0) {
-            if (v2 === void 0) {
-              if (bf2.__staleWhileFetching !== void 0) {
-                this.#valList[index] = bf2.__staleWhileFetching;
-              } else {
-                this.#delete(k, "fetch");
-              }
-            } 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: aborted2 } = ac.signal;
-          const allowStaleAborted = aborted2 && options.allowStaleOnFetchAbort;
-          const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
-          const noDelete = allowStale || options.noDeleteOnFetchRejection;
-          const bf2 = p;
-          if (this.#valList[index] === p) {
-            const del = !noDelete || bf2.__staleWhileFetching === void 0;
-            if (del) {
-              this.#delete(k, "fetch");
-            } else if (!allowStaleAborted) {
-              this.#valList[index] = bf2.__staleWhileFetching;
-            }
-          }
-          if (allowStale) {
-            if (options.status && bf2.__staleWhileFetching !== void 0) {
-              options.status.returnedStale = true;
-            }
-            return bf2.__staleWhileFetching;
-          } else if (bf2.__returned === bf2) {
-            throw er;
-          }
-        };
-        const pcall = (res, rej) => {
-          const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-          if (fmp && fmp instanceof Promise) {
-            fmp.then((v2) => res(v2 === void 0 ? void 0 : v2), rej);
-          }
-          ac.signal.addEventListener("abort", () => {
-            if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
-              res(void 0);
-              if (options.allowStaleOnFetchAbort) {
-                res = (v2) => cb(v2, true);
-              }
-            }
-          });
-        };
-        if (options.status)
-          options.status.fetchDispatched = true;
-        const p = new Promise(pcall).then(cb, eb);
-        const bf = Object.assign(p, {
-          __abortController: ac,
-          __staleWhileFetching: v,
-          __returned: void 0
-        });
-        if (index === void 0) {
-          this.set(k, bf, { ...fetchOpts.options, status: void 0 });
-          index = this.#keyMap.get(k);
-        } else {
-          this.#valList[index] = bf;
-        }
-        return bf;
-      }
-      #isBackgroundFetch(p) {
-        if (!this.#hasFetchMethod)
-          return false;
-        const b = p;
-        return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC;
-      }
-      async fetch(k, fetchOptions = {}) {
-        const {
-          // 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,
-          context,
-          forceRefresh = false,
-          status,
-          signal
-        } = fetchOptions;
-        if (!this.#hasFetchMethod) {
-          if (status)
-            status.fetch = "get";
-          return this.get(k, {
-            allowStale,
-            updateAgeOnGet,
-            noDeleteOnStaleGet,
-            status
+      peek(t, e = {}) {
+        let { allowStale: i2 = this.allowStale } = e, s = this.#s.get(t);
+        if (s === void 0 || !i2 && this.#p(s)) return;
+        let n2 = this.#t[s];
+        return this.#e(n2) ? n2.__staleWhileFetching : n2;
+      }
+      #x(t, e, i2, s) {
+        let n2 = e === void 0 ? void 0 : this.#t[e];
+        if (this.#e(n2)) return n2;
+        let o2 = new C(), { signal: h2 } = i2;
+        h2?.addEventListener("abort", () => o2.abort(h2.reason), { signal: o2.signal });
+        let r = { signal: o2.signal, options: i2, context: s }, a2 = (p, _ = false) => {
+          let { aborted: l } = o2.signal, S = i2.ignoreFetchAbort && p !== void 0, b = i2.ignoreFetchAbort || !!(i2.allowStaleOnFetchAbort && p !== void 0);
+          if (i2.status && (l && !_ ? (i2.status.fetchAborted = true, i2.status.fetchError = o2.signal.reason, S && (i2.status.fetchAbortIgnored = true)) : i2.status.fetchResolved = true), l && !S && !_) return f(o2.signal.reason, b);
+          let m = g, u2 = this.#t[e];
+          return (u2 === g || S && _ && u2 === void 0) && (p === void 0 ? m.__staleWhileFetching !== void 0 ? this.#t[e] = m.__staleWhileFetching : this.#E(t, "fetch") : (i2.status && (i2.status.fetchUpdated = true), this.set(t, p, r.options))), p;
+        }, w = (p) => (i2.status && (i2.status.fetchRejected = true, i2.status.fetchError = p), f(p, false)), f = (p, _) => {
+          let { aborted: l } = o2.signal, S = l && i2.allowStaleOnFetchAbort, b = S || i2.allowStaleOnFetchRejection, m = b || i2.noDeleteOnFetchRejection, u2 = g;
+          if (this.#t[e] === g && (!m || !_ && u2.__staleWhileFetching === void 0 ? this.#E(t, "fetch") : S || (this.#t[e] = u2.__staleWhileFetching)), b) return i2.status && u2.__staleWhileFetching !== void 0 && (i2.status.returnedStale = true), u2.__staleWhileFetching;
+          if (u2.__returned === u2) throw p;
+        }, d = (p, _) => {
+          let l = this.#L?.(t, n2, r);
+          l && l instanceof Promise && l.then((S) => p(S === void 0 ? void 0 : S), _), o2.signal.addEventListener("abort", () => {
+            (!i2.ignoreFetchAbort || i2.allowStaleOnFetchAbort) && (p(void 0), i2.allowStaleOnFetchAbort && (p = (S) => a2(S, true)));
           });
-        }
-        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, context);
-          return p.__returned = p;
+        i2.status && (i2.status.fetchDispatched = true);
+        let g = new Promise(d).then(a2, w), A = Object.assign(g, { __abortController: o2, __staleWhileFetching: n2, __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.#v) return false;
+        let e = t;
+        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof C;
+      }
+      async fetch(t, e = {}) {
+        let { allowStale: i2 = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n2 = this.noDeleteOnStaleGet, ttl: o2 = this.ttl, noDisposeOnSet: h2 = this.noDisposeOnSet, size: r = 0, sizeCalculation: a2 = this.sizeCalculation, noUpdateTTL: w = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: g = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: p, forceRefresh: _ = false, status: l, signal: S } = e;
+        if (!this.#v) return l && (l.fetch = "get"), this.get(t, { allowStale: i2, updateAgeOnGet: s, noDeleteOnStaleGet: n2, status: l });
+        let b = { allowStale: i2, updateAgeOnGet: s, noDeleteOnStaleGet: n2, ttl: o2, noDisposeOnSet: h2, size: r, sizeCalculation: a2, noUpdateTTL: w, noDeleteOnFetchRejection: f, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: g, status: l, signal: S }, m = this.#s.get(t);
+        if (m === void 0) {
+          l && (l.fetch = "miss");
+          let u2 = this.#x(t, m, b, p);
+          return u2.__returned = u2;
         } 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);
-            }
-            if (status)
-              this.#statusTTL(status, index);
-            return v;
-          }
-          const p = this.#backgroundFetch(k, index, options, context);
-          const hasStale = p.__staleWhileFetching !== void 0;
-          const staleVal = hasStale && allowStale;
-          if (status) {
-            status.fetch = isStale ? "stale" : "refresh";
-            if (staleVal && isStale)
-              status.returnedStale = true;
-          }
-          return staleVal ? p.__staleWhileFetching : p.__returned = p;
-        }
-      }
-      async forceFetch(k, fetchOptions = {}) {
-        const v = await this.fetch(k, fetchOptions);
-        if (v === void 0)
-          throw new Error("fetch() returned undefined");
-        return v;
-      }
-      memo(k, memoOptions = {}) {
-        const memoMethod = this.#memoMethod;
-        if (!memoMethod) {
-          throw new Error("no memoMethod provided to constructor");
-        }
-        const { context, forceRefresh, ...options } = memoOptions;
-        const v = this.get(k, options);
-        if (!forceRefresh && v !== void 0)
-          return v;
-        const vv = memoMethod(k, v, {
-          options,
-          context
-        });
-        this.set(k, vv, options);
-        return vv;
-      }
-      /**
-       * Return a value from the cache. Will update the recency of the cache
-       * entry found.
-       *
-       * If the key is not found, get() will return `undefined`.
-       */
-      get(k, getOptions = {}) {
-        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== void 0) {
-          const value = this.#valList[index];
-          const fetching = this.#isBackgroundFetch(value);
-          if (status)
-            this.#statusTTL(status, index);
-          if (this.#isStale(index)) {
-            if (status)
-              status.get = "stale";
-            if (!fetching) {
-              if (!noDeleteOnStaleGet) {
-                this.#delete(k, "expire");
-              }
-              if (status && allowStale)
-                status.returnedStale = true;
-              return allowStale ? value : void 0;
-            } else {
-              if (status && allowStale && value.__staleWhileFetching !== void 0) {
-                status.returnedStale = true;
-              }
-              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;
+          let u2 = this.#t[m];
+          if (this.#e(u2)) {
+            let E = i2 && u2.__staleWhileFetching !== void 0;
+            return l && (l.fetch = "inflight", E && (l.returnedStale = true)), E ? u2.__staleWhileFetching : u2.__returned = u2;
           }
-        } else if (status) {
-          status.get = "miss";
+          let T = this.#p(m);
+          if (!_ && !T) return l && (l.fetch = "hit"), this.#D(m), s && this.#R(m), l && this.#z(l, m), u2;
+          let F = this.#x(t, m, b, p), O = F.__staleWhileFetching !== void 0 && i2;
+          return l && (l.fetch = T ? "stale" : "refresh", O && T && (l.returnedStale = true)), O ? F.__staleWhileFetching : F.__returned = F;
         }
       }
-      #connect(p, n2) {
-        this.#prev[n2] = p;
-        this.#next[p] = n2;
-      }
-      #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;
-        }
+      async forceFetch(t, e = {}) {
+        let i2 = await this.fetch(t, e);
+        if (i2 === void 0) throw new Error("fetch() returned undefined");
+        return i2;
       }
-      /**
-       * Deletes a key out of the cache.
-       *
-       * Returns true if the key was deleted, false otherwise.
-       */
-      delete(k) {
-        return this.#delete(k, "delete");
-      }
-      #delete(k, reason) {
-        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(reason);
-            } else {
-              this.#removeItemSize(index);
-              const v = this.#valList[index];
-              if (this.#isBackgroundFetch(v)) {
-                v.__abortController.abort(new Error("deleted"));
-              } else if (this.#hasDispose || this.#hasDisposeAfter) {
-                if (this.#hasDispose) {
-                  this.#dispose?.(v, k, reason);
-                }
-                if (this.#hasDisposeAfter) {
-                  this.#disposed?.push([v, k, reason]);
-                }
-              }
-              this.#keyMap.delete(k);
-              this.#keyList[index] = void 0;
-              this.#valList[index] = void 0;
-              if (index === this.#tail) {
-                this.#tail = this.#prev[index];
-              } else if (index === this.#head) {
-                this.#head = this.#next[index];
-              } else {
-                const pi = this.#prev[index];
-                this.#next[pi] = this.#next[index];
-                const ni = this.#next[index];
-                this.#prev[ni] = this.#prev[index];
-              }
-              this.#size--;
-              this.#free.push(index);
+      memo(t, e = {}) {
+        let i2 = this.#U;
+        if (!i2) throw new Error("no memoMethod provided to constructor");
+        let { context: s, forceRefresh: n2, ...o2 } = e, h2 = this.get(t, o2);
+        if (!n2 && h2 !== void 0) return h2;
+        let r = i2(t, h2, { options: o2, context: s });
+        return this.set(t, r, o2), r;
+      }
+      get(t, e = {}) {
+        let { allowStale: i2 = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n2 = this.noDeleteOnStaleGet, status: o2 } = e, h2 = this.#s.get(t);
+        if (h2 !== void 0) {
+          let r = this.#t[h2], a2 = this.#e(r);
+          return o2 && this.#z(o2, h2), this.#p(h2) ? (o2 && (o2.get = "stale"), a2 ? (o2 && i2 && r.__staleWhileFetching !== void 0 && (o2.returnedStale = true), i2 ? r.__staleWhileFetching : void 0) : (n2 || this.#E(t, "expire"), o2 && i2 && (o2.returnedStale = true), i2 ? r : void 0)) : (o2 && (o2.get = "hit"), a2 ? r.__staleWhileFetching : (this.#D(h2), s && this.#R(h2), r));
+        } else o2 && (o2.get = "miss");
+      }
+      #k(t, e) {
+        this.#u[e] = t, this.#a[t] = e;
+      }
+      #D(t) {
+        t !== this.#h && (t === this.#l ? this.#l = this.#a[t] : this.#k(this.#u[t], this.#a[t]), this.#k(this.#h, t), this.#h = t);
+      }
+      delete(t) {
+        return this.#E(t, "delete");
+      }
+      #E(t, e) {
+        let i2 = false;
+        if (this.#n !== 0) {
+          let s = this.#s.get(t);
+          if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i2 = true, this.#n === 1) this.#V(e);
+          else {
+            this.#W(s);
+            let n2 = this.#t[s];
+            if (this.#e(n2) ? n2.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(n2, t, e), this.#f && this.#r?.push([n2, 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.#l) this.#l = this.#a[s];
+            else {
+              let o2 = this.#u[s];
+              this.#a[o2] = this.#a[s];
+              let h2 = this.#a[s];
+              this.#u[h2] = this.#u[s];
             }
+            this.#n--, this.#b.push(s);
           }
         }
-        if (this.#hasDisposeAfter && this.#disposed?.length) {
-          const dt = this.#disposed;
-          let task;
-          while (task = dt?.shift()) {
-            this.#disposeAfter?.(...task);
-          }
+        if (this.#f && this.#r?.length) {
+          let s = this.#r, n2;
+          for (; n2 = s?.shift(); ) this.#S?.(...n2);
         }
-        return deleted;
+        return i2;
       }
-      /**
-       * Clear the cache entirely, throwing away all values.
-       */
       clear() {
-        return this.#clear("delete");
+        return this.#V("delete");
       }
-      #clear(reason) {
-        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];
-            if (this.#hasDispose) {
-              this.#dispose?.(v, k, reason);
-            }
-            if (this.#hasDisposeAfter) {
-              this.#disposed?.push([v, k, reason]);
-            }
+      #V(t) {
+        for (let e of this.#O({ allowStale: true })) {
+          let i2 = this.#t[e];
+          if (this.#e(i2)) i2.__abortController.abort(new Error("deleted"));
+          else {
+            let s = this.#i[e];
+            this.#T && this.#w?.(i2, s, t), this.#f && this.#r?.push([i2, s, t]);
           }
         }
-        this.#keyMap.clear();
-        this.#valList.fill(void 0);
-        this.#keyList.fill(void 0);
-        if (this.#ttls && this.#starts) {
-          this.#ttls.fill(0);
-          this.#starts.fill(0);
+        if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#A) {
+          this.#d.fill(0), this.#A.fill(0);
+          for (let e of this.#g ?? []) e !== void 0 && clearTimeout(e);
+          this.#g?.fill(void 0);
         }
-        if (this.#sizes) {
-          this.#sizes.fill(0);
-        }
-        this.#head = 0;
-        this.#tail = 0;
-        this.#free.length = 0;
-        this.#calculatedSize = 0;
-        this.#size = 0;
-        if (this.#hasDisposeAfter && this.#disposed) {
-          const dt = this.#disposed;
-          let task;
-          while (task = dt?.shift()) {
-            this.#disposeAfter?.(...task);
-          }
+        if (this.#y && this.#y.fill(0), this.#l = 0, this.#h = 0, this.#b.length = 0, this.#_ = 0, this.#n = 0, this.#f && this.#r) {
+          let e = this.#r, i2;
+          for (; i2 = e?.shift(); ) this.#S?.(...i2);
         }
       }
     };
-    exports.LRUCache = LRUCache;
+    exports.LRUCache = D;
   }
 });
 
@@ -4188,7 +3336,7 @@ var require_from_url = __commonJS({
 var require_lib = __commonJS({
   "node_modules/hosted-git-info/lib/index.js"(exports, module) {
     "use strict";
-    var { LRUCache } = require_commonjs();
+    var { LRUCache } = require_index_min();
     var hosts = require_hosts();
     var fromUrl = require_from_url();
     var parseUrl = require_parse_url();
@@ -4361,11 +3509,18 @@ var require_lib = __commonJS({
   }
 });
 
+// node_modules/npm-package-arg/node_modules/validate-npm-package-name/lib/builtin-modules.json
+var require_builtin_modules = __commonJS({
+  "node_modules/npm-package-arg/node_modules/validate-npm-package-name/lib/builtin-modules.json"(exports, module) {
+    module.exports = ["_http_agent", "_http_client", "_http_common", "_http_incoming", "_http_outgoing", "_http_server", "_stream_duplex", "_stream_passthrough", "_stream_readable", "_stream_transform", "_stream_wrap", "_stream_writable", "_tls_common", "_tls_wrap", "assert", "assert/strict", "async_hooks", "buffer", "child_process", "cluster", "console", "constants", "crypto", "dgram", "diagnostics_channel", "dns", "dns/promises", "domain", "events", "fs", "fs/promises", "http", "http2", "https", "inspector", "inspector/promises", "module", "net", "os", "path", "path/posix", "path/win32", "perf_hooks", "process", "punycode", "querystring", "readline", "readline/promises", "repl", "stream", "stream/consumers", "stream/promises", "stream/web", "string_decoder", "sys", "timers", "timers/promises", "tls", "trace_events", "tty", "url", "util", "util/types", "v8", "vm", "wasi", "worker_threads", "zlib", "node:sea", "node:sqlite", "node:test", "node:test/reporters"];
+  }
+});
+
 // node_modules/npm-package-arg/node_modules/validate-npm-package-name/lib/index.js
 var require_lib2 = __commonJS({
   "node_modules/npm-package-arg/node_modules/validate-npm-package-name/lib/index.js"(exports, module) {
     "use strict";
-    var { builtinModules: builtins } = __require("module");
+    var builtins = require_builtin_modules();
     var scopedPackagePattern = new RegExp("^(?:@([^/]+?)[/])?([^/]+?)$");
     var exclusionList = [
       "node_modules",
@@ -4392,6 +3547,9 @@ var require_lib2 = __commonJS({
       if (name.startsWith(".")) {
         errors.push("name cannot start with a period");
       }
+      if (name.startsWith("-")) {
+        errors.push("name cannot start with a hyphen");
+      }
       if (name.match(/^_/)) {
         errors.push("name cannot start with an underscore");
       }
@@ -4577,10 +3735,14 @@ var require_lib3 = __commonJS({
           end: "end",
           read: "read"
         },
-        start: function(fn) {
-          process.emit("input", "start");
+        start: function(...args) {
+          let fn;
+          if (typeof args[0] === "function") {
+            fn = args.shift();
+          }
+          process.emit("input", "start", ...args);
           function end() {
-            return process.emit("input", "end");
+            return process.emit("input", "end", ...args);
           }
           if (typeof fn === "function") {
             const res = fn();
@@ -4592,8 +3754,8 @@ var require_lib3 = __commonJS({
           }
           return end;
         },
-        end: function() {
-          return process.emit("input", "end");
+        end: function(...args) {
+          return process.emit("input", "end", ...args);
         },
         read: function(...args) {
           let resolve2, reject;
@@ -5075,9 +4237,9 @@ var require_path = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
-    var os4 = __require("os");
+    var os5 = __require("os");
     var path26 = __require("path");
-    var IS_WINDOWS_PLATFORM = os4.platform() === "win32";
+    var IS_WINDOWS_PLATFORM = os5.platform() === "win32";
     var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
     var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
     var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
@@ -6381,13 +5543,14 @@ var require_braces = __commonJS({
   }
 });
 
-// node_modules/picomatch/lib/constants.js
+// node_modules/micromatch/node_modules/picomatch/lib/constants.js
 var require_constants3 = __commonJS({
-  "node_modules/picomatch/lib/constants.js"(exports, module) {
+  "node_modules/micromatch/node_modules/picomatch/lib/constants.js"(exports, module) {
     "use strict";
     var path26 = __require("path");
     var WIN_SLASH = "\\\\/";
     var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+    var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
     var DOT_LITERAL = "\\.";
     var PLUS_LITERAL = "\\+";
     var QMARK_LITERAL = "\\?";
@@ -6435,6 +5598,7 @@ var require_constants3 = __commonJS({
       END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
     };
     var POSIX_REGEX_SOURCE = {
+      __proto__: null,
       alnum: "a-zA-Z0-9",
       alpha: "a-zA-Z",
       ascii: "\\x00-\\x7F",
@@ -6451,6 +5615,7 @@ var require_constants3 = __commonJS({
       xdigit: "A-Fa-f0-9"
     };
     module.exports = {
+      DEFAULT_MAX_EXTGLOB_RECURSION,
       MAX_LENGTH: 1024 * 64,
       POSIX_REGEX_SOURCE,
       // regular expressions
@@ -6462,6 +5627,7 @@ var require_constants3 = __commonJS({
       REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
       // Replace globs with equivalent patterns to reduce parsing time.
       REPLACEMENTS: {
+        __proto__: null,
         "***": "*",
         "**/**": "**",
         "**/**/**": "**"
@@ -6578,9 +5744,9 @@ var require_constants3 = __commonJS({
   }
 });
 
-// node_modules/picomatch/lib/utils.js
+// node_modules/micromatch/node_modules/picomatch/lib/utils.js
 var require_utils2 = __commonJS({
-  "node_modules/picomatch/lib/utils.js"(exports) {
+  "node_modules/micromatch/node_modules/picomatch/lib/utils.js"(exports) {
     "use strict";
     var path26 = __require("path");
     var win32 = process.platform === "win32";
@@ -6639,9 +5805,9 @@ var require_utils2 = __commonJS({
   }
 });
 
-// node_modules/picomatch/lib/scan.js
+// node_modules/micromatch/node_modules/picomatch/lib/scan.js
 var require_scan = __commonJS({
-  "node_modules/picomatch/lib/scan.js"(exports, module) {
+  "node_modules/micromatch/node_modules/picomatch/lib/scan.js"(exports, module) {
     "use strict";
     var utils = require_utils2();
     var {
@@ -6969,9 +6135,9 @@ var require_scan = __commonJS({
   }
 });
 
-// node_modules/picomatch/lib/parse.js
+// node_modules/micromatch/node_modules/picomatch/lib/parse.js
 var require_parse4 = __commonJS({
-  "node_modules/picomatch/lib/parse.js"(exports, module) {
+  "node_modules/micromatch/node_modules/picomatch/lib/parse.js"(exports, module) {
     "use strict";
     var constants6 = require_constants3();
     var utils = require_utils2();
@@ -6998,6 +6164,213 @@ var require_parse4 = __commonJS({
     var syntaxError = (type2, char) => {
       return `Missing ${type2}: "${char}" - use "\\\\${char}" to match literal characters`;
     };
+    var splitTopLevel = (input) => {
+      const parts = [];
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let value = "";
+      let escaped = false;
+      for (const ch of input) {
+        if (escaped === true) {
+          value += ch;
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          value += ch;
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          value += ch;
+          continue;
+        }
+        if (quote === 0) {
+          if (ch === "[") {
+            bracket++;
+          } else if (ch === "]" && bracket > 0) {
+            bracket--;
+          } else if (bracket === 0) {
+            if (ch === "(") {
+              paren++;
+            } else if (ch === ")" && paren > 0) {
+              paren--;
+            } else if (ch === "|" && paren === 0) {
+              parts.push(value);
+              value = "";
+              continue;
+            }
+          }
+        }
+        value += ch;
+      }
+      parts.push(value);
+      return parts;
+    };
+    var isPlainBranch = (branch2) => {
+      let escaped = false;
+      for (const ch of branch2) {
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (/[?*+@!()[\]{}]/.test(ch)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var normalizeSimpleBranch = (branch2) => {
+      let value = branch2.trim();
+      let changed = true;
+      while (changed === true) {
+        changed = false;
+        if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+          value = value.slice(2, -1);
+          changed = true;
+        }
+      }
+      if (!isPlainBranch(value)) {
+        return;
+      }
+      return value.replace(/\\(.)/g, "$1");
+    };
+    var hasRepeatedCharPrefixOverlap = (branches) => {
+      const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+      for (let i2 = 0; i2 < values.length; i2++) {
+        for (let j = i2 + 1; j < values.length; j++) {
+          const a2 = values[i2];
+          const b = values[j];
+          const char = a2[0];
+          if (!char || a2 !== char.repeat(a2.length) || b !== char.repeat(b.length)) {
+            continue;
+          }
+          if (a2 === b || a2.startsWith(b) || b.startsWith(a2)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    var parseRepeatedExtglob = (pattern, requireEnd = true) => {
+      if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
+        return;
+      }
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let escaped = false;
+      for (let i2 = 1; i2 < pattern.length; i2++) {
+        const ch = pattern[i2];
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          continue;
+        }
+        if (quote === 1) {
+          continue;
+        }
+        if (ch === "[") {
+          bracket++;
+          continue;
+        }
+        if (ch === "]" && bracket > 0) {
+          bracket--;
+          continue;
+        }
+        if (bracket > 0) {
+          continue;
+        }
+        if (ch === "(") {
+          paren++;
+          continue;
+        }
+        if (ch === ")") {
+          paren--;
+          if (paren === 0) {
+            if (requireEnd === true && i2 !== pattern.length - 1) {
+              return;
+            }
+            return {
+              type: pattern[0],
+              body: pattern.slice(2, i2),
+              end: i2
+            };
+          }
+        }
+      }
+    };
+    var getStarExtglobSequenceOutput = (pattern) => {
+      let index = 0;
+      const chars = [];
+      while (index < pattern.length) {
+        const match2 = parseRepeatedExtglob(pattern.slice(index), false);
+        if (!match2 || match2.type !== "*") {
+          return;
+        }
+        const branches = splitTopLevel(match2.body).map((branch3) => branch3.trim());
+        if (branches.length !== 1) {
+          return;
+        }
+        const branch2 = normalizeSimpleBranch(branches[0]);
+        if (!branch2 || branch2.length !== 1) {
+          return;
+        }
+        chars.push(branch2);
+        index += match2.end + 1;
+      }
+      if (chars.length < 1) {
+        return;
+      }
+      const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+      return `${source}*`;
+    };
+    var repeatedExtglobRecursion = (pattern) => {
+      let depth = 0;
+      let value = pattern.trim();
+      let match2 = parseRepeatedExtglob(value);
+      while (match2) {
+        depth++;
+        value = match2.body.trim();
+        match2 = parseRepeatedExtglob(value);
+      }
+      return depth;
+    };
+    var analyzeRepeatedExtglob = (body, options) => {
+      if (options.maxExtglobRecursion === false) {
+        return { risky: false };
+      }
+      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants6.DEFAULT_MAX_EXTGLOB_RECURSION;
+      const branches = splitTopLevel(body).map((branch2) => branch2.trim());
+      if (branches.length > 1) {
+        if (branches.some((branch2) => branch2 === "") || branches.some((branch2) => /^[*?]+$/.test(branch2)) || hasRepeatedCharPrefixOverlap(branches)) {
+          return { risky: true };
+        }
+      }
+      for (const branch2 of branches) {
+        const safeOutput = getStarExtglobSequenceOutput(branch2);
+        if (safeOutput) {
+          return { risky: true, safeOutput };
+        }
+        if (repeatedExtglobRecursion(branch2) > max) {
+          return { risky: true };
+        }
+      }
+      return { risky: false };
+    };
     var parse2 = (input, options) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
@@ -7129,6 +6502,8 @@ var require_parse4 = __commonJS({
         token.prev = prev;
         token.parens = state.parens;
         token.output = state.output;
+        token.startIndex = state.index;
+        token.tokensIndex = tokens.length;
         const output = (opts.capture ? "(" : "") + token.open;
         increment2("parens");
         push({ type: type2, value: value2, output: state.output ? "" : ONE_CHAR });
@@ -7136,6 +6511,26 @@ var require_parse4 = __commonJS({
         extglobs.push(token);
       };
       const extglobClose = (token) => {
+        const literal = input.slice(token.startIndex, state.index + 1);
+        const body = input.slice(token.startIndex + 2, state.index);
+        const analysis = analyzeRepeatedExtglob(body, opts);
+        if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+          const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
+          const open = tokens[token.tokensIndex];
+          open.type = "text";
+          open.value = literal;
+          open.output = safeOutput || utils.escapeRegex(literal);
+          for (let i2 = token.tokensIndex + 1; i2 < tokens.length; i2++) {
+            tokens[i2].value = "";
+            tokens[i2].output = "";
+            delete tokens[i2].suffix;
+          }
+          state.output = token.output + open.output;
+          state.backtrack = true;
+          push({ type: "paren", extglob: true, value, output: "" });
+          decrement("parens");
+          return;
+        }
         let output = token.close + (opts.capture ? ")" : "");
         let rest;
         if (token.type === "negate") {
@@ -7742,9 +7137,9 @@ var require_parse4 = __commonJS({
   }
 });
 
-// node_modules/picomatch/lib/picomatch.js
+// node_modules/micromatch/node_modules/picomatch/lib/picomatch.js
 var require_picomatch = __commonJS({
-  "node_modules/picomatch/lib/picomatch.js"(exports, module) {
+  "node_modules/micromatch/node_modules/picomatch/lib/picomatch.js"(exports, module) {
     "use strict";
     var path26 = __require("path");
     var scan = require_scan();
@@ -7883,9 +7278,9 @@ var require_picomatch = __commonJS({
   }
 });
 
-// node_modules/picomatch/index.js
+// node_modules/micromatch/node_modules/picomatch/index.js
 var require_picomatch2 = __commonJS({
-  "node_modules/picomatch/index.js"(exports, module) {
+  "node_modules/micromatch/node_modules/picomatch/index.js"(exports, module) {
     "use strict";
     module.exports = require_picomatch();
   }
@@ -9109,7 +8504,8 @@ var require_queue = __commonJS({
         empty: noop4,
         kill,
         killAndDrain,
-        error
+        error,
+        abort
       };
       return self;
       function running() {
@@ -9228,6 +8624,28 @@ var require_queue = __commonJS({
         self.drain();
         self.drain = noop4;
       }
+      function abort() {
+        var current = queueHead;
+        queueHead = null;
+        queueTail = null;
+        while (current) {
+          var next = current.next;
+          var callback = current.callback;
+          var errorHandler2 = current.errorHandler;
+          var val = current.value;
+          var context2 = current.context;
+          current.value = null;
+          current.callback = noop4;
+          current.errorHandler = null;
+          if (errorHandler2) {
+            errorHandler2(new Error("abort"), val);
+          }
+          callback.call(context2, new Error("abort"));
+          current.release(current);
+          current = next;
+        }
+        self.drain = noop4;
+      }
       function error(handler) {
         errorHandler = handler;
       }
@@ -10339,8 +9757,8 @@ var require_settings4 = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
     var fs11 = __require("fs");
-    var os4 = __require("os");
-    var CPU_COUNT = Math.max(os4.cpus().length, 1);
+    var os5 = __require("os");
+    var CPU_COUNT = Math.max(os5.cpus().length, 1);
     exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
       lstat: fs11.lstat,
       lstatSync: fs11.lstatSync,
@@ -10493,9 +9911,9 @@ var require_out4 = __commonJS({
   }
 });
 
-// node_modules/globby/node_modules/ignore/index.js
+// node_modules/ignore/index.js
 var require_ignore = __commonJS({
-  "node_modules/globby/node_modules/ignore/index.js"(exports, module) {
+  "node_modules/ignore/index.js"(exports, module) {
     function makeArray(subject) {
       return Array.isArray(subject) ? subject : [subject];
     }
@@ -11561,7 +10979,7 @@ var require_minimist = __commonJS({
 var require_rc = __commonJS({
   "node_modules/rc/index.js"(exports, module) {
     var cc = require_utils5();
-    var join2 = __require("path").join;
+    var join = __require("path").join;
     var deepExtend = require_deep_extend();
     var etc = "/etc";
     var win = process.platform === "win32";
@@ -11586,15 +11004,15 @@ var require_rc = __commonJS({
       }
       if (!win)
         [
-          join2(etc, name, "config"),
-          join2(etc, name + "rc")
+          join(etc, name, "config"),
+          join(etc, name + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join2(home, ".config", name, "config"),
-          join2(home, ".config", name),
-          join2(home, "." + name, "config"),
-          join2(home, "." + name + "rc")
+          join(home, ".config", name, "config"),
+          join(home, ".config", name),
+          join(home, "." + name, "config"),
+          join(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
       if (env.config) addConfigFile(env.config);
@@ -12310,7 +11728,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os4 = __require("os");
+    var os5 = __require("os");
     var tty3 = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -12358,7 +11776,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os4.release().split(".");
+        const osRelease = os5.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -13091,6 +12509,7 @@ var require_spdx_license_ids = __commonJS({
       "AGPL-1.0-or-later",
       "AGPL-3.0-only",
       "AGPL-3.0-or-later",
+      "ALGLIB-Documentation",
       "AMD-newlib",
       "AMDPLPA",
       "AML",
@@ -13112,6 +12531,7 @@ var require_spdx_license_ids = __commonJS({
       "Adobe-Display-PostScript",
       "Adobe-Glyph",
       "Adobe-Utopia",
+      "Advanced-Cryptics-Dictionary",
       "Afmparse",
       "Aladdin",
       "Apache-1.0",
@@ -13125,6 +12545,7 @@ var require_spdx_license_ids = __commonJS({
       "Artistic-2.0",
       "Artistic-dist",
       "Aspell-RU",
+      "BOLA-1.1",
       "BSD-1-Clause",
       "BSD-2-Clause",
       "BSD-2-Clause-Darwin",
@@ -13144,6 +12565,7 @@ var require_spdx_license_ids = __commonJS({
       "BSD-3-Clause-No-Nuclear-Warranty",
       "BSD-3-Clause-Open-MPI",
       "BSD-3-Clause-Sun",
+      "BSD-3-Clause-Tso",
       "BSD-3-Clause-acpica",
       "BSD-3-Clause-flex",
       "BSD-4-Clause",
@@ -13154,6 +12576,7 @@ var require_spdx_license_ids = __commonJS({
       "BSD-Advertising-Acknowledgement",
       "BSD-Attribution-HPND-disclaimer",
       "BSD-Inferno-Nettverk",
+      "BSD-Mark-Modifications",
       "BSD-Protection",
       "BSD-Source-Code",
       "BSD-Source-beginning-file",
@@ -13175,9 +12598,11 @@ var require_spdx_license_ids = __commonJS({
       "Borceux",
       "Brian-Gladman-2-Clause",
       "Brian-Gladman-3-Clause",
+      "Buddy",
       "C-UDA-1.0",
       "CAL-1.0",
       "CAL-1.0-Combined-Work-Exception",
+      "CAPEC-tou",
       "CATOSL-1.1",
       "CC-BY-1.0",
       "CC-BY-2.0",
@@ -13295,6 +12720,9 @@ var require_spdx_license_ids = __commonJS({
       "EPICS",
       "EPL-1.0",
       "EPL-2.0",
+      "ESA-PL-permissive-2.4",
+      "ESA-PL-strong-copyleft-2.4",
+      "ESA-PL-weak-copyleft-2.4",
       "EUDatagrid",
       "EUPL-1.0",
       "EUPL-1.1",
@@ -13368,6 +12796,7 @@ var require_spdx_license_ids = __commonJS({
       "HPND-Markus-Kuhn",
       "HPND-Netrek",
       "HPND-Pbmplus",
+      "HPND-SMC",
       "HPND-UC",
       "HPND-UC-export-US",
       "HPND-doc",
@@ -13382,6 +12811,7 @@ var require_spdx_license_ids = __commonJS({
       "HPND-sell-variant",
       "HPND-sell-variant-MIT-disclaimer",
       "HPND-sell-variant-MIT-disclaimer-rev",
+      "HPND-sell-variant-critical-systems",
       "HTMLTIDY",
       "HaskellReport",
       "Hippocratic-2.1",
@@ -13394,6 +12824,7 @@ var require_spdx_license_ids = __commonJS({
       "IPL-1.0",
       "ISC",
       "ISC-Veillard",
+      "ISO-permission",
       "ImageMagick",
       "Imlib2",
       "Info-ZIP",
@@ -13451,6 +12882,7 @@ var require_spdx_license_ids = __commonJS({
       "MIT-Festival",
       "MIT-Khronos-old",
       "MIT-Modern-Variant",
+      "MIT-STK",
       "MIT-Wu",
       "MIT-advertising",
       "MIT-enna",
@@ -13459,6 +12891,7 @@ var require_spdx_license_ids = __commonJS({
       "MIT-testregex",
       "MITNFA",
       "MMIXware",
+      "MMPL-1.0.1",
       "MPEG-SSG",
       "MPL-1.0",
       "MPL-1.1",
@@ -13490,6 +12923,7 @@ var require_spdx_license_ids = __commonJS({
       "NGPL",
       "NICTA-1.0",
       "NIST-PD",
+      "NIST-PD-TNT",
       "NIST-PD-fallback",
       "NIST-Software",
       "NLOD-1.0",
@@ -13549,12 +12983,15 @@ var require_spdx_license_ids = __commonJS({
       "OPL-1.0",
       "OPL-UK-3.0",
       "OPUBL-1.0",
+      "OSC-1.0",
       "OSET-PL-2.1",
       "OSL-1.0",
       "OSL-1.1",
       "OSL-2.0",
       "OSL-2.1",
       "OSL-3.0",
+      "OSSP",
+      "OpenMDW-1.0",
       "OpenPBS-2.3",
       "OpenSSL",
       "OpenSSL-standalone",
@@ -13565,6 +13002,7 @@ var require_spdx_license_ids = __commonJS({
       "PHP-3.01",
       "PPL",
       "PSF-2.0",
+      "ParaType-Free-Font-1.3",
       "Parity-6.0.0",
       "Parity-7.0.0",
       "Pixar",
@@ -13593,6 +13031,7 @@ var require_spdx_license_ids = __commonJS({
       "SGI-B-1.1",
       "SGI-B-2.0",
       "SGI-OpenGL",
+      "SGMLUG-PM",
       "SGP4",
       "SHL-0.5",
       "SHL-0.51",
@@ -13640,6 +13079,7 @@ var require_spdx_license_ids = __commonJS({
       "TTYP0",
       "TU-Berlin-1.0",
       "TU-Berlin-2.0",
+      "TekHVC",
       "TermReadKey",
       "ThirdEye",
       "TrustedQSL",
@@ -13649,6 +13089,7 @@ var require_spdx_license_ids = __commonJS({
       "UPL-1.0",
       "URT-RLE",
       "Ubuntu-font-1.0",
+      "UnRAR",
       "Unicode-3.0",
       "Unicode-DFS-2015",
       "Unicode-DFS-2016",
@@ -13660,15 +13101,19 @@ var require_spdx_license_ids = __commonJS({
       "VOSTROM",
       "VSL-1.0",
       "Vim",
+      "Vixie-Cron",
       "W3C",
       "W3C-19980720",
       "W3C-20150513",
+      "WTFNMFPL",
       "WTFPL",
       "Watcom-1.0",
       "Widget-Workshop",
+      "WordNet",
       "Wsuipa",
       "X11",
       "X11-distribute-modifications-variant",
+      "X11-no-permit-persons",
       "X11-swapped",
       "XFree86-1.1",
       "XSkat",
@@ -13709,6 +13154,7 @@ var require_spdx_license_ids = __commonJS({
       "gnuplot",
       "gtkbook",
       "hdparm",
+      "hyphen-bulgarian",
       "iMatix",
       "jove",
       "libpng-1.6.35",
@@ -15102,7 +14548,7 @@ var require_normalize = __commonJS({
 // src/index.js
 import { randomBytes } from "node:crypto";
 import fs10, { realpathSync as realpathSync2 } from "node:fs";
-import os3 from "node:os";
+import os4 from "node:os";
 import path25 from "node:path";
 
 // node_modules/indent-string/index.js
@@ -15141,7 +14587,7 @@ function indentString(string, count2 = 1, options = {}) {
 // node_modules/clean-stack/index.js
 import { fileURLToPath } from "node:url";
 
-// node_modules/escape-string-regexp/index.js
+// node_modules/clean-stack/node_modules/escape-string-regexp/index.js
 function escapeStringRegexp(string) {
   if (typeof string !== "string") {
     throw new TypeError("Expected a string");
@@ -22287,6 +21733,7 @@ import process10 from "node:process";
 import fs3 from "node:fs";
 import fsPromises from "node:fs/promises";
 import path9 from "node:path";
+import os2 from "node:os";
 
 // node_modules/is-path-inside/index.js
 import path7 from "node:path";
@@ -22536,6 +21983,7 @@ var ignoreFilesGlobOptions = {
   dot: true
 };
 var GITIGNORE_FILES_PATTERN = "**/.gitignore";
+var MAX_INCLUDE_DEPTH = 10;
 var getReadFileMethod = (fsImplementation) => bindFsMethod(fsImplementation?.promises, "readFile") ?? bindFsMethod(fsPromises, "readFile") ?? promisifyFsMethod(fsImplementation, "readFile");
 var getReadFileSyncMethod = (fsImplementation) => bindFsMethod(fsImplementation, "readFileSync") ?? bindFsMethod(fs3, "readFileSync");
 var shouldSkipIgnoreFileError = (error, suppressErrors) => {
@@ -22547,13 +21995,15 @@ var shouldSkipIgnoreFileError = (error, suppressErrors) => {
   }
   return Boolean(suppressErrors);
 };
-var createIgnoreFileReadError = (filePath, error) => {
+var createReadError = (kind, filePath, error) => {
+  const prefix = `Failed to read ${kind} at ${filePath}`;
   if (error instanceof Error) {
-    error.message = `Failed to read ignore file at ${filePath}: ${error.message}`;
-    return error;
+    return new Error(`${prefix}: ${error.message}`, { cause: error });
   }
-  return new Error(`Failed to read ignore file at ${filePath}: ${String(error)}`);
+  return new Error(`${prefix}: ${String(error)}`);
 };
+var createIgnoreFileReadError = (filePath, error) => createReadError("ignore file", filePath, error);
+var createGitConfigReadError = (filePath, error) => createReadError("git config", filePath, error);
 var processIgnoreFileCore = (filePath, readMethod, suppressErrors) => {
   try {
     const content = readMethod(filePath, "utf8");
@@ -22603,9 +22053,11 @@ var combineIgnoreFilePaths = (gitRoot, normalizedOptions, childPaths) => dedupeP
 var buildIgnoreResult = (files, normalizedOptions, gitRoot) => {
   const baseDir = gitRoot || normalizedOptions.cwd;
   const patterns = getPatternsFromIgnoreFiles(files, baseDir);
+  const matcher = createIgnoreMatcher(patterns, normalizedOptions.cwd, baseDir);
   return {
     patterns,
-    predicate: createIgnorePredicate(patterns, normalizedOptions.cwd, baseDir),
+    matcher,
+    predicate: (fileOrDirectory) => matcher(fileOrDirectory).ignored,
     usingGitRoot: Boolean(gitRoot && gitRoot !== normalizedOptions.cwd)
   };
 };
@@ -22647,21 +22099,29 @@ var toRelativePath = (fileOrDirectory, cwd) => {
   }
   return fileOrDirectory;
 };
-var createIgnorePredicate = (patterns, cwd, baseDir) => {
+var notIgnored = { ignored: false, unignored: false };
+var createIgnoreMatcher = (patterns, cwd, baseDir) => {
   const ignores = (0, import_ignore.default)().add(patterns);
   const resolvedCwd = path9.normalize(path9.resolve(cwd));
   const resolvedBaseDir = path9.normalize(path9.resolve(baseDir));
   return (fileOrDirectory) => {
     fileOrDirectory = toPath2(fileOrDirectory);
+    const hasTrailingSeparator = /[/\\]$/.test(fileOrDirectory);
     const normalizedPath = path9.normalize(path9.resolve(fileOrDirectory));
     if (normalizedPath === resolvedCwd) {
-      return false;
+      return notIgnored;
     }
-    const relativePath = toRelativePath(fileOrDirectory, resolvedBaseDir);
+    let relativePath = toRelativePath(fileOrDirectory, resolvedBaseDir);
     if (relativePath === void 0) {
-      return false;
+      return notIgnored;
+    }
+    if (!relativePath) {
+      return notIgnored;
+    }
+    if (hasTrailingSeparator && !relativePath.endsWith(path9.sep)) {
+      relativePath += path9.sep;
     }
-    return relativePath ? ignores.ignores(slash(relativePath)) : false;
+    return ignores.test(slash(relativePath));
   };
 };
 var normalizeOptions2 = (options = {}) => {
@@ -22679,6 +22139,384 @@ var normalizeOptions2 = (options = {}) => {
     fs: options.fs
   };
 };
+var unescapeGitQuotedValue = (value) => value.replaceAll(/\\(["\\abfnrtv])/g, (_match, escapedCharacter) => {
+  switch (escapedCharacter) {
+    case "a": {
+      return "\x07";
+    }
+    case "b": {
+      return "\b";
+    }
+    case "f": {
+      return "\f";
+    }
+    case "n": {
+      return "\n";
+    }
+    case "r": {
+      return "\r";
+    }
+    case "t": {
+      return "	";
+    }
+    case "v": {
+      return "\v";
+    }
+    default: {
+      return escapedCharacter;
+    }
+  }
+});
+var parseGitConfigValue = (value) => {
+  const trimmedValue = value.trim();
+  const quotedMatch = trimmedValue.match(/^"((?:[^"\\]|\\.)*)"\s*(?:[#;].*)?$/);
+  if (quotedMatch) {
+    return unescapeGitQuotedValue(quotedMatch[1]);
+  }
+  return trimmedValue.replace(/\s[#;].*$/, "").trim();
+};
+var resolveConfigPath = (filePath, configPath) => {
+  if (configPath.startsWith("~/")) {
+    const homeDirectory = os2.homedir();
+    const resolved = path9.join(homeDirectory, configPath.slice(2));
+    if (!isPathInside(resolved, homeDirectory)) {
+      return path9.join(homeDirectory, ".globby-invalid-path-traversal");
+    }
+    return resolved;
+  }
+  if (path9.isAbsolute(configPath)) {
+    return configPath;
+  }
+  return path9.resolve(path9.dirname(filePath), configPath);
+};
+var parseGitConfigSection = (line) => {
+  if (!line.startsWith("[")) {
+    return void 0;
+  }
+  let inQuotes = false;
+  let isEscaped = false;
+  for (let index = 1; index < line.length; index++) {
+    const character = line[index];
+    if (isEscaped) {
+      isEscaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      isEscaped = true;
+      continue;
+    }
+    if (character === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (character === "]" && !inQuotes) {
+      const remainder = line.slice(index + 1).trimStart();
+      if (remainder && !remainder.startsWith("#") && !remainder.startsWith(";")) {
+        return void 0;
+      }
+      return line.slice(1, index).trim();
+    }
+  }
+  return void 0;
+};
+var parseGitConfigEntry = (line) => {
+  const match2 = line.match(/^([A-Za-z\d-.]+)\s*=\s*(.*)$/);
+  if (!match2) {
+    return void 0;
+  }
+  return {
+    key: match2[1].toLowerCase(),
+    value: parseGitConfigValue(match2[2])
+  };
+};
+var parseIncludeIfCondition = (section) => {
+  if (!section) {
+    return void 0;
+  }
+  const match2 = section.match(/^includeif\s+"([^"]+)"$/i);
+  return match2 ? match2[1] : void 0;
+};
+var normalizeGitConfigConditionPattern = (pattern, configFilePath) => {
+  if (pattern.startsWith("~/")) {
+    pattern = path9.join(os2.homedir(), pattern.slice(2));
+  } else if (pattern.startsWith("./")) {
+    pattern = path9.resolve(path9.dirname(configFilePath), pattern.slice(2));
+  } else if (!path9.isAbsolute(pattern)) {
+    pattern = `**/${pattern}`;
+  }
+  if (pattern.endsWith("/")) {
+    pattern += "**";
+  }
+  return slash(pattern);
+};
+var gitConfigGlobToRegex = (pattern, flags) => {
+  let regex = "";
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    const nextCharacter = pattern[index + 1];
+    const nextNextCharacter = pattern[index + 2];
+    if (character === "*" && nextCharacter === "*" && nextNextCharacter === "/") {
+      regex += "(?:.*/)?";
+      index += 2;
+      continue;
+    }
+    if (character === "*" && nextCharacter === "*") {
+      regex += ".*";
+      index += 1;
+      continue;
+    }
+    if (character === "*") {
+      regex += "[^/]*";
+      continue;
+    }
+    if (character === "?") {
+      regex += "[^/]";
+      continue;
+    }
+    if (character === "[") {
+      const closingBracketIndex = pattern.indexOf("]", index + 1);
+      if (closingBracketIndex !== -1) {
+        const bracketContent = pattern.slice(index + 1, closingBracketIndex);
+        if (bracketContent) {
+          const negatedBracketContent = bracketContent[0] === "!" ? `^${bracketContent.slice(1)}` : bracketContent;
+          regex += `[${negatedBracketContent}]`;
+          index = closingBracketIndex;
+          continue;
+        }
+      }
+    }
+    regex += /[|\\{}()[\]^$+?.]/.test(character) ? `\\${character}` : character;
+  }
+  try {
+    return new RegExp(`^${regex}$`, flags);
+  } catch {
+    return /(?!)/;
+  }
+};
+var matchesIncludeIfCondition = (condition, gitDirectory, configFilePath) => {
+  if (!gitDirectory) {
+    return false;
+  }
+  const match2 = condition.match(/^(gitdir|gitdir\/i):(.*)$/i);
+  if (!match2) {
+    return false;
+  }
+  const [, keyword, rawPattern] = match2;
+  const pattern = normalizeGitConfigConditionPattern(rawPattern.trim(), configFilePath);
+  const isCaseInsensitive = keyword.toLowerCase() === "gitdir/i";
+  const regularExpression = gitConfigGlobToRegex(pattern, isCaseInsensitive ? "i" : void 0);
+  const normalizedGitDirectory = slash(path9.resolve(gitDirectory));
+  return regularExpression.test(normalizedGitDirectory);
+};
+var shouldIncludeConfigSection = (section, gitDirectory, configFilePath) => {
+  if (section?.toLowerCase() === "include") {
+    return true;
+  }
+  const condition = parseIncludeIfCondition(section);
+  return condition ? matchesIncludeIfCondition(condition, gitDirectory, configFilePath) : false;
+};
+var createExcludesFileValue = (value, declaringFilePath) => ({
+  value,
+  declaringFilePath
+});
+var parseGitConfigForExcludesFile = (content, normalizedPath, gitDirectory) => {
+  let currentSection;
+  let excludesFile;
+  const includePaths = [];
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";")) {
+      continue;
+    }
+    if (trimmed.startsWith("[")) {
+      currentSection = parseGitConfigSection(trimmed);
+      continue;
+    }
+    const entry = parseGitConfigEntry(trimmed);
+    if (!entry) {
+      continue;
+    }
+    if (currentSection?.toLowerCase() === "core" && entry.key === "excludesfile") {
+      excludesFile = createExcludesFileValue(entry.value, normalizedPath);
+      continue;
+    }
+    if (shouldIncludeConfigSection(currentSection, gitDirectory, normalizedPath) && entry.key === "path" && entry.value) {
+      includePaths.push(resolveConfigPath(normalizedPath, entry.value));
+    }
+  }
+  return { excludesFile, includePaths };
+};
+var readGitConfigFile = (normalizedPath, readMethod, suppressErrors) => {
+  try {
+    return readMethod(normalizedPath, "utf8");
+  } catch (error) {
+    if (shouldSkipIgnoreFileError(error, suppressErrors)) {
+      return void 0;
+    }
+    throw createGitConfigReadError(normalizedPath, error);
+  }
+};
+var getExcludesFileFromGitConfigSync = (filePath, readFileSync5, gitDirectory, options = {}) => {
+  const { suppressErrors, includeStack = /* @__PURE__ */ new Set(), depth = 0 } = options;
+  const normalizedPath = path9.resolve(filePath);
+  if (includeStack.has(normalizedPath)) {
+    return void 0;
+  }
+  if (depth >= MAX_INCLUDE_DEPTH) {
+    return void 0;
+  }
+  includeStack.add(normalizedPath);
+  const content = readGitConfigFile(normalizedPath, readFileSync5, suppressErrors);
+  if (content === void 0) {
+    includeStack.delete(normalizedPath);
+    return void 0;
+  }
+  let { excludesFile, includePaths } = parseGitConfigForExcludesFile(content, normalizedPath, gitDirectory);
+  for (const includePath of includePaths) {
+    const includedExcludesFile = getExcludesFileFromGitConfigSync(includePath, readFileSync5, gitDirectory, { suppressErrors, includeStack, depth: depth + 1 });
+    if (includedExcludesFile !== void 0) {
+      excludesFile = includedExcludesFile;
+    }
+  }
+  includeStack.delete(normalizedPath);
+  return excludesFile;
+};
+var getExcludesFileFromGitConfigAsync = async (filePath, readFile, gitDirectory, options = {}) => {
+  const { suppressErrors, includeStack = /* @__PURE__ */ new Set(), depth = 0 } = options;
+  const normalizedPath = path9.resolve(filePath);
+  if (includeStack.has(normalizedPath)) {
+    return void 0;
+  }
+  if (depth >= MAX_INCLUDE_DEPTH) {
+    return void 0;
+  }
+  includeStack.add(normalizedPath);
+  let content;
+  try {
+    content = await readFile(normalizedPath, "utf8");
+  } catch (error) {
+    includeStack.delete(normalizedPath);
+    if (shouldSkipIgnoreFileError(error, suppressErrors)) {
+      return void 0;
+    }
+    throw createGitConfigReadError(normalizedPath, error);
+  }
+  let { excludesFile, includePaths } = parseGitConfigForExcludesFile(content, normalizedPath, gitDirectory);
+  for (const includePath of includePaths) {
+    const includedExcludesFile = await getExcludesFileFromGitConfigAsync(includePath, readFile, gitDirectory, { suppressErrors, includeStack, depth: depth + 1 });
+    if (includedExcludesFile !== void 0) {
+      excludesFile = includedExcludesFile;
+    }
+  }
+  includeStack.delete(normalizedPath);
+  return excludesFile;
+};
+var resolveGitDirectoryFromFile = (gitFilePath, content) => {
+  const match2 = content.match(/^gitdir:\s*(.+?)\s*$/i);
+  if (!match2) {
+    return gitFilePath;
+  }
+  return path9.resolve(path9.dirname(gitFilePath), match2[1]);
+};
+var getGitDirectorySync = (gitRoot, readFileSync5) => {
+  if (!gitRoot) {
+    return void 0;
+  }
+  const gitFilePath = path9.join(gitRoot, ".git");
+  try {
+    return resolveGitDirectoryFromFile(gitFilePath, readFileSync5(gitFilePath, "utf8"));
+  } catch {
+    return gitFilePath;
+  }
+};
+var getGitDirectoryAsync = async (gitRoot, readFile) => {
+  if (!gitRoot) {
+    return void 0;
+  }
+  const gitFilePath = path9.join(gitRoot, ".git");
+  try {
+    return resolveGitDirectoryFromFile(gitFilePath, await readFile(gitFilePath, "utf8"));
+  } catch {
+    return gitFilePath;
+  }
+};
+var getXdgConfigHome = () => process10.env.XDG_CONFIG_HOME || path9.join(os2.homedir(), ".config");
+var getGitConfigPaths = () => {
+  if ("GIT_CONFIG_GLOBAL" in process10.env) {
+    const value = process10.env.GIT_CONFIG_GLOBAL;
+    return value ? [value] : [];
+  }
+  return [
+    path9.join(getXdgConfigHome(), "git", "config"),
+    path9.join(os2.homedir(), ".gitconfig")
+  ];
+};
+var getDefaultGlobalGitignorePath = () => path9.join(getXdgConfigHome(), "git", "ignore");
+var resolveExcludesFilePath = (excludesFileConfig) => {
+  if (excludesFileConfig?.value === "") {
+    return void 0;
+  }
+  if (excludesFileConfig === void 0) {
+    return getDefaultGlobalGitignorePath();
+  }
+  return resolveConfigPath(excludesFileConfig.declaringFilePath, excludesFileConfig.value);
+};
+var readGlobalGitignoreContent = (filePath, readMethod, suppressErrors) => {
+  try {
+    const content = readMethod(filePath, "utf8");
+    return { filePath, content };
+  } catch (error) {
+    if (shouldSkipIgnoreFileError(error, suppressErrors)) {
+      return void 0;
+    }
+    throw createIgnoreFileReadError(filePath, error);
+  }
+};
+var getGlobalGitignoreFile = (options = {}) => {
+  const cwd = toPath2(options.cwd) ?? process10.cwd();
+  const readFileSync5 = getReadFileSyncMethod(options.fs);
+  const gitRoot = findGitRootSync(cwd, options.fs);
+  const gitDirectory = getGitDirectorySync(gitRoot, readFileSync5);
+  let excludesFileConfig;
+  for (const gitConfigPath of getGitConfigPaths()) {
+    const value = getExcludesFileFromGitConfigSync(gitConfigPath, readFileSync5, gitDirectory, { suppressErrors: options.suppressErrors });
+    if (value !== void 0) {
+      excludesFileConfig = value;
+    }
+  }
+  const filePath = resolveExcludesFilePath(excludesFileConfig);
+  return filePath === void 0 ? void 0 : readGlobalGitignoreContent(filePath, readFileSync5, options.suppressErrors);
+};
+var getGlobalGitignoreFileAsync = async (options = {}) => {
+  const cwd = toPath2(options.cwd) ?? process10.cwd();
+  const readFile = getReadFileMethod(options.fs);
+  const gitRoot = await findGitRoot(cwd, options.fs);
+  const gitDirectory = await getGitDirectoryAsync(gitRoot, readFile);
+  const excludesFileValues = await Promise.all(getGitConfigPaths().map((gitConfigPath) => getExcludesFileFromGitConfigAsync(
+    gitConfigPath,
+    readFile,
+    gitDirectory,
+    { suppressErrors: options.suppressErrors }
+  )));
+  const excludesFileConfig = excludesFileValues.findLast((value) => value !== void 0);
+  const filePath = resolveExcludesFilePath(excludesFileConfig);
+  if (filePath === void 0) {
+    return void 0;
+  }
+  try {
+    const content = await readFile(filePath, "utf8");
+    return { filePath, content };
+  } catch (error) {
+    if (shouldSkipIgnoreFileError(error, options.suppressErrors)) {
+      return void 0;
+    }
+    throw createIgnoreFileReadError(filePath, error);
+  }
+};
+var buildGlobalMatcher = (globalIgnoreFile, cwd, rootDirectory = cwd) => {
+  const patterns = parseIgnoreFile(globalIgnoreFile, path9.dirname(globalIgnoreFile.filePath));
+  return createIgnoreMatcher(patterns, cwd, rootDirectory);
+};
 var collectIgnoreFileArtifactsAsync = async (patterns, options, includeParentIgnoreFiles) => {
   const normalizedOptions = normalizeOptions2(options);
   const childPaths = await globIgnoreFiles(import_fast_glob2.default, patterns, normalizedOptions);
@@ -22721,7 +22559,12 @@ var assertPatternsInput = (patterns) => {
     throw new TypeError("Patterns must be a string or an array of strings");
   }
 };
-var getStatMethod = (fsImplementation) => bindFsMethod(fsImplementation?.promises, "stat") ?? bindFsMethod(fs4.promises, "stat") ?? promisifyFsMethod(fsImplementation, "stat");
+var getStatMethod = (fsImplementation) => {
+  if (fsImplementation) {
+    return bindFsMethod(fsImplementation.promises, "stat") ?? promisifyFsMethod(fsImplementation, "stat");
+  }
+  return bindFsMethod(fs4.promises, "stat");
+};
 var getStatSyncMethod2 = (fsImplementation) => bindFsMethod(fsImplementation, "statSync") ?? bindFsMethod(fs4, "statSync");
 var isDirectory = async (path26, fsImplementation) => {
   try {
@@ -22826,73 +22669,204 @@ var getIgnoreFilesPatterns = (options) => {
   }
   return patterns;
 };
+var isPathIgnored = (matcher, globalMatcher, path26) => {
+  const globalResult = globalMatcher ? globalMatcher(path26) : void 0;
+  const result = matcher ? matcher(path26) : void 0;
+  if (result?.unignored) {
+    return false;
+  }
+  return Boolean(result?.ignored || globalResult?.ignored);
+};
+var hasIgnoredAncestorDirectory = (matcher, globalMatcher, file) => {
+  let currentPath = file;
+  while (true) {
+    const parentDirectory = nodePath.dirname(currentPath);
+    if (parentDirectory === currentPath) {
+      return false;
+    }
+    if (isPathIgnored(matcher, globalMatcher, `${parentDirectory}${nodePath.sep}`)) {
+      return true;
+    }
+    currentPath = parentDirectory;
+  }
+};
+var combinePredicate = (matcher, globalMatcher) => {
+  if (!matcher && !globalMatcher) {
+    return false;
+  }
+  return (file) => {
+    const result = matcher ? matcher(file) : void 0;
+    if (result?.unignored) {
+      const globalResult = globalMatcher ? globalMatcher(file) : void 0;
+      return globalResult?.ignored && hasIgnoredAncestorDirectory(matcher, globalMatcher, file);
+    }
+    return isPathIgnored(matcher, globalMatcher, file);
+  };
+};
+var buildIgnoreFilterResult = (options, cwd, { patterns, matcher, usingGitRoot }, globalMatcher, createFilter) => {
+  const finalPredicate = combinePredicate(matcher, globalMatcher);
+  const patternsForFastGlob = convertPatternsForFastGlob(patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob);
+  return {
+    options: {
+      ...options,
+      ignore: [...options.ignore, ...patternsForFastGlob]
+    },
+    filter: createFilter(finalPredicate, cwd, options.fs)
+  };
+};
 var applyIgnoreFilesAndGetFilter = async (options) => {
+  const cwd = options.cwd ?? process11.cwd();
   const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
-  if (ignoreFilesPatterns.length === 0) {
+  const globalIgnoreFile = options.globalGitignore ? await getGlobalGitignoreFileAsync(options) : void 0;
+  if (ignoreFilesPatterns.length === 0 && !globalIgnoreFile) {
     return {
       options,
-      filter: createFilterFunction(false, options.cwd)
+      filter: createFilterFunctionAsync(false, cwd, options.fs)
     };
   }
   const includeParentIgnoreFiles = options.gitignore === true;
-  const { patterns, predicate, usingGitRoot } = await getIgnorePatternsAndPredicate(ignoreFilesPatterns, options, includeParentIgnoreFiles);
-  const patternsForFastGlob = convertPatternsForFastGlob(patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob);
-  const modifiedOptions = {
-    ...options,
-    ignore: [...options.ignore, ...patternsForFastGlob]
-  };
-  return {
-    options: modifiedOptions,
-    filter: createFilterFunction(predicate, options.cwd)
-  };
+  const ignoreResult = ignoreFilesPatterns.length > 0 ? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { patterns: [], matcher: false, usingGitRoot: false };
+  const globalGitRoot = globalIgnoreFile ? await findGitRoot(cwd, options.fs) : void 0;
+  const globalMatcher = globalIgnoreFile ? buildGlobalMatcher(globalIgnoreFile, cwd, globalGitRoot ?? cwd) : void 0;
+  return buildIgnoreFilterResult(options, cwd, ignoreResult, globalMatcher, createFilterFunctionAsync);
 };
 var applyIgnoreFilesAndGetFilterSync = (options) => {
+  const cwd = options.cwd ?? process11.cwd();
   const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
-  if (ignoreFilesPatterns.length === 0) {
+  const globalIgnoreFile = options.globalGitignore ? getGlobalGitignoreFile(options) : void 0;
+  if (ignoreFilesPatterns.length === 0 && !globalIgnoreFile) {
     return {
       options,
-      filter: createFilterFunction(false, options.cwd)
+      filter: createFilterFunction(false, cwd, options.fs)
     };
   }
   const includeParentIgnoreFiles = options.gitignore === true;
-  const { patterns, predicate, usingGitRoot } = getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, options, includeParentIgnoreFiles);
-  const patternsForFastGlob = convertPatternsForFastGlob(patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob);
-  const modifiedOptions = {
-    ...options,
-    ignore: [...options.ignore, ...patternsForFastGlob]
+  const ignoreResult = ignoreFilesPatterns.length > 0 ? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { patterns: [], matcher: false, usingGitRoot: false };
+  const globalGitRoot = globalIgnoreFile ? findGitRootSync(cwd, options.fs) : void 0;
+  const globalMatcher = globalIgnoreFile ? buildGlobalMatcher(globalIgnoreFile, cwd, globalGitRoot ?? cwd) : void 0;
+  return buildIgnoreFilterResult(options, cwd, ignoreResult, globalMatcher, createFilterFunction);
+};
+var assertGlobalGitignoreSyncSupport = (options) => {
+  if (options.globalGitignore && options.fs && !options.fs.statSync) {
+    throw new Error("The `globalGitignore` option in `globbySync()` requires `fs.statSync` when a custom `fs` is provided.");
+  }
+};
+var globalGitignoreAsyncStatErrorMessage = "The `globalGitignore` option in `globby()` and `globbyStream()` requires `fs.promises.stat` or `fs.stat` when a custom `fs` is provided.";
+var assertGlobalGitignoreAsyncSupport = (options) => {
+  if (!options.globalGitignore || !options.fs) {
+    return;
+  }
+  if (!options.fs.promises?.stat && !options.fs.stat) {
+    throw new Error(globalGitignoreAsyncStatErrorMessage);
+  }
+};
+var createPathResolver = (cwd) => {
+  const basePath = cwd || process11.cwd();
+  const pathCache = /* @__PURE__ */ new Map();
+  return (pathKey3) => {
+    let absolutePath = pathCache.get(pathKey3);
+    if (absolutePath === void 0) {
+      if (pathCache.size > 1e4) {
+        pathCache.clear();
+      }
+      absolutePath = nodePath.isAbsolute(pathKey3) ? pathKey3 : nodePath.resolve(basePath, pathKey3);
+      pathCache.set(pathKey3, absolutePath);
+    }
+    return absolutePath;
   };
-  return {
-    options: modifiedOptions,
-    filter: createFilterFunction(predicate, options.cwd)
+};
+var createAsyncDirectoryCheck = (fsMethod) => {
+  const directoryCache = /* @__PURE__ */ new Map();
+  return async (absolutePath) => {
+    let isDirectory2 = directoryCache.get(absolutePath);
+    if (isDirectory2 !== void 0) {
+      return isDirectory2;
+    }
+    try {
+      const stats = await fsMethod?.(absolutePath);
+      isDirectory2 = Boolean(stats?.isDirectory());
+    } catch {
+      isDirectory2 = false;
+    }
+    if (directoryCache.size > 1e4) {
+      directoryCache.clear();
+    }
+    directoryCache.set(absolutePath, isDirectory2);
+    return isDirectory2;
+  };
+};
+var createDirectoryCheck = (fsMethod) => {
+  const directoryCache = /* @__PURE__ */ new Map();
+  return (absolutePath) => {
+    let isDirectory2 = directoryCache.get(absolutePath);
+    if (isDirectory2 !== void 0) {
+      return isDirectory2;
+    }
+    try {
+      isDirectory2 = Boolean(fsMethod?.(absolutePath)?.isDirectory());
+    } catch {
+      isDirectory2 = false;
+    }
+    if (directoryCache.size > 1e4) {
+      directoryCache.clear();
+    }
+    directoryCache.set(absolutePath, isDirectory2);
+    return isDirectory2;
+  };
+};
+var createFilterFunctionAsync = (isIgnored, cwd, fsImplementation) => {
+  const resolveAbsolutePath = createPathResolver(cwd);
+  const isDirectoryEntry = createAsyncDirectoryCheck(getStatMethod(fsImplementation));
+  return async (fastGlobResult) => {
+    if (!isIgnored) {
+      return true;
+    }
+    const absolutePath = resolveAbsolutePath(nodePath.normalize(fastGlobResult.path ?? fastGlobResult));
+    if (isIgnored(absolutePath)) {
+      return false;
+    }
+    return !(await isDirectoryEntry(absolutePath) && isIgnored(`${absolutePath}${nodePath.sep}`));
   };
 };
-var createFilterFunction = (isIgnored, cwd) => {
+var createFilterFunction = (isIgnored, cwd, fsImplementation) => {
   const seen = /* @__PURE__ */ new Set();
-  const basePath = cwd || process11.cwd();
-  const pathCache = /* @__PURE__ */ new Map();
+  const resolveAbsolutePath = createPathResolver(cwd);
+  const isDirectoryEntry = createDirectoryCheck(getStatSyncMethod2(fsImplementation));
   return (fastGlobResult) => {
     const pathKey3 = nodePath.normalize(fastGlobResult.path ?? fastGlobResult);
     if (seen.has(pathKey3)) {
       return false;
     }
     if (isIgnored) {
-      let absolutePath = pathCache.get(pathKey3);
-      if (absolutePath === void 0) {
-        absolutePath = nodePath.isAbsolute(pathKey3) ? pathKey3 : nodePath.resolve(basePath, pathKey3);
-        pathCache.set(pathKey3, absolutePath);
-        if (pathCache.size > 1e4) {
-          pathCache.clear();
-        }
-      }
+      const absolutePath = resolveAbsolutePath(pathKey3);
       if (isIgnored(absolutePath)) {
         return false;
       }
+      if (isDirectoryEntry(absolutePath) && isIgnored(`${absolutePath}${nodePath.sep}`)) {
+        return false;
+      }
     }
     seen.add(pathKey3);
     return true;
   };
 };
 var unionFastGlobResults = (results, filter2) => results.flat().filter((fastGlobResult) => filter2(fastGlobResult));
+var unionFastGlobResultsAsync = async (results, filter2) => {
+  results = results.flat();
+  const matches = await Promise.all(results.map((fastGlobResult) => filter2(fastGlobResult)));
+  const seen = /* @__PURE__ */ new Set();
+  return results.filter((fastGlobResult, index) => {
+    if (!matches[index]) {
+      return false;
+    }
+    const pathKey3 = nodePath.normalize(fastGlobResult.path ?? fastGlobResult);
+    if (seen.has(pathKey3)) {
+      return false;
+    }
+    seen.add(pathKey3);
+    return true;
+  });
+};
 var convertNegativePatterns = (patterns, options) => {
   if (patterns.length > 0 && patterns.every((pattern) => isNegativePattern(pattern))) {
     if (options.expandNegationOnlyPatterns === false) {
@@ -22997,25 +22971,37 @@ var generateTasksSync = (patterns, options) => {
   });
 };
 var globby = normalizeArguments(async (patterns, options) => {
+  assertGlobalGitignoreAsyncSupport(options);
   const { options: modifiedOptions, filter: filter2 } = await applyIgnoreFilesAndGetFilter(options);
   const tasks = await generateTasks(patterns, modifiedOptions);
   const results = await Promise.all(tasks.map((task) => (0, import_fast_glob3.default)(task.patterns, task.options)));
-  return unionFastGlobResults(results, filter2);
+  return unionFastGlobResultsAsync(results, filter2);
 });
 var globbySync = normalizeArgumentsSync((patterns, options) => {
+  assertGlobalGitignoreSyncSupport(options);
   const { options: modifiedOptions, filter: filter2 } = applyIgnoreFilesAndGetFilterSync(options);
   const tasks = generateTasksSync(patterns, modifiedOptions);
   const results = tasks.map((task) => import_fast_glob3.default.sync(task.patterns, task.options));
   return unionFastGlobResults(results, filter2);
 });
 var globbyStream = normalizeArgumentsSync((patterns, options) => {
-  const { options: modifiedOptions, filter: filter2 } = applyIgnoreFilesAndGetFilterSync(options);
-  const tasks = generateTasksSync(patterns, modifiedOptions);
-  const streams = tasks.map((task) => import_fast_glob3.default.stream(task.patterns, task.options));
-  if (streams.length === 0) {
-    return Readable4.from([]);
-  }
-  const stream = mergeStreams(streams).filter((fastGlobResult) => filter2(fastGlobResult));
+  assertGlobalGitignoreAsyncSupport(options);
+  const seen = /* @__PURE__ */ new Set();
+  const stream = Readable4.from((async function* () {
+    const { options: modifiedOptions, filter: filter2 } = await applyIgnoreFilesAndGetFilter(options);
+    const tasks = await generateTasks(patterns, modifiedOptions);
+    if (tasks.length === 0) {
+      return;
+    }
+    const streams = tasks.map((task) => import_fast_glob3.default.stream(task.patterns, task.options));
+    for await (const fastGlobResult of mergeStreams(streams)) {
+      const pathKey3 = nodePath.normalize(fastGlobResult.path ?? fastGlobResult);
+      if (!seen.has(pathKey3) && await filter2(fastGlobResult)) {
+        seen.add(pathKey3);
+        yield fastGlobResult;
+      }
+    }
+  })());
   return stream;
 });
 var isDynamicPattern = normalizeArgumentsSync((patterns, options) => patterns.some((pattern) => import_fast_glob3.default.isDynamicPattern(pattern, options)));
@@ -25800,7 +25786,7 @@ function hasTags(opts, logger) {
 // src/utils/make-diff-predicate.js
 import path11 from "node:path/posix";
 
-// node_modules/minimatch/node_modules/balanced-match/dist/esm/index.js
+// node_modules/balanced-match/dist/esm/index.js
 var balanced = (a2, b, str2) => {
   const ma = a2 instanceof RegExp ? maybeMatch(a2, str2) : a2;
   const mb = b instanceof RegExp ? maybeMatch(b, str2) : b;
@@ -25853,7 +25839,7 @@ var range = (a2, b, str2) => {
   return result;
 };
 
-// node_modules/minimatch/node_modules/brace-expansion/dist/esm/index.js
+// node_modules/brace-expansion/dist/esm/index.js
 var escSlash = "\0SLASH" + Math.random() + "\0";
 var escOpen = "\0OPEN" + Math.random() + "\0";
 var escClose = "\0CLOSE" + Math.random() + "\0";
@@ -25868,7 +25854,7 @@ var slashPattern = /\\\\/g;
 var openPattern = /\\{/g;
 var closePattern = /\\}/g;
 var commaPattern = /\\,/g;
-var periodPattern = /\\./g;
+var periodPattern = /\\\./g;
 var EXPANSION_MAX = 1e5;
 function numeric(str2) {
   return !isNaN(str2) ? parseInt(str2, 10) : str2.charCodeAt(0);
@@ -25963,7 +25949,7 @@ function expand_(str2, max, isTop) {
       const x = numeric(n2[0]);
       const y = numeric(n2[1]);
       const width = Math.max(n2[0].length, n2[1].length);
-      let incr = n2.length === 3 && n2[2] !== void 0 ? Math.abs(numeric(n2[2])) : 1;
+      let incr = n2.length === 3 && n2[2] !== void 0 ? Math.max(Math.abs(numeric(n2[2])), 1) : 1;
       let test = lte;
       const reverse = y < x;
       if (reverse) {
@@ -28963,7 +28949,7 @@ var npmRunPathEnv2 = ({ env = process12.env, ...options } = {}) => {
   return env;
 };
 
-// node_modules/env-ci/node_modules/mimic-fn/index.js
+// node_modules/mimic-fn/index.js
 var copyProperty = (to, from, property, ignoreNonConfigurable) => {
   if (property === "length" || property === "prototype") {
     return;
@@ -29505,7 +29491,7 @@ var normalizeStdio = (options) => {
 };
 
 // node_modules/env-ci/node_modules/execa/lib/kill.js
-import os2 from "node:os";
+import os3 from "node:os";
 var DEFAULT_FORCE_KILL_TIMEOUT2 = 1e3 * 5;
 var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
   const killResult = kill(signal);
@@ -29525,7 +29511,7 @@ var setKillTimeout2 = (kill, signal, options, killResult) => {
   }
 };
 var shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
-var isSigterm = (signal) => signal === os2.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
+var isSigterm = (signal) => signal === os3.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
 var getForceKillAfterTimeout = ({ forceKillAfterTimeout = true }) => {
   if (forceKillAfterTimeout === true) {
     return DEFAULT_FORCE_KILL_TIMEOUT2;
@@ -31176,14 +31162,14 @@ var nomatchRegex = /(?!.*)/;
 function escape2(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function join(parts, joiner) {
-  return parts.map((val) => escape2(val.trim())).filter(Boolean).join(joiner);
+function joinOr(parts) {
+  return parts.map((val) => typeof val === "string" ? escape2(val.trim()) : val.source).filter(Boolean).join("|");
 }
 function getNotesRegex(noteKeywords, notesPattern) {
   if (!noteKeywords) {
     return nomatchRegex;
   }
-  const noteKeywordsSelection = join(noteKeywords, "|");
+  const noteKeywordsSelection = joinOr(noteKeywords);
   if (!notesPattern) {
     return new RegExp(`^[\\s|*]*(${noteKeywordsSelection})[:\\s]+(.*)`, "i");
   }
@@ -31194,13 +31180,13 @@ function getReferencePartsRegex(issuePrefixes, issuePrefixesCaseSensitive) {
     return nomatchRegex;
   }
   const flags = issuePrefixesCaseSensitive ? "g" : "gi";
-  return new RegExp(`(?:.*?)??\\s*([\\w-\\.\\/]*?)??(${join(issuePrefixes, "|")})([\\w-]+)(?=\\s|$|[,;)\\]])`, flags);
+  return new RegExp(`(?:.*?)??\\s*([\\w-\\.\\/]*?)??(${joinOr(issuePrefixes)})([\\w-]+)(?=\\s|$|[,;)\\]])`, flags);
 }
 function getReferencesRegex(referenceActions) {
   if (!referenceActions) {
     return /()(.+)/gi;
   }
-  const joinedKeywords = join(referenceActions, "|");
+  const joinedKeywords = joinOr(referenceActions);
   return new RegExp(`(${joinedKeywords})(?:\\s+(.*?))(?=(?:${joinedKeywords})|$)`, "gi");
 }
 function getParserRegexes(options = {}) {
@@ -33155,7 +33141,19 @@ function parseJson(string, reviver, fileName) {
 
 // node_modules/read-package-up/node_modules/read-pkg/index.js
 var import_normalize_package_data = __toESM(require_normalize(), 1);
-var getPackagePath = (cwd) => path23.resolve(toPath(cwd) ?? ".", "package.json");
+
+// node_modules/read-package-up/node_modules/unicorn-magic/node.js
+import { promisify as promisify5 } from "node:util";
+import { execFile as execFileCallback3, execFileSync as execFileSyncOriginal3 } from "node:child_process";
+import { fileURLToPath as fileURLToPath11 } from "node:url";
+var execFileOriginal3 = promisify5(execFileCallback3);
+function toPath4(urlOrPath) {
+  return urlOrPath instanceof URL ? fileURLToPath11(urlOrPath) : urlOrPath;
+}
+var TEN_MEGABYTES_IN_BYTES3 = 10 * 1024 * 1024;
+
+// node_modules/read-package-up/node_modules/read-pkg/index.js
+var getPackagePath = (cwd) => path23.resolve(toPath4(cwd) ?? ".", "package.json");
 var _readPackage = (file, normalize2) => {
   const json2 = typeof file === "string" ? parseJson(file) : file;
   if (normalize2) {
@@ -33360,7 +33358,7 @@ async function generateNotes(pluginConfig, context) {
 
 // src/index.js
 var verified;
-var tempdir = realpathSync2(os3.tmpdir());
+var tempdir = realpathSync2(os4.tmpdir());
 var npmrc = temporaryFile({ name: ".npmrc" });
 var defaultConfig = {
   npmVerifyAuth: true,