@revolugo/elements 5.5.1-beta.1 → 5.5.1-beta.10

package/dist/revolugo.vdialog.C-Jh0Eq7.min.js

@@ -0,0 +1,341 @@
+import { V as u, R as v } from "./revolugo.index.G0QSOBn3.min.js";
+import { A as f, S as m, b as y, D as p } from "./revolugo.index.DSbeMte7.min.js";
+import { d as g, m as w } from "./revolugo.webcomponentwrapper.Dhr34jp1.min.js";
+import { w as E, y as b, k as o, z as S, A as O, m as C, h as a } from "./revolugo.revolugo-config.B9n_CElG.min.js";
+import { V as k } from "./revolugo.i18n.BIDah4Hr.min.js";
+import { C as x } from "./revolugo.vuetify.BEdap6Ni.min.js";
+function h(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 s of REVOLUGO_ELEMENTS_STYLES.components)
+        s(i);
+      if (e.indexOf("fonts") >= 0) {
+        const s = document.createElement("link");
+        s.rel = "stylesheet", linK.href = i, document.head.appendChild(s);
+      }
+    }
+  } catch (t) {
+    console.error("[revolugo-elements] ", t);
+  }
+}
+const l = k.extend().extend({
+  name: "overlayable",
+  props: {
+    hideOverlay: Boolean,
+    overlayColor: String,
+    overlayOpacity: [Number, String]
+  },
+  data() {
+    return {
+      animationFrame: 0,
+      overlay: null
+    };
+  },
+  watch: {
+    hideOverlay(e) {
+      this.isActive && (e ? this.removeOverlay() : this.genOverlay());
+    }
+  },
+  beforeDestroy() {
+    this.removeOverlay();
+  },
+  methods: {
+    createOverlay() {
+      const e = new g({
+        propsData: {
+          absolute: this.absolute,
+          value: !1,
+          color: this.overlayColor,
+          opacity: this.overlayOpacity
+        }
+      });
+      e.$mount();
+      const t = this.absolute ? this.$el.parentNode : this.attach || document.body.firstChild;
+      t && t.insertBefore(e.$el, t.firstChild), this.overlay = e;
+    },
+    genOverlay() {
+      if (this.hideScroll(), !this.hideOverlay)
+        return this.overlay || this.createOverlay(), this.animationFrame = requestAnimationFrame(() => {
+          this.overlay && (this.activeZIndex !== void 0 ? this.overlay.zIndex = String(this.activeZIndex - 1) : this.$el && (this.overlay.zIndex = E(this.$el)), this.overlay.value = !0);
+        }), !0;
+    },
+    /** removeOverlay(false) will not restore the scollbar afterwards */
+    removeOverlay(e = !0) {
+      this.overlay && (b(this.overlay.$el, "transitionend", () => {
+        !this.overlay || !this.overlay.$el || !this.overlay.$el.parentNode || this.overlay.value || this.isActive || (this.overlay.$el.parentNode.removeChild(this.overlay.$el), this.overlay.$destroy(), this.overlay = null);
+      }), cancelAnimationFrame(this.animationFrame), this.overlay.value = !1), e && this.showScroll();
+    },
+    scrollListener(e) {
+      if ("key" in e) {
+        if (["INPUT", "TEXTAREA", "SELECT"].includes(e.target.tagName) || // https://github.com/vuetifyjs/vuetify/issues/4715
+        e.target.isContentEditable)
+          return;
+        const t = [o.up, o.pageup], i = [o.down, o.pagedown];
+        if (t.includes(e.keyCode))
+          e.deltaY = -1;
+        else if (i.includes(e.keyCode))
+          e.deltaY = 1;
+        else
+          return;
+      }
+      (e.target === this.overlay || e.type !== "keydown" && e.target === document.body || this.checkPath(e)) && e.preventDefault();
+    },
+    hasScrollbar(e) {
+      if (!e || e.nodeType !== Node.ELEMENT_NODE)
+        return !1;
+      const t = window.getComputedStyle(e);
+      return (["auto", "scroll"].includes(t.overflowY) || e.tagName === "SELECT") && e.scrollHeight > e.clientHeight || ["auto", "scroll"].includes(t.overflowX) && e.scrollWidth > e.clientWidth;
+    },
+    shouldScroll(e, t) {
+      if (typeof e.hasAttribute == "function" && e.hasAttribute("data-app"))
+        return !1;
+      const i = t.shiftKey || t.deltaX ? "x" : "y", s = i === "y" ? t.deltaY : t.deltaX || t.deltaY;
+      let n, r;
+      i === "y" ? (n = e.scrollTop === 0, r = e.scrollTop + e.clientHeight === e.scrollHeight) : (n = e.scrollLeft === 0, r = e.scrollLeft + e.clientWidth === e.scrollWidth);
+      const d = s < 0, c = s > 0;
+      return !n && d || !r && c ? !0 : (n || r) && e.parentNode ? this.shouldScroll(e.parentNode, t) : !1;
+    },
+    isInside(e, t) {
+      return e === t ? !0 : e === null || e === document.body ? !1 : this.isInside(e.parentNode, t);
+    },
+    checkPath(e) {
+      const t = S(e);
+      if (e.type === "keydown" && t[0] === document.body) {
+        const i = this.$refs.dialog, s = window.getSelection().anchorNode;
+        return i && this.hasScrollbar(i) && this.isInside(s, i) ? !this.shouldScroll(i, e) : !0;
+      }
+      for (let i = 0; i < t.length; i++) {
+        const s = t[i];
+        if (s === document || s === document.documentElement || s === this.$refs.content)
+          return !0;
+        if (this.hasScrollbar(s))
+          return !this.shouldScroll(s, e);
+      }
+      return !0;
+    },
+    hideScroll() {
+      document.documentElement.style["overflow-y"] = "hidden", this.$vuetify.breakpoint.smAndDown ? document.documentElement.classList.add("overflow-y-hidden") : (O(window, "wheel", this.scrollListener, {
+        passive: !1
+      }), window.addEventListener("keydown", this.scrollListener));
+    },
+    showScroll() {
+      document.documentElement.style["overflow-y"] = "", document.documentElement.classList.remove("overflow-y-hidden"), window.removeEventListener("wheel", this.scrollListener), window.removeEventListener("keydown", this.scrollListener);
+    }
+  }
+}), A = w(p, y, l, v, m, f), B = A.extend({
+  name: "v-dialog",
+  directives: {
+    ClickOutside: x
+  },
+  props: {
+    dark: Boolean,
+    disabled: Boolean,
+    fullscreen: Boolean,
+    light: Boolean,
+    maxWidth: [String, Number],
+    noClickAnimation: Boolean,
+    origin: {
+      type: String,
+      default: "center center"
+    },
+    persistent: Boolean,
+    retainFocus: {
+      type: Boolean,
+      default: !0
+    },
+    scrollable: Boolean,
+    transition: {
+      type: [String, Boolean],
+      default: "dialog-transition"
+    },
+    width: [String, Number]
+  },
+  data() {
+    return {
+      activatedBy: null,
+      animate: !1,
+      animateTimeout: -1,
+      stackMinZIndex: 200,
+      previousActiveElement: null
+    };
+  },
+  computed: {
+    classes() {
+      return {
+        [`v-dialog ${this.contentClass}`.trim()]: !0,
+        "v-dialog--active": this.isActive,
+        "v-dialog--persistent": this.persistent,
+        "v-dialog--fullscreen": this.fullscreen,
+        "v-dialog--scrollable": this.scrollable,
+        "v-dialog--animated": this.animate
+      };
+    },
+    contentClasses() {
+      return {
+        "v-dialog__content": !0,
+        "v-dialog__content--active": this.isActive
+      };
+    },
+    hasActivator() {
+      return !!(this.$slots.activator || this.$scopedSlots.activator);
+    }
+  },
+  watch: {
+    isActive(e) {
+      var t;
+      e ? (this.show(), this.hideScroll()) : (this.removeOverlay(), this.unbind(), (t = this.previousActiveElement) === null || t === void 0 || t.focus());
+    },
+    fullscreen(e) {
+      this.isActive && (e ? (this.hideScroll(), this.removeOverlay(!1)) : (this.showScroll(), this.genOverlay()));
+    }
+  },
+  created() {
+    this.$attrs.hasOwnProperty("full-width") && C("full-width", this);
+  },
+  beforeMount() {
+    this.$nextTick(() => {
+      this.isBooted = this.isActive, this.isActive && this.show();
+    });
+  },
+  beforeDestroy() {
+    typeof window < "u" && this.unbind();
+  },
+  methods: {
+    animateClick() {
+      this.animate = !1, this.$nextTick(() => {
+        this.animate = !0, window.clearTimeout(this.animateTimeout), this.animateTimeout = window.setTimeout(() => this.animate = !1, 150);
+      });
+    },
+    closeConditional(e) {
+      const t = e.target;
+      return !(this._isDestroyed || !this.isActive || this.$refs.content.contains(t) || this.overlay && t && !this.overlay.$el.contains(t)) && this.activeZIndex >= this.getMaxZIndex();
+    },
+    hideScroll() {
+      this.fullscreen ? document.documentElement.classList.add("overflow-y-hidden") : l.options.methods.hideScroll.call(this);
+    },
+    show() {
+      !this.fullscreen && !this.hideOverlay && this.genOverlay(), this.$nextTick(() => {
+        this.$nextTick(() => {
+          var e, t;
+          !((e = this.$refs.dialog) === null || e === void 0) && e.contains(document.activeElement) || (this.previousActiveElement = document.activeElement, (t = this.$refs.dialog) === null || t === void 0 || t.focus()), this.bind();
+        });
+      });
+    },
+    bind() {
+      window.addEventListener("focusin", this.onFocusin);
+    },
+    unbind() {
+      window.removeEventListener("focusin", this.onFocusin);
+    },
+    onClickOutside(e) {
+      this.$emit("click:outside", e), this.persistent ? this.noClickAnimation || this.animateClick() : this.isActive = !1;
+    },
+    onKeydown(e) {
+      if (e.keyCode === o.esc && !this.getOpenDependents().length)
+        if (this.persistent)
+          this.noClickAnimation || this.animateClick();
+        else {
+          this.isActive = !1;
+          const t = this.getActivator();
+          this.$nextTick(() => t && t.focus());
+        }
+      this.$emit("keydown", e);
+    },
+    // On focus change, wrap focus to stay inside the dialog
+    // https://github.com/vuetifyjs/vuetify/issues/6892
+    onFocusin(e) {
+      if (!e || !this.retainFocus)
+        return;
+      const t = e.target;
+      if (t && this.$refs.dialog && // It isn't the document or the dialog body
+      ![document, this.$refs.dialog].includes(t) && // It isn't inside the dialog body
+      !this.$refs.dialog.contains(t) && // We're the topmost dialog
+      this.activeZIndex >= this.getMaxZIndex() && // It isn't inside a dependent element (like a menu)
+      !this.getOpenDependentElements().some((i) => i.contains(t))) {
+        const s = [...this.$refs.dialog.querySelectorAll('button, [href], input:not([type="hidden"]), select, textarea, [tabindex]:not([tabindex="-1"])')].find((n) => !n.hasAttribute("disabled") && !n.matches('[tabindex="-1"]'));
+        s && s.focus();
+      }
+    },
+    genContent() {
+      return this.showLazyContent(() => [this.$createElement(u, {
+        props: {
+          root: !0,
+          light: this.light,
+          dark: this.dark
+        }
+      }, [this.$createElement("div", {
+        class: this.contentClasses,
+        attrs: {
+          role: "dialog",
+          "aria-modal": this.hideOverlay ? void 0 : "true",
+          ...this.getScopeIdAttrs()
+        },
+        on: {
+          keydown: this.onKeydown
+        },
+        style: {
+          zIndex: this.activeZIndex
+        },
+        ref: "content"
+      }, [this.genTransition()])])]);
+    },
+    genTransition() {
+      const e = this.genInnerContent();
+      return this.transition ? this.$createElement("transition", {
+        props: {
+          name: this.transition,
+          origin: this.origin,
+          appear: !0
+        }
+      }, [e]) : e;
+    },
+    genInnerContent() {
+      const e = {
+        class: this.classes,
+        attrs: {
+          tabindex: this.isActive ? 0 : void 0
+        },
+        ref: "dialog",
+        directives: [{
+          name: "click-outside",
+          value: {
+            handler: this.onClickOutside,
+            closeConditional: this.closeConditional,
+            include: this.getOpenDependentElements
+          }
+        }, {
+          name: "show",
+          value: this.isActive
+        }],
+        style: {
+          transformOrigin: this.origin
+        }
+      };
+      return this.fullscreen || (e.style = {
+        ...e.style,
+        maxWidth: a(this.maxWidth),
+        width: a(this.width)
+      }), this.$createElement("div", e, this.getContentSlot());
+    }
+  },
+  render(e) {
+    return e("div", {
+      staticClass: "v-dialog__container",
+      class: {
+        "v-dialog__container--attached": this.attach === "" || this.attach === !0 || this.attach === "attach"
+      }
+    }, [this.genActivator(), this.genContent()]);
+  }
+});
+h("css/revolugo.vdialog.C02Cvwul.css");
+export {
+  l as O,
+  B as _
+};
+//# sourceMappingURL=revolugo.vdialog.C-Jh0Eq7.min.js.map

package/dist/revolugo.vexpansionpanelheader.DJijrIj9.min.js

@@ -0,0 +1,263 @@
+import { B as o } from "./revolugo.vitemgroup.DjZ_N7Ml.min.js";
+import { i as l, j as i } from "./revolugo.revolugo-config.B9n_CElG.min.js";
+import { p as h, f as d, i as r, _ as u } from "./revolugo.index.CMpCToBI.min.js";
+import { m as a, C as p } from "./revolugo.webcomponentwrapper.Dhr34jp1.min.js";
+import { a as v, b as x } from "./revolugo.index.Ce2wa-yh.min.js";
+import { B as m } from "./revolugo.watch-list.Bb06Iz6D.min.js";
+import { r as f } from "./revolugo.vuetify.BEdap6Ni.min.js";
+function c(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const n = import.meta.url, t = n.slice(0, n.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(t);
+      for (const s of REVOLUGO_ELEMENTS_STYLES.components)
+        s(t);
+      if (e.indexOf("fonts") >= 0) {
+        const s = document.createElement("link");
+        s.rel = "stylesheet", linK.href = t, document.head.appendChild(s);
+      }
+    }
+  } catch (n) {
+    console.error("[revolugo-elements] ", n);
+  }
+}
+const P = o.extend({
+  name: "v-expansion-panels",
+  provide() {
+    return {
+      expansionPanels: this
+    };
+  },
+  props: {
+    accordion: Boolean,
+    disabled: Boolean,
+    flat: Boolean,
+    hover: Boolean,
+    focusable: Boolean,
+    inset: Boolean,
+    popout: Boolean,
+    readonly: Boolean,
+    tile: Boolean
+  },
+  computed: {
+    classes() {
+      return {
+        ...o.options.computed.classes.call(this),
+        "v-expansion-panels": !0,
+        "v-expansion-panels--accordion": this.accordion,
+        "v-expansion-panels--flat": this.flat,
+        "v-expansion-panels--hover": this.hover,
+        "v-expansion-panels--focusable": this.focusable,
+        "v-expansion-panels--inset": this.inset,
+        "v-expansion-panels--popout": this.popout,
+        "v-expansion-panels--tile": this.tile
+      };
+    }
+  },
+  created() {
+    this.$attrs.hasOwnProperty("expand") && l("expand", "multiple", this), Array.isArray(this.value) && this.value.length > 0 && typeof this.value[0] == "boolean" && l(':value="[true, false, true]"', ':value="[0, 2]"', this);
+  },
+  methods: {
+    updateItem(e, n) {
+      const t = this.getValue(e, n), s = this.getValue(e, n + 1);
+      e.isActive = this.toggleMethod(t), e.nextIsActive = this.toggleMethod(s);
+    }
+  }
+}), S = a(
+  d("expansionPanels", "v-expansion-panel", "v-expansion-panels"),
+  h("expansionPanel", !0)
+  /* @vue/component */
+).extend({
+  name: "v-expansion-panel",
+  props: {
+    disabled: Boolean,
+    readonly: Boolean
+  },
+  data() {
+    return {
+      content: null,
+      header: null,
+      nextIsActive: !1
+    };
+  },
+  computed: {
+    classes() {
+      return {
+        "v-expansion-panel--active": this.isActive,
+        "v-expansion-panel--next-active": this.nextIsActive,
+        "v-expansion-panel--disabled": this.isDisabled,
+        ...this.groupClasses
+      };
+    },
+    isDisabled() {
+      return this.expansionPanels.disabled || this.disabled;
+    },
+    isReadonly() {
+      return this.expansionPanels.readonly || this.readonly;
+    }
+  },
+  methods: {
+    registerContent(e) {
+      this.content = e;
+    },
+    unregisterContent() {
+      this.content = null;
+    },
+    registerHeader(e) {
+      this.header = e, e.$on("click", this.onClick);
+    },
+    unregisterHeader() {
+      this.header = null;
+    },
+    onClick(e) {
+      e.detail && this.header.$el.blur(), this.$emit("click", e), this.isReadonly || this.isDisabled || this.toggle();
+    },
+    toggle() {
+      this.$nextTick(() => this.$emit("change"));
+    }
+  },
+  render(e) {
+    return e("div", {
+      staticClass: "v-expansion-panel",
+      class: this.classes,
+      attrs: {
+        "aria-expanded": String(this.isActive)
+      }
+    }, i(this));
+  }
+}), g = a(m, p, r("expansionPanel", "v-expansion-panel-content", "v-expansion-panel")), k = g.extend().extend({
+  name: "v-expansion-panel-content",
+  data: () => ({
+    isActive: !1
+  }),
+  computed: {
+    parentIsActive() {
+      return this.expansionPanel.isActive;
+    }
+  },
+  watch: {
+    parentIsActive: {
+      immediate: !0,
+      handler(e, n) {
+        e && (this.isBooted = !0), n == null ? this.isActive = e : this.$nextTick(() => this.isActive = e);
+      }
+    }
+  },
+  created() {
+    this.expansionPanel.registerContent(this);
+  },
+  beforeDestroy() {
+    this.expansionPanel.unregisterContent();
+  },
+  render(e) {
+    return e(v, this.showLazyContent(() => [e("div", this.setBackgroundColor(this.color, {
+      staticClass: "v-expansion-panel-content",
+      directives: [{
+        name: "show",
+        value: this.isActive
+      }]
+    }), [e("div", {
+      class: "v-expansion-panel-content__wrap"
+    }, i(this, "default", {
+      open: this.isActive
+    }))])]));
+  }
+}), _ = a(p, r("expansionPanel", "v-expansion-panel-header", "v-expansion-panel")), I = _.extend().extend({
+  name: "v-expansion-panel-header",
+  directives: {
+    ripple: f
+  },
+  props: {
+    disableIconRotate: Boolean,
+    expandIcon: {
+      type: String,
+      default: "$expand"
+    },
+    hideActions: Boolean,
+    ripple: {
+      type: [Boolean, Object],
+      default: !1
+    }
+  },
+  data: () => ({
+    hasMousedown: !1
+  }),
+  computed: {
+    classes() {
+      return {
+        "v-expansion-panel-header--active": this.isActive,
+        "v-expansion-panel-header--mousedown": this.hasMousedown
+      };
+    },
+    isActive() {
+      return this.expansionPanel.isActive;
+    },
+    isDisabled() {
+      return this.expansionPanel.isDisabled;
+    },
+    isReadonly() {
+      return this.expansionPanel.isReadonly;
+    }
+  },
+  created() {
+    this.expansionPanel.registerHeader(this);
+  },
+  beforeDestroy() {
+    this.expansionPanel.unregisterHeader();
+  },
+  methods: {
+    onClick(e) {
+      this.$emit("click", e);
+    },
+    genIcon() {
+      const e = i(this, "actions", {
+        open: this.isActive
+      }) || [this.$createElement(u, this.expandIcon)];
+      return this.$createElement(x, [this.$createElement("div", {
+        staticClass: "v-expansion-panel-header__icon",
+        class: {
+          "v-expansion-panel-header__icon--disable-rotate": this.disableIconRotate
+        },
+        directives: [{
+          name: "show",
+          value: !this.isDisabled
+        }]
+      }, e)]);
+    }
+  },
+  render(e) {
+    return e("button", this.setBackgroundColor(this.color, {
+      staticClass: "v-expansion-panel-header",
+      class: this.classes,
+      attrs: {
+        tabindex: this.isDisabled ? -1 : null,
+        type: "button",
+        "aria-expanded": this.isActive
+      },
+      directives: [{
+        name: "ripple",
+        value: this.ripple
+      }],
+      on: {
+        ...this.$listeners,
+        click: this.onClick,
+        mousedown: () => this.hasMousedown = !0,
+        mouseup: () => this.hasMousedown = !1
+      }
+    }), [i(this, "default", {
+      open: this.isActive
+    }, !0), this.hideActions || this.genIcon()]);
+  }
+});
+c("css/revolugo.vexpansionpanelheader.B2eKo8Lo.css");
+export {
+  P as _,
+  S as a,
+  I as b,
+  k as c
+};
+//# sourceMappingURL=revolugo.vexpansionpanelheader.DJijrIj9.min.js.map

package/dist/revolugo.vform.D7XJ7bEy.min.js

@@ -0,0 +1,98 @@
+import { m as a } from "./revolugo.webcomponentwrapper.Dhr34jp1.min.js";
+import { B as o } from "./revolugo.index.mq4mKuqN.min.js";
+import { p as h } from "./revolugo.index.CMpCToBI.min.js";
+const l = a(
+  o,
+  h("form")
+  /* @vue/component */
+).extend({
+  name: "v-form",
+  provide() {
+    return {
+      form: this
+    };
+  },
+  inheritAttrs: !1,
+  props: {
+    disabled: Boolean,
+    lazyValidation: Boolean,
+    readonly: Boolean,
+    value: Boolean
+  },
+  data: () => ({
+    inputs: [],
+    watchers: [],
+    errorBag: {}
+  }),
+  watch: {
+    errorBag: {
+      handler(t) {
+        const r = Object.values(t).includes(!0);
+        this.$emit("input", !r);
+      },
+      deep: !0,
+      immediate: !0
+    }
+  },
+  methods: {
+    watchInput(t) {
+      const r = (i) => i.$watch("hasError", (s) => {
+        this.$set(this.errorBag, i._uid, s);
+      }, {
+        immediate: !0
+      }), e = {
+        _uid: t._uid,
+        valid: () => {
+        },
+        shouldValidate: () => {
+        }
+      };
+      return this.lazyValidation ? e.shouldValidate = t.$watch("shouldValidate", (i) => {
+        i && (this.errorBag.hasOwnProperty(t._uid) || (e.valid = r(t)));
+      }) : e.valid = r(t), e;
+    },
+    /** @public */
+    validate() {
+      return this.inputs.filter((t) => !t.validate(!0)).length === 0;
+    },
+    /** @public */
+    reset() {
+      this.inputs.forEach((t) => t.reset()), this.resetErrorBag();
+    },
+    resetErrorBag() {
+      this.lazyValidation && setTimeout(() => {
+        this.errorBag = {};
+      }, 0);
+    },
+    /** @public */
+    resetValidation() {
+      this.inputs.forEach((t) => t.resetValidation()), this.resetErrorBag();
+    },
+    register(t) {
+      this.inputs.push(t), this.watchers.push(this.watchInput(t));
+    },
+    unregister(t) {
+      const r = this.inputs.find((i) => i._uid === t._uid);
+      if (!r)
+        return;
+      const e = this.watchers.find((i) => i._uid === r._uid);
+      e && (e.valid(), e.shouldValidate()), this.watchers = this.watchers.filter((i) => i._uid !== r._uid), this.inputs = this.inputs.filter((i) => i._uid !== r._uid), this.$delete(this.errorBag, r._uid);
+    }
+  },
+  render(t) {
+    return t("form", {
+      staticClass: "v-form",
+      attrs: {
+        novalidate: !0,
+        ...this.attrs$
+      },
+      on: {
+        submit: (r) => this.$emit("submit", r)
+      }
+    }, this.$slots.default);
+  }
+});
+export {
+  l as _
+};
+//# sourceMappingURL=revolugo.vform.D7XJ7bEy.min.js.map