@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/dist/{cli-cd0hv9nh.js → cli-j67mh2vg.js}

@@ -14,11 +14,11 @@ async function createRuntimeProvider(kind, target = {}) {
       return new StaticRuntimeProvider;
     }
     case "docker": {
-      const { DockerRuntimeProvider } = await import("./docker-f503k9p0.js");
+      const { DockerRuntimeProvider } = await import("./docker-b1e4cqab.js");
       return new DockerRuntimeProvider;
     }
     case "e2b": {
-      const { E2BRuntimeProvider } = await import("./e2b-66xra4az.js");
+      const { E2BRuntimeProvider } = await import("./e2b-bbt8ey45.js");
       return new E2BRuntimeProvider(target);
     }
     case "k8s":

package/dist/cli-jta2eyzc.js

@@ -0,0 +1,619 @@
+import {
+  __commonJS
+} from "./cli-bc05qbss.js";
+
+// node_modules/lru-cache/dist/commonjs/index.min.js
+var require_index_min = __commonJS(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LRUCache = undefined;
+  var x = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+  var U = new Set;
+  var R = typeof process == "object" && process ? process : {};
+  var I = (a, t, e, i) => {
+    typeof R.emitWarning == "function" ? R.emitWarning(a, t, e, i) : console.error(`[${e}] ${t}: ${a}`);
+  };
+  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 a = R.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+      a && (a = 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 G = (a) => !U.has(a);
+  var H = Symbol("type");
+  var y = (a) => a && a === Math.floor(a) && a > 0 && isFinite(a);
+  var M = (a) => y(a) ? a <= Math.pow(2, 8) ? Uint8Array : a <= Math.pow(2, 16) ? Uint16Array : a <= Math.pow(2, 32) ? Uint32Array : a <= Number.MAX_SAFE_INTEGER ? z : null : null;
+  var z = class extends Array {
+    constructor(t) {
+      super(t), this.fill(0);
+    }
+  };
+  var W = class a {
+    heap;
+    length;
+    static #o = false;
+    static create(t) {
+      let e = M(t);
+      if (!e)
+        return [];
+      a.#o = true;
+      let i = new a(t, e);
+      return a.#o = false, i;
+    }
+    constructor(t, e) {
+      if (!a.#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 a {
+    #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, h) => t.#G(e, i, s, h), 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: h, updateAgeOnGet: n, updateAgeOnHas: o, allowStale: r, dispose: f, onInsert: m, disposeAfter: c, noDisposeOnSet: d, noUpdateTTL: g, maxSize: A = 0, maxEntrySize: p = 0, sizeCalculation: _, fetchMethod: l, memoMethod: w, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: S, allowStaleOnFetchRejection: u, allowStaleOnFetchAbort: T, ignoreFetchAbort: F, perf: v } = t;
+      if (v !== undefined && typeof v?.now != "function")
+        throw new TypeError("perf option must have a now() method if specified");
+      if (this.#m = v ?? x, 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 (w !== undefined && typeof w != "function")
+        throw new TypeError("memoMethod must be a function if defined");
+      if (this.#U = w, 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 f == "function" && (this.#w = f), typeof m == "function" && (this.#C = m), typeof c == "function" ? (this.#S = c, 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 = !!S, this.updateAgeOnGet = !!n, this.updateAgeOnHas = !!o, this.ttlResolution = y(s) || s === 0 ? s : 1, this.ttlAutopurge = !!h, this.ttl = i || 0, this.ttl) {
+        if (!y(this.ttl))
+          throw new TypeError("ttl must be a positive integer if specified");
+        this.#j();
+      }
+      if (this.#o === 0 && this.ttl === 0 && this.#c === 0)
+        throw new TypeError("At least one of max, maxSize, or ttl is required");
+      if (!this.ttlAutopurge && !this.#o && !this.#c) {
+        let E = "LRU_CACHE_UNBOUNDED";
+        G(E) && (U.add(E), I("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, a));
+      }
+    }
+    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 = (n, o, r = this.#m.now()) => {
+        if (e[n] = o !== 0 ? r : 0, t[n] = o, i?.[n] && (clearTimeout(i[n]), i[n] = undefined), o !== 0 && i) {
+          let f = setTimeout(() => {
+            this.#p(n) && this.#E(this.#i[n], "expire");
+          }, o + 1);
+          f.unref && f.unref(), i[n] = f;
+        }
+      }, this.#R = (n) => {
+        e[n] = t[n] !== 0 ? this.#m.now() : 0;
+      }, this.#z = (n, o) => {
+        if (t[o]) {
+          let r = t[o], f = e[o];
+          if (!r || !f)
+            return;
+          n.ttl = r, n.start = f, n.now = s || h();
+          let m = n.now - f;
+          n.remainingTTL = r - m;
+        }
+      };
+      let s = 0, h = () => {
+        let n = this.#m.now();
+        if (this.ttlResolution > 0) {
+          s = n;
+          let o = setTimeout(() => s = 0, this.ttlResolution);
+          o.unref && o.unref();
+        }
+        return n;
+      };
+      this.getRemainingTTL = (n) => {
+        let o = this.#s.get(n);
+        if (o === undefined)
+          return 0;
+        let r = t[o], f = e[o];
+        if (!r || !f)
+          return 1 / 0;
+        let m = (s || h()) - f;
+        return r - m;
+      }, this.#p = (n) => {
+        let o = e[n], r = t[n];
+        return !!r && !!o && (s || h()) - o > r;
+      };
+    }
+    #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, h) => {
+        if (this.#e(i))
+          return 0;
+        if (!y(s))
+          if (h) {
+            if (typeof h != "function")
+              throw new TypeError("sizeCalculation must be a function");
+            if (s = h(i, e), !y(s))
+              throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+          } else
+            throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+        return s;
+      }, this.#M = (e, i, s) => {
+        if (t[e] = i, this.#c) {
+          let h = this.#c - t[e];
+          for (;this.#_ > h; )
+            this.#x(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], h = this.#e(s) ? s.__staleWhileFetching : s;
+        if (h !== undefined && t(h, 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], h = this.#e(s) ? s.__staleWhileFetching : s;
+        h !== undefined && t.call(e, h, this.#i[i], this);
+      }
+    }
+    rforEach(t, e = this) {
+      for (let i of this.#O()) {
+        let s = this.#t[i], h = this.#e(s) ? s.__staleWhileFetching : s;
+        h !== undefined && t.call(e, h, 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 h = { value: s };
+      if (this.#d && this.#A) {
+        let n = this.#d[e], o = this.#A[e];
+        if (n && o) {
+          let r = n - (this.#m.now() - o);
+          h.ttl = r, h.start = Date.now();
+        }
+      }
+      return this.#y && (h.size = this.#y[e]), h;
+    }
+    dump() {
+      let t = [];
+      for (let e of this.#F({ allowStale: true })) {
+        let i = this.#i[e], s = this.#t[e], h = this.#e(s) ? s.__staleWhileFetching : s;
+        if (h === undefined || i === undefined)
+          continue;
+        let n = { value: h };
+        if (this.#d && this.#A) {
+          n.ttl = this.#d[e];
+          let o = this.#m.now() - this.#A[e];
+          n.start = Math.floor(Date.now() - o);
+        }
+        this.#y && (n.size = this.#y[e]), t.unshift([i, n]);
+      }
+      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: h, noDisposeOnSet: n = this.noDisposeOnSet, sizeCalculation: o = this.sizeCalculation, status: r } = i, { noUpdateTTL: f = this.noUpdateTTL } = i, m = this.#P(t, e, i.size || 0, o);
+      if (this.maxEntrySize && m > this.maxEntrySize)
+        return r && (r.set = "miss", r.maxEntrySizeExceeded = true), this.#E(t, "set"), this;
+      let c = this.#n === 0 ? undefined : this.#s.get(t);
+      if (c === undefined)
+        c = this.#n === 0 ? this.#h : this.#b.length !== 0 ? this.#b.pop() : this.#n === this.#o ? this.#x(false) : this.#n, this.#i[c] = t, this.#t[c] = e, this.#s.set(t, c), this.#a[this.#h] = c, this.#u[c] = this.#h, this.#h = c, this.#n++, this.#M(c, m, r), r && (r.set = "add"), f = false, this.#I && this.#C?.(e, t, "add");
+      else {
+        this.#D(c);
+        let d = this.#t[c];
+        if (e !== d) {
+          if (this.#v && this.#e(d)) {
+            d.__abortController.abort(new Error("replaced"));
+            let { __staleWhileFetching: g } = d;
+            g !== undefined && !n && (this.#T && this.#w?.(g, t, "set"), this.#f && this.#r?.push([g, t, "set"]));
+          } else
+            n || (this.#T && this.#w?.(d, t, "set"), this.#f && this.#r?.push([d, t, "set"]));
+          if (this.#W(c), this.#M(c, m, r), this.#t[c] = 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 && (f || this.#N(c, s, h), r && this.#z(r, c)), !n && 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.#x(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);
+        }
+      }
+    }
+    #x(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, h = this.#s.get(t);
+      if (h !== undefined) {
+        let n = this.#t[h];
+        if (this.#e(n) && n.__staleWhileFetching === undefined)
+          return false;
+        if (this.#p(h))
+          s && (s.has = "stale", this.#z(s, h));
+        else
+          return i && this.#R(h), s && (s.has = "hit", this.#z(s, h)), true;
+      } else
+        s && (s.has = "miss");
+      return false;
+    }
+    peek(t, e = {}) {
+      let { allowStale: i = this.allowStale } = e, s = this.#s.get(t);
+      if (s === undefined || !i && this.#p(s))
+        return;
+      let h = this.#t[s];
+      return this.#e(h) ? h.__staleWhileFetching : h;
+    }
+    #G(t, e, i, s) {
+      let h = e === undefined ? undefined : this.#t[e];
+      if (this.#e(h))
+        return h;
+      let n = new C, { signal: o } = i;
+      o?.addEventListener("abort", () => n.abort(o.reason), { signal: n.signal });
+      let r = { signal: n.signal, options: i, context: s }, f = (p, _ = false) => {
+        let { aborted: l } = n.signal, w = i.ignoreFetchAbort && p !== undefined, b = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && p !== undefined);
+        if (i.status && (l && !_ ? (i.status.fetchAborted = true, i.status.fetchError = n.signal.reason, w && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), l && !w && !_)
+          return c(n.signal.reason, b);
+        let S = g, u = this.#t[e];
+        return (u === g || w && _ && u === undefined) && (p === undefined ? S.__staleWhileFetching !== undefined ? this.#t[e] = S.__staleWhileFetching : this.#E(t, "fetch") : (i.status && (i.status.fetchUpdated = true), this.set(t, p, r.options))), p;
+      }, m = (p) => (i.status && (i.status.fetchRejected = true, i.status.fetchError = p), c(p, false)), c = (p, _) => {
+        let { aborted: l } = n.signal, w = l && i.allowStaleOnFetchAbort, b = w || i.allowStaleOnFetchRejection, S = b || i.noDeleteOnFetchRejection, u = g;
+        if (this.#t[e] === g && (!S || !_ && u.__staleWhileFetching === undefined ? this.#E(t, "fetch") : w || (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, h, r);
+        l && l instanceof Promise && l.then((w) => p(w === undefined ? undefined : w), _), n.signal.addEventListener("abort", () => {
+          (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (p(undefined), i.allowStaleOnFetchAbort && (p = (w) => f(w, true)));
+        });
+      };
+      i.status && (i.status.fetchDispatched = true);
+      let g = new Promise(d).then(f, m), A = Object.assign(g, { __abortController: n, __staleWhileFetching: h, __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: h = this.noDeleteOnStaleGet, ttl: n = this.ttl, noDisposeOnSet: o = this.noDisposeOnSet, size: r = 0, sizeCalculation: f = this.sizeCalculation, noUpdateTTL: m = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: g = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: p, forceRefresh: _ = false, status: l, signal: w } = e;
+      if (!this.#v)
+        return l && (l.fetch = "get"), this.get(t, { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: h, status: l });
+      let b = { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: h, ttl: n, noDisposeOnSet: o, size: r, sizeCalculation: f, noUpdateTTL: m, noDeleteOnFetchRejection: c, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: g, status: l, signal: w }, S = this.#s.get(t);
+      if (S === undefined) {
+        l && (l.fetch = "miss");
+        let u = this.#G(t, S, b, p);
+        return u.__returned = u;
+      } else {
+        let u = this.#t[S];
+        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(S);
+        if (!_ && !T)
+          return l && (l.fetch = "hit"), this.#D(S), s && this.#R(S), l && this.#z(l, S), u;
+        let F = this.#G(t, S, 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: h, ...n } = e, o = this.get(t, n);
+      if (!h && o !== undefined)
+        return o;
+      let r = i(t, o, { options: n, context: s });
+      return this.set(t, r, n), r;
+    }
+    get(t, e = {}) {
+      let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: h = this.noDeleteOnStaleGet, status: n } = e, o = this.#s.get(t);
+      if (o !== undefined) {
+        let r = this.#t[o], f = this.#e(r);
+        return n && this.#z(n, o), this.#p(o) ? (n && (n.get = "stale"), f ? (n && i && r.__staleWhileFetching !== undefined && (n.returnedStale = true), i ? r.__staleWhileFetching : undefined) : (h || this.#E(t, "expire"), n && i && (n.returnedStale = true), i ? r : undefined)) : (n && (n.get = "hit"), f ? r.__staleWhileFetching : (this.#D(o), s && this.#R(o), r));
+      } else
+        n && (n.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 h = this.#t[s];
+            if (this.#e(h) ? h.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(h, t, e), this.#f && this.#r?.push([h, 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 n = this.#u[s];
+              this.#a[n] = this.#a[s];
+              let o = this.#a[s];
+              this.#u[o] = this.#u[s];
+            }
+            this.#n--, this.#b.push(s);
+          }
+      }
+      if (this.#f && this.#r?.length) {
+        let s = this.#r, h;
+        for (;h = s?.shift(); )
+          this.#S?.(...h);
+      }
+      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;
+});
+
+export { require_index_min };