@ozdao/prometheus-framework 0.1.55 → 0.1.57

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

@@ -0,0 +1,700 @@
+import { isSymbol as q, isObject as z, hasChanged as J, toRawType as ae, isArray as w, extend as A, NOOP as Me, hasOwn as H, isIntegerKey as Q, def as Ie, isFunction as Ve, isMap as D, makeMap as ye, capitalize as xe } from "../../shared/dist/shared.esm-bundler.js";
+function P(e, ...t) {
+  console.warn(`[Vue warn] ${e}`, ...t);
+}
+let u;
+class Ke {
+  constructor(t = !1) {
+    this.detached = t, this._active = !0, this.effects = [], this.cleanups = [], this.parent = u, !t && u && (this.index = (u.scopes || (u.scopes = [])).push(this) - 1);
+  }
+  get active() {
+    return this._active;
+  }
+  run(t) {
+    if (this._active) {
+      const n = u;
+      try {
+        return u = this, t();
+      } finally {
+        u = n;
+      }
+    } else
+      process.env.NODE_ENV !== "production" && P("cannot run an inactive effect scope.");
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  on() {
+    u = this;
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  off() {
+    u = this.parent;
+  }
+  stop(t) {
+    if (this._active) {
+      let n, s;
+      for (n = 0, s = this.effects.length; n < s; n++)
+        this.effects[n].stop();
+      for (n = 0, s = this.cleanups.length; n < s; n++)
+        this.cleanups[n]();
+      if (this.scopes)
+        for (n = 0, s = this.scopes.length; n < s; n++)
+          this.scopes[n].stop(!0);
+      if (!this.detached && this.parent && !t) {
+        const r = this.parent.scopes.pop();
+        r && r !== this && (this.parent.scopes[this.index] = r, r.index = this.index);
+      }
+      this.parent = void 0, this._active = !1;
+    }
+  }
+}
+function Et(e) {
+  return new Ke(e);
+}
+function fe(e, t = u) {
+  t && t.active && t.effects.push(e);
+}
+function Rt() {
+  return u;
+}
+function Nt(e) {
+  u ? u.cleanups.push(e) : process.env.NODE_ENV !== "production" && P("onScopeDispose() is called when there is no active effect scope to be associated with.");
+}
+const T = (e) => {
+  const t = new Set(e);
+  return t.w = 0, t.n = 0, t;
+}, ue = (e) => (e.w & E) > 0, le = (e) => (e.n & E) > 0, Pe = ({ deps: e }) => {
+  if (e.length)
+    for (let t = 0; t < e.length; t++)
+      e[t].w |= E;
+}, $e = (e) => {
+  const { deps: t } = e;
+  if (t.length) {
+    let n = 0;
+    for (let s = 0; s < t.length; s++) {
+      const r = t[s];
+      ue(r) && !le(r) ? r.delete(e) : t[n++] = r, r.w &= ~E, r.n &= ~E;
+    }
+    t.length = n;
+  }
+}, $ = /* @__PURE__ */ new WeakMap();
+let O = 0, E = 1;
+const B = 30;
+let f;
+const m = Symbol(process.env.NODE_ENV !== "production" ? "iterate" : ""), L = Symbol(process.env.NODE_ENV !== "production" ? "Map key iterate" : "");
+class he {
+  constructor(t, n = null, s) {
+    this.fn = t, this.scheduler = n, this.active = !0, this.deps = [], this.parent = void 0, fe(this, s);
+  }
+  run() {
+    if (!this.active)
+      return this.fn();
+    let t = f, n = g;
+    for (; t; ) {
+      if (t === this)
+        return;
+      t = t.parent;
+    }
+    try {
+      return this.parent = f, f = this, g = !0, E = 1 << ++O, O <= B ? Pe(this) : te(this), this.fn();
+    } finally {
+      O <= B && $e(this), E = 1 << --O, f = this.parent, g = n, this.parent = void 0, this.deferStop && this.stop();
+    }
+  }
+  stop() {
+    f === this ? this.deferStop = !0 : this.active && (te(this), this.onStop && this.onStop(), this.active = !1);
+  }
+}
+function te(e) {
+  const { deps: t } = e;
+  if (t.length) {
+    for (let n = 0; n < t.length; n++)
+      t[n].delete(e);
+    t.length = 0;
+  }
+}
+function mt(e, t) {
+  e.effect && (e = e.effect.fn);
+  const n = new he(e);
+  t && (A(n, t), t.scope && fe(n, t.scope)), (!t || !t.lazy) && n.run();
+  const s = n.run.bind(n);
+  return s.effect = n, s;
+}
+function St(e) {
+  e.effect.stop();
+}
+let g = !0;
+const pe = [];
+function ze() {
+  pe.push(g), g = !1;
+}
+function Ae() {
+  const e = pe.pop();
+  g = e === void 0 ? !0 : e;
+}
+function l(e, t, n) {
+  if (g && f) {
+    let s = $.get(e);
+    s || $.set(e, s = /* @__PURE__ */ new Map());
+    let r = s.get(n);
+    r || s.set(n, r = T());
+    const i = process.env.NODE_ENV !== "production" ? { effect: f, target: e, type: t, key: n } : void 0;
+    U(r, i);
+  }
+}
+function U(e, t) {
+  let n = !1;
+  O <= B ? le(e) || (e.n |= E, n = !ue(e)) : n = !e.has(f), n && (e.add(f), f.deps.push(e), process.env.NODE_ENV !== "production" && f.onTrack && f.onTrack(Object.assign({ effect: f }, t)));
+}
+function R(e, t, n, s, r, i) {
+  const o = $.get(e);
+  if (!o)
+    return;
+  let c = [];
+  if (t === "clear")
+    c = [...o.values()];
+  else if (n === "length" && w(e)) {
+    const _ = Number(s);
+    o.forEach((h, N) => {
+      (N === "length" || N >= _) && c.push(h);
+    });
+  } else
+    switch (n !== void 0 && c.push(o.get(n)), t) {
+      case "add":
+        w(e) ? Q(n) && c.push(o.get("length")) : (c.push(o.get(m)), D(e) && c.push(o.get(L)));
+        break;
+      case "delete":
+        w(e) || (c.push(o.get(m)), D(e) && c.push(o.get(L)));
+        break;
+      case "set":
+        D(e) && c.push(o.get(m));
+        break;
+    }
+  const d = process.env.NODE_ENV !== "production" ? { target: e, type: t, key: n, newValue: s, oldValue: r, oldTarget: i } : void 0;
+  if (c.length === 1)
+    c[0] && (process.env.NODE_ENV !== "production" ? S(c[0], d) : S(c[0]));
+  else {
+    const _ = [];
+    for (const h of c)
+      h && _.push(...h);
+    process.env.NODE_ENV !== "production" ? S(T(_), d) : S(T(_));
+  }
+}
+function S(e, t) {
+  const n = w(e) ? e : [...e];
+  for (const s of n)
+    s.computed && ne(s, t);
+  for (const s of n)
+    s.computed || ne(s, t);
+}
+function ne(e, t) {
+  (e !== f || e.allowRecurse) && (process.env.NODE_ENV !== "production" && e.onTrigger && e.onTrigger(A({ effect: e }, t)), e.scheduler ? e.scheduler() : e.run());
+}
+function He(e, t) {
+  var n;
+  return (n = $.get(e)) === null || n === void 0 ? void 0 : n.get(t);
+}
+const je = /* @__PURE__ */ ye("__proto__,__v_isRef,__isVue"), de = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(q)
+), Ce = /* @__PURE__ */ j(), Ge = /* @__PURE__ */ j(!1, !0), We = /* @__PURE__ */ j(!0), Fe = /* @__PURE__ */ j(!0, !0), se = /* @__PURE__ */ Ye();
+function Ye() {
+  const e = {};
+  return ["includes", "indexOf", "lastIndexOf"].forEach((t) => {
+    e[t] = function(...n) {
+      const s = a(this);
+      for (let i = 0, o = this.length; i < o; i++)
+        l(s, "get", i + "");
+      const r = s[t](...n);
+      return r === -1 || r === !1 ? s[t](...n.map(a)) : r;
+    };
+  }), ["push", "pop", "shift", "unshift", "splice"].forEach((t) => {
+    e[t] = function(...n) {
+      ze();
+      const s = a(this)[t].apply(this, n);
+      return Ae(), s;
+    };
+  }), e;
+}
+function Be(e) {
+  const t = a(this);
+  return l(t, "has", e), t.hasOwnProperty(e);
+}
+function j(e = !1, t = !1) {
+  return function(s, r, i) {
+    if (r === "__v_isReactive")
+      return !e;
+    if (r === "__v_isReadonly")
+      return e;
+    if (r === "__v_isShallow")
+      return t;
+    if (r === "__v_raw" && i === (e ? t ? me : Ne : t ? Re : Ee).get(s))
+      return s;
+    const o = w(s);
+    if (!e) {
+      if (o && H(se, r))
+        return Reflect.get(se, r, i);
+      if (r === "hasOwnProperty")
+        return Be;
+    }
+    const c = Reflect.get(s, r, i);
+    return (q(r) ? de.has(r) : je(r)) || (e || l(s, "get", r), t) ? c : p(c) ? o && Q(r) ? c : c.value : z(c) ? e ? be(c) : Se(c) : c;
+  };
+}
+const Le = /* @__PURE__ */ _e(), Ue = /* @__PURE__ */ _e(!0);
+function _e(e = !1) {
+  return function(n, s, r, i) {
+    let o = n[s];
+    if (b(o) && p(o) && !p(r))
+      return !1;
+    if (!e && (!Oe(r) && !b(r) && (o = a(o), r = a(r)), !w(n) && p(o) && !p(r)))
+      return o.value = r, !0;
+    const c = w(n) && Q(s) ? Number(s) < n.length : H(n, s), d = Reflect.set(n, s, r, i);
+    return n === a(i) && (c ? J(r, o) && R(n, "set", s, r, o) : R(n, "add", s, r)), d;
+  };
+}
+function qe(e, t) {
+  const n = H(e, t), s = e[t], r = Reflect.deleteProperty(e, t);
+  return r && n && R(e, "delete", t, void 0, s), r;
+}
+function Je(e, t) {
+  const n = Reflect.has(e, t);
+  return (!q(t) || !de.has(t)) && l(e, "has", t), n;
+}
+function Qe(e) {
+  return l(e, "iterate", w(e) ? "length" : m), Reflect.ownKeys(e);
+}
+const we = {
+  get: Ce,
+  set: Le,
+  deleteProperty: qe,
+  has: Je,
+  ownKeys: Qe
+}, ve = {
+  get: We,
+  set(e, t) {
+    return process.env.NODE_ENV !== "production" && P(`Set operation on key "${String(t)}" failed: target is readonly.`, e), !0;
+  },
+  deleteProperty(e, t) {
+    return process.env.NODE_ENV !== "production" && P(`Delete operation on key "${String(t)}" failed: target is readonly.`, e), !0;
+  }
+}, Xe = /* @__PURE__ */ A({}, we, {
+  get: Ge,
+  set: Ue
+}), Ze = /* @__PURE__ */ A({}, ve, {
+  get: Fe
+}), X = (e) => e, C = (e) => Reflect.getPrototypeOf(e);
+function I(e, t, n = !1, s = !1) {
+  e = e.__v_raw;
+  const r = a(e), i = a(t);
+  n || (t !== i && l(r, "get", t), l(r, "get", i));
+  const { has: o } = C(r), c = s ? X : n ? k : M;
+  if (o.call(r, t))
+    return c(e.get(t));
+  if (o.call(r, i))
+    return c(e.get(i));
+  e !== r && e.get(t);
+}
+function V(e, t = !1) {
+  const n = this.__v_raw, s = a(n), r = a(e);
+  return t || (e !== r && l(s, "has", e), l(s, "has", r)), e === r ? n.has(e) : n.has(e) || n.has(r);
+}
+function y(e, t = !1) {
+  return e = e.__v_raw, !t && l(a(e), "iterate", m), Reflect.get(e, "size", e);
+}
+function re(e) {
+  e = a(e);
+  const t = a(this);
+  return C(t).has.call(t, e) || (t.add(e), R(t, "add", e, e)), this;
+}
+function ie(e, t) {
+  t = a(t);
+  const n = a(this), { has: s, get: r } = C(n);
+  let i = s.call(n, e);
+  i ? process.env.NODE_ENV !== "production" && ge(n, s, e) : (e = a(e), i = s.call(n, e));
+  const o = r.call(n, e);
+  return n.set(e, t), i ? J(t, o) && R(n, "set", e, t, o) : R(n, "add", e, t), this;
+}
+function oe(e) {
+  const t = a(this), { has: n, get: s } = C(t);
+  let r = n.call(t, e);
+  r ? process.env.NODE_ENV !== "production" && ge(t, n, e) : (e = a(e), r = n.call(t, e));
+  const i = s ? s.call(t, e) : void 0, o = t.delete(e);
+  return r && R(t, "delete", e, void 0, i), o;
+}
+function ce() {
+  const e = a(this), t = e.size !== 0, n = process.env.NODE_ENV !== "production" ? D(e) ? new Map(e) : new Set(e) : void 0, s = e.clear();
+  return t && R(e, "clear", void 0, void 0, n), s;
+}
+function x(e, t) {
+  return function(s, r) {
+    const i = this, o = i.__v_raw, c = a(o), d = t ? X : e ? k : M;
+    return !e && l(c, "iterate", m), o.forEach((_, h) => s.call(r, d(_), d(h), i));
+  };
+}
+function K(e, t, n) {
+  return function(...s) {
+    const r = this.__v_raw, i = a(r), o = D(i), c = e === "entries" || e === Symbol.iterator && o, d = e === "keys" && o, _ = r[e](...s), h = n ? X : t ? k : M;
+    return !t && l(i, "iterate", d ? L : m), {
+      // iterator protocol
+      next() {
+        const { value: N, done: Y } = _.next();
+        return Y ? { value: N, done: Y } : {
+          value: c ? [h(N[0]), h(N[1])] : h(N),
+          done: Y
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function v(e) {
+  return function(...t) {
+    if (process.env.NODE_ENV !== "production") {
+      const n = t[0] ? `on key "${t[0]}" ` : "";
+      console.warn(`${xe(e)} operation ${n}failed: target is readonly.`, a(this));
+    }
+    return e === "delete" ? !1 : this;
+  };
+}
+function ke() {
+  const e = {
+    get(i) {
+      return I(this, i);
+    },
+    get size() {
+      return y(this);
+    },
+    has: V,
+    add: re,
+    set: ie,
+    delete: oe,
+    clear: ce,
+    forEach: x(!1, !1)
+  }, t = {
+    get(i) {
+      return I(this, i, !1, !0);
+    },
+    get size() {
+      return y(this);
+    },
+    has: V,
+    add: re,
+    set: ie,
+    delete: oe,
+    clear: ce,
+    forEach: x(!1, !0)
+  }, n = {
+    get(i) {
+      return I(this, i, !0);
+    },
+    get size() {
+      return y(this, !0);
+    },
+    has(i) {
+      return V.call(this, i, !0);
+    },
+    add: v(
+      "add"
+      /* TriggerOpTypes.ADD */
+    ),
+    set: v(
+      "set"
+      /* TriggerOpTypes.SET */
+    ),
+    delete: v(
+      "delete"
+      /* TriggerOpTypes.DELETE */
+    ),
+    clear: v(
+      "clear"
+      /* TriggerOpTypes.CLEAR */
+    ),
+    forEach: x(!0, !1)
+  }, s = {
+    get(i) {
+      return I(this, i, !0, !0);
+    },
+    get size() {
+      return y(this, !0);
+    },
+    has(i) {
+      return V.call(this, i, !0);
+    },
+    add: v(
+      "add"
+      /* TriggerOpTypes.ADD */
+    ),
+    set: v(
+      "set"
+      /* TriggerOpTypes.SET */
+    ),
+    delete: v(
+      "delete"
+      /* TriggerOpTypes.DELETE */
+    ),
+    clear: v(
+      "clear"
+      /* TriggerOpTypes.CLEAR */
+    ),
+    forEach: x(!0, !0)
+  };
+  return ["keys", "values", "entries", Symbol.iterator].forEach((i) => {
+    e[i] = K(i, !1, !1), n[i] = K(i, !0, !1), t[i] = K(i, !1, !0), s[i] = K(i, !0, !0);
+  }), [
+    e,
+    n,
+    t,
+    s
+  ];
+}
+const [et, tt, nt, st] = /* @__PURE__ */ ke();
+function G(e, t) {
+  const n = t ? e ? st : nt : e ? tt : et;
+  return (s, r, i) => r === "__v_isReactive" ? !e : r === "__v_isReadonly" ? e : r === "__v_raw" ? s : Reflect.get(H(n, r) && r in s ? n : s, r, i);
+}
+const rt = {
+  get: /* @__PURE__ */ G(!1, !1)
+}, it = {
+  get: /* @__PURE__ */ G(!1, !0)
+}, ot = {
+  get: /* @__PURE__ */ G(!0, !1)
+}, ct = {
+  get: /* @__PURE__ */ G(!0, !0)
+};
+function ge(e, t, n) {
+  const s = a(n);
+  if (s !== n && t.call(e, s)) {
+    const r = ae(e);
+    console.warn(`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 Ee = /* @__PURE__ */ new WeakMap(), Re = /* @__PURE__ */ new WeakMap(), Ne = /* @__PURE__ */ new WeakMap(), me = /* @__PURE__ */ new WeakMap();
+function at(e) {
+  switch (e) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function ft(e) {
+  return e.__v_skip || !Object.isExtensible(e) ? 0 : at(ae(e));
+}
+function Se(e) {
+  return b(e) ? e : W(e, !1, we, rt, Ee);
+}
+function bt(e) {
+  return W(e, !1, Xe, it, Re);
+}
+function be(e) {
+  return W(e, !0, ve, ot, Ne);
+}
+function Ot(e) {
+  return W(e, !0, Ze, ct, me);
+}
+function W(e, t, n, s, r) {
+  if (!z(e))
+    return process.env.NODE_ENV !== "production" && console.warn(`value cannot be made 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 = ft(e);
+  if (o === 0)
+    return e;
+  const c = new Proxy(e, o === 2 ? s : n);
+  return r.set(e, c), c;
+}
+function Z(e) {
+  return b(e) ? Z(e.__v_raw) : !!(e && e.__v_isReactive);
+}
+function b(e) {
+  return !!(e && e.__v_isReadonly);
+}
+function Oe(e) {
+  return !!(e && e.__v_isShallow);
+}
+function ut(e) {
+  return Z(e) || b(e);
+}
+function a(e) {
+  const t = e && e.__v_raw;
+  return t ? a(t) : e;
+}
+function Dt(e) {
+  return Ie(e, "__v_skip", !0), e;
+}
+const M = (e) => z(e) ? Se(e) : e, k = (e) => z(e) ? be(e) : e;
+function ee(e) {
+  g && f && (e = a(e), process.env.NODE_ENV !== "production" ? U(e.dep || (e.dep = T()), {
+    target: e,
+    type: "get",
+    key: "value"
+  }) : U(e.dep || (e.dep = T())));
+}
+function F(e, t) {
+  e = a(e);
+  const n = e.dep;
+  n && (process.env.NODE_ENV !== "production" ? S(n, {
+    target: e,
+    type: "set",
+    key: "value",
+    newValue: t
+  }) : S(n));
+}
+function p(e) {
+  return !!(e && e.__v_isRef === !0);
+}
+function Tt(e) {
+  return De(e, !1);
+}
+function Mt(e) {
+  return De(e, !0);
+}
+function De(e, t) {
+  return p(e) ? e : new lt(e, t);
+}
+class lt {
+  constructor(t, n) {
+    this.__v_isShallow = n, this.dep = void 0, this.__v_isRef = !0, this._rawValue = n ? t : a(t), this._value = n ? t : M(t);
+  }
+  get value() {
+    return ee(this), this._value;
+  }
+  set value(t) {
+    const n = this.__v_isShallow || Oe(t) || b(t);
+    t = n ? t : a(t), J(t, this._rawValue) && (this._rawValue = t, this._value = n ? t : M(t), F(this, t));
+  }
+}
+function It(e) {
+  F(e, process.env.NODE_ENV !== "production" ? e.value : void 0);
+}
+function ht(e) {
+  return p(e) ? e.value : e;
+}
+const pt = {
+  get: (e, t, n) => ht(Reflect.get(e, t, n)),
+  set: (e, t, n, s) => {
+    const r = e[t];
+    return p(r) && !p(n) ? (r.value = n, !0) : Reflect.set(e, t, n, s);
+  }
+};
+function Vt(e) {
+  return Z(e) ? e : new Proxy(e, pt);
+}
+class dt {
+  constructor(t) {
+    this.dep = void 0, this.__v_isRef = !0;
+    const { get: n, set: s } = t(() => ee(this), () => F(this));
+    this._get = n, this._set = s;
+  }
+  get value() {
+    return this._get();
+  }
+  set value(t) {
+    this._set(t);
+  }
+}
+function yt(e) {
+  return new dt(e);
+}
+function xt(e) {
+  process.env.NODE_ENV !== "production" && !ut(e) && console.warn("toRefs() expects a reactive object but received a plain one.");
+  const t = w(e) ? new Array(e.length) : {};
+  for (const n in e)
+    t[n] = wt(e, n);
+  return t;
+}
+class _t {
+  constructor(t, n, s) {
+    this._object = t, this._key = n, this._defaultValue = s, this.__v_isRef = !0;
+  }
+  get value() {
+    const t = this._object[this._key];
+    return t === void 0 ? this._defaultValue : t;
+  }
+  set value(t) {
+    this._object[this._key] = t;
+  }
+  get dep() {
+    return He(a(this._object), this._key);
+  }
+}
+function wt(e, t, n) {
+  const s = e[t];
+  return p(s) ? s : new _t(e, t, n);
+}
+var Te;
+class vt {
+  constructor(t, n, s, r) {
+    this._setter = n, this.dep = void 0, this.__v_isRef = !0, this[Te] = !1, this._dirty = !0, this.effect = new he(t, () => {
+      this._dirty || (this._dirty = !0, F(this));
+    }), this.effect.computed = this, this.effect.active = this._cacheable = !r, this.__v_isReadonly = s;
+  }
+  get value() {
+    const t = a(this);
+    return ee(t), (t._dirty || !t._cacheable) && (t._dirty = !1, t._value = t.effect.run()), t._value;
+  }
+  set value(t) {
+    this._setter(t);
+  }
+}
+Te = "__v_isReadonly";
+function Kt(e, t, n = !1) {
+  let s, r;
+  const i = Ve(e);
+  i ? (s = e, r = process.env.NODE_ENV !== "production" ? () => {
+    console.warn("Write operation failed: computed value is readonly");
+  } : Me) : (s = e.get, r = e.set);
+  const o = new vt(s, r, i || !r, n);
+  return process.env.NODE_ENV !== "production" && t && !n && (o.effect.onTrack = t.onTrack, o.effect.onTrigger = t.onTrigger), o;
+}
+export {
+  Ke as EffectScope,
+  m as ITERATE_KEY,
+  he as ReactiveEffect,
+  Kt as computed,
+  yt as customRef,
+  mt as effect,
+  Et as effectScope,
+  Rt as getCurrentScope,
+  ut as isProxy,
+  Z as isReactive,
+  b as isReadonly,
+  p as isRef,
+  Oe as isShallow,
+  Dt as markRaw,
+  Nt as onScopeDispose,
+  ze as pauseTracking,
+  Vt as proxyRefs,
+  Se as reactive,
+  be as readonly,
+  Tt as ref,
+  Ae as resetTracking,
+  bt as shallowReactive,
+  Ot as shallowReadonly,
+  Mt as shallowRef,
+  St as stop,
+  a as toRaw,
+  wt as toRef,
+  xt as toRefs,
+  l as track,
+  R as trigger,
+  It as triggerRef,
+  ht as unref
+};