@scalar/agent-chat 0.2.1 → 0.2.2

package/dist/node_modules/.pnpm/@vue_reactivity@3.5.26/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js

@@ -0,0 +1,1185 @@
+import { isFunction as B, EMPTY_OBJ as Qe, hasChanged as T, isObject as P, isArray as D, extend as de, toRawType as Oe, hasOwn as se, isSymbol as U, makeMap as qe, isIntegerKey as re, capitalize as Xe, isMap as L, def as Ze, remove as ke, isSet as et, isPlainObject as tt, NOOP as st } from "../../../../../@vue_shared@3.5.26/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+/**
+* @vue/reactivity v3.5.26
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+function E(e, ...t) {
+  console.warn(`[Vue warn] ${e}`, ...t);
+}
+let v;
+class it {
+  constructor(t = !1) {
+    this.detached = t, this._active = !0, this._on = 0, this.effects = [], this.cleanups = [], this._isPaused = !1, this.parent = v, !t && v && (this.index = (v.scopes || (v.scopes = [])).push(
+      this
+    ) - 1);
+  }
+  get active() {
+    return this._active;
+  }
+  pause() {
+    if (this._active) {
+      this._isPaused = !0;
+      let t, s;
+      if (this.scopes)
+        for (t = 0, s = this.scopes.length; t < s; t++)
+          this.scopes[t].pause();
+      for (t = 0, s = this.effects.length; t < s; t++)
+        this.effects[t].pause();
+    }
+  }
+  /**
+   * Resumes the effect scope, including all child scopes and effects.
+   */
+  resume() {
+    if (this._active && this._isPaused) {
+      this._isPaused = !1;
+      let t, s;
+      if (this.scopes)
+        for (t = 0, s = this.scopes.length; t < s; t++)
+          this.scopes[t].resume();
+      for (t = 0, s = this.effects.length; t < s; t++)
+        this.effects[t].resume();
+    }
+  }
+  run(t) {
+    if (this._active) {
+      const s = v;
+      try {
+        return v = this, t();
+      } finally {
+        v = s;
+      }
+    } else process.env.NODE_ENV !== "production" && E("cannot run an inactive effect scope.");
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  on() {
+    ++this._on === 1 && (this.prevScope = v, v = this);
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  off() {
+    this._on > 0 && --this._on === 0 && (v = this.prevScope, this.prevScope = void 0);
+  }
+  stop(t) {
+    if (this._active) {
+      this._active = !1;
+      let s, n;
+      for (s = 0, n = this.effects.length; s < n; s++)
+        this.effects[s].stop();
+      for (this.effects.length = 0, s = 0, n = this.cleanups.length; s < n; s++)
+        this.cleanups[s]();
+      if (this.cleanups.length = 0, this.scopes) {
+        for (s = 0, n = this.scopes.length; s < n; s++)
+          this.scopes[s].stop(!0);
+        this.scopes.length = 0;
+      }
+      if (!this.detached && this.parent && !t) {
+        const i = this.parent.scopes.pop();
+        i && i !== this && (this.parent.scopes[this.index] = i, i.index = this.index);
+      }
+      this.parent = void 0;
+    }
+  }
+}
+function Pt(e) {
+  return new it(e);
+}
+function nt() {
+  return v;
+}
+function Ht(e, t = !1) {
+  v ? v.cleanups.push(e) : process.env.NODE_ENV !== "production" && !t && E(
+    "onScopeDispose() is called when there is no active effect scope to be associated with."
+  );
+}
+let u;
+const ue = /* @__PURE__ */ new WeakSet();
+class rt {
+  constructor(t) {
+    this.fn = t, this.deps = void 0, this.depsTail = void 0, this.flags = 5, this.next = void 0, this.cleanup = void 0, this.scheduler = void 0, v && v.active && v.effects.push(this);
+  }
+  pause() {
+    this.flags |= 64;
+  }
+  resume() {
+    this.flags & 64 && (this.flags &= -65, ue.has(this) && (ue.delete(this), this.trigger()));
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    this.flags & 2 && !(this.flags & 32) || this.flags & 8 || Ve(this);
+  }
+  run() {
+    if (!(this.flags & 1))
+      return this.fn();
+    this.flags |= 2, Ne(this), Ie(this);
+    const t = u, s = S;
+    u = this, S = !0;
+    try {
+      return this.fn();
+    } finally {
+      process.env.NODE_ENV !== "production" && u !== this && E(
+        "Active effect was not restored correctly - this is likely a Vue internal bug."
+      ), Me(this), u = t, S = s, this.flags &= -3;
+    }
+  }
+  stop() {
+    if (this.flags & 1) {
+      for (let t = this.deps; t; t = t.nextDep)
+        Se(t);
+      this.deps = this.depsTail = void 0, Ne(this), this.onStop && this.onStop(), this.flags &= -2;
+    }
+  }
+  trigger() {
+    this.flags & 64 ? ue.add(this) : this.scheduler ? this.scheduler() : this.runIfDirty();
+  }
+  /**
+   * @internal
+   */
+  runIfDirty() {
+    _e(this) && this.run();
+  }
+  get dirty() {
+    return _e(this);
+  }
+}
+let Te = 0, Y, z;
+function Ve(e, t = !1) {
+  if (e.flags |= 8, t) {
+    e.next = z, z = e;
+    return;
+  }
+  e.next = Y, Y = e;
+}
+function Ee() {
+  Te++;
+}
+function be() {
+  if (--Te > 0)
+    return;
+  if (z) {
+    let t = z;
+    for (z = void 0; t; ) {
+      const s = t.next;
+      t.next = void 0, t.flags &= -9, t = s;
+    }
+  }
+  let e;
+  for (; Y; ) {
+    let t = Y;
+    for (Y = void 0; t; ) {
+      const s = t.next;
+      if (t.next = void 0, t.flags &= -9, t.flags & 1)
+        try {
+          t.trigger();
+        } catch (n) {
+          e || (e = n);
+        }
+      t = s;
+    }
+  }
+  if (e) throw e;
+}
+function Ie(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    t.version = -1, t.prevActiveLink = t.dep.activeLink, t.dep.activeLink = t;
+}
+function Me(e) {
+  let t, s = e.depsTail, n = s;
+  for (; n; ) {
+    const i = n.prevDep;
+    n.version === -1 ? (n === s && (s = i), Se(n), ot(n)) : t = n, n.dep.activeLink = n.prevActiveLink, n.prevActiveLink = void 0, n = i;
+  }
+  e.deps = t, e.depsTail = s;
+}
+function _e(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    if (t.dep.version !== t.version || t.dep.computed && (Ae(t.dep.computed) || t.dep.version !== t.version))
+      return !0;
+  return !!e._dirty;
+}
+function Ae(e) {
+  if (e.flags & 4 && !(e.flags & 16) || (e.flags &= -17, e.globalVersion === F) || (e.globalVersion = F, !e.isSSR && e.flags & 128 && (!e.deps && !e._dirty || !_e(e))))
+    return;
+  e.flags |= 2;
+  const t = e.dep, s = u, n = S;
+  u = e, S = !0;
+  try {
+    Ie(e);
+    const i = e.fn(e._value);
+    (t.version === 0 || T(i, e._value)) && (e.flags |= 128, e._value = i, t.version++);
+  } catch (i) {
+    throw t.version++, i;
+  } finally {
+    u = s, S = n, Me(e), e.flags &= -3;
+  }
+}
+function Se(e, t = !1) {
+  const { dep: s, prevSub: n, nextSub: i } = e;
+  if (n && (n.nextSub = i, e.prevSub = void 0), i && (i.prevSub = n, e.nextSub = void 0), process.env.NODE_ENV !== "production" && s.subsHead === e && (s.subsHead = i), s.subs === e && (s.subs = n, !n && s.computed)) {
+    s.computed.flags &= -5;
+    for (let r = s.computed.deps; r; r = r.nextDep)
+      Se(r, !0);
+  }
+  !t && !--s.sc && s.map && s.map.delete(s.key);
+}
+function ot(e) {
+  const { prevDep: t, nextDep: s } = e;
+  t && (t.nextDep = s, e.prevDep = void 0), s && (s.prevDep = t, e.nextDep = void 0);
+}
+let S = !0;
+const Pe = [];
+function He() {
+  Pe.push(S), S = !1;
+}
+function Ke() {
+  const e = Pe.pop();
+  S = e === void 0 ? !0 : e;
+}
+function Ne(e) {
+  const { cleanup: t } = e;
+  if (e.cleanup = void 0, t) {
+    const s = u;
+    u = void 0;
+    try {
+      t();
+    } finally {
+      u = s;
+    }
+  }
+}
+let F = 0;
+class ct {
+  constructor(t, s) {
+    this.sub = t, this.dep = s, this.version = s.version, this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
+  }
+}
+class oe {
+  // TODO isolatedDeclarations "__v_skip"
+  constructor(t) {
+    this.computed = t, this.version = 0, this.activeLink = void 0, this.subs = void 0, this.map = void 0, this.key = void 0, this.sc = 0, this.__v_skip = !0, process.env.NODE_ENV !== "production" && (this.subsHead = void 0);
+  }
+  track(t) {
+    if (!u || !S || u === this.computed)
+      return;
+    let s = this.activeLink;
+    if (s === void 0 || s.sub !== u)
+      s = this.activeLink = new ct(u, this), u.deps ? (s.prevDep = u.depsTail, u.depsTail.nextDep = s, u.depsTail = s) : u.deps = u.depsTail = s, Le(s);
+    else if (s.version === -1 && (s.version = this.version, s.nextDep)) {
+      const n = s.nextDep;
+      n.prevDep = s.prevDep, s.prevDep && (s.prevDep.nextDep = n), s.prevDep = u.depsTail, s.nextDep = void 0, u.depsTail.nextDep = s, u.depsTail = s, u.deps === s && (u.deps = n);
+    }
+    return process.env.NODE_ENV !== "production" && u.onTrack && u.onTrack(
+      de(
+        {
+          effect: u
+        },
+        t
+      )
+    ), s;
+  }
+  trigger(t) {
+    this.version++, F++, this.notify(t);
+  }
+  notify(t) {
+    Ee();
+    try {
+      if (process.env.NODE_ENV !== "production")
+        for (let s = this.subsHead; s; s = s.nextSub)
+          s.sub.onTrigger && !(s.sub.flags & 8) && s.sub.onTrigger(
+            de(
+              {
+                effect: s.sub
+              },
+              t
+            )
+          );
+      for (let s = this.subs; s; s = s.prevSub)
+        s.sub.notify() && s.sub.dep.notify();
+    } finally {
+      be();
+    }
+  }
+}
+function Le(e) {
+  if (e.dep.sc++, e.sub.flags & 4) {
+    const t = e.dep.computed;
+    if (t && !e.dep.subs) {
+      t.flags |= 20;
+      for (let n = t.deps; n; n = n.nextDep)
+        Le(n);
+    }
+    const s = e.dep.subs;
+    s !== e && (e.prevSub = s, s && (s.nextSub = e)), process.env.NODE_ENV !== "production" && e.dep.subsHead === void 0 && (e.dep.subsHead = e), e.dep.subs = e;
+  }
+}
+const ie = /* @__PURE__ */ new WeakMap(), A = /* @__PURE__ */ Symbol(
+  process.env.NODE_ENV !== "production" ? "Object iterate" : ""
+), ve = /* @__PURE__ */ Symbol(
+  process.env.NODE_ENV !== "production" ? "Map keys iterate" : ""
+), G = /* @__PURE__ */ Symbol(
+  process.env.NODE_ENV !== "production" ? "Array iterate" : ""
+);
+function w(e, t, s) {
+  if (S && u) {
+    let n = ie.get(e);
+    n || ie.set(e, n = /* @__PURE__ */ new Map());
+    let i = n.get(s);
+    i || (n.set(s, i = new oe()), i.map = n, i.key = s), process.env.NODE_ENV !== "production" ? i.track({
+      target: e,
+      type: t,
+      key: s
+    }) : i.track();
+  }
+}
+function x(e, t, s, n, i, r) {
+  const o = ie.get(e);
+  if (!o) {
+    F++;
+    return;
+  }
+  const c = (a) => {
+    a && (process.env.NODE_ENV !== "production" ? a.trigger({
+      target: e,
+      type: t,
+      key: s,
+      newValue: n,
+      oldValue: i,
+      oldTarget: r
+    }) : a.trigger());
+  };
+  if (Ee(), t === "clear")
+    o.forEach(c);
+  else {
+    const a = D(e), p = a && re(s);
+    if (a && s === "length") {
+      const _ = Number(n);
+      o.forEach((f, d) => {
+        (d === "length" || d === G || !U(d) && d >= _) && c(f);
+      });
+    } else
+      switch ((s !== void 0 || o.has(void 0)) && c(o.get(s)), p && c(o.get(G)), t) {
+        case "add":
+          a ? p && c(o.get("length")) : (c(o.get(A)), L(e) && c(o.get(ve)));
+          break;
+        case "delete":
+          a || (c(o.get(A)), L(e) && c(o.get(ve)));
+          break;
+        case "set":
+          L(e) && c(o.get(A));
+          break;
+      }
+  }
+  be();
+}
+function at(e, t) {
+  const s = ie.get(e);
+  return s && s.get(t);
+}
+function K(e) {
+  const t = h(e);
+  return t === e ? t : (w(t, "iterate", G), b(e) ? t : t.map(N));
+}
+function ye(e) {
+  return w(e = h(e), "iterate", G), e;
+}
+function m(e, t) {
+  return V(e) ? j(e) ? J(N(t)) : J(t) : N(t);
+}
+const ft = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return he(this, Symbol.iterator, (e) => m(this, e));
+  },
+  concat(...e) {
+    return K(this).concat(
+      ...e.map((t) => D(t) ? K(t) : t)
+    );
+  },
+  entries() {
+    return he(this, "entries", (e) => (e[1] = m(this, e[1]), e));
+  },
+  every(e, t) {
+    return R(this, "every", e, t, void 0, arguments);
+  },
+  filter(e, t) {
+    return R(
+      this,
+      "filter",
+      e,
+      t,
+      (s) => s.map((n) => m(this, n)),
+      arguments
+    );
+  },
+  find(e, t) {
+    return R(
+      this,
+      "find",
+      e,
+      t,
+      (s) => m(this, s),
+      arguments
+    );
+  },
+  findIndex(e, t) {
+    return R(this, "findIndex", e, t, void 0, arguments);
+  },
+  findLast(e, t) {
+    return R(
+      this,
+      "findLast",
+      e,
+      t,
+      (s) => m(this, s),
+      arguments
+    );
+  },
+  findLastIndex(e, t) {
+    return R(this, "findLastIndex", e, t, void 0, arguments);
+  },
+  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+  forEach(e, t) {
+    return R(this, "forEach", e, t, void 0, arguments);
+  },
+  includes(...e) {
+    return pe(this, "includes", e);
+  },
+  indexOf(...e) {
+    return pe(this, "indexOf", e);
+  },
+  join(e) {
+    return K(this).join(e);
+  },
+  // keys() iterator only reads `length`, no optimization required
+  lastIndexOf(...e) {
+    return pe(this, "lastIndexOf", e);
+  },
+  map(e, t) {
+    return R(this, "map", e, t, void 0, arguments);
+  },
+  pop() {
+    return $(this, "pop");
+  },
+  push(...e) {
+    return $(this, "push", e);
+  },
+  reduce(e, ...t) {
+    return me(this, "reduce", e, t);
+  },
+  reduceRight(e, ...t) {
+    return me(this, "reduceRight", e, t);
+  },
+  shift() {
+    return $(this, "shift");
+  },
+  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+  some(e, t) {
+    return R(this, "some", e, t, void 0, arguments);
+  },
+  splice(...e) {
+    return $(this, "splice", e);
+  },
+  toReversed() {
+    return K(this).toReversed();
+  },
+  toSorted(e) {
+    return K(this).toSorted(e);
+  },
+  toSpliced(...e) {
+    return K(this).toSpliced(...e);
+  },
+  unshift(...e) {
+    return $(this, "unshift", e);
+  },
+  values() {
+    return he(this, "values", (e) => m(this, e));
+  }
+};
+function he(e, t, s) {
+  const n = ye(e), i = n[t]();
+  return n !== e && !b(e) && (i._next = i.next, i.next = () => {
+    const r = i._next();
+    return r.done || (r.value = s(r.value)), r;
+  }), i;
+}
+const lt = Array.prototype;
+function R(e, t, s, n, i, r) {
+  const o = ye(e), c = o !== e && !b(e), a = o[t];
+  if (a !== lt[t]) {
+    const f = a.apply(e, r);
+    return c ? N(f) : f;
+  }
+  let p = s;
+  o !== e && (c ? p = function(f, d) {
+    return s.call(this, m(e, f), d, e);
+  } : s.length > 2 && (p = function(f, d) {
+    return s.call(this, f, d, e);
+  }));
+  const _ = a.call(o, p, n);
+  return c && i ? i(_) : _;
+}
+function me(e, t, s, n) {
+  const i = ye(e);
+  let r = s;
+  return i !== e && (b(e) ? s.length > 3 && (r = function(o, c, a) {
+    return s.call(this, o, c, a, e);
+  }) : r = function(o, c, a) {
+    return s.call(this, o, m(e, c), a, e);
+  }), i[t](r, ...n);
+}
+function pe(e, t, s) {
+  const n = h(e);
+  w(n, "iterate", G);
+  const i = n[t](...s);
+  return (i === -1 || i === !1) && Re(s[0]) ? (s[0] = h(s[0]), n[t](...s)) : i;
+}
+function $(e, t, s = []) {
+  He(), Ee();
+  const n = h(e)[t].apply(e, s);
+  return be(), Ke(), n;
+}
+const ut = /* @__PURE__ */ qe("__proto__,__v_isRef,__isVue"), je = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(U)
+);
+function ht(e) {
+  U(e) || (e = String(e));
+  const t = h(this);
+  return w(t, "has", e), t.hasOwnProperty(e);
+}
+class We {
+  constructor(t = !1, s = !1) {
+    this._isReadonly = t, this._isShallow = s;
+  }
+  get(t, s, n) {
+    if (s === "__v_skip") return t.__v_skip;
+    const i = this._isReadonly, r = this._isShallow;
+    if (s === "__v_isReactive")
+      return !i;
+    if (s === "__v_isReadonly")
+      return i;
+    if (s === "__v_isShallow")
+      return r;
+    if (s === "__v_raw")
+      return n === (i ? r ? Fe : Be : r ? ze : Ye).get(t) || // receiver is not the reactive proxy, but has the same prototype
+      // this means the receiver is a user proxy of the reactive proxy
+      Object.getPrototypeOf(t) === Object.getPrototypeOf(n) ? t : void 0;
+    const o = D(t);
+    if (!i) {
+      let a;
+      if (o && (a = ft[s]))
+        return a;
+      if (s === "hasOwnProperty")
+        return ht;
+    }
+    const c = Reflect.get(
+      t,
+      s,
+      // if this is a proxy wrapping a ref, return methods using the raw ref
+      // as receiver so that we don't have to call `toRaw` on the ref in all
+      // its class methods
+      g(t) ? t : n
+    );
+    if ((U(s) ? je.has(s) : ut(s)) || (i || w(t, "get", s), r))
+      return c;
+    if (g(c)) {
+      const a = o && re(s) ? c : c.value;
+      return i && P(a) ? we(a) : a;
+    }
+    return P(c) ? i ? we(c) : Ge(c) : c;
+  }
+}
+class Ce extends We {
+  constructor(t = !1) {
+    super(!1, t);
+  }
+  set(t, s, n, i) {
+    let r = t[s];
+    const o = D(t) && re(s);
+    if (!this._isShallow) {
+      const p = V(r);
+      if (!b(n) && !V(n) && (r = h(r), n = h(n)), !o && g(r) && !g(n))
+        return p ? (process.env.NODE_ENV !== "production" && E(
+          `Set operation on key "${String(s)}" failed: target is readonly.`,
+          t[s]
+        ), !0) : (r.value = n, !0);
+    }
+    const c = o ? Number(s) < t.length : se(t, s), a = Reflect.set(
+      t,
+      s,
+      n,
+      g(t) ? t : i
+    );
+    return t === h(i) && (c ? T(n, r) && x(t, "set", s, n, r) : x(t, "add", s, n)), a;
+  }
+  deleteProperty(t, s) {
+    const n = se(t, s), i = t[s], r = Reflect.deleteProperty(t, s);
+    return r && n && x(t, "delete", s, void 0, i), r;
+  }
+  has(t, s) {
+    const n = Reflect.has(t, s);
+    return (!U(s) || !je.has(s)) && w(t, "has", s), n;
+  }
+  ownKeys(t) {
+    return w(
+      t,
+      "iterate",
+      D(t) ? "length" : A
+    ), Reflect.ownKeys(t);
+  }
+}
+class $e extends We {
+  constructor(t = !1) {
+    super(!0, t);
+  }
+  set(t, s) {
+    return process.env.NODE_ENV !== "production" && E(
+      `Set operation on key "${String(s)}" failed: target is readonly.`,
+      t
+    ), !0;
+  }
+  deleteProperty(t, s) {
+    return process.env.NODE_ENV !== "production" && E(
+      `Delete operation on key "${String(s)}" failed: target is readonly.`,
+      t
+    ), !0;
+  }
+}
+const pt = /* @__PURE__ */ new Ce(), dt = /* @__PURE__ */ new $e(), _t = /* @__PURE__ */ new Ce(!0), vt = /* @__PURE__ */ new $e(!0), ge = (e) => e, k = (e) => Reflect.getPrototypeOf(e);
+function gt(e, t, s) {
+  return function(...n) {
+    const i = this.__v_raw, r = h(i), o = L(r), c = e === "entries" || e === Symbol.iterator && o, a = e === "keys" && o, p = i[e](...n), _ = s ? ge : t ? J : N;
+    return !t && w(
+      r,
+      "iterate",
+      a ? ve : A
+    ), {
+      // iterator protocol
+      next() {
+        const { value: f, done: d } = p.next();
+        return d ? { value: f, done: d } : {
+          value: c ? [_(f[0]), _(f[1])] : _(f),
+          done: d
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function ee(e) {
+  return function(...t) {
+    if (process.env.NODE_ENV !== "production") {
+      const s = t[0] ? `on key "${t[0]}" ` : "";
+      E(
+        `${Xe(e)} operation ${s}failed: target is readonly.`,
+        h(this)
+      );
+    }
+    return e === "delete" ? !1 : e === "clear" ? void 0 : this;
+  };
+}
+function wt(e, t) {
+  const s = {
+    get(i) {
+      const r = this.__v_raw, o = h(r), c = h(i);
+      e || (T(i, c) && w(o, "get", i), w(o, "get", c));
+      const { has: a } = k(o), p = t ? ge : e ? J : N;
+      if (a.call(o, i))
+        return p(r.get(i));
+      if (a.call(o, c))
+        return p(r.get(c));
+      r !== o && r.get(i);
+    },
+    get size() {
+      const i = this.__v_raw;
+      return !e && w(h(i), "iterate", A), i.size;
+    },
+    has(i) {
+      const r = this.__v_raw, o = h(r), c = h(i);
+      return e || (T(i, c) && w(o, "has", i), w(o, "has", c)), i === c ? r.has(i) : r.has(i) || r.has(c);
+    },
+    forEach(i, r) {
+      const o = this, c = o.__v_raw, a = h(c), p = t ? ge : e ? J : N;
+      return !e && w(a, "iterate", A), c.forEach((_, f) => i.call(r, p(_), p(f), o));
+    }
+  };
+  return de(
+    s,
+    e ? {
+      add: ee("add"),
+      set: ee("set"),
+      delete: ee("delete"),
+      clear: ee("clear")
+    } : {
+      add(i) {
+        !t && !b(i) && !V(i) && (i = h(i));
+        const r = h(this);
+        return k(r).has.call(r, i) || (r.add(i), x(r, "add", i, i)), this;
+      },
+      set(i, r) {
+        !t && !b(r) && !V(r) && (r = h(r));
+        const o = h(this), { has: c, get: a } = k(o);
+        let p = c.call(o, i);
+        p ? process.env.NODE_ENV !== "production" && xe(o, c, i) : (i = h(i), p = c.call(o, i));
+        const _ = a.call(o, i);
+        return o.set(i, r), p ? T(r, _) && x(o, "set", i, r, _) : x(o, "add", i, r), this;
+      },
+      delete(i) {
+        const r = h(this), { has: o, get: c } = k(r);
+        let a = o.call(r, i);
+        a ? process.env.NODE_ENV !== "production" && xe(r, o, i) : (i = h(i), a = o.call(r, i));
+        const p = c ? c.call(r, i) : void 0, _ = r.delete(i);
+        return a && x(r, "delete", i, void 0, p), _;
+      },
+      clear() {
+        const i = h(this), r = i.size !== 0, o = process.env.NODE_ENV !== "production" ? L(i) ? new Map(i) : new Set(i) : void 0, c = i.clear();
+        return r && x(
+          i,
+          "clear",
+          void 0,
+          void 0,
+          o
+        ), c;
+      }
+    }
+  ), [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ].forEach((i) => {
+    s[i] = gt(i, e, t);
+  }), s;
+}
+function ce(e, t) {
+  const s = wt(e, t);
+  return (n, i, r) => i === "__v_isReactive" ? !e : i === "__v_isReadonly" ? e : i === "__v_raw" ? n : Reflect.get(
+    se(s, i) && i in n ? s : n,
+    i,
+    r
+  );
+}
+const Et = {
+  get: /* @__PURE__ */ ce(!1, !1)
+}, bt = {
+  get: /* @__PURE__ */ ce(!1, !0)
+}, St = {
+  get: /* @__PURE__ */ ce(!0, !1)
+}, yt = {
+  get: /* @__PURE__ */ ce(!0, !0)
+};
+function xe(e, t, s) {
+  const n = h(s);
+  if (n !== s && t.call(e, n)) {
+    const i = Oe(e);
+    E(
+      `Reactive ${i} contains both the raw and reactive versions of the same object${i === "Map" ? " as keys" : ""}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
+    );
+  }
+}
+const Ye = /* @__PURE__ */ new WeakMap(), ze = /* @__PURE__ */ new WeakMap(), Be = /* @__PURE__ */ new WeakMap(), Fe = /* @__PURE__ */ new WeakMap();
+function Rt(e) {
+  switch (e) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function Dt(e) {
+  return e.__v_skip || !Object.isExtensible(e) ? 0 : Rt(Oe(e));
+}
+function Ge(e) {
+  return V(e) ? e : ae(
+    e,
+    !1,
+    pt,
+    Et,
+    Ye
+  );
+}
+function Kt(e) {
+  return ae(
+    e,
+    !1,
+    _t,
+    bt,
+    ze
+  );
+}
+function we(e) {
+  return ae(
+    e,
+    !0,
+    dt,
+    St,
+    Be
+  );
+}
+function Lt(e) {
+  return ae(
+    e,
+    !0,
+    vt,
+    yt,
+    Fe
+  );
+}
+function ae(e, t, s, n, i) {
+  if (!P(e))
+    return process.env.NODE_ENV !== "production" && E(
+      `value cannot be made ${t ? "readonly" : "reactive"}: ${String(
+        e
+      )}`
+    ), e;
+  if (e.__v_raw && !(t && e.__v_isReactive))
+    return e;
+  const r = Dt(e);
+  if (r === 0)
+    return e;
+  const o = i.get(e);
+  if (o)
+    return o;
+  const c = new Proxy(
+    e,
+    r === 2 ? n : s
+  );
+  return i.set(e, c), c;
+}
+function j(e) {
+  return V(e) ? j(e.__v_raw) : !!(e && e.__v_isReactive);
+}
+function V(e) {
+  return !!(e && e.__v_isReadonly);
+}
+function b(e) {
+  return !!(e && e.__v_isShallow);
+}
+function Re(e) {
+  return e ? !!e.__v_raw : !1;
+}
+function h(e) {
+  const t = e && e.__v_raw;
+  return t ? h(t) : e;
+}
+function jt(e) {
+  return !se(e, "__v_skip") && Object.isExtensible(e) && Ze(e, "__v_skip", !0), e;
+}
+const N = (e) => P(e) ? Ge(e) : e, J = (e) => P(e) ? we(e) : e;
+function g(e) {
+  return e ? e.__v_isRef === !0 : !1;
+}
+function Nt(e) {
+  return Je(e, !1);
+}
+function Wt(e) {
+  return Je(e, !0);
+}
+function Je(e, t) {
+  return g(e) ? e : new mt(e, t);
+}
+class mt {
+  constructor(t, s) {
+    this.dep = new oe(), this.__v_isRef = !0, this.__v_isShallow = !1, this._rawValue = s ? t : h(t), this._value = s ? t : N(t), this.__v_isShallow = s;
+  }
+  get value() {
+    return process.env.NODE_ENV !== "production" ? this.dep.track({
+      target: this,
+      type: "get",
+      key: "value"
+    }) : this.dep.track(), this._value;
+  }
+  set value(t) {
+    const s = this._rawValue, n = this.__v_isShallow || b(t) || V(t);
+    t = n ? t : h(t), T(t, s) && (this._rawValue = t, this._value = n ? t : N(t), process.env.NODE_ENV !== "production" ? this.dep.trigger({
+      target: this,
+      type: "set",
+      key: "value",
+      newValue: t,
+      oldValue: s
+    }) : this.dep.trigger());
+  }
+}
+function De(e) {
+  return g(e) ? e.value : e;
+}
+function Ct(e) {
+  return B(e) ? e() : De(e);
+}
+const xt = {
+  get: (e, t, s) => t === "__v_raw" ? e : De(Reflect.get(e, t, s)),
+  set: (e, t, s, n) => {
+    const i = e[t];
+    return g(i) && !g(s) ? (i.value = s, !0) : Reflect.set(e, t, s, n);
+  }
+};
+function $t(e) {
+  return j(e) ? e : new Proxy(e, xt);
+}
+class Ot {
+  constructor(t) {
+    this.__v_isRef = !0, this._value = void 0;
+    const s = this.dep = new oe(), { get: n, set: i } = t(s.track.bind(s), s.trigger.bind(s));
+    this._get = n, this._set = i;
+  }
+  get value() {
+    return this._value = this._get();
+  }
+  set value(t) {
+    this._set(t);
+  }
+}
+function Yt(e) {
+  return new Ot(e);
+}
+function zt(e) {
+  process.env.NODE_ENV !== "production" && !Re(e) && E("toRefs() expects a reactive object but received a plain one.");
+  const t = D(e) ? new Array(e.length) : {};
+  for (const s in e)
+    t[s] = Ue(e, s);
+  return t;
+}
+class Tt {
+  constructor(t, s, n) {
+    this._object = t, this._key = s, this._defaultValue = n, this.__v_isRef = !0, this._value = void 0, this._raw = h(t);
+    let i = !0, r = t;
+    if (!D(t) || !re(String(s)))
+      do
+        i = !Re(r) || b(r);
+      while (i && (r = r.__v_raw));
+    this._shallow = i;
+  }
+  get value() {
+    let t = this._object[this._key];
+    return this._shallow && (t = De(t)), this._value = t === void 0 ? this._defaultValue : t;
+  }
+  set value(t) {
+    if (this._shallow && g(this._raw[this._key])) {
+      const s = this._object[this._key];
+      if (g(s)) {
+        s.value = t;
+        return;
+      }
+    }
+    this._object[this._key] = t;
+  }
+  get dep() {
+    return at(this._raw, this._key);
+  }
+}
+class Vt {
+  constructor(t) {
+    this._getter = t, this.__v_isRef = !0, this.__v_isReadonly = !0, this._value = void 0;
+  }
+  get value() {
+    return this._value = this._getter();
+  }
+}
+function Bt(e, t, s) {
+  return g(e) ? e : B(e) ? new Vt(e) : P(e) && arguments.length > 1 ? Ue(e, t, s) : Nt(e);
+}
+function Ue(e, t, s) {
+  return new Tt(e, t, s);
+}
+class It {
+  constructor(t, s, n) {
+    this.fn = t, this.setter = s, this._value = void 0, this.dep = new oe(this), this.__v_isRef = !0, this.deps = void 0, this.depsTail = void 0, this.flags = 16, this.globalVersion = F - 1, this.next = void 0, this.effect = this, this.__v_isReadonly = !s, this.isSSR = n;
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    if (this.flags |= 16, !(this.flags & 8) && // avoid infinite self recursion
+    u !== this)
+      return Ve(this, !0), !0;
+    process.env.NODE_ENV;
+  }
+  get value() {
+    const t = process.env.NODE_ENV !== "production" ? this.dep.track({
+      target: this,
+      type: "get",
+      key: "value"
+    }) : this.dep.track();
+    return Ae(this), t && (t.version = this.dep.version), this._value;
+  }
+  set value(t) {
+    this.setter ? this.setter(t) : process.env.NODE_ENV !== "production" && E("Write operation failed: computed value is readonly");
+  }
+}
+function Ft(e, t, s = !1) {
+  let n, i;
+  B(e) ? n = e : (n = e.get, i = e.set);
+  const r = new It(n, i, s);
+  return process.env.NODE_ENV, r;
+}
+const te = {}, ne = /* @__PURE__ */ new WeakMap();
+let M;
+function Mt(e, t = !1, s = M) {
+  if (s) {
+    let n = ne.get(s);
+    n || ne.set(s, n = []), n.push(e);
+  } else process.env.NODE_ENV !== "production" && !t && E(
+    "onWatcherCleanup() was called when there was no active watcher to associate with."
+  );
+}
+function Gt(e, t, s = Qe) {
+  const { immediate: n, deep: i, once: r, scheduler: o, augmentJob: c, call: a } = s, p = (l) => {
+    (s.onWarn || E)(
+      "Invalid watch source: ",
+      l,
+      "A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types."
+    );
+  }, _ = (l) => i ? l : b(l) || i === !1 || i === 0 ? O(l, 1) : O(l);
+  let f, d, W, Q, q = !1, X = !1;
+  if (g(e) ? (d = () => e.value, q = b(e)) : j(e) ? (d = () => _(e), q = !0) : D(e) ? (X = !0, q = e.some((l) => j(l) || b(l)), d = () => e.map((l) => {
+    if (g(l))
+      return l.value;
+    if (j(l))
+      return _(l);
+    if (B(l))
+      return a ? a(l, 2) : l();
+    process.env.NODE_ENV !== "production" && p(l);
+  })) : B(e) ? t ? d = a ? () => a(e, 2) : e : d = () => {
+    if (W) {
+      He();
+      try {
+        W();
+      } finally {
+        Ke();
+      }
+    }
+    const l = M;
+    M = f;
+    try {
+      return a ? a(e, 3, [Q]) : e(Q);
+    } finally {
+      M = l;
+    }
+  } : (d = st, process.env.NODE_ENV !== "production" && p(e)), t && i) {
+    const l = d, y = i === !0 ? 1 / 0 : i;
+    d = () => O(l(), y);
+  }
+  const fe = nt(), H = () => {
+    f.stop(), fe && fe.active && ke(fe.effects, f);
+  };
+  if (r && t) {
+    const l = t;
+    t = (...y) => {
+      l(...y), H();
+    };
+  }
+  let I = X ? new Array(e.length).fill(te) : te;
+  const C = (l) => {
+    if (!(!(f.flags & 1) || !f.dirty && !l))
+      if (t) {
+        const y = f.run();
+        if (i || q || (X ? y.some((le, Z) => T(le, I[Z])) : T(y, I))) {
+          W && W();
+          const le = M;
+          M = f;
+          try {
+            const Z = [
+              y,
+              // pass undefined as the old value when it's changed for the first time
+              I === te ? void 0 : X && I[0] === te ? [] : I,
+              Q
+            ];
+            I = y, a ? a(t, 3, Z) : (
+              // @ts-expect-error
+              t(...Z)
+            );
+          } finally {
+            M = le;
+          }
+        }
+      } else
+        f.run();
+  };
+  return c && c(C), f = new rt(d), f.scheduler = o ? () => o(C, !1) : C, Q = (l) => Mt(l, !1, f), W = f.onStop = () => {
+    const l = ne.get(f);
+    if (l) {
+      if (a)
+        a(l, 4);
+      else
+        for (const y of l) y();
+      ne.delete(f);
+    }
+  }, process.env.NODE_ENV !== "production" && (f.onTrack = s.onTrack, f.onTrigger = s.onTrigger), t ? n ? C(!0) : I = f.run() : o ? o(C.bind(null, !0), !0) : f.run(), H.pause = f.pause.bind(f), H.resume = f.resume.bind(f), H.stop = H, H;
+}
+function O(e, t = 1 / 0, s) {
+  if (t <= 0 || !P(e) || e.__v_skip || (s = s || /* @__PURE__ */ new Map(), (s.get(e) || 0) >= t))
+    return e;
+  if (s.set(e, t), t--, g(e))
+    O(e.value, t, s);
+  else if (D(e))
+    for (let n = 0; n < e.length; n++)
+      O(e[n], t, s);
+  else if (et(e) || L(e))
+    e.forEach((n) => {
+      O(n, t, s);
+    });
+  else if (tt(e)) {
+    for (const n in e)
+      O(e[n], t, s);
+    for (const n of Object.getOwnPropertySymbols(e))
+      Object.prototype.propertyIsEnumerable.call(e, n) && O(e[n], t, s);
+  }
+  return e;
+}
+export {
+  G as ARRAY_ITERATE_KEY,
+  it as EffectScope,
+  A as ITERATE_KEY,
+  ve as MAP_KEY_ITERATE_KEY,
+  rt as ReactiveEffect,
+  Ft as computed,
+  Yt as customRef,
+  Pt as effectScope,
+  nt as getCurrentScope,
+  Re as isProxy,
+  j as isReactive,
+  V as isReadonly,
+  g as isRef,
+  b as isShallow,
+  jt as markRaw,
+  Ht as onScopeDispose,
+  Mt as onWatcherCleanup,
+  He as pauseTracking,
+  $t as proxyRefs,
+  Ge as reactive,
+  K as reactiveReadArray,
+  we as readonly,
+  Nt as ref,
+  Ke as resetTracking,
+  Kt as shallowReactive,
+  ye as shallowReadArray,
+  Lt as shallowReadonly,
+  Wt as shallowRef,
+  h as toRaw,
+  N as toReactive,
+  J as toReadonly,
+  Bt as toRef,
+  zt as toRefs,
+  Ct as toValue,
+  w as track,
+  O as traverse,
+  x as trigger,
+  De as unref,
+  Gt as watch
+};