@settlemint/sdk-cli 2.2.3-pr0f5033c1 → 2.2.3-pr19ac75c7

package/dist/cli.js

@@ -29768,7 +29768,7 @@ var require_lib3 = __commonJS((exports, module) => {
   };
 });
 
-// ../../node_modules/lru-cache/dist/commonjs/index.js
+// ../../node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/index.js
 var require_commonjs = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.LRUCache = undefined;
@@ -32623,8 +32623,1123 @@ globstar while`, file, fr, pattern, pr, swallowee);
   exports.minimatch.unescape = unescape_js_1.unescape;
 });
 
-// ../../node_modules/minipass/dist/commonjs/index.js
+// ../../node_modules/path-scurry/node_modules/lru-cache/dist/commonjs/index.js
 var require_commonjs3 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LRUCache = undefined;
+  var perf2 = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+  var warned2 = new Set;
+  var PROCESS2 = typeof process === "object" && !!process ? process : {};
+  var emitWarning2 = (msg, type2, code, fn) => {
+    typeof PROCESS2.emitWarning === "function" ? PROCESS2.emitWarning(msg, type2, code, fn) : console.error(`[${code}] ${type2}: ${msg}`);
+  };
+  var AC2 = globalThis.AbortController;
+  var AS2 = globalThis.AbortSignal;
+  if (typeof AC2 === "undefined") {
+    AS2 = class AbortSignal2 {
+      onabort;
+      _onabort = [];
+      reason;
+      aborted = false;
+      addEventListener(_, fn) {
+        this._onabort.push(fn);
+      }
+    };
+    AC2 = class AbortController2 {
+      constructor() {
+        warnACPolyfill();
+      }
+      signal = new AS2;
+      abort(reason) {
+        if (this.signal.aborted)
+          return;
+        this.signal.reason = reason;
+        this.signal.aborted = true;
+        for (const fn of this.signal._onabort) {
+          fn(reason);
+        }
+        this.signal.onabort?.(reason);
+      }
+    };
+    let printACPolyfillWarning = PROCESS2.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+    const warnACPolyfill = () => {
+      if (!printACPolyfillWarning)
+        return;
+      printACPolyfillWarning = false;
+      emitWarning2("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);
+    };
+  }
+  var shouldWarn2 = (code) => !warned2.has(code);
+  var TYPE2 = Symbol("type");
+  var isPosInt2 = (n2) => n2 && n2 === Math.floor(n2) && n2 > 0 && isFinite(n2);
+  var getUintArray2 = (max) => !isPosInt2(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 ? ZeroArray2 : null;
+
+  class ZeroArray2 extends Array {
+    constructor(size) {
+      super(size);
+      this.fill(0);
+    }
+  }
+
+  class Stack2 {
+    heap;
+    length;
+    static #constructing = false;
+    static create(max) {
+      const HeapCls = getUintArray2(max);
+      if (!HeapCls)
+        return [];
+      Stack2.#constructing = true;
+      const s = new Stack2(max, HeapCls);
+      Stack2.#constructing = false;
+      return s;
+    }
+    constructor(max, HeapCls) {
+      if (!Stack2.#constructing) {
+        throw new TypeError("instantiate Stack using Stack.create(n)");
+      }
+      this.heap = new HeapCls(max);
+      this.length = 0;
+    }
+    push(n2) {
+      this.heap[this.length++] = n2;
+    }
+    pop() {
+      return this.heap[--this.length];
+    }
+  }
+
+  class LRUCache2 {
+    #max;
+    #maxSize;
+    #dispose;
+    #disposeAfter;
+    #fetchMethod;
+    #memoMethod;
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    static unsafeExposeInternals(c) {
+      return {
+        starts: c.#starts,
+        ttls: c.#ttls,
+        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,
+        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)
+      };
+    }
+    get max() {
+      return this.#max;
+    }
+    get maxSize() {
+      return this.#maxSize;
+    }
+    get calculatedSize() {
+      return this.#calculatedSize;
+    }
+    get size() {
+      return this.#size;
+    }
+    get fetchMethod() {
+      return this.#fetchMethod;
+    }
+    get memoMethod() {
+      return this.#memoMethod;
+    }
+    get dispose() {
+      return this.#dispose;
+    }
+    get disposeAfter() {
+      return this.#disposeAfter;
+    }
+    constructor(options) {
+      const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+      if (max !== 0 && !isPosInt2(max)) {
+        throw new TypeError("max option must be a nonnegative integer");
+      }
+      const UintArray = max ? getUintArray2(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 !== undefined && typeof memoMethod !== "function") {
+        throw new TypeError("memoMethod must be a function if defined");
+      }
+      this.#memoMethod = memoMethod;
+      if (fetchMethod !== undefined && typeof fetchMethod !== "function") {
+        throw new TypeError("fetchMethod must be a function if specified");
+      }
+      this.#fetchMethod = fetchMethod;
+      this.#hasFetchMethod = !!fetchMethod;
+      this.#keyMap = new Map;
+      this.#keyList = new Array(max).fill(undefined);
+      this.#valList = new Array(max).fill(undefined);
+      this.#next = new UintArray(max);
+      this.#prev = new UintArray(max);
+      this.#head = 0;
+      this.#tail = 0;
+      this.#free = Stack2.create(max);
+      this.#size = 0;
+      this.#calculatedSize = 0;
+      if (typeof dispose === "function") {
+        this.#dispose = dispose;
+      }
+      if (typeof disposeAfter === "function") {
+        this.#disposeAfter = disposeAfter;
+        this.#disposed = [];
+      } else {
+        this.#disposeAfter = undefined;
+        this.#disposed = undefined;
+      }
+      this.#hasDispose = !!this.#dispose;
+      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 (!isPosInt2(this.#maxSize)) {
+            throw new TypeError("maxSize must be a positive integer if specified");
+          }
+        }
+        if (!isPosInt2(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 = isPosInt2(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+      this.ttlAutopurge = !!ttlAutopurge;
+      this.ttl = ttl || 0;
+      if (this.ttl) {
+        if (!isPosInt2(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 (shouldWarn2(code)) {
+          warned2.add(code);
+          const msg = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
+          emitWarning2(msg, "UnboundedCacheWarning", code, LRUCache2);
+        }
+      }
+    }
+    getRemainingTTL(key2) {
+      return this.#keyMap.has(key2) ? Infinity : 0;
+    }
+    #initializeTTLTracking() {
+      const ttls = new ZeroArray2(this.#max);
+      const starts = new ZeroArray2(this.#max);
+      this.#ttls = ttls;
+      this.#starts = starts;
+      this.#setItemTTL = (index, ttl, start = perf2.now()) => {
+        starts[index] = ttl !== 0 ? start : 0;
+        ttls[index] = ttl;
+        if (ttl !== 0 && this.ttlAutopurge) {
+          const t3 = setTimeout(() => {
+            if (this.#isStale(index)) {
+              this.#delete(this.#keyList[index], "expire");
+            }
+          }, ttl + 1);
+          if (t3.unref) {
+            t3.unref();
+          }
+        }
+      };
+      this.#updateItemAge = (index) => {
+        starts[index] = ttls[index] !== 0 ? perf2.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 n2 = perf2.now();
+        if (this.ttlResolution > 0) {
+          cachedNow = n2;
+          const t3 = setTimeout(() => cachedNow = 0, this.ttlResolution);
+          if (t3.unref) {
+            t3.unref();
+          }
+        }
+        return n2;
+      };
+      this.getRemainingTTL = (key2) => {
+        const index = this.#keyMap.get(key2);
+        if (index === undefined) {
+          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;
+      };
+    }
+    #updateItemAge = () => {};
+    #statusTTL = () => {};
+    #setItemTTL = () => {};
+    #isStale = () => false;
+    #initializeSizeTracking() {
+      const sizes = new ZeroArray2(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 (!isPosInt2(size)) {
+          if (sizeCalculation) {
+            if (typeof sizeCalculation !== "function") {
+              throw new TypeError("sizeCalculation must be a function");
+            }
+            size = sizeCalculation(v, k);
+            if (!isPosInt2(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;
+        }
+      };
+    }
+    #removeItemSize = (_i) => {};
+    #addItemSize = (_i, _s, _st) => {};
+    #requireSize = (_k, _v, size, sizeCalculation) => {
+      if (size || sizeCalculation) {
+        throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+      }
+      return 0;
+    };
+    *#indexes({ allowStale = this.allowStale } = {}) {
+      if (this.#size) {
+        for (let i2 = this.#tail;; ) {
+          if (!this.#isValidIndex(i2)) {
+            break;
+          }
+          if (allowStale || !this.#isStale(i2)) {
+            yield i2;
+          }
+          if (i2 === this.#head) {
+            break;
+          } else {
+            i2 = this.#prev[i2];
+          }
+        }
+      }
+    }
+    *#rindexes({ allowStale = this.allowStale } = {}) {
+      if (this.#size) {
+        for (let i2 = this.#head;; ) {
+          if (!this.#isValidIndex(i2)) {
+            break;
+          }
+          if (allowStale || !this.#isStale(i2)) {
+            yield i2;
+          }
+          if (i2 === this.#tail) {
+            break;
+          } else {
+            i2 = this.#next[i2];
+          }
+        }
+      }
+    }
+    #isValidIndex(index) {
+      return index !== undefined && this.#keyMap.get(this.#keyList[index]) === index;
+    }
+    *entries() {
+      for (const i2 of this.#indexes()) {
+        if (this.#valList[i2] !== undefined && this.#keyList[i2] !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield [this.#keyList[i2], this.#valList[i2]];
+        }
+      }
+    }
+    *rentries() {
+      for (const i2 of this.#rindexes()) {
+        if (this.#valList[i2] !== undefined && this.#keyList[i2] !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield [this.#keyList[i2], this.#valList[i2]];
+        }
+      }
+    }
+    *keys() {
+      for (const i2 of this.#indexes()) {
+        const k = this.#keyList[i2];
+        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield k;
+        }
+      }
+    }
+    *rkeys() {
+      for (const i2 of this.#rindexes()) {
+        const k = this.#keyList[i2];
+        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield k;
+        }
+      }
+    }
+    *values() {
+      for (const i2 of this.#indexes()) {
+        const v = this.#valList[i2];
+        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield this.#valList[i2];
+        }
+      }
+    }
+    *rvalues() {
+      for (const i2 of this.#rindexes()) {
+        const v = this.#valList[i2];
+        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield this.#valList[i2];
+        }
+      }
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+    [Symbol.toStringTag] = "LRUCache";
+    find(fn, getOptions = {}) {
+      for (const i2 of this.#indexes()) {
+        const v = this.#valList[i2];
+        const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value2 === undefined)
+          continue;
+        if (fn(value2, this.#keyList[i2], this)) {
+          return this.get(this.#keyList[i2], getOptions);
+        }
+      }
+    }
+    forEach(fn, thisp = this) {
+      for (const i2 of this.#indexes()) {
+        const v = this.#valList[i2];
+        const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value2 === undefined)
+          continue;
+        fn.call(thisp, value2, this.#keyList[i2], this);
+      }
+    }
+    rforEach(fn, thisp = this) {
+      for (const i2 of this.#rindexes()) {
+        const v = this.#valList[i2];
+        const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value2 === undefined)
+          continue;
+        fn.call(thisp, value2, this.#keyList[i2], this);
+      }
+    }
+    purgeStale() {
+      let deleted = false;
+      for (const i2 of this.#rindexes({ allowStale: true })) {
+        if (this.#isStale(i2)) {
+          this.#delete(this.#keyList[i2], "expire");
+          deleted = true;
+        }
+      }
+      return deleted;
+    }
+    info(key2) {
+      const i2 = this.#keyMap.get(key2);
+      if (i2 === undefined)
+        return;
+      const v = this.#valList[i2];
+      const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+      if (value2 === undefined)
+        return;
+      const entry = { value: value2 };
+      if (this.#ttls && this.#starts) {
+        const ttl = this.#ttls[i2];
+        const start = this.#starts[i2];
+        if (ttl && start) {
+          const remain = ttl - (perf2.now() - start);
+          entry.ttl = remain;
+          entry.start = Date.now();
+        }
+      }
+      if (this.#sizes) {
+        entry.size = this.#sizes[i2];
+      }
+      return entry;
+    }
+    dump() {
+      const arr = [];
+      for (const i2 of this.#indexes({ allowStale: true })) {
+        const key2 = this.#keyList[i2];
+        const v = this.#valList[i2];
+        const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value2 === undefined || key2 === undefined)
+          continue;
+        const entry = { value: value2 };
+        if (this.#ttls && this.#starts) {
+          entry.ttl = this.#ttls[i2];
+          const age = perf2.now() - this.#starts[i2];
+          entry.start = Math.floor(Date.now() - age);
+        }
+        if (this.#sizes) {
+          entry.size = this.#sizes[i2];
+        }
+        arr.unshift([key2, entry]);
+      }
+      return arr;
+    }
+    load(arr) {
+      this.clear();
+      for (const [key2, entry] of arr) {
+        if (entry.start) {
+          const age = Date.now() - entry.start;
+          entry.start = perf2.now() - age;
+        }
+        this.set(key2, entry.value, entry);
+      }
+    }
+    set(k, v, setOptions = {}) {
+      if (v === undefined) {
+        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 ? undefined : this.#keyMap.get(k);
+      if (index === undefined) {
+        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;
+      } 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 !== undefined && !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 !== undefined)
+              status.oldValue = oldValue;
+          }
+        } else if (status) {
+          status.set = "update";
+        }
+      }
+      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 dt2 = this.#disposed;
+        let task;
+        while (task = dt2?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+      return this;
+    }
+    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 !== undefined) {
+            return val;
+          }
+        }
+      } finally {
+        if (this.#hasDisposeAfter && this.#disposed) {
+          const dt2 = this.#disposed;
+          let task;
+          while (task = dt2?.shift()) {
+            this.#disposeAfter?.(...task);
+          }
+        }
+      }
+    }
+    #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 (free) {
+        this.#keyList[head] = undefined;
+        this.#valList[head] = undefined;
+        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;
+    }
+    has(k, hasOptions = {}) {
+      const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+      const index = this.#keyMap.get(k);
+      if (index !== undefined) {
+        const v = this.#valList[index];
+        if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === undefined) {
+          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";
+      }
+      return false;
+    }
+    peek(k, peekOptions = {}) {
+      const { allowStale = this.allowStale } = peekOptions;
+      const index = this.#keyMap.get(k);
+      if (index === undefined || !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 === undefined ? undefined : this.#valList[index];
+      if (this.#isBackgroundFetch(v)) {
+        return v;
+      }
+      const ac = new AC2;
+      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 !== undefined;
+        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);
+        }
+        const bf2 = p;
+        if (this.#valList[index] === p) {
+          if (v2 === undefined) {
+            if (bf2.__staleWhileFetching) {
+              this.#valList[index] = bf2.__staleWhileFetching;
+            } else {
+              this.#delete(k, "fetch");
+            }
+          } else {
+            if (options.status)
+              options.status.fetchUpdated = true;
+            this.set(k, v2, fetchOpts.options);
+          }
+        }
+        return v2;
+      };
+      const eb = (er) => {
+        if (options.status) {
+          options.status.fetchRejected = true;
+          options.status.fetchError = er;
+        }
+        return fetchFail(er);
+      };
+      const fetchFail = (er) => {
+        const { aborted } = 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 || bf2.__staleWhileFetching === undefined;
+          if (del) {
+            this.#delete(k, "fetch");
+          } else if (!allowStaleAborted) {
+            this.#valList[index] = bf2.__staleWhileFetching;
+          }
+        }
+        if (allowStale) {
+          if (options.status && bf2.__staleWhileFetching !== undefined) {
+            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 === undefined ? undefined : v2), rej);
+        }
+        ac.signal.addEventListener("abort", () => {
+          if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+            res(undefined);
+            if (options.allowStaleOnFetchAbort) {
+              res = (v2) => cb(v2, true);
+            }
+          }
+        });
+      };
+      if (options.status)
+        options.status.fetchDispatched = true;
+      const p = new Promise(pcall).then(cb, eb);
+      const bf = Object.assign(p, {
+        __abortController: ac,
+        __staleWhileFetching: v,
+        __returned: undefined
+      });
+      if (index === undefined) {
+        this.set(k, bf, { ...fetchOpts.options, status: undefined });
+        index = this.#keyMap.get(k);
+      } else {
+        this.#valList[index] = bf;
+      }
+      return bf;
+    }
+    #isBackgroundFetch(p) {
+      if (!this.#hasFetchMethod)
+        return false;
+      const b = p;
+      return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC2;
+    }
+    async fetch(k, fetchOptions = {}) {
+      const {
+        allowStale = this.allowStale,
+        updateAgeOnGet = this.updateAgeOnGet,
+        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+        ttl = this.ttl,
+        noDisposeOnSet = this.noDisposeOnSet,
+        size = 0,
+        sizeCalculation = this.sizeCalculation,
+        noUpdateTTL = this.noUpdateTTL,
+        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 === undefined) {
+        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 !== undefined;
+          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 !== undefined;
+        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 === undefined)
+        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 !== undefined)
+        return v;
+      const vv = memoMethod(k, v, {
+        options,
+        context
+      });
+      this.set(k, vv, options);
+      return vv;
+    }
+    get(k, getOptions = {}) {
+      const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+      const index = this.#keyMap.get(k);
+      if (index !== undefined) {
+        const value2 = this.#valList[index];
+        const fetching = this.#isBackgroundFetch(value2);
+        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 ? value2 : undefined;
+          } else {
+            if (status && allowStale && value2.__staleWhileFetching !== undefined) {
+              status.returnedStale = true;
+            }
+            return allowStale ? value2.__staleWhileFetching : undefined;
+          }
+        } else {
+          if (status)
+            status.get = "hit";
+          if (fetching) {
+            return value2.__staleWhileFetching;
+          }
+          this.#moveToTail(index);
+          if (updateAgeOnGet) {
+            this.#updateItemAge(index);
+          }
+          return value2;
+        }
+      } else if (status) {
+        status.get = "miss";
+      }
+    }
+    #connect(p, n2) {
+      this.#prev[n2] = p;
+      this.#next[p] = n2;
+    }
+    #moveToTail(index) {
+      if (index !== this.#tail) {
+        if (index === this.#head) {
+          this.#head = this.#next[index];
+        } else {
+          this.#connect(this.#prev[index], this.#next[index]);
+        }
+        this.#connect(this.#tail, index);
+        this.#tail = index;
+      }
+    }
+    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 !== undefined) {
+          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] = undefined;
+            this.#valList[index] = undefined;
+            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);
+          }
+        }
+      }
+      if (this.#hasDisposeAfter && this.#disposed?.length) {
+        const dt2 = this.#disposed;
+        let task;
+        while (task = dt2?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+      return deleted;
+    }
+    clear() {
+      return this.#clear("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(undefined);
+      this.#keyList.fill(undefined);
+      if (this.#ttls && this.#starts) {
+        this.#ttls.fill(0);
+        this.#starts.fill(0);
+      }
+      if (this.#sizes) {
+        this.#sizes.fill(0);
+      }
+      this.#head = 0;
+      this.#tail = 0;
+      this.#free.length = 0;
+      this.#calculatedSize = 0;
+      this.#size = 0;
+      if (this.#hasDisposeAfter && this.#disposed) {
+        const dt2 = this.#disposed;
+        let task;
+        while (task = dt2?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+    }
+  }
+  exports.LRUCache = LRUCache2;
+});
+
+// ../../node_modules/minipass/dist/commonjs/index.js
+var require_commonjs4 = __commonJS((exports) => {
   var __importDefault = exports && exports.__importDefault || function(mod) {
     return mod && mod.__esModule ? mod : { default: mod };
   };
@@ -33296,7 +34411,7 @@ var require_commonjs3 = __commonJS((exports) => {
 });
 
 // ../../node_modules/path-scurry/dist/commonjs/index.js
-var require_commonjs4 = __commonJS((exports) => {
+var require_commonjs5 = __commonJS((exports) => {
   var __createBinding = exports && exports.__createBinding || (Object.create ? function(o2, m, k, k2) {
     if (k2 === undefined)
       k2 = k;
@@ -33331,14 +34446,14 @@ var require_commonjs4 = __commonJS((exports) => {
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.PathScurry = exports.Path = exports.PathScurryDarwin = exports.PathScurryPosix = exports.PathScurryWin32 = exports.PathScurryBase = exports.PathPosix = exports.PathWin32 = exports.PathBase = exports.ChildrenCache = exports.ResolveCache = undefined;
-  var lru_cache_1 = require_commonjs();
+  var lru_cache_1 = require_commonjs3();
   var node_path_1 = __require("node:path");
   var node_url_1 = __require("node:url");
   var fs_1 = __require("fs");
   var actualFS2 = __importStar(__require("node:fs"));
   var realpathSync2 = fs_1.realpathSync.native;
   var promises_1 = __require("node:fs/promises");
-  var minipass_1 = require_commonjs3();
+  var minipass_1 = require_commonjs4();
   var defaultFS2 = {
     lstatSync: fs_1.lstatSync,
     readdir: fs_1.readdir,
@@ -35096,7 +36211,7 @@ var require_processor = __commonJS((exports) => {
 var require_walker2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.GlobStream = exports.GlobWalker = exports.GlobUtil = undefined;
-  var minipass_1 = require_commonjs3();
+  var minipass_1 = require_commonjs4();
   var ignore_js_1 = require_ignore2();
   var processor_js_1 = require_processor();
   var makeIgnore2 = (ignore, opts) => typeof ignore === "string" ? new ignore_js_1.Ignore([ignore], opts) : Array.isArray(ignore) ? new ignore_js_1.Ignore(ignore, opts) : ignore;
@@ -35435,7 +36550,7 @@ var require_glob = __commonJS((exports) => {
   exports.Glob = undefined;
   var minimatch_1 = require_commonjs2();
   var node_url_1 = __require("node:url");
-  var path_scurry_1 = require_commonjs4();
+  var path_scurry_1 = require_commonjs5();
   var pattern_js_1 = require_pattern();
   var walker_js_1 = require_walker2();
   var defaultPlatform4 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
@@ -35632,7 +36747,7 @@ var require_has_magic = __commonJS((exports) => {
 });
 
 // ../../node_modules/glob/dist/commonjs/index.js
-var require_commonjs5 = __commonJS((exports) => {
+var require_commonjs6 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.glob = exports.sync = exports.iterate = exports.iterateSync = exports.stream = exports.streamSync = exports.Ignore = exports.hasMagic = exports.Glob = exports.unescape = exports.escape = undefined;
   exports.globStreamSync = globStreamSync2;
@@ -36390,454 +37505,1569 @@ var require_retry = __commonJS((exports) => {
         }
       }
     }
-    for (var i2 = 0;i2 < methods.length; i2++) {
-      var method = methods[i2];
-      var original = obj[method];
-      obj[method] = function retryWrapper(original2) {
-        var op = exports.operation(options);
-        var args = Array.prototype.slice.call(arguments, 1);
-        var callback = args.pop();
-        args.push(function(err) {
-          if (op.retry(err)) {
-            return;
-          }
-          if (err) {
-            arguments[0] = op.mainError();
-          }
-          callback.apply(this, arguments);
-        });
-        op.attempt(function() {
-          original2.apply(obj, args);
-        });
-      }.bind(obj, original);
-      obj[method].options = options;
-    }
-  };
-});
-
-// ../../node_modules/promise-retry/index.js
-var require_promise_retry = __commonJS((exports, module) => {
-  var errcode = require_err_code();
-  var retry = require_retry();
-  var hasOwn = Object.prototype.hasOwnProperty;
-  function isRetryError(err) {
-    return err && err.code === "EPROMISERETRY" && hasOwn.call(err, "retried");
-  }
-  function promiseRetry(fn, options) {
-    var temp;
-    var operation;
-    if (typeof fn === "object" && typeof options === "function") {
-      temp = options;
-      options = fn;
-      fn = temp;
+    for (var i2 = 0;i2 < methods.length; i2++) {
+      var method = methods[i2];
+      var original = obj[method];
+      obj[method] = function retryWrapper(original2) {
+        var op = exports.operation(options);
+        var args = Array.prototype.slice.call(arguments, 1);
+        var callback = args.pop();
+        args.push(function(err) {
+          if (op.retry(err)) {
+            return;
+          }
+          if (err) {
+            arguments[0] = op.mainError();
+          }
+          callback.apply(this, arguments);
+        });
+        op.attempt(function() {
+          original2.apply(obj, args);
+        });
+      }.bind(obj, original);
+      obj[method].options = options;
+    }
+  };
+});
+
+// ../../node_modules/promise-retry/index.js
+var require_promise_retry = __commonJS((exports, module) => {
+  var errcode = require_err_code();
+  var retry = require_retry();
+  var hasOwn = Object.prototype.hasOwnProperty;
+  function isRetryError(err) {
+    return err && err.code === "EPROMISERETRY" && hasOwn.call(err, "retried");
+  }
+  function promiseRetry(fn, options) {
+    var temp;
+    var operation;
+    if (typeof fn === "object" && typeof options === "function") {
+      temp = options;
+      options = fn;
+      fn = temp;
+    }
+    operation = retry.operation(options);
+    return new Promise(function(resolve2, reject) {
+      operation.attempt(function(number) {
+        Promise.resolve().then(function() {
+          return fn(function(err) {
+            if (isRetryError(err)) {
+              err = err.retried;
+            }
+            throw errcode(new Error("Retrying"), "EPROMISERETRY", { retried: err });
+          }, number);
+        }).then(resolve2, function(err) {
+          if (isRetryError(err)) {
+            err = err.retried;
+            if (operation.retry(err || new Error)) {
+              return;
+            }
+          }
+          reject(err);
+        });
+      });
+    });
+  }
+  module.exports = promiseRetry;
+});
+
+// ../../node_modules/@npmcli/git/lib/errors.js
+var require_errors2 = __commonJS((exports, module) => {
+  var maxRetry = 3;
+
+  class GitError extends Error {
+    shouldRetry() {
+      return false;
+    }
+  }
+
+  class GitConnectionError extends GitError {
+    constructor() {
+      super("A git connection error occurred");
+    }
+    shouldRetry(number) {
+      return number < maxRetry;
+    }
+  }
+
+  class GitPathspecError extends GitError {
+    constructor() {
+      super("The git reference could not be found");
+    }
+  }
+
+  class GitUnknownError extends GitError {
+    constructor() {
+      super("An unknown git error occurred");
+    }
+  }
+  module.exports = {
+    GitConnectionError,
+    GitPathspecError,
+    GitUnknownError
+  };
+});
+
+// ../../node_modules/@npmcli/git/lib/make-error.js
+var require_make_error = __commonJS((exports, module) => {
+  var {
+    GitConnectionError,
+    GitPathspecError,
+    GitUnknownError
+  } = require_errors2();
+  var connectionErrorRe = new RegExp([
+    "remote error: Internal Server Error",
+    "The remote end hung up unexpectedly",
+    "Connection timed out",
+    "Operation timed out",
+    "Failed to connect to .* Timed out",
+    "Connection reset by peer",
+    "SSL_ERROR_SYSCALL",
+    "The requested URL returned error: 503"
+  ].join("|"));
+  var missingPathspecRe = /pathspec .* did not match any file\(s\) known to git/;
+  function makeError(er) {
+    const message = er.stderr;
+    let gitEr;
+    if (connectionErrorRe.test(message)) {
+      gitEr = new GitConnectionError(message);
+    } else if (missingPathspecRe.test(message)) {
+      gitEr = new GitPathspecError(message);
+    } else {
+      gitEr = new GitUnknownError(message);
+    }
+    return Object.assign(gitEr, er);
+  }
+  module.exports = makeError;
+});
+
+// ../../node_modules/ini/lib/ini.js
+var require_ini = __commonJS((exports, module) => {
+  var { hasOwnProperty } = Object.prototype;
+  var encode = (obj, opt = {}) => {
+    if (typeof opt === "string") {
+      opt = { section: opt };
+    }
+    opt.align = opt.align === true;
+    opt.newline = opt.newline === true;
+    opt.sort = opt.sort === true;
+    opt.whitespace = opt.whitespace === true || opt.align === true;
+    opt.platform = opt.platform || typeof process !== "undefined" && process.platform;
+    opt.bracketedArray = opt.bracketedArray !== false;
+    const eol = opt.platform === "win32" ? `\r
+` : `
+`;
+    const separator = opt.whitespace ? " = " : "=";
+    const children = [];
+    const keys = opt.sort ? Object.keys(obj).sort() : Object.keys(obj);
+    let padToChars = 0;
+    if (opt.align) {
+      padToChars = safe(keys.filter((k) => obj[k] === null || Array.isArray(obj[k]) || typeof obj[k] !== "object").map((k) => Array.isArray(obj[k]) ? `${k}[]` : k).concat([""]).reduce((a3, b) => safe(a3).length >= safe(b).length ? a3 : b)).length;
+    }
+    let out = "";
+    const arraySuffix = opt.bracketedArray ? "[]" : "";
+    for (const k of keys) {
+      const val = obj[k];
+      if (val && Array.isArray(val)) {
+        for (const item of val) {
+          out += safe(`${k}${arraySuffix}`).padEnd(padToChars, " ") + separator + safe(item) + eol;
+        }
+      } else if (val && typeof val === "object") {
+        children.push(k);
+      } else {
+        out += safe(k).padEnd(padToChars, " ") + separator + safe(val) + eol;
+      }
+    }
+    if (opt.section && out.length) {
+      out = "[" + safe(opt.section) + "]" + (opt.newline ? eol + eol : eol) + out;
+    }
+    for (const k of children) {
+      const nk = splitSections(k, ".").join("\\.");
+      const section = (opt.section ? opt.section + "." : "") + nk;
+      const child = encode(obj[k], {
+        ...opt,
+        section
+      });
+      if (out.length && child.length) {
+        out += eol;
+      }
+      out += child;
+    }
+    return out;
+  };
+  function splitSections(str, separator) {
+    var lastMatchIndex = 0;
+    var lastSeparatorIndex = 0;
+    var nextIndex = 0;
+    var sections = [];
+    do {
+      nextIndex = str.indexOf(separator, lastMatchIndex);
+      if (nextIndex !== -1) {
+        lastMatchIndex = nextIndex + separator.length;
+        if (nextIndex > 0 && str[nextIndex - 1] === "\\") {
+          continue;
+        }
+        sections.push(str.slice(lastSeparatorIndex, nextIndex));
+        lastSeparatorIndex = nextIndex + separator.length;
+      }
+    } while (nextIndex !== -1);
+    sections.push(str.slice(lastSeparatorIndex));
+    return sections;
+  }
+  var decode = (str, opt = {}) => {
+    opt.bracketedArray = opt.bracketedArray !== false;
+    const out = Object.create(null);
+    let p = out;
+    let section = null;
+    const re = /^\[([^\]]*)\]\s*$|^([^=]+)(=(.*))?$/i;
+    const lines2 = str.split(/[\r\n]+/g);
+    const duplicates = {};
+    for (const line of lines2) {
+      if (!line || line.match(/^\s*[;#]/) || line.match(/^\s*$/)) {
+        continue;
+      }
+      const match2 = line.match(re);
+      if (!match2) {
+        continue;
+      }
+      if (match2[1] !== undefined) {
+        section = unsafe(match2[1]);
+        if (section === "__proto__") {
+          p = Object.create(null);
+          continue;
+        }
+        p = out[section] = out[section] || Object.create(null);
+        continue;
+      }
+      const keyRaw = unsafe(match2[2]);
+      let isArray;
+      if (opt.bracketedArray) {
+        isArray = keyRaw.length > 2 && keyRaw.slice(-2) === "[]";
+      } else {
+        duplicates[keyRaw] = (duplicates?.[keyRaw] || 0) + 1;
+        isArray = duplicates[keyRaw] > 1;
+      }
+      const key2 = isArray && keyRaw.endsWith("[]") ? keyRaw.slice(0, -2) : keyRaw;
+      if (key2 === "__proto__") {
+        continue;
+      }
+      const valueRaw = match2[3] ? unsafe(match2[4]) : true;
+      const value2 = valueRaw === "true" || valueRaw === "false" || valueRaw === "null" ? JSON.parse(valueRaw) : valueRaw;
+      if (isArray) {
+        if (!hasOwnProperty.call(p, key2)) {
+          p[key2] = [];
+        } else if (!Array.isArray(p[key2])) {
+          p[key2] = [p[key2]];
+        }
+      }
+      if (Array.isArray(p[key2])) {
+        p[key2].push(value2);
+      } else {
+        p[key2] = value2;
+      }
+    }
+    const remove = [];
+    for (const k of Object.keys(out)) {
+      if (!hasOwnProperty.call(out, k) || typeof out[k] !== "object" || Array.isArray(out[k])) {
+        continue;
+      }
+      const parts = splitSections(k, ".");
+      p = out;
+      const l2 = parts.pop();
+      const nl = l2.replace(/\\\./g, ".");
+      for (const part of parts) {
+        if (part === "__proto__") {
+          continue;
+        }
+        if (!hasOwnProperty.call(p, part) || typeof p[part] !== "object") {
+          p[part] = Object.create(null);
+        }
+        p = p[part];
+      }
+      if (p === out && nl === l2) {
+        continue;
+      }
+      p[nl] = out[k];
+      remove.push(k);
+    }
+    for (const del of remove) {
+      delete out[del];
+    }
+    return out;
+  };
+  var isQuoted = (val) => {
+    return val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'");
+  };
+  var safe = (val) => {
+    if (typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim()) {
+      return JSON.stringify(val);
+    }
+    return val.split(";").join("\\;").split("#").join("\\#");
+  };
+  var unsafe = (val) => {
+    val = (val || "").trim();
+    if (isQuoted(val)) {
+      if (val.charAt(0) === "'") {
+        val = val.slice(1, -1);
+      }
+      try {
+        val = JSON.parse(val);
+      } catch {}
+    } else {
+      let esc = false;
+      let unesc = "";
+      for (let i2 = 0, l2 = val.length;i2 < l2; i2++) {
+        const c = val.charAt(i2);
+        if (esc) {
+          if ("\\;#".indexOf(c) !== -1) {
+            unesc += c;
+          } else {
+            unesc += "\\" + c;
+          }
+          esc = false;
+        } else if (";#".indexOf(c) !== -1) {
+          break;
+        } else if (c === "\\") {
+          esc = true;
+        } else {
+          unesc += c;
+        }
+      }
+      if (esc) {
+        unesc += "\\";
+      }
+      return unesc.trim();
+    }
+    return val;
+  };
+  module.exports = {
+    parse: decode,
+    decode,
+    stringify: encode,
+    encode,
+    safe,
+    unsafe
+  };
+});
+
+// ../../node_modules/@npmcli/git/lib/opts.js
+var require_opts = __commonJS((exports, module) => {
+  var fs4 = __require("node:fs");
+  var os = __require("node:os");
+  var path6 = __require("node:path");
+  var ini = require_ini();
+  var gitConfigPath = path6.join(os.homedir(), ".gitconfig");
+  var cachedConfig = null;
+  var loadGitConfig = () => {
+    if (cachedConfig === null) {
+      try {
+        cachedConfig = {};
+        if (fs4.existsSync(gitConfigPath)) {
+          const configContent = fs4.readFileSync(gitConfigPath, "utf-8");
+          cachedConfig = ini.parse(configContent);
+        }
+      } catch (error2) {
+        cachedConfig = {};
+      }
+    }
+    return cachedConfig;
+  };
+  var checkGitConfigs = () => {
+    const config3 = loadGitConfig();
+    return {
+      sshCommandSetInConfig: config3?.core?.sshCommand !== undefined,
+      askPassSetInConfig: config3?.core?.askpass !== undefined
+    };
+  };
+  var sshCommandSetInEnv = process.env.GIT_SSH_COMMAND !== undefined;
+  var askPassSetInEnv = process.env.GIT_ASKPASS !== undefined;
+  var { sshCommandSetInConfig, askPassSetInConfig } = checkGitConfigs();
+  var finalGitEnv = {
+    ...askPassSetInEnv || askPassSetInConfig ? {} : {
+      GIT_ASKPASS: "echo"
+    },
+    ...sshCommandSetInEnv || sshCommandSetInConfig ? {} : {
+      GIT_SSH_COMMAND: "ssh -oStrictHostKeyChecking=accept-new"
+    }
+  };
+  module.exports = (opts = {}) => ({
+    stdioString: true,
+    ...opts,
+    shell: false,
+    env: opts.env || { ...finalGitEnv, ...process.env }
+  });
+  module.exports.loadGitConfig = loadGitConfig;
+});
+
+// ../../node_modules/@npmcli/git/lib/which.js
+var require_which = __commonJS((exports, module) => {
+  var which = require_lib5();
+  var gitPath;
+  try {
+    gitPath = which.sync("git");
+  } catch {}
+  module.exports = (opts = {}) => {
+    if (opts.git) {
+      return opts.git;
+    }
+    if (!gitPath || opts.git === false) {
+      return Object.assign(new Error("No git binary found in $PATH"), { code: "ENOGIT" });
+    }
+    return gitPath;
+  };
+});
+
+// ../../node_modules/@npmcli/git/lib/spawn.js
+var require_spawn = __commonJS((exports, module) => {
+  var spawn2 = require_lib6();
+  var promiseRetry = require_promise_retry();
+  var { log } = require_lib3();
+  var makeError = require_make_error();
+  var makeOpts = require_opts();
+  module.exports = (gitArgs, opts = {}) => {
+    const whichGit = require_which();
+    const gitPath = whichGit(opts);
+    if (gitPath instanceof Error) {
+      return Promise.reject(gitPath);
+    }
+    const args = opts.allowReplace || gitArgs[0] === "--no-replace-objects" ? gitArgs : ["--no-replace-objects", ...gitArgs];
+    let retryOpts = opts.retry;
+    if (retryOpts === null || retryOpts === undefined) {
+      retryOpts = {
+        retries: opts.fetchRetries || 2,
+        factor: opts.fetchRetryFactor || 10,
+        maxTimeout: opts.fetchRetryMaxtimeout || 60000,
+        minTimeout: opts.fetchRetryMintimeout || 1000
+      };
+    }
+    return promiseRetry((retryFn, number) => {
+      if (number !== 1) {
+        log.silly("git", `Retrying git command: ${args.join(" ")} attempt # ${number}`);
+      }
+      return spawn2(gitPath, args, makeOpts(opts)).catch((er) => {
+        const gitError = makeError(er);
+        if (!gitError.shouldRetry(number)) {
+          throw gitError;
+        }
+        retryFn(gitError);
+      });
+    }, retryOpts);
+  };
+});
+
+// ../../node_modules/@npmcli/git/node_modules/lru-cache/dist/commonjs/index.js
+var require_commonjs7 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LRUCache = undefined;
+  var perf2 = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+  var warned2 = new Set;
+  var PROCESS2 = typeof process === "object" && !!process ? process : {};
+  var emitWarning2 = (msg, type2, code, fn) => {
+    typeof PROCESS2.emitWarning === "function" ? PROCESS2.emitWarning(msg, type2, code, fn) : console.error(`[${code}] ${type2}: ${msg}`);
+  };
+  var AC2 = globalThis.AbortController;
+  var AS2 = globalThis.AbortSignal;
+  if (typeof AC2 === "undefined") {
+    AS2 = class AbortSignal2 {
+      onabort;
+      _onabort = [];
+      reason;
+      aborted = false;
+      addEventListener(_, fn) {
+        this._onabort.push(fn);
+      }
+    };
+    AC2 = class AbortController2 {
+      constructor() {
+        warnACPolyfill();
+      }
+      signal = new AS2;
+      abort(reason) {
+        if (this.signal.aborted)
+          return;
+        this.signal.reason = reason;
+        this.signal.aborted = true;
+        for (const fn of this.signal._onabort) {
+          fn(reason);
+        }
+        this.signal.onabort?.(reason);
+      }
+    };
+    let printACPolyfillWarning = PROCESS2.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+    const warnACPolyfill = () => {
+      if (!printACPolyfillWarning)
+        return;
+      printACPolyfillWarning = false;
+      emitWarning2("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);
+    };
+  }
+  var shouldWarn2 = (code) => !warned2.has(code);
+  var TYPE2 = Symbol("type");
+  var isPosInt2 = (n2) => n2 && n2 === Math.floor(n2) && n2 > 0 && isFinite(n2);
+  var getUintArray2 = (max) => !isPosInt2(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 ? ZeroArray2 : null;
+
+  class ZeroArray2 extends Array {
+    constructor(size) {
+      super(size);
+      this.fill(0);
+    }
+  }
+
+  class Stack2 {
+    heap;
+    length;
+    static #constructing = false;
+    static create(max) {
+      const HeapCls = getUintArray2(max);
+      if (!HeapCls)
+        return [];
+      Stack2.#constructing = true;
+      const s = new Stack2(max, HeapCls);
+      Stack2.#constructing = false;
+      return s;
+    }
+    constructor(max, HeapCls) {
+      if (!Stack2.#constructing) {
+        throw new TypeError("instantiate Stack using Stack.create(n)");
+      }
+      this.heap = new HeapCls(max);
+      this.length = 0;
+    }
+    push(n2) {
+      this.heap[this.length++] = n2;
+    }
+    pop() {
+      return this.heap[--this.length];
+    }
+  }
+
+  class LRUCache2 {
+    #max;
+    #maxSize;
+    #dispose;
+    #disposeAfter;
+    #fetchMethod;
+    #memoMethod;
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    static unsafeExposeInternals(c) {
+      return {
+        starts: c.#starts,
+        ttls: c.#ttls,
+        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,
+        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)
+      };
+    }
+    get max() {
+      return this.#max;
+    }
+    get maxSize() {
+      return this.#maxSize;
+    }
+    get calculatedSize() {
+      return this.#calculatedSize;
+    }
+    get size() {
+      return this.#size;
+    }
+    get fetchMethod() {
+      return this.#fetchMethod;
+    }
+    get memoMethod() {
+      return this.#memoMethod;
+    }
+    get dispose() {
+      return this.#dispose;
+    }
+    get disposeAfter() {
+      return this.#disposeAfter;
+    }
+    constructor(options) {
+      const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+      if (max !== 0 && !isPosInt2(max)) {
+        throw new TypeError("max option must be a nonnegative integer");
+      }
+      const UintArray = max ? getUintArray2(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 !== undefined && typeof memoMethod !== "function") {
+        throw new TypeError("memoMethod must be a function if defined");
+      }
+      this.#memoMethod = memoMethod;
+      if (fetchMethod !== undefined && typeof fetchMethod !== "function") {
+        throw new TypeError("fetchMethod must be a function if specified");
+      }
+      this.#fetchMethod = fetchMethod;
+      this.#hasFetchMethod = !!fetchMethod;
+      this.#keyMap = new Map;
+      this.#keyList = new Array(max).fill(undefined);
+      this.#valList = new Array(max).fill(undefined);
+      this.#next = new UintArray(max);
+      this.#prev = new UintArray(max);
+      this.#head = 0;
+      this.#tail = 0;
+      this.#free = Stack2.create(max);
+      this.#size = 0;
+      this.#calculatedSize = 0;
+      if (typeof dispose === "function") {
+        this.#dispose = dispose;
+      }
+      if (typeof disposeAfter === "function") {
+        this.#disposeAfter = disposeAfter;
+        this.#disposed = [];
+      } else {
+        this.#disposeAfter = undefined;
+        this.#disposed = undefined;
+      }
+      this.#hasDispose = !!this.#dispose;
+      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 (!isPosInt2(this.#maxSize)) {
+            throw new TypeError("maxSize must be a positive integer if specified");
+          }
+        }
+        if (!isPosInt2(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 = isPosInt2(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+      this.ttlAutopurge = !!ttlAutopurge;
+      this.ttl = ttl || 0;
+      if (this.ttl) {
+        if (!isPosInt2(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 (shouldWarn2(code)) {
+          warned2.add(code);
+          const msg = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
+          emitWarning2(msg, "UnboundedCacheWarning", code, LRUCache2);
+        }
+      }
+    }
+    getRemainingTTL(key2) {
+      return this.#keyMap.has(key2) ? Infinity : 0;
+    }
+    #initializeTTLTracking() {
+      const ttls = new ZeroArray2(this.#max);
+      const starts = new ZeroArray2(this.#max);
+      this.#ttls = ttls;
+      this.#starts = starts;
+      this.#setItemTTL = (index, ttl, start = perf2.now()) => {
+        starts[index] = ttl !== 0 ? start : 0;
+        ttls[index] = ttl;
+        if (ttl !== 0 && this.ttlAutopurge) {
+          const t3 = setTimeout(() => {
+            if (this.#isStale(index)) {
+              this.#delete(this.#keyList[index], "expire");
+            }
+          }, ttl + 1);
+          if (t3.unref) {
+            t3.unref();
+          }
+        }
+      };
+      this.#updateItemAge = (index) => {
+        starts[index] = ttls[index] !== 0 ? perf2.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 n2 = perf2.now();
+        if (this.ttlResolution > 0) {
+          cachedNow = n2;
+          const t3 = setTimeout(() => cachedNow = 0, this.ttlResolution);
+          if (t3.unref) {
+            t3.unref();
+          }
+        }
+        return n2;
+      };
+      this.getRemainingTTL = (key2) => {
+        const index = this.#keyMap.get(key2);
+        if (index === undefined) {
+          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;
+      };
+    }
+    #updateItemAge = () => {};
+    #statusTTL = () => {};
+    #setItemTTL = () => {};
+    #isStale = () => false;
+    #initializeSizeTracking() {
+      const sizes = new ZeroArray2(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 (!isPosInt2(size)) {
+          if (sizeCalculation) {
+            if (typeof sizeCalculation !== "function") {
+              throw new TypeError("sizeCalculation must be a function");
+            }
+            size = sizeCalculation(v, k);
+            if (!isPosInt2(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;
+        }
+      };
+    }
+    #removeItemSize = (_i) => {};
+    #addItemSize = (_i, _s, _st) => {};
+    #requireSize = (_k, _v, size, sizeCalculation) => {
+      if (size || sizeCalculation) {
+        throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+      }
+      return 0;
+    };
+    *#indexes({ allowStale = this.allowStale } = {}) {
+      if (this.#size) {
+        for (let i2 = this.#tail;; ) {
+          if (!this.#isValidIndex(i2)) {
+            break;
+          }
+          if (allowStale || !this.#isStale(i2)) {
+            yield i2;
+          }
+          if (i2 === this.#head) {
+            break;
+          } else {
+            i2 = this.#prev[i2];
+          }
+        }
+      }
+    }
+    *#rindexes({ allowStale = this.allowStale } = {}) {
+      if (this.#size) {
+        for (let i2 = this.#head;; ) {
+          if (!this.#isValidIndex(i2)) {
+            break;
+          }
+          if (allowStale || !this.#isStale(i2)) {
+            yield i2;
+          }
+          if (i2 === this.#tail) {
+            break;
+          } else {
+            i2 = this.#next[i2];
+          }
+        }
+      }
+    }
+    #isValidIndex(index) {
+      return index !== undefined && this.#keyMap.get(this.#keyList[index]) === index;
+    }
+    *entries() {
+      for (const i2 of this.#indexes()) {
+        if (this.#valList[i2] !== undefined && this.#keyList[i2] !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield [this.#keyList[i2], this.#valList[i2]];
+        }
+      }
+    }
+    *rentries() {
+      for (const i2 of this.#rindexes()) {
+        if (this.#valList[i2] !== undefined && this.#keyList[i2] !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield [this.#keyList[i2], this.#valList[i2]];
+        }
+      }
     }
-    operation = retry.operation(options);
-    return new Promise(function(resolve2, reject) {
-      operation.attempt(function(number) {
-        Promise.resolve().then(function() {
-          return fn(function(err) {
-            if (isRetryError(err)) {
-              err = err.retried;
-            }
-            throw errcode(new Error("Retrying"), "EPROMISERETRY", { retried: err });
-          }, number);
-        }).then(resolve2, function(err) {
-          if (isRetryError(err)) {
-            err = err.retried;
-            if (operation.retry(err || new Error)) {
-              return;
-            }
-          }
-          reject(err);
-        });
-      });
-    });
-  }
-  module.exports = promiseRetry;
-});
-
-// ../../node_modules/@npmcli/git/lib/errors.js
-var require_errors2 = __commonJS((exports, module) => {
-  var maxRetry = 3;
-
-  class GitError extends Error {
-    shouldRetry() {
-      return false;
+    *keys() {
+      for (const i2 of this.#indexes()) {
+        const k = this.#keyList[i2];
+        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield k;
+        }
+      }
     }
-  }
-
-  class GitConnectionError extends GitError {
-    constructor() {
-      super("A git connection error occurred");
+    *rkeys() {
+      for (const i2 of this.#rindexes()) {
+        const k = this.#keyList[i2];
+        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield k;
+        }
+      }
     }
-    shouldRetry(number) {
-      return number < maxRetry;
+    *values() {
+      for (const i2 of this.#indexes()) {
+        const v = this.#valList[i2];
+        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield this.#valList[i2];
+        }
+      }
     }
-  }
-
-  class GitPathspecError extends GitError {
-    constructor() {
-      super("The git reference could not be found");
+    *rvalues() {
+      for (const i2 of this.#rindexes()) {
+        const v = this.#valList[i2];
+        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i2])) {
+          yield this.#valList[i2];
+        }
+      }
     }
-  }
-
-  class GitUnknownError extends GitError {
-    constructor() {
-      super("An unknown git error occurred");
+    [Symbol.iterator]() {
+      return this.entries();
     }
-  }
-  module.exports = {
-    GitConnectionError,
-    GitPathspecError,
-    GitUnknownError
-  };
-});
-
-// ../../node_modules/@npmcli/git/lib/make-error.js
-var require_make_error = __commonJS((exports, module) => {
-  var {
-    GitConnectionError,
-    GitPathspecError,
-    GitUnknownError
-  } = require_errors2();
-  var connectionErrorRe = new RegExp([
-    "remote error: Internal Server Error",
-    "The remote end hung up unexpectedly",
-    "Connection timed out",
-    "Operation timed out",
-    "Failed to connect to .* Timed out",
-    "Connection reset by peer",
-    "SSL_ERROR_SYSCALL",
-    "The requested URL returned error: 503"
-  ].join("|"));
-  var missingPathspecRe = /pathspec .* did not match any file\(s\) known to git/;
-  function makeError(er) {
-    const message = er.stderr;
-    let gitEr;
-    if (connectionErrorRe.test(message)) {
-      gitEr = new GitConnectionError(message);
-    } else if (missingPathspecRe.test(message)) {
-      gitEr = new GitPathspecError(message);
-    } else {
-      gitEr = new GitUnknownError(message);
+    [Symbol.toStringTag] = "LRUCache";
+    find(fn, getOptions = {}) {
+      for (const i2 of this.#indexes()) {
+        const v = this.#valList[i2];
+        const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value2 === undefined)
+          continue;
+        if (fn(value2, this.#keyList[i2], this)) {
+          return this.get(this.#keyList[i2], getOptions);
+        }
+      }
     }
-    return Object.assign(gitEr, er);
-  }
-  module.exports = makeError;
-});
-
-// ../../node_modules/ini/lib/ini.js
-var require_ini = __commonJS((exports, module) => {
-  var { hasOwnProperty } = Object.prototype;
-  var encode = (obj, opt = {}) => {
-    if (typeof opt === "string") {
-      opt = { section: opt };
+    forEach(fn, thisp = this) {
+      for (const i2 of this.#indexes()) {
+        const v = this.#valList[i2];
+        const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value2 === undefined)
+          continue;
+        fn.call(thisp, value2, this.#keyList[i2], this);
+      }
     }
-    opt.align = opt.align === true;
-    opt.newline = opt.newline === true;
-    opt.sort = opt.sort === true;
-    opt.whitespace = opt.whitespace === true || opt.align === true;
-    opt.platform = opt.platform || typeof process !== "undefined" && process.platform;
-    opt.bracketedArray = opt.bracketedArray !== false;
-    const eol = opt.platform === "win32" ? `\r
-` : `
-`;
-    const separator = opt.whitespace ? " = " : "=";
-    const children = [];
-    const keys = opt.sort ? Object.keys(obj).sort() : Object.keys(obj);
-    let padToChars = 0;
-    if (opt.align) {
-      padToChars = safe(keys.filter((k) => obj[k] === null || Array.isArray(obj[k]) || typeof obj[k] !== "object").map((k) => Array.isArray(obj[k]) ? `${k}[]` : k).concat([""]).reduce((a3, b) => safe(a3).length >= safe(b).length ? a3 : b)).length;
+    rforEach(fn, thisp = this) {
+      for (const i2 of this.#rindexes()) {
+        const v = this.#valList[i2];
+        const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value2 === undefined)
+          continue;
+        fn.call(thisp, value2, this.#keyList[i2], this);
+      }
     }
-    let out = "";
-    const arraySuffix = opt.bracketedArray ? "[]" : "";
-    for (const k of keys) {
-      const val = obj[k];
-      if (val && Array.isArray(val)) {
-        for (const item of val) {
-          out += safe(`${k}${arraySuffix}`).padEnd(padToChars, " ") + separator + safe(item) + eol;
+    purgeStale() {
+      let deleted = false;
+      for (const i2 of this.#rindexes({ allowStale: true })) {
+        if (this.#isStale(i2)) {
+          this.#delete(this.#keyList[i2], "expire");
+          deleted = true;
         }
-      } else if (val && typeof val === "object") {
-        children.push(k);
-      } else {
-        out += safe(k).padEnd(padToChars, " ") + separator + safe(val) + eol;
       }
+      return deleted;
     }
-    if (opt.section && out.length) {
-      out = "[" + safe(opt.section) + "]" + (opt.newline ? eol + eol : eol) + out;
-    }
-    for (const k of children) {
-      const nk = splitSections(k, ".").join("\\.");
-      const section = (opt.section ? opt.section + "." : "") + nk;
-      const child = encode(obj[k], {
-        ...opt,
-        section
-      });
-      if (out.length && child.length) {
-        out += eol;
+    info(key2) {
+      const i2 = this.#keyMap.get(key2);
+      if (i2 === undefined)
+        return;
+      const v = this.#valList[i2];
+      const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+      if (value2 === undefined)
+        return;
+      const entry = { value: value2 };
+      if (this.#ttls && this.#starts) {
+        const ttl = this.#ttls[i2];
+        const start = this.#starts[i2];
+        if (ttl && start) {
+          const remain = ttl - (perf2.now() - start);
+          entry.ttl = remain;
+          entry.start = Date.now();
+        }
       }
-      out += child;
+      if (this.#sizes) {
+        entry.size = this.#sizes[i2];
+      }
+      return entry;
     }
-    return out;
-  };
-  function splitSections(str, separator) {
-    var lastMatchIndex = 0;
-    var lastSeparatorIndex = 0;
-    var nextIndex = 0;
-    var sections = [];
-    do {
-      nextIndex = str.indexOf(separator, lastMatchIndex);
-      if (nextIndex !== -1) {
-        lastMatchIndex = nextIndex + separator.length;
-        if (nextIndex > 0 && str[nextIndex - 1] === "\\") {
+    dump() {
+      const arr = [];
+      for (const i2 of this.#indexes({ allowStale: true })) {
+        const key2 = this.#keyList[i2];
+        const v = this.#valList[i2];
+        const value2 = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value2 === undefined || key2 === undefined)
           continue;
+        const entry = { value: value2 };
+        if (this.#ttls && this.#starts) {
+          entry.ttl = this.#ttls[i2];
+          const age = perf2.now() - this.#starts[i2];
+          entry.start = Math.floor(Date.now() - age);
         }
-        sections.push(str.slice(lastSeparatorIndex, nextIndex));
-        lastSeparatorIndex = nextIndex + separator.length;
+        if (this.#sizes) {
+          entry.size = this.#sizes[i2];
+        }
+        arr.unshift([key2, entry]);
       }
-    } while (nextIndex !== -1);
-    sections.push(str.slice(lastSeparatorIndex));
-    return sections;
-  }
-  var decode = (str, opt = {}) => {
-    opt.bracketedArray = opt.bracketedArray !== false;
-    const out = Object.create(null);
-    let p = out;
-    let section = null;
-    const re = /^\[([^\]]*)\]\s*$|^([^=]+)(=(.*))?$/i;
-    const lines2 = str.split(/[\r\n]+/g);
-    const duplicates = {};
-    for (const line of lines2) {
-      if (!line || line.match(/^\s*[;#]/) || line.match(/^\s*$/)) {
-        continue;
+      return arr;
+    }
+    load(arr) {
+      this.clear();
+      for (const [key2, entry] of arr) {
+        if (entry.start) {
+          const age = Date.now() - entry.start;
+          entry.start = perf2.now() - age;
+        }
+        this.set(key2, entry.value, entry);
       }
-      const match2 = line.match(re);
-      if (!match2) {
-        continue;
+    }
+    set(k, v, setOptions = {}) {
+      if (v === undefined) {
+        this.delete(k);
+        return this;
       }
-      if (match2[1] !== undefined) {
-        section = unsafe(match2[1]);
-        if (section === "__proto__") {
-          p = Object.create(null);
-          continue;
+      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;
         }
-        p = out[section] = out[section] || Object.create(null);
-        continue;
+        this.#delete(k, "set");
+        return this;
       }
-      const keyRaw = unsafe(match2[2]);
-      let isArray;
-      if (opt.bracketedArray) {
-        isArray = keyRaw.length > 2 && keyRaw.slice(-2) === "[]";
+      let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
+      if (index === undefined) {
+        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;
       } else {
-        duplicates[keyRaw] = (duplicates?.[keyRaw] || 0) + 1;
-        isArray = duplicates[keyRaw] > 1;
+        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 !== undefined && !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 !== undefined)
+              status.oldValue = oldValue;
+          }
+        } else if (status) {
+          status.set = "update";
+        }
       }
-      const key2 = isArray && keyRaw.endsWith("[]") ? keyRaw.slice(0, -2) : keyRaw;
-      if (key2 === "__proto__") {
-        continue;
+      if (ttl !== 0 && !this.#ttls) {
+        this.#initializeTTLTracking();
       }
-      const valueRaw = match2[3] ? unsafe(match2[4]) : true;
-      const value2 = valueRaw === "true" || valueRaw === "false" || valueRaw === "null" ? JSON.parse(valueRaw) : valueRaw;
-      if (isArray) {
-        if (!hasOwnProperty.call(p, key2)) {
-          p[key2] = [];
-        } else if (!Array.isArray(p[key2])) {
-          p[key2] = [p[key2]];
+      if (this.#ttls) {
+        if (!noUpdateTTL) {
+          this.#setItemTTL(index, ttl, start);
         }
+        if (status)
+          this.#statusTTL(status, index);
       }
-      if (Array.isArray(p[key2])) {
-        p[key2].push(value2);
-      } else {
-        p[key2] = value2;
+      if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+        const dt2 = this.#disposed;
+        let task;
+        while (task = dt2?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
       }
+      return this;
     }
-    const remove = [];
-    for (const k of Object.keys(out)) {
-      if (!hasOwnProperty.call(out, k) || typeof out[k] !== "object" || Array.isArray(out[k])) {
-        continue;
+    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 !== undefined) {
+            return val;
+          }
+        }
+      } finally {
+        if (this.#hasDisposeAfter && this.#disposed) {
+          const dt2 = this.#disposed;
+          let task;
+          while (task = dt2?.shift()) {
+            this.#disposeAfter?.(...task);
+          }
+        }
       }
-      const parts = splitSections(k, ".");
-      p = out;
-      const l2 = parts.pop();
-      const nl = l2.replace(/\\\./g, ".");
-      for (const part of parts) {
-        if (part === "__proto__") {
-          continue;
+    }
+    #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 (!hasOwnProperty.call(p, part) || typeof p[part] !== "object") {
-          p[part] = Object.create(null);
+        if (this.#hasDisposeAfter) {
+          this.#disposed?.push([v, k, "evict"]);
         }
-        p = p[part];
       }
-      if (p === out && nl === l2) {
-        continue;
+      this.#removeItemSize(head);
+      if (free) {
+        this.#keyList[head] = undefined;
+        this.#valList[head] = undefined;
+        this.#free.push(head);
       }
-      p[nl] = out[k];
-      remove.push(k);
+      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;
     }
-    for (const del of remove) {
-      delete out[del];
+    has(k, hasOptions = {}) {
+      const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+      const index = this.#keyMap.get(k);
+      if (index !== undefined) {
+        const v = this.#valList[index];
+        if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === undefined) {
+          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";
+      }
+      return false;
     }
-    return out;
-  };
-  var isQuoted = (val) => {
-    return val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'");
-  };
-  var safe = (val) => {
-    if (typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim()) {
-      return JSON.stringify(val);
+    peek(k, peekOptions = {}) {
+      const { allowStale = this.allowStale } = peekOptions;
+      const index = this.#keyMap.get(k);
+      if (index === undefined || !allowStale && this.#isStale(index)) {
+        return;
+      }
+      const v = this.#valList[index];
+      return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
     }
-    return val.split(";").join("\\;").split("#").join("\\#");
-  };
-  var unsafe = (val) => {
-    val = (val || "").trim();
-    if (isQuoted(val)) {
-      if (val.charAt(0) === "'") {
-        val = val.slice(1, -1);
+    #backgroundFetch(k, index, options, context) {
+      const v = index === undefined ? undefined : this.#valList[index];
+      if (this.#isBackgroundFetch(v)) {
+        return v;
       }
-      try {
-        val = JSON.parse(val);
-      } catch {}
-    } else {
-      let esc = false;
-      let unesc = "";
-      for (let i2 = 0, l2 = val.length;i2 < l2; i2++) {
-        const c = val.charAt(i2);
-        if (esc) {
-          if ("\\;#".indexOf(c) !== -1) {
-            unesc += c;
+      const ac = new AC2;
+      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 !== undefined;
+        if (options.status) {
+          if (aborted && !updateCache) {
+            options.status.fetchAborted = true;
+            options.status.fetchError = ac.signal.reason;
+            if (ignoreAbort)
+              options.status.fetchAbortIgnored = true;
           } else {
-            unesc += "\\" + c;
+            options.status.fetchResolved = true;
           }
-          esc = false;
-        } else if (";#".indexOf(c) !== -1) {
-          break;
-        } else if (c === "\\") {
-          esc = true;
-        } else {
-          unesc += c;
         }
+        if (aborted && !ignoreAbort && !updateCache) {
+          return fetchFail(ac.signal.reason);
+        }
+        const bf2 = p;
+        if (this.#valList[index] === p) {
+          if (v2 === undefined) {
+            if (bf2.__staleWhileFetching) {
+              this.#valList[index] = bf2.__staleWhileFetching;
+            } else {
+              this.#delete(k, "fetch");
+            }
+          } else {
+            if (options.status)
+              options.status.fetchUpdated = true;
+            this.set(k, v2, fetchOpts.options);
+          }
+        }
+        return v2;
+      };
+      const eb = (er) => {
+        if (options.status) {
+          options.status.fetchRejected = true;
+          options.status.fetchError = er;
+        }
+        return fetchFail(er);
+      };
+      const fetchFail = (er) => {
+        const { aborted } = 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 || bf2.__staleWhileFetching === undefined;
+          if (del) {
+            this.#delete(k, "fetch");
+          } else if (!allowStaleAborted) {
+            this.#valList[index] = bf2.__staleWhileFetching;
+          }
+        }
+        if (allowStale) {
+          if (options.status && bf2.__staleWhileFetching !== undefined) {
+            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 === undefined ? undefined : v2), rej);
+        }
+        ac.signal.addEventListener("abort", () => {
+          if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+            res(undefined);
+            if (options.allowStaleOnFetchAbort) {
+              res = (v2) => cb(v2, true);
+            }
+          }
+        });
+      };
+      if (options.status)
+        options.status.fetchDispatched = true;
+      const p = new Promise(pcall).then(cb, eb);
+      const bf = Object.assign(p, {
+        __abortController: ac,
+        __staleWhileFetching: v,
+        __returned: undefined
+      });
+      if (index === undefined) {
+        this.set(k, bf, { ...fetchOpts.options, status: undefined });
+        index = this.#keyMap.get(k);
+      } else {
+        this.#valList[index] = bf;
       }
-      if (esc) {
-        unesc += "\\";
+      return bf;
+    }
+    #isBackgroundFetch(p) {
+      if (!this.#hasFetchMethod)
+        return false;
+      const b = p;
+      return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC2;
+    }
+    async fetch(k, fetchOptions = {}) {
+      const {
+        allowStale = this.allowStale,
+        updateAgeOnGet = this.updateAgeOnGet,
+        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+        ttl = this.ttl,
+        noDisposeOnSet = this.noDisposeOnSet,
+        size = 0,
+        sizeCalculation = this.sizeCalculation,
+        noUpdateTTL = this.noUpdateTTL,
+        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 === undefined) {
+        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 !== undefined;
+          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 !== undefined;
+        const staleVal = hasStale && allowStale;
+        if (status) {
+          status.fetch = isStale ? "stale" : "refresh";
+          if (staleVal && isStale)
+            status.returnedStale = true;
+        }
+        return staleVal ? p.__staleWhileFetching : p.__returned = p;
       }
-      return unesc.trim();
     }
-    return val;
-  };
-  module.exports = {
-    parse: decode,
-    decode,
-    stringify: encode,
-    encode,
-    safe,
-    unsafe
-  };
-});
-
-// ../../node_modules/@npmcli/git/lib/opts.js
-var require_opts = __commonJS((exports, module) => {
-  var fs4 = __require("node:fs");
-  var os = __require("node:os");
-  var path6 = __require("node:path");
-  var ini = require_ini();
-  var gitConfigPath = path6.join(os.homedir(), ".gitconfig");
-  var cachedConfig = null;
-  var loadGitConfig = () => {
-    if (cachedConfig === null) {
-      try {
-        cachedConfig = {};
-        if (fs4.existsSync(gitConfigPath)) {
-          const configContent = fs4.readFileSync(gitConfigPath, "utf-8");
-          cachedConfig = ini.parse(configContent);
+    async forceFetch(k, fetchOptions = {}) {
+      const v = await this.fetch(k, fetchOptions);
+      if (v === undefined)
+        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 !== undefined)
+        return v;
+      const vv = memoMethod(k, v, {
+        options,
+        context
+      });
+      this.set(k, vv, options);
+      return vv;
+    }
+    get(k, getOptions = {}) {
+      const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+      const index = this.#keyMap.get(k);
+      if (index !== undefined) {
+        const value2 = this.#valList[index];
+        const fetching = this.#isBackgroundFetch(value2);
+        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 ? value2 : undefined;
+          } else {
+            if (status && allowStale && value2.__staleWhileFetching !== undefined) {
+              status.returnedStale = true;
+            }
+            return allowStale ? value2.__staleWhileFetching : undefined;
+          }
+        } else {
+          if (status)
+            status.get = "hit";
+          if (fetching) {
+            return value2.__staleWhileFetching;
+          }
+          this.#moveToTail(index);
+          if (updateAgeOnGet) {
+            this.#updateItemAge(index);
+          }
+          return value2;
         }
-      } catch (error2) {
-        cachedConfig = {};
+      } else if (status) {
+        status.get = "miss";
       }
     }
-    return cachedConfig;
-  };
-  var checkGitConfigs = () => {
-    const config3 = loadGitConfig();
-    return {
-      sshCommandSetInConfig: config3?.core?.sshCommand !== undefined,
-      askPassSetInConfig: config3?.core?.askpass !== undefined
-    };
-  };
-  var sshCommandSetInEnv = process.env.GIT_SSH_COMMAND !== undefined;
-  var askPassSetInEnv = process.env.GIT_ASKPASS !== undefined;
-  var { sshCommandSetInConfig, askPassSetInConfig } = checkGitConfigs();
-  var finalGitEnv = {
-    ...askPassSetInEnv || askPassSetInConfig ? {} : {
-      GIT_ASKPASS: "echo"
-    },
-    ...sshCommandSetInEnv || sshCommandSetInConfig ? {} : {
-      GIT_SSH_COMMAND: "ssh -oStrictHostKeyChecking=accept-new"
+    #connect(p, n2) {
+      this.#prev[n2] = p;
+      this.#next[p] = n2;
     }
-  };
-  module.exports = (opts = {}) => ({
-    stdioString: true,
-    ...opts,
-    shell: false,
-    env: opts.env || { ...finalGitEnv, ...process.env }
-  });
-  module.exports.loadGitConfig = loadGitConfig;
-});
-
-// ../../node_modules/@npmcli/git/lib/which.js
-var require_which = __commonJS((exports, module) => {
-  var which = require_lib5();
-  var gitPath;
-  try {
-    gitPath = which.sync("git");
-  } catch {}
-  module.exports = (opts = {}) => {
-    if (opts.git) {
-      return opts.git;
+    #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;
+      }
     }
-    if (!gitPath || opts.git === false) {
-      return Object.assign(new Error("No git binary found in $PATH"), { code: "ENOGIT" });
+    delete(k) {
+      return this.#delete(k, "delete");
     }
-    return gitPath;
-  };
-});
-
-// ../../node_modules/@npmcli/git/lib/spawn.js
-var require_spawn = __commonJS((exports, module) => {
-  var spawn2 = require_lib6();
-  var promiseRetry = require_promise_retry();
-  var { log } = require_lib3();
-  var makeError = require_make_error();
-  var makeOpts = require_opts();
-  module.exports = (gitArgs, opts = {}) => {
-    const whichGit = require_which();
-    const gitPath = whichGit(opts);
-    if (gitPath instanceof Error) {
-      return Promise.reject(gitPath);
+    #delete(k, reason) {
+      let deleted = false;
+      if (this.#size !== 0) {
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+          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] = undefined;
+            this.#valList[index] = undefined;
+            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);
+          }
+        }
+      }
+      if (this.#hasDisposeAfter && this.#disposed?.length) {
+        const dt2 = this.#disposed;
+        let task;
+        while (task = dt2?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+      return deleted;
     }
-    const args = opts.allowReplace || gitArgs[0] === "--no-replace-objects" ? gitArgs : ["--no-replace-objects", ...gitArgs];
-    let retryOpts = opts.retry;
-    if (retryOpts === null || retryOpts === undefined) {
-      retryOpts = {
-        retries: opts.fetchRetries || 2,
-        factor: opts.fetchRetryFactor || 10,
-        maxTimeout: opts.fetchRetryMaxtimeout || 60000,
-        minTimeout: opts.fetchRetryMintimeout || 1000
-      };
+    clear() {
+      return this.#clear("delete");
     }
-    return promiseRetry((retryFn, number) => {
-      if (number !== 1) {
-        log.silly("git", `Retrying git command: ${args.join(" ")} attempt # ${number}`);
+    #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]);
+          }
+        }
       }
-      return spawn2(gitPath, args, makeOpts(opts)).catch((er) => {
-        const gitError = makeError(er);
-        if (!gitError.shouldRetry(number)) {
-          throw gitError;
+      this.#keyMap.clear();
+      this.#valList.fill(undefined);
+      this.#keyList.fill(undefined);
+      if (this.#ttls && this.#starts) {
+        this.#ttls.fill(0);
+        this.#starts.fill(0);
+      }
+      if (this.#sizes) {
+        this.#sizes.fill(0);
+      }
+      this.#head = 0;
+      this.#tail = 0;
+      this.#free.length = 0;
+      this.#calculatedSize = 0;
+      this.#size = 0;
+      if (this.#hasDisposeAfter && this.#disposed) {
+        const dt2 = this.#disposed;
+        let task;
+        while (task = dt2?.shift()) {
+          this.#disposeAfter?.(...task);
         }
-        retryFn(gitError);
-      });
-    }, retryOpts);
-  };
+      }
+    }
+  }
+  exports.LRUCache = LRUCache2;
 });
 
 // ../../node_modules/semver/functions/inc.js
@@ -38266,7 +40496,7 @@ var require_lines_to_revs = __commonJS((exports, module) => {
 // ../../node_modules/@npmcli/git/lib/revs.js
 var require_revs = __commonJS((exports, module) => {
   var spawn2 = require_spawn();
-  var { LRUCache: LRUCache2 } = require_commonjs();
+  var { LRUCache: LRUCache2 } = require_commonjs7();
   var linesToRevs = require_lines_to_revs();
   var revsCache = new LRUCache2({
     max: 100,
@@ -41007,7 +43237,7 @@ var require_normalize = __commonJS((exports, module) => {
   var _glob;
   function lazyLoadGlob() {
     if (!_glob) {
-      _glob = require_commonjs5().glob;
+      _glob = require_commonjs6().glob;
     }
     return _glob;
   }
@@ -228184,11 +230414,11 @@ var require_visit = __commonJS((exports) => {
   visit2.BREAK = BREAK;
   visit2.SKIP = SKIP;
   visit2.REMOVE = REMOVE;
-  function visit_(key2, node, visitor, path6) {
-    const ctrl = callVisitor(key2, node, visitor, path6);
+  function visit_(key3, node, visitor, path6) {
+    const ctrl = callVisitor(key3, node, visitor, path6);
     if (identity2.isNode(ctrl) || identity2.isPair(ctrl)) {
-      replaceNode(key2, path6, ctrl);
-      return visit_(key2, ctrl, visitor, path6);
+      replaceNode(key3, path6, ctrl);
+      return visit_(key3, ctrl, visitor, path6);
     }
     if (typeof ctrl !== "symbol") {
       if (identity2.isCollection(node)) {
@@ -228232,11 +230462,11 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key2, node, visitor, path6) {
-    const ctrl = await callVisitor(key2, node, visitor, path6);
+  async function visitAsync_(key3, node, visitor, path6) {
+    const ctrl = await callVisitor(key3, node, visitor, path6);
     if (identity2.isNode(ctrl) || identity2.isPair(ctrl)) {
-      replaceNode(key2, path6, ctrl);
-      return visitAsync_(key2, ctrl, visitor, path6);
+      replaceNode(key3, path6, ctrl);
+      return visitAsync_(key3, ctrl, visitor, path6);
     }
     if (typeof ctrl !== "symbol") {
       if (identity2.isCollection(node)) {
@@ -228286,27 +230516,27 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key2, node, visitor, path6) {
+  function callVisitor(key3, node, visitor, path6) {
     if (typeof visitor === "function")
-      return visitor(key2, node, path6);
+      return visitor(key3, node, path6);
     if (identity2.isMap(node))
-      return visitor.Map?.(key2, node, path6);
+      return visitor.Map?.(key3, node, path6);
     if (identity2.isSeq(node))
-      return visitor.Seq?.(key2, node, path6);
+      return visitor.Seq?.(key3, node, path6);
     if (identity2.isPair(node))
-      return visitor.Pair?.(key2, node, path6);
+      return visitor.Pair?.(key3, node, path6);
     if (identity2.isScalar(node))
-      return visitor.Scalar?.(key2, node, path6);
+      return visitor.Scalar?.(key3, node, path6);
     if (identity2.isAlias(node))
-      return visitor.Alias?.(key2, node, path6);
+      return visitor.Alias?.(key3, node, path6);
     return;
   }
-  function replaceNode(key2, path6, node) {
+  function replaceNode(key3, path6, node) {
     const parent = path6[path6.length - 1];
     if (identity2.isCollection(parent)) {
-      parent.items[key2] = node;
+      parent.items[key3] = node;
     } else if (identity2.isPair(parent)) {
-      if (key2 === "key")
+      if (key3 === "key")
         parent.key = node;
       else
         parent.value = node;
@@ -228538,7 +230768,7 @@ var require_anchors = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/doc/applyReviver.js
 var require_applyReviver = __commonJS((exports) => {
-  function applyReviver(reviver, obj, key2, val) {
+  function applyReviver(reviver, obj, key3, val) {
     if (val && typeof val === "object") {
       if (Array.isArray(val)) {
         for (let i7 = 0, len = val.length;i7 < len; ++i7) {
@@ -228578,7 +230808,7 @@ var require_applyReviver = __commonJS((exports) => {
         }
       }
     }
-    return reviver.call(obj, key2, val);
+    return reviver.call(obj, key3, val);
   }
   exports.applyReviver = applyReviver;
 });
@@ -228896,29 +231126,29 @@ var require_Collection = __commonJS((exports) => {
       if (isEmptyPath(path6))
         this.add(value4);
       else {
-        const [key2, ...rest] = path6;
-        const node = this.get(key2, true);
+        const [key3, ...rest] = path6;
+        const node = this.get(key3, true);
         if (identity2.isCollection(node))
           node.addIn(rest, value4);
         else if (node === undefined && this.schema)
-          this.set(key2, collectionFromPath(this.schema, rest, value4));
+          this.set(key3, collectionFromPath(this.schema, rest, value4));
         else
-          throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
+          throw new Error(`Expected YAML collection at ${key3}. Remaining path: ${rest}`);
       }
     }
     deleteIn(path6) {
-      const [key2, ...rest] = path6;
+      const [key3, ...rest] = path6;
       if (rest.length === 0)
-        return this.delete(key2);
-      const node = this.get(key2, true);
+        return this.delete(key3);
+      const node = this.get(key3, true);
       if (identity2.isCollection(node))
         return node.deleteIn(rest);
       else
-        throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
+        throw new Error(`Expected YAML collection at ${key3}. Remaining path: ${rest}`);
     }
     getIn(path6, keepScalar) {
-      const [key2, ...rest] = path6;
-      const node = this.get(key2, true);
+      const [key3, ...rest] = path6;
+      const node = this.get(key3, true);
       if (rest.length === 0)
         return !keepScalar && identity2.isScalar(node) ? node.value : node;
       else
@@ -228933,24 +231163,24 @@ var require_Collection = __commonJS((exports) => {
       });
     }
     hasIn(path6) {
-      const [key2, ...rest] = path6;
+      const [key3, ...rest] = path6;
       if (rest.length === 0)
-        return this.has(key2);
-      const node = this.get(key2, true);
+        return this.has(key3);
+      const node = this.get(key3, true);
       return identity2.isCollection(node) ? node.hasIn(rest) : false;
     }
     setIn(path6, value4) {
-      const [key2, ...rest] = path6;
+      const [key3, ...rest] = path6;
       if (rest.length === 0) {
-        this.set(key2, value4);
+        this.set(key3, value4);
       } else {
-        const node = this.get(key2, true);
+        const node = this.get(key3, true);
         if (identity2.isCollection(node))
           node.setIn(rest, value4);
         else if (node === undefined && this.schema)
-          this.set(key2, collectionFromPath(this.schema, rest, value4));
+          this.set(key3, collectionFromPath(this.schema, rest, value4));
         else
-          throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
+          throw new Error(`Expected YAML collection at ${key3}. Remaining path: ${rest}`);
       }
     }
   }
@@ -229538,19 +231768,19 @@ var require_stringifyPair = __commonJS((exports) => {
   var Scalar = require_Scalar();
   var stringify3 = require_stringify();
   var stringifyComment = require_stringifyComment();
-  function stringifyPair2({ key: key2, value: value4 }, ctx, onComment, onChompKeep) {
+  function stringifyPair2({ key: key3, value: value4 }, ctx, onComment, onChompKeep) {
     const { allNullValues, doc, indent: indent2, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
-    let keyComment = identity2.isNode(key2) && key2.comment || null;
+    let keyComment = identity2.isNode(key3) && key3.comment || null;
     if (simpleKeys) {
       if (keyComment) {
         throw new Error("With simple keys, key nodes cannot have comments");
       }
-      if (identity2.isCollection(key2) || !identity2.isNode(key2) && typeof key2 === "object") {
+      if (identity2.isCollection(key3) || !identity2.isNode(key3) && typeof key3 === "object") {
         const msg = "With simple keys, collection cannot be used as a key value";
         throw new Error(msg);
       }
     }
-    let explicitKey = !simpleKeys && (!key2 || keyComment && value4 == null && !ctx.inFlow || identity2.isCollection(key2) || (identity2.isScalar(key2) ? key2.type === Scalar.Scalar.BLOCK_FOLDED || key2.type === Scalar.Scalar.BLOCK_LITERAL : typeof key2 === "object"));
+    let explicitKey = !simpleKeys && (!key3 || keyComment && value4 == null && !ctx.inFlow || identity2.isCollection(key3) || (identity2.isScalar(key3) ? key3.type === Scalar.Scalar.BLOCK_FOLDED || key3.type === Scalar.Scalar.BLOCK_LITERAL : typeof key3 === "object"));
     ctx = Object.assign({}, ctx, {
       allNullValues: false,
       implicitKey: !explicitKey && (simpleKeys || !allNullValues),
@@ -229558,7 +231788,7 @@ var require_stringifyPair = __commonJS((exports) => {
     });
     let keyCommentDone = false;
     let chompKeep = false;
-    let str = stringify3.stringify(key2, ctx, () => keyCommentDone = true, () => chompKeep = true);
+    let str = stringify3.stringify(key3, ctx, () => keyCommentDone = true, () => chompKeep = true);
     if (!explicitKey && !ctx.inFlow && str.length > 1024) {
       if (simpleKeys)
         throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
@@ -229702,7 +231932,7 @@ var require_merge = __commonJS((exports) => {
     }),
     stringify: () => MERGE_KEY
   };
-  var isMergeKey = (ctx, key2) => (merge3.identify(key2) || identity2.isScalar(key2) && (!key2.type || key2.type === Scalar.Scalar.PLAIN) && merge3.identify(key2.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge3.tag && tag.default);
+  var isMergeKey = (ctx, key3) => (merge3.identify(key3) || identity2.isScalar(key3) && (!key3.type || key3.type === Scalar.Scalar.PLAIN) && merge3.identify(key3.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge3.tag && tag.default);
   function addMergeToJSMap(ctx, map3, value4) {
     value4 = ctx && identity2.isAlias(value4) ? value4.resolve(ctx.doc) : value4;
     if (identity2.isSeq(value4))
@@ -229719,14 +231949,14 @@ var require_merge = __commonJS((exports) => {
     if (!identity2.isMap(source))
       throw new Error("Merge sources must be maps or map aliases");
     const srcMap = source.toJSON(null, ctx, Map);
-    for (const [key2, value5] of srcMap) {
+    for (const [key3, value5] of srcMap) {
       if (map3 instanceof Map) {
-        if (!map3.has(key2))
-          map3.set(key2, value5);
+        if (!map3.has(key3))
+          map3.set(key3, value5);
       } else if (map3 instanceof Set) {
-        map3.add(key2);
-      } else if (!Object.prototype.hasOwnProperty.call(map3, key2)) {
-        Object.defineProperty(map3, key2, {
+        map3.add(key3);
+      } else if (!Object.prototype.hasOwnProperty.call(map3, key3)) {
+        Object.defineProperty(map3, key3, {
           value: value5,
           writable: true,
           enumerable: true,
@@ -229748,19 +231978,19 @@ var require_addPairToJSMap = __commonJS((exports) => {
   var stringify3 = require_stringify();
   var identity2 = require_identity();
   var toJS = require_toJS();
-  function addPairToJSMap(ctx, map3, { key: key2, value: value4 }) {
-    if (identity2.isNode(key2) && key2.addToJSMap)
-      key2.addToJSMap(ctx, map3, value4);
-    else if (merge3.isMergeKey(ctx, key2))
+  function addPairToJSMap(ctx, map3, { key: key3, value: value4 }) {
+    if (identity2.isNode(key3) && key3.addToJSMap)
+      key3.addToJSMap(ctx, map3, value4);
+    else if (merge3.isMergeKey(ctx, key3))
       merge3.addMergeToJSMap(ctx, map3, value4);
     else {
-      const jsKey = toJS.toJS(key2, "", ctx);
+      const jsKey = toJS.toJS(key3, "", ctx);
       if (map3 instanceof Map) {
         map3.set(jsKey, toJS.toJS(value4, jsKey, ctx));
       } else if (map3 instanceof Set) {
         map3.add(jsKey);
       } else {
-        const stringKey = stringifyKey(key2, jsKey, ctx);
+        const stringKey = stringifyKey(key3, jsKey, ctx);
         const jsValue = toJS.toJS(value4, stringKey, ctx);
         if (stringKey in map3)
           Object.defineProperty(map3, stringKey, {
@@ -229775,19 +232005,19 @@ var require_addPairToJSMap = __commonJS((exports) => {
     }
     return map3;
   }
-  function stringifyKey(key2, jsKey, ctx) {
+  function stringifyKey(key3, jsKey, ctx) {
     if (jsKey === null)
       return "";
     if (typeof jsKey !== "object")
       return String(jsKey);
-    if (identity2.isNode(key2) && ctx?.doc) {
+    if (identity2.isNode(key3) && ctx?.doc) {
       const strCtx = stringify3.createStringifyContext(ctx.doc, {});
       strCtx.anchors = new Set;
       for (const node of ctx.anchors.keys())
         strCtx.anchors.add(node.anchor);
       strCtx.inFlow = true;
       strCtx.inStringifyKey = true;
-      const strKey = key2.toString(strCtx);
+      const strKey = key3.toString(strCtx);
       if (!ctx.mapKeyWarned) {
         let jsonStr = JSON.stringify(strKey);
         if (jsonStr.length > 40)
@@ -229808,25 +232038,25 @@ var require_Pair = __commonJS((exports) => {
   var stringifyPair2 = require_stringifyPair();
   var addPairToJSMap = require_addPairToJSMap();
   var identity2 = require_identity();
-  function createPair(key2, value4, ctx) {
-    const k6 = createNode.createNode(key2, undefined, ctx);
+  function createPair(key3, value4, ctx) {
+    const k6 = createNode.createNode(key3, undefined, ctx);
     const v7 = createNode.createNode(value4, undefined, ctx);
     return new Pair(k6, v7);
   }
 
   class Pair {
-    constructor(key2, value4 = null) {
+    constructor(key3, value4 = null) {
       Object.defineProperty(this, identity2.NODE_TYPE, { value: identity2.PAIR });
-      this.key = key2;
+      this.key = key3;
       this.value = value4;
     }
     clone(schema) {
-      let { key: key2, value: value4 } = this;
-      if (identity2.isNode(key2))
-        key2 = key2.clone(schema);
+      let { key: key3, value: value4 } = this;
+      if (identity2.isNode(key3))
+        key3 = key3.clone(schema);
       if (identity2.isNode(value4))
         value4 = value4.clone(schema);
-      return new Pair(key2, value4);
+      return new Pair(key3, value4);
     }
     toJSON(_6, ctx) {
       const pair = ctx?.mapAsMap ? new Map : {};
@@ -229993,11 +232223,11 @@ var require_YAMLMap = __commonJS((exports) => {
   var identity2 = require_identity();
   var Pair = require_Pair();
   var Scalar = require_Scalar();
-  function findPair(items, key2) {
-    const k6 = identity2.isScalar(key2) ? key2.value : key2;
+  function findPair(items, key3) {
+    const k6 = identity2.isScalar(key3) ? key3.value : key3;
     for (const it2 of items) {
       if (identity2.isPair(it2)) {
-        if (it2.key === key2 || it2.key === k6)
+        if (it2.key === key3 || it2.key === k6)
           return it2;
         if (identity2.isScalar(it2.key) && it2.key.value === k6)
           return it2;
@@ -230017,20 +232247,20 @@ var require_YAMLMap = __commonJS((exports) => {
     static from(schema, obj, ctx) {
       const { keepUndefined, replacer } = ctx;
       const map3 = new this(schema);
-      const add = (key2, value4) => {
+      const add = (key3, value4) => {
         if (typeof replacer === "function")
-          value4 = replacer.call(obj, key2, value4);
-        else if (Array.isArray(replacer) && !replacer.includes(key2))
+          value4 = replacer.call(obj, key3, value4);
+        else if (Array.isArray(replacer) && !replacer.includes(key3))
           return;
         if (value4 !== undefined || keepUndefined)
-          map3.items.push(Pair.createPair(key2, value4, ctx));
+          map3.items.push(Pair.createPair(key3, value4, ctx));
       };
       if (obj instanceof Map) {
-        for (const [key2, value4] of obj)
-          add(key2, value4);
+        for (const [key3, value4] of obj)
+          add(key3, value4);
       } else if (obj && typeof obj === "object") {
-        for (const key2 of Object.keys(obj))
-          add(key2, obj[key2]);
+        for (const key3 of Object.keys(obj))
+          add(key3, obj[key3]);
       }
       if (typeof schema.sortMapEntries === "function") {
         map3.items.sort(schema.sortMapEntries);
@@ -230064,23 +232294,23 @@ var require_YAMLMap = __commonJS((exports) => {
         this.items.push(_pair);
       }
     }
-    delete(key2) {
-      const it2 = findPair(this.items, key2);
+    delete(key3) {
+      const it2 = findPair(this.items, key3);
       if (!it2)
         return false;
       const del = this.items.splice(this.items.indexOf(it2), 1);
       return del.length > 0;
     }
-    get(key2, keepScalar) {
-      const it2 = findPair(this.items, key2);
+    get(key3, keepScalar) {
+      const it2 = findPair(this.items, key3);
       const node = it2?.value;
       return (!keepScalar && identity2.isScalar(node) ? node.value : node) ?? undefined;
     }
-    has(key2) {
-      return !!findPair(this.items, key2);
+    has(key3) {
+      return !!findPair(this.items, key3);
     }
-    set(key2, value4) {
-      this.add(new Pair.Pair(key2, value4), true);
+    set(key3, value4) {
+      this.add(new Pair.Pair(key3, value4), true);
     }
     toJSON(_6, ctx, Type) {
       const map3 = Type ? new Type : ctx?.mapAsMap ? new Map : {};
@@ -230151,28 +232381,28 @@ var require_YAMLSeq = __commonJS((exports) => {
     add(value4) {
       this.items.push(value4);
     }
-    delete(key2) {
-      const idx = asItemIndex(key2);
+    delete(key3) {
+      const idx = asItemIndex(key3);
       if (typeof idx !== "number")
         return false;
       const del = this.items.splice(idx, 1);
       return del.length > 0;
     }
-    get(key2, keepScalar) {
-      const idx = asItemIndex(key2);
+    get(key3, keepScalar) {
+      const idx = asItemIndex(key3);
       if (typeof idx !== "number")
         return;
       const it2 = this.items[idx];
       return !keepScalar && identity2.isScalar(it2) ? it2.value : it2;
     }
-    has(key2) {
-      const idx = asItemIndex(key2);
+    has(key3) {
+      const idx = asItemIndex(key3);
       return typeof idx === "number" && idx < this.items.length;
     }
-    set(key2, value4) {
-      const idx = asItemIndex(key2);
+    set(key3, value4) {
+      const idx = asItemIndex(key3);
       if (typeof idx !== "number")
-        throw new Error(`Expected a valid index, not ${key2}.`);
+        throw new Error(`Expected a valid index, not ${key3}.`);
       const prev = this.items[idx];
       if (identity2.isScalar(prev) && Scalar.isScalarValue(value4))
         prev.value = value4;
@@ -230206,8 +232436,8 @@ var require_YAMLSeq = __commonJS((exports) => {
         let i7 = 0;
         for (let it2 of obj) {
           if (typeof replacer === "function") {
-            const key2 = obj instanceof Set ? it2 : String(i7++);
-            it2 = replacer.call(obj, key2, it2);
+            const key3 = obj instanceof Set ? it2 : String(i7++);
+            it2 = replacer.call(obj, key3, it2);
           }
           seq.items.push(createNode.createNode(it2, undefined, ctx));
         }
@@ -230215,8 +232445,8 @@ var require_YAMLSeq = __commonJS((exports) => {
       return seq;
     }
   }
-  function asItemIndex(key2) {
-    let idx = identity2.isScalar(key2) ? key2.value : key2;
+  function asItemIndex(key3) {
+    let idx = identity2.isScalar(key3) ? key3.value : key3;
     if (idx && typeof idx === "string")
       idx = Number(idx);
     return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null;
@@ -230590,25 +232820,25 @@ ${cn.comment}` : item.comment;
       for (let it2 of iterable) {
         if (typeof replacer === "function")
           it2 = replacer.call(iterable, String(i7++), it2);
-        let key2, value4;
+        let key3, value4;
         if (Array.isArray(it2)) {
           if (it2.length === 2) {
-            key2 = it2[0];
+            key3 = it2[0];
             value4 = it2[1];
           } else
             throw new TypeError(`Expected [key, value] tuple: ${it2}`);
         } else if (it2 && it2 instanceof Object) {
           const keys = Object.keys(it2);
           if (keys.length === 1) {
-            key2 = keys[0];
-            value4 = it2[key2];
+            key3 = keys[0];
+            value4 = it2[key3];
           } else {
             throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
           }
         } else {
-          key2 = it2;
+          key3 = it2;
         }
-        pairs2.items.push(Pair.createPair(key2, value4, ctx));
+        pairs2.items.push(Pair.createPair(key3, value4, ctx));
       }
     return pairs2;
   }
@@ -230649,16 +232879,16 @@ var require_omap = __commonJS((exports) => {
       if (ctx?.onCreate)
         ctx.onCreate(map3);
       for (const pair of this.items) {
-        let key2, value4;
+        let key3, value4;
         if (identity2.isPair(pair)) {
-          key2 = toJS.toJS(pair.key, "", ctx);
-          value4 = toJS.toJS(pair.value, key2, ctx);
+          key3 = toJS.toJS(pair.key, "", ctx);
+          value4 = toJS.toJS(pair.value, key3, ctx);
         } else {
-          key2 = toJS.toJS(pair, "", ctx);
+          key3 = toJS.toJS(pair, "", ctx);
         }
-        if (map3.has(key2))
+        if (map3.has(key3))
           throw new Error("Ordered maps must not include duplicate keys");
-        map3.set(key2, value4);
+        map3.set(key3, value4);
       }
       return map3;
     }
@@ -230679,12 +232909,12 @@ var require_omap = __commonJS((exports) => {
     resolve(seq, onError) {
       const pairs$1 = pairs.resolvePairs(seq, onError);
       const seenKeys = [];
-      for (const { key: key2 } of pairs$1.items) {
-        if (identity2.isScalar(key2)) {
-          if (seenKeys.includes(key2.value)) {
-            onError(`Ordered maps must not include duplicate keys: ${key2.value}`);
+      for (const { key: key3 } of pairs$1.items) {
+        if (identity2.isScalar(key3)) {
+          if (seenKeys.includes(key3.value)) {
+            onError(`Ordered maps must not include duplicate keys: ${key3.value}`);
           } else {
-            seenKeys.push(key2.value);
+            seenKeys.push(key3.value);
           }
         }
       }
@@ -230858,30 +233088,30 @@ var require_set = __commonJS((exports) => {
       super(schema);
       this.tag = YAMLSet.tag;
     }
-    add(key2) {
+    add(key3) {
       let pair;
-      if (identity2.isPair(key2))
-        pair = key2;
-      else if (key2 && typeof key2 === "object" && "key" in key2 && "value" in key2 && key2.value === null)
-        pair = new Pair.Pair(key2.key, null);
+      if (identity2.isPair(key3))
+        pair = key3;
+      else if (key3 && typeof key3 === "object" && "key" in key3 && "value" in key3 && key3.value === null)
+        pair = new Pair.Pair(key3.key, null);
       else
-        pair = new Pair.Pair(key2, null);
+        pair = new Pair.Pair(key3, null);
       const prev = YAMLMap.findPair(this.items, pair.key);
       if (!prev)
         this.items.push(pair);
     }
-    get(key2, keepPair) {
-      const pair = YAMLMap.findPair(this.items, key2);
+    get(key3, keepPair) {
+      const pair = YAMLMap.findPair(this.items, key3);
       return !keepPair && identity2.isPair(pair) ? identity2.isScalar(pair.key) ? pair.key.value : pair.key : pair;
     }
-    set(key2, value4) {
+    set(key3, value4) {
       if (typeof value4 !== "boolean")
         throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value4}`);
-      const prev = YAMLMap.findPair(this.items, key2);
+      const prev = YAMLMap.findPair(this.items, key3);
       if (prev && !value4) {
         this.items.splice(this.items.indexOf(prev), 1);
       } else if (!prev && value4) {
-        this.items.push(new Pair.Pair(key2));
+        this.items.push(new Pair.Pair(key3));
       }
     }
     toJSON(_6, ctx) {
@@ -231116,7 +233346,7 @@ var require_tags = __commonJS((exports) => {
       if (Array.isArray(customTags))
         tags = [];
       else {
-        const keys = Array.from(schemas.keys()).filter((key2) => key2 !== "yaml11").map((key2) => JSON.stringify(key2)).join(", ");
+        const keys = Array.from(schemas.keys()).filter((key3) => key3 !== "yaml11").map((key3) => JSON.stringify(key3)).join(", ");
         throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
       }
     }
@@ -231132,7 +233362,7 @@ var require_tags = __commonJS((exports) => {
       const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
       if (!tagObj) {
         const tagName = JSON.stringify(tag);
-        const keys = Object.keys(tagsByName).map((key2) => JSON.stringify(key2)).join(", ");
+        const keys = Object.keys(tagsByName).map((key3) => JSON.stringify(key3)).join(", ");
         throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
       }
       if (!tags2.includes(tagObj))
@@ -231367,13 +233597,13 @@ var require_Document = __commonJS((exports) => {
       setAnchors();
       return node;
     }
-    createPair(key2, value4, options = {}) {
-      const k6 = this.createNode(key2, null, options);
+    createPair(key3, value4, options = {}) {
+      const k6 = this.createNode(key3, null, options);
       const v7 = this.createNode(value4, null, options);
       return new Pair.Pair(k6, v7);
     }
-    delete(key2) {
-      return assertCollection(this.contents) ? this.contents.delete(key2) : false;
+    delete(key3) {
+      return assertCollection(this.contents) ? this.contents.delete(key3) : false;
     }
     deleteIn(path6) {
       if (Collection.isEmptyPath(path6)) {
@@ -231384,27 +233614,27 @@ var require_Document = __commonJS((exports) => {
       }
       return assertCollection(this.contents) ? this.contents.deleteIn(path6) : false;
     }
-    get(key2, keepScalar) {
-      return identity2.isCollection(this.contents) ? this.contents.get(key2, keepScalar) : undefined;
+    get(key3, keepScalar) {
+      return identity2.isCollection(this.contents) ? this.contents.get(key3, keepScalar) : undefined;
     }
     getIn(path6, keepScalar) {
       if (Collection.isEmptyPath(path6))
         return !keepScalar && identity2.isScalar(this.contents) ? this.contents.value : this.contents;
       return identity2.isCollection(this.contents) ? this.contents.getIn(path6, keepScalar) : undefined;
     }
-    has(key2) {
-      return identity2.isCollection(this.contents) ? this.contents.has(key2) : false;
+    has(key3) {
+      return identity2.isCollection(this.contents) ? this.contents.has(key3) : false;
     }
     hasIn(path6) {
       if (Collection.isEmptyPath(path6))
         return this.contents !== undefined;
       return identity2.isCollection(this.contents) ? this.contents.hasIn(path6) : false;
     }
-    set(key2, value4) {
+    set(key3, value4) {
       if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, [key2], value4);
+        this.contents = Collection.collectionFromPath(this.schema, [key3], value4);
       } else if (assertCollection(this.contents)) {
-        this.contents.set(key2, value4);
+        this.contents.set(key3, value4);
       }
     }
     setIn(path6, value4) {
@@ -231688,25 +233918,25 @@ var require_resolve_props = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/compose/util-contains-newline.js
 var require_util_contains_newline = __commonJS((exports) => {
-  function containsNewline(key2) {
-    if (!key2)
+  function containsNewline(key3) {
+    if (!key3)
       return null;
-    switch (key2.type) {
+    switch (key3.type) {
       case "alias":
       case "scalar":
       case "double-quoted-scalar":
       case "single-quoted-scalar":
-        if (key2.source.includes(`
+        if (key3.source.includes(`
 `))
           return true;
-        if (key2.end) {
-          for (const st2 of key2.end)
+        if (key3.end) {
+          for (const st2 of key3.end)
             if (st2.type === "newline")
               return true;
         }
         return false;
       case "flow-collection":
-        for (const it2 of key2.items) {
+        for (const it2 of key3.items) {
           for (const st2 of it2.start)
             if (st2.type === "newline")
               return true;
@@ -231771,10 +234001,10 @@ var require_resolve_block_map = __commonJS((exports) => {
     let offset = bm.offset;
     let commentEnd = null;
     for (const collItem of bm.items) {
-      const { start: start3, key: key2, sep: sep3, value: value4 } = collItem;
+      const { start: start3, key: key3, sep: sep3, value: value4 } = collItem;
       const keyProps = resolveProps.resolveProps(start3, {
         indicator: "explicit-key-ind",
-        next: key2 ?? sep3?.[0],
+        next: key3 ?? sep3?.[0],
         offset,
         onError,
         parentIndent: bm.indent,
@@ -231782,10 +234012,10 @@ var require_resolve_block_map = __commonJS((exports) => {
       });
       const implicitKey = !keyProps.found;
       if (implicitKey) {
-        if (key2) {
-          if (key2.type === "block-seq")
+        if (key3) {
+          if (key3.type === "block-seq")
             onError(offset, "BLOCK_AS_IMPLICIT_KEY", "A block sequence may not be used as an implicit map key");
-          else if ("indent" in key2 && key2.indent !== bm.indent)
+          else if ("indent" in key3 && key3.indent !== bm.indent)
             onError(offset, "BAD_INDENT", startColMsg);
         }
         if (!keyProps.anchor && !keyProps.tag && !sep3) {
@@ -231799,17 +234029,17 @@ var require_resolve_block_map = __commonJS((exports) => {
           }
           continue;
         }
-        if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key2)) {
-          onError(key2 ?? start3[start3.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
+        if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key3)) {
+          onError(key3 ?? start3[start3.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
         }
       } else if (keyProps.found?.indent !== bm.indent) {
         onError(offset, "BAD_INDENT", startColMsg);
       }
       ctx.atKey = true;
       const keyStart = keyProps.end;
-      const keyNode = key2 ? composeNode(ctx, key2, keyProps, onError) : composeEmptyNode(ctx, keyStart, start3, null, keyProps, onError);
+      const keyNode = key3 ? composeNode(ctx, key3, keyProps, onError) : composeEmptyNode(ctx, keyStart, start3, null, keyProps, onError);
       if (ctx.schema.compat)
-        utilFlowIndentCheck.flowIndentCheck(bm.indent, key2, onError);
+        utilFlowIndentCheck.flowIndentCheck(bm.indent, key3, onError);
       ctx.atKey = false;
       if (utilMapIncludes.mapIncludes(ctx, map3.items, keyNode))
         onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
@@ -231819,7 +234049,7 @@ var require_resolve_block_map = __commonJS((exports) => {
         offset: keyNode.range[2],
         onError,
         parentIndent: bm.indent,
-        startOnNewline: !key2 || key2.type === "block-scalar"
+        startOnNewline: !key3 || key3.type === "block-scalar"
       });
       offset = valueProps.end;
       if (valueProps.found) {
@@ -231975,11 +234205,11 @@ var require_resolve_flow_collection = __commonJS((exports) => {
     let offset = fc.offset + fc.start.source.length;
     for (let i7 = 0;i7 < fc.items.length; ++i7) {
       const collItem = fc.items[i7];
-      const { start: start3, key: key2, sep: sep3, value: value4 } = collItem;
+      const { start: start3, key: key3, sep: sep3, value: value4 } = collItem;
       const props = resolveProps.resolveProps(start3, {
         flow: fcName,
         indicator: "explicit-key-ind",
-        next: key2 ?? sep3?.[0],
+        next: key3 ?? sep3?.[0],
         offset,
         onError,
         parentIndent: fc.indent,
@@ -232001,8 +234231,8 @@ var require_resolve_flow_collection = __commonJS((exports) => {
           offset = props.end;
           continue;
         }
-        if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key2))
-          onError(key2, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+        if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key3))
+          onError(key3, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
       }
       if (i7 === 0) {
         if (props.comma)
@@ -232047,8 +234277,8 @@ var require_resolve_flow_collection = __commonJS((exports) => {
       } else {
         ctx.atKey = true;
         const keyStart = props.end;
-        const keyNode = key2 ? composeNode(ctx, key2, props, onError) : composeEmptyNode(ctx, keyStart, start3, null, props, onError);
-        if (isBlock(key2))
+        const keyNode = key3 ? composeNode(ctx, key3, props, onError) : composeEmptyNode(ctx, keyStart, start3, null, props, onError);
+        if (isBlock(key3))
           onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
         ctx.atKey = false;
         const valueProps = resolveProps.resolveProps(sep3 ?? [], {
@@ -232860,7 +235090,7 @@ var require_composer = __commonJS((exports) => {
   var node_process = __require("node:process");
   var directives4 = require_directives2();
   var Document = require_Document();
-  var errors2 = require_errors3();
+  var errors3 = require_errors3();
   var identity2 = require_identity();
   var composeDoc = require_compose_doc();
   var resolveEnd = require_resolve_end();
@@ -232911,9 +235141,9 @@ var require_composer = __commonJS((exports) => {
       this.onError = (source, code2, message, warning) => {
         const pos = getErrorPos(source);
         if (warning)
-          this.warnings.push(new errors2.YAMLWarning(pos, code2, message));
+          this.warnings.push(new errors3.YAMLWarning(pos, code2, message));
         else
-          this.errors.push(new errors2.YAMLParseError(pos, code2, message));
+          this.errors.push(new errors3.YAMLParseError(pos, code2, message));
       };
       this.directives = new directives4.Directives({ version: options.version || "1.2" });
       this.options = options;
@@ -232997,7 +235227,7 @@ ${cb}` : comment;
           break;
         case "error": {
           const msg = token.source ? `${token.message}: ${JSON.stringify(token.source)}` : token.message;
-          const error5 = new errors2.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
+          const error5 = new errors3.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
           if (this.atDirectives || !this.doc)
             this.errors.push(error5);
           else
@@ -233007,7 +235237,7 @@ ${cb}` : comment;
         case "doc-end": {
           if (!this.doc) {
             const msg = "Unexpected doc-end without preceding document";
-            this.errors.push(new errors2.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg));
+            this.errors.push(new errors3.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg));
             break;
           }
           this.doc.directives.docEnd = true;
@@ -233022,7 +235252,7 @@ ${end.comment}` : end.comment;
           break;
         }
         default:
-          this.errors.push(new errors2.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", `Unsupported token ${token.type}`));
+          this.errors.push(new errors3.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", `Unsupported token ${token.type}`));
       }
     }
     *end(forceDoc = false, endOffset = -1) {
@@ -233048,7 +235278,7 @@ ${end.comment}` : end.comment;
 var require_cst_scalar = __commonJS((exports) => {
   var resolveBlockScalar = require_resolve_block_scalar();
   var resolveFlowScalar = require_resolve_flow_scalar();
-  var errors2 = require_errors3();
+  var errors3 = require_errors3();
   var stringifyString = require_stringifyString();
   function resolveAsScalar(token, strict = true, onError) {
     if (token) {
@@ -233057,7 +235287,7 @@ var require_cst_scalar = __commonJS((exports) => {
         if (onError)
           onError(offset, code2, message);
         else
-          throw new errors2.YAMLParseError([offset, offset + 1], code2, message);
+          throw new errors3.YAMLParseError([offset, offset + 1], code2, message);
       };
       switch (token.type) {
         case "scalar":
@@ -233171,9 +235401,9 @@ var require_cst_scalar = __commonJS((exports) => {
       if (!addEndtoBlockProps(props, "end" in token ? token.end : undefined))
         props.push({ type: "newline", offset: -1, indent: indent2, source: `
 ` });
-      for (const key2 of Object.keys(token))
-        if (key2 !== "type" && key2 !== "offset")
-          delete token[key2];
+      for (const key3 of Object.keys(token))
+        if (key3 !== "type" && key3 !== "offset")
+          delete token[key3];
       Object.assign(token, { type: "block-scalar", indent: indent2, props, source: body });
     }
   }
@@ -233222,9 +235452,9 @@ var require_cst_scalar = __commonJS((exports) => {
       default: {
         const indent2 = "indent" in token ? token.indent : -1;
         const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st2) => st2.type === "space" || st2.type === "comment" || st2.type === "newline") : [];
-        for (const key2 of Object.keys(token))
-          if (key2 !== "type" && key2 !== "offset")
-            delete token[key2];
+        for (const key3 of Object.keys(token))
+          if (key3 !== "type" && key3 !== "offset")
+            delete token[key3];
         Object.assign(token, { type: type4, indent: indent2, source, end });
       }
     }
@@ -233276,12 +235506,12 @@ var require_cst_stringify = __commonJS((exports) => {
       }
     }
   }
-  function stringifyItem({ start: start3, key: key2, sep: sep3, value: value4 }) {
+  function stringifyItem({ start: start3, key: key3, sep: sep3, value: value4 }) {
     let res = "";
     for (const st2 of start3)
       res += st2.source;
-    if (key2)
-      res += stringifyToken(key2);
+    if (key3)
+      res += stringifyToken(key3);
     if (sep3)
       for (const st2 of sep3)
         res += st2.source;
@@ -234577,7 +236807,7 @@ var require_parser2 = __commonJS((exports) => {
                 });
               } else if (isFlowToken(it2.key) && !includesToken(it2.sep, "newline")) {
                 const start4 = getFirstKeyStartProps(it2.start);
-                const key2 = it2.key;
+                const key3 = it2.key;
                 const sep3 = it2.sep;
                 sep3.push(this.sourceToken);
                 delete it2.key;
@@ -234586,7 +236816,7 @@ var require_parser2 = __commonJS((exports) => {
                   type: "block-map",
                   offset: this.offset,
                   indent: this.indent,
-                  items: [{ start: start4, key: key2, sep: sep3 }]
+                  items: [{ start: start4, key: key3, sep: sep3 }]
                 });
               } else if (start3.length > 0) {
                 it2.sep = it2.sep.concat(start3, this.sourceToken);
@@ -234919,7 +237149,7 @@ var require_parser2 = __commonJS((exports) => {
 var require_public_api = __commonJS((exports) => {
   var composer = require_composer();
   var Document = require_Document();
-  var errors2 = require_errors3();
+  var errors3 = require_errors3();
   var log = require_log();
   var identity2 = require_identity();
   var lineCounter = require_line_counter();
@@ -234936,8 +237166,8 @@ var require_public_api = __commonJS((exports) => {
     const docs = Array.from(composer$1.compose(parser$1.parse(source)));
     if (prettyErrors && lineCounter2)
       for (const doc of docs) {
-        doc.errors.forEach(errors2.prettifyError(source, lineCounter2));
-        doc.warnings.forEach(errors2.prettifyError(source, lineCounter2));
+        doc.errors.forEach(errors3.prettifyError(source, lineCounter2));
+        doc.warnings.forEach(errors3.prettifyError(source, lineCounter2));
       }
     if (docs.length > 0)
       return docs;
@@ -234952,13 +237182,13 @@ var require_public_api = __commonJS((exports) => {
       if (!doc)
         doc = _doc;
       else if (doc.options.logLevel !== "silent") {
-        doc.errors.push(new errors2.YAMLParseError(_doc.range.slice(0, 2), "MULTIPLE_DOCS", "Source contains multiple documents; please use YAML.parseAllDocuments()"));
+        doc.errors.push(new errors3.YAMLParseError(_doc.range.slice(0, 2), "MULTIPLE_DOCS", "Source contains multiple documents; please use YAML.parseAllDocuments()"));
         break;
       }
     }
     if (prettyErrors && lineCounter2) {
-      doc.errors.forEach(errors2.prettifyError(source, lineCounter2));
-      doc.warnings.forEach(errors2.prettifyError(source, lineCounter2));
+      doc.errors.forEach(errors3.prettifyError(source, lineCounter2));
+      doc.warnings.forEach(errors3.prettifyError(source, lineCounter2));
     }
     return doc;
   }
@@ -240787,7 +243017,7 @@ minimatch.unescape = unescape2;
 // ../../node_modules/glob/dist/esm/glob.js
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
-// ../../node_modules/lru-cache/dist/esm/index.js
+// ../../node_modules/path-scurry/node_modules/lru-cache/dist/esm/index.js
 var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
 var warned = new Set;
 var PROCESS = typeof process === "object" && !!process ? process : {};
@@ -245345,7 +247575,7 @@ function pruneCurrentEnv(currentEnv, env2) {
 var package_default = {
   name: "@settlemint/sdk-cli",
   description: "Command-line interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.2.3-pr0f5033c1",
+  version: "2.2.3-pr19ac75c7",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -245392,11 +247622,11 @@ var package_default = {
     commander: "11.1.0",
     "@inquirer/confirm": "5.1.9",
     "@inquirer/input": "4.1.9",
-    "@inquirer/password": "4.0.12",
+    "@inquirer/password": "4.0.13",
     "@inquirer/select": "4.2.0",
-    "@settlemint/sdk-js": "2.2.3-pr0f5033c1",
-    "@settlemint/sdk-utils": "2.2.3-pr0f5033c1",
-    "@types/node": "22.15.14",
+    "@settlemint/sdk-js": "2.2.3-pr19ac75c7",
+    "@settlemint/sdk-utils": "2.2.3-pr19ac75c7",
+    "@types/node": "22.15.17",
     "@types/semver": "7.7.0",
     "@types/which": "3.0.4",
     "get-tsconfig": "4.10.0",
@@ -245409,7 +247639,7 @@ var package_default = {
     yoctocolors: "2.1.1"
   },
   peerDependencies: {
-    hardhat: "2.23.0"
+    hardhat: "2.24.0"
   },
   peerDependenciesMeta: {
     hardhat: {
@@ -248824,7 +251054,7 @@ var getPlatformConfigQuery = graphql(`
             disabled
           }
         }
-        preDeployedAbis
+        preDeployedContracts
         sdkVersion
         kits {
           id
@@ -252413,20 +254643,476 @@ var esm_default4 = createPrompt((config3, done) => {
   return `${prefix} ${message}${defaultValue} ${formattedValue}`;
 });
 
-// ../../node_modules/@inquirer/password/dist/esm/index.js
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/key.js
+var isEnterKey2 = (key2) => key2.name === "enter" || key2.name === "return";
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/errors.js
+class AbortPromptError2 extends Error {
+  name = "AbortPromptError";
+  message = "Prompt was aborted";
+  constructor(options) {
+    super();
+    this.cause = options?.cause;
+  }
+}
+
+class CancelPromptError2 extends Error {
+  name = "CancelPromptError";
+  message = "Prompt was canceled";
+}
+
+class ExitPromptError2 extends Error {
+  name = "ExitPromptError";
+}
+
+class HookError2 extends Error {
+  name = "HookError";
+}
+
+class ValidationError2 extends Error {
+  name = "ValidationError";
+}
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/use-prefix.js
+import { AsyncResource as AsyncResource5 } from "node:async_hooks";
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/hook-engine.js
+import { AsyncLocalStorage as AsyncLocalStorage2, AsyncResource as AsyncResource4 } from "node:async_hooks";
+var hookStorage2 = new AsyncLocalStorage2;
+function createStore2(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {}
+  };
+  return store;
+}
+function withHooks2(rl, cb) {
+  const store = createStore2(rl);
+  return hookStorage2.run(store, () => {
+    function cycle(render) {
+      store.handleChange = () => {
+        store.index = 0;
+        render();
+      };
+      store.handleChange();
+    }
+    return cb(cycle);
+  });
+}
+function getStore2() {
+  const store = hookStorage2.getStore();
+  if (!store) {
+    throw new HookError2("[Inquirer] Hook functions can only be called from within a prompt");
+  }
+  return store;
+}
+function readline3() {
+  return getStore2().rl;
+}
+function withUpdates2(fn) {
+  const wrapped = (...args) => {
+    const store = getStore2();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource4.bind(wrapped);
+}
+function withPointer2(cb) {
+  const store = getStore2();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value4) {
+      store.hooks[index] = value4;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange2() {
+  getStore2().handleChange();
+}
+var effectScheduler2 = {
+  queue(cb) {
+    const store = getStore2();
+    const { index } = store;
+    store.hooksEffect.push(() => {
+      store.hooksCleanup[index]?.();
+      const cleanFn = cb(readline3());
+      if (cleanFn != null && typeof cleanFn !== "function") {
+        throw new ValidationError2("useEffect return value must be a cleanup function or nothing.");
+      }
+      store.hooksCleanup[index] = cleanFn;
+    });
+  },
+  run() {
+    const store = getStore2();
+    withUpdates2(() => {
+      store.hooksEffect.forEach((effect) => {
+        effect();
+      });
+      store.hooksEffect.length = 0;
+    })();
+  },
+  clearAll() {
+    const store = getStore2();
+    store.hooksCleanup.forEach((cleanFn) => {
+      cleanFn?.();
+    });
+    store.hooksEffect.length = 0;
+    store.hooksCleanup.length = 0;
+  }
+};
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/use-state.js
+function useState2(defaultValue) {
+  return withPointer2((pointer) => {
+    const setFn = (newValue) => {
+      if (pointer.get() !== newValue) {
+        pointer.set(newValue);
+        handleChange2();
+      }
+    };
+    if (pointer.initialized) {
+      return [pointer.get(), setFn];
+    }
+    const value4 = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+    pointer.set(value4);
+    return [value4, setFn];
+  });
+}
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/use-effect.js
+function useEffect2(cb, depArray) {
+  withPointer2((pointer) => {
+    const oldDeps = pointer.get();
+    const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i6) => !Object.is(dep, oldDeps[i6]));
+    if (hasChanged) {
+      effectScheduler2.queue(cb);
+    }
+    pointer.set(depArray);
+  });
+}
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/theme.js
+var import_yoctocolors_cjs4 = __toESM(require_yoctocolors_cjs(), 1);
+var defaultTheme2 = {
+  prefix: {
+    idle: import_yoctocolors_cjs4.default.blue("?"),
+    done: import_yoctocolors_cjs4.default.green(esm_default.tick)
+  },
+  spinner: {
+    interval: 80,
+    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].map((frame) => import_yoctocolors_cjs4.default.yellow(frame))
+  },
+  style: {
+    answer: import_yoctocolors_cjs4.default.cyan,
+    message: import_yoctocolors_cjs4.default.bold,
+    error: (text2) => import_yoctocolors_cjs4.default.red(`> ${text2}`),
+    defaultAnswer: (text2) => import_yoctocolors_cjs4.default.dim(`(${text2})`),
+    help: import_yoctocolors_cjs4.default.dim,
+    highlight: import_yoctocolors_cjs4.default.cyan,
+    key: (text2) => import_yoctocolors_cjs4.default.cyan(import_yoctocolors_cjs4.default.bold(`<${text2}>`))
+  }
+};
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/make-theme.js
+function isPlainObject3(value4) {
+  if (typeof value4 !== "object" || value4 === null)
+    return false;
+  let proto = value4;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value4) === proto;
+}
+function deepMerge3(...objects) {
+  const output = {};
+  for (const obj of objects) {
+    for (const [key2, value4] of Object.entries(obj)) {
+      const prevValue = output[key2];
+      output[key2] = isPlainObject3(prevValue) && isPlainObject3(value4) ? deepMerge3(prevValue, value4) : value4;
+    }
+  }
+  return output;
+}
+function makeTheme2(...themes) {
+  const themesToMerge = [
+    defaultTheme2,
+    ...themes.filter((theme) => theme != null)
+  ];
+  return deepMerge3(...themesToMerge);
+}
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/use-prefix.js
+function usePrefix2({ status = "idle", theme }) {
+  const [showLoader, setShowLoader] = useState2(false);
+  const [tick, setTick] = useState2(0);
+  const { prefix, spinner: spinner2 } = makeTheme2(theme);
+  useEffect2(() => {
+    if (status === "loading") {
+      let tickInterval;
+      let inc = -1;
+      const delayTimeout = setTimeout(AsyncResource5.bind(() => {
+        setShowLoader(true);
+        tickInterval = setInterval(AsyncResource5.bind(() => {
+          inc = inc + 1;
+          setTick(inc % spinner2.frames.length);
+        }), spinner2.interval);
+      }), 300);
+      return () => {
+        clearTimeout(delayTimeout);
+        clearInterval(tickInterval);
+      };
+    } else {
+      setShowLoader(false);
+    }
+  }, [status]);
+  if (showLoader) {
+    return spinner2.frames[tick];
+  }
+  const iconName = status === "loading" ? "idle" : status;
+  return typeof prefix === "string" ? prefix : prefix[iconName] ?? prefix["idle"];
+}
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/use-ref.js
+function useRef2(val) {
+  return useState2({ current: val })[0];
+}
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/use-keypress.js
+function useKeypress2(userHandler) {
+  const signal = useRef2(userHandler);
+  signal.current = userHandler;
+  useEffect2((rl) => {
+    let ignore = false;
+    const handler = withUpdates2((_input, event) => {
+      if (ignore)
+        return;
+      signal.current(event, rl);
+    });
+    rl.input.on("keypress", handler);
+    return () => {
+      ignore = true;
+      rl.input.removeListener("keypress", handler);
+    };
+  }, []);
+}
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/utils.js
+var import_cli_width2 = __toESM(require_cli_width(), 1);
+var import_wrap_ansi2 = __toESM(require_wrap_ansi(), 1);
+function breakLines2(content, width) {
+  return content.split(`
+`).flatMap((line) => import_wrap_ansi2.default(line, width, { trim: false, hard: true }).split(`
+`).map((str) => str.trimEnd())).join(`
+`);
+}
+function readlineWidth2() {
+  return import_cli_width2.default({ defaultWidth: 80, output: readline3().output });
+}
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/create-prompt.js
+var import_mute_stream2 = __toESM(require_lib(), 1);
+import * as readline4 from "node:readline";
+import { AsyncResource as AsyncResource6 } from "node:async_hooks";
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/screen-manager.js
 var import_ansi_escapes3 = __toESM(require_ansi_escapes(), 1);
-var esm_default5 = createPrompt((config3, done) => {
+import { stripVTControlCharacters as stripVTControlCharacters3 } from "node:util";
+var height2 = (content) => content.split(`
+`).length;
+var lastLine2 = (content) => content.split(`
+`).pop() ?? "";
+function cursorDown2(n6) {
+  return n6 > 0 ? import_ansi_escapes3.default.cursorDown(n6) : "";
+}
+
+class ScreenManager2 {
+  height = 0;
+  extraLinesUnderPrompt = 0;
+  cursorPos;
+  rl;
+  constructor(rl) {
+    this.rl = rl;
+    this.cursorPos = rl.getCursorPos();
+  }
+  write(content) {
+    this.rl.output.unmute();
+    this.rl.output.write(content);
+    this.rl.output.mute();
+  }
+  render(content, bottomContent = "") {
+    const promptLine = lastLine2(content);
+    const rawPromptLine = stripVTControlCharacters3(promptLine);
+    let prompt = rawPromptLine;
+    if (this.rl.line.length > 0) {
+      prompt = prompt.slice(0, -this.rl.line.length);
+    }
+    this.rl.setPrompt(prompt);
+    this.cursorPos = this.rl.getCursorPos();
+    const width = readlineWidth2();
+    content = breakLines2(content, width);
+    bottomContent = breakLines2(bottomContent, width);
+    if (rawPromptLine.length % width === 0) {
+      content += `
+`;
+    }
+    let output = content + (bottomContent ? `
+` + bottomContent : "");
+    const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+    const bottomContentHeight = promptLineUpDiff + (bottomContent ? height2(bottomContent) : 0);
+    if (bottomContentHeight > 0)
+      output += import_ansi_escapes3.default.cursorUp(bottomContentHeight);
+    output += import_ansi_escapes3.default.cursorTo(this.cursorPos.cols);
+    this.write(cursorDown2(this.extraLinesUnderPrompt) + import_ansi_escapes3.default.eraseLines(this.height) + output);
+    this.extraLinesUnderPrompt = bottomContentHeight;
+    this.height = height2(output);
+  }
+  checkCursorPos() {
+    const cursorPos = this.rl.getCursorPos();
+    if (cursorPos.cols !== this.cursorPos.cols) {
+      this.write(import_ansi_escapes3.default.cursorTo(cursorPos.cols));
+      this.cursorPos = cursorPos;
+    }
+  }
+  done({ clearContent }) {
+    this.rl.setPrompt("");
+    let output = cursorDown2(this.extraLinesUnderPrompt);
+    output += clearContent ? import_ansi_escapes3.default.eraseLines(this.height) : `
+`;
+    output += import_ansi_escapes3.default.cursorShow;
+    this.write(output);
+    this.rl.close();
+  }
+}
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/promise-polyfill.js
+class PromisePolyfill2 extends Promise {
+  static withResolver() {
+    let resolve6;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve6 = res;
+      reject = rej;
+    });
+    return { promise, resolve: resolve6, reject };
+  }
+}
+
+// ../../node_modules/@inquirer/password/node_modules/@inquirer/core/dist/esm/lib/create-prompt.js
+function getCallSites2() {
+  const _prepareStackTrace = Error.prepareStackTrace;
+  let result = [];
+  try {
+    Error.prepareStackTrace = (_5, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+  } catch {
+    return result;
+  }
+  Error.prepareStackTrace = _prepareStackTrace;
+  return result;
+}
+function createPrompt2(view) {
+  const callSites = getCallSites2();
+  const prompt = (config3, context = {}) => {
+    const { input = process.stdin, signal } = context;
+    const cleanups = new Set;
+    const output = new import_mute_stream2.default;
+    output.pipe(context.output ?? process.stdout);
+    const rl = readline4.createInterface({
+      terminal: true,
+      input,
+      output
+    });
+    const screen = new ScreenManager2(rl);
+    const { promise, resolve: resolve6, reject } = PromisePolyfill2.withResolver();
+    const cancel3 = () => reject(new CancelPromptError2);
+    if (signal) {
+      const abort = () => reject(new AbortPromptError2({ cause: signal.reason }));
+      if (signal.aborted) {
+        abort();
+        return Object.assign(promise, { cancel: cancel3 });
+      }
+      signal.addEventListener("abort", abort);
+      cleanups.add(() => signal.removeEventListener("abort", abort));
+    }
+    cleanups.add(onExit((code2, signal2) => {
+      reject(new ExitPromptError2(`User force closed the prompt with ${code2} ${signal2}`));
+    }));
+    const sigint = () => reject(new ExitPromptError2(`User force closed the prompt with SIGINT`));
+    rl.on("SIGINT", sigint);
+    cleanups.add(() => rl.removeListener("SIGINT", sigint));
+    const checkCursorPos = () => screen.checkCursorPos();
+    rl.input.on("keypress", checkCursorPos);
+    cleanups.add(() => rl.input.removeListener("keypress", checkCursorPos));
+    return withHooks2(rl, (cycle) => {
+      const hooksCleanup = AsyncResource6.bind(() => effectScheduler2.clearAll());
+      rl.on("close", hooksCleanup);
+      cleanups.add(() => rl.removeListener("close", hooksCleanup));
+      cycle(() => {
+        try {
+          const nextView = view(config3, (value4) => {
+            setImmediate(() => resolve6(value4));
+          });
+          if (nextView === undefined) {
+            const callerFilename = callSites[1]?.getFileName();
+            throw new Error(`Prompt functions must return a string.
+    at ${callerFilename}`);
+          }
+          const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+          screen.render(content, bottomContent);
+          effectScheduler2.run();
+        } catch (error5) {
+          reject(error5);
+        }
+      });
+      return Object.assign(promise.then((answer) => {
+        effectScheduler2.clearAll();
+        return answer;
+      }, (error5) => {
+        effectScheduler2.clearAll();
+        throw error5;
+      }).finally(() => {
+        cleanups.forEach((cleanup) => cleanup());
+        screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+        output.end();
+      }).then(() => promise), { cancel: cancel3 });
+    });
+  };
+  return prompt;
+}
+// ../../node_modules/@inquirer/password/dist/esm/index.js
+var import_ansi_escapes4 = __toESM(require_ansi_escapes(), 1);
+var esm_default5 = createPrompt2((config3, done) => {
   const { validate: validate3 = () => true } = config3;
-  const theme = makeTheme(config3.theme);
-  const [status, setStatus] = useState("idle");
-  const [errorMsg, setError] = useState();
-  const [value4, setValue] = useState("");
-  const prefix = usePrefix({ status, theme });
-  useKeypress(async (key2, rl) => {
+  const theme = makeTheme2(config3.theme);
+  const [status, setStatus] = useState2("idle");
+  const [errorMsg, setError] = useState2();
+  const [value4, setValue] = useState2("");
+  const prefix = usePrefix2({ status, theme });
+  useKeypress2(async (key3, rl) => {
     if (status !== "idle") {
       return;
     }
-    if (isEnterKey(key2)) {
+    if (isEnterKey2(key3)) {
       const answer = value4;
       setStatus("loading");
       const isValid2 = await validate3(answer);
@@ -252451,7 +255137,7 @@ var esm_default5 = createPrompt((config3, done) => {
     const maskChar = typeof config3.mask === "string" ? config3.mask : "*";
     formattedValue = maskChar.repeat(value4.length);
   } else if (status !== "done") {
-    helpTip = `${theme.style.help("[input is masked]")}${import_ansi_escapes3.default.cursorHide}`;
+    helpTip = `${theme.style.help("[input is masked]")}${import_ansi_escapes4.default.cursorHide}`;
   }
   if (status === "done") {
     formattedValue = theme.style.answer(formattedValue);
@@ -253675,7 +256361,7 @@ var basename2 = function(p6, extension) {
   return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 };
 // ../../node_modules/defu/dist/defu.mjs
-function isPlainObject3(value4) {
+function isPlainObject4(value4) {
   if (value4 === null || typeof value4 !== "object") {
     return false;
   }
@@ -253692,27 +256378,27 @@ function isPlainObject3(value4) {
   return true;
 }
 function _defu(baseObject, defaults2, namespace = ".", merger) {
-  if (!isPlainObject3(defaults2)) {
+  if (!isPlainObject4(defaults2)) {
     return _defu(baseObject, {}, namespace, merger);
   }
   const object = Object.assign({}, defaults2);
-  for (const key2 in baseObject) {
-    if (key2 === "__proto__" || key2 === "constructor") {
+  for (const key3 in baseObject) {
+    if (key3 === "__proto__" || key3 === "constructor") {
       continue;
     }
-    const value4 = baseObject[key2];
+    const value4 = baseObject[key3];
     if (value4 === null || value4 === undefined) {
       continue;
     }
-    if (merger && merger(object, key2, value4, namespace)) {
+    if (merger && merger(object, key3, value4, namespace)) {
       continue;
     }
-    if (Array.isArray(value4) && Array.isArray(object[key2])) {
-      object[key2] = [...value4, ...object[key2]];
-    } else if (isPlainObject3(value4) && isPlainObject3(object[key2])) {
-      object[key2] = _defu(value4, object[key2], (namespace ? `${namespace}.` : "") + key2.toString(), merger);
+    if (Array.isArray(value4) && Array.isArray(object[key3])) {
+      object[key3] = [...value4, ...object[key3]];
+    } else if (isPlainObject4(value4) && isPlainObject4(object[key3])) {
+      object[key3] = _defu(value4, object[key3], (namespace ? `${namespace}.` : "") + key3.toString(), merger);
     } else {
-      object[key2] = value4;
+      object[key3] = value4;
     }
   }
   return object;
@@ -253721,15 +256407,15 @@ function createDefu(merger) {
   return (...arguments_4) => arguments_4.reduce((p6, c3) => _defu(p6, c3, "", merger), {});
 }
 var defu = createDefu();
-var defuFn = createDefu((object, key2, currentValue) => {
-  if (object[key2] !== undefined && typeof currentValue === "function") {
-    object[key2] = currentValue(object[key2]);
+var defuFn = createDefu((object, key3, currentValue) => {
+  if (object[key3] !== undefined && typeof currentValue === "function") {
+    object[key3] = currentValue(object[key3]);
     return true;
   }
 });
-var defuArrayFn = createDefu((object, key2, currentValue) => {
-  if (Array.isArray(object[key2]) && typeof currentValue === "function") {
-    object[key2] = currentValue(object[key2]);
+var defuArrayFn = createDefu((object, key3, currentValue) => {
+  if (Array.isArray(object[key3]) && typeof currentValue === "function") {
+    object[key3] = currentValue(object[key3]);
     return true;
   }
 });
@@ -256426,11 +259112,11 @@ function cacheDirectory() {
 }
 function normalizeHeaders(headers = {}) {
   const normalized = {};
-  for (const [key2, value4] of Object.entries(headers)) {
+  for (const [key3, value4] of Object.entries(headers)) {
     if (!value4) {
       continue;
     }
-    normalized[key2.toLowerCase()] = value4;
+    normalized[key3.toLowerCase()] = value4;
   }
   return normalized;
 }
@@ -258298,9 +260984,9 @@ function smartContractPortalMiddlewareCreateCommand() {
           }
           if (includePredeployedAbis && includePredeployedAbis.length > 0) {
             const platformConfig = await settlemint.platform.config();
-            const invalidPredeployedAbis = includePredeployedAbis.filter((abi) => !platformConfig.preDeployedAbis.some((predeployedAbi) => predeployedAbi === abi));
+            const invalidPredeployedAbis = includePredeployedAbis.filter((abi) => !platformConfig.preDeployedContracts.some((contract) => contract === abi));
             if (invalidPredeployedAbis.length > 0) {
-              cancel2(`Invalid pre-deployed abis: '${invalidPredeployedAbis.join(", ")}'. Possible values: '${platformConfig.preDeployedAbis.sort().join(", ")}'`);
+              cancel2(`Invalid pre-deployed abis: '${invalidPredeployedAbis.join(", ")}'. Possible values: '${platformConfig.preDeployedContracts.sort().join(", ")}'`);
             }
           }
           const result = await showSpinner(() => settlemint.middleware.create({
@@ -259064,7 +261750,7 @@ function jsonOutput(data) {
 var composer = require_composer();
 var Document = require_Document();
 var Schema = require_Schema();
-var errors2 = require_errors3();
+var errors3 = require_errors3();
 var Alias = require_Alias();
 var identity2 = require_identity();
 var Pair = require_Pair();
@@ -259080,9 +261766,9 @@ var visit2 = require_visit();
 var $Composer = composer.Composer;
 var $Document = Document.Document;
 var $Schema = Schema.Schema;
-var $YAMLError = errors2.YAMLError;
-var $YAMLParseError = errors2.YAMLParseError;
-var $YAMLWarning = errors2.YAMLWarning;
+var $YAMLError = errors3.YAMLError;
+var $YAMLParseError = errors3.YAMLParseError;
+var $YAMLWarning = errors3.YAMLWarning;
 var $Alias = Alias.Alias;
 var $isAlias = identity2.isAlias;
 var $isCollection = identity2.isCollection;
@@ -259155,7 +261841,7 @@ function configCommand() {
         providerName: provider.name,
         regionName: region.name
       }))).sort((a8, b4) => a8.providerId.localeCompare(b4.providerId) || a8.regionId.localeCompare(b4.regionId)),
-      preDeployedAbis: platformConfig.preDeployedAbis.sort()
+      preDeployedContracts: platformConfig.preDeployedContracts.sort()
     };
     if (output === "json") {
       jsonOutput(platformConfigData);
@@ -259165,7 +261851,7 @@ function configCommand() {
       table("Templates (Kits)", platformConfigData.kits);
       table("Use cases (Smart Contract Sets)", platformConfigData.useCases);
       table("Providers and regions", platformConfigData.deploymentEngineTargets);
-      list("Pre-deployed abis (Smart Contract Portal)", platformConfigData.preDeployedAbis);
+      list("Pre-deployed abis (Smart Contract Portal)", platformConfigData.preDeployedContracts);
     }
     outro("Platform configuration retrieved");
   });
@@ -259432,7 +262118,7 @@ async function getServicesAndMapResults({
   const application = await settlemint.application.read(applicationUniqueName);
   const services = await servicesSpinner(settlemint, applicationUniqueName, types2);
   const results = (types2 ?? SERVICE_TYPES).filter((serviceType) => !types2 || types2.includes(serviceType)).map((serviceType) => {
-    const [_6, labels] = Object.entries(LABELS_MAP).find(([key2, value4]) => value4.command === serviceType) ?? [
+    const [_6, labels] = Object.entries(LABELS_MAP).find(([key3, value4]) => value4.command === serviceType) ?? [
       null,
       { plural: serviceType }
     ];
@@ -259667,11 +262353,11 @@ function createCommand4() {
 
 // src/utils/commands/passthrough-options.ts
 function mapPassthroughOptions(options, command) {
-  const optionArgs = Object.entries(options).map(([key2, value4]) => {
+  const optionArgs = Object.entries(options).map(([key3, value4]) => {
     if (value4 === true) {
-      return `--${key2}`;
+      return `--${key3}`;
     }
-    return `--${key2}=${value4}`;
+    return `--${key3}=${value4}`;
   });
   return [...optionArgs, ...command.args];
 }
@@ -260710,4 +263396,4 @@ async function sdkCliCommand(argv = process.argv) {
 // src/cli.ts
 sdkCliCommand();
 
-//# debugId=D1AD32A1C09D698564756E2164756E21
+//# debugId=1AA3ACD61A1C91EC64756E2164756E21