@duxweb/dvha-naiveui 0.0.4 → 0.0.6

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

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