@vltpkg/cli-js 1.0.2 → 1.0.3

package/chunk-LPIBYUMT.js

@@ -0,0 +1,854 @@
+var global = globalThis;
+import {Buffer} from "node:buffer";
+import {setTimeout as _vlt_setTimeout,clearTimeout as _vlt_clearTimeout,setImmediate as _vlt_setImmediate,clearImmediate as _vlt_clearImmediate,setInterval as _vlt_setInterval,clearInterval as _vlt_clearInterval} from "node:timers";
+globalThis.setTimeout = _vlt_setTimeout;
+globalThis.clearTimeout = _vlt_clearTimeout;
+globalThis.setImmediate = _vlt_setImmediate;
+globalThis.clearImmediate = _vlt_clearImmediate;
+globalThis.setInterval = _vlt_setInterval;
+globalThis.clearInterval = _vlt_clearInterval;
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  error
+} from "./chunk-WZWDS3W4.js";
+
+// ../../node_modules/.vlt/~npm~lru-cache@11.5.2/node_modules/lru-cache/dist/esm/node/index.min.js
+import { tracingChannel as G, channel as P } from "node:diagnostics_channel";
+var S = P("lru-cache:metrics");
+var W = G("lru-cache");
+var L = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+var R = () => S.hasSubscribers || W.hasSubscribers;
+var U = /* @__PURE__ */ new Set();
+var M = typeof process == "object" && process ? process : {};
+var k = (d4, e, t, i2) => {
+  typeof M.emitWarning == "function" ? M.emitWarning(d4, e, t, i2) : console.error(`[${t}] ${e}: ${d4}`);
+};
+var H = (d4) => !U.has(d4);
+var T = (d4) => !!d4 && d4 === Math.floor(d4) && d4 > 0 && isFinite(d4);
+var j = (d4) => T(d4) ? d4 <= Math.pow(2, 8) ? Uint8Array : d4 <= Math.pow(2, 16) ? Uint16Array : d4 <= Math.pow(2, 32) ? Uint32Array : d4 <= Number.MAX_SAFE_INTEGER ? O : null : null;
+var O = class extends Array {
+  constructor(e) {
+    super(e), this.fill(0);
+  }
+};
+var x = class d {
+  heap;
+  length;
+  static #o = false;
+  static create(e) {
+    let t = j(e);
+    if (!t) return [];
+    d.#o = true;
+    let i2 = new d(e, t);
+    return d.#o = false, i2;
+  }
+  constructor(e, t) {
+    if (!d.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+    this.heap = new t(e), this.length = 0;
+  }
+  push(e) {
+    this.heap[this.length++] = e;
+  }
+  pop() {
+    return this.heap[--this.length];
+  }
+};
+var I = class d2 {
+  #o;
+  #c;
+  #S;
+  #O;
+  #w;
+  #M;
+  #I;
+  #m;
+  get perf() {
+    return this.#m;
+  }
+  ttl;
+  ttlResolution;
+  ttlAutopurge;
+  updateAgeOnGet;
+  updateAgeOnHas;
+  allowStale;
+  noDisposeOnSet;
+  noUpdateTTL;
+  maxEntrySize;
+  sizeCalculation;
+  noDeleteOnFetchRejection;
+  noDeleteOnStaleGet;
+  allowStaleOnFetchAbort;
+  allowStaleOnFetchRejection;
+  ignoreFetchAbort;
+  backgroundFetchSize;
+  #n;
+  #b;
+  #s;
+  #i;
+  #t;
+  #l;
+  #u;
+  #a;
+  #h;
+  #y;
+  #r;
+  #_;
+  #F;
+  #d;
+  #g;
+  #T;
+  #U;
+  #f;
+  #D;
+  static unsafeExposeInternals(e) {
+    return { starts: e.#F, ttls: e.#d, autopurgeTimers: e.#g, sizes: e.#_, keyMap: e.#s, keyList: e.#i, valList: e.#t, next: e.#l, prev: e.#u, get head() {
+      return e.#a;
+    }, get tail() {
+      return e.#h;
+    }, free: e.#y, isBackgroundFetch: (t) => e.#e(t), backgroundFetch: (t, i2, s, n) => e.#P(t, i2, s, n), moveToTail: (t) => e.#L(t), indexes: (t) => e.#A(t), rindexes: (t) => e.#z(t), isStale: (t) => e.#p(t) };
+  }
+  get max() {
+    return this.#o;
+  }
+  get maxSize() {
+    return this.#c;
+  }
+  get calculatedSize() {
+    return this.#b;
+  }
+  get size() {
+    return this.#n;
+  }
+  get fetchMethod() {
+    return this.#M;
+  }
+  get memoMethod() {
+    return this.#I;
+  }
+  get dispose() {
+    return this.#S;
+  }
+  get onInsert() {
+    return this.#O;
+  }
+  get disposeAfter() {
+    return this.#w;
+  }
+  constructor(e) {
+    let { max: t = 0, ttl: i2, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: l, allowStale: h, dispose: r, onInsert: c, disposeAfter: m2, noDisposeOnSet: _2, noUpdateTTL: u2, maxSize: g2 = 0, maxEntrySize: f = 0, sizeCalculation: y2, fetchMethod: a2, memoMethod: w2, noDeleteOnFetchRejection: F2, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: p, allowStaleOnFetchAbort: A2, ignoreFetchAbort: z, backgroundFetchSize: C2 = 1, perf: E } = e;
+    if (this.backgroundFetchSize = C2, E !== void 0 && typeof E?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+    if (this.#m = E ?? L, t !== 0 && !T(t)) throw new TypeError("max option must be a nonnegative integer");
+    let v2 = t ? j(t) : Array;
+    if (!v2) throw new Error("invalid max value: " + t);
+    if (this.#o = t, this.#c = g2, this.maxEntrySize = f || this.#c, this.sizeCalculation = y2, this.sizeCalculation) {
+      if (!this.#c && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+      if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+    }
+    if (w2 !== void 0 && typeof w2 != "function") throw new TypeError("memoMethod must be a function if defined");
+    if (this.#I = w2, a2 !== void 0 && typeof a2 != "function") throw new TypeError("fetchMethod must be a function if specified");
+    if (this.#M = a2, this.#U = !!a2, this.#s = /* @__PURE__ */ new Map(), this.#i = Array.from({ length: t }).fill(void 0), this.#t = Array.from({ length: t }).fill(void 0), this.#l = new v2(t), this.#u = new v2(t), this.#a = 0, this.#h = 0, this.#y = x.create(t), this.#n = 0, this.#b = 0, typeof r == "function" && (this.#S = r), typeof c == "function" && (this.#O = c), typeof m2 == "function" ? (this.#w = m2, this.#r = []) : (this.#w = void 0, this.#r = void 0), this.#T = !!this.#S, this.#D = !!this.#O, this.#f = !!this.#w, this.noDisposeOnSet = !!_2, this.noUpdateTTL = !!u2, this.noDeleteOnFetchRejection = !!F2, this.allowStaleOnFetchRejection = !!p, this.allowStaleOnFetchAbort = !!A2, this.ignoreFetchAbort = !!z, this.maxEntrySize !== 0) {
+      if (this.#c !== 0 && !T(this.#c)) throw new TypeError("maxSize must be a positive integer if specified");
+      if (!T(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+      this.#X();
+    }
+    if (this.allowStale = !!h, this.noDeleteOnStaleGet = !!b, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!l, this.ttlResolution = T(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i2 || 0, this.ttl) {
+      if (!T(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+      this.#k();
+    }
+    if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+    if (!this.ttlAutopurge && !this.#o && !this.#c) {
+      let D = "LRU_CACHE_UNBOUNDED";
+      H(D) && (U.add(D), k("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", D, d2));
+    }
+  }
+  getRemainingTTL(e) {
+    return this.#s.has(e) ? 1 / 0 : 0;
+  }
+  #k() {
+    let e = new O(this.#o), t = new O(this.#o);
+    this.#d = e, this.#F = t;
+    let i2 = this.ttlAutopurge ? Array.from({ length: this.#o }) : void 0;
+    this.#g = i2, this.#H = (h, r, c = this.#m.now()) => {
+      t[h] = r !== 0 ? c : 0, e[h] = r, s(h, r);
+    }, this.#R = (h) => {
+      t[h] = e[h] !== 0 ? this.#m.now() : 0, s(h, e[h]);
+    };
+    let s = this.ttlAutopurge ? (h, r) => {
+      if (i2?.[h] && (clearTimeout(i2[h]), i2[h] = void 0), r && r !== 0 && i2) {
+        let c = setTimeout(() => {
+          this.#p(h) ? (this.#E(this.#i[h], "expire"), i2[h] = void 0) : s(h, l(h));
+        }, r + 1);
+        c.unref && c.unref(), i2[h] = c;
+      }
+    } : () => {
+    };
+    this.#v = (h, r) => {
+      if (e[r]) {
+        let c = e[r], m2 = t[r];
+        if (!c || !m2) return;
+        h.ttl = c, h.start = m2, h.now = n || o();
+        let _2 = h.now - m2;
+        h.remainingTTL = c - _2;
+      }
+    };
+    let n = 0, o = () => {
+      let h = this.#m.now();
+      if (this.ttlResolution > 0) {
+        n = h;
+        let r = setTimeout(() => n = 0, this.ttlResolution);
+        r.unref && r.unref();
+      }
+      return h;
+    };
+    this.getRemainingTTL = (h) => {
+      let r = this.#s.get(h);
+      return r === void 0 ? 0 : l(r);
+    };
+    let l = (h) => {
+      let r = e[h], c = t[h];
+      if (!r || !c) return 1 / 0;
+      let m2 = (n || o()) - c;
+      return r - m2;
+    };
+    this.#p = (h) => {
+      let r = t[h], c = e[h];
+      return !!c && !!r && (n || o()) - r > c;
+    };
+  }
+  #R = () => {
+  };
+  #v = () => {
+  };
+  #H = () => {
+  };
+  #p = () => false;
+  #X() {
+    let e = new O(this.#o);
+    this.#b = 0, this.#_ = e, this.#x = (t) => {
+      this.#b -= e[t], e[t] = 0;
+    }, this.#N = (t, i2, s, n) => {
+      if (!T(s)) {
+        if (this.#e(i2)) return this.backgroundFetchSize;
+        if (n) {
+          if (typeof n != "function") throw new TypeError("sizeCalculation must be a function");
+          if (s = n(i2, t), !T(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+        } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+      }
+      return s;
+    }, this.#j = (t, i2, s) => {
+      if (e[t] = i2, this.#c) {
+        let n = this.#c - e[t];
+        for (; this.#b > n; ) this.#G(true);
+      }
+      this.#b += e[t], s && (s.entrySize = i2, s.totalCalculatedSize = this.#b);
+    };
+  }
+  #x = (e) => {
+  };
+  #j = (e, t, i2) => {
+  };
+  #N = (e, t, i2, s) => {
+    if (i2 || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+    return 0;
+  };
+  *#A({ allowStale: e = this.allowStale } = {}) {
+    if (this.#n) for (let t = this.#h; this.#V(t) && ((e || !this.#p(t)) && (yield t), t !== this.#a); ) t = this.#u[t];
+  }
+  *#z({ allowStale: e = this.allowStale } = {}) {
+    if (this.#n) for (let t = this.#a; this.#V(t) && ((e || !this.#p(t)) && (yield t), t !== this.#h); ) t = this.#l[t];
+  }
+  #V(e) {
+    return e !== void 0 && this.#s.get(this.#i[e]) === e;
+  }
+  *entries() {
+    for (let e of this.#A()) this.#t[e] !== void 0 && this.#i[e] !== void 0 && !this.#e(this.#t[e]) && (yield [this.#i[e], this.#t[e]]);
+  }
+  *rentries() {
+    for (let e of this.#z()) this.#t[e] !== void 0 && this.#i[e] !== void 0 && !this.#e(this.#t[e]) && (yield [this.#i[e], this.#t[e]]);
+  }
+  *keys() {
+    for (let e of this.#A()) {
+      let t = this.#i[e];
+      t !== void 0 && !this.#e(this.#t[e]) && (yield t);
+    }
+  }
+  *rkeys() {
+    for (let e of this.#z()) {
+      let t = this.#i[e];
+      t !== void 0 && !this.#e(this.#t[e]) && (yield t);
+    }
+  }
+  *values() {
+    for (let e of this.#A()) this.#t[e] !== void 0 && !this.#e(this.#t[e]) && (yield this.#t[e]);
+  }
+  *rvalues() {
+    for (let e of this.#z()) this.#t[e] !== void 0 && !this.#e(this.#t[e]) && (yield this.#t[e]);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  [Symbol.toStringTag] = "LRUCache";
+  find(e, t = {}) {
+    for (let i2 of this.#A()) {
+      let s = this.#t[i2], n = this.#e(s) ? s.__staleWhileFetching : s;
+      if (n !== void 0 && e(n, this.#i[i2], this)) return this.#C(this.#i[i2], t);
+    }
+  }
+  forEach(e, t = this) {
+    for (let i2 of this.#A()) {
+      let s = this.#t[i2], n = this.#e(s) ? s.__staleWhileFetching : s;
+      n !== void 0 && e.call(t, n, this.#i[i2], this);
+    }
+  }
+  rforEach(e, t = this) {
+    for (let i2 of this.#z()) {
+      let s = this.#t[i2], n = this.#e(s) ? s.__staleWhileFetching : s;
+      n !== void 0 && e.call(t, n, this.#i[i2], this);
+    }
+  }
+  purgeStale() {
+    let e = false;
+    for (let t of this.#z({ allowStale: true })) this.#p(t) && (this.#E(this.#i[t], "expire"), e = true);
+    return e;
+  }
+  info(e) {
+    let t = this.#s.get(e);
+    if (t === void 0) return;
+    let i2 = this.#t[t], s = this.#e(i2) ? i2.__staleWhileFetching : i2;
+    if (s === void 0) return;
+    let n = { value: s };
+    if (this.#d && this.#F) {
+      let o = this.#d[t], l = this.#F[t];
+      if (o && l) {
+        let h = o - (this.#m.now() - l);
+        n.ttl = h, n.start = Date.now();
+      }
+    }
+    return this.#_ && (n.size = this.#_[t]), n;
+  }
+  dump() {
+    let e = [];
+    for (let t of this.#A({ allowStale: true })) {
+      let i2 = this.#i[t], s = this.#t[t], n = this.#e(s) ? s.__staleWhileFetching : s;
+      if (n === void 0 || i2 === void 0) continue;
+      let o = { value: n };
+      if (this.#d && this.#F) {
+        o.ttl = this.#d[t];
+        let l = this.#m.now() - this.#F[t];
+        o.start = Math.floor(Date.now() - l);
+      }
+      this.#_ && (o.size = this.#_[t]), e.unshift([i2, o]);
+    }
+    return e;
+  }
+  load(e) {
+    this.clear();
+    for (let [t, i2] of e) {
+      if (i2.start) {
+        let s = Date.now() - i2.start;
+        i2.start = this.#m.now() - s;
+      }
+      this.#W(t, i2.value, i2);
+    }
+  }
+  set(e, t, i2 = {}) {
+    let { status: s = S.hasSubscribers ? {} : void 0 } = i2;
+    i2.status = s, s && (s.op = "set", s.key = e, t !== void 0 && (s.value = t), s.cache = this);
+    let n = this.#W(e, t, i2);
+    return s && S.hasSubscribers && S.publish(s), n;
+  }
+  #W(e, t, i2, s) {
+    let { ttl: n = this.ttl, start: o, noDisposeOnSet: l = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: r } = i2, c = this.#e(t);
+    if (t === void 0) return r && (r.set = "deleted"), this.delete(e), this;
+    let { noUpdateTTL: m2 = this.noUpdateTTL } = i2;
+    r && !c && (r.value = t);
+    let _2 = this.#N(e, t, i2.size || 0, h, r);
+    if (this.maxEntrySize && _2 > this.maxEntrySize) return this.#E(e, "set"), r && (r.set = "miss", r.maxEntrySizeExceeded = true), this;
+    let u2 = this.#n === 0 ? void 0 : this.#s.get(e);
+    if (u2 === void 0) u2 = this.#n === 0 ? this.#h : this.#y.length !== 0 ? this.#y.pop() : this.#n === this.#o ? this.#G(false) : this.#n, this.#i[u2] = e, this.#t[u2] = t, this.#s.set(e, u2), this.#l[this.#h] = u2, this.#u[u2] = this.#h, this.#h = u2, this.#n++, this.#j(u2, _2, r), r && (r.set = "add"), m2 = false, this.#D && !c && this.#O?.(t, e, "add");
+    else {
+      this.#L(u2);
+      let g2 = this.#t[u2];
+      if (t !== g2) {
+        if (!l) if (this.#e(g2)) {
+          g2 !== s && g2.__abortController.abort(new Error("replaced"));
+          let { __staleWhileFetching: f } = g2;
+          f !== void 0 && f !== t && (this.#T && this.#S?.(f, e, "set"), this.#f && this.#r?.push([f, e, "set"]));
+        } else this.#T && this.#S?.(g2, e, "set"), this.#f && this.#r?.push([g2, e, "set"]);
+        if (this.#x(u2), this.#j(u2, _2, r), this.#t[u2] = t, !c) {
+          let f = g2 && this.#e(g2) ? g2.__staleWhileFetching : g2, y2 = f === void 0 ? "add" : t !== f ? "replace" : "update";
+          r && (r.set = y2, f !== void 0 && (r.oldValue = f)), this.#D && this.onInsert?.(t, e, y2);
+        }
+      } else c || (r && (r.set = "update"), this.#D && this.onInsert?.(t, e, "update"));
+    }
+    if (n !== 0 && !this.#d && this.#k(), this.#d && (m2 || this.#H(u2, n, o), r && this.#v(r, u2)), !l && this.#f && this.#r) {
+      let g2 = this.#r, f;
+      for (; f = g2?.shift(); ) this.#w?.(...f);
+    }
+    return this;
+  }
+  pop() {
+    try {
+      for (; this.#n; ) {
+        let e = this.#t[this.#a];
+        if (this.#G(true), this.#e(e)) {
+          if (e.__staleWhileFetching) return e.__staleWhileFetching;
+        } else if (e !== void 0) return e;
+      }
+    } finally {
+      if (this.#f && this.#r) {
+        let e = this.#r, t;
+        for (; t = e?.shift(); ) this.#w?.(...t);
+      }
+    }
+  }
+  #G(e) {
+    let t = this.#a, i2 = this.#i[t], s = this.#t[t], n = this.#e(s);
+    n && s.__abortController.abort(new Error("evicted"));
+    let o = n ? s.__staleWhileFetching : s;
+    return (this.#T || this.#f) && o !== void 0 && (this.#T && this.#S?.(o, i2, "evict"), this.#f && this.#r?.push([o, i2, "evict"])), this.#x(t), this.#g?.[t] && (clearTimeout(this.#g[t]), this.#g[t] = void 0), e && (this.#i[t] = void 0, this.#t[t] = void 0, this.#y.push(t)), this.#n === 1 ? (this.#a = this.#h = 0, this.#y.length = 0) : this.#a = this.#l[t], this.#s.delete(i2), this.#n--, t;
+  }
+  has(e, t = {}) {
+    let { status: i2 = S.hasSubscribers ? {} : void 0 } = t;
+    t.status = i2, i2 && (i2.op = "has", i2.key = e, i2.cache = this);
+    let s = this.#Y(e, t);
+    return S.hasSubscribers && S.publish(i2), s;
+  }
+  #Y(e, t = {}) {
+    let { updateAgeOnHas: i2 = this.updateAgeOnHas, status: s } = t, n = this.#s.get(e);
+    if (n !== void 0) {
+      let o = this.#t[n];
+      if (this.#e(o) && o.__staleWhileFetching === void 0) return false;
+      if (this.#p(n)) s && (s.has = "stale", this.#v(s, n));
+      else return i2 && this.#R(n), s && (s.has = "hit", this.#v(s, n)), true;
+    } else s && (s.has = "miss");
+    return false;
+  }
+  peek(e, t = {}) {
+    let { status: i2 = R() ? {} : void 0 } = t;
+    i2 && (i2.op = "peek", i2.key = e, i2.cache = this), t.status = i2;
+    let s = this.#J(e, t);
+    return S.hasSubscribers && S.publish(i2), s;
+  }
+  #J(e, t) {
+    let { status: i2, allowStale: s = this.allowStale } = t, n = this.#s.get(e);
+    if (n === void 0 || !s && this.#p(n)) {
+      i2 && (i2.peek = n === void 0 ? "miss" : "stale");
+      return;
+    }
+    let o = this.#t[n], l = this.#e(o) ? o.__staleWhileFetching : o;
+    return i2 && (l !== void 0 ? (i2.peek = "hit", i2.value = l) : i2.peek = "miss"), l;
+  }
+  #P(e, t, i2, s) {
+    let n = t === void 0 ? void 0 : this.#t[t];
+    if (this.#e(n)) return n;
+    let o = new AbortController(), { signal: l } = i2;
+    l?.addEventListener("abort", () => o.abort(l.reason), { signal: o.signal });
+    let h = { signal: o.signal, options: i2, context: s }, r = (f, y2 = false) => {
+      let { aborted: a2 } = o.signal, w2 = i2.ignoreFetchAbort && f !== void 0, F2 = i2.ignoreFetchAbort || !!(i2.allowStaleOnFetchAbort && f !== void 0);
+      if (i2.status && (a2 && !y2 ? (i2.status.fetchAborted = true, i2.status.fetchError = o.signal.reason, w2 && (i2.status.fetchAbortIgnored = true)) : i2.status.fetchResolved = true), a2 && !w2 && !y2) return m2(o.signal.reason, F2);
+      let b = u2, p = this.#t[t];
+      return (p === u2 || p === void 0 && w2 && y2) && (f === void 0 ? b.__staleWhileFetching !== void 0 ? this.#t[t] = b.__staleWhileFetching : this.#E(e, "fetch") : (i2.status && (i2.status.fetchUpdated = true), this.#W(e, f, h.options, b))), f;
+    }, c = (f) => (i2.status && (i2.status.fetchRejected = true, i2.status.fetchError = f), m2(f, false)), m2 = (f, y2) => {
+      let { aborted: a2 } = o.signal, w2 = a2 && i2.allowStaleOnFetchAbort, F2 = w2 || i2.allowStaleOnFetchRejection, b = F2 || i2.noDeleteOnFetchRejection, p = u2;
+      if (this.#t[t] === u2 && (!b || !y2 && p.__staleWhileFetching === void 0 ? this.#E(e, "fetch") : w2 || (this.#t[t] = p.__staleWhileFetching)), F2) return i2.status && p.__staleWhileFetching !== void 0 && (i2.status.returnedStale = true), p.__staleWhileFetching;
+      if (p.__returned === p) throw f;
+    }, _2 = (f, y2) => {
+      let a2 = this.#M?.(e, n, h);
+      o.signal.addEventListener("abort", () => {
+        (!i2.ignoreFetchAbort || i2.allowStaleOnFetchAbort) && (f(void 0), i2.allowStaleOnFetchAbort && (f = (w2) => r(w2, true)));
+      }), a2 && a2 instanceof Promise ? a2.then((w2) => f(w2 === void 0 ? void 0 : w2), y2) : a2 !== void 0 && f(a2);
+    };
+    i2.status && (i2.status.fetchDispatched = true);
+    let u2 = new Promise(_2).then(r, c), g2 = Object.assign(u2, { __abortController: o, __staleWhileFetching: n, __returned: void 0 });
+    return t === void 0 ? (this.#W(e, g2, { ...h.options, status: void 0 }), t = this.#s.get(e)) : this.#t[t] = g2, g2;
+  }
+  #e(e) {
+    if (!this.#U) return false;
+    let t = e;
+    return !!t && t instanceof Promise && t.hasOwnProperty("__staleWhileFetching") && t.__abortController instanceof AbortController;
+  }
+  fetch(e, t = {}) {
+    let i2 = W.hasSubscribers, { status: s = R() ? {} : void 0 } = t;
+    t.status = s, s && t.context && (s.context = t.context);
+    let n = this.#B(e, t);
+    return s && i2 && (s.trace = true, W.tracePromise(() => n, s).catch(() => {
+    })), n;
+  }
+  async #B(e, t = {}) {
+    let { allowStale: i2 = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: l = this.noDisposeOnSet, size: h = 0, sizeCalculation: r = this.sizeCalculation, noUpdateTTL: c = this.noUpdateTTL, noDeleteOnFetchRejection: m2 = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: _2 = this.allowStaleOnFetchRejection, ignoreFetchAbort: u2 = this.ignoreFetchAbort, allowStaleOnFetchAbort: g2 = this.allowStaleOnFetchAbort, context: f, forceRefresh: y2 = false, status: a2, signal: w2 } = t;
+    if (a2 && (a2.op = "fetch", a2.key = e, y2 && (a2.forceRefresh = true), a2.cache = this), !this.#U) return a2 && (a2.fetch = "get"), this.#C(e, { allowStale: i2, updateAgeOnGet: s, noDeleteOnStaleGet: n, status: a2 });
+    let F2 = { allowStale: i2, updateAgeOnGet: s, noDeleteOnStaleGet: n, ttl: o, noDisposeOnSet: l, size: h, sizeCalculation: r, noUpdateTTL: c, noDeleteOnFetchRejection: m2, allowStaleOnFetchRejection: _2, allowStaleOnFetchAbort: g2, ignoreFetchAbort: u2, status: a2, signal: w2 }, b = this.#s.get(e);
+    if (b === void 0) {
+      a2 && (a2.fetch = "miss");
+      let p = this.#P(e, b, F2, f);
+      return p.__returned = p;
+    } else {
+      let p = this.#t[b];
+      if (this.#e(p)) {
+        let v2 = i2 && p.__staleWhileFetching !== void 0;
+        return a2 && (a2.fetch = "inflight", v2 && (a2.returnedStale = true)), v2 ? p.__staleWhileFetching : p.__returned = p;
+      }
+      let A2 = this.#p(b);
+      if (!y2 && !A2) return a2 && (a2.fetch = "hit"), this.#L(b), s && this.#R(b), a2 && this.#v(a2, b), p;
+      let z = this.#P(e, b, F2, f), E = z.__staleWhileFetching !== void 0 && i2;
+      return a2 && (a2.fetch = A2 ? "stale" : "refresh", E && A2 && (a2.returnedStale = true)), E ? z.__staleWhileFetching : z.__returned = z;
+    }
+  }
+  forceFetch(e, t = {}) {
+    let i2 = W.hasSubscribers, { status: s = R() ? {} : void 0 } = t;
+    t.status = s, s && t.context && (s.context = t.context);
+    let n = this.#K(e, t);
+    return s && i2 && (s.trace = true, W.tracePromise(() => n, s).catch(() => {
+    })), n;
+  }
+  async #K(e, t = {}) {
+    let i2 = await this.#B(e, t);
+    if (i2 === void 0) throw new Error("fetch() returned undefined");
+    return i2;
+  }
+  memo(e, t = {}) {
+    let { status: i2 = S.hasSubscribers ? {} : void 0 } = t;
+    t.status = i2, i2 && (i2.op = "memo", i2.key = e, t.context && (i2.context = t.context), i2.cache = this);
+    let s = this.#Q(e, t);
+    return i2 && (i2.value = s), S.hasSubscribers && S.publish(i2), s;
+  }
+  #Q(e, t = {}) {
+    let i2 = this.#I;
+    if (!i2) throw new Error("no memoMethod provided to constructor");
+    let { context: s, status: n, forceRefresh: o, ...l } = t;
+    n && o && (n.forceRefresh = true);
+    let h = this.#C(e, l), r = o || h === void 0;
+    if (n && (n.memo = r ? "miss" : "hit", r || (n.value = h)), !r) return h;
+    let c = i2(e, h, { options: l, context: s });
+    return n && (n.value = c), this.#W(e, c, l), c;
+  }
+  get(e, t = {}) {
+    let { status: i2 = S.hasSubscribers ? {} : void 0 } = t;
+    t.status = i2, i2 && (i2.op = "get", i2.key = e, i2.cache = this);
+    let s = this.#C(e, t);
+    return i2 && (s !== void 0 && (i2.value = s), S.hasSubscribers && S.publish(i2)), s;
+  }
+  #C(e, t = {}) {
+    let { allowStale: i2 = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = t, l = this.#s.get(e);
+    if (l === void 0) {
+      o && (o.get = "miss");
+      return;
+    }
+    let h = this.#t[l], r = this.#e(h);
+    return o && this.#v(o, l), this.#p(l) ? r ? (o && (o.get = "stale-fetching"), i2 && h.__staleWhileFetching !== void 0 ? (o && (o.returnedStale = true), h.__staleWhileFetching) : void 0) : (n || this.#E(e, "expire"), o && (o.get = "stale"), i2 ? (o && (o.returnedStale = true), h) : void 0) : (o && (o.get = r ? "fetching" : "hit"), this.#L(l), s && this.#R(l), r ? h.__staleWhileFetching : h);
+  }
+  #$(e, t) {
+    this.#u[t] = e, this.#l[e] = t;
+  }
+  #L(e) {
+    e !== this.#h && (e === this.#a ? this.#a = this.#l[e] : this.#$(this.#u[e], this.#l[e]), this.#$(this.#h, e), this.#h = e);
+  }
+  delete(e) {
+    return this.#E(e, "delete");
+  }
+  #E(e, t) {
+    S.hasSubscribers && S.publish({ op: "delete", delete: t, key: e, cache: this });
+    let i2 = false;
+    if (this.#n !== 0) {
+      let s = this.#s.get(e);
+      if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g[s]), this.#g[s] = void 0), i2 = true, this.#n === 1) this.#q(t);
+      else {
+        this.#x(s);
+        let n = this.#t[s];
+        if (this.#e(n) ? n.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#S?.(n, e, t), this.#f && this.#r?.push([n, e, t])), this.#s.delete(e), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#u[s];
+        else if (s === this.#a) this.#a = this.#l[s];
+        else {
+          let o = this.#u[s];
+          this.#l[o] = this.#l[s];
+          let l = this.#l[s];
+          this.#u[l] = this.#u[s];
+        }
+        this.#n--, this.#y.push(s);
+      }
+    }
+    if (this.#f && this.#r?.length) {
+      let s = this.#r, n;
+      for (; n = s?.shift(); ) this.#w?.(...n);
+    }
+    return i2;
+  }
+  clear() {
+    return this.#q("delete");
+  }
+  #q(e) {
+    for (let t of this.#z({ allowStale: true })) {
+      let i2 = this.#t[t];
+      if (this.#e(i2)) i2.__abortController.abort(new Error("deleted"));
+      else {
+        let s = this.#i[t];
+        this.#T && this.#S?.(i2, s, e), this.#f && this.#r?.push([i2, s, e]);
+      }
+    }
+    if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#F) {
+      this.#d.fill(0), this.#F.fill(0);
+      for (let t of this.#g ?? []) t !== void 0 && clearTimeout(t);
+      this.#g?.fill(void 0);
+    }
+    if (this.#_ && this.#_.fill(0), this.#a = 0, this.#h = 0, this.#y.length = 0, this.#b = 0, this.#n = 0, this.#f && this.#r) {
+      let t = this.#r, i2;
+      for (; i2 = t?.shift(); ) this.#w?.(...i2);
+    }
+  }
+};
+
+// ../../src/promise-spawn/src/index.ts
+import { spawn } from "node:child_process";
+var isPipe = (stdio = "pipe", fd) => stdio === "pipe" || stdio === "overlapped" || stdio === null ? true : Array.isArray(stdio) ? isPipe(stdio[fd], fd) : false;
+function stdioResult(stdout, stderr, o) {
+  return {
+    stdout: !isPipe(o.stdio, 1) ? null : o.stdioString !== false ? Buffer.concat(stdout).toString().trim() : Buffer.concat(stdout),
+    stderr: !isPipe(o.stdio, 2) ? null : o.stdioString !== false ? Buffer.concat(stderr).toString().trim() : Buffer.concat(stderr)
+  };
+}
+var SpawnPromise = class extends Promise {
+  [Symbol.toStringTag] = "SpawnPromise";
+  /** The spawned process this promise references */
+  process;
+  /** Expose the child process stdin, if available */
+  stdin;
+  /**
+   * Set static `Symbol.species` back to the base Promise class so that
+   * v8 doesn't get confused by the changed constructor signature.
+   */
+  static get [Symbol.species]() {
+    return Promise;
+  }
+  constructor(command, args, opts, extra = {}) {
+    let proc;
+    super((res, rej) => {
+      proc = spawn(command, args, opts);
+      const stdout = [];
+      const stderr = [];
+      const reject = (er, status, signal) => {
+        const stdio = stdioResult(stdout, stderr, opts);
+        const errorResult = {
+          command,
+          args,
+          stdout: stdio.stdout,
+          stderr: stdio.stderr,
+          cwd: opts.cwd?.toString() ?? process.cwd()
+        };
+        if (er !== void 0) {
+          errorResult.cause = er;
+        }
+        if (status !== void 0) {
+          errorResult.status = status;
+        }
+        if (signal !== void 0) {
+          errorResult.signal = signal;
+        }
+        Object.assign(errorResult, extra);
+        rej(error("command failed", errorResult));
+      };
+      const resolve = (status, signal) => {
+        const stdio = stdioResult(stdout, stderr, opts);
+        const successResult = {
+          command,
+          args,
+          status,
+          signal,
+          stdout: stdio.stdout,
+          stderr: stdio.stderr,
+          cwd: opts.cwd?.toString() ?? process.cwd()
+        };
+        Object.assign(successResult, extra);
+        res(successResult);
+      };
+      proc.on("error", reject);
+      proc.stdout?.on("data", (c) => stdout.push(c)).on("error", reject);
+      proc.stderr?.on("data", (c) => stderr.push(c)).on("error", reject);
+      proc.on("close", (status, signal) => {
+        if ((status || signal) && !opts.acceptFail) {
+          reject(void 0, status, signal);
+        } else {
+          resolve(status, signal);
+        }
+      });
+    });
+    this.process = proc;
+    this.stdin = proc.stdin;
+  }
+};
+function promiseSpawn(command, args, opts = {}, extra = {}) {
+  return new SpawnPromise(command, args, opts, extra);
+}
+
+// ../../node_modules/.vlt/~npm~isexe@3.1.5/node_modules/isexe/dist/esm/index.min.js
+import { statSync as w } from "node:fs";
+import { stat as S2 } from "node:fs/promises";
+import { statSync as k2 } from "node:fs";
+import { stat as I2 } from "node:fs/promises";
+import { delimiter as _ } from "node:path";
+var y = Object.defineProperty;
+var u = (t, r) => {
+  for (var e in r) y(t, e, { get: r[e], enumerable: true });
+};
+var i = {};
+u(i, { isexe: () => C, sync: () => A });
+var C = async (t, r = {}) => {
+  let { ignoreErrors: e = false } = r;
+  try {
+    return d3(await S2(t), r);
+  } catch (s) {
+    let o = s;
+    if (e || o.code === "EACCES") return false;
+    throw o;
+  }
+};
+var A = (t, r = {}) => {
+  let { ignoreErrors: e = false } = r;
+  try {
+    return d3(w(t), r);
+  } catch (s) {
+    let o = s;
+    if (e || o.code === "EACCES") return false;
+    throw o;
+  }
+};
+var d3 = (t, r) => t.isFile() && T2(t, r);
+var T2 = (t, r) => {
+  let e = r.uid ?? process.getuid?.(), s = r.groups ?? process.getgroups?.() ?? [], o = r.gid ?? process.getgid?.() ?? s[0];
+  if (e === void 0 || o === void 0) throw new Error("cannot get uid or gid");
+  let c = /* @__PURE__ */ new Set([o, ...s]), n = t.mode, l = t.uid, E = t.gid, f = parseInt("100", 8), p = parseInt("010", 8), x2 = parseInt("001", 8), h = f | p;
+  return !!(n & x2 || n & p && c.has(E) || n & f && l === e || n & h && e === 0);
+};
+var a = {};
+u(a, { isexe: () => F, sync: () => L2 });
+var F = async (t, r = {}) => {
+  let { ignoreErrors: e = false } = r;
+  try {
+    return m(await I2(t), t, r);
+  } catch (s) {
+    let o = s;
+    if (e || o.code === "EACCES") return false;
+    throw o;
+  }
+};
+var L2 = (t, r = {}) => {
+  let { ignoreErrors: e = false } = r;
+  try {
+    return m(k2(t), t, r);
+  } catch (s) {
+    let o = s;
+    if (e || o.code === "EACCES") return false;
+    throw o;
+  }
+};
+var P2 = (t, r) => {
+  let { pathExt: e = process.env.PATHEXT || "" } = r, s = e.split(_);
+  if (s.indexOf("") !== -1) return true;
+  for (let o of s) {
+    let c = o.toLowerCase(), n = t.substring(t.length - c.length).toLowerCase();
+    if (c && n === c) return true;
+  }
+  return false;
+};
+var m = (t, r, e) => t.isFile() && P2(r, e);
+var v = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+var g = v === "win32" ? a : i;
+var R2 = g.isexe;
+var U2 = g.sync;
+
+// ../../src/which/src/index.ts
+import { delimiter, join, sep } from "node:path";
+var isWindows = process.platform === "win32";
+var rSlash = sep === "/" ? /\// : /[\\/]/;
+var rRel = new RegExp(`^\\.${rSlash.source}`);
+var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+var getPathInfo = (cmd, {
+  path: optPath = process.env.PATH,
+  pathExt: optPathExt = process.env.PATHEXT,
+  delimiter: optDelimiter = delimiter
+}) => {
+  const pathEnv = cmd.match(rSlash) ? [""] : [
+    // windows always checks the cwd first
+    /* c8 ignore next - platform-specific */
+    ...isWindows ? [process.cwd()] : [],
+    ...(optPath ?? /* c8 ignore next - very unusual */
+    "").split(
+      optDelimiter
+    )
+  ];
+  if (isWindows) {
+    const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+    const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
+    if (cmd.includes(".") && pathExt[0] !== "") {
+      pathExt.unshift("");
+    }
+    return { pathEnv, pathExt, pathExtExe };
+  }
+  return { pathEnv, pathExt: [""] };
+};
+var getPathPart = (raw, cmd) => {
+  const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+  const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+  return prefix + join(pathPart, cmd);
+};
+async function which(cmd, opt = {}) {
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+  for (const envPart of pathEnv) {
+    const p = getPathPart(envPart, cmd);
+    for (const ext of pathExt) {
+      const withExt = p + ext;
+      const is = await R2(withExt, {
+        pathExt: pathExtExe,
+        ignoreErrors: true
+      });
+      if (is) {
+        if (!opt.all) {
+          return withExt;
+        }
+        found.push(withExt);
+      }
+    }
+  }
+  if (opt.all && found.length) {
+    return found;
+  }
+  if (opt.nothrow) {
+    return null;
+  }
+  throw getNotFoundError(cmd);
+}
+function whichSync(cmd, opt = {}) {
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+  for (const pathEnvPart of pathEnv) {
+    const p = getPathPart(pathEnvPart, cmd);
+    for (const ext of pathExt) {
+      const withExt = p + ext;
+      const is = U2(withExt, {
+        pathExt: pathExtExe,
+        ignoreErrors: true
+      });
+      if (is) {
+        if (!opt.all) {
+          return withExt;
+        }
+        found.push(withExt);
+      }
+    }
+  }
+  if (opt.all && found.length) {
+    return found;
+  }
+  if (opt.nothrow) {
+    return null;
+  }
+  throw getNotFoundError(cmd);
+}
+
+export {
+  I,
+  promiseSpawn,
+  which,
+  whichSync
+};