wp-typia 0.22.7 → 0.22.8

package/dist-bunli/cli-mzvzbpnz.js

@@ -0,0 +1,3702 @@
+// @bun
+import {
+  BUILTIN_TEMPLATE_IDS,
+  OFFICIAL_WORKSPACE_TEMPLATE_ALIAS,
+  OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE,
+  TEMPLATE_IDS,
+  getRemovedBuiltInTemplateMessage,
+  getTemplateById,
+  isBuiltInTemplateId,
+  isRemovedBuiltInTemplateId
+} from "./cli-qse6myha.js";
+import {
+  CLI_DIAGNOSTIC_CODES,
+  createCliDiagnosticCodeError
+} from "./cli-p95wr1q8.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./cli-xnn9xjcy.js";
+
+// ../../node_modules/.bun/lru-cache@11.2.7/node_modules/lru-cache/dist/commonjs/index.min.js
+var require_index_min = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LRUCache = undefined;
+  var G = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+  var U = new Set;
+  var R = typeof process == "object" && process ? process : {};
+  var I = (c, t, e, i) => {
+    typeof R.emitWarning == "function" ? R.emitWarning(c, t, e, i) : console.error(`[${e}] ${t}: ${c}`);
+  };
+  var C = globalThis.AbortController;
+  var L = globalThis.AbortSignal;
+  if (typeof C > "u") {
+    L = class {
+      onabort;
+      _onabort = [];
+      reason;
+      aborted = false;
+      addEventListener(i, s) {
+        this._onabort.push(s);
+      }
+    }, C = class {
+      constructor() {
+        t();
+      }
+      signal = new L;
+      abort(i) {
+        if (!this.signal.aborted) {
+          this.signal.reason = i, this.signal.aborted = true;
+          for (let s of this.signal._onabort)
+            s(i);
+          this.signal.onabort?.(i);
+        }
+      }
+    };
+    let c = R.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+      c && (c = false, I("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
+    };
+  }
+  var x = (c) => !U.has(c);
+  var H = Symbol("type");
+  var y = (c) => c && c === Math.floor(c) && c > 0 && isFinite(c);
+  var M = (c) => y(c) ? c <= Math.pow(2, 8) ? Uint8Array : c <= Math.pow(2, 16) ? Uint16Array : c <= Math.pow(2, 32) ? Uint32Array : c <= Number.MAX_SAFE_INTEGER ? z : null : null;
+  var z = class extends Array {
+    constructor(t) {
+      super(t), this.fill(0);
+    }
+  };
+  var W = class c {
+    heap;
+    length;
+    static #o = false;
+    static create(t) {
+      let e = M(t);
+      if (!e)
+        return [];
+      c.#o = true;
+      let i = new c(t, e);
+      return c.#o = false, i;
+    }
+    constructor(t, e) {
+      if (!c.#o)
+        throw new TypeError("instantiate Stack using Stack.create(n)");
+      this.heap = new e(t), this.length = 0;
+    }
+    push(t) {
+      this.heap[this.length++] = t;
+    }
+    pop() {
+      return this.heap[--this.length];
+    }
+  };
+  var D = class c {
+    #o;
+    #c;
+    #w;
+    #C;
+    #S;
+    #L;
+    #U;
+    #m;
+    get perf() {
+      return this.#m;
+    }
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #n;
+    #_;
+    #s;
+    #i;
+    #t;
+    #a;
+    #u;
+    #l;
+    #h;
+    #b;
+    #r;
+    #y;
+    #A;
+    #d;
+    #g;
+    #T;
+    #v;
+    #f;
+    #I;
+    static unsafeExposeInternals(t) {
+      return { starts: t.#A, ttls: t.#d, autopurgeTimers: t.#g, sizes: t.#y, keyMap: t.#s, keyList: t.#i, valList: t.#t, next: t.#a, prev: t.#u, get head() {
+        return t.#l;
+      }, get tail() {
+        return t.#h;
+      }, free: t.#b, isBackgroundFetch: (e) => t.#e(e), backgroundFetch: (e, i, s, n) => t.#x(e, i, s, n), moveToTail: (e) => t.#D(e), indexes: (e) => t.#F(e), rindexes: (e) => t.#O(e), isStale: (e) => t.#p(e) };
+    }
+    get max() {
+      return this.#o;
+    }
+    get maxSize() {
+      return this.#c;
+    }
+    get calculatedSize() {
+      return this.#_;
+    }
+    get size() {
+      return this.#n;
+    }
+    get fetchMethod() {
+      return this.#L;
+    }
+    get memoMethod() {
+      return this.#U;
+    }
+    get dispose() {
+      return this.#w;
+    }
+    get onInsert() {
+      return this.#C;
+    }
+    get disposeAfter() {
+      return this.#S;
+    }
+    constructor(t) {
+      let { max: e = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: h, allowStale: r, dispose: a, onInsert: w, disposeAfter: f, noDisposeOnSet: d, noUpdateTTL: g, maxSize: A = 0, maxEntrySize: p = 0, sizeCalculation: _, fetchMethod: l, memoMethod: S, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: m, allowStaleOnFetchRejection: u, allowStaleOnFetchAbort: T, ignoreFetchAbort: F, perf: v } = t;
+      if (v !== undefined && typeof v?.now != "function")
+        throw new TypeError("perf option must have a now() method if specified");
+      if (this.#m = v ?? G, e !== 0 && !y(e))
+        throw new TypeError("max option must be a nonnegative integer");
+      let O = e ? M(e) : Array;
+      if (!O)
+        throw new Error("invalid max value: " + e);
+      if (this.#o = e, this.#c = A, this.maxEntrySize = p || this.#c, this.sizeCalculation = _, this.sizeCalculation) {
+        if (!this.#c && !this.maxEntrySize)
+          throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+        if (typeof this.sizeCalculation != "function")
+          throw new TypeError("sizeCalculation set to non-function");
+      }
+      if (S !== undefined && typeof S != "function")
+        throw new TypeError("memoMethod must be a function if defined");
+      if (this.#U = S, l !== undefined && typeof l != "function")
+        throw new TypeError("fetchMethod must be a function if specified");
+      if (this.#L = l, this.#v = !!l, this.#s = new Map, this.#i = new Array(e).fill(undefined), this.#t = new Array(e).fill(undefined), this.#a = new O(e), this.#u = new O(e), this.#l = 0, this.#h = 0, this.#b = W.create(e), this.#n = 0, this.#_ = 0, typeof a == "function" && (this.#w = a), typeof w == "function" && (this.#C = w), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = undefined, this.#r = undefined), this.#T = !!this.#w, this.#I = !!this.#C, this.#f = !!this.#S, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!g, this.noDeleteOnFetchRejection = !!b, this.allowStaleOnFetchRejection = !!u, this.allowStaleOnFetchAbort = !!T, this.ignoreFetchAbort = !!F, this.maxEntrySize !== 0) {
+        if (this.#c !== 0 && !y(this.#c))
+          throw new TypeError("maxSize must be a positive integer if specified");
+        if (!y(this.maxEntrySize))
+          throw new TypeError("maxEntrySize must be a positive integer if specified");
+        this.#B();
+      }
+      if (this.allowStale = !!r, this.noDeleteOnStaleGet = !!m, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!h, this.ttlResolution = y(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
+        if (!y(this.ttl))
+          throw new TypeError("ttl must be a positive integer if specified");
+        this.#j();
+      }
+      if (this.#o === 0 && this.ttl === 0 && this.#c === 0)
+        throw new TypeError("At least one of max, maxSize, or ttl is required");
+      if (!this.ttlAutopurge && !this.#o && !this.#c) {
+        let E = "LRU_CACHE_UNBOUNDED";
+        x(E) && (U.add(E), I("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, c));
+      }
+    }
+    getRemainingTTL(t) {
+      return this.#s.has(t) ? 1 / 0 : 0;
+    }
+    #j() {
+      let t = new z(this.#o), e = new z(this.#o);
+      this.#d = t, this.#A = e;
+      let i = this.ttlAutopurge ? new Array(this.#o) : undefined;
+      this.#g = i, this.#N = (h, r, a = this.#m.now()) => {
+        e[h] = r !== 0 ? a : 0, t[h] = r, s(h, r);
+      }, this.#R = (h) => {
+        e[h] = t[h] !== 0 ? this.#m.now() : 0, s(h, t[h]);
+      };
+      let s = this.ttlAutopurge ? (h, r) => {
+        if (i?.[h] && (clearTimeout(i[h]), i[h] = undefined), r && r !== 0 && i) {
+          let a = setTimeout(() => {
+            this.#p(h) && this.#E(this.#i[h], "expire");
+          }, r + 1);
+          a.unref && a.unref(), i[h] = a;
+        }
+      } : () => {};
+      this.#z = (h, r) => {
+        if (t[r]) {
+          let a = t[r], w = e[r];
+          if (!a || !w)
+            return;
+          h.ttl = a, h.start = w, h.now = n || o();
+          let f = h.now - w;
+          h.remainingTTL = a - f;
+        }
+      };
+      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);
+        if (r === undefined)
+          return 0;
+        let a = t[r], w = e[r];
+        if (!a || !w)
+          return 1 / 0;
+        let f = (n || o()) - w;
+        return a - f;
+      }, this.#p = (h) => {
+        let r = e[h], a = t[h];
+        return !!a && !!r && (n || o()) - r > a;
+      };
+    }
+    #R = () => {};
+    #z = () => {};
+    #N = () => {};
+    #p = () => false;
+    #B() {
+      let t = new z(this.#o);
+      this.#_ = 0, this.#y = t, this.#W = (e) => {
+        this.#_ -= t[e], t[e] = 0;
+      }, this.#P = (e, i, s, n) => {
+        if (this.#e(i))
+          return 0;
+        if (!y(s))
+          if (n) {
+            if (typeof n != "function")
+              throw new TypeError("sizeCalculation must be a function");
+            if (s = n(i, e), !y(s))
+              throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+          } else
+            throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+        return s;
+      }, this.#M = (e, i, s) => {
+        if (t[e] = i, this.#c) {
+          let n = this.#c - t[e];
+          for (;this.#_ > n; )
+            this.#G(true);
+        }
+        this.#_ += t[e], s && (s.entrySize = i, s.totalCalculatedSize = this.#_);
+      };
+    }
+    #W = (t) => {};
+    #M = (t, e, i) => {};
+    #P = (t, e, i, s) => {
+      if (i || s)
+        throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+      return 0;
+    };
+    *#F({ allowStale: t = this.allowStale } = {}) {
+      if (this.#n)
+        for (let e = this.#h;!(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#l)); )
+          e = this.#u[e];
+    }
+    *#O({ allowStale: t = this.allowStale } = {}) {
+      if (this.#n)
+        for (let e = this.#l;!(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#h)); )
+          e = this.#a[e];
+    }
+    #H(t) {
+      return t !== undefined && this.#s.get(this.#i[t]) === t;
+    }
+    *entries() {
+      for (let t of this.#F())
+        this.#t[t] !== undefined && this.#i[t] !== undefined && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
+    }
+    *rentries() {
+      for (let t of this.#O())
+        this.#t[t] !== undefined && this.#i[t] !== undefined && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
+    }
+    *keys() {
+      for (let t of this.#F()) {
+        let e = this.#i[t];
+        e !== undefined && !this.#e(this.#t[t]) && (yield e);
+      }
+    }
+    *rkeys() {
+      for (let t of this.#O()) {
+        let e = this.#i[t];
+        e !== undefined && !this.#e(this.#t[t]) && (yield e);
+      }
+    }
+    *values() {
+      for (let t of this.#F())
+        this.#t[t] !== undefined && !this.#e(this.#t[t]) && (yield this.#t[t]);
+    }
+    *rvalues() {
+      for (let t of this.#O())
+        this.#t[t] !== undefined && !this.#e(this.#t[t]) && (yield this.#t[t]);
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+    [Symbol.toStringTag] = "LRUCache";
+    find(t, e = {}) {
+      for (let i of this.#F()) {
+        let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+        if (n !== undefined && t(n, this.#i[i], this))
+          return this.get(this.#i[i], e);
+      }
+    }
+    forEach(t, e = this) {
+      for (let i of this.#F()) {
+        let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+        n !== undefined && t.call(e, n, this.#i[i], this);
+      }
+    }
+    rforEach(t, e = this) {
+      for (let i of this.#O()) {
+        let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+        n !== undefined && t.call(e, n, this.#i[i], this);
+      }
+    }
+    purgeStale() {
+      let t = false;
+      for (let e of this.#O({ allowStale: true }))
+        this.#p(e) && (this.#E(this.#i[e], "expire"), t = true);
+      return t;
+    }
+    info(t) {
+      let e = this.#s.get(t);
+      if (e === undefined)
+        return;
+      let i = this.#t[e], s = this.#e(i) ? i.__staleWhileFetching : i;
+      if (s === undefined)
+        return;
+      let n = { value: s };
+      if (this.#d && this.#A) {
+        let o = this.#d[e], h = this.#A[e];
+        if (o && h) {
+          let r = o - (this.#m.now() - h);
+          n.ttl = r, n.start = Date.now();
+        }
+      }
+      return this.#y && (n.size = this.#y[e]), n;
+    }
+    dump() {
+      let t = [];
+      for (let e of this.#F({ allowStale: true })) {
+        let i = this.#i[e], s = this.#t[e], n = this.#e(s) ? s.__staleWhileFetching : s;
+        if (n === undefined || i === undefined)
+          continue;
+        let o = { value: n };
+        if (this.#d && this.#A) {
+          o.ttl = this.#d[e];
+          let h = this.#m.now() - this.#A[e];
+          o.start = Math.floor(Date.now() - h);
+        }
+        this.#y && (o.size = this.#y[e]), t.unshift([i, o]);
+      }
+      return t;
+    }
+    load(t) {
+      this.clear();
+      for (let [e, i] of t) {
+        if (i.start) {
+          let s = Date.now() - i.start;
+          i.start = this.#m.now() - s;
+        }
+        this.set(e, i.value, i);
+      }
+    }
+    set(t, e, i = {}) {
+      if (e === undefined)
+        return this.delete(t), this;
+      let { ttl: s = this.ttl, start: n, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: r } = i, { noUpdateTTL: a = this.noUpdateTTL } = i, w = this.#P(t, e, i.size || 0, h);
+      if (this.maxEntrySize && w > this.maxEntrySize)
+        return r && (r.set = "miss", r.maxEntrySizeExceeded = true), this.#E(t, "set"), this;
+      let f = this.#n === 0 ? undefined : this.#s.get(t);
+      if (f === undefined)
+        f = this.#n === 0 ? this.#h : this.#b.length !== 0 ? this.#b.pop() : this.#n === this.#o ? this.#G(false) : this.#n, this.#i[f] = t, this.#t[f] = e, this.#s.set(t, f), this.#a[this.#h] = f, this.#u[f] = this.#h, this.#h = f, this.#n++, this.#M(f, w, r), r && (r.set = "add"), a = false, this.#I && this.#C?.(e, t, "add");
+      else {
+        this.#D(f);
+        let d = this.#t[f];
+        if (e !== d) {
+          if (this.#v && this.#e(d)) {
+            d.__abortController.abort(new Error("replaced"));
+            let { __staleWhileFetching: g } = d;
+            g !== undefined && !o && (this.#T && this.#w?.(g, t, "set"), this.#f && this.#r?.push([g, t, "set"]));
+          } else
+            o || (this.#T && this.#w?.(d, t, "set"), this.#f && this.#r?.push([d, t, "set"]));
+          if (this.#W(f), this.#M(f, w, r), this.#t[f] = e, r) {
+            r.set = "replace";
+            let g = d && this.#e(d) ? d.__staleWhileFetching : d;
+            g !== undefined && (r.oldValue = g);
+          }
+        } else
+          r && (r.set = "update");
+        this.#I && this.onInsert?.(e, t, e === d ? "update" : "replace");
+      }
+      if (s !== 0 && !this.#d && this.#j(), this.#d && (a || this.#N(f, s, n), r && this.#z(r, f)), !o && this.#f && this.#r) {
+        let d = this.#r, g;
+        for (;g = d?.shift(); )
+          this.#S?.(...g);
+      }
+      return this;
+    }
+    pop() {
+      try {
+        for (;this.#n; ) {
+          let t = this.#t[this.#l];
+          if (this.#G(true), this.#e(t)) {
+            if (t.__staleWhileFetching)
+              return t.__staleWhileFetching;
+          } else if (t !== undefined)
+            return t;
+        }
+      } finally {
+        if (this.#f && this.#r) {
+          let t = this.#r, e;
+          for (;e = t?.shift(); )
+            this.#S?.(...e);
+        }
+      }
+    }
+    #G(t) {
+      let e = this.#l, i = this.#i[e], s = this.#t[e];
+      return this.#v && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#w?.(s, i, "evict"), this.#f && this.#r?.push([s, i, "evict"])), this.#W(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = undefined), t && (this.#i[e] = undefined, this.#t[e] = undefined, this.#b.push(e)), this.#n === 1 ? (this.#l = this.#h = 0, this.#b.length = 0) : this.#l = this.#a[e], this.#s.delete(i), this.#n--, e;
+    }
+    has(t, e = {}) {
+      let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = e, n = this.#s.get(t);
+      if (n !== undefined) {
+        let o = this.#t[n];
+        if (this.#e(o) && o.__staleWhileFetching === undefined)
+          return false;
+        if (this.#p(n))
+          s && (s.has = "stale", this.#z(s, n));
+        else
+          return i && this.#R(n), s && (s.has = "hit", this.#z(s, n)), true;
+      } else
+        s && (s.has = "miss");
+      return false;
+    }
+    peek(t, e = {}) {
+      let { allowStale: i = this.allowStale } = e, s = this.#s.get(t);
+      if (s === undefined || !i && this.#p(s))
+        return;
+      let n = this.#t[s];
+      return this.#e(n) ? n.__staleWhileFetching : n;
+    }
+    #x(t, e, i, s) {
+      let n = e === undefined ? undefined : this.#t[e];
+      if (this.#e(n))
+        return n;
+      let o = new C, { signal: h } = i;
+      h?.addEventListener("abort", () => o.abort(h.reason), { signal: o.signal });
+      let r = { signal: o.signal, options: i, context: s }, a = (p, _ = false) => {
+        let { aborted: l } = o.signal, S = i.ignoreFetchAbort && p !== undefined, b = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && p !== undefined);
+        if (i.status && (l && !_ ? (i.status.fetchAborted = true, i.status.fetchError = o.signal.reason, S && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), l && !S && !_)
+          return f(o.signal.reason, b);
+        let m = g, u = this.#t[e];
+        return (u === g || S && _ && u === undefined) && (p === undefined ? m.__staleWhileFetching !== undefined ? this.#t[e] = m.__staleWhileFetching : this.#E(t, "fetch") : (i.status && (i.status.fetchUpdated = true), this.set(t, p, r.options))), p;
+      }, w = (p) => (i.status && (i.status.fetchRejected = true, i.status.fetchError = p), f(p, false)), f = (p, _) => {
+        let { aborted: l } = o.signal, S = l && i.allowStaleOnFetchAbort, b = S || i.allowStaleOnFetchRejection, m = b || i.noDeleteOnFetchRejection, u = g;
+        if (this.#t[e] === g && (!m || !_ && u.__staleWhileFetching === undefined ? this.#E(t, "fetch") : S || (this.#t[e] = u.__staleWhileFetching)), b)
+          return i.status && u.__staleWhileFetching !== undefined && (i.status.returnedStale = true), u.__staleWhileFetching;
+        if (u.__returned === u)
+          throw p;
+      }, d = (p, _) => {
+        let l = this.#L?.(t, n, r);
+        l && l instanceof Promise && l.then((S) => p(S === undefined ? undefined : S), _), o.signal.addEventListener("abort", () => {
+          (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (p(undefined), i.allowStaleOnFetchAbort && (p = (S) => a(S, true)));
+        });
+      };
+      i.status && (i.status.fetchDispatched = true);
+      let g = new Promise(d).then(a, w), A = Object.assign(g, { __abortController: o, __staleWhileFetching: n, __returned: undefined });
+      return e === undefined ? (this.set(t, A, { ...r.options, status: undefined }), e = this.#s.get(t)) : this.#t[e] = A, A;
+    }
+    #e(t) {
+      if (!this.#v)
+        return false;
+      let e = t;
+      return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof C;
+    }
+    async fetch(t, e = {}) {
+      let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: r = 0, sizeCalculation: a = this.sizeCalculation, noUpdateTTL: w = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: g = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: p, forceRefresh: _ = false, status: l, signal: S } = e;
+      if (!this.#v)
+        return l && (l.fetch = "get"), this.get(t, { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: n, status: l });
+      let b = { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: n, ttl: o, noDisposeOnSet: h, size: r, sizeCalculation: a, noUpdateTTL: w, noDeleteOnFetchRejection: f, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: g, status: l, signal: S }, m = this.#s.get(t);
+      if (m === undefined) {
+        l && (l.fetch = "miss");
+        let u = this.#x(t, m, b, p);
+        return u.__returned = u;
+      } else {
+        let u = this.#t[m];
+        if (this.#e(u)) {
+          let E = i && u.__staleWhileFetching !== undefined;
+          return l && (l.fetch = "inflight", E && (l.returnedStale = true)), E ? u.__staleWhileFetching : u.__returned = u;
+        }
+        let T = this.#p(m);
+        if (!_ && !T)
+          return l && (l.fetch = "hit"), this.#D(m), s && this.#R(m), l && this.#z(l, m), u;
+        let F = this.#x(t, m, b, p), O = F.__staleWhileFetching !== undefined && i;
+        return l && (l.fetch = T ? "stale" : "refresh", O && T && (l.returnedStale = true)), O ? F.__staleWhileFetching : F.__returned = F;
+      }
+    }
+    async forceFetch(t, e = {}) {
+      let i = await this.fetch(t, e);
+      if (i === undefined)
+        throw new Error("fetch() returned undefined");
+      return i;
+    }
+    memo(t, e = {}) {
+      let i = this.#U;
+      if (!i)
+        throw new Error("no memoMethod provided to constructor");
+      let { context: s, forceRefresh: n, ...o } = e, h = this.get(t, o);
+      if (!n && h !== undefined)
+        return h;
+      let r = i(t, h, { options: o, context: s });
+      return this.set(t, r, o), r;
+    }
+    get(t, e = {}) {
+      let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = e, h = this.#s.get(t);
+      if (h !== undefined) {
+        let r = this.#t[h], a = this.#e(r);
+        return o && this.#z(o, h), this.#p(h) ? (o && (o.get = "stale"), a ? (o && i && r.__staleWhileFetching !== undefined && (o.returnedStale = true), i ? r.__staleWhileFetching : undefined) : (n || this.#E(t, "expire"), o && i && (o.returnedStale = true), i ? r : undefined)) : (o && (o.get = "hit"), a ? r.__staleWhileFetching : (this.#D(h), s && this.#R(h), r));
+      } else
+        o && (o.get = "miss");
+    }
+    #k(t, e) {
+      this.#u[e] = t, this.#a[t] = e;
+    }
+    #D(t) {
+      t !== this.#h && (t === this.#l ? this.#l = this.#a[t] : this.#k(this.#u[t], this.#a[t]), this.#k(this.#h, t), this.#h = t);
+    }
+    delete(t) {
+      return this.#E(t, "delete");
+    }
+    #E(t, e) {
+      let i = false;
+      if (this.#n !== 0) {
+        let s = this.#s.get(t);
+        if (s !== undefined)
+          if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = undefined), i = true, this.#n === 1)
+            this.#V(e);
+          else {
+            this.#W(s);
+            let n = this.#t[s];
+            if (this.#e(n) ? n.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(n, t, e), this.#f && this.#r?.push([n, t, e])), this.#s.delete(t), this.#i[s] = undefined, this.#t[s] = undefined, s === this.#h)
+              this.#h = this.#u[s];
+            else if (s === this.#l)
+              this.#l = this.#a[s];
+            else {
+              let o = this.#u[s];
+              this.#a[o] = this.#a[s];
+              let h = this.#a[s];
+              this.#u[h] = this.#u[s];
+            }
+            this.#n--, this.#b.push(s);
+          }
+      }
+      if (this.#f && this.#r?.length) {
+        let s = this.#r, n;
+        for (;n = s?.shift(); )
+          this.#S?.(...n);
+      }
+      return i;
+    }
+    clear() {
+      return this.#V("delete");
+    }
+    #V(t) {
+      for (let e of this.#O({ allowStale: true })) {
+        let i = this.#t[e];
+        if (this.#e(i))
+          i.__abortController.abort(new Error("deleted"));
+        else {
+          let s = this.#i[e];
+          this.#T && this.#w?.(i, s, t), this.#f && this.#r?.push([i, s, t]);
+        }
+      }
+      if (this.#s.clear(), this.#t.fill(undefined), this.#i.fill(undefined), this.#d && this.#A) {
+        this.#d.fill(0), this.#A.fill(0);
+        for (let e of this.#g ?? [])
+          e !== undefined && clearTimeout(e);
+        this.#g?.fill(undefined);
+      }
+      if (this.#y && this.#y.fill(0), this.#l = 0, this.#h = 0, this.#b.length = 0, this.#_ = 0, this.#n = 0, this.#f && this.#r) {
+        let e = this.#r, i;
+        for (;i = e?.shift(); )
+          this.#S?.(...i);
+      }
+    }
+  };
+  exports.LRUCache = D;
+});
+
+// ../../node_modules/.bun/hosted-git-info@9.0.2/node_modules/hosted-git-info/lib/hosts.js
+var require_hosts = __commonJS((exports, module) => {
+  var maybeJoin = (...args) => args.every((arg) => arg) ? args.join("") : "";
+  var maybeEncode = (arg) => arg ? encodeURIComponent(arg) : "";
+  var formatHashFragment = (f) => f.toLowerCase().replace(/^\W+/g, "").replace(/(?<!\W)\W+$/, "").replace(/\//g, "").replace(/\W+/g, "-");
+  var defaults = {
+    sshtemplate: ({ domain, user, project, committish }) => `git@${domain}:${user}/${project}.git${maybeJoin("#", committish)}`,
+    sshurltemplate: ({ domain, user, project, committish }) => `git+ssh://git@${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
+    edittemplate: ({ domain, user, project, committish, editpath, path }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path)}`,
+    browsetemplate: ({ domain, user, project, committish, treepath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}`,
+    browsetreetemplate: ({ domain, user, project, committish, treepath, path, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path}${maybeJoin("#", hashformat(fragment || ""))}`,
+    browseblobtemplate: ({ domain, user, project, committish, blobpath, path, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path}${maybeJoin("#", hashformat(fragment || ""))}`,
+    docstemplate: ({ domain, user, project, treepath, committish }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}#readme`,
+    httpstemplate: ({ auth, domain, user, project, committish }) => `git+https://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
+    filetemplate: ({ domain, user, project, committish, path }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path}`,
+    shortcuttemplate: ({ type, user, project, committish }) => `${type}:${user}/${project}${maybeJoin("#", committish)}`,
+    pathtemplate: ({ user, project, committish }) => `${user}/${project}${maybeJoin("#", committish)}`,
+    bugstemplate: ({ domain, user, project }) => `https://${domain}/${user}/${project}/issues`,
+    hashformat: formatHashFragment
+  };
+  var hosts = {};
+  hosts.github = {
+    protocols: ["git:", "http:", "git+ssh:", "git+https:", "ssh:", "https:"],
+    domain: "github.com",
+    treepath: "tree",
+    blobpath: "blob",
+    editpath: "edit",
+    filetemplate: ({ auth, user, project, committish, path }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path}`,
+    gittemplate: ({ auth, domain, user, project, committish }) => `git://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
+    tarballtemplate: ({ domain, user, project, committish }) => `https://codeload.${domain}/${user}/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`,
+    extract: (url) => {
+      let [, user, project, type, committish] = url.pathname.split("/", 5);
+      if (type && type !== "tree") {
+        return;
+      }
+      if (!type) {
+        committish = url.hash.slice(1);
+      }
+      if (project && project.endsWith(".git")) {
+        project = project.slice(0, -4);
+      }
+      if (!user || !project) {
+        return;
+      }
+      return { user, project, committish };
+    }
+  };
+  hosts.bitbucket = {
+    protocols: ["git+ssh:", "git+https:", "ssh:", "https:"],
+    domain: "bitbucket.org",
+    treepath: "src",
+    blobpath: "src",
+    editpath: "?mode=edit",
+    edittemplate: ({ domain, user, project, committish, treepath, path, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path, editpath)}`,
+    tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/get/${maybeEncode(committish || "HEAD")}.tar.gz`,
+    extract: (url) => {
+      let [, user, project, aux] = url.pathname.split("/", 4);
+      if (["get"].includes(aux)) {
+        return;
+      }
+      if (project && project.endsWith(".git")) {
+        project = project.slice(0, -4);
+      }
+      if (!user || !project) {
+        return;
+      }
+      return { user, project, committish: url.hash.slice(1) };
+    }
+  };
+  hosts.gitlab = {
+    protocols: ["git+ssh:", "git+https:", "ssh:", "https:"],
+    domain: "gitlab.com",
+    treepath: "tree",
+    blobpath: "tree",
+    editpath: "-/edit",
+    tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/repository/archive.tar.gz?ref=${maybeEncode(committish || "HEAD")}`,
+    extract: (url) => {
+      const path = url.pathname.slice(1);
+      if (path.includes("/-/") || path.includes("/archive.tar.gz")) {
+        return;
+      }
+      const segments = path.split("/");
+      let project = segments.pop();
+      if (project.endsWith(".git")) {
+        project = project.slice(0, -4);
+      }
+      const user = segments.join("/");
+      if (!user || !project) {
+        return;
+      }
+      return { user, project, committish: url.hash.slice(1) };
+    }
+  };
+  hosts.gist = {
+    protocols: ["git:", "git+ssh:", "git+https:", "ssh:", "https:"],
+    domain: "gist.github.com",
+    editpath: "edit",
+    sshtemplate: ({ domain, project, committish }) => `git@${domain}:${project}.git${maybeJoin("#", committish)}`,
+    sshurltemplate: ({ domain, project, committish }) => `git+ssh://git@${domain}/${project}.git${maybeJoin("#", committish)}`,
+    edittemplate: ({ domain, user, project, committish, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", maybeEncode(committish))}/${editpath}`,
+    browsetemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
+    browsetreetemplate: ({ domain, project, committish, path, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path))}`,
+    browseblobtemplate: ({ domain, project, committish, path, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path))}`,
+    docstemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
+    httpstemplate: ({ domain, project, committish }) => `git+https://${domain}/${project}.git${maybeJoin("#", committish)}`,
+    filetemplate: ({ user, project, committish, path }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path}`,
+    shortcuttemplate: ({ type, project, committish }) => `${type}:${project}${maybeJoin("#", committish)}`,
+    pathtemplate: ({ project, committish }) => `${project}${maybeJoin("#", committish)}`,
+    bugstemplate: ({ domain, project }) => `https://${domain}/${project}`,
+    gittemplate: ({ domain, project, committish }) => `git://${domain}/${project}.git${maybeJoin("#", committish)}`,
+    tarballtemplate: ({ project, committish }) => `https://codeload.github.com/gist/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`,
+    extract: (url) => {
+      let [, user, project, aux] = url.pathname.split("/", 4);
+      if (aux === "raw") {
+        return;
+      }
+      if (!project) {
+        if (!user) {
+          return;
+        }
+        project = user;
+        user = null;
+      }
+      if (project.endsWith(".git")) {
+        project = project.slice(0, -4);
+      }
+      return { user, project, committish: url.hash.slice(1) };
+    },
+    hashformat: function(fragment) {
+      return fragment && "file-" + formatHashFragment(fragment);
+    }
+  };
+  hosts.sourcehut = {
+    protocols: ["git+ssh:", "https:"],
+    domain: "git.sr.ht",
+    treepath: "tree",
+    blobpath: "tree",
+    filetemplate: ({ domain, user, project, committish, path }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path}`,
+    httpstemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
+    tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || "HEAD"}.tar.gz`,
+    bugstemplate: () => null,
+    extract: (url) => {
+      let [, user, project, aux] = url.pathname.split("/", 4);
+      if (["archive"].includes(aux)) {
+        return;
+      }
+      if (project && project.endsWith(".git")) {
+        project = project.slice(0, -4);
+      }
+      if (!user || !project) {
+        return;
+      }
+      return { user, project, committish: url.hash.slice(1) };
+    }
+  };
+  for (const [name, host] of Object.entries(hosts)) {
+    hosts[name] = Object.assign({}, defaults, host);
+  }
+  module.exports = hosts;
+});
+
+// ../../node_modules/.bun/hosted-git-info@9.0.2/node_modules/hosted-git-info/lib/parse-url.js
+var require_parse_url = __commonJS((exports, module) => {
+  var url = __require("url");
+  var lastIndexOfBefore = (str, char, beforeChar) => {
+    const startPosition = str.indexOf(beforeChar);
+    return str.lastIndexOf(char, startPosition > -1 ? startPosition : Infinity);
+  };
+  var safeUrl = (u) => {
+    try {
+      return new url.URL(u);
+    } catch {}
+  };
+  var correctProtocol = (arg, protocols) => {
+    const firstColon = arg.indexOf(":");
+    const proto = arg.slice(0, firstColon + 1);
+    if (Object.prototype.hasOwnProperty.call(protocols, proto)) {
+      return arg;
+    }
+    if (arg.substr(firstColon, 3) === "://") {
+      return arg;
+    }
+    const firstAt = arg.indexOf("@");
+    if (firstAt > -1) {
+      if (firstAt > firstColon) {
+        return `git+ssh://${arg}`;
+      } else {
+        return arg;
+      }
+    }
+    return `${arg.slice(0, firstColon + 1)}//${arg.slice(firstColon + 1)}`;
+  };
+  var correctUrl = (giturl) => {
+    const firstAt = lastIndexOfBefore(giturl, "@", "#");
+    const lastColonBeforeHash = lastIndexOfBefore(giturl, ":", "#");
+    if (lastColonBeforeHash > firstAt) {
+      giturl = giturl.slice(0, lastColonBeforeHash) + "/" + giturl.slice(lastColonBeforeHash + 1);
+    }
+    if (lastIndexOfBefore(giturl, ":", "#") === -1 && giturl.indexOf("//") === -1) {
+      giturl = `git+ssh://${giturl}`;
+    }
+    return giturl;
+  };
+  module.exports = (giturl, protocols) => {
+    const withProtocol = protocols ? correctProtocol(giturl, protocols) : giturl;
+    return safeUrl(withProtocol) || safeUrl(correctUrl(withProtocol));
+  };
+});
+
+// ../../node_modules/.bun/hosted-git-info@9.0.2/node_modules/hosted-git-info/lib/from-url.js
+var require_from_url = __commonJS((exports, module) => {
+  var parseUrl = require_parse_url();
+  var isGitHubShorthand = (arg) => {
+    const firstHash = arg.indexOf("#");
+    const firstSlash = arg.indexOf("/");
+    const secondSlash = arg.indexOf("/", firstSlash + 1);
+    const firstColon = arg.indexOf(":");
+    const firstSpace = /\s/.exec(arg);
+    const firstAt = arg.indexOf("@");
+    const spaceOnlyAfterHash = !firstSpace || firstHash > -1 && firstSpace.index > firstHash;
+    const atOnlyAfterHash = firstAt === -1 || firstHash > -1 && firstAt > firstHash;
+    const colonOnlyAfterHash = firstColon === -1 || firstHash > -1 && firstColon > firstHash;
+    const secondSlashOnlyAfterHash = secondSlash === -1 || firstHash > -1 && secondSlash > firstHash;
+    const hasSlash = firstSlash > 0;
+    const doesNotEndWithSlash = firstHash > -1 ? arg[firstHash - 1] !== "/" : !arg.endsWith("/");
+    const doesNotStartWithDot = !arg.startsWith(".");
+    return spaceOnlyAfterHash && hasSlash && doesNotEndWithSlash && doesNotStartWithDot && atOnlyAfterHash && colonOnlyAfterHash && secondSlashOnlyAfterHash;
+  };
+  module.exports = (giturl, opts, { gitHosts, protocols }) => {
+    if (!giturl) {
+      return;
+    }
+    const correctedUrl = isGitHubShorthand(giturl) ? `github:${giturl}` : giturl;
+    const parsed = parseUrl(correctedUrl, protocols);
+    if (!parsed) {
+      return;
+    }
+    const gitHostShortcut = gitHosts.byShortcut[parsed.protocol];
+    const gitHostDomain = gitHosts.byDomain[parsed.hostname.startsWith("www.") ? parsed.hostname.slice(4) : parsed.hostname];
+    const gitHostName = gitHostShortcut || gitHostDomain;
+    if (!gitHostName) {
+      return;
+    }
+    const gitHostInfo = gitHosts[gitHostShortcut || gitHostDomain];
+    let auth = null;
+    if (protocols[parsed.protocol]?.auth && (parsed.username || parsed.password)) {
+      auth = `${parsed.username}${parsed.password ? ":" + parsed.password : ""}`;
+    }
+    let committish = null;
+    let user = null;
+    let project = null;
+    let defaultRepresentation = null;
+    try {
+      if (gitHostShortcut) {
+        let pathname = parsed.pathname.startsWith("/") ? parsed.pathname.slice(1) : parsed.pathname;
+        const firstAt = pathname.indexOf("@");
+        if (firstAt > -1) {
+          pathname = pathname.slice(firstAt + 1);
+        }
+        const lastSlash = pathname.lastIndexOf("/");
+        if (lastSlash > -1) {
+          user = decodeURIComponent(pathname.slice(0, lastSlash));
+          if (!user) {
+            user = null;
+          }
+          project = decodeURIComponent(pathname.slice(lastSlash + 1));
+        } else {
+          project = decodeURIComponent(pathname);
+        }
+        if (project.endsWith(".git")) {
+          project = project.slice(0, -4);
+        }
+        if (parsed.hash) {
+          committish = decodeURIComponent(parsed.hash.slice(1));
+        }
+        defaultRepresentation = "shortcut";
+      } else {
+        if (!gitHostInfo.protocols.includes(parsed.protocol)) {
+          return;
+        }
+        const segments = gitHostInfo.extract(parsed);
+        if (!segments) {
+          return;
+        }
+        user = segments.user && decodeURIComponent(segments.user);
+        project = decodeURIComponent(segments.project);
+        committish = decodeURIComponent(segments.committish);
+        defaultRepresentation = protocols[parsed.protocol]?.name || parsed.protocol.slice(0, -1);
+      }
+    } catch (err) {
+      if (err instanceof URIError) {
+        return;
+      } else {
+        throw err;
+      }
+    }
+    return [gitHostName, user, auth, project, committish, defaultRepresentation, opts];
+  };
+});
+
+// ../../node_modules/.bun/hosted-git-info@9.0.2/node_modules/hosted-git-info/lib/index.js
+var require_lib = __commonJS((exports, module) => {
+  var { LRUCache } = require_index_min();
+  var hosts = require_hosts();
+  var fromUrl = require_from_url();
+  var parseUrl = require_parse_url();
+  var cache = new LRUCache({ max: 1000 });
+  function unknownHostedUrl(url) {
+    try {
+      const {
+        protocol,
+        hostname,
+        pathname
+      } = new URL(url);
+      if (!hostname) {
+        return null;
+      }
+      const proto = /(?:git\+)http:$/.test(protocol) ? "http:" : "https:";
+      const path = pathname.replace(/\.git$/, "");
+      return `${proto}//${hostname}${path}`;
+    } catch {
+      return null;
+    }
+  }
+
+  class GitHost {
+    constructor(type, user, auth, project, committish, defaultRepresentation, opts = {}) {
+      Object.assign(this, GitHost.#gitHosts[type], {
+        type,
+        user,
+        auth,
+        project,
+        committish,
+        default: defaultRepresentation,
+        opts
+      });
+    }
+    static #gitHosts = { byShortcut: {}, byDomain: {} };
+    static #protocols = {
+      "git+ssh:": { name: "sshurl" },
+      "ssh:": { name: "sshurl" },
+      "git+https:": { name: "https", auth: true },
+      "git:": { auth: true },
+      "http:": { auth: true },
+      "https:": { auth: true },
+      "git+http:": { auth: true }
+    };
+    static addHost(name, host) {
+      GitHost.#gitHosts[name] = host;
+      GitHost.#gitHosts.byDomain[host.domain] = name;
+      GitHost.#gitHosts.byShortcut[`${name}:`] = name;
+      GitHost.#protocols[`${name}:`] = { name };
+    }
+    static fromUrl(giturl, opts) {
+      if (typeof giturl !== "string") {
+        return;
+      }
+      const key = giturl + JSON.stringify(opts || {});
+      if (!cache.has(key)) {
+        const hostArgs = fromUrl(giturl, opts, {
+          gitHosts: GitHost.#gitHosts,
+          protocols: GitHost.#protocols
+        });
+        cache.set(key, hostArgs ? new GitHost(...hostArgs) : undefined);
+      }
+      return cache.get(key);
+    }
+    static fromManifest(manifest, opts = {}) {
+      if (!manifest || typeof manifest !== "object") {
+        return;
+      }
+      const r = manifest.repository;
+      const rurl = r && (typeof r === "string" ? r : typeof r === "object" && typeof r.url === "string" ? r.url : null);
+      if (!rurl) {
+        throw new Error("no repository");
+      }
+      const info = rurl && GitHost.fromUrl(rurl.replace(/^git\+/, ""), opts) || null;
+      if (info) {
+        return info;
+      }
+      const unk = unknownHostedUrl(rurl);
+      return GitHost.fromUrl(unk, opts) || unk;
+    }
+    static parseUrl(url) {
+      return parseUrl(url);
+    }
+    #fill(template, opts) {
+      if (typeof template !== "function") {
+        return null;
+      }
+      const options = { ...this, ...this.opts, ...opts };
+      if (!options.path) {
+        options.path = "";
+      }
+      if (options.path.startsWith("/")) {
+        options.path = options.path.slice(1);
+      }
+      if (options.noCommittish) {
+        options.committish = null;
+      }
+      const result = template(options);
+      return options.noGitPlus && result.startsWith("git+") ? result.slice(4) : result;
+    }
+    hash() {
+      return this.committish ? `#${this.committish}` : "";
+    }
+    ssh(opts) {
+      return this.#fill(this.sshtemplate, opts);
+    }
+    sshurl(opts) {
+      return this.#fill(this.sshurltemplate, opts);
+    }
+    browse(path, ...args) {
+      if (typeof path !== "string") {
+        return this.#fill(this.browsetemplate, path);
+      }
+      if (typeof args[0] !== "string") {
+        return this.#fill(this.browsetreetemplate, { ...args[0], path });
+      }
+      return this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path });
+    }
+    browseFile(path, ...args) {
+      if (typeof args[0] !== "string") {
+        return this.#fill(this.browseblobtemplate, { ...args[0], path });
+      }
+      return this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path });
+    }
+    docs(opts) {
+      return this.#fill(this.docstemplate, opts);
+    }
+    bugs(opts) {
+      return this.#fill(this.bugstemplate, opts);
+    }
+    https(opts) {
+      return this.#fill(this.httpstemplate, opts);
+    }
+    git(opts) {
+      return this.#fill(this.gittemplate, opts);
+    }
+    shortcut(opts) {
+      return this.#fill(this.shortcuttemplate, opts);
+    }
+    path(opts) {
+      return this.#fill(this.pathtemplate, opts);
+    }
+    tarball(opts) {
+      return this.#fill(this.tarballtemplate, { ...opts, noCommittish: false });
+    }
+    file(path, opts) {
+      return this.#fill(this.filetemplate, { ...opts, path });
+    }
+    edit(path, opts) {
+      return this.#fill(this.edittemplate, { ...opts, path });
+    }
+    getDefaultRepresentation() {
+      return this.default;
+    }
+    toString(opts) {
+      if (this.default && typeof this[this.default] === "function") {
+        return this[this.default](opts);
+      }
+      return this.sshurl(opts);
+    }
+  }
+  for (const [name, host] of Object.entries(hosts)) {
+    GitHost.addHost(name, host);
+  }
+  module.exports = GitHost;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/constants.js
+var require_constants = __commonJS((exports, module) => {
+  var SEMVER_SPEC_VERSION = "2.0.0";
+  var MAX_LENGTH = 256;
+  var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+  var MAX_SAFE_COMPONENT_LENGTH = 16;
+  var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+  var RELEASE_TYPES = [
+    "major",
+    "premajor",
+    "minor",
+    "preminor",
+    "patch",
+    "prepatch",
+    "prerelease"
+  ];
+  module.exports = {
+    MAX_LENGTH,
+    MAX_SAFE_COMPONENT_LENGTH,
+    MAX_SAFE_BUILD_LENGTH,
+    MAX_SAFE_INTEGER,
+    RELEASE_TYPES,
+    SEMVER_SPEC_VERSION,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  };
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/debug.js
+var require_debug = __commonJS((exports, module) => {
+  var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
+  module.exports = debug;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/re.js
+var require_re = __commonJS((exports, module) => {
+  var {
+    MAX_SAFE_COMPONENT_LENGTH,
+    MAX_SAFE_BUILD_LENGTH,
+    MAX_LENGTH
+  } = require_constants();
+  var debug = require_debug();
+  exports = module.exports = {};
+  var re = exports.re = [];
+  var safeRe = exports.safeRe = [];
+  var src = exports.src = [];
+  var safeSrc = exports.safeSrc = [];
+  var t = exports.t = {};
+  var R = 0;
+  var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+  var safeRegexReplacements = [
+    ["\\s", 1],
+    ["\\d", MAX_LENGTH],
+    [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+  ];
+  var makeSafeRegex = (value) => {
+    for (const [token, max] of safeRegexReplacements) {
+      value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+    }
+    return value;
+  };
+  var createToken = (name, value, isGlobal) => {
+    const safe = makeSafeRegex(value);
+    const index = R++;
+    debug(name, index, value);
+    t[name] = index;
+    src[index] = value;
+    safeSrc[index] = safe;
+    re[index] = new RegExp(value, isGlobal ? "g" : undefined);
+    safeRe[index] = new RegExp(safe, isGlobal ? "g" : undefined);
+  };
+  createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+  createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+  createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+  createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})`);
+  createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+  createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+  createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+  createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+  createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+  createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+  createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+  createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+  createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+  createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+  createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+  createToken("GTLT", "((?:<|>)?=?)");
+  createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+  createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+  createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?` + `)?)?`);
+  createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);
+  createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+  createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("COERCEPLAIN", `${"(^|[^\\d])" + "(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+  createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+  createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?` + `(?:${src[t.BUILD]})?` + `(?:$|[^\\d])`);
+  createToken("COERCERTL", src[t.COERCE], true);
+  createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+  createToken("LONETILDE", "(?:~>?)");
+  createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+  exports.tildeTrimReplace = "$1~";
+  createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+  createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("LONECARET", "(?:\\^)");
+  createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+  exports.caretTrimReplace = "$1^";
+  createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+  createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+  createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+  createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+  exports.comparatorTrimReplace = "$1$2$3";
+  createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAIN]})` + `\\s*$`);
+  createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAINLOOSE]})` + `\\s*$`);
+  createToken("STAR", "(<|>)?=?\\s*\\*");
+  createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+  createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS((exports, module) => {
+  var looseOption = Object.freeze({ loose: true });
+  var emptyOpts = Object.freeze({});
+  var parseOptions = (options) => {
+    if (!options) {
+      return emptyOpts;
+    }
+    if (typeof options !== "object") {
+      return looseOption;
+    }
+    return options;
+  };
+  module.exports = parseOptions;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS((exports, module) => {
+  var numeric = /^[0-9]+$/;
+  var compareIdentifiers = (a, b) => {
+    if (typeof a === "number" && typeof b === "number") {
+      return a === b ? 0 : a < b ? -1 : 1;
+    }
+    const anum = numeric.test(a);
+    const bnum = numeric.test(b);
+    if (anum && bnum) {
+      a = +a;
+      b = +b;
+    }
+    return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+  };
+  var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+  module.exports = {
+    compareIdentifiers,
+    rcompareIdentifiers
+  };
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/classes/semver.js
+var require_semver = __commonJS((exports, module) => {
+  var debug = require_debug();
+  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+  var { safeRe: re, t } = require_re();
+  var parseOptions = require_parse_options();
+  var { compareIdentifiers } = require_identifiers();
+
+  class SemVer {
+    constructor(version, options) {
+      options = parseOptions(options);
+      if (version instanceof SemVer) {
+        if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+          return version;
+        } else {
+          version = version.version;
+        }
+      } else if (typeof version !== "string") {
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+      }
+      if (version.length > MAX_LENGTH) {
+        throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+      }
+      debug("SemVer", version, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+      const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+      if (!m) {
+        throw new TypeError(`Invalid Version: ${version}`);
+      }
+      this.raw = version;
+      this.major = +m[1];
+      this.minor = +m[2];
+      this.patch = +m[3];
+      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+        throw new TypeError("Invalid major version");
+      }
+      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+        throw new TypeError("Invalid minor version");
+      }
+      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+        throw new TypeError("Invalid patch version");
+      }
+      if (!m[4]) {
+        this.prerelease = [];
+      } else {
+        this.prerelease = m[4].split(".").map((id) => {
+          if (/^[0-9]+$/.test(id)) {
+            const num = +id;
+            if (num >= 0 && num < MAX_SAFE_INTEGER) {
+              return num;
+            }
+          }
+          return id;
+        });
+      }
+      this.build = m[5] ? m[5].split(".") : [];
+      this.format();
+    }
+    format() {
+      this.version = `${this.major}.${this.minor}.${this.patch}`;
+      if (this.prerelease.length) {
+        this.version += `-${this.prerelease.join(".")}`;
+      }
+      return this.version;
+    }
+    toString() {
+      return this.version;
+    }
+    compare(other) {
+      debug("SemVer.compare", this.version, this.options, other);
+      if (!(other instanceof SemVer)) {
+        if (typeof other === "string" && other === this.version) {
+          return 0;
+        }
+        other = new SemVer(other, this.options);
+      }
+      if (other.version === this.version) {
+        return 0;
+      }
+      return this.compareMain(other) || this.comparePre(other);
+    }
+    compareMain(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      if (this.major < other.major) {
+        return -1;
+      }
+      if (this.major > other.major) {
+        return 1;
+      }
+      if (this.minor < other.minor) {
+        return -1;
+      }
+      if (this.minor > other.minor) {
+        return 1;
+      }
+      if (this.patch < other.patch) {
+        return -1;
+      }
+      if (this.patch > other.patch) {
+        return 1;
+      }
+      return 0;
+    }
+    comparePre(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      if (this.prerelease.length && !other.prerelease.length) {
+        return -1;
+      } else if (!this.prerelease.length && other.prerelease.length) {
+        return 1;
+      } else if (!this.prerelease.length && !other.prerelease.length) {
+        return 0;
+      }
+      let i = 0;
+      do {
+        const a = this.prerelease[i];
+        const b = other.prerelease[i];
+        debug("prerelease compare", i, a, b);
+        if (a === undefined && b === undefined) {
+          return 0;
+        } else if (b === undefined) {
+          return 1;
+        } else if (a === undefined) {
+          return -1;
+        } else if (a === b) {
+          continue;
+        } else {
+          return compareIdentifiers(a, b);
+        }
+      } while (++i);
+    }
+    compareBuild(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      let i = 0;
+      do {
+        const a = this.build[i];
+        const b = other.build[i];
+        debug("build compare", i, a, b);
+        if (a === undefined && b === undefined) {
+          return 0;
+        } else if (b === undefined) {
+          return 1;
+        } else if (a === undefined) {
+          return -1;
+        } else if (a === b) {
+          continue;
+        } else {
+          return compareIdentifiers(a, b);
+        }
+      } while (++i);
+    }
+    inc(release, identifier, identifierBase) {
+      if (release.startsWith("pre")) {
+        if (!identifier && identifierBase === false) {
+          throw new Error("invalid increment argument: identifier is empty");
+        }
+        if (identifier) {
+          const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+          if (!match || match[1] !== identifier) {
+            throw new Error(`invalid identifier: ${identifier}`);
+          }
+        }
+      }
+      switch (release) {
+        case "premajor":
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor = 0;
+          this.major++;
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "preminor":
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor++;
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0;
+          this.inc("patch", identifier, identifierBase);
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "prerelease":
+          if (this.prerelease.length === 0) {
+            this.inc("patch", identifier, identifierBase);
+          }
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "release":
+          if (this.prerelease.length === 0) {
+            throw new Error(`version ${this.raw} is not a prerelease`);
+          }
+          this.prerelease.length = 0;
+          break;
+        case "major":
+          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+            this.major++;
+          }
+          this.minor = 0;
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "minor":
+          if (this.patch !== 0 || this.prerelease.length === 0) {
+            this.minor++;
+          }
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "patch":
+          if (this.prerelease.length === 0) {
+            this.patch++;
+          }
+          this.prerelease = [];
+          break;
+        case "pre": {
+          const base = Number(identifierBase) ? 1 : 0;
+          if (this.prerelease.length === 0) {
+            this.prerelease = [base];
+          } else {
+            let i = this.prerelease.length;
+            while (--i >= 0) {
+              if (typeof this.prerelease[i] === "number") {
+                this.prerelease[i]++;
+                i = -2;
+              }
+            }
+            if (i === -1) {
+              if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                throw new Error("invalid increment argument: identifier already exists");
+              }
+              this.prerelease.push(base);
+            }
+          }
+          if (identifier) {
+            let prerelease = [identifier, base];
+            if (identifierBase === false) {
+              prerelease = [identifier];
+            }
+            if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+              if (isNaN(this.prerelease[1])) {
+                this.prerelease = prerelease;
+              }
+            } else {
+              this.prerelease = prerelease;
+            }
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${release}`);
+      }
+      this.raw = this.format();
+      if (this.build.length) {
+        this.raw += `+${this.build.join(".")}`;
+      }
+      return this;
+    }
+  }
+  module.exports = SemVer;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var parse = (version, options, throwErrors = false) => {
+    if (version instanceof SemVer) {
+      return version;
+    }
+    try {
+      return new SemVer(version, options);
+    } catch (er) {
+      if (!throwErrors) {
+        return null;
+      }
+      throw er;
+    }
+  };
+  module.exports = parse;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/valid.js
+var require_valid = __commonJS((exports, module) => {
+  var parse = require_parse();
+  var valid = (version, options) => {
+    const v = parse(version, options);
+    return v ? v.version : null;
+  };
+  module.exports = valid;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/clean.js
+var require_clean = __commonJS((exports, module) => {
+  var parse = require_parse();
+  var clean = (version, options) => {
+    const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+    return s ? s.version : null;
+  };
+  module.exports = clean;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/inc.js
+var require_inc = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var inc = (version, release, options, identifier, identifierBase) => {
+    if (typeof options === "string") {
+      identifierBase = identifier;
+      identifier = options;
+      options = undefined;
+    }
+    try {
+      return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier, identifierBase).version;
+    } catch (er) {
+      return null;
+    }
+  };
+  module.exports = inc;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/diff.js
+var require_diff = __commonJS((exports, module) => {
+  var parse = require_parse();
+  var diff = (version1, version2) => {
+    const v1 = parse(version1, null, true);
+    const v2 = parse(version2, null, true);
+    const comparison = v1.compare(v2);
+    if (comparison === 0) {
+      return null;
+    }
+    const v1Higher = comparison > 0;
+    const highVersion = v1Higher ? v1 : v2;
+    const lowVersion = v1Higher ? v2 : v1;
+    const highHasPre = !!highVersion.prerelease.length;
+    const lowHasPre = !!lowVersion.prerelease.length;
+    if (lowHasPre && !highHasPre) {
+      if (!lowVersion.patch && !lowVersion.minor) {
+        return "major";
+      }
+      if (lowVersion.compareMain(highVersion) === 0) {
+        if (lowVersion.minor && !lowVersion.patch) {
+          return "minor";
+        }
+        return "patch";
+      }
+    }
+    const prefix = highHasPre ? "pre" : "";
+    if (v1.major !== v2.major) {
+      return prefix + "major";
+    }
+    if (v1.minor !== v2.minor) {
+      return prefix + "minor";
+    }
+    if (v1.patch !== v2.patch) {
+      return prefix + "patch";
+    }
+    return "prerelease";
+  };
+  module.exports = diff;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/major.js
+var require_major = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var major = (a, loose) => new SemVer(a, loose).major;
+  module.exports = major;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/minor.js
+var require_minor = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var minor = (a, loose) => new SemVer(a, loose).minor;
+  module.exports = minor;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/patch.js
+var require_patch = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var patch = (a, loose) => new SemVer(a, loose).patch;
+  module.exports = patch;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS((exports, module) => {
+  var parse = require_parse();
+  var prerelease = (version, options) => {
+    const parsed = parse(version, options);
+    return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+  };
+  module.exports = prerelease;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/compare.js
+var require_compare = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+  module.exports = compare;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var rcompare = (a, b, loose) => compare(b, a, loose);
+  module.exports = rcompare;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var compareLoose = (a, b) => compare(a, b, true);
+  module.exports = compareLoose;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var compareBuild = (a, b, loose) => {
+    const versionA = new SemVer(a, loose);
+    const versionB = new SemVer(b, loose);
+    return versionA.compare(versionB) || versionA.compareBuild(versionB);
+  };
+  module.exports = compareBuild;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/sort.js
+var require_sort = __commonJS((exports, module) => {
+  var compareBuild = require_compare_build();
+  var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+  module.exports = sort;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS((exports, module) => {
+  var compareBuild = require_compare_build();
+  var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+  module.exports = rsort;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/gt.js
+var require_gt = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var gt = (a, b, loose) => compare(a, b, loose) > 0;
+  module.exports = gt;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/lt.js
+var require_lt = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var lt = (a, b, loose) => compare(a, b, loose) < 0;
+  module.exports = lt;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/eq.js
+var require_eq = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var eq = (a, b, loose) => compare(a, b, loose) === 0;
+  module.exports = eq;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/neq.js
+var require_neq = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+  module.exports = neq;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/gte.js
+var require_gte = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+  module.exports = gte;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/lte.js
+var require_lte = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+  module.exports = lte;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS((exports, module) => {
+  var eq = require_eq();
+  var neq = require_neq();
+  var gt = require_gt();
+  var gte = require_gte();
+  var lt = require_lt();
+  var lte = require_lte();
+  var cmp = (a, op, b, loose) => {
+    switch (op) {
+      case "===":
+        if (typeof a === "object") {
+          a = a.version;
+        }
+        if (typeof b === "object") {
+          b = b.version;
+        }
+        return a === b;
+      case "!==":
+        if (typeof a === "object") {
+          a = a.version;
+        }
+        if (typeof b === "object") {
+          b = b.version;
+        }
+        return a !== b;
+      case "":
+      case "=":
+      case "==":
+        return eq(a, b, loose);
+      case "!=":
+        return neq(a, b, loose);
+      case ">":
+        return gt(a, b, loose);
+      case ">=":
+        return gte(a, b, loose);
+      case "<":
+        return lt(a, b, loose);
+      case "<=":
+        return lte(a, b, loose);
+      default:
+        throw new TypeError(`Invalid operator: ${op}`);
+    }
+  };
+  module.exports = cmp;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var parse = require_parse();
+  var { safeRe: re, t } = require_re();
+  var coerce = (version, options) => {
+    if (version instanceof SemVer) {
+      return version;
+    }
+    if (typeof version === "number") {
+      version = String(version);
+    }
+    if (typeof version !== "string") {
+      return null;
+    }
+    options = options || {};
+    let match = null;
+    if (!options.rtl) {
+      match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+    } else {
+      const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+      let next;
+      while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+        if (!match || next.index + next[0].length !== match.index + match[0].length) {
+          match = next;
+        }
+        coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+      }
+      coerceRtlRegex.lastIndex = -1;
+    }
+    if (match === null) {
+      return null;
+    }
+    const major = match[2];
+    const minor = match[3] || "0";
+    const patch = match[4] || "0";
+    const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+    const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+    return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+  };
+  module.exports = coerce;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS((exports, module) => {
+  class LRUCache {
+    constructor() {
+      this.max = 1000;
+      this.map = new Map;
+    }
+    get(key) {
+      const value = this.map.get(key);
+      if (value === undefined) {
+        return;
+      } else {
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+      }
+    }
+    delete(key) {
+      return this.map.delete(key);
+    }
+    set(key, value) {
+      const deleted = this.delete(key);
+      if (!deleted && value !== undefined) {
+        if (this.map.size >= this.max) {
+          const firstKey = this.map.keys().next().value;
+          this.delete(firstKey);
+        }
+        this.map.set(key, value);
+      }
+      return this;
+    }
+  }
+  module.exports = LRUCache;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/classes/range.js
+var require_range = __commonJS((exports, module) => {
+  var SPACE_CHARACTERS = /\s+/g;
+
+  class Range {
+    constructor(range, options) {
+      options = parseOptions(options);
+      if (range instanceof Range) {
+        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+          return range;
+        } else {
+          return new Range(range.raw, options);
+        }
+      }
+      if (range instanceof Comparator) {
+        this.raw = range.value;
+        this.set = [[range]];
+        this.formatted = undefined;
+        return this;
+      }
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+      this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+      this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+      if (!this.set.length) {
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      }
+      if (this.set.length > 1) {
+        const first = this.set[0];
+        this.set = this.set.filter((c) => !isNullSet(c[0]));
+        if (this.set.length === 0) {
+          this.set = [first];
+        } else if (this.set.length > 1) {
+          for (const c of this.set) {
+            if (c.length === 1 && isAny(c[0])) {
+              this.set = [c];
+              break;
+            }
+          }
+        }
+      }
+      this.formatted = undefined;
+    }
+    get range() {
+      if (this.formatted === undefined) {
+        this.formatted = "";
+        for (let i = 0;i < this.set.length; i++) {
+          if (i > 0) {
+            this.formatted += "||";
+          }
+          const comps = this.set[i];
+          for (let k = 0;k < comps.length; k++) {
+            if (k > 0) {
+              this.formatted += " ";
+            }
+            this.formatted += comps[k].toString().trim();
+          }
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(range) {
+      const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+      const memoKey = memoOpts + ":" + range;
+      const cached = cache.get(memoKey);
+      if (cached) {
+        return cached;
+      }
+      const loose = this.options.loose;
+      const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+      range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+      debug("hyphen replace", range);
+      range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+      debug("comparator trim", range);
+      range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+      debug("tilde trim", range);
+      range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+      debug("caret trim", range);
+      let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+      if (loose) {
+        rangeList = rangeList.filter((comp) => {
+          debug("loose invalid filter", comp, this.options);
+          return !!comp.match(re[t.COMPARATORLOOSE]);
+        });
+      }
+      debug("range list", rangeList);
+      const rangeMap = new Map;
+      const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+      for (const comp of comparators) {
+        if (isNullSet(comp)) {
+          return [comp];
+        }
+        rangeMap.set(comp.value, comp);
+      }
+      if (rangeMap.size > 1 && rangeMap.has("")) {
+        rangeMap.delete("");
+      }
+      const result = [...rangeMap.values()];
+      cache.set(memoKey, result);
+      return result;
+    }
+    intersects(range, options) {
+      if (!(range instanceof Range)) {
+        throw new TypeError("a Range is required");
+      }
+      return this.set.some((thisComparators) => {
+        return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+          return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+            return rangeComparators.every((rangeComparator) => {
+              return thisComparator.intersects(rangeComparator, options);
+            });
+          });
+        });
+      });
+    }
+    test(version) {
+      if (!version) {
+        return false;
+      }
+      if (typeof version === "string") {
+        try {
+          version = new SemVer(version, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      for (let i = 0;i < this.set.length; i++) {
+        if (testSet(this.set[i], version, this.options)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  module.exports = Range;
+  var LRU = require_lrucache();
+  var cache = new LRU;
+  var parseOptions = require_parse_options();
+  var Comparator = require_comparator();
+  var debug = require_debug();
+  var SemVer = require_semver();
+  var {
+    safeRe: re,
+    t,
+    comparatorTrimReplace,
+    tildeTrimReplace,
+    caretTrimReplace
+  } = require_re();
+  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+  var isNullSet = (c) => c.value === "<0.0.0-0";
+  var isAny = (c) => c.value === "";
+  var isSatisfiable = (comparators, options) => {
+    let result = true;
+    const remainingComparators = comparators.slice();
+    let testComparator = remainingComparators.pop();
+    while (result && remainingComparators.length) {
+      result = remainingComparators.every((otherComparator) => {
+        return testComparator.intersects(otherComparator, options);
+      });
+      testComparator = remainingComparators.pop();
+    }
+    return result;
+  };
+  var parseComparator = (comp, options) => {
+    comp = comp.replace(re[t.BUILD], "");
+    debug("comp", comp, options);
+    comp = replaceCarets(comp, options);
+    debug("caret", comp);
+    comp = replaceTildes(comp, options);
+    debug("tildes", comp);
+    comp = replaceXRanges(comp, options);
+    debug("xrange", comp);
+    comp = replaceStars(comp, options);
+    debug("stars", comp);
+    return comp;
+  };
+  var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+  var replaceTildes = (comp, options) => {
+    return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+  };
+  var replaceTilde = (comp, options) => {
+    const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+    return comp.replace(r, (_, M, m, p, pr) => {
+      debug("tilde", comp, _, M, m, p, pr);
+      let ret;
+      if (isX(M)) {
+        ret = "";
+      } else if (isX(m)) {
+        ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+      } else if (isX(p)) {
+        ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+      } else if (pr) {
+        debug("replaceTilde pr", pr);
+        ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+      } else {
+        ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+      }
+      debug("tilde return", ret);
+      return ret;
+    });
+  };
+  var replaceCarets = (comp, options) => {
+    return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+  };
+  var replaceCaret = (comp, options) => {
+    debug("caret", comp, options);
+    const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+    const z = options.includePrerelease ? "-0" : "";
+    return comp.replace(r, (_, M, m, p, pr) => {
+      debug("caret", comp, _, M, m, p, pr);
+      let ret;
+      if (isX(M)) {
+        ret = "";
+      } else if (isX(m)) {
+        ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+      } else if (isX(p)) {
+        if (M === "0") {
+          ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+        }
+      } else if (pr) {
+        debug("replaceCaret pr", pr);
+        if (M === "0") {
+          if (m === "0") {
+            ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+          }
+        } else {
+          ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+        }
+      } else {
+        debug("no pr");
+        if (M === "0") {
+          if (m === "0") {
+            ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+          } else {
+            ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+          }
+        } else {
+          ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+        }
+      }
+      debug("caret return", ret);
+      return ret;
+    });
+  };
+  var replaceXRanges = (comp, options) => {
+    debug("replaceXRanges", comp, options);
+    return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+  };
+  var replaceXRange = (comp, options) => {
+    comp = comp.trim();
+    const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+    return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+      debug("xRange", comp, ret, gtlt, M, m, p, pr);
+      const xM = isX(M);
+      const xm = xM || isX(m);
+      const xp = xm || isX(p);
+      const anyX = xp;
+      if (gtlt === "=" && anyX) {
+        gtlt = "";
+      }
+      pr = options.includePrerelease ? "-0" : "";
+      if (xM) {
+        if (gtlt === ">" || gtlt === "<") {
+          ret = "<0.0.0-0";
+        } else {
+          ret = "*";
+        }
+      } else if (gtlt && anyX) {
+        if (xm) {
+          m = 0;
+        }
+        p = 0;
+        if (gtlt === ">") {
+          gtlt = ">=";
+          if (xm) {
+            M = +M + 1;
+            m = 0;
+            p = 0;
+          } else {
+            m = +m + 1;
+            p = 0;
+          }
+        } else if (gtlt === "<=") {
+          gtlt = "<";
+          if (xm) {
+            M = +M + 1;
+          } else {
+            m = +m + 1;
+          }
+        }
+        if (gtlt === "<") {
+          pr = "-0";
+        }
+        ret = `${gtlt + M}.${m}.${p}${pr}`;
+      } else if (xm) {
+        ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+      } else if (xp) {
+        ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+      }
+      debug("xRange return", ret);
+      return ret;
+    });
+  };
+  var replaceStars = (comp, options) => {
+    debug("replaceStars", comp, options);
+    return comp.trim().replace(re[t.STAR], "");
+  };
+  var replaceGTE0 = (comp, options) => {
+    debug("replaceGTE0", comp, options);
+    return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+  };
+  var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+    if (isX(fM)) {
+      from = "";
+    } else if (isX(fm)) {
+      from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+    } else if (isX(fp)) {
+      from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+    } else if (fpr) {
+      from = `>=${from}`;
+    } else {
+      from = `>=${from}${incPr ? "-0" : ""}`;
+    }
+    if (isX(tM)) {
+      to = "";
+    } else if (isX(tm)) {
+      to = `<${+tM + 1}.0.0-0`;
+    } else if (isX(tp)) {
+      to = `<${tM}.${+tm + 1}.0-0`;
+    } else if (tpr) {
+      to = `<=${tM}.${tm}.${tp}-${tpr}`;
+    } else if (incPr) {
+      to = `<${tM}.${tm}.${+tp + 1}-0`;
+    } else {
+      to = `<=${to}`;
+    }
+    return `${from} ${to}`.trim();
+  };
+  var testSet = (set, version, options) => {
+    for (let i = 0;i < set.length; i++) {
+      if (!set[i].test(version)) {
+        return false;
+      }
+    }
+    if (version.prerelease.length && !options.includePrerelease) {
+      for (let i = 0;i < set.length; i++) {
+        debug(set[i].semver);
+        if (set[i].semver === Comparator.ANY) {
+          continue;
+        }
+        if (set[i].semver.prerelease.length > 0) {
+          const allowed = set[i].semver;
+          if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    return true;
+  };
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS((exports, module) => {
+  var ANY = Symbol("SemVer ANY");
+
+  class Comparator {
+    static get ANY() {
+      return ANY;
+    }
+    constructor(comp, options) {
+      options = parseOptions(options);
+      if (comp instanceof Comparator) {
+        if (comp.loose === !!options.loose) {
+          return comp;
+        } else {
+          comp = comp.value;
+        }
+      }
+      comp = comp.trim().split(/\s+/).join(" ");
+      debug("comparator", comp, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.parse(comp);
+      if (this.semver === ANY) {
+        this.value = "";
+      } else {
+        this.value = this.operator + this.semver.version;
+      }
+      debug("comp", this);
+    }
+    parse(comp) {
+      const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+      const m = comp.match(r);
+      if (!m) {
+        throw new TypeError(`Invalid comparator: ${comp}`);
+      }
+      this.operator = m[1] !== undefined ? m[1] : "";
+      if (this.operator === "=") {
+        this.operator = "";
+      }
+      if (!m[2]) {
+        this.semver = ANY;
+      } else {
+        this.semver = new SemVer(m[2], this.options.loose);
+      }
+    }
+    toString() {
+      return this.value;
+    }
+    test(version) {
+      debug("Comparator.test", version, this.options.loose);
+      if (this.semver === ANY || version === ANY) {
+        return true;
+      }
+      if (typeof version === "string") {
+        try {
+          version = new SemVer(version, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      return cmp(version, this.operator, this.semver, this.options);
+    }
+    intersects(comp, options) {
+      if (!(comp instanceof Comparator)) {
+        throw new TypeError("a Comparator is required");
+      }
+      if (this.operator === "") {
+        if (this.value === "") {
+          return true;
+        }
+        return new Range(comp.value, options).test(this.value);
+      } else if (comp.operator === "") {
+        if (comp.value === "") {
+          return true;
+        }
+        return new Range(this.value, options).test(comp.semver);
+      }
+      options = parseOptions(options);
+      if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+        return false;
+      }
+      if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+        return false;
+      }
+      if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+        return true;
+      }
+      if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+        return true;
+      }
+      if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+        return true;
+      }
+      if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+        return true;
+      }
+      if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+        return true;
+      }
+      return false;
+    }
+  }
+  module.exports = Comparator;
+  var parseOptions = require_parse_options();
+  var { safeRe: re, t } = require_re();
+  var cmp = require_cmp();
+  var debug = require_debug();
+  var SemVer = require_semver();
+  var Range = require_range();
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS((exports, module) => {
+  var Range = require_range();
+  var satisfies = (version, range, options) => {
+    try {
+      range = new Range(range, options);
+    } catch (er) {
+      return false;
+    }
+    return range.test(version);
+  };
+  module.exports = satisfies;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS((exports, module) => {
+  var Range = require_range();
+  var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+  module.exports = toComparators;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var Range = require_range();
+  var maxSatisfying = (versions, range, options) => {
+    let max = null;
+    let maxSV = null;
+    let rangeObj = null;
+    try {
+      rangeObj = new Range(range, options);
+    } catch (er) {
+      return null;
+    }
+    versions.forEach((v) => {
+      if (rangeObj.test(v)) {
+        if (!max || maxSV.compare(v) === -1) {
+          max = v;
+          maxSV = new SemVer(max, options);
+        }
+      }
+    });
+    return max;
+  };
+  module.exports = maxSatisfying;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var Range = require_range();
+  var minSatisfying = (versions, range, options) => {
+    let min = null;
+    let minSV = null;
+    let rangeObj = null;
+    try {
+      rangeObj = new Range(range, options);
+    } catch (er) {
+      return null;
+    }
+    versions.forEach((v) => {
+      if (rangeObj.test(v)) {
+        if (!min || minSV.compare(v) === 1) {
+          min = v;
+          minSV = new SemVer(min, options);
+        }
+      }
+    });
+    return min;
+  };
+  module.exports = minSatisfying;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var Range = require_range();
+  var gt = require_gt();
+  var minVersion = (range, loose) => {
+    range = new Range(range, loose);
+    let minver = new SemVer("0.0.0");
+    if (range.test(minver)) {
+      return minver;
+    }
+    minver = new SemVer("0.0.0-0");
+    if (range.test(minver)) {
+      return minver;
+    }
+    minver = null;
+    for (let i = 0;i < range.set.length; ++i) {
+      const comparators = range.set[i];
+      let setMin = null;
+      comparators.forEach((comparator) => {
+        const compver = new SemVer(comparator.semver.version);
+        switch (comparator.operator) {
+          case ">":
+            if (compver.prerelease.length === 0) {
+              compver.patch++;
+            } else {
+              compver.prerelease.push(0);
+            }
+            compver.raw = compver.format();
+          case "":
+          case ">=":
+            if (!setMin || gt(compver, setMin)) {
+              setMin = compver;
+            }
+            break;
+          case "<":
+          case "<=":
+            break;
+          default:
+            throw new Error(`Unexpected operation: ${comparator.operator}`);
+        }
+      });
+      if (setMin && (!minver || gt(minver, setMin))) {
+        minver = setMin;
+      }
+    }
+    if (minver && range.test(minver)) {
+      return minver;
+    }
+    return null;
+  };
+  module.exports = minVersion;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS((exports, module) => {
+  var Range = require_range();
+  var validRange = (range, options) => {
+    try {
+      return new Range(range, options).range || "*";
+    } catch (er) {
+      return null;
+    }
+  };
+  module.exports = validRange;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/outside.js
+var require_outside = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var Comparator = require_comparator();
+  var { ANY } = Comparator;
+  var Range = require_range();
+  var satisfies = require_satisfies();
+  var gt = require_gt();
+  var lt = require_lt();
+  var lte = require_lte();
+  var gte = require_gte();
+  var outside = (version, range, hilo, options) => {
+    version = new SemVer(version, options);
+    range = new Range(range, options);
+    let gtfn, ltefn, ltfn, comp, ecomp;
+    switch (hilo) {
+      case ">":
+        gtfn = gt;
+        ltefn = lte;
+        ltfn = lt;
+        comp = ">";
+        ecomp = ">=";
+        break;
+      case "<":
+        gtfn = lt;
+        ltefn = gte;
+        ltfn = gt;
+        comp = "<";
+        ecomp = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (satisfies(version, range, options)) {
+      return false;
+    }
+    for (let i = 0;i < range.set.length; ++i) {
+      const comparators = range.set[i];
+      let high = null;
+      let low = null;
+      comparators.forEach((comparator) => {
+        if (comparator.semver === ANY) {
+          comparator = new Comparator(">=0.0.0");
+        }
+        high = high || comparator;
+        low = low || comparator;
+        if (gtfn(comparator.semver, high.semver, options)) {
+          high = comparator;
+        } else if (ltfn(comparator.semver, low.semver, options)) {
+          low = comparator;
+        }
+      });
+      if (high.operator === comp || high.operator === ecomp) {
+        return false;
+      }
+      if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+        return false;
+      } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  module.exports = outside;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS((exports, module) => {
+  var outside = require_outside();
+  var gtr = (version, range, options) => outside(version, range, ">", options);
+  module.exports = gtr;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS((exports, module) => {
+  var outside = require_outside();
+  var ltr = (version, range, options) => outside(version, range, "<", options);
+  module.exports = ltr;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS((exports, module) => {
+  var Range = require_range();
+  var intersects = (r1, r2, options) => {
+    r1 = new Range(r1, options);
+    r2 = new Range(r2, options);
+    return r1.intersects(r2, options);
+  };
+  module.exports = intersects;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS((exports, module) => {
+  var satisfies = require_satisfies();
+  var compare = require_compare();
+  module.exports = (versions, range, options) => {
+    const set = [];
+    let first = null;
+    let prev = null;
+    const v = versions.sort((a, b) => compare(a, b, options));
+    for (const version of v) {
+      const included = satisfies(version, range, options);
+      if (included) {
+        prev = version;
+        if (!first) {
+          first = version;
+        }
+      } else {
+        if (prev) {
+          set.push([first, prev]);
+        }
+        prev = null;
+        first = null;
+      }
+    }
+    if (first) {
+      set.push([first, null]);
+    }
+    const ranges = [];
+    for (const [min, max] of set) {
+      if (min === max) {
+        ranges.push(min);
+      } else if (!max && min === v[0]) {
+        ranges.push("*");
+      } else if (!max) {
+        ranges.push(`>=${min}`);
+      } else if (min === v[0]) {
+        ranges.push(`<=${max}`);
+      } else {
+        ranges.push(`${min} - ${max}`);
+      }
+    }
+    const simplified = ranges.join(" || ");
+    const original = typeof range.raw === "string" ? range.raw : String(range);
+    return simplified.length < original.length ? simplified : range;
+  };
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/subset.js
+var require_subset = __commonJS((exports, module) => {
+  var Range = require_range();
+  var Comparator = require_comparator();
+  var { ANY } = Comparator;
+  var satisfies = require_satisfies();
+  var compare = require_compare();
+  var subset = (sub, dom, options = {}) => {
+    if (sub === dom) {
+      return true;
+    }
+    sub = new Range(sub, options);
+    dom = new Range(dom, options);
+    let sawNonNull = false;
+    OUTER:
+      for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || isSub !== null;
+          if (isSub) {
+            continue OUTER;
+          }
+        }
+        if (sawNonNull) {
+          return false;
+        }
+      }
+    return true;
+  };
+  var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+  var minimumVersion = [new Comparator(">=0.0.0")];
+  var simpleSubset = (sub, dom, options) => {
+    if (sub === dom) {
+      return true;
+    }
+    if (sub.length === 1 && sub[0].semver === ANY) {
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        return true;
+      } else if (options.includePrerelease) {
+        sub = minimumVersionWithPreRelease;
+      } else {
+        sub = minimumVersion;
+      }
+    }
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      if (options.includePrerelease) {
+        return true;
+      } else {
+        dom = minimumVersion;
+      }
+    }
+    const eqSet = new Set;
+    let gt, lt;
+    for (const c of sub) {
+      if (c.operator === ">" || c.operator === ">=") {
+        gt = higherGT(gt, c, options);
+      } else if (c.operator === "<" || c.operator === "<=") {
+        lt = lowerLT(lt, c, options);
+      } else {
+        eqSet.add(c.semver);
+      }
+    }
+    if (eqSet.size > 1) {
+      return null;
+    }
+    let gtltComp;
+    if (gt && lt) {
+      gtltComp = compare(gt.semver, lt.semver, options);
+      if (gtltComp > 0) {
+        return null;
+      } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+        return null;
+      }
+    }
+    for (const eq of eqSet) {
+      if (gt && !satisfies(eq, String(gt), options)) {
+        return null;
+      }
+      if (lt && !satisfies(eq, String(lt), options)) {
+        return null;
+      }
+      for (const c of dom) {
+        if (!satisfies(eq, String(c), options)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    let higher, lower;
+    let hasDomLT, hasDomGT;
+    let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+    let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+    if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+      needDomLTPre = false;
+    }
+    for (const c of dom) {
+      hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+      hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+      if (gt) {
+        if (needDomGTPre) {
+          if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+            needDomGTPre = false;
+          }
+        }
+        if (c.operator === ">" || c.operator === ">=") {
+          higher = higherGT(gt, c, options);
+          if (higher === c && higher !== gt) {
+            return false;
+          }
+        } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+          return false;
+        }
+      }
+      if (lt) {
+        if (needDomLTPre) {
+          if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+            needDomLTPre = false;
+          }
+        }
+        if (c.operator === "<" || c.operator === "<=") {
+          lower = lowerLT(lt, c, options);
+          if (lower === c && lower !== lt) {
+            return false;
+          }
+        } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+          return false;
+        }
+      }
+      if (!c.operator && (lt || gt) && gtltComp !== 0) {
+        return false;
+      }
+    }
+    if (gt && hasDomLT && !lt && gtltComp !== 0) {
+      return false;
+    }
+    if (lt && hasDomGT && !gt && gtltComp !== 0) {
+      return false;
+    }
+    if (needDomGTPre || needDomLTPre) {
+      return false;
+    }
+    return true;
+  };
+  var higherGT = (a, b, options) => {
+    if (!a) {
+      return b;
+    }
+    const comp = compare(a.semver, b.semver, options);
+    return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+  };
+  var lowerLT = (a, b, options) => {
+    if (!a) {
+      return b;
+    }
+    const comp = compare(a.semver, b.semver, options);
+    return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+  };
+  module.exports = subset;
+});
+
+// ../../node_modules/.bun/semver@7.7.4/node_modules/semver/index.js
+var require_semver2 = __commonJS((exports, module) => {
+  var internalRe = require_re();
+  var constants = require_constants();
+  var SemVer = require_semver();
+  var identifiers = require_identifiers();
+  var parse = require_parse();
+  var valid = require_valid();
+  var clean = require_clean();
+  var inc = require_inc();
+  var diff = require_diff();
+  var major = require_major();
+  var minor = require_minor();
+  var patch = require_patch();
+  var prerelease = require_prerelease();
+  var compare = require_compare();
+  var rcompare = require_rcompare();
+  var compareLoose = require_compare_loose();
+  var compareBuild = require_compare_build();
+  var sort = require_sort();
+  var rsort = require_rsort();
+  var gt = require_gt();
+  var lt = require_lt();
+  var eq = require_eq();
+  var neq = require_neq();
+  var gte = require_gte();
+  var lte = require_lte();
+  var cmp = require_cmp();
+  var coerce = require_coerce();
+  var Comparator = require_comparator();
+  var Range = require_range();
+  var satisfies = require_satisfies();
+  var toComparators = require_to_comparators();
+  var maxSatisfying = require_max_satisfying();
+  var minSatisfying = require_min_satisfying();
+  var minVersion = require_min_version();
+  var validRange = require_valid2();
+  var outside = require_outside();
+  var gtr = require_gtr();
+  var ltr = require_ltr();
+  var intersects = require_intersects();
+  var simplifyRange = require_simplify();
+  var subset = require_subset();
+  module.exports = {
+    parse,
+    valid,
+    clean,
+    inc,
+    diff,
+    major,
+    minor,
+    patch,
+    prerelease,
+    compare,
+    rcompare,
+    compareLoose,
+    compareBuild,
+    sort,
+    rsort,
+    gt,
+    lt,
+    eq,
+    neq,
+    gte,
+    lte,
+    cmp,
+    coerce,
+    Comparator,
+    Range,
+    satisfies,
+    toComparators,
+    maxSatisfying,
+    minSatisfying,
+    minVersion,
+    validRange,
+    outside,
+    gtr,
+    ltr,
+    intersects,
+    simplifyRange,
+    subset,
+    SemVer,
+    re: internalRe.re,
+    src: internalRe.src,
+    tokens: internalRe.t,
+    SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: constants.RELEASE_TYPES,
+    compareIdentifiers: identifiers.compareIdentifiers,
+    rcompareIdentifiers: identifiers.rcompareIdentifiers
+  };
+});
+
+// ../../node_modules/.bun/validate-npm-package-name@7.0.2/node_modules/validate-npm-package-name/lib/builtin-modules.json
+var require_builtin_modules = __commonJS((exports, module) => {
+  module.exports = ["_http_agent", "_http_client", "_http_common", "_http_incoming", "_http_outgoing", "_http_server", "_stream_duplex", "_stream_passthrough", "_stream_readable", "_stream_transform", "_stream_wrap", "_stream_writable", "_tls_common", "_tls_wrap", "assert", "assert/strict", "async_hooks", "buffer", "child_process", "cluster", "console", "constants", "crypto", "dgram", "diagnostics_channel", "dns", "dns/promises", "domain", "events", "fs", "fs/promises", "http", "http2", "https", "inspector", "inspector/promises", "module", "net", "os", "path", "path/posix", "path/win32", "perf_hooks", "process", "punycode", "querystring", "readline", "readline/promises", "repl", "stream", "stream/consumers", "stream/promises", "stream/web", "string_decoder", "sys", "timers", "timers/promises", "tls", "trace_events", "tty", "url", "util", "util/types", "v8", "vm", "wasi", "worker_threads", "zlib", "node:sea", "node:sqlite", "node:test", "node:test/reporters"];
+});
+
+// ../../node_modules/.bun/validate-npm-package-name@7.0.2/node_modules/validate-npm-package-name/lib/index.js
+var require_lib2 = __commonJS((exports, module) => {
+  var builtins = require_builtin_modules();
+  var scopedPackagePattern = new RegExp("^(?:@([^/]+?)[/])?([^/]+?)$");
+  var exclusionList = [
+    "node_modules",
+    "favicon.ico"
+  ];
+  function validate(name) {
+    var warnings = [];
+    var errors = [];
+    if (name === null) {
+      errors.push("name cannot be null");
+      return done(warnings, errors);
+    }
+    if (name === undefined) {
+      errors.push("name cannot be undefined");
+      return done(warnings, errors);
+    }
+    if (typeof name !== "string") {
+      errors.push("name must be a string");
+      return done(warnings, errors);
+    }
+    if (!name.length) {
+      errors.push("name length must be greater than zero");
+    }
+    if (name.startsWith(".")) {
+      errors.push("name cannot start with a period");
+    }
+    if (name.startsWith("-")) {
+      errors.push("name cannot start with a hyphen");
+    }
+    if (name.match(/^_/)) {
+      errors.push("name cannot start with an underscore");
+    }
+    if (name.trim() !== name) {
+      errors.push("name cannot contain leading or trailing spaces");
+    }
+    exclusionList.forEach(function(excludedName) {
+      if (name.toLowerCase() === excludedName) {
+        errors.push(excludedName + " is not a valid package name");
+      }
+    });
+    if (builtins.includes(name.toLowerCase())) {
+      warnings.push(name + " is a core module name");
+    }
+    if (name.length > 214) {
+      warnings.push("name can no longer contain more than 214 characters");
+    }
+    if (name.toLowerCase() !== name) {
+      warnings.push("name can no longer contain capital letters");
+    }
+    if (/[~'!()*]/.test(name.split("/").slice(-1)[0])) {
+      warnings.push(`name can no longer contain special characters ("~'!()*")`);
+    }
+    if (encodeURIComponent(name) !== name) {
+      var nameMatch = name.match(scopedPackagePattern);
+      if (nameMatch) {
+        var user = nameMatch[1];
+        var pkg = nameMatch[2];
+        if (pkg.startsWith(".")) {
+          errors.push("name cannot start with a period");
+        }
+        if (encodeURIComponent(user) === user && encodeURIComponent(pkg) === pkg) {
+          return done(warnings, errors);
+        }
+      }
+      errors.push("name can only contain URL-friendly characters");
+    }
+    return done(warnings, errors);
+  }
+  var done = function(warnings, errors) {
+    var result = {
+      validForNewPackages: errors.length === 0 && warnings.length === 0,
+      validForOldPackages: errors.length === 0,
+      warnings,
+      errors
+    };
+    if (!result.warnings.length) {
+      delete result.warnings;
+    }
+    if (!result.errors.length) {
+      delete result.errors;
+    }
+    return result;
+  };
+  module.exports = validate;
+});
+
+// ../../node_modules/.bun/proc-log@6.1.0/node_modules/proc-log/lib/index.js
+var require_lib3 = __commonJS((exports, module) => {
+  var META = Symbol("proc-log.meta");
+  module.exports = {
+    META,
+    output: {
+      LEVELS: [
+        "standard",
+        "error",
+        "buffer",
+        "flush"
+      ],
+      KEYS: {
+        standard: "standard",
+        error: "error",
+        buffer: "buffer",
+        flush: "flush"
+      },
+      standard: function(...args) {
+        return process.emit("output", "standard", ...args);
+      },
+      error: function(...args) {
+        return process.emit("output", "error", ...args);
+      },
+      buffer: function(...args) {
+        return process.emit("output", "buffer", ...args);
+      },
+      flush: function(...args) {
+        return process.emit("output", "flush", ...args);
+      }
+    },
+    log: {
+      LEVELS: [
+        "notice",
+        "error",
+        "warn",
+        "info",
+        "verbose",
+        "http",
+        "silly",
+        "timing",
+        "pause",
+        "resume"
+      ],
+      KEYS: {
+        notice: "notice",
+        error: "error",
+        warn: "warn",
+        info: "info",
+        verbose: "verbose",
+        http: "http",
+        silly: "silly",
+        timing: "timing",
+        pause: "pause",
+        resume: "resume"
+      },
+      error: function(...args) {
+        return process.emit("log", "error", ...args);
+      },
+      notice: function(...args) {
+        return process.emit("log", "notice", ...args);
+      },
+      warn: function(...args) {
+        return process.emit("log", "warn", ...args);
+      },
+      info: function(...args) {
+        return process.emit("log", "info", ...args);
+      },
+      verbose: function(...args) {
+        return process.emit("log", "verbose", ...args);
+      },
+      http: function(...args) {
+        return process.emit("log", "http", ...args);
+      },
+      silly: function(...args) {
+        return process.emit("log", "silly", ...args);
+      },
+      timing: function(...args) {
+        return process.emit("log", "timing", ...args);
+      },
+      pause: function() {
+        return process.emit("log", "pause");
+      },
+      resume: function() {
+        return process.emit("log", "resume");
+      }
+    },
+    time: {
+      LEVELS: [
+        "start",
+        "end"
+      ],
+      KEYS: {
+        start: "start",
+        end: "end"
+      },
+      start: function(name, fn) {
+        process.emit("time", "start", name);
+        function end() {
+          return process.emit("time", "end", name);
+        }
+        if (typeof fn === "function") {
+          const res = fn();
+          if (res && res.finally) {
+            return res.finally(end);
+          }
+          end();
+          return res;
+        }
+        return end;
+      },
+      end: function(name) {
+        return process.emit("time", "end", name);
+      }
+    },
+    input: {
+      LEVELS: [
+        "start",
+        "end",
+        "read"
+      ],
+      KEYS: {
+        start: "start",
+        end: "end",
+        read: "read"
+      },
+      start: function(...args) {
+        let fn;
+        if (typeof args[0] === "function") {
+          fn = args.shift();
+        }
+        process.emit("input", "start", ...args);
+        function end() {
+          return process.emit("input", "end", ...args);
+        }
+        if (typeof fn === "function") {
+          const res = fn();
+          if (res && res.finally) {
+            return res.finally(end);
+          }
+          end();
+          return res;
+        }
+        return end;
+      },
+      end: function(...args) {
+        return process.emit("input", "end", ...args);
+      },
+      read: function(...args) {
+        let resolve, reject;
+        const promise = new Promise((_resolve, _reject) => {
+          resolve = _resolve;
+          reject = _reject;
+        });
+        process.emit("input", "read", resolve, reject, ...args);
+        return promise;
+      }
+    }
+  };
+});
+
+// ../../node_modules/.bun/npm-package-arg@13.0.2/node_modules/npm-package-arg/lib/npa.js
+var require_npa = __commonJS((exports, module) => {
+  var isWindows = process.platform === "win32";
+  var { URL: URL2 } = __require("url");
+  var path = isWindows ? __require("path/win32") : __require("path");
+  var { homedir } = __require("os");
+  var HostedGit = require_lib();
+  var semver = require_semver2();
+  var validatePackageName = require_lib2();
+  var { log } = require_lib3();
+  var hasSlashes = isWindows ? /\\|[/]/ : /[/]/;
+  var isURL = /^(?:git[+])?[a-z]+:/i;
+  var isGit = /^[^@]+@[^:.]+\.[^:]+:.+$/i;
+  var isFileType = /[.](?:tgz|tar\.gz|tar)$/i;
+  var isPortNumber = /:[0-9]+(\/|$)/i;
+  var isWindowsFile = /^(?:[.]|~[/]|[/\\]|[a-zA-Z]:)/;
+  var isPosixFile = /^(?:[.]|~[/]|[/]|[a-zA-Z]:)/;
+  var defaultRegistry = "https://registry.npmjs.org";
+  function npa(arg, where) {
+    let name;
+    let spec;
+    if (typeof arg === "object") {
+      if (arg instanceof Result && (!where || where === arg.where)) {
+        return arg;
+      } else if (arg.name && arg.rawSpec) {
+        return npa.resolve(arg.name, arg.rawSpec, where || arg.where);
+      } else {
+        return npa(arg.raw, where || arg.where);
+      }
+    }
+    const nameEndsAt = arg.indexOf("@", 1);
+    const namePart = nameEndsAt > 0 ? arg.slice(0, nameEndsAt) : arg;
+    if (isURL.test(arg)) {
+      spec = arg;
+    } else if (isGit.test(arg)) {
+      spec = `git+ssh://${arg}`;
+    } else if (!namePart.startsWith("@") && (hasSlashes.test(namePart) || isFileType.test(namePart))) {
+      spec = arg;
+    } else if (nameEndsAt > 0) {
+      name = namePart;
+      spec = arg.slice(nameEndsAt + 1) || "*";
+    } else {
+      const valid = validatePackageName(arg);
+      if (valid.validForOldPackages) {
+        name = arg;
+        spec = "*";
+      } else {
+        spec = arg;
+      }
+    }
+    return resolve(name, spec, where, arg);
+  }
+  function isFileSpec(spec) {
+    if (!spec) {
+      return false;
+    }
+    if (spec.toLowerCase().startsWith("file:")) {
+      return true;
+    }
+    if (isWindows) {
+      return isWindowsFile.test(spec);
+    }
+    return isPosixFile.test(spec);
+  }
+  function isAliasSpec(spec) {
+    if (!spec) {
+      return false;
+    }
+    return spec.toLowerCase().startsWith("npm:");
+  }
+  function resolve(name, spec, where, arg) {
+    const res = new Result({
+      raw: arg,
+      name,
+      rawSpec: spec,
+      fromArgument: arg != null
+    });
+    if (name) {
+      res.name = name;
+    }
+    if (!where) {
+      where = process.cwd();
+    }
+    if (isFileSpec(spec)) {
+      return fromFile(res, where);
+    } else if (isAliasSpec(spec)) {
+      return fromAlias(res, where);
+    }
+    const hosted = HostedGit.fromUrl(spec, {
+      noGitPlus: true,
+      noCommittish: true
+    });
+    if (hosted) {
+      return fromHostedGit(res, hosted);
+    } else if (spec && isURL.test(spec)) {
+      return fromURL(res);
+    } else if (spec && (hasSlashes.test(spec) || isFileType.test(spec))) {
+      return fromFile(res, where);
+    } else {
+      return fromRegistry(res);
+    }
+  }
+  function toPurl(arg, reg = defaultRegistry) {
+    const res = npa(arg);
+    if (res.type !== "version") {
+      throw invalidPurlType(res.type, res.raw);
+    }
+    let purl = "pkg:npm/" + res.name.replace(/^@/, "%40") + "@" + res.rawSpec;
+    if (reg !== defaultRegistry) {
+      purl += "?repository_url=" + reg;
+    }
+    return purl;
+  }
+  function invalidPackageName(name, valid, raw) {
+    const err = new Error(`Invalid package name "${name}" of package "${raw}": ${valid.errors.join("; ")}.`);
+    err.code = "EINVALIDPACKAGENAME";
+    return err;
+  }
+  function invalidTagName(name, raw) {
+    const err = new Error(`Invalid tag name "${name}" of package "${raw}": Tags may not have any characters that encodeURIComponent encodes.`);
+    err.code = "EINVALIDTAGNAME";
+    return err;
+  }
+  function invalidPurlType(type, raw) {
+    const err = new Error(`Invalid type "${type}" of package "${raw}": Purl can only be generated for "version" types.`);
+    err.code = "EINVALIDPURLTYPE";
+    return err;
+  }
+
+  class Result {
+    constructor(opts) {
+      this.type = opts.type;
+      this.registry = opts.registry;
+      this.where = opts.where;
+      if (opts.raw == null) {
+        this.raw = opts.name ? `${opts.name}@${opts.rawSpec}` : opts.rawSpec;
+      } else {
+        this.raw = opts.raw;
+      }
+      this.name = undefined;
+      this.escapedName = undefined;
+      this.scope = undefined;
+      this.rawSpec = opts.rawSpec || "";
+      this.saveSpec = opts.saveSpec;
+      this.fetchSpec = opts.fetchSpec;
+      if (opts.name) {
+        this.setName(opts.name);
+      }
+      this.gitRange = opts.gitRange;
+      this.gitCommittish = opts.gitCommittish;
+      this.gitSubdir = opts.gitSubdir;
+      this.hosted = opts.hosted;
+    }
+    setName(name) {
+      const valid = validatePackageName(name);
+      if (!valid.validForOldPackages) {
+        throw invalidPackageName(name, valid, this.raw);
+      }
+      this.name = name;
+      this.scope = name[0] === "@" ? name.slice(0, name.indexOf("/")) : undefined;
+      this.escapedName = name.replace("/", "%2f");
+      return this;
+    }
+    toString() {
+      const full = [];
+      if (this.name != null && this.name !== "") {
+        full.push(this.name);
+      }
+      const spec = this.saveSpec || this.fetchSpec || this.rawSpec;
+      if (spec != null && spec !== "") {
+        full.push(spec);
+      }
+      return full.length ? full.join("@") : this.raw;
+    }
+    toJSON() {
+      const result = Object.assign({}, this);
+      delete result.hosted;
+      return result;
+    }
+  }
+  function setGitAttrs(res, committish) {
+    if (!committish) {
+      res.gitCommittish = null;
+      return;
+    }
+    for (const part of committish.split("::")) {
+      if (!part.includes(":")) {
+        if (res.gitRange) {
+          throw new Error("cannot override existing semver range with a committish");
+        }
+        if (res.gitCommittish) {
+          throw new Error("cannot override existing committish with a second committish");
+        }
+        res.gitCommittish = part;
+        continue;
+      }
+      const [name, value] = part.split(":");
+      if (name === "semver") {
+        if (res.gitCommittish) {
+          throw new Error("cannot override existing committish with a semver range");
+        }
+        if (res.gitRange) {
+          throw new Error("cannot override existing semver range with a second semver range");
+        }
+        res.gitRange = decodeURIComponent(value);
+        continue;
+      }
+      if (name === "path") {
+        if (res.gitSubdir) {
+          throw new Error("cannot override existing path with a second path");
+        }
+        res.gitSubdir = `/${value}`;
+        continue;
+      }
+      log.warn("npm-package-arg", `ignoring unknown key "${name}"`);
+    }
+  }
+  var encodedPathChars = new Map([
+    ["\x00", "%00"],
+    ["\t", "%09"],
+    [`
+`, "%0A"],
+    ["\r", "%0D"],
+    [" ", "%20"],
+    ['"', "%22"],
+    ["#", "%23"],
+    ["%", "%25"],
+    ["?", "%3F"],
+    ["[", "%5B"],
+    ["\\", isWindows ? "/" : "%5C"],
+    ["]", "%5D"],
+    ["^", "%5E"],
+    ["|", "%7C"],
+    ["~", "%7E"]
+  ]);
+  function pathToFileURL(str) {
+    let result = "";
+    for (let i = 0;i < str.length; i++) {
+      result = `${result}${encodedPathChars.get(str[i]) ?? str[i]}`;
+    }
+    if (result.startsWith("file:")) {
+      return result;
+    }
+    return `file:${result}`;
+  }
+  function fromFile(res, where) {
+    res.type = isFileType.test(res.rawSpec) ? "file" : "directory";
+    res.where = where;
+    let rawSpec = pathToFileURL(res.rawSpec);
+    if (rawSpec.startsWith("file:/")) {
+      if (/^file:\/\/[^/]/.test(rawSpec)) {
+        rawSpec = `file:/${rawSpec.slice(5)}`;
+      }
+      if (/^\/{1,3}\.\.?(\/|$)/.test(rawSpec.slice(5))) {
+        rawSpec = rawSpec.replace(/^file:\/{1,3}/, "file:");
+      }
+    }
+    let resolvedUrl;
+    let specUrl;
+    try {
+      resolvedUrl = new URL2(rawSpec, `${pathToFileURL(path.resolve(where))}/`);
+      specUrl = new URL2(rawSpec);
+    } catch (originalError) {
+      const er = new Error("Invalid file: URL, must comply with RFC 8089");
+      throw Object.assign(er, {
+        raw: res.rawSpec,
+        spec: res,
+        where,
+        originalError
+      });
+    }
+    let specPath = decodeURIComponent(specUrl.pathname);
+    let resolvedPath = decodeURIComponent(resolvedUrl.pathname);
+    if (isWindows) {
+      specPath = specPath.replace(/^\/+([a-z]:\/)/i, "$1");
+      resolvedPath = resolvedPath.replace(/^\/+([a-z]:\/)/i, "$1");
+    }
+    if (/^\/~(\/|$)/.test(specPath)) {
+      res.saveSpec = `file:${specPath.substr(1)}`;
+      resolvedPath = path.resolve(homedir(), specPath.substr(3));
+    } else if (!path.isAbsolute(rawSpec.slice(5))) {
+      res.saveSpec = `file:${path.relative(where, resolvedPath)}`;
+    } else {
+      res.saveSpec = `file:${path.resolve(resolvedPath)}`;
+    }
+    res.fetchSpec = path.resolve(where, resolvedPath);
+    res.saveSpec = res.saveSpec.split("\\").join("/");
+    if (res.saveSpec.startsWith("file://")) {
+      res.saveSpec = `file:/${res.saveSpec.slice(7)}`;
+    }
+    return res;
+  }
+  function fromHostedGit(res, hosted) {
+    res.type = "git";
+    res.hosted = hosted;
+    res.saveSpec = hosted.toString({ noGitPlus: false, noCommittish: false });
+    res.fetchSpec = hosted.getDefaultRepresentation() === "shortcut" ? null : hosted.toString();
+    setGitAttrs(res, hosted.committish);
+    return res;
+  }
+  function unsupportedURLType(protocol, spec) {
+    const err = new Error(`Unsupported URL Type "${protocol}": ${spec}`);
+    err.code = "EUNSUPPORTEDPROTOCOL";
+    return err;
+  }
+  function fromURL(res) {
+    let rawSpec = res.rawSpec;
+    res.saveSpec = rawSpec;
+    if (rawSpec.startsWith("git+ssh:")) {
+      const matched = rawSpec.match(/^git\+ssh:\/\/([^:#]+:[^#]+(?:\.git)?)(?:#(.*))?$/i);
+      if (matched && !matched[1].match(isPortNumber)) {
+        res.type = "git";
+        setGitAttrs(res, matched[2]);
+        res.fetchSpec = matched[1];
+        return res;
+      }
+    } else if (rawSpec.startsWith("git+file://")) {
+      rawSpec = rawSpec.replace(/\\/g, "/");
+    }
+    const parsedUrl = new URL2(rawSpec);
+    switch (parsedUrl.protocol) {
+      case "git:":
+      case "git+http:":
+      case "git+https:":
+      case "git+rsync:":
+      case "git+ftp:":
+      case "git+file:":
+      case "git+ssh:":
+        res.type = "git";
+        setGitAttrs(res, parsedUrl.hash.slice(1));
+        if (parsedUrl.protocol === "git+file:" && /^git\+file:\/\/[a-z]:/i.test(rawSpec)) {
+          res.fetchSpec = `git+file://${parsedUrl.host.toLowerCase()}:${parsedUrl.pathname}`;
+        } else {
+          parsedUrl.hash = "";
+          res.fetchSpec = parsedUrl.toString();
+        }
+        if (res.fetchSpec.startsWith("git+")) {
+          res.fetchSpec = res.fetchSpec.slice(4);
+        }
+        break;
+      case "http:":
+      case "https:":
+        res.type = "remote";
+        res.fetchSpec = res.saveSpec;
+        break;
+      default:
+        throw unsupportedURLType(parsedUrl.protocol, rawSpec);
+    }
+    return res;
+  }
+  function fromAlias(res, where) {
+    const subSpec = npa(res.rawSpec.substr(4), where);
+    if (subSpec.type === "alias") {
+      throw new Error("nested aliases not supported");
+    }
+    if (!subSpec.registry) {
+      throw new Error("aliases only work for registry deps");
+    }
+    if (!subSpec.name) {
+      throw new Error("aliases must have a name");
+    }
+    res.subSpec = subSpec;
+    res.registry = true;
+    res.type = "alias";
+    res.saveSpec = null;
+    res.fetchSpec = null;
+    return res;
+  }
+  function fromRegistry(res) {
+    res.registry = true;
+    const spec = res.rawSpec.trim();
+    res.saveSpec = null;
+    res.fetchSpec = spec;
+    const version = semver.valid(spec, true);
+    const range = semver.validRange(spec, true);
+    if (version) {
+      res.type = "version";
+    } else if (range) {
+      res.type = "range";
+    } else {
+      if (encodeURIComponent(spec) !== spec) {
+        throw invalidTagName(spec, res.raw);
+      }
+      res.type = "tag";
+    }
+    return res;
+  }
+  module.exports = npa;
+  module.exports.resolve = resolve;
+  module.exports.toPurl = toPurl;
+  module.exports.Result = Result;
+});
+
+// ../wp-typia-project-tools/src/runtime/create-template-validation.ts
+import path2 from "path";
+
+// ../wp-typia-project-tools/src/runtime/template-source-locators.ts
+var import_npm_package_arg = __toESM(require_npa(), 1);
+import path from "path";
+function isTemplatePathLocator(templateId) {
+  return path.isAbsolute(templateId) || templateId.startsWith("./") || templateId.startsWith("../");
+}
+function parseGitHubTemplateLocator(templateId) {
+  if (!templateId.startsWith("github:")) {
+    return null;
+  }
+  const [locatorBody, refSegment] = templateId.slice("github:".length).split("#", 2);
+  const segments = locatorBody.split("/").filter(Boolean);
+  if (segments.length < 3) {
+    throw new Error(`GitHub template locators must look like github:owner/repo/path[#ref]. Received: ${templateId}`);
+  }
+  const [owner, repo, ...sourcePathSegments] = segments;
+  return {
+    owner,
+    repo,
+    ref: refSegment ?? null,
+    sourcePath: sourcePathSegments.join("/")
+  };
+}
+function parseNpmTemplateLocator(templateId) {
+  if (isBuiltInTemplateId(templateId) || isTemplatePathLocator(templateId) || templateId.startsWith("github:")) {
+    return null;
+  }
+  try {
+    const parsed = import_npm_package_arg.default(templateId);
+    if (!parsed.registry || !parsed.name) {
+      return null;
+    }
+    const parsedWithRawSpec = parsed;
+    const rawSpec = typeof parsedWithRawSpec.rawSpec === "string" ? parsedWithRawSpec.rawSpec : "";
+    return {
+      fetchSpec: typeof parsed.fetchSpec === "string" ? parsed.fetchSpec : "",
+      name: parsed.name,
+      raw: templateId,
+      rawSpec,
+      type: parsed.type
+    };
+  } catch {
+    return null;
+  }
+}
+function parseTemplateLocator(templateId) {
+  if (isRemovedBuiltInTemplateId(templateId)) {
+    throw new Error(getRemovedBuiltInTemplateMessage(templateId));
+  }
+  const githubLocator = parseGitHubTemplateLocator(templateId);
+  if (githubLocator) {
+    return { kind: "github", locator: githubLocator };
+  }
+  if (isTemplatePathLocator(templateId)) {
+    return { kind: "path", templatePath: templateId };
+  }
+  const npmLocator = parseNpmTemplateLocator(templateId);
+  if (npmLocator) {
+    return { kind: "npm", locator: npmLocator };
+  }
+  throw new Error(`Unknown template "${templateId}". Expected one of: ${BUILTIN_TEMPLATE_IDS.join(", ")}, a local path, github:owner/repo/path[#ref], or an npm package spec.`);
+}
+
+// ../wp-typia-project-tools/src/runtime/create-template-validation.ts
+var CREATE_TEMPLATE_SELECTION_HINT = `--template <${[
+  ...TEMPLATE_IDS,
+  OFFICIAL_WORKSPACE_TEMPLATE_ALIAS
+].join("|")}|./path|github:owner/repo/path[#ref]|npm-package>`;
+var TEMPLATE_SUGGESTION_IDS = [
+  ...TEMPLATE_IDS,
+  OFFICIAL_WORKSPACE_TEMPLATE_ALIAS
+];
+var USER_FACING_TEMPLATE_IDS = [
+  ...TEMPLATE_IDS,
+  OFFICIAL_WORKSPACE_TEMPLATE_ALIAS
+];
+function normalizeCreateTemplateSelection(templateId) {
+  return templateId === OFFICIAL_WORKSPACE_TEMPLATE_ALIAS ? OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE : templateId;
+}
+function looksLikeWindowsAbsoluteTemplatePath(templateId) {
+  return /^[a-z]:[\\/]/iu.test(templateId) || /^\\\\[^\\]+\\[^\\]+/u.test(templateId);
+}
+function looksLikeExplicitNonNpmExternalTemplateLocator(templateId) {
+  return path2.isAbsolute(templateId) || looksLikeWindowsAbsoluteTemplatePath(templateId) || templateId.startsWith("./") || templateId.startsWith(".\\") || templateId.startsWith("../") || templateId.startsWith("..\\") || templateId.startsWith("@") || templateId.startsWith("github:") || templateId.includes("/") || templateId.includes("\\");
+}
+function looksLikeExplicitCreateExternalTemplateLocator(templateId) {
+  return looksLikeExplicitNonNpmExternalTemplateLocator(templateId) || parseNpmTemplateLocator(templateId) !== null;
+}
+function getEditDistance(left, right) {
+  const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  const current = new Array(right.length + 1);
+  for (let leftIndex = 0;leftIndex < left.length; leftIndex += 1) {
+    current[0] = leftIndex + 1;
+    for (let rightIndex = 0;rightIndex < right.length; rightIndex += 1) {
+      const substitutionCost = left[leftIndex] === right[rightIndex] ? 0 : 1;
+      current[rightIndex + 1] = Math.min(current[rightIndex] + 1, previous[rightIndex + 1] + 1, previous[rightIndex] + substitutionCost);
+    }
+    for (let index = 0;index < current.length; index += 1) {
+      previous[index] = current[index];
+    }
+  }
+  return previous[right.length];
+}
+function findMistypedBuiltInTemplateSuggestion(templateId) {
+  const normalizedTemplateId = templateId.trim().toLowerCase();
+  if (normalizedTemplateId.length === 0 || looksLikeExplicitNonNpmExternalTemplateLocator(normalizedTemplateId)) {
+    return null;
+  }
+  let bestCandidate = null;
+  for (const candidateId of TEMPLATE_SUGGESTION_IDS) {
+    const distance = getEditDistance(normalizedTemplateId, candidateId);
+    if (bestCandidate === null || distance < bestCandidate.distance) {
+      bestCandidate = {
+        distance,
+        id: candidateId
+      };
+    }
+  }
+  return bestCandidate && bestCandidate.distance <= 2 ? bestCandidate.id : null;
+}
+function getMistypedBuiltInTemplateMessage(templateId) {
+  const suggestion = findMistypedBuiltInTemplateSuggestion(templateId);
+  if (!suggestion) {
+    return null;
+  }
+  const suggestionDescription = suggestion === OFFICIAL_WORKSPACE_TEMPLATE_ALIAS ? "official workspace scaffold" : "built-in scaffold";
+  return `Unknown template "${templateId}". Did you mean "${suggestion}"? Use \`--template ${suggestion}\` for the ${suggestionDescription}, or pass a local path, \`github:owner/repo/path[#ref]\`, or an npm package spec for an external template.`;
+}
+function getUnknownTemplateMessage(templateId) {
+  return [
+    `Unknown template "${templateId}". Expected one of: ${USER_FACING_TEMPLATE_IDS.join(", ")}.`,
+    "Run `wp-typia templates list` to inspect available templates.",
+    "Pass an explicit external template locator such as `./path`, `github:owner/repo/path[#ref]`, or `@scope/template` for custom templates."
+  ].join(" ");
+}
+function validateExplicitCreateTemplateId(templateId) {
+  const normalizedTemplateId = normalizeCreateTemplateSelection(templateId);
+  if (isRemovedBuiltInTemplateId(templateId)) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getRemovedBuiltInTemplateMessage(templateId));
+  }
+  if (normalizedTemplateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+    return normalizedTemplateId;
+  }
+  if (isBuiltInTemplateId(normalizedTemplateId)) {
+    return getTemplateById(normalizedTemplateId).id;
+  }
+  const mistypedBuiltInTemplateMessage = getMistypedBuiltInTemplateMessage(templateId);
+  if (mistypedBuiltInTemplateMessage) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, mistypedBuiltInTemplateMessage);
+  }
+  if (!looksLikeExplicitCreateExternalTemplateLocator(normalizedTemplateId)) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getUnknownTemplateMessage(templateId));
+  }
+  return normalizedTemplateId;
+}
+
+export { require_semver2 as require_semver, parseTemplateLocator, CREATE_TEMPLATE_SELECTION_HINT, validateExplicitCreateTemplateId };
+
+//# debugId=BE9DD1EB4BD209FD64756E2164756E21