weapp-vite 6.6.3 → 6.6.4

package/dist/{chunk-T7MKRIRO.mjs → chunk-5V5BMEO4.mjs}

@@ -82,7 +82,7 @@ var require_re = __commonJS({
     var src = exports.src = [];
     var safeSrc = exports.safeSrc = [];
     var t3 = exports.t = {};
-    var R = 0;
+    var R2 = 0;
     var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
     var safeRegexReplacements = [
       ["\\s", 1],
@@ -97,7 +97,7 @@ var require_re = __commonJS({
     };
     var createToken = (name, value, isGlobal) => {
       const safe = makeSafeRegex(value);
-      const index = R++;
+      const index = R2++;
       debug4(name, index, value);
       t3[name] = index;
       src[index] = value;
@@ -180,19 +180,19 @@ var require_identifiers = __commonJS({
     "use strict";
     init_esm_shims();
     var numeric2 = /^[0-9]+$/;
-    var compareIdentifiers = (a, b) => {
-      if (typeof a === "number" && typeof b === "number") {
-        return a === b ? 0 : a < b ? -1 : 1;
+    var compareIdentifiers = (a3, b) => {
+      if (typeof a3 === "number" && typeof b === "number") {
+        return a3 === b ? 0 : a3 < b ? -1 : 1;
       }
-      const anum = numeric2.test(a);
+      const anum = numeric2.test(a3);
       const bnum = numeric2.test(b);
       if (anum && bnum) {
-        a = +a;
+        a3 = +a3;
         b = +b;
       }
-      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+      return a3 === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a3 < b ? -1 : 1;
     };
-    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    var rcompareIdentifiers = (a3, b) => compareIdentifiers(b, a3);
     module.exports = {
       compareIdentifiers,
       rcompareIdentifiers
@@ -324,19 +324,19 @@ var require_semver = __commonJS({
         }
         let i = 0;
         do {
-          const a = this.prerelease[i];
+          const a3 = this.prerelease[i];
           const b = other.prerelease[i];
-          debug4("prerelease compare", i, a, b);
-          if (a === void 0 && b === void 0) {
+          debug4("prerelease compare", i, a3, b);
+          if (a3 === void 0 && b === void 0) {
             return 0;
           } else if (b === void 0) {
             return 1;
-          } else if (a === void 0) {
+          } else if (a3 === void 0) {
             return -1;
-          } else if (a === b) {
+          } else if (a3 === b) {
             continue;
           } else {
-            return compareIdentifiers(a, b);
+            return compareIdentifiers(a3, b);
           }
         } while (++i);
       }
@@ -346,19 +346,19 @@ var require_semver = __commonJS({
         }
         let i = 0;
         do {
-          const a = this.build[i];
+          const a3 = this.build[i];
           const b = other.build[i];
-          debug4("build compare", i, a, b);
-          if (a === void 0 && b === void 0) {
+          debug4("build compare", i, a3, b);
+          if (a3 === void 0 && b === void 0) {
             return 0;
           } else if (b === void 0) {
             return 1;
-          } else if (a === void 0) {
+          } else if (a3 === void 0) {
             return -1;
-          } else if (a === b) {
+          } else if (a3 === b) {
             continue;
           } else {
-            return compareIdentifiers(a, b);
+            return compareIdentifiers(a3, b);
           }
         } while (++i);
       }
@@ -486,7 +486,7 @@ var require_compare = __commonJS({
     "use strict";
     init_esm_shims();
     var SemVer = require_semver();
-    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    var compare = (a3, b, loose) => new SemVer(a3, loose).compare(new SemVer(b, loose));
     module.exports = compare;
   }
 });
@@ -497,7 +497,7 @@ var require_gte = __commonJS({
     "use strict";
     init_esm_shims();
     var compare = require_compare();
-    var gte2 = (a, b, loose) => compare(a, b, loose) >= 0;
+    var gte2 = (a3, b, loose) => compare(a3, b, loose) >= 0;
     module.exports = gte2;
   }
 });
@@ -507,7 +507,7 @@ var require_lrucache = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/lrucache.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var LRUCache2 = class {
+    var LRUCache = class {
       constructor() {
         this.max = 1e3;
         this.map = /* @__PURE__ */ new Map();
@@ -537,7 +537,7 @@ var require_lrucache = __commonJS({
         return this;
       }
     };
-    module.exports = LRUCache2;
+    module.exports = LRUCache;
   }
 });
 
@@ -547,7 +547,7 @@ var require_eq = __commonJS({
     "use strict";
     init_esm_shims();
     var compare = require_compare();
-    var eq = (a, b, loose) => compare(a, b, loose) === 0;
+    var eq = (a3, b, loose) => compare(a3, b, loose) === 0;
     module.exports = eq;
   }
 });
@@ -558,7 +558,7 @@ var require_neq = __commonJS({
     "use strict";
     init_esm_shims();
     var compare = require_compare();
-    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    var neq = (a3, b, loose) => compare(a3, b, loose) !== 0;
     module.exports = neq;
   }
 });
@@ -569,7 +569,7 @@ var require_gt = __commonJS({
     "use strict";
     init_esm_shims();
     var compare = require_compare();
-    var gt = (a, b, loose) => compare(a, b, loose) > 0;
+    var gt = (a3, b, loose) => compare(a3, b, loose) > 0;
     module.exports = gt;
   }
 });
@@ -580,7 +580,7 @@ var require_lt = __commonJS({
     "use strict";
     init_esm_shims();
     var compare = require_compare();
-    var lt = (a, b, loose) => compare(a, b, loose) < 0;
+    var lt = (a3, b, loose) => compare(a3, b, loose) < 0;
     module.exports = lt;
   }
 });
@@ -591,7 +591,7 @@ var require_lte = __commonJS({
     "use strict";
     init_esm_shims();
     var compare = require_compare();
-    var lte2 = (a, b, loose) => compare(a, b, loose) <= 0;
+    var lte2 = (a3, b, loose) => compare(a3, b, loose) <= 0;
     module.exports = lte2;
   }
 });
@@ -607,38 +607,38 @@ var require_cmp = __commonJS({
     var gte2 = require_gte();
     var lt = require_lt();
     var lte2 = require_lte();
-    var cmp = (a, op, b, loose) => {
+    var cmp = (a3, op, b, loose) => {
       switch (op) {
         case "===":
-          if (typeof a === "object") {
-            a = a.version;
+          if (typeof a3 === "object") {
+            a3 = a3.version;
           }
           if (typeof b === "object") {
             b = b.version;
           }
-          return a === b;
+          return a3 === b;
         case "!==":
-          if (typeof a === "object") {
-            a = a.version;
+          if (typeof a3 === "object") {
+            a3 = a3.version;
           }
           if (typeof b === "object") {
             b = b.version;
           }
-          return a !== b;
+          return a3 !== b;
         case "":
         case "=":
         case "==":
-          return eq(a, b, loose);
+          return eq(a3, b, loose);
         case "!=":
-          return neq(a, b, loose);
+          return neq(a3, b, loose);
         case ">":
-          return gt(a, b, loose);
+          return gt(a3, b, loose);
         case ">=":
-          return gte2(a, b, loose);
+          return gte2(a3, b, loose);
         case "<":
-          return lt(a, b, loose);
+          return lt(a3, b, loose);
         case "<=":
-          return lte2(a, b, loose);
+          return lte2(a3, b, loose);
         default:
           throw new TypeError(`Invalid operator: ${op}`);
       }
@@ -953,20 +953,20 @@ var require_range = __commonJS({
     };
     var replaceTilde = (comp, options) => {
       const r2 = options.loose ? re[t3.TILDELOOSE] : re[t3.TILDE];
-      return comp.replace(r2, (_, M, m, p, pr) => {
-        debug4("tilde", comp, _, M, m, p, pr);
+      return comp.replace(r2, (_, M2, m, p, pr) => {
+        debug4("tilde", comp, _, M2, m, p, pr);
         let ret;
-        if (isX(M)) {
+        if (isX(M2)) {
           ret = "";
         } else if (isX(m)) {
-          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+          ret = `>=${M2}.0.0 <${+M2 + 1}.0.0-0`;
         } else if (isX(p)) {
-          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+          ret = `>=${M2}.${m}.0 <${M2}.${+m + 1}.0-0`;
         } else if (pr) {
           debug4("replaceTilde pr", pr);
-          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+          ret = `>=${M2}.${m}.${p}-${pr} <${M2}.${+m + 1}.0-0`;
         } else {
-          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+          ret = `>=${M2}.${m}.${p} <${M2}.${+m + 1}.0-0`;
         }
         debug4("tilde return", ret);
         return ret;
@@ -978,41 +978,41 @@ var require_range = __commonJS({
     var replaceCaret = (comp, options) => {
       debug4("caret", comp, options);
       const r2 = options.loose ? re[t3.CARETLOOSE] : re[t3.CARET];
-      const z = options.includePrerelease ? "-0" : "";
-      return comp.replace(r2, (_, M, m, p, pr) => {
-        debug4("caret", comp, _, M, m, p, pr);
+      const z2 = options.includePrerelease ? "-0" : "";
+      return comp.replace(r2, (_, M2, m, p, pr) => {
+        debug4("caret", comp, _, M2, m, p, pr);
         let ret;
-        if (isX(M)) {
+        if (isX(M2)) {
           ret = "";
         } else if (isX(m)) {
-          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+          ret = `>=${M2}.0.0${z2} <${+M2 + 1}.0.0-0`;
         } else if (isX(p)) {
-          if (M === "0") {
-            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          if (M2 === "0") {
+            ret = `>=${M2}.${m}.0${z2} <${M2}.${+m + 1}.0-0`;
           } else {
-            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+            ret = `>=${M2}.${m}.0${z2} <${+M2 + 1}.0.0-0`;
           }
         } else if (pr) {
           debug4("replaceCaret pr", pr);
-          if (M === "0") {
+          if (M2 === "0") {
             if (m === "0") {
-              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+              ret = `>=${M2}.${m}.${p}-${pr} <${M2}.${m}.${+p + 1}-0`;
             } else {
-              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+              ret = `>=${M2}.${m}.${p}-${pr} <${M2}.${+m + 1}.0-0`;
             }
           } else {
-            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+            ret = `>=${M2}.${m}.${p}-${pr} <${+M2 + 1}.0.0-0`;
           }
         } else {
           debug4("no pr");
-          if (M === "0") {
+          if (M2 === "0") {
             if (m === "0") {
-              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+              ret = `>=${M2}.${m}.${p}${z2} <${M2}.${m}.${+p + 1}-0`;
             } else {
-              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+              ret = `>=${M2}.${m}.${p}${z2} <${M2}.${+m + 1}.0-0`;
             }
           } else {
-            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+            ret = `>=${M2}.${m}.${p} <${+M2 + 1}.0.0-0`;
           }
         }
         debug4("caret return", ret);
@@ -1026,9 +1026,9 @@ var require_range = __commonJS({
     var replaceXRange = (comp, options) => {
       comp = comp.trim();
       const r2 = options.loose ? re[t3.XRANGELOOSE] : re[t3.XRANGE];
-      return comp.replace(r2, (ret, gtlt, M, m, p, pr) => {
-        debug4("xRange", comp, ret, gtlt, M, m, p, pr);
-        const xM = isX(M);
+      return comp.replace(r2, (ret, gtlt, M2, m, p, pr) => {
+        debug4("xRange", comp, ret, gtlt, M2, m, p, pr);
+        const xM = isX(M2);
         const xm = xM || isX(m);
         const xp = xm || isX(p);
         const anyX = xp;
@@ -1050,7 +1050,7 @@ var require_range = __commonJS({
           if (gtlt === ">") {
             gtlt = ">=";
             if (xm) {
-              M = +M + 1;
+              M2 = +M2 + 1;
               m = 0;
               p = 0;
             } else {
@@ -1060,7 +1060,7 @@ var require_range = __commonJS({
           } else if (gtlt === "<=") {
             gtlt = "<";
             if (xm) {
-              M = +M + 1;
+              M2 = +M2 + 1;
             } else {
               m = +m + 1;
             }
@@ -1068,11 +1068,11 @@ var require_range = __commonJS({
           if (gtlt === "<") {
             pr = "-0";
           }
-          ret = `${gtlt + M}.${m}.${p}${pr}`;
+          ret = `${gtlt + M2}.${m}.${p}${pr}`;
         } else if (xm) {
-          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+          ret = `>=${M2}.0.0${pr} <${+M2 + 1}.0.0-0`;
         } else if (xp) {
-          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+          ret = `>=${M2}.${m}.0${pr} <${M2}.${+m + 1}.0-0`;
         }
         debug4("xRange return", ret);
         return ret;
@@ -1256,7 +1256,7 @@ var require_eventemitter3 = __commonJS({
       if (listeners.fn) return 1;
       return listeners.length;
     };
-    EventEmitter4.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    EventEmitter4.prototype.emit = function emit(event, a1, a22, a3, a4, a5) {
       var evt = prefix ? prefix + event : event;
       if (!this._events[evt]) return false;
       var listeners = this._events[evt], len = arguments.length, args, i;
@@ -1268,13 +1268,13 @@ var require_eventemitter3 = __commonJS({
           case 2:
             return listeners.fn.call(listeners.context, a1), true;
           case 3:
-            return listeners.fn.call(listeners.context, a1, a2), true;
+            return listeners.fn.call(listeners.context, a1, a22), true;
           case 4:
-            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+            return listeners.fn.call(listeners.context, a1, a22, a3), true;
           case 5:
-            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+            return listeners.fn.call(listeners.context, a1, a22, a3, a4), true;
           case 6:
-            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+            return listeners.fn.call(listeners.context, a1, a22, a3, a4, a5), true;
         }
         for (i = 1, args = new Array(len - 1); i < len; i++) {
           args[i - 1] = arguments[i];
@@ -1292,10 +1292,10 @@ var require_eventemitter3 = __commonJS({
               listeners[i].fn.call(listeners[i].context, a1);
               break;
             case 3:
-              listeners[i].fn.call(listeners[i].context, a1, a2);
+              listeners[i].fn.call(listeners[i].context, a1, a22);
               break;
             case 4:
-              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              listeners[i].fn.call(listeners[i].context, a1, a22, a3);
               break;
             default:
               if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
@@ -1708,7 +1708,7 @@ function resolveImportee(importee, jsonPath, aliasEntries) {
     if (!jsonPath) {
       return importee;
     }
-    const matchedEntry = aliasEntries.find((x) => matches(x.find, importee));
+    const matchedEntry = aliasEntries.find((x2) => matches(x2.find, importee));
     if (!matchedEntry) {
       return importee;
     }
@@ -2211,1426 +2211,546 @@ init_esm_shims();
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep3 } from "@weapp-core/shared";
 
-// ../../node_modules/.pnpm/lru-cache@11.2.5/node_modules/lru-cache/dist/esm/index.js
+// ../../node_modules/.pnpm/lru-cache@11.2.6/node_modules/lru-cache/dist/esm/index.min.js
 init_esm_shims();
-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, type, code, fn) => {
-  typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+var M = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+var I = /* @__PURE__ */ new Set();
+var R = typeof process == "object" && process ? process : {};
+var x = (a3, t3, e, i) => {
+  typeof R.emitWarning == "function" ? R.emitWarning(a3, t3, e, i) : console.error(`[${e}] ${t3}: ${a3}`);
 };
-var AC = globalThis.AbortController;
-var AS = globalThis.AbortSignal;
-if (typeof AC === "undefined") {
-  AS = class AbortSignal {
+var C = globalThis.AbortController;
+var D = globalThis.AbortSignal;
+if (typeof C > "u") {
+  D = class {
     onabort;
     _onabort = [];
     reason;
     aborted = false;
-    addEventListener(_, fn) {
-      this._onabort.push(fn);
+    addEventListener(i, s) {
+      this._onabort.push(s);
     }
-  };
-  AC = class AbortController {
+  }, C = class {
     constructor() {
-      warnACPolyfill();
+      t3();
     }
-    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 D();
+    abort(i) {
+      if (!this.signal.aborted) {
+        this.signal.reason = i, this.signal.aborted = true;
+        for (let s of this.signal._onabort) s(i);
+        this.signal.onabort?.(i);
       }
-      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 a3 = R.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t3 = () => {
+    a3 && (a3 = false, x("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", t3));
   };
 }
-var shouldWarn = (code) => !warned.has(code);
-var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
-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 G = (a3) => !I.has(a3);
+var y = (a3) => a3 && a3 === Math.floor(a3) && a3 > 0 && isFinite(a3);
+var U = (a3) => y(a3) ? a3 <= Math.pow(2, 8) ? Uint8Array : a3 <= Math.pow(2, 16) ? Uint16Array : a3 <= Math.pow(2, 32) ? Uint32Array : a3 <= Number.MAX_SAFE_INTEGER ? z : null : null;
+var z = class extends Array {
+  constructor(t3) {
+    super(t3), this.fill(0);
   }
 };
-var Stack = class _Stack {
+var W = class a {
   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;
+  static #o = false;
+  static create(t3) {
+    let e = U(t3);
+    if (!e) return [];
+    a.#o = true;
+    let i = new a(t3, e);
+    return a.#o = false, i;
   }
-  constructor(max, HeapCls) {
-    if (!_Stack.#constructing) {
-      throw new TypeError("instantiate Stack using Stack.create(n)");
-    }
-    this.heap = new HeapCls(max);
-    this.length = 0;
+  constructor(t3, e) {
+    if (!a.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+    this.heap = new e(t3), this.length = 0;
   }
-  push(n) {
-    this.heap[this.length++] = n;
+  push(t3) {
+    this.heap[this.length++] = t3;
   }
   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 L = class a2 {
+  #o;
+  #c;
+  #w;
+  #C;
+  #S;
+  #L;
+  #I;
+  #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;
-  #autopurgeTimers;
-  #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(c) {
-    return {
-      // properties
-      starts: c.#starts,
-      ttls: c.#ttls,
-      autopurgeTimers: c.#autopurgeTimers,
-      sizes: c.#sizes,
-      keyMap: c.#keyMap,
-      keyList: c.#keyList,
-      valList: c.#valList,
-      next: c.#next,
-      prev: c.#prev,
-      get head() {
-        return c.#head;
-      },
-      get tail() {
-        return c.#tail;
-      },
-      free: c.#free,
-      // methods
-      isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
-      backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
-      moveToTail: (index) => c.#moveToTail(index),
-      indexes: (options) => c.#indexes(options),
-      rindexes: (options) => c.#rindexes(options),
-      isStale: (index) => c.#isStale(index)
-    };
+  #n;
+  #_;
+  #s;
+  #i;
+  #t;
+  #a;
+  #u;
+  #l;
+  #h;
+  #b;
+  #r;
+  #y;
+  #A;
+  #d;
+  #g;
+  #T;
+  #v;
+  #f;
+  #x;
+  static unsafeExposeInternals(t3) {
+    return { starts: t3.#A, ttls: t3.#d, autopurgeTimers: t3.#g, sizes: t3.#y, keyMap: t3.#s, keyList: t3.#i, valList: t3.#t, next: t3.#a, prev: t3.#u, get head() {
+      return t3.#l;
+    }, get tail() {
+      return t3.#h;
+    }, free: t3.#b, isBackgroundFetch: (e) => t3.#e(e), backgroundFetch: (e, i, s, h) => t3.#G(e, i, s, h), moveToTail: (e) => t3.#D(e), indexes: (e) => t3.#F(e), rindexes: (e) => t3.#O(e), isStale: (e) => t3.#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.#I;
   }
-  /**
-   * {@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 this.#S;
+  }
+  constructor(t3) {
+    let { max: e = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: h, updateAgeOnGet: n, updateAgeOnHas: o, allowStale: r2, dispose: f, onInsert: m, disposeAfter: c, noDisposeOnSet: d, noUpdateTTL: g, maxSize: A = 0, maxEntrySize: p = 0, sizeCalculation: _, fetchMethod: l, memoMethod: w, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: S, allowStaleOnFetchRejection: u, allowStaleOnFetchAbort: T, ignoreFetchAbort: F, perf: v } = t3;
+    if (v !== void 0 && typeof v?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+    if (this.#m = v ?? M, e !== 0 && !y(e)) throw new TypeError("max option must be a nonnegative integer");
+    let O = e ? U(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 (w !== void 0 && typeof w != "function") throw new TypeError("memoMethod must be a function if defined");
+    if (this.#I = w, 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 f == "function" && (this.#w = f), typeof m == "function" && (this.#C = m), typeof c == "function" ? (this.#S = c, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#w, this.#x = !!this.#C, this.#f = !!this.#S, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!g, this.noDeleteOnFetchRejection = !!b, this.allowStaleOnFetchRejection = !!u, 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 = !!r2, this.noDeleteOnStaleGet = !!S, this.updateAgeOnGet = !!n, this.updateAgeOnHas = !!o, this.ttlResolution = y(s) || s === 0 ? s : 1, this.ttlAutopurge = !!h, this.ttl = i || 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";
+      G(E) && (I.add(E), x("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, a2));
+    }
+  }
+  getRemainingTTL(t3) {
+    return this.#s.has(t3) ? 1 / 0 : 0;
+  }
+  #j() {
+    let t3 = new z(this.#o), e = new z(this.#o);
+    this.#d = t3, this.#A = e;
+    let i = this.ttlAutopurge ? new Array(this.#o) : void 0;
+    this.#g = i, this.#N = (n, o, r2 = this.#m.now()) => {
+      if (e[n] = o !== 0 ? r2 : 0, t3[n] = o, i?.[n] && (clearTimeout(i[n]), i[n] = void 0), o !== 0 && i) {
+        let f = setTimeout(() => {
+          this.#p(n) && this.#E(this.#i[n], "expire");
+        }, o + 1);
+        f.unref && f.unref(), i[n] = f;
+      }
+    }, this.#R = (n) => {
+      e[n] = t3[n] !== 0 ? this.#m.now() : 0;
+    }, this.#z = (n, o) => {
+      if (t3[o]) {
+        let r2 = t3[o], f = e[o];
+        if (!r2 || !f) return;
+        n.ttl = r2, n.start = f, n.now = s || h();
+        let m = n.now - f;
+        n.remainingTTL = r2 - m;
       }
-    }
-  }
-  /**
-   * 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;
-    const purgeTimers = this.ttlAutopurge ? new Array(this.#max) : void 0;
-    this.#autopurgeTimers = purgeTimers;
-    this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
-      starts[index] = ttl !== 0 ? start : 0;
-      ttls[index] = ttl;
-      if (purgeTimers?.[index]) {
-        clearTimeout(purgeTimers[index]);
-        purgeTimers[index] = void 0;
-      }
-      if (ttl !== 0 && purgeTimers) {
-        const t3 = setTimeout(() => {
-          if (this.#isStale(index)) {
-            this.#delete(this.#keyList[index], "expire");
-          }
-        }, ttl + 1);
-        if (t3.unref) {
-          t3.unref();
-        }
-        purgeTimers[index] = t3;
-      }
-    };
-    this.#updateItemAge = (index) => {
-      starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0;
     };
-    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;
-      }
-    };
-    let cachedNow = 0;
-    const getNow = () => {
-      const n = this.#perf.now();
+    let s = 0, h = () => {
+      let n = this.#m.now();
       if (this.ttlResolution > 0) {
-        cachedNow = n;
-        const t3 = setTimeout(() => cachedNow = 0, this.ttlResolution);
-        if (t3.unref) {
-          t3.unref();
-        }
+        s = n;
+        let o = setTimeout(() => s = 0, this.ttlResolution);
+        o.unref && o.unref();
       }
       return n;
     };
-    this.getRemainingTTL = (key) => {
-      const index = this.#keyMap.get(key);
-      if (index === void 0) {
-        return 0;
-      }
-      const ttl = ttls[index];
-      const start = starts[index];
-      if (!ttl || !start) {
-        return Infinity;
-      }
-      const age = (cachedNow || getNow()) - start;
-      return ttl - age;
-    };
-    this.#isStale = (index) => {
-      const s = starts[index];
-      const t3 = ttls[index];
-      return !!t3 && !!s && (cachedNow || getNow()) - s > t3;
+    this.getRemainingTTL = (n) => {
+      let o = this.#s.get(n);
+      if (o === void 0) return 0;
+      let r2 = t3[o], f = e[o];
+      if (!r2 || !f) return 1 / 0;
+      let m = (s || h()) - f;
+      return r2 - m;
+    }, this.#p = (n) => {
+      let o = e[n], r2 = t3[n];
+      return !!r2 && !!o && (s || h()) - o > r2;
     };
   }
-  // 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 t3 = new z(this.#o);
+    this.#_ = 0, this.#y = t3, this.#W = (e) => {
+      this.#_ -= t3[e], t3[e] = 0;
+    }, this.#P = (e, i, s, h) => {
+      if (this.#e(i)) return 0;
+      if (!y(s)) if (h) {
+        if (typeof h != "function") throw new TypeError("sizeCalculation must be a function");
+        if (s = h(i, e), !y(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+      } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+      return s;
+    }, this.#U = (e, i, s) => {
+      if (t3[e] = i, this.#c) {
+        let h = this.#c - t3[e];
+        for (; this.#_ > h; ) this.#M(true);
+      }
+      this.#_ += t3[e], s && (s.entrySize = i, s.totalCalculatedSize = this.#_);
     };
   }
-  #removeItemSize = (_i) => {
+  #W = (t3) => {
   };
-  #addItemSize = (_i, _s, _st) => {
+  #U = (t3, e, i) => {
   };
-  #requireSize = (_k, _v, size, sizeCalculation) => {
-    if (size || sizeCalculation) {
-      throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
-    }
+  #P = (t3, e, i, s) => {
+    if (i || 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 i = this.#tail; true; ) {
-        if (!this.#isValidIndex(i)) {
-          break;
-        }
-        if (allowStale || !this.#isStale(i)) {
-          yield i;
-        }
-        if (i === this.#head) {
-          break;
-        } else {
-          i = this.#prev[i];
-        }
-      }
-    }
+  *#F({ allowStale: t3 = this.allowStale } = {}) {
+    if (this.#n) for (let e = this.#h; !(!this.#H(e) || ((t3 || !this.#p(e)) && (yield e), e === this.#l)); ) e = this.#u[e];
   }
-  *#rindexes({ allowStale = this.allowStale } = {}) {
-    if (this.#size) {
-      for (let i = this.#head; true; ) {
-        if (!this.#isValidIndex(i)) {
-          break;
-        }
-        if (allowStale || !this.#isStale(i)) {
-          yield i;
-        }
-        if (i === this.#tail) {
-          break;
-        } else {
-          i = this.#next[i];
-        }
-      }
-    }
+  *#O({ allowStale: t3 = this.allowStale } = {}) {
+    if (this.#n) for (let e = this.#l; !(!this.#H(e) || ((t3 || !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(t3) {
+    return t3 !== void 0 && this.#s.get(this.#i[t3]) === t3;
   }
-  /**
-   * Return a generator yielding `[key, value]` pairs,
-   * in order from most recently used to least recently used.
-   */
   *entries() {
-    for (const i of this.#indexes()) {
-      if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-        yield [this.#keyList[i], this.#valList[i]];
-      }
-    }
+    for (let t3 of this.#F()) this.#t[t3] !== void 0 && this.#i[t3] !== void 0 && !this.#e(this.#t[t3]) && (yield [this.#i[t3], this.#t[t3]]);
   }
-  /**
-   * 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 i of this.#rindexes()) {
-      if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-        yield [this.#keyList[i], this.#valList[i]];
-      }
-    }
+    for (let t3 of this.#O()) this.#t[t3] !== void 0 && this.#i[t3] !== void 0 && !this.#e(this.#t[t3]) && (yield [this.#i[t3], this.#t[t3]]);
   }
-  /**
-   * Return a generator yielding the keys in the cache,
-   * in order from most recently used to least recently used.
-   */
   *keys() {
-    for (const i of this.#indexes()) {
-      const k = this.#keyList[i];
-      if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-        yield k;
-      }
+    for (let t3 of this.#F()) {
+      let e = this.#i[t3];
+      e !== void 0 && !this.#e(this.#t[t3]) && (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 i of this.#rindexes()) {
-      const k = this.#keyList[i];
-      if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-        yield k;
-      }
+    for (let t3 of this.#O()) {
+      let e = this.#i[t3];
+      e !== void 0 && !this.#e(this.#t[t3]) && (yield e);
     }
   }
-  /**
-   * Return a generator yielding the values in the cache,
-   * in order from most recently used to least recently used.
-   */
   *values() {
-    for (const i of this.#indexes()) {
-      const v = this.#valList[i];
-      if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-        yield this.#valList[i];
-      }
-    }
+    for (let t3 of this.#F()) this.#t[t3] !== void 0 && !this.#e(this.#t[t3]) && (yield this.#t[t3]);
   }
-  /**
-   * 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 i of this.#rindexes()) {
-      const v = this.#valList[i];
-      if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-        yield this.#valList[i];
-      }
-    }
+    for (let t3 of this.#O()) this.#t[t3] !== void 0 && !this.#e(this.#t[t3]) && (yield this.#t[t3]);
   }
-  /**
-   * 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, getOptions2 = {}) {
-    for (const i of this.#indexes()) {
-      const v = this.#valList[i];
-      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-      if (value === void 0)
-        continue;
-      if (fn(value, this.#keyList[i], this)) {
-        return this.get(this.#keyList[i], getOptions2);
-      }
+  find(t3, e = {}) {
+    for (let i of this.#F()) {
+      let s = this.#t[i], h = this.#e(s) ? s.__staleWhileFetching : s;
+      if (h !== void 0 && t3(h, this.#i[i], this)) return this.get(this.#i[i], 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 i of this.#indexes()) {
-      const v = this.#valList[i];
-      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-      if (value === void 0)
-        continue;
-      fn.call(thisp, value, this.#keyList[i], this);
+  forEach(t3, e = this) {
+    for (let i of this.#F()) {
+      let s = this.#t[i], h = this.#e(s) ? s.__staleWhileFetching : s;
+      h !== void 0 && t3.call(e, h, this.#i[i], 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 i of this.#rindexes()) {
-      const v = this.#valList[i];
-      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-      if (value === void 0)
-        continue;
-      fn.call(thisp, value, this.#keyList[i], this);
+  rforEach(t3, e = this) {
+    for (let i of this.#O()) {
+      let s = this.#t[i], h = this.#e(s) ? s.__staleWhileFetching : s;
+      h !== void 0 && t3.call(e, h, this.#i[i], this);
     }
   }
-  /**
-   * Delete any stale entries. Returns true if anything was removed,
-   * false otherwise.
-   */
   purgeStale() {
-    let deleted = false;
-    for (const i of this.#rindexes({ allowStale: true })) {
-      if (this.#isStale(i)) {
-        this.#delete(this.#keyList[i], "expire");
-        deleted = true;
-      }
-    }
-    return deleted;
+    let t3 = false;
+    for (let e of this.#O({ allowStale: true })) this.#p(e) && (this.#E(this.#i[e], "expire"), t3 = true);
+    return t3;
   }
-  /**
-   * 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 i = this.#keyMap.get(key);
-    if (i === void 0)
-      return void 0;
-    const v = this.#valList[i];
-    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[i];
-      const start = this.#starts[i];
-      if (ttl && start) {
-        const remain = ttl - (this.#perf.now() - start);
-        entry.ttl = remain;
-        entry.start = Date.now();
+  info(t3) {
+    let e = this.#s.get(t3);
+    if (e === void 0) return;
+    let i = this.#t[e], s = this.#e(i) ? i.__staleWhileFetching : i;
+    if (s === void 0) return;
+    let h = { value: s };
+    if (this.#d && this.#A) {
+      let n = this.#d[e], o = this.#A[e];
+      if (n && o) {
+        let r2 = n - (this.#m.now() - o);
+        h.ttl = r2, h.start = Date.now();
       }
     }
-    if (this.#sizes) {
-      entry.size = this.#sizes[i];
-    }
-    return entry;
+    return this.#y && (h.size = this.#y[e]), h;
   }
-  /**
-   * 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 i of this.#indexes({ allowStale: true })) {
-      const key = this.#keyList[i];
-      const v = this.#valList[i];
-      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-      if (value === void 0 || key === void 0)
-        continue;
-      const entry = { value };
-      if (this.#ttls && this.#starts) {
-        entry.ttl = this.#ttls[i];
-        const age = this.#perf.now() - this.#starts[i];
-        entry.start = Math.floor(Date.now() - age);
-      }
-      if (this.#sizes) {
-        entry.size = this.#sizes[i];
+    let t3 = [];
+    for (let e of this.#F({ allowStale: true })) {
+      let i = this.#i[e], s = this.#t[e], h = this.#e(s) ? s.__staleWhileFetching : s;
+      if (h === void 0 || i === void 0) continue;
+      let n = { value: h };
+      if (this.#d && this.#A) {
+        n.ttl = this.#d[e];
+        let o = this.#m.now() - this.#A[e];
+        n.start = Math.floor(Date.now() - o);
       }
-      arr.unshift([key, entry]);
+      this.#y && (n.size = this.#y[e]), t3.unshift([i, n]);
     }
-    return arr;
+    return t3;
   }
-  /**
-   * 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(t3) {
     this.clear();
-    for (const [key, entry] of arr) {
-      if (entry.start) {
-        const age = Date.now() - entry.start;
-        entry.start = this.#perf.now() - age;
+    for (let [e, i] of t3) {
+      if (i.start) {
+        let s = Date.now() - i.start;
+        i.start = this.#m.now() - s;
       }
-      this.set(key, entry.value, entry);
+      this.set(e, i.value, i);
     }
   }
-  /**
-   * 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;
-        }
-      } 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);
-    }
-    if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
-      const dt = this.#disposed;
-      let task;
-      while (task = dt?.shift()) {
-        this.#disposeAfter?.(...task);
-      }
+  set(t3, e, i = {}) {
+    if (e === void 0) return this.delete(t3), this;
+    let { ttl: s = this.ttl, start: h, noDisposeOnSet: n = this.noDisposeOnSet, sizeCalculation: o = this.sizeCalculation, status: r2 } = i, { noUpdateTTL: f = this.noUpdateTTL } = i, m = this.#P(t3, e, i.size || 0, o);
+    if (this.maxEntrySize && m > this.maxEntrySize) return r2 && (r2.set = "miss", r2.maxEntrySizeExceeded = true), this.#E(t3, "set"), this;
+    let c = this.#n === 0 ? void 0 : this.#s.get(t3);
+    if (c === void 0) c = this.#n === 0 ? this.#h : this.#b.length !== 0 ? this.#b.pop() : this.#n === this.#o ? this.#M(false) : this.#n, this.#i[c] = t3, this.#t[c] = e, this.#s.set(t3, c), this.#a[this.#h] = c, this.#u[c] = this.#h, this.#h = c, this.#n++, this.#U(c, m, r2), r2 && (r2.set = "add"), f = false, this.#x && this.#C?.(e, t3, "add");
+    else {
+      this.#D(c);
+      let d = this.#t[c];
+      if (e !== d) {
+        if (this.#v && this.#e(d)) {
+          d.__abortController.abort(new Error("replaced"));
+          let { __staleWhileFetching: g } = d;
+          g !== void 0 && !n && (this.#T && this.#w?.(g, t3, "set"), this.#f && this.#r?.push([g, t3, "set"]));
+        } else n || (this.#T && this.#w?.(d, t3, "set"), this.#f && this.#r?.push([d, t3, "set"]));
+        if (this.#W(c), this.#U(c, m, r2), this.#t[c] = e, r2) {
+          r2.set = "replace";
+          let g = d && this.#e(d) ? d.__staleWhileFetching : d;
+          g !== void 0 && (r2.oldValue = g);
+        }
+      } else r2 && (r2.set = "update");
+      this.#x && this.onInsert?.(e, t3, e === d ? "update" : "replace");
+    }
+    if (s !== 0 && !this.#d && this.#j(), this.#d && (f || this.#N(c, s, h), r2 && this.#z(r2, c)), !n && 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 t3 = this.#t[this.#l];
+        if (this.#M(true), this.#e(t3)) {
+          if (t3.__staleWhileFetching) return t3.__staleWhileFetching;
+        } else if (t3 !== void 0) return t3;
       }
     } 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 t3 = this.#r, e;
+        for (; e = t3?.shift(); ) this.#S?.(...e);
       }
     }
   }
-  #evict(free) {
-    const head = this.#head;
-    const k = this.#keyList[head];
-    const v = this.#valList[head];
-    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(head);
-    if (this.#autopurgeTimers?.[head]) {
-      clearTimeout(this.#autopurgeTimers[head]);
-      this.#autopurgeTimers[head] = void 0;
-    }
-    if (free) {
-      this.#keyList[head] = void 0;
-      this.#valList[head] = void 0;
-      this.#free.push(head);
-    }
-    if (this.#size === 1) {
-      this.#head = this.#tail = 0;
-      this.#free.length = 0;
-    } else {
-      this.#head = this.#next[head];
-    }
-    this.#keyMap.delete(k);
-    this.#size--;
-    return head;
+  #M(t3) {
+    let e = this.#l, i = 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, i, "evict"), this.#f && this.#r?.push([s, i, "evict"])), this.#W(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = void 0), t3 && (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(i), 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(t3, e = {}) {
+    let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = e, h = this.#s.get(t3);
+    if (h !== void 0) {
+      let n = this.#t[h];
+      if (this.#e(n) && n.__staleWhileFetching === void 0) return false;
+      if (this.#p(h)) s && (s.has = "stale", this.#z(s, h));
+      else return i && this.#R(h), s && (s.has = "hit", this.#z(s, h)), 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 } = ac.signal;
-      const ignoreAbort = options.ignoreFetchAbort && v2 !== void 0;
-      const proceed = options.ignoreFetchAbort || !!(options.allowStaleOnFetchAbort && v2 !== void 0);
-      if (options.status) {
-        if (aborted && !updateCache) {
-          options.status.fetchAborted = true;
-          options.status.fetchError = ac.signal.reason;
-          if (ignoreAbort)
-            options.status.fetchAbortIgnored = true;
-        } else {
-          options.status.fetchResolved = true;
-        }
-      }
-      if (aborted && !ignoreAbort && !updateCache) {
-        return fetchFail(ac.signal.reason, proceed);
-      }
-      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, false);
-    };
-    const fetchFail = (er, proceed) => {
-      const { aborted } = ac.signal;
-      const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
-      const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
-      const noDelete = allowStale || options.noDeleteOnFetchRejection;
-      const bf2 = p;
-      if (this.#valList[index] === p) {
-        const del = !noDelete || !proceed && 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);
-          }
-        }
+  peek(t3, e = {}) {
+    let { allowStale: i = this.allowStale } = e, s = this.#s.get(t3);
+    if (s === void 0 || !i && this.#p(s)) return;
+    let h = this.#t[s];
+    return this.#e(h) ? h.__staleWhileFetching : h;
+  }
+  #G(t3, e, i, s) {
+    let h = e === void 0 ? void 0 : this.#t[e];
+    if (this.#e(h)) return h;
+    let n = new C(), { signal: o } = i;
+    o?.addEventListener("abort", () => n.abort(o.reason), { signal: n.signal });
+    let r2 = { signal: n.signal, options: i, context: s }, f = (p, _ = false) => {
+      let { aborted: l } = n.signal, w = i.ignoreFetchAbort && p !== void 0, b = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && p !== void 0);
+      if (i.status && (l && !_ ? (i.status.fetchAborted = true, i.status.fetchError = n.signal.reason, w && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), l && !w && !_) return c(n.signal.reason, b);
+      let S = g, u = this.#t[e];
+      return (u === g || w && _ && u === void 0) && (p === void 0 ? S.__staleWhileFetching !== void 0 ? this.#t[e] = S.__staleWhileFetching : this.#E(t3, "fetch") : (i.status && (i.status.fetchUpdated = true), this.set(t3, p, r2.options))), p;
+    }, m = (p) => (i.status && (i.status.fetchRejected = true, i.status.fetchError = p), c(p, false)), c = (p, _) => {
+      let { aborted: l } = n.signal, w = l && i.allowStaleOnFetchAbort, b = w || i.allowStaleOnFetchRejection, S = b || i.noDeleteOnFetchRejection, u = g;
+      if (this.#t[e] === g && (!S || !_ && u.__staleWhileFetching === void 0 ? this.#E(t3, "fetch") : w || (this.#t[e] = u.__staleWhileFetching)), b) return i.status && u.__staleWhileFetching !== void 0 && (i.status.returnedStale = true), u.__staleWhileFetching;
+      if (u.__returned === u) throw p;
+    }, d = (p, _) => {
+      let l = this.#L?.(t3, h, r2);
+      l && l instanceof Promise && l.then((w) => p(w === void 0 ? void 0 : w), _), n.signal.addEventListener("abort", () => {
+        (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (p(void 0), i.allowStaleOnFetchAbort && (p = (w) => f(w, 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);
+    i.status && (i.status.fetchDispatched = true);
+    let g = new Promise(d).then(f, m), A = Object.assign(g, { __abortController: n, __staleWhileFetching: h, __returned: void 0 });
+    return e === void 0 ? (this.set(t3, A, { ...r2.options, status: void 0 }), e = this.#s.get(t3)) : this.#t[e] = A, A;
+  }
+  #e(t3) {
+    if (!this.#v) return false;
+    let e = t3;
+    return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof C;
+  }
+  async fetch(t3, e = {}) {
+    let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: h = this.noDeleteOnStaleGet, ttl: n = this.ttl, noDisposeOnSet: o = this.noDisposeOnSet, size: r2 = 0, sizeCalculation: f = this.sizeCalculation, noUpdateTTL: m = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: g = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: p, forceRefresh: _ = false, status: l, signal: w } = e;
+    if (!this.#v) return l && (l.fetch = "get"), this.get(t3, { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: h, status: l });
+    let b = { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: h, ttl: n, noDisposeOnSet: o, size: r2, sizeCalculation: f, noUpdateTTL: m, noDeleteOnFetchRejection: c, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: g, status: l, signal: w }, S = this.#s.get(t3);
+    if (S === void 0) {
+      l && (l.fetch = "miss");
+      let u = this.#G(t3, S, b, p);
+      return u.__returned = u;
     } 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
-      });
-    }
-    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;
-    } 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, getOptions2 = {}) {
-    const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions2;
-    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 u = this.#t[S];
+      if (this.#e(u)) {
+        let E = i && u.__staleWhileFetching !== void 0;
+        return l && (l.fetch = "inflight", E && (l.returnedStale = true)), E ? u.__staleWhileFetching : u.__returned = u;
       }
-    } else if (status) {
-      status.get = "miss";
+      let T = this.#p(S);
+      if (!_ && !T) return l && (l.fetch = "hit"), this.#D(S), s && this.#R(S), l && this.#z(l, S), u;
+      let F = this.#G(t3, S, b, p), O = F.__staleWhileFetching !== void 0 && i;
+      return l && (l.fetch = T ? "stale" : "refresh", O && T && (l.returnedStale = true)), O ? F.__staleWhileFetching : F.__returned = F;
     }
   }
-  #connect(p, n) {
-    this.#prev[n] = p;
-    this.#next[p] = n;
-  }
-  #moveToTail(index) {
-    if (index !== this.#tail) {
-      if (index === this.#head) {
-        this.#head = this.#next[index];
-      } else {
-        this.#connect(this.#prev[index], this.#next[index]);
-      }
-      this.#connect(this.#tail, index);
-      this.#tail = index;
-    }
+  async forceFetch(t3, e = {}) {
+    let i = await this.fetch(t3, e);
+    if (i === void 0) throw new Error("fetch() returned undefined");
+    return i;
   }
-  /**
-   * 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) {
-        if (this.#autopurgeTimers?.[index]) {
-          clearTimeout(this.#autopurgeTimers?.[index]);
-          this.#autopurgeTimers[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(t3, e = {}) {
+    let i = this.#I;
+    if (!i) throw new Error("no memoMethod provided to constructor");
+    let { context: s, forceRefresh: h, ...n } = e, o = this.get(t3, n);
+    if (!h && o !== void 0) return o;
+    let r2 = i(t3, o, { options: n, context: s });
+    return this.set(t3, r2, n), r2;
+  }
+  get(t3, e = {}) {
+    let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: h = this.noDeleteOnStaleGet, status: n } = e, o = this.#s.get(t3);
+    if (o !== void 0) {
+      let r2 = this.#t[o], f = this.#e(r2);
+      return n && this.#z(n, o), this.#p(o) ? (n && (n.get = "stale"), f ? (n && i && r2.__staleWhileFetching !== void 0 && (n.returnedStale = true), i ? r2.__staleWhileFetching : void 0) : (h || this.#E(t3, "expire"), n && i && (n.returnedStale = true), i ? r2 : void 0)) : (n && (n.get = "hit"), f ? r2.__staleWhileFetching : (this.#D(o), s && this.#R(o), r2));
+    } else n && (n.get = "miss");
+  }
+  #k(t3, e) {
+    this.#u[e] = t3, this.#a[t3] = e;
+  }
+  #D(t3) {
+    t3 !== this.#h && (t3 === this.#l ? this.#l = this.#a[t3] : this.#k(this.#u[t3], this.#a[t3]), this.#k(this.#h, t3), this.#h = t3);
+  }
+  delete(t3) {
+    return this.#E(t3, "delete");
+  }
+  #E(t3, e) {
+    let i = false;
+    if (this.#n !== 0) {
+      let s = this.#s.get(t3);
+      if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = true, this.#n === 1) this.#V(e);
+      else {
+        this.#W(s);
+        let h = this.#t[s];
+        if (this.#e(h) ? h.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(h, t3, e), this.#f && this.#r?.push([h, t3, e])), this.#s.delete(t3), 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 n = this.#u[s];
+          this.#a[n] = this.#a[s];
+          let o = this.#a[s];
+          this.#u[o] = 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, h;
+      for (; h = s?.shift(); ) this.#S?.(...h);
     }
-    return deleted;
+    return i;
   }
-  /**
-   * 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]);
-        }
-      }
-    }
-    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);
-      for (const t3 of this.#autopurgeTimers ?? []) {
-        if (t3 !== void 0)
-          clearTimeout(t3);
+  #V(t3) {
+    for (let e of this.#O({ allowStale: true })) {
+      let i = this.#t[e];
+      if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
+      else {
+        let s = this.#i[e];
+        this.#T && this.#w?.(i, s, t3), this.#f && this.#r?.push([i, s, t3]);
       }
-      this.#autopurgeTimers?.fill(void 0);
     }
-    if (this.#sizes) {
-      this.#sizes.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);
     }
-    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, i;
+      for (; i = e?.shift(); ) this.#S?.(...i);
     }
   }
 };
@@ -4778,7 +3898,7 @@ function collectAllComponentNames(options) {
   for (const key of manifestCache.keys()) {
     names.add(key);
   }
-  return Array.from(names).sort((a, b) => a.localeCompare(b));
+  return Array.from(names).sort((a3, b) => a3.localeCompare(b));
 }
 async function writeManifestFile(options) {
   const {
@@ -4798,7 +3918,7 @@ async function writeManifestFile(options) {
     manifestMap.set(componentName, match2.value.from);
   }
   const manifest = Object.fromEntries(
-    Array.from(manifestMap.entries()).sort(([a], [b]) => a.localeCompare(b))
+    Array.from(manifestMap.entries()).sort(([a3], [b]) => a3.localeCompare(b))
   );
   manifestCache.clear();
   for (const [componentName, fromPath] of manifestMap.entries()) {
@@ -4940,7 +4060,7 @@ function createHtmlCustomDataDefinition(componentNames, getMetadata, baseTags =
       ...combinedTypes.keys(),
       ...docs.keys()
     ]);
-    const attributes = Array.from(attributeNames2).sort((a, b) => a.localeCompare(b)).map((propName) => {
+    const attributes = Array.from(attributeNames2).sort((a3, b) => a3.localeCompare(b)).map((propName) => {
       const type = combinedTypes.get(propName);
       const doc = docs.get(propName);
       const pieces = [];
@@ -5011,7 +4131,7 @@ function mergeHtmlCustomDataTags(baseTags, extraTags) {
       references: mergedReferences
     });
   }
-  return Array.from(tagMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+  return Array.from(tagMap.values()).sort((a3, b) => a3.name.localeCompare(b.name));
 }
 function mergeHtmlAttributes(baseAttributes, extraAttributes) {
   if (!baseAttributes?.length) {
@@ -5042,7 +4162,7 @@ function mergeHtmlAttributes(baseAttributes, extraAttributes) {
       values: mergeAttributeValues(existing.values, attr.values)
     });
   }
-  return Array.from(attrMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+  return Array.from(attrMap.values()).sort((a3, b) => a3.name.localeCompare(b.name));
 }
 function mergeAttributeValues(baseValues, extraValues) {
   if (!baseValues?.length) {
@@ -5131,7 +4251,7 @@ function formatComponentEntry(name, props) {
   }
   const lines = [`${indent}${key}: {`];
   const innerIndent = `${indent}  `;
-  const entries = Array.from(props.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+  const entries = Array.from(props.entries()).sort((a3, b) => a3[0].localeCompare(b[0]));
   for (const [propName, type] of entries) {
     const formattedProp = formatPropertyKey(propName);
     lines.push(`${innerIndent}readonly ${formattedProp}?: ${type};`);
@@ -5173,7 +4293,7 @@ function formatPropsType(props) {
   if (!props || props.size === 0) {
     return "Record<string, any>";
   }
-  const entries = Array.from(props.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+  const entries = Array.from(props.entries()).sort((a3, b) => a3[0].localeCompare(b[0]));
   const lines = ["{"];
   for (const [propName, type] of entries) {
     const key = formatPropertyKey(propName);
@@ -8624,7 +7744,7 @@ function createResolverHelpers(state) {
 }
 
 // src/runtime/autoImport/service/index.ts
-var logWarnCache = new LRUCache({
+var logWarnCache = new L({
   max: 512,
   ttl: 1e3 * 60 * 60
 });
@@ -8927,11 +8047,11 @@ function cloneCandidate(candidate) {
     jsonPath: candidate.jsonPath
   };
 }
-function areSetsEqual(a, b) {
-  if (a.size !== b.size) {
+function areSetsEqual(a3, b) {
+  if (a3.size !== b.size) {
     return false;
   }
-  for (const value of a) {
+  for (const value of a3) {
     if (!b.has(value)) {
       return false;
     }
@@ -9118,31 +8238,31 @@ async function scanRoutes(ctx, candidatesMap) {
   const entries = Array.from(entriesSet);
   const subPackageList = Array.from(subPackages.entries()).map(([root, value]) => {
     const pagesArray = Array.from(value);
-    pagesArray.sort((a, b) => a.localeCompare(b));
+    pagesArray.sort((a3, b) => a3.localeCompare(b));
     return {
       root,
       pages: pagesArray
     };
   });
-  pages.sort((a, b) => {
-    if (a === "pages/index/index") {
+  pages.sort((a3, b) => {
+    if (a3 === "pages/index/index") {
       return -1;
     }
     if (b === "pages/index/index") {
       return 1;
     }
-    return a.localeCompare(b);
+    return a3.localeCompare(b);
   });
-  entries.sort((a, b) => {
-    if (a === "pages/index/index") {
+  entries.sort((a3, b) => {
+    if (a3 === "pages/index/index") {
       return -1;
     }
     if (b === "pages/index/index") {
       return 1;
     }
-    return a.localeCompare(b);
+    return a3.localeCompare(b);
   });
-  subPackageList.sort((a, b) => a.root.localeCompare(b.root));
+  subPackageList.sort((a3, b) => a3.root.localeCompare(b.root));
   const snapshot = {
     pages,
     entries,
@@ -16247,17 +15367,17 @@ function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, ba
   }
   throw exportsNotFound(packageSubpath, packageJsonUrl, base);
 }
-function patternKeyCompare(a, b) {
-  const aPatternIndex = a.indexOf("*");
+function patternKeyCompare(a3, b) {
+  const aPatternIndex = a3.indexOf("*");
   const bPatternIndex = b.indexOf("*");
-  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
+  const baseLengthA = aPatternIndex === -1 ? a3.length : aPatternIndex + 1;
   const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
   if (baseLengthA > baseLengthB) return -1;
   if (baseLengthB > baseLengthA) return 1;
   if (aPatternIndex === -1) return 1;
   if (bPatternIndex === -1) return -1;
-  if (a.length > b.length) return -1;
-  if (b.length > a.length) return 1;
+  if (a3.length > b.length) return -1;
+  if (b.length > a3.length) return 1;
   return 0;
 }
 function packageImportsResolve(name, base, conditions) {
@@ -18805,8 +17925,8 @@ init_esm_shims();
 
 // ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
 init_esm_shims();
-var balanced = (a, b, str) => {
-  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+var balanced = (a3, b, str) => {
+  const ma = a3 instanceof RegExp ? maybeMatch(a3, str) : a3;
   const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
   const r2 = ma !== null && mb != null && range(ma, mb, str);
   return r2 && {
@@ -18821,13 +17941,13 @@ var maybeMatch = (reg, str) => {
   const m = str.match(reg);
   return m ? m[0] : null;
 };
-var range = (a, b, str) => {
+var range = (a3, b, str) => {
   let begs, beg, left, right = void 0, result;
-  let ai = str.indexOf(a);
+  let ai = str.indexOf(a3);
   let bi = str.indexOf(b, ai + 1);
   let i = ai;
   if (ai >= 0 && bi > 0) {
-    if (a === b) {
+    if (a3 === b) {
       return [ai, bi];
     }
     begs = [];
@@ -18835,7 +17955,7 @@ var range = (a, b, str) => {
     while (i >= 0 && !result) {
       if (i === ai) {
         begs.push(i);
-        ai = str.indexOf(a, i + 1);
+        ai = str.indexOf(a3, i + 1);
       } else if (begs.length === 1) {
         const r2 = begs.pop();
         if (r2 !== void 0)
@@ -18918,11 +18038,11 @@ function embrace(str) {
 function isPadded(el) {
   return /^-?0\d/.test(el);
 }
-function lte(i, y) {
-  return i <= y;
+function lte(i, y2) {
+  return i <= y2;
 }
-function gte(i, y) {
-  return i >= y;
+function gte(i, y2) {
+  return i >= y2;
 }
 function expand_(str, isTop) {
   const expansions = [];
@@ -18962,19 +18082,19 @@ function expand_(str, isTop) {
     }
     let N;
     if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-      const x = numeric(n[0]);
-      const y = numeric(n[1]);
+      const x2 = numeric(n[0]);
+      const y2 = numeric(n[1]);
       const width = Math.max(n[0].length, n[1].length);
       let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
       let test = lte;
-      const reverse = y < x;
+      const reverse = y2 < x2;
       if (reverse) {
         incr *= -1;
         test = gte;
       }
       const pad = n.some(isPadded);
       N = [];
-      for (let i = x; test(i, y); i += incr) {
+      for (let i = x2; test(i, y2); i += incr) {
         let c;
         if (isAlphaSequence) {
           c = String.fromCharCode(i);
@@ -18986,11 +18106,11 @@ function expand_(str, isTop) {
           if (pad) {
             const need = width - c.length;
             if (need > 0) {
-              const z = new Array(need + 1).join("0");
+              const z2 = new Array(need + 1).join("0");
               if (i < 0) {
-                c = "-" + z + c.slice(1);
+                c = "-" + z2 + c.slice(1);
               } else {
-                c = z + c;
+                c = z2 + c;
               }
             }
           }
@@ -19707,7 +18827,7 @@ var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
 var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
 var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
 minimatch.filter = filter;
-var ext = (a, b = {}) => Object.assign({}, a, b);
+var ext = (a3, b = {}) => Object.assign({}, a3, b);
 var defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
@@ -20064,30 +19184,30 @@ var Minimatch = class {
     }
     return globParts.filter((gs) => gs.length);
   }
-  partsMatch(a, b, emptyGSMatch = false) {
+  partsMatch(a3, b, emptyGSMatch = false) {
     let ai = 0;
     let bi = 0;
     let result = [];
     let which = "";
-    while (ai < a.length && bi < b.length) {
-      if (a[ai] === b[bi]) {
-        result.push(which === "b" ? b[bi] : a[ai]);
+    while (ai < a3.length && bi < b.length) {
+      if (a3[ai] === b[bi]) {
+        result.push(which === "b" ? b[bi] : a3[ai]);
         ai++;
         bi++;
-      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
-        result.push(a[ai]);
+      } else if (emptyGSMatch && a3[ai] === "**" && b[bi] === a3[ai + 1]) {
+        result.push(a3[ai]);
         ai++;
-      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+      } else if (emptyGSMatch && b[bi] === "**" && a3[ai] === b[bi + 1]) {
         result.push(b[bi]);
         bi++;
-      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+      } else if (a3[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
         if (which === "b")
           return false;
         which = "a";
-        result.push(a[ai]);
+        result.push(a3[ai]);
         ai++;
         bi++;
-      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+      } else if (b[bi] === "*" && a3[ai] && (this.options.dot || !a3[ai].startsWith(".")) && a3[ai] !== "**") {
         if (which === "a")
           return false;
         which = "b";
@@ -20098,7 +19218,7 @@ var Minimatch = class {
         return false;
       }
     }
-    return a.length === b.length && result;
+    return a3.length === b.length && result;
   }
   parseNegate() {
     if (this.nonegate)
@@ -20586,8 +19706,8 @@ var Minipass = class extends EventEmitter {
    * behavior.  Ie, a sync stream can be made async, but an async stream
    * cannot be safely made sync.
    */
-  set ["async"](a) {
-    this[ASYNC] = this[ASYNC] || !!a;
+  set ["async"](a3) {
+    this[ASYNC] = this[ASYNC] || !!a3;
   }
   // drop everything and get out of the flow completely
   [ABORT]() {
@@ -21299,7 +20419,7 @@ var ENOREALPATH = 512;
 var ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
 var TYPEMASK = 1023;
 var entToType = (s) => s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
-var normalizeCache = new LRUCache({ max: 2 ** 12 });
+var normalizeCache = new L({ max: 2 ** 12 });
 var normalize2 = (s) => {
   const c = normalizeCache.get(s);
   if (c)
@@ -21308,7 +20428,7 @@ var normalize2 = (s) => {
   normalizeCache.set(s, n);
   return n;
 };
-var normalizeNocaseCache = new LRUCache({ max: 2 ** 12 });
+var normalizeNocaseCache = new L({ max: 2 ** 12 });
 var normalizeNocase = (s) => {
   const c = normalizeNocaseCache.get(s);
   if (c)
@@ -21317,17 +20437,17 @@ var normalizeNocase = (s) => {
   normalizeNocaseCache.set(s, n);
   return n;
 };
-var ResolveCache = class extends LRUCache {
+var ResolveCache = class extends L {
   constructor() {
     super({ max: 256 });
   }
 };
-var ChildrenCache = class extends LRUCache {
+var ChildrenCache = class extends L {
   constructor(maxSize = 16 * 1024) {
     super({
       maxSize,
       // parent + children
-      sizeCalculation: (a) => a.length + 1
+      sizeCalculation: (a3) => a3.length + 1
     });
   }
 };
@@ -24665,7 +23785,7 @@ var wrap = (fn) => async (path81, opt) => {
     path81 = await glob(path81, options.glob);
   }
   if (Array.isArray(path81)) {
-    return !!(await Promise.all(path81.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
+    return !!(await Promise.all(path81.map((p) => fn(path_arg_default(p, options), options)))).reduce((a3, b) => a3 && b, true);
   } else {
     return !!await fn(path_arg_default(path81, options), options);
   }
@@ -24676,7 +23796,7 @@ var wrapSync = (fn) => (path81, opt) => {
     path81 = globSync(path81, options.glob);
   }
   if (Array.isArray(path81)) {
-    return !!path81.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
+    return !!path81.map((p) => fn(path_arg_default(p, options), options)).reduce((a3, b) => a3 && b, true);
   } else {
     return !!fn(path_arg_default(path81, options), options);
   }
@@ -28661,9 +27781,9 @@ function analyzeAppJson(json) {
   const entries = [];
   const pages = json.pages ?? [];
   const components = Object.values(get3(json, "usingComponents") ?? {});
-  const subPackages = [...json.subPackages ?? [], ...json.subpackages ?? []].filter((x) => !x.independent).reduce(
+  const subPackages = [...json.subPackages ?? [], ...json.subpackages ?? []].filter((x2) => !x2.independent).reduce(
     (acc, cur) => {
-      acc.push(...(cur.pages ?? []).map((x) => `${cur.root}/${x}`));
+      acc.push(...(cur.pages ?? []).map((x2) => `${cur.root}/${x2}`));
       if (cur.entry) {
         acc.push(`${cur.root}/${removeExtension(cur.entry)}`);
       }
@@ -31295,7 +30415,7 @@ async function cssPostProcess(code, options) {
 }
 
 // src/plugins/css/shared/preprocessor.ts
-var cssCodeCache = new LRUCache({
+var cssCodeCache = new L({
   max: 512
 });
 var sharedStyleCache = /* @__PURE__ */ new Map();
@@ -32875,7 +31995,7 @@ import { defu as defu4 } from "@weapp-core/shared";
 
 // src/wxml/scan/cache.ts
 init_esm_shims();
-var scanWxmlCache = new LRUCache(
+var scanWxmlCache = new L(
   {
     max: 512
   }
@@ -35557,7 +34677,7 @@ function parseWxml(options) {
   );
   parser.end();
   if (removalRanges.length > 1) {
-    removalRanges.sort((a, b) => b.start - a.start);
+    removalRanges.sort((a3, b) => b.start - a3.start);
   }
   const token = {
     components,
@@ -36847,7 +35967,7 @@ init_esm_shims();
 import { removeExtension as removeExtension3 } from "@weapp-core/shared";
 import fs34 from "fs-extra";
 import path69 from "pathe";
-var wxsCodeCache = new LRUCache({
+var wxsCodeCache = new L({
   max: 512
 });
 async function transformWxsFile(state, wxsPath) {
@@ -38233,9 +37353,9 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
       }
       if (keys.length > 0) {
         await Promise.all(
-          keys.map((x) => {
+          keys.map((x2) => {
             return buildPackage({
-              dep: x,
+              dep: x2,
               outDir,
               options,
               isDependenciesCacheOutdate
@@ -38269,9 +37389,9 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
       });
       if (keys.length > 0) {
         await Promise.all(
-          keys.filter((x) => isBuiltin(x)).map((x) => {
+          keys.filter((x2) => isBuiltin(x2)).map((x2) => {
             return buildPackage({
-              dep: `${x}/`,
+              dep: `${x2}/`,
               outDir,
               options,
               isDependenciesCacheOutdate
@@ -38451,49 +37571,49 @@ function createNpmService(ctx) {
           );
           await cache2.writeDependenciesCache();
           const targetDirs = [
-            ...subRelations.map((x) => {
+            ...subRelations.map((x2) => {
               return {
-                npmDistDir: path75.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, npmDistDirName)
+                npmDistDir: path75.resolve(ctx.configService.cwd, x2.miniprogramNpmDistDir, npmDistDirName)
               };
             }),
-            ...[...ctx.scanService.independentSubPackageMap.values()].map((x) => {
-              const dependencies2 = x.subPackage.dependencies;
+            ...[...ctx.scanService.independentSubPackageMap.values()].map((x2) => {
+              const dependencies2 = x2.subPackage.dependencies;
               return {
-                root: x.subPackage.root,
+                root: x2.subPackage.root,
                 dependencies: dependencies2,
-                npmDistDir: path75.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, npmDistDirName)
+                npmDistDir: path75.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x2.subPackage.root, npmDistDirName)
               };
             })
           ];
-          await Promise.all(targetDirs.map(async (x) => {
-            if (x.root) {
-              const isDependenciesCacheOutdate2 = await cache2.checkDependenciesCacheOutdate(x.root);
-              if (isDependenciesCacheOutdate2 || !await fs38.pathExists(x.npmDistDir)) {
-                await fs38.copy(outDir, x.npmDistDir, {
+          await Promise.all(targetDirs.map(async (x2) => {
+            if (x2.root) {
+              const isDependenciesCacheOutdate2 = await cache2.checkDependenciesCacheOutdate(x2.root);
+              if (isDependenciesCacheOutdate2 || !await fs38.pathExists(x2.npmDistDir)) {
+                await fs38.copy(outDir, x2.npmDistDir, {
                   overwrite: true,
                   filter: (src) => {
-                    if (Array.isArray(x.dependencies)) {
+                    if (Array.isArray(x2.dependencies)) {
                       const relPath = toPosixPath(path75.relative(outDir, src));
                       if (relPath === "") {
                         return true;
                       }
-                      return regExpTest(x.dependencies, relPath);
+                      return regExpTest(x2.dependencies, relPath);
                     }
                     return true;
                   }
                 });
               }
-              await cache2.writeDependenciesCache(x.root);
+              await cache2.writeDependenciesCache(x2.root);
             } else {
-              await fs38.copy(outDir, x.npmDistDir, {
+              await fs38.copy(outDir, x2.npmDistDir, {
                 overwrite: true,
                 filter: (src) => {
-                  if (Array.isArray(x.dependencies)) {
+                  if (Array.isArray(x2.dependencies)) {
                     const relPath = toPosixPath(path75.relative(outDir, src));
                     if (relPath === "") {
                       return true;
                     }
-                    return regExpTest(x.dependencies, relPath);
+                    return regExpTest(x2.dependencies, relPath);
                   }
                   return true;
                 }
@@ -38652,7 +37772,7 @@ var PriorityQueue = class {
       this.#queue.push(element);
       return;
     }
-    const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+    const index = lowerBound(this.#queue, element, (a3, b) => b.priority - a3.priority);
     this.#queue.splice(index, 0, element);
   }
   setPriority(id, priority) {
@@ -39381,7 +38501,7 @@ var FileCache = class {
   constructor(max = 1024) {
     this.mtimeMap = /* @__PURE__ */ new Map();
     this.signatureMap = /* @__PURE__ */ new Map();
-    this.cache = new LRUCache({
+    this.cache = new L({
       max,
       dispose: (_value, key) => {
         this.mtimeMap.delete(key);
@@ -40384,11 +39504,11 @@ function createWxmlService(ctx) {
     cache2.set(filepath, res);
     await addDeps(
       filepath,
-      res.deps.filter((x) => isImportTag(x.tagName) && isTemplate(x.value)).map((x) => {
-        if (x.value.startsWith("/")) {
-          return path80.resolve(configService.absoluteSrcRoot, x.value.slice(1));
+      res.deps.filter((x2) => isImportTag(x2.tagName) && isTemplate(x2.value)).map((x2) => {
+        if (x2.value.startsWith("/")) {
+          return path80.resolve(configService.absoluteSrcRoot, x2.value.slice(1));
         } else {
-          return path80.resolve(dirname5, x.value);
+          return path80.resolve(dirname5, x2.value);
         }
       })
     );