@revolugo/elements 5.5.3 → 5.5.4-beta.0

package/dist/revolugo.vuetify.yojzDMFk.min.js

@@ -0,0 +1,865 @@
+import { k as U, b as oe, V as se, e as We, f as $e, l as Ie } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+import { V as ae, j as Ne, m as Me, p as De, i as He } from "./revolugo.i18n.DF3U6VhD.min.js";
+function Be(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const t = import.meta.url, i = t.slice(0, t.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(i);
+      for (const n of REVOLUGO_ELEMENTS_STYLES.components)
+        n(i);
+      if (e.indexOf("fonts") >= 0) {
+        const n = document.createElement("link");
+        n.rel = "stylesheet", linK.href = i, document.head.appendChild(n);
+      }
+    }
+  } catch (t) {
+    console.error("[revolugo-elements] ", t);
+  }
+}
+function Xe(e, t, i) {
+  if (typeof window > "u" || !("IntersectionObserver" in window))
+    return;
+  const n = t.modifiers || {}, r = t.value, {
+    handler: o,
+    options: s
+  } = typeof r == "object" ? r : {
+    handler: r,
+    options: {}
+  }, a = new IntersectionObserver((v = [], d) => {
+    var p;
+    const u = (p = e._observe) === null || p === void 0 ? void 0 : p[i.context._uid];
+    if (!u)
+      return;
+    const f = v.some((B) => B.isIntersecting);
+    o && (!n.quiet || u.init) && (!n.once || f || u.init) && o(v, d, f), f && n.once ? ce(e, t, i) : u.init = !0;
+  }, s);
+  e._observe = Object(e._observe), e._observe[i.context._uid] = {
+    init: !1,
+    observer: a
+  }, a.observe(e);
+}
+function ce(e, t, i) {
+  var n;
+  const r = (n = e._observe) === null || n === void 0 ? void 0 : n[i.context._uid];
+  r && (r.observer.unobserve(e), delete e._observe[i.context._uid]);
+}
+const Ae = {
+  inserted: Xe,
+  unbind: ce
+};
+function ue(e) {
+  if (typeof e.getRootNode != "function") {
+    for (; e.parentNode; )
+      e = e.parentNode;
+    return e !== document ? null : document;
+  }
+  const t = e.getRootNode();
+  return t !== document && t.getRootNode({
+    composed: !0
+  }) !== document ? null : t;
+}
+function Ve() {
+  return !0;
+}
+function de(e, t, i) {
+  if (!e || ve(e, i) === !1)
+    return !1;
+  const n = ue(t);
+  if (typeof ShadowRoot < "u" && n instanceof ShadowRoot && n.host === e.target)
+    return !1;
+  const r = (typeof i.value == "object" && i.value.include || (() => []))();
+  return r.push(t), !r.some((o) => o.contains(e.target));
+}
+function ve(e, t) {
+  return (typeof t.value == "object" && t.value.closeConditional || Ve)(e);
+}
+function Ye(e, t, i) {
+  const n = typeof i.value == "function" ? i.value : i.value.handler;
+  t._clickOutside.lastMousedownWasOutside && de(e, t, i) && setTimeout(() => {
+    ve(e, i) && n && n(e);
+  }, 0);
+}
+function q(e, t) {
+  const i = ue(e);
+  t(document), typeof ShadowRoot < "u" && i instanceof ShadowRoot && t(i);
+}
+const Pe = {
+  // [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
+  inserted(e, t, i) {
+    const n = (o) => Ye(o, e, t), r = (o) => {
+      e._clickOutside.lastMousedownWasOutside = de(o, e, t);
+    };
+    q(e, (o) => {
+      o.addEventListener("click", n, !0), o.addEventListener("mousedown", r, !0);
+    }), e._clickOutside || (e._clickOutside = {
+      lastMousedownWasOutside: !0
+    }), e._clickOutside[i.context._uid] = {
+      onClick: n,
+      onMousedown: r
+    };
+  },
+  unbind(e, t, i) {
+    e._clickOutside && (q(e, (n) => {
+      var r;
+      if (!n || !(!((r = e._clickOutside) === null || r === void 0) && r[i.context._uid]))
+        return;
+      const {
+        onClick: o,
+        onMousedown: s
+      } = e._clickOutside[i.context._uid];
+      n.removeEventListener("click", o, !0), n.removeEventListener("mousedown", s, !0);
+    }), delete e._clickOutside[i.context._uid]);
+  }
+};
+function Ue(e, t, i) {
+  const n = t.value, r = t.options || {
+    passive: !0
+  };
+  window.addEventListener("resize", n, r), e._onResize = Object(e._onResize), e._onResize[i.context._uid] = {
+    callback: n,
+    options: r
+  }, (!t.modifiers || !t.modifiers.quiet) && n();
+}
+function qe(e, t, i) {
+  var n;
+  if (!(!((n = e._onResize) === null || n === void 0) && n[i.context._uid]))
+    return;
+  const {
+    callback: r,
+    options: o
+  } = e._onResize[i.context._uid];
+  window.removeEventListener("resize", r, o), delete e._onResize[i.context._uid];
+}
+const je = {
+  inserted: Ue,
+  unbind: qe
+}, Dt = je, Fe = 80;
+function j(e, t) {
+  e.style.transform = t, e.style.webkitTransform = t;
+}
+function M(e) {
+  return e.constructor.name === "TouchEvent";
+}
+function he(e) {
+  return e.constructor.name === "KeyboardEvent";
+}
+const Ge = (e, t, i = {}) => {
+  let n = 0, r = 0;
+  if (!he(e)) {
+    const u = t.getBoundingClientRect(), f = M(e) ? e.touches[e.touches.length - 1] : e;
+    n = f.clientX - u.left, r = f.clientY - u.top;
+  }
+  let o = 0, s = 0.3;
+  t._ripple && t._ripple.circle ? (s = 0.15, o = t.clientWidth / 2, o = i.center ? o : o + Math.sqrt((n - o) ** 2 + (r - o) ** 2) / 4) : o = Math.sqrt(t.clientWidth ** 2 + t.clientHeight ** 2) / 2;
+  const a = `${(t.clientWidth - o * 2) / 2}px`, v = `${(t.clientHeight - o * 2) / 2}px`, d = i.center ? a : `${n - o}px`, p = i.center ? v : `${r - o}px`;
+  return {
+    radius: o,
+    scale: s,
+    x: d,
+    y: p,
+    centerX: a,
+    centerY: v
+  };
+}, C = {
+  /* eslint-disable max-statements */
+  show(e, t, i = {}) {
+    if (!t._ripple || !t._ripple.enabled)
+      return;
+    const n = document.createElement("span"), r = document.createElement("span");
+    n.appendChild(r), n.className = "v-ripple__container", i.class && (n.className += ` ${i.class}`);
+    const {
+      radius: o,
+      scale: s,
+      x: a,
+      y: v,
+      centerX: d,
+      centerY: p
+    } = Ge(e, t, i), u = `${o * 2}px`;
+    r.className = "v-ripple__animation", r.style.width = u, r.style.height = u, t.appendChild(n);
+    const f = window.getComputedStyle(t);
+    f && f.position === "static" && (t.style.position = "relative", t.dataset.previousPosition = "static"), r.classList.add("v-ripple__animation--enter"), r.classList.add("v-ripple__animation--visible"), j(r, `translate(${a}, ${v}) scale3d(${s},${s},${s})`), r.dataset.activated = String(performance.now()), setTimeout(() => {
+      r.classList.remove("v-ripple__animation--enter"), r.classList.add("v-ripple__animation--in"), j(r, `translate(${d}, ${p}) scale3d(1,1,1)`);
+    }, 0);
+  },
+  hide(e) {
+    if (!e || !e._ripple || !e._ripple.enabled)
+      return;
+    const t = e.getElementsByClassName("v-ripple__animation");
+    if (t.length === 0)
+      return;
+    const i = t[t.length - 1];
+    if (i.dataset.isHiding)
+      return;
+    i.dataset.isHiding = "true";
+    const n = performance.now() - Number(i.dataset.activated), r = Math.max(250 - n, 0);
+    setTimeout(() => {
+      i.classList.remove("v-ripple__animation--in"), i.classList.add("v-ripple__animation--out"), setTimeout(() => {
+        var o;
+        e.getElementsByClassName("v-ripple__animation").length === 1 && e.dataset.previousPosition && (e.style.position = e.dataset.previousPosition, delete e.dataset.previousPosition), ((o = i.parentNode) === null || o === void 0 ? void 0 : o.parentNode) === e && e.removeChild(i.parentNode);
+      }, 300);
+    }, r);
+  }
+};
+function le(e) {
+  return typeof e > "u" || !!e;
+}
+function _(e) {
+  const t = {}, i = e.currentTarget;
+  if (!(!i || !i._ripple || i._ripple.touched || e.rippleStop)) {
+    if (e.rippleStop = !0, M(e))
+      i._ripple.touched = !0, i._ripple.isTouch = !0;
+    else if (i._ripple.isTouch)
+      return;
+    if (t.center = i._ripple.centered || he(e), i._ripple.class && (t.class = i._ripple.class), M(e)) {
+      if (i._ripple.showTimerCommit)
+        return;
+      i._ripple.showTimerCommit = () => {
+        C.show(e, i, t);
+      }, i._ripple.showTimer = window.setTimeout(() => {
+        i && i._ripple && i._ripple.showTimerCommit && (i._ripple.showTimerCommit(), i._ripple.showTimerCommit = null);
+      }, Fe);
+    } else
+      C.show(e, i, t);
+  }
+}
+function h(e) {
+  const t = e.currentTarget;
+  if (!(!t || !t._ripple)) {
+    if (window.clearTimeout(t._ripple.showTimer), e.type === "touchend" && t._ripple.showTimerCommit) {
+      t._ripple.showTimerCommit(), t._ripple.showTimerCommit = null, t._ripple.showTimer = setTimeout(() => {
+        h(e);
+      });
+      return;
+    }
+    window.setTimeout(() => {
+      t._ripple && (t._ripple.touched = !1);
+    }), C.hide(t);
+  }
+}
+function pe(e) {
+  const t = e.currentTarget;
+  !t || !t._ripple || (t._ripple.showTimerCommit && (t._ripple.showTimerCommit = null), window.clearTimeout(t._ripple.showTimer));
+}
+let k = !1;
+function fe(e) {
+  !k && (e.keyCode === U.enter || e.keyCode === U.space) && (k = !0, _(e));
+}
+function be(e) {
+  k = !1, h(e);
+}
+function me(e) {
+  k === !0 && (k = !1, h(e));
+}
+function ge(e, t, i) {
+  const n = le(t.value);
+  n || C.hide(e), e._ripple = e._ripple || {}, e._ripple.enabled = n;
+  const r = t.value || {};
+  r.center && (e._ripple.centered = !0), r.class && (e._ripple.class = t.value.class), r.circle && (e._ripple.circle = r.circle), n && !i ? (e.addEventListener("touchstart", _, {
+    passive: !0
+  }), e.addEventListener("touchend", h, {
+    passive: !0
+  }), e.addEventListener("touchmove", pe, {
+    passive: !0
+  }), e.addEventListener("touchcancel", h), e.addEventListener("mousedown", _), e.addEventListener("mouseup", h), e.addEventListener("mouseleave", h), e.addEventListener("keydown", fe), e.addEventListener("keyup", be), e.addEventListener("blur", me), e.addEventListener("dragstart", h, {
+    passive: !0
+  })) : !n && i && Oe(e);
+}
+function Oe(e) {
+  e.removeEventListener("mousedown", _), e.removeEventListener("touchstart", _), e.removeEventListener("touchend", h), e.removeEventListener("touchmove", pe), e.removeEventListener("touchcancel", h), e.removeEventListener("mouseup", h), e.removeEventListener("mouseleave", h), e.removeEventListener("keydown", fe), e.removeEventListener("keyup", be), e.removeEventListener("dragstart", h), e.removeEventListener("blur", me);
+}
+function Ke(e, t, i) {
+  ge(e, t, !1);
+}
+function Je(e) {
+  delete e._ripple, Oe(e);
+}
+function Qe(e, t) {
+  if (t.value === t.oldValue)
+    return;
+  const i = le(t.oldValue);
+  ge(e, t, i);
+}
+const Ze = {
+  bind: Ke,
+  unbind: Je,
+  update: Qe
+}, Ht = Ze, et = (e) => {
+  const {
+    touchstartX: t,
+    touchendX: i,
+    touchstartY: n,
+    touchendY: r
+  } = e, o = 0.5, s = 16;
+  e.offsetX = i - t, e.offsetY = r - n, Math.abs(e.offsetY) < o * Math.abs(e.offsetX) && (e.left && i < t - s && e.left(e), e.right && i > t + s && e.right(e)), Math.abs(e.offsetX) < o * Math.abs(e.offsetY) && (e.up && r < n - s && e.up(e), e.down && r > n + s && e.down(e));
+};
+function tt(e, t) {
+  const i = e.changedTouches[0];
+  t.touchstartX = i.clientX, t.touchstartY = i.clientY, t.start && t.start(Object.assign(e, t));
+}
+function it(e, t) {
+  const i = e.changedTouches[0];
+  t.touchendX = i.clientX, t.touchendY = i.clientY, t.end && t.end(Object.assign(e, t)), et(t);
+}
+function nt(e, t) {
+  const i = e.changedTouches[0];
+  t.touchmoveX = i.clientX, t.touchmoveY = i.clientY, t.move && t.move(Object.assign(e, t));
+}
+function rt(e) {
+  const t = {
+    touchstartX: 0,
+    touchstartY: 0,
+    touchendX: 0,
+    touchendY: 0,
+    touchmoveX: 0,
+    touchmoveY: 0,
+    offsetX: 0,
+    offsetY: 0,
+    left: e.left,
+    right: e.right,
+    up: e.up,
+    down: e.down,
+    start: e.start,
+    move: e.move,
+    end: e.end
+  };
+  return {
+    touchstart: (i) => tt(i, t),
+    touchend: (i) => it(i, t),
+    touchmove: (i) => nt(i, t)
+  };
+}
+function ot(e, t, i) {
+  const n = t.value, r = n.parent ? e.parentElement : e, o = n.options || {
+    passive: !0
+  };
+  if (!r)
+    return;
+  const s = rt(t.value);
+  r._touchHandlers = Object(r._touchHandlers), r._touchHandlers[i.context._uid] = s, oe(s).forEach((a) => {
+    r.addEventListener(a, s[a], o);
+  });
+}
+function st(e, t, i) {
+  const n = t.value.parent ? e.parentElement : e;
+  if (!n || !n._touchHandlers)
+    return;
+  const r = n._touchHandlers[i.context._uid];
+  oe(r).forEach((o) => {
+    n.removeEventListener(o, r[o]);
+  }), delete n._touchHandlers[i.context._uid];
+}
+const at = {
+  inserted: ot,
+  unbind: st
+}, Xt = at;
+var m = [], ct = function() {
+  return m.some(function(e) {
+    return e.activeTargets.length > 0;
+  });
+}, ut = function() {
+  return m.some(function(e) {
+    return e.skippedTargets.length > 0;
+  });
+}, F = "ResizeObserver loop completed with undelivered notifications.", dt = function() {
+  var e;
+  typeof ErrorEvent == "function" ? e = new ErrorEvent("error", {
+    message: F
+  }) : (e = document.createEvent("Event"), e.initEvent("error", !1, !1), e.message = F), window.dispatchEvent(e);
+}, y;
+(function(e) {
+  e.BORDER_BOX = "border-box", e.CONTENT_BOX = "content-box", e.DEVICE_PIXEL_CONTENT_BOX = "device-pixel-content-box";
+})(y || (y = {}));
+var g = function(e) {
+  return Object.freeze(e);
+}, vt = /* @__PURE__ */ function() {
+  function e(t, i) {
+    this.inlineSize = t, this.blockSize = i, g(this);
+  }
+  return e;
+}(), Ee = function() {
+  function e(t, i, n, r) {
+    return this.x = t, this.y = i, this.width = n, this.height = r, this.top = this.y, this.left = this.x, this.bottom = this.top + this.height, this.right = this.left + this.width, g(this);
+  }
+  return e.prototype.toJSON = function() {
+    var t = this, i = t.x, n = t.y, r = t.top, o = t.right, s = t.bottom, a = t.left, v = t.width, d = t.height;
+    return { x: i, y: n, top: r, right: o, bottom: s, left: a, width: v, height: d };
+  }, e.fromRect = function(t) {
+    return new e(t.x, t.y, t.width, t.height);
+  }, e;
+}(), H = function(e) {
+  return e instanceof SVGElement && "getBBox" in e;
+}, _e = function(e) {
+  if (H(e)) {
+    var t = e.getBBox(), i = t.width, n = t.height;
+    return !i && !n;
+  }
+  var r = e, o = r.offsetWidth, s = r.offsetHeight;
+  return !(o || s || e.getClientRects().length);
+}, G = function(e) {
+  var t;
+  if (e instanceof Element)
+    return !0;
+  var i = (t = e == null ? void 0 : e.ownerDocument) === null || t === void 0 ? void 0 : t.defaultView;
+  return !!(i && e instanceof i.Element);
+}, ht = function(e) {
+  switch (e.tagName) {
+    case "INPUT":
+      if (e.type !== "image")
+        break;
+    case "VIDEO":
+    case "AUDIO":
+    case "EMBED":
+    case "OBJECT":
+    case "CANVAS":
+    case "IFRAME":
+    case "IMG":
+      return !0;
+  }
+  return !1;
+}, E = typeof window < "u" ? window : {}, T = /* @__PURE__ */ new WeakMap(), K = /auto|scroll/, lt = /^tb|vertical/, pt = /msie|trident/i.test(E.navigator && E.navigator.userAgent), b = function(e) {
+  return parseFloat(e || "0");
+}, O = function(e, t, i) {
+  return e === void 0 && (e = 0), t === void 0 && (t = 0), i === void 0 && (i = !1), new vt((i ? t : e) || 0, (i ? e : t) || 0);
+}, J = g({
+  devicePixelContentBoxSize: O(),
+  borderBoxSize: O(),
+  contentBoxSize: O(),
+  contentRect: new Ee(0, 0, 0, 0)
+}), ke = function(e, t) {
+  if (t === void 0 && (t = !1), T.has(e) && !t)
+    return T.get(e);
+  if (_e(e))
+    return T.set(e, J), J;
+  var i = getComputedStyle(e), n = H(e) && e.ownerSVGElement && e.getBBox(), r = !pt && i.boxSizing === "border-box", o = lt.test(i.writingMode || ""), s = !n && K.test(i.overflowY || ""), a = !n && K.test(i.overflowX || ""), v = n ? 0 : b(i.paddingTop), d = n ? 0 : b(i.paddingRight), p = n ? 0 : b(i.paddingBottom), u = n ? 0 : b(i.paddingLeft), f = n ? 0 : b(i.borderTopWidth), B = n ? 0 : b(i.borderRightWidth), Te = n ? 0 : b(i.borderBottomWidth), Re = n ? 0 : b(i.borderLeftWidth), X = u + d, A = v + p, W = Re + B, $ = f + Te, V = a ? e.offsetHeight - $ - e.clientHeight : 0, Y = s ? e.offsetWidth - W - e.clientWidth : 0, ze = r ? X + W : 0, Se = r ? A + $ : 0, x = n ? n.width : b(i.width) - ze - Y, w = n ? n.height : b(i.height) - Se - V, Le = x + X + Y + W, Ce = w + A + V + $, P = g({
+    devicePixelContentBoxSize: O(Math.round(x * devicePixelRatio), Math.round(w * devicePixelRatio), o),
+    borderBoxSize: O(Le, Ce, o),
+    contentBoxSize: O(x, w, o),
+    contentRect: new Ee(u, v, x, w)
+  });
+  return T.set(e, P), P;
+}, ye = function(e, t, i) {
+  var n = ke(e, i), r = n.borderBoxSize, o = n.contentBoxSize, s = n.devicePixelContentBoxSize;
+  switch (t) {
+    case y.DEVICE_PIXEL_CONTENT_BOX:
+      return s;
+    case y.BORDER_BOX:
+      return r;
+    default:
+      return o;
+  }
+}, ft = /* @__PURE__ */ function() {
+  function e(t) {
+    var i = ke(t);
+    this.target = t, this.contentRect = i.contentRect, this.borderBoxSize = g([i.borderBoxSize]), this.contentBoxSize = g([i.contentBoxSize]), this.devicePixelContentBoxSize = g([i.devicePixelContentBoxSize]);
+  }
+  return e;
+}(), xe = function(e) {
+  if (_e(e))
+    return 1 / 0;
+  for (var t = 0, i = e.parentNode; i; )
+    t += 1, i = i.parentNode;
+  return t;
+}, bt = function() {
+  var e = 1 / 0, t = [];
+  m.forEach(function(s) {
+    if (s.activeTargets.length !== 0) {
+      var a = [];
+      s.activeTargets.forEach(function(d) {
+        var p = new ft(d.target), u = xe(d.target);
+        a.push(p), d.lastReportedSize = ye(d.target, d.observedBox), u < e && (e = u);
+      }), t.push(function() {
+        s.callback.call(s.observer, a, s.observer);
+      }), s.activeTargets.splice(0, s.activeTargets.length);
+    }
+  });
+  for (var i = 0, n = t; i < n.length; i++) {
+    var r = n[i];
+    r();
+  }
+  return e;
+}, Q = function(e) {
+  m.forEach(function(i) {
+    i.activeTargets.splice(0, i.activeTargets.length), i.skippedTargets.splice(0, i.skippedTargets.length), i.observationTargets.forEach(function(r) {
+      r.isActive() && (xe(r.target) > e ? i.activeTargets.push(r) : i.skippedTargets.push(r));
+    });
+  });
+}, mt = function() {
+  var e = 0;
+  for (Q(e); ct(); )
+    e = bt(), Q(e);
+  return ut() && dt(), e > 0;
+}, I, we = [], gt = function() {
+  return we.splice(0).forEach(function(e) {
+    return e();
+  });
+}, Ot = function(e) {
+  if (!I) {
+    var t = 0, i = document.createTextNode(""), n = { characterData: !0 };
+    new MutationObserver(function() {
+      return gt();
+    }).observe(i, n), I = function() {
+      i.textContent = "".concat(t ? t-- : t++);
+    };
+  }
+  we.push(e), I();
+}, Et = function(e) {
+  Ot(function() {
+    requestAnimationFrame(e);
+  });
+}, L = 0, _t = function() {
+  return !!L;
+}, kt = 250, yt = { attributes: !0, characterData: !0, childList: !0, subtree: !0 }, Z = [
+  "resize",
+  "load",
+  "transitionend",
+  "animationend",
+  "animationstart",
+  "animationiteration",
+  "keyup",
+  "keydown",
+  "mouseup",
+  "mousedown",
+  "mouseover",
+  "mouseout",
+  "blur",
+  "focus"
+], ee = function(e) {
+  return e === void 0 && (e = 0), Date.now() + e;
+}, N = !1, xt = function() {
+  function e() {
+    var t = this;
+    this.stopped = !0, this.listener = function() {
+      return t.schedule();
+    };
+  }
+  return e.prototype.run = function(t) {
+    var i = this;
+    if (t === void 0 && (t = kt), !N) {
+      N = !0;
+      var n = ee(t);
+      Et(function() {
+        var r = !1;
+        try {
+          r = mt();
+        } finally {
+          if (N = !1, t = n - ee(), !_t())
+            return;
+          r ? i.run(1e3) : t > 0 ? i.run(t) : i.start();
+        }
+      });
+    }
+  }, e.prototype.schedule = function() {
+    this.stop(), this.run();
+  }, e.prototype.observe = function() {
+    var t = this, i = function() {
+      return t.observer && t.observer.observe(document.body, yt);
+    };
+    document.body ? i() : E.addEventListener("DOMContentLoaded", i);
+  }, e.prototype.start = function() {
+    var t = this;
+    this.stopped && (this.stopped = !1, this.observer = new MutationObserver(this.listener), this.observe(), Z.forEach(function(i) {
+      return E.addEventListener(i, t.listener, !0);
+    }));
+  }, e.prototype.stop = function() {
+    var t = this;
+    this.stopped || (this.observer && this.observer.disconnect(), Z.forEach(function(i) {
+      return E.removeEventListener(i, t.listener, !0);
+    }), this.stopped = !0);
+  }, e;
+}(), D = new xt(), te = function(e) {
+  !L && e > 0 && D.start(), L += e, !L && D.stop();
+}, wt = function(e) {
+  return !H(e) && !ht(e) && getComputedStyle(e).display === "inline";
+}, Tt = function() {
+  function e(t, i) {
+    this.target = t, this.observedBox = i || y.CONTENT_BOX, this.lastReportedSize = {
+      inlineSize: 0,
+      blockSize: 0
+    };
+  }
+  return e.prototype.isActive = function() {
+    var t = ye(this.target, this.observedBox, !0);
+    return wt(this.target) && (this.lastReportedSize = t), this.lastReportedSize.inlineSize !== t.inlineSize || this.lastReportedSize.blockSize !== t.blockSize;
+  }, e;
+}(), Rt = /* @__PURE__ */ function() {
+  function e(t, i) {
+    this.activeTargets = [], this.skippedTargets = [], this.observationTargets = [], this.observer = t, this.callback = i;
+  }
+  return e;
+}(), R = /* @__PURE__ */ new WeakMap(), ie = function(e, t) {
+  for (var i = 0; i < e.length; i += 1)
+    if (e[i].target === t)
+      return i;
+  return -1;
+}, z = function() {
+  function e() {
+  }
+  return e.connect = function(t, i) {
+    var n = new Rt(t, i);
+    R.set(t, n);
+  }, e.observe = function(t, i, n) {
+    var r = R.get(t), o = r.observationTargets.length === 0;
+    ie(r.observationTargets, i) < 0 && (o && m.push(r), r.observationTargets.push(new Tt(i, n && n.box)), te(1), D.schedule());
+  }, e.unobserve = function(t, i) {
+    var n = R.get(t), r = ie(n.observationTargets, i), o = n.observationTargets.length === 1;
+    r >= 0 && (o && m.splice(m.indexOf(n), 1), n.observationTargets.splice(r, 1), te(-1));
+  }, e.disconnect = function(t) {
+    var i = this, n = R.get(t);
+    n.observationTargets.slice().forEach(function(r) {
+      return i.unobserve(t, r.target);
+    }), n.activeTargets.splice(0, n.activeTargets.length);
+  }, e;
+}(), zt = function() {
+  function e(t) {
+    if (arguments.length === 0)
+      throw new TypeError("Failed to construct 'ResizeObserver': 1 argument required, but only 0 present.");
+    if (typeof t != "function")
+      throw new TypeError("Failed to construct 'ResizeObserver': The callback provided as parameter 1 is not a function.");
+    z.connect(this, t);
+  }
+  return e.prototype.observe = function(t, i) {
+    if (arguments.length === 0)
+      throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': 1 argument required, but only 0 present.");
+    if (!G(t))
+      throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': parameter 1 is not of type 'Element");
+    z.observe(this, t, i);
+  }, e.prototype.unobserve = function(t) {
+    if (arguments.length === 0)
+      throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': 1 argument required, but only 0 present.");
+    if (!G(t))
+      throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': parameter 1 is not of type 'Element");
+    z.unobserve(this, t);
+  }, e.prototype.disconnect = function() {
+    z.disconnect(this);
+  }, e.toString = function() {
+    return "function ResizeObserver () { [polyfill code] }";
+  }, e;
+}();
+let S;
+const St = new Uint8Array(16);
+function Lt() {
+  if (!S && (S = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !S))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return S(St);
+}
+const c = [];
+for (let e = 0; e < 256; ++e)
+  c.push((e + 256).toString(16).slice(1));
+function Ct(e, t = 0) {
+  return c[e[t + 0]] + c[e[t + 1]] + c[e[t + 2]] + c[e[t + 3]] + "-" + c[e[t + 4]] + c[e[t + 5]] + "-" + c[e[t + 6]] + c[e[t + 7]] + "-" + c[e[t + 8]] + c[e[t + 9]] + "-" + c[e[t + 10]] + c[e[t + 11]] + c[e[t + 12]] + c[e[t + 13]] + c[e[t + 14]] + c[e[t + 15]];
+}
+const Bt = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), ne = {
+  randomUUID: Bt
+};
+function Wt(e, t, i) {
+  if (ne.randomUUID && !t && !e)
+    return ne.randomUUID();
+  e = e || {};
+  const n = e.random || (e.rng || Lt)();
+  if (n[6] = n[6] & 15 | 64, n[8] = n[8] & 63 | 128, t) {
+    i = i || 0;
+    for (let r = 0; r < 16; ++r)
+      t[i + r] = n[r];
+    return t;
+  }
+  return Ct(n);
+}
+const l = {
+  xs: { maxWidth: 575 },
+  sm: {
+    minWidth: 576,
+    maxWidth: 767
+  },
+  md: {
+    minWidth: 768,
+    maxWidth: 991
+  },
+  lg: {
+    minWidth: 992,
+    maxWidth: 1199
+  },
+  xl: {
+    minWidth: 1200
+  }
+}, re = "bp-observer", $t = function(e) {
+  return e.$el.className === re ? e.$el : typeof e.$el.closest != "function" ? null : e.$el.closest(`.${re}`);
+}, At = ae.extend({
+  data() {
+    return {
+      breakpointObserverEl: null,
+      breakpointObserverId: null,
+      breakpointObserverResizeObserver: null,
+      breakpointObserverSize: {
+        width: 0,
+        height: 0
+      },
+      breakpointObserverEq: {
+        breakpoints: l
+      }
+    };
+  },
+  computed: {
+    breakpointService() {
+      return this.breakpointObserverEq && this.breakpointObserverEq.breakpoints && this.breakpointObserverSize && // mark this.breakpointObserverSize.width and this.breakpointObserverSize.height as dependencies
+      // for the reactivity of the computed breakpoints-property
+      typeof this.breakpointObserverSize.width == "number" && typeof this.breakpointObserverSize.height == "number" ? Object.keys(this.breakpointObserverEq.breakpoints).reduce(
+        (e, t) => ({
+          ...e,
+          [t]: this.breakpointObserverCheckAllConditions(
+            this.breakpointObserverEq.breakpoints[t]
+          )
+        }),
+        { ready: !0 }
+      ) : { ready: !1 };
+    },
+    currentBreakpoint() {
+      return Ne(
+        this.breakpointService,
+        (e, t) => t !== "ready" && e === !0
+      );
+    }
+  },
+  mounted() {
+    this.breakpointObserverInit();
+  },
+  beforeDestroy() {
+    this.breakpointObserverDestroy();
+  },
+  methods: {
+    onResize({ width: e, height: t }) {
+      this.breakpointObserverSize && (this.breakpointObserverSize.height = t, this.breakpointObserverSize.width = e);
+      let i = "";
+      switch (this.currentBreakpoint) {
+        case "sm": {
+          i = `${l.sm.minWidth}px`;
+          break;
+        }
+        case "md": {
+          i = `${l.sm.minWidth}px ${l.md.minWidth}px`;
+          break;
+        }
+        case "lg": {
+          i = `${l.sm.minWidth}px ${l.md.minWidth}px ${l.lg.minWidth}px`;
+          break;
+        }
+        case "xl": {
+          i = `${l.sm.minWidth}px ${l.md.minWidth}px ${l.lg.minWidth}px ${l.xl.minWidth}px`;
+          break;
+        }
+      }
+      this.breakpointObserverEl && (this.breakpointObserverEl.setAttribute("min-width", i), this.breakpointObserverId && this.$store.set(
+        `breakpointService/breakpointObservers@${this.breakpointObserverId}`,
+        {
+          ...this.breakpointService,
+          height: t,
+          width: e
+        }
+      ));
+    },
+    /**
+     * initialize the ResizeObserver for this component
+     */
+    breakpointObserverInit() {
+      this.breakpointObserverEl = this.breakpointObserverEl || $t(this), this.breakpointObserverEl && (this.breakpointObserverId = Wt(), this.breakpointObserverEl.setAttribute("id", this.breakpointObserverId), this.$store.set(
+        `breakpointService/breakpointObservers@${this.breakpointObserverId}`,
+        { ready: !1 }
+      ), this.breakpointObserverResizeObserver = new zt(([e]) => {
+        const { height: t, width: i } = e.contentRect;
+        this.onResize({
+          width: i,
+          height: t
+        });
+      }), this.breakpointObserverResizeObserver.observe(this.breakpointObserverEl));
+    },
+    /**
+     * Stop observing the current element and disconnect the ResizeObserver
+     */
+    breakpointObserverDestroy() {
+      this.breakpointObserverResizeObserver && this.breakpointObserverResizeObserver.disconnect();
+    },
+    /**
+     * Checks all the conditions of a breakpoint
+     * returns `true` if all conditions match
+     * @param {object} bp
+     */
+    breakpointObserverCheckAllConditions(e) {
+      return !Object.keys(e).find(
+        // if any condition returns false:
+        // we break out of the iteration early because of `.find()`
+        (t) => !this.breakpointObserverCheckCondition(t, e[t])
+      );
+    },
+    /**
+     * Checks the condition of a specific condition + value
+     * @param {string} type
+     * @param {number} value
+     */
+    breakpointObserverCheckCondition(e, t) {
+      switch (e) {
+        case "minWidth":
+          return this.breakpointObserverSize.width >= t;
+        case "maxWidth":
+          return this.breakpointObserverSize.width <= t;
+        case "minHeight":
+          return this.breakpointObserverSize.height >= t;
+        case "maxHeight":
+          return this.breakpointObserverSize.height <= t;
+      }
+      return !1;
+    }
+  }
+});
+ae.use(se, {
+  directives: {
+    ClickOutside: Pe,
+    Intersect: Ae
+  }
+});
+const It = {
+  options: { customProperties: !0 },
+  themes: {
+    light: Ie
+  }
+}, Vt = new se({
+  breakpoint: {
+    thresholds: Me(
+      De(l, ["xs", "sm", "md", "lg"]),
+      (e) => (e.maxWidth || 0) + 1
+    ),
+    scrollBarWidth: 0
+  },
+  theme: It,
+  icons: {
+    iconfont: "fa"
+  },
+  locales: {
+    en: We,
+    fr: $e
+  },
+  lang: {
+    t: (e, ...t) => He.t(e, t)
+  }
+});
+Be("css/revolugo.vuetify.BpIoHlAi.css");
+export {
+  Pe as C,
+  Ae as I,
+  Dt as R,
+  Xt as T,
+  ue as a,
+  At as b,
+  re as c,
+  It as d,
+  $t as g,
+  Ht as r,
+  Vt as v
+};
+//# sourceMappingURL=revolugo.vuetify.yojzDMFk.min.js.map