bt-core-app 2.2.10 → 2.2.12

package/dist/bt-core/core/node_modules/vuetify/lib/composables/validation.mjs

@@ -0,0 +1,139 @@
+import { makeFocusProps as $ } from "./focus.mjs";
+import { useForm as k } from "./form.mjs";
+import { useProxiedModel as D } from "./proxiedModel.mjs";
+import { useToggleScope as x } from "./toggleScope.mjs";
+import { useId as E, computed as i, ref as N, shallowRef as z, unref as O, onBeforeMount as P, onBeforeUnmount as A, onMounted as C, watch as h, nextTick as F } from "vue";
+import { useRules as T } from "../labs/rules/rules.mjs";
+import { propsFactory as U } from "../util/propsFactory.mjs";
+import { getCurrentInstanceName as j, getCurrentInstance as q } from "../util/getCurrentInstance.mjs";
+import { wrapInArray as M } from "../util/helpers.mjs";
+const _ = U({
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  errorMessages: {
+    type: [Array, String],
+    default: () => []
+  },
+  maxErrors: {
+    type: [Number, String],
+    default: 1
+  },
+  name: String,
+  label: String,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  rules: {
+    type: Array,
+    default: () => []
+  },
+  modelValue: null,
+  validateOn: String,
+  validationValue: null,
+  ...$()
+}, "validation");
+function ee(a) {
+  let f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : j(), S = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : E();
+  const c = D(a, "modelValue"), d = i(() => a.validationValue === void 0 ? c.value : a.validationValue), l = k(a), I = T(() => a.rules), u = N([]), g = z(!0), V = i(() => !!(M(c.value === "" ? null : c.value).length || M(d.value === "" ? null : d.value).length)), m = i(() => {
+    var e;
+    return (e = a.errorMessages) != null && e.length ? M(a.errorMessages).concat(u.value).slice(0, Math.max(0, Number(a.maxErrors))) : u.value;
+  }), t = i(() => {
+    var o;
+    let e = (a.validateOn ?? ((o = l.validateOn) == null ? void 0 : o.value)) || "input";
+    e === "lazy" && (e = "input lazy"), e === "eager" && (e = "input eager");
+    const n = new Set((e == null ? void 0 : e.split(" ")) ?? []);
+    return {
+      input: n.has("input"),
+      blur: n.has("blur") || n.has("input") || n.has("invalid-input"),
+      invalidInput: n.has("invalid-input"),
+      lazy: n.has("lazy"),
+      eager: n.has("eager")
+    };
+  }), s = i(() => {
+    var e;
+    return a.error || (e = a.errorMessages) != null && e.length ? !1 : a.rules.length ? g.value ? u.value.length || t.value.lazy ? null : !0 : !u.value.length : !0;
+  }), b = z(!1), R = i(() => ({
+    [`${f}--error`]: s.value === !1,
+    [`${f}--dirty`]: V.value,
+    [`${f}--disabled`]: l.isDisabled.value,
+    [`${f}--readonly`]: l.isReadonly.value
+  })), B = q("validation"), y = i(() => a.name ?? O(S));
+  P(() => {
+    var e;
+    (e = l.register) == null || e.call(l, {
+      id: y.value,
+      vm: B,
+      validate: r,
+      reset: p,
+      resetValidation: w
+    });
+  }), A(() => {
+    var e;
+    (e = l.unregister) == null || e.call(l, y.value);
+  }), C(async () => {
+    var e;
+    t.value.lazy || await r(!t.value.eager), (e = l.update) == null || e.call(l, y.value, s.value, m.value);
+  }), x(() => t.value.input || t.value.invalidInput && s.value === !1, () => {
+    h(d, () => {
+      if (d.value != null)
+        r();
+      else if (a.focused) {
+        const e = h(() => a.focused, (n) => {
+          n || r(), e();
+        });
+      }
+    });
+  }), x(() => t.value.blur, () => {
+    h(() => a.focused, (e) => {
+      e || r();
+    });
+  }), h([s, m], () => {
+    var e;
+    (e = l.update) == null || e.call(l, y.value, s.value, m.value);
+  });
+  async function p() {
+    c.value = null, await F(), await w();
+  }
+  async function w() {
+    g.value = !0, t.value.lazy ? u.value = [] : await r(!t.value.eager);
+  }
+  async function r() {
+    let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1;
+    const n = [];
+    b.value = !0;
+    for (const o of I.value) {
+      if (n.length >= Number(a.maxErrors ?? 1))
+        break;
+      const v = await (typeof o == "function" ? o : () => o)(d.value);
+      if (v !== !0) {
+        if (v !== !1 && typeof v != "string") {
+          console.warn(`${v} is not a valid value. Rule functions must return boolean true or a string.`);
+          continue;
+        }
+        n.push(v || "");
+      }
+    }
+    return u.value = n, b.value = !1, g.value = e, u.value;
+  }
+  return {
+    errorMessages: m,
+    isDirty: V,
+    isDisabled: l.isDisabled,
+    isReadonly: l.isReadonly,
+    isPristine: g,
+    isValid: s,
+    isValidating: b,
+    reset: p,
+    resetValidation: w,
+    validate: r,
+    validationClasses: R
+  };
+}
+export {
+  _ as makeValidationProps,
+  ee as useValidation
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/variant.mjs

@@ -0,0 +1,53 @@
+import { createElementVNode as n, Fragment as c, normalizeClass as r, toRef as m, toValue as l } from "vue";
+import { useColor as d } from "./color.mjs";
+import { propsFactory as v } from "../util/propsFactory.mjs";
+import { getCurrentInstanceName as f } from "../util/getCurrentInstance.mjs";
+const g = ["elevated", "flat", "tonal", "outlined", "text", "plain"];
+function k(t, e) {
+  return n(c, null, [t && n("span", {
+    key: "overlay",
+    class: r(`${e}__overlay`)
+  }, null), n("span", {
+    key: "underlay",
+    class: r(`${e}__underlay`)
+  }, null)]);
+}
+const _ = v({
+  color: String,
+  variant: {
+    type: String,
+    default: "elevated",
+    validator: (t) => g.includes(t)
+  }
+}, "variant");
+function $(t) {
+  let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : f();
+  const o = m(() => {
+    const {
+      variant: a
+    } = l(t);
+    return `${e}--variant-${a}`;
+  }), {
+    colorClasses: s,
+    colorStyles: i
+  } = d(() => {
+    const {
+      variant: a,
+      color: u
+    } = l(t);
+    return {
+      [["elevated", "flat"].includes(a) ? "background" : "text"]: u
+    };
+  });
+  return {
+    colorClasses: s,
+    colorStyles: i,
+    variantClasses: o
+  };
+}
+export {
+  g as allowedVariants,
+  k as genOverlays,
+  _ as makeVariantProps,
+  $ as useVariant
+};

package/dist/bt-core/core/node_modules/vuetify/lib/composables/virtual.mjs

@@ -0,0 +1,164 @@
+import { useDisplay as Y } from "./display.mjs";
+import { useResizeObserver as Z } from "./resizeObserver.mjs";
+import { shallowRef as g, watchEffect as _, ref as q, computed as x, watch as H, onScopeDispose as $, nextTick as ee } from "vue";
+import { clamp as P, getPropertyFromItem as te, debounce as le } from "../util/helpers.mjs";
+import { propsFactory as ne } from "../util/propsFactory.mjs";
+import { IN_BROWSER as oe } from "../util/globals.mjs";
+const ae = -1, re = 1, k = 100, pe = ne({
+  itemHeight: {
+    type: [Number, String],
+    default: null
+  },
+  itemKey: {
+    type: [String, Array, Function],
+    default: null
+  },
+  height: [Number, String]
+}, "virtual");
+function ge(i, l) {
+  const s = Y(), o = g(0);
+  _(() => {
+    o.value = parseFloat(i.itemHeight || 0);
+  });
+  const a = g(0), r = g(Math.ceil(
+    // Assume 16px items filling the entire screen height if
+    // not provided. This is probably incorrect but it minimises
+    // the chance of ending up with empty space at the bottom.
+    // The default value is set here to avoid poisoning getSize()
+    (parseInt(i.height) || s.height.value) / (o.value || 16)
+  ) || 1), d = g(0), z = g(0), c = q(), p = q();
+  let b = 0;
+  const {
+    resizeRef: B,
+    contentRect: K
+  } = Z();
+  _(() => {
+    B.value = c.value;
+  });
+  const y = x(() => {
+    var e;
+    return c.value === document.documentElement ? s.height.value : ((e = K.value) == null ? void 0 : e.height) || parseInt(i.height) || 0;
+  }), U = x(() => !!(c.value && p.value && y.value && o.value));
+  let I = Array.from({
+    length: l.value.length
+  }), v = Array.from({
+    length: l.value.length
+  });
+  const F = g(0);
+  let O = -1;
+  function W(e) {
+    return I[e] || o.value;
+  }
+  const R = le(() => {
+    const e = performance.now();
+    v[0] = 0;
+    const t = l.value.length;
+    for (let n = 1; n <= t; n++)
+      v[n] = (v[n - 1] || 0) + W(n - 1);
+    F.value = Math.max(F.value, performance.now() - e);
+  }, F), C = H(U, (e) => {
+    e && (C(), b = p.value.offsetTop, R.immediate(), m(), ~O && ee(() => {
+      oe && window.requestAnimationFrame(() => {
+        N(O), O = -1;
+      });
+    }));
+  });
+  $(() => {
+    R.clear();
+  });
+  function X(e, t) {
+    const n = I[e], u = o.value;
+    o.value = u ? Math.min(o.value, t) : t, (n !== t || u !== o.value) && (I[e] = t, R());
+  }
+  function f(e) {
+    e = P(e, 0, l.value.length);
+    const t = Math.floor(e), n = e % 1, u = t + 1, T = v[t] || 0, h = v[u] || T;
+    return T + (h - T) * n;
+  }
+  function D(e) {
+    return ue(v, e);
+  }
+  let S = 0, w = 0, A = 0;
+  H(y, (e, t) => {
+    m(), e < t && requestAnimationFrame(() => {
+      w = 0, m();
+    });
+  });
+  let M = -1;
+  function j() {
+    if (!c.value || !p.value)
+      return;
+    const e = c.value.scrollTop, t = performance.now();
+    t - A > 500 ? (w = Math.sign(e - S), b = p.value.offsetTop) : w = e - S, S = e, A = t, window.clearTimeout(M), M = window.setTimeout(V, 500), m();
+  }
+  function V() {
+    !c.value || !p.value || (w = 0, A = 0, window.clearTimeout(M), m());
+  }
+  let E = -1;
+  function m() {
+    cancelAnimationFrame(E), E = requestAnimationFrame(G);
+  }
+  function G() {
+    if (!c.value || !y.value || !o.value)
+      return;
+    const e = S - b, t = Math.sign(w), n = Math.max(0, e - k), u = P(D(n), 0, l.value.length), T = e + y.value + k, h = P(D(T) + 1, u + 1, l.value.length);
+    if (
+      // Only update the side we're scrolling towards,
+      // the other side will be updated incidentally
+      (t !== ae || u < a.value) && (t !== re || h > r.value)
+    ) {
+      const L = f(a.value) - f(u), Q = f(h) - f(r.value);
+      Math.max(L, Q) > k ? (a.value = u, r.value = h) : (u <= 0 && (a.value = u), h >= l.value.length && (r.value = h));
+    }
+    d.value = f(a.value), z.value = f(l.value.length) - f(r.value);
+  }
+  function N(e) {
+    const t = f(e);
+    !c.value || e && !t ? O = e : c.value.scrollTop = t;
+  }
+  const J = x(() => l.value.slice(a.value, r.value).map((e, t) => {
+    const n = t + a.value;
+    return {
+      raw: e,
+      index: n,
+      key: te(e, i.itemKey, n)
+    };
+  }));
+  return H(l, () => {
+    I = Array.from({
+      length: l.value.length
+    }), v = Array.from({
+      length: l.value.length
+    }), R.immediate(), m();
+  }, {
+    deep: 1
+  }), {
+    calculateVisibleItems: m,
+    containerRef: c,
+    markerRef: p,
+    computedItems: J,
+    paddingTop: d,
+    paddingBottom: z,
+    scrollToIndex: N,
+    handleScroll: j,
+    handleScrollend: V,
+    handleItemResize: X
+  };
+}
+function ue(i, l) {
+  let s = i.length - 1, o = 0, a = 0, r = null, d = -1;
+  if (i[s] < l)
+    return s;
+  for (; o <= s; )
+    if (a = o + s >> 1, r = i[a], r > l)
+      s = a - 1;
+    else if (r < l)
+      d = a, o = a + 1;
+    else
+      return r === l ? a : o;
+  return d;
+}
+export {
+  pe as makeVirtualProps,
+  ge as useVirtual
+};

package/dist/bt-core/core/node_modules/vuetify/lib/directives/click-outside/index.mjs

@@ -0,0 +1,62 @@
+import { attachedRoot as i } from "../../util/dom.mjs";
+function r() {
+  return !0;
+}
+function a(t, o, e) {
+  if (!t || d(t, e) === !1)
+    return !1;
+  const c = i(o);
+  if (typeof ShadowRoot < "u" && c instanceof ShadowRoot && c.host === t.target)
+    return !1;
+  const s = (typeof e.value == "object" && e.value.include || (() => []))();
+  return s.push(o), !s.some((u) => u == null ? void 0 : u.contains(t.target));
+}
+function d(t, o) {
+  return (typeof o.value == "object" && o.value.closeConditional || r)(t);
+}
+function f(t, o, e) {
+  const c = typeof e.value == "function" ? e.value : e.value.handler;
+  t.shadowTarget = t.target, o._clickOutside.lastMousedownWasOutside && a(t, o, e) && setTimeout(() => {
+    d(t, e) && c && c(t);
+  }, 0);
+}
+function n(t, o) {
+  const e = i(t);
+  o(document), typeof ShadowRoot < "u" && e instanceof ShadowRoot && o(e);
+}
+const l = {
+  // [data-app] may not be found
+  // if using bind, inserted makes
+  // sure that the root element is
+  // available, iOS does not support
+  // clicks on body
+  mounted(t, o) {
+    const e = (s) => f(s, t, o), c = (s) => {
+      t._clickOutside.lastMousedownWasOutside = a(s, t, o);
+    };
+    n(t, (s) => {
+      s.addEventListener("click", e, !0), s.addEventListener("mousedown", c, !0);
+    }), t._clickOutside || (t._clickOutside = {
+      lastMousedownWasOutside: !1
+    }), t._clickOutside[o.instance.$.uid] = {
+      onClick: e,
+      onMousedown: c
+    };
+  },
+  beforeUnmount(t, o) {
+    t._clickOutside && (n(t, (e) => {
+      var u;
+      if (!e || !((u = t._clickOutside) != null && u[o.instance.$.uid]))
+        return;
+      const {
+        onClick: c,
+        onMousedown: s
+      } = t._clickOutside[o.instance.$.uid];
+      e.removeEventListener("click", c, !0), e.removeEventListener("mousedown", s, !0);
+    }), delete t._clickOutside[o.instance.$.uid]);
+  }
+}, k = l;
+export {
+  l as ClickOutside,
+  k as default
+};

package/dist/bt-core/core/node_modules/vuetify/lib/directives/intersect/index.mjs

@@ -0,0 +1,41 @@
+import { SUPPORTS_INTERSECTION as _ } from "../../util/globals.mjs";
+function f(e, t) {
+  if (!_)
+    return;
+  const s = t.modifiers || {}, n = t.value, {
+    handler: u,
+    options: d
+  } = typeof n == "object" ? n : {
+    handler: n,
+    options: {}
+  }, c = new IntersectionObserver(function() {
+    var v;
+    let a = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [], m = arguments.length > 1 ? arguments[1] : void 0;
+    const r = (v = e._observe) == null ? void 0 : v[t.instance.$.uid];
+    if (!r)
+      return;
+    const o = a.some((b) => b.isIntersecting);
+    u && (!s.quiet || r.init) && (!s.once || o || r.init) && u(o, a, m), o && s.once ? i(e, t) : r.init = !0;
+  }, d);
+  e._observe = Object(e._observe), e._observe[t.instance.$.uid] = {
+    init: !1,
+    observer: c
+  }, c.observe(e);
+}
+function i(e, t) {
+  var n;
+  const s = (n = e._observe) == null ? void 0 : n[t.instance.$.uid];
+  s && (s.observer.unobserve(e), delete e._observe[t.instance.$.uid]);
+}
+const I = {
+  mounted: f,
+  unmounted: i,
+  updated: (e, t) => {
+    var s;
+    (s = e._observe) != null && s[t.instance.$.uid] && (i(e, t), f(e, t));
+  }
+}, $ = I;
+export {
+  I as Intersect,
+  $ as default
+};

package/dist/bt-core/core/node_modules/vuetify/lib/directives/ripple/index.mjs

@@ -0,0 +1,183 @@
+import "../../../../../../../_virtual/VRipple.sass.mjs";
+import { isObject as R } from "../../util/helpers.mjs";
+const E = Symbol("rippleStop"), S = 80;
+function y(e, t) {
+  e.style.transform = t, e.style.webkitTransform = t;
+}
+function L(e) {
+  return e.constructor.name === "TouchEvent";
+}
+function T(e) {
+  return e.constructor.name === "KeyboardEvent";
+}
+const x = function(e, t) {
+  var u;
+  let i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, s = 0, r = 0;
+  if (!T(e)) {
+    const d = t.getBoundingClientRect(), l = L(e) ? e.touches[e.touches.length - 1] : e;
+    s = l.clientX - d.left, r = l.clientY - d.top;
+  }
+  let n = 0, o = 0.3;
+  (u = t._ripple) != null && u.circle ? (o = 0.15, n = t.clientWidth / 2, n = i.center ? n : n + Math.sqrt((s - n) ** 2 + (r - n) ** 2) / 4) : n = Math.sqrt(t.clientWidth ** 2 + t.clientHeight ** 2) / 2;
+  const p = `${(t.clientWidth - n * 2) / 2}px`, c = `${(t.clientHeight - n * 2) / 2}px`, _ = i.center ? p : `${s - n}px`, w = i.center ? c : `${r - n}px`;
+  return {
+    radius: n,
+    scale: o,
+    x: _,
+    y: w,
+    centerX: p,
+    centerY: c
+  };
+}, f = {
+  /* eslint-disable max-statements */
+  show(e, t) {
+    var l;
+    let i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    if (!((l = t == null ? void 0 : t._ripple) != null && l.enabled))
+      return;
+    const s = document.createElement("span"), r = document.createElement("span");
+    s.appendChild(r), s.className = "v-ripple__container", i.class && (s.className += ` ${i.class}`);
+    const {
+      radius: n,
+      scale: o,
+      x: p,
+      y: c,
+      centerX: _,
+      centerY: w
+    } = x(e, t, i), u = `${n * 2}px`;
+    r.className = "v-ripple__animation", r.style.width = u, r.style.height = u, t.appendChild(s);
+    const d = window.getComputedStyle(t);
+    d && d.position === "static" && (t.style.position = "relative", t.dataset.previousPosition = "static"), r.classList.add("v-ripple__animation--enter"), r.classList.add("v-ripple__animation--visible"), y(r, `translate(${p}, ${c}) scale3d(${o},${o},${o})`), r.dataset.activated = String(performance.now()), requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        r.classList.remove("v-ripple__animation--enter"), r.classList.add("v-ripple__animation--in"), y(r, `translate(${_}, ${w}) scale3d(1,1,1)`);
+      });
+    });
+  },
+  hide(e) {
+    var n;
+    if (!((n = e == null ? void 0 : e._ripple) != null && n.enabled))
+      return;
+    const t = e.getElementsByClassName("v-ripple__animation");
+    if (t.length === 0)
+      return;
+    const i = Array.from(t).findLast((o) => !o.dataset.isHiding);
+    if (i)
+      i.dataset.isHiding = "true";
+    else
+      return;
+    const s = performance.now() - Number(i.dataset.activated), r = Math.max(250 - s, 0);
+    setTimeout(() => {
+      i.classList.remove("v-ripple__animation--in"), i.classList.add("v-ripple__animation--out"), setTimeout(() => {
+        var p;
+        e.getElementsByClassName("v-ripple__animation").length === 1 && e.dataset.previousPosition && (e.style.position = e.dataset.previousPosition, delete e.dataset.previousPosition), ((p = i.parentNode) == null ? void 0 : p.parentNode) === e && e.removeChild(i.parentNode);
+      }, 300);
+    }, r);
+  }
+};
+function g(e) {
+  return typeof e > "u" || !!e;
+}
+function m(e) {
+  const t = {}, i = e.currentTarget;
+  if (!(!(i != null && i._ripple) || i._ripple.touched || e[E])) {
+    if (e[E] = !0, L(e))
+      i._ripple.touched = !0, i._ripple.isTouch = !0;
+    else if (i._ripple.isTouch)
+      return;
+    if (t.center = i._ripple.centered || T(e), i._ripple.class && (t.class = i._ripple.class), L(e)) {
+      if (i._ripple.showTimerCommit)
+        return;
+      i._ripple.showTimerCommit = () => {
+        f.show(e, i, t);
+      }, i._ripple.showTimer = window.setTimeout(() => {
+        var s;
+        (s = i == null ? void 0 : i._ripple) != null && s.showTimerCommit && (i._ripple.showTimerCommit(), i._ripple.showTimerCommit = null);
+      }, S);
+    } else
+      f.show(e, i, t);
+  }
+}
+function h(e) {
+  e[E] = !0;
+}
+function a(e) {
+  const t = e.currentTarget;
+  if (t != null && t._ripple) {
+    if (window.clearTimeout(t._ripple.showTimer), e.type === "touchend" && t._ripple.showTimerCommit) {
+      t._ripple.showTimerCommit(), t._ripple.showTimerCommit = null, t._ripple.showTimer = window.setTimeout(() => {
+        a(e);
+      });
+      return;
+    }
+    window.setTimeout(() => {
+      t._ripple && (t._ripple.touched = !1);
+    }), f.hide(t);
+  }
+}
+function C(e) {
+  const t = e.currentTarget;
+  t != null && t._ripple && (t._ripple.showTimerCommit && (t._ripple.showTimerCommit = null), window.clearTimeout(t._ripple.showTimer));
+}
+let v = !1;
+function N(e, t) {
+  !v && t.includes(e.key) && (v = !0, m(e));
+}
+function b(e) {
+  v = !1, a(e);
+}
+function k(e) {
+  v && (v = !1, a(e));
+}
+function $(e, t, i) {
+  const {
+    value: s,
+    modifiers: r
+  } = t, n = g(s);
+  n || f.hide(e), e._ripple = e._ripple ?? {}, e._ripple.enabled = n, e._ripple.centered = r.center, e._ripple.circle = r.circle;
+  const o = R(s) ? s : {};
+  o.class && (e._ripple.class = o.class);
+  const p = o.keys ?? ["Enter", "Space"];
+  if (e._ripple.keyDownHandler = (c) => N(c, p), n && !i) {
+    if (r.stop) {
+      e.addEventListener("touchstart", h, {
+        passive: !0
+      }), e.addEventListener("mousedown", h);
+      return;
+    }
+    e.addEventListener("touchstart", m, {
+      passive: !0
+    }), e.addEventListener("touchend", a, {
+      passive: !0
+    }), e.addEventListener("touchmove", C, {
+      passive: !0
+    }), e.addEventListener("touchcancel", a), e.addEventListener("mousedown", m), e.addEventListener("mouseup", a), e.addEventListener("mouseleave", a), e.addEventListener("keydown", e._ripple.keyDownHandler), e.addEventListener("keyup", b), e.addEventListener("blur", k), e.addEventListener("dragstart", a, {
+      passive: !0
+    });
+  } else
+    !n && i && H(e);
+}
+function H(e) {
+  var t;
+  e.removeEventListener("touchstart", h), e.removeEventListener("mousedown", h), e.removeEventListener("touchstart", m), e.removeEventListener("touchend", a), e.removeEventListener("touchmove", C), e.removeEventListener("touchcancel", a), e.removeEventListener("mousedown", m), e.removeEventListener("mouseup", a), e.removeEventListener("mouseleave", a), (t = e._ripple) != null && t.keyDownHandler && e.removeEventListener("keydown", e._ripple.keyDownHandler), e.removeEventListener("keyup", b), e.removeEventListener("blur", k), e.removeEventListener("dragstart", a);
+}
+function P(e, t) {
+  $(e, t, !1);
+}
+function D(e) {
+  H(e), delete e._ripple;
+}
+function Y(e, t) {
+  if (t.value === t.oldValue)
+    return;
+  const i = g(t.oldValue);
+  $(e, t, i);
+}
+const q = {
+  mounted: P,
+  unmounted: D,
+  updated: Y
+}, B = q;
+export {
+  q as Ripple,
+  B as default
+};