@solar-taro/ui-vant 1.4.1 → 1.4.2

package/index65.js

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