@duxweb/dvha-naiveui 1.0.10 → 1.0.12

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

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