@revolugo/elements 5.5.4 → 5.5.5-beta.0

package/dist/revolugo.bdaterangepicker.DwXWu7y_.min.js

@@ -0,0 +1,1351 @@
+import { V as M, d as m, x as V, O as Y } from "./revolugo.i18n.DF3U6VhD.min.js";
+import { b as N } from "./revolugo.breakpoint-service.CwWRBzMQ.min.js";
+import { m as c, C as f, T as v, g as A, c as R, l as W, n as U, _ as D, a as y } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+import "./revolugo.common.D4pnatuu.min.js";
+import { _ as w } from "./revolugo.index.sTY3URQu.min.js";
+import { B as j, I as H, J as x, h as Z, C as E, q as z } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+import { _ as q } from "./revolugo.vbtn.CP4AezmI.min.js";
+import { T as G } from "./revolugo.vuetify.yojzDMFk.min.js";
+import "./revolugo.vcard.Cy5A2_pV.min.js";
+import { E as F } from "./revolugo.vsheet.C1tyLBBd.min.js";
+import { _ as X } from "./revolugo.parsed-props.B_x1Ob04.min.js";
+function O(t) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const e = import.meta.url, i = e.slice(0, e.lastIndexOf("/") + 1) + t;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(i);
+      for (const s of REVOLUGO_ELEMENTS_STYLES.components)
+        s(i);
+      if (t.indexOf("fonts") >= 0) {
+        const s = document.createElement("link");
+        s.rel = "stylesheet", linK.href = i, document.head.appendChild(s);
+      }
+    }
+  } catch (e) {
+    console.error("[revolugo-elements] ", e);
+  }
+}
+const k = M.extend({
+  name: "localable",
+  props: {
+    locale: String
+  },
+  computed: {
+    currentLocale() {
+      return this.locale || this.$vuetify.lang.current;
+    }
+  }
+});
+function J(t, e = 0, i = 1) {
+  let s;
+  return t < 100 && t >= 0 ? (s = new Date(Date.UTC(t, e, i)), isFinite(s.getUTCFullYear()) && s.setUTCFullYear(t)) : s = new Date(Date.UTC(t, e, i)), s;
+}
+function _(t, e, i) {
+  const s = 7 + e - i;
+  return -((7 + J(t, 0, s).getUTCDay() - e) % 7) + s - 1;
+}
+function K(t, e, i, s) {
+  let n = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334][e];
+  return e > 1 && C(t) && n++, n + i;
+}
+function $(t, e, i) {
+  const s = _(t, e, i), n = _(t + 1, e, i);
+  return ((C(t) ? 366 : 365) - s + n) / 7;
+}
+function Q(t, e, i, s, n) {
+  const r = _(t, s, n), a = Math.ceil((K(t, e, i) - r) / 7);
+  return a < 1 ? a + $(t - 1, s, n) : a > $(t, s, n) ? a - $(t, s, n) : a;
+}
+function C(t) {
+  return t % 4 === 0 && t % 100 !== 0 || t % 400 === 0;
+}
+const tt = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], et = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function it(t, e) {
+  return C(t) ? et[e] : tt[e];
+}
+const st = c(f).extend({
+  methods: {
+    genPickerButton(t, e, i, s = !1, n = "") {
+      const r = this[t] === e, a = (o) => {
+        o.stopPropagation(), this.$emit(`update:${j(t)}`, e);
+      };
+      return this.$createElement("div", {
+        staticClass: `v-picker__title__btn ${n}`.trim(),
+        class: {
+          "v-picker__title__btn--active": r,
+          "v-picker__title__btn--readonly": s
+        },
+        on: r || s ? void 0 : {
+          click: a
+        }
+      }, Array.isArray(i) ? i : [i]);
+    }
+  }
+}), nt = c(
+  st
+  /* @vue/component */
+).extend({
+  name: "v-date-picker-title",
+  props: {
+    date: {
+      type: String,
+      default: ""
+    },
+    disabled: Boolean,
+    readonly: Boolean,
+    selectingYear: Boolean,
+    value: {
+      type: String
+    },
+    year: {
+      type: [Number, String],
+      default: ""
+    },
+    yearIcon: {
+      type: String
+    }
+  },
+  data: () => ({
+    isReversing: !1
+  }),
+  computed: {
+    computedTransition() {
+      return this.isReversing ? "picker-reverse-transition" : "picker-transition";
+    }
+  },
+  watch: {
+    value(t, e) {
+      this.isReversing = t < e;
+    }
+  },
+  methods: {
+    genYearIcon() {
+      return this.$createElement(w, {
+        props: {
+          dark: !0
+        }
+      }, this.yearIcon);
+    },
+    getYearBtn() {
+      return this.genPickerButton("selectingYear", !0, [String(this.year), this.yearIcon ? this.genYearIcon() : null], !1, "v-date-picker-title__year");
+    },
+    genTitleText() {
+      return this.$createElement("transition", {
+        props: {
+          name: this.computedTransition
+        }
+      }, [this.$createElement("div", {
+        domProps: {
+          innerHTML: this.date || "&nbsp;"
+        },
+        key: this.value
+      })]);
+    },
+    genTitleDate() {
+      return this.genPickerButton("selectingYear", !1, [this.genTitleText()], !1, "v-date-picker-title__date");
+    }
+  },
+  render(t) {
+    return t("div", {
+      staticClass: "v-date-picker-title",
+      class: {
+        "v-date-picker-title--disabled": this.disabled
+      }
+    }, [this.getYearBtn(), this.genTitleDate()]);
+  }
+});
+function B(t, e, i) {
+  return Object.keys(t.$listeners).reduce((s, n) => (n.endsWith(e) && (s[n.slice(0, -e.length)] = (r) => t.$emit(n, i, r)), s), {});
+}
+function T(t, e) {
+  return Object.keys(t.$listeners).reduce((i, s) => (s.endsWith(e) && (i[s] = t.$listeners[s]), i), {});
+}
+const rt = (t, e, i) => (e = e >> 0, t = String(t), i = String(i), t.length > e ? String(t) : (e = e - t.length, e > i.length && (i += i.repeat(e / i.length)), i.slice(0, e) + String(t))), l = (t, e = 2) => rt(t, e, "0");
+function p(t, e, i = {
+  start: 0,
+  length: 0
+}) {
+  const s = (n) => {
+    const [r, a, o] = n.trim().split(" ")[0].split("-");
+    return [l(r, 4), l(a || 1), l(o || 1)].join("-");
+  };
+  try {
+    const n = new Intl.DateTimeFormat(t || void 0, e);
+    return (r) => n.format(/* @__PURE__ */ new Date(`${s(r)}T00:00:00+00:00`));
+  } catch {
+    return i.start || i.length ? (r) => s(r).substr(i.start || 0, i.length) : void 0;
+  }
+}
+const P = (t, e) => {
+  const [i, s] = t.split("-").map(Number);
+  return s + e === 0 ? `${i - 1}-12` : s + e === 13 ? `${i + 1}-01` : `${i}-${l(s + e)}`;
+}, h = (t, e) => {
+  const [i, s = 1, n = 1] = t.split("-");
+  return `${i}-${l(s)}-${l(n)}`.substr(0, {
+    date: 10,
+    month: 7,
+    year: 4
+  }[e]);
+}, at = c(
+  f,
+  k,
+  v
+  /* @vue/component */
+).extend({
+  name: "v-date-picker-header",
+  props: {
+    disabled: Boolean,
+    format: Function,
+    min: String,
+    max: String,
+    nextAriaLabel: String,
+    nextIcon: {
+      type: String,
+      default: "$next"
+    },
+    prevAriaLabel: String,
+    prevIcon: {
+      type: String,
+      default: "$prev"
+    },
+    readonly: Boolean,
+    value: {
+      type: [Number, String],
+      required: !0
+    }
+  },
+  data() {
+    return {
+      isReversing: !1
+    };
+  },
+  computed: {
+    formatter() {
+      return this.format ? this.format : String(this.value).split("-")[1] ? p(this.currentLocale, {
+        month: "long",
+        year: "numeric",
+        timeZone: "UTC"
+      }, {
+        length: 7
+      }) : p(this.currentLocale, {
+        year: "numeric",
+        timeZone: "UTC"
+      }, {
+        length: 4
+      });
+    }
+  },
+  watch: {
+    value(t, e) {
+      this.isReversing = t < e;
+    }
+  },
+  methods: {
+    genBtn(t) {
+      const e = t > 0 ? this.nextAriaLabel : this.prevAriaLabel, i = e ? this.$vuetify.lang.t(e) : void 0, s = this.disabled || t < 0 && this.min && this.calculateChange(t) < this.min || t > 0 && this.max && this.calculateChange(t) > this.max;
+      return this.$createElement(q, {
+        attrs: {
+          "aria-label": i
+        },
+        props: {
+          dark: this.dark,
+          disabled: s,
+          icon: !0,
+          light: this.light
+        },
+        on: {
+          click: (n) => {
+            n.stopPropagation(), this.$emit("input", this.calculateChange(t));
+          }
+        }
+      }, [this.$createElement(w, t < 0 == !this.$vuetify.rtl ? this.prevIcon : this.nextIcon)]);
+    },
+    calculateChange(t) {
+      const [e, i] = String(this.value).split("-").map(Number);
+      return i == null ? `${e + t}` : P(String(this.value), t);
+    },
+    genHeader() {
+      const t = !this.disabled && (this.color || "accent"), e = this.$createElement("div", this.setTextColor(t, {
+        key: String(this.value)
+      }), [this.$createElement("button", {
+        attrs: {
+          type: "button"
+        },
+        on: {
+          click: () => this.$emit("toggle")
+        }
+      }, [this.$slots.default || this.formatter(String(this.value))])]), i = this.$createElement("transition", {
+        props: {
+          name: this.isReversing === !this.$vuetify.rtl ? "tab-reverse-transition" : "tab-transition"
+        }
+      }, [e]);
+      return this.$createElement("div", {
+        staticClass: "v-date-picker-header__value",
+        class: {
+          "v-date-picker-header__value--disabled": this.disabled
+        }
+      }, [i]);
+    }
+  },
+  render() {
+    return this.$createElement("div", {
+      staticClass: "v-date-picker-header",
+      class: {
+        "v-date-picker-header--disabled": this.disabled,
+        ...this.themeClasses
+      }
+    }, [this.genBtn(-1), this.genHeader(), this.genBtn(1)]);
+  }
+});
+function I(t, e, i, s) {
+  return (!s || s(t)) && (!e || t >= e.substr(0, 10)) && (!i || t <= i);
+}
+const L = c(
+  f,
+  k,
+  v
+  /* @vue/component */
+).extend({
+  directives: {
+    Touch: G
+  },
+  props: {
+    allowedDates: Function,
+    current: String,
+    disabled: Boolean,
+    format: Function,
+    events: {
+      type: [Array, Function, Object],
+      default: () => null
+    },
+    eventColor: {
+      type: [Array, Function, Object, String],
+      default: () => "warning"
+    },
+    min: String,
+    max: String,
+    range: Boolean,
+    readonly: Boolean,
+    scrollable: Boolean,
+    tableDate: {
+      type: String,
+      required: !0
+    },
+    value: [String, Array]
+  },
+  data: () => ({
+    isReversing: !1,
+    wheelThrottle: null
+  }),
+  computed: {
+    computedTransition() {
+      return this.isReversing === !this.$vuetify.rtl ? "tab-reverse-transition" : "tab-transition";
+    },
+    displayedMonth() {
+      return Number(this.tableDate.split("-")[1]) - 1;
+    },
+    displayedYear() {
+      return Number(this.tableDate.split("-")[0]);
+    }
+  },
+  watch: {
+    tableDate(t, e) {
+      this.isReversing = t < e;
+    }
+  },
+  mounted() {
+    this.wheelThrottle = H(this.wheel, 250);
+  },
+  methods: {
+    genButtonClasses(t, e, i, s, n, r) {
+      return {
+        "v-size--default": !e,
+        "v-date-picker-table__current": s,
+        "v-btn--active": i,
+        "v-btn--flat": !t || this.disabled,
+        "v-btn--text": i === s,
+        "v-btn--rounded": e,
+        "v-btn--disabled": !t || this.disabled,
+        "v-btn--outlined": s && !i,
+        "v-date-picker--first-in-range": n,
+        "v-date-picker--last-in-range": r,
+        ...this.themeClasses
+      };
+    },
+    genButtonEvents(t, e, i) {
+      if (!this.disabled)
+        return A({
+          click: () => {
+            e && !this.readonly && this.$emit("input", t);
+          }
+        }, B(this, `:${i}`, t));
+    },
+    genButton(t, e, i, s, n = !1) {
+      const r = I(t, this.min, this.max, this.allowedDates), a = this.isSelected(t) && r, o = t === this.current, u = a ? this.setBackgroundColor : this.setTextColor, b = (a || o) && (this.color || "accent");
+      let g = !1, d = !1;
+      return this.range && this.value && Array.isArray(this.value) && (g = t === this.value[0], d = t === this.value[this.value.length - 1]), this.$createElement("button", u(b, {
+        staticClass: "v-btn",
+        class: this.genButtonClasses(r && !n, e, a, o, g, d),
+        attrs: {
+          type: "button"
+        },
+        domProps: {
+          disabled: this.disabled || !r || n
+        },
+        on: this.genButtonEvents(t, r, i)
+      }), [this.$createElement("div", {
+        staticClass: "v-btn__content"
+      }, [s(t)]), this.genEvents(t)]);
+    },
+    getEventColors(t) {
+      const e = (n) => Array.isArray(n) ? n : [n];
+      let i, s = [];
+      if (Array.isArray(this.events) ? i = this.events.includes(t) : this.events instanceof Function ? i = this.events(t) || !1 : this.events ? i = this.events[t] || !1 : i = !1, i)
+        i !== !0 ? s = e(i) : typeof this.eventColor == "string" ? s = [this.eventColor] : typeof this.eventColor == "function" ? s = e(this.eventColor(t)) : Array.isArray(this.eventColor) ? s = this.eventColor : s = e(this.eventColor[t]);
+      else
+        return [];
+      return s.filter((n) => n);
+    },
+    genEvents(t) {
+      const e = this.getEventColors(t);
+      return e.length ? this.$createElement("div", {
+        staticClass: "v-date-picker-table__events"
+      }, e.map((i) => this.$createElement("div", this.setBackgroundColor(i)))) : null;
+    },
+    isValidScroll(t, e) {
+      const i = e(t), s = i.split("-").length === 1 ? "year" : "month";
+      return t < 0 && (this.min ? i >= h(this.min, s) : !0) || t > 0 && (this.max ? i <= h(this.max, s) : !0);
+    },
+    wheel(t, e) {
+      this.$emit("update:table-date", e(t.deltaY));
+    },
+    touch(t, e) {
+      this.$emit("update:table-date", e(t));
+    },
+    genTable(t, e, i) {
+      const s = this.$createElement("transition", {
+        props: {
+          name: this.computedTransition
+        }
+      }, [this.$createElement("table", {
+        key: this.tableDate
+      }, e)]), n = {
+        name: "touch",
+        value: {
+          left: (r) => r.offsetX < -15 && this.isValidScroll(1, i) && this.touch(1, i),
+          right: (r) => r.offsetX > 15 && this.isValidScroll(-1, i) && this.touch(-1, i)
+        }
+      };
+      return this.$createElement("div", {
+        staticClass: t,
+        class: {
+          "v-date-picker-table--disabled": this.disabled,
+          ...this.themeClasses
+        },
+        on: !this.disabled && this.scrollable ? {
+          wheel: (r) => {
+            r.preventDefault(), this.isValidScroll(r.deltaY, i) && this.wheelThrottle(r, i);
+          }
+        } : void 0,
+        directives: [n]
+      }, [s]);
+    },
+    isSelected(t) {
+      if (Array.isArray(this.value))
+        if (this.range && this.value.length === 2) {
+          const [e, i] = [...this.value].sort();
+          return e <= t && t <= i;
+        } else
+          return this.value.indexOf(t) !== -1;
+      return t === this.value;
+    }
+  }
+}), lt = c(
+  L
+  /* @vue/component */
+).extend({
+  name: "v-date-picker-date-table",
+  props: {
+    firstDayOfWeek: {
+      type: [String, Number],
+      default: 0
+    },
+    localeFirstDayOfYear: {
+      type: [String, Number],
+      default: 0
+    },
+    showAdjacentMonths: Boolean,
+    showWeek: Boolean,
+    weekdayFormat: Function
+  },
+  computed: {
+    formatter() {
+      return this.format || p(this.currentLocale, {
+        day: "numeric",
+        timeZone: "UTC"
+      }, {
+        start: 8,
+        length: 2
+      });
+    },
+    weekdayFormatter() {
+      return this.weekdayFormat || p(this.currentLocale, {
+        weekday: "narrow",
+        timeZone: "UTC"
+      });
+    },
+    weekDays() {
+      const t = parseInt(this.firstDayOfWeek, 10);
+      return this.weekdayFormatter ? x(7).map((e) => this.weekdayFormatter(`2017-01-${t + e + 15}`)) : x(7).map((e) => ["S", "M", "T", "W", "T", "F", "S"][(e + t) % 7]);
+    }
+  },
+  methods: {
+    calculateTableDate(t) {
+      return P(this.tableDate, Math.sign(t || 1));
+    },
+    genTHead() {
+      const t = this.weekDays.map((e) => this.$createElement("th", e));
+      return this.showWeek && t.unshift(this.$createElement("th")), this.$createElement("thead", this.genTR(t));
+    },
+    // Returns number of the days from the firstDayOfWeek to the first day of the current month
+    weekDaysBeforeFirstDayOfTheMonth() {
+      return ((/* @__PURE__ */ new Date(`${this.displayedYear}-${l(this.displayedMonth + 1)}-01T00:00:00+00:00`)).getUTCDay() - parseInt(this.firstDayOfWeek) + 7) % 7;
+    },
+    getWeekNumber(t) {
+      return Q(this.displayedYear, this.displayedMonth, t, parseInt(this.firstDayOfWeek), parseInt(this.localeFirstDayOfYear));
+    },
+    genWeekNumber(t) {
+      return this.$createElement("td", [this.$createElement("small", {
+        staticClass: "v-date-picker-table--date__week"
+      }, String(t).padStart(2, "0"))]);
+    },
+    // eslint-disable-next-line max-statements
+    genTBody() {
+      const t = [], e = new Date(this.displayedYear, this.displayedMonth + 1, 0).getDate();
+      let i = [], s = this.weekDaysBeforeFirstDayOfTheMonth();
+      this.showWeek && i.push(this.genWeekNumber(this.getWeekNumber(1)));
+      const n = this.displayedMonth ? this.displayedYear : this.displayedYear - 1, r = (this.displayedMonth + 11) % 12, a = new Date(this.displayedYear, this.displayedMonth, 0).getDate(), o = this.showWeek ? 8 : 7;
+      for (; s--; ) {
+        const d = `${n}-${l(r + 1)}-${l(a - s)}`;
+        i.push(this.$createElement("td", this.showAdjacentMonths ? [this.genButton(d, !0, "date", this.formatter, !0)] : []));
+      }
+      for (s = 1; s <= e; s++) {
+        const d = `${this.displayedYear}-${l(this.displayedMonth + 1)}-${l(s)}`;
+        i.push(this.$createElement("td", [this.genButton(d, !0, "date", this.formatter)])), i.length % o === 0 && (t.push(this.genTR(i)), i = [], this.showWeek && (s < e || this.showAdjacentMonths) && i.push(this.genWeekNumber(this.getWeekNumber(s + 7))));
+      }
+      const u = this.displayedMonth === 11 ? this.displayedYear + 1 : this.displayedYear, b = (this.displayedMonth + 1) % 12;
+      let g = 1;
+      for (; i.length < o; ) {
+        const d = `${u}-${l(b + 1)}-${l(g++)}`;
+        i.push(this.$createElement("td", this.showAdjacentMonths ? [this.genButton(d, !0, "date", this.formatter, !0)] : []));
+      }
+      return i.length && t.push(this.genTR(i)), this.$createElement("tbody", t);
+    },
+    genTR(t) {
+      return [this.$createElement("tr", t)];
+    }
+  },
+  render() {
+    return this.genTable("v-date-picker-table v-date-picker-table--date", [this.genTHead(), this.genTBody()], this.calculateTableDate);
+  }
+}), ot = c(
+  L
+  /* @vue/component */
+).extend({
+  name: "v-date-picker-month-table",
+  computed: {
+    formatter() {
+      return this.format || p(this.currentLocale, {
+        month: "short",
+        timeZone: "UTC"
+      }, {
+        start: 5,
+        length: 2
+      });
+    }
+  },
+  methods: {
+    calculateTableDate(t) {
+      return `${parseInt(this.tableDate, 10) + Math.sign(t || 1)}`;
+    },
+    genTBody() {
+      const t = [], e = Array(3).fill(null), i = 12 / e.length;
+      for (let s = 0; s < i; s++) {
+        const n = e.map((r, a) => {
+          const o = s * e.length + a, u = `${this.displayedYear}-${l(o + 1)}`;
+          return this.$createElement("td", {
+            key: o
+          }, [this.genButton(u, !1, "month", this.formatter)]);
+        });
+        t.push(this.$createElement("tr", {
+          key: s
+        }, n));
+      }
+      return this.$createElement("tbody", t);
+    }
+  },
+  render() {
+    return this.genTable("v-date-picker-table v-date-picker-table--month", [this.genTBody()], this.calculateTableDate);
+  }
+}), ht = c(
+  f,
+  k
+  /* @vue/component */
+).extend({
+  name: "v-date-picker-years",
+  props: {
+    format: Function,
+    min: [Number, String],
+    max: [Number, String],
+    readonly: Boolean,
+    value: [Number, String]
+  },
+  data() {
+    return {
+      defaultColor: "primary"
+    };
+  },
+  computed: {
+    formatter() {
+      return this.format || p(this.currentLocale, {
+        year: "numeric",
+        timeZone: "UTC"
+      }, {
+        length: 4
+      });
+    }
+  },
+  mounted() {
+    setTimeout(() => {
+      const t = this.$el.getElementsByClassName("active")[0];
+      t ? this.$el.scrollTop = t.offsetTop - this.$el.offsetHeight / 2 + t.offsetHeight / 2 : this.min && !this.max ? this.$el.scrollTop = this.$el.scrollHeight : !this.min && this.max ? this.$el.scrollTop = 0 : this.$el.scrollTop = this.$el.scrollHeight / 2 - this.$el.offsetHeight / 2;
+    });
+  },
+  methods: {
+    genYearItem(t) {
+      const e = this.formatter(`${t}`), i = parseInt(this.value, 10) === t, s = i && (this.color || "primary");
+      return this.$createElement("li", this.setTextColor(s, {
+        key: t,
+        class: {
+          active: i
+        },
+        on: A({
+          click: () => this.$emit("input", t)
+        }, B(this, ":year", t))
+      }), e);
+    },
+    genYearItems() {
+      const t = [], e = this.value ? parseInt(this.value, 10) : (/* @__PURE__ */ new Date()).getFullYear(), i = this.max ? parseInt(this.max, 10) : e + 100, s = Math.min(i, this.min ? parseInt(this.min, 10) : e - 100);
+      for (let n = i; n >= s; n--)
+        t.push(this.genYearItem(n));
+      return t;
+    }
+  },
+  render() {
+    return this.$createElement("ul", {
+      staticClass: "v-date-picker-years",
+      ref: "years"
+    }, this.genYearItems());
+  }
+}), ct = c(f, F, v).extend({
+  name: "v-picker",
+  props: {
+    flat: Boolean,
+    fullWidth: Boolean,
+    landscape: Boolean,
+    noTitle: Boolean,
+    transition: {
+      type: String,
+      default: "fade-transition"
+    },
+    width: {
+      type: [Number, String],
+      default: 290
+    }
+  },
+  computed: {
+    computedTitleColor() {
+      const t = this.isDark ? !1 : this.color || "primary";
+      return this.color || t;
+    }
+  },
+  methods: {
+    genTitle() {
+      return this.$createElement("div", this.setBackgroundColor(this.computedTitleColor, {
+        staticClass: "v-picker__title",
+        class: {
+          "v-picker__title--landscape": this.landscape
+        }
+      }), this.$slots.title);
+    },
+    genBodyTransition() {
+      return this.$createElement("transition", {
+        props: {
+          name: this.transition
+        }
+      }, this.$slots.default);
+    },
+    genBody() {
+      return this.$createElement("div", {
+        staticClass: "v-picker__body",
+        class: {
+          "v-picker__body--no-title": this.noTitle,
+          ...this.themeClasses
+        },
+        style: this.fullWidth ? void 0 : {
+          width: Z(this.width)
+        }
+      }, [this.genBodyTransition()]);
+    },
+    genActions() {
+      return this.$createElement("div", {
+        staticClass: "v-picker__actions v-card__actions",
+        class: {
+          "v-picker__actions--no-title": this.noTitle
+        }
+      }, this.$slots.actions);
+    }
+  },
+  render(t) {
+    return t("div", {
+      staticClass: "v-picker v-card",
+      class: {
+        "v-picker--flat": this.flat,
+        "v-picker--landscape": this.landscape,
+        "v-picker--full-width": this.fullWidth,
+        ...this.themeClasses,
+        ...this.elevationClasses
+      }
+    }, [this.$slots.title ? this.genTitle() : null, this.genBody(), this.$slots.actions ? this.genActions() : null]);
+  }
+}), ut = c(
+  f,
+  F,
+  v
+  /* @vue/component */
+).extend({
+  name: "picker",
+  props: {
+    flat: Boolean,
+    fullWidth: Boolean,
+    headerColor: String,
+    landscape: Boolean,
+    noTitle: Boolean,
+    width: {
+      type: [Number, String],
+      default: 290
+    }
+  },
+  methods: {
+    genPickerTitle() {
+      return null;
+    },
+    genPickerBody() {
+      return null;
+    },
+    genPickerActionsSlot() {
+      return this.$scopedSlots.default ? this.$scopedSlots.default({
+        save: this.save,
+        cancel: this.cancel
+      }) : this.$slots.default;
+    },
+    genPicker(t) {
+      const e = [];
+      if (!this.noTitle) {
+        const s = this.genPickerTitle();
+        s && e.push(s);
+      }
+      const i = this.genPickerBody();
+      return i && e.push(i), e.push(this.$createElement("template", {
+        slot: "actions"
+      }, [this.genPickerActionsSlot()])), this.$createElement(ct, {
+        staticClass: t,
+        props: {
+          color: this.headerColor || this.color,
+          dark: this.dark,
+          elevation: this.elevation,
+          flat: this.flat,
+          fullWidth: this.fullWidth,
+          landscape: this.landscape,
+          light: this.light,
+          width: this.width,
+          noTitle: this.noTitle
+        }
+      }, e);
+    }
+  }
+}), S = c(k, ut).extend({
+  name: "v-date-picker",
+  props: {
+    activePicker: String,
+    allowedDates: Function,
+    // Function formatting the day in date picker table
+    dayFormat: Function,
+    disabled: Boolean,
+    events: {
+      type: [Array, Function, Object],
+      default: () => null
+    },
+    eventColor: {
+      type: [Array, Function, Object, String],
+      default: () => "warning"
+    },
+    firstDayOfWeek: {
+      type: [String, Number],
+      default: 0
+    },
+    // Function formatting the tableDate in the day/month table header
+    headerDateFormat: Function,
+    localeFirstDayOfYear: {
+      type: [String, Number],
+      default: 0
+    },
+    max: String,
+    min: String,
+    // Function formatting month in the months table
+    monthFormat: Function,
+    multiple: Boolean,
+    nextIcon: {
+      type: String,
+      default: "$next"
+    },
+    nextMonthAriaLabel: {
+      type: String,
+      default: "$vuetify.datePicker.nextMonthAriaLabel"
+    },
+    nextYearAriaLabel: {
+      type: String,
+      default: "$vuetify.datePicker.nextYearAriaLabel"
+    },
+    pickerDate: String,
+    prevIcon: {
+      type: String,
+      default: "$prev"
+    },
+    prevMonthAriaLabel: {
+      type: String,
+      default: "$vuetify.datePicker.prevMonthAriaLabel"
+    },
+    prevYearAriaLabel: {
+      type: String,
+      default: "$vuetify.datePicker.prevYearAriaLabel"
+    },
+    range: Boolean,
+    reactive: Boolean,
+    readonly: Boolean,
+    scrollable: Boolean,
+    showCurrent: {
+      type: [Boolean, String],
+      default: !0
+    },
+    selectedItemsText: {
+      type: String,
+      default: "$vuetify.datePicker.itemsSelected"
+    },
+    showAdjacentMonths: Boolean,
+    showWeek: Boolean,
+    // Function formatting currently selected date in the picker title
+    titleDateFormat: Function,
+    type: {
+      type: String,
+      default: "date",
+      validator: (t) => ["date", "month"].includes(t)
+      // TODO: year
+    },
+    value: [Array, String],
+    weekdayFormat: Function,
+    // Function formatting the year in table header and pickup title
+    yearFormat: Function,
+    yearIcon: String
+  },
+  data() {
+    const t = /* @__PURE__ */ new Date();
+    return {
+      internalActivePicker: this.type.toUpperCase(),
+      inputDay: null,
+      inputMonth: null,
+      inputYear: null,
+      isReversing: !1,
+      now: t,
+      // tableDate is a string in 'YYYY' / 'YYYY-M' format (leading zero for month is not required)
+      tableDate: (() => {
+        if (this.pickerDate)
+          return this.pickerDate;
+        const e = E(this.value), i = e[e.length - 1] || (typeof this.showCurrent == "string" ? this.showCurrent : `${t.getFullYear()}-${t.getMonth() + 1}`);
+        return h(i, this.type === "date" ? "month" : "year");
+      })()
+    };
+  },
+  computed: {
+    multipleValue() {
+      return E(this.value);
+    },
+    isMultiple() {
+      return this.multiple || this.range;
+    },
+    lastValue() {
+      return this.isMultiple ? this.multipleValue[this.multipleValue.length - 1] : this.value;
+    },
+    selectedMonths() {
+      return !this.value || this.type === "month" ? this.value : this.isMultiple ? this.multipleValue.map((t) => t.substr(0, 7)) : this.value.substr(0, 7);
+    },
+    current() {
+      return this.showCurrent === !0 ? h(`${this.now.getFullYear()}-${this.now.getMonth() + 1}-${this.now.getDate()}`, this.type) : this.showCurrent || null;
+    },
+    inputDate() {
+      return this.type === "date" ? `${this.inputYear}-${l(this.inputMonth + 1)}-${l(this.inputDay)}` : `${this.inputYear}-${l(this.inputMonth + 1)}`;
+    },
+    tableMonth() {
+      return Number((this.pickerDate || this.tableDate).split("-")[1]) - 1;
+    },
+    tableYear() {
+      return Number((this.pickerDate || this.tableDate).split("-")[0]);
+    },
+    minMonth() {
+      return this.min ? h(this.min, "month") : null;
+    },
+    maxMonth() {
+      return this.max ? h(this.max, "month") : null;
+    },
+    minYear() {
+      return this.min ? h(this.min, "year") : null;
+    },
+    maxYear() {
+      return this.max ? h(this.max, "year") : null;
+    },
+    formatters() {
+      return {
+        year: this.yearFormat || p(this.currentLocale, {
+          year: "numeric",
+          timeZone: "UTC"
+        }, {
+          length: 4
+        }),
+        titleDate: this.titleDateFormat || (this.isMultiple ? this.defaultTitleMultipleDateFormatter : this.defaultTitleDateFormatter)
+      };
+    },
+    defaultTitleMultipleDateFormatter() {
+      return (t) => t.length ? t.length === 1 ? this.defaultTitleDateFormatter(t[0]) : this.$vuetify.lang.t(this.selectedItemsText, t.length) : "-";
+    },
+    defaultTitleDateFormatter() {
+      const t = {
+        year: {
+          year: "numeric",
+          timeZone: "UTC"
+        },
+        month: {
+          month: "long",
+          timeZone: "UTC"
+        },
+        date: {
+          weekday: "short",
+          month: "short",
+          day: "numeric",
+          timeZone: "UTC"
+        }
+      }, e = p(this.currentLocale, t[this.type], {
+        start: 0,
+        length: {
+          date: 10,
+          month: 7,
+          year: 4
+        }[this.type]
+      }), i = (s) => e(s).replace(/([^\d\s])([\d])/g, (n, r, a) => `${r} ${a}`).replace(", ", ",<br>");
+      return this.landscape ? i : e;
+    }
+  },
+  watch: {
+    internalActivePicker: {
+      immediate: !0,
+      handler(t) {
+        this.$emit("update:active-picker", t);
+      }
+    },
+    activePicker(t) {
+      this.internalActivePicker = t;
+    },
+    tableDate(t, e) {
+      const i = this.type === "month" ? "year" : "month";
+      this.isReversing = h(t, i) < h(e, i), this.$emit("update:picker-date", t);
+    },
+    pickerDate(t) {
+      t ? this.tableDate = t : this.lastValue && this.type === "date" ? this.tableDate = h(this.lastValue, "month") : this.lastValue && this.type === "month" && (this.tableDate = h(this.lastValue, "year"));
+    },
+    value(t, e) {
+      this.checkMultipleProp(), this.setInputDate(), (!this.isMultiple && this.value && !this.pickerDate || this.isMultiple && this.multipleValue.length && (!e || !e.length) && !this.pickerDate) && (this.tableDate = h(this.inputDate, this.type === "month" ? "year" : "month"));
+    },
+    type(t) {
+      if (this.internalActivePicker = t.toUpperCase(), this.value && this.value.length) {
+        const e = this.multipleValue.map((i) => h(i, t)).filter(this.isDateAllowed);
+        this.$emit("input", this.isMultiple ? e : e[0]);
+      }
+    }
+  },
+  created() {
+    this.checkMultipleProp(), this.pickerDate !== this.tableDate && this.$emit("update:picker-date", this.tableDate), this.setInputDate();
+  },
+  methods: {
+    emitInput(t) {
+      if (this.range) {
+        if (this.multipleValue.length !== 1)
+          this.$emit("input", [t]);
+        else {
+          const i = [this.multipleValue[0], t];
+          this.$emit("input", i), this.$emit("change", i);
+        }
+        return;
+      }
+      const e = this.multiple ? this.multipleValue.indexOf(t) === -1 ? this.multipleValue.concat([t]) : this.multipleValue.filter((i) => i !== t) : t;
+      this.$emit("input", e), this.multiple || this.$emit("change", t);
+    },
+    checkMultipleProp() {
+      if (this.value == null)
+        return;
+      const t = this.value.constructor.name, e = this.isMultiple ? "Array" : "String";
+      t !== e && z(`Value must be ${this.isMultiple ? "an" : "a"} ${e}, got ${t}`, this);
+    },
+    isDateAllowed(t) {
+      return I(t, this.min, this.max, this.allowedDates);
+    },
+    yearClick(t) {
+      this.inputYear = t, this.type === "month" ? this.tableDate = `${t}` : this.tableDate = `${t}-${l((this.tableMonth || 0) + 1)}`, this.internalActivePicker = "MONTH", this.reactive && !this.readonly && !this.isMultiple && this.isDateAllowed(this.inputDate) && this.$emit("input", this.inputDate);
+    },
+    monthClick(t) {
+      const [e, i] = t.split("-");
+      this.inputYear = parseInt(e, 10), this.inputMonth = parseInt(i, 10) - 1, this.type === "date" ? (this.inputDay && (this.inputDay = Math.min(this.inputDay, it(this.inputYear, this.inputMonth + 1))), this.tableDate = t, this.internalActivePicker = "DATE", this.reactive && !this.readonly && !this.isMultiple && this.isDateAllowed(this.inputDate) && this.$emit("input", this.inputDate)) : this.emitInput(this.inputDate);
+    },
+    dateClick(t) {
+      const [e, i, s] = t.split("-");
+      this.inputYear = parseInt(e, 10), this.inputMonth = parseInt(i, 10) - 1, this.inputDay = parseInt(s, 10), this.emitInput(this.inputDate);
+    },
+    genPickerTitle() {
+      return this.$createElement(nt, {
+        props: {
+          date: this.value ? this.formatters.titleDate(this.isMultiple ? this.multipleValue : this.value) : "",
+          disabled: this.disabled,
+          readonly: this.readonly,
+          selectingYear: this.internalActivePicker === "YEAR",
+          year: this.formatters.year(this.multipleValue.length ? `${this.inputYear}` : this.tableDate),
+          yearIcon: this.yearIcon,
+          value: this.multipleValue[0]
+        },
+        slot: "title",
+        on: {
+          "update:selecting-year": (t) => this.internalActivePicker = t ? "YEAR" : this.type.toUpperCase()
+        }
+      });
+    },
+    genTableHeader() {
+      return this.$createElement(at, {
+        props: {
+          nextIcon: this.nextIcon,
+          color: this.color,
+          dark: this.dark,
+          disabled: this.disabled,
+          format: this.headerDateFormat,
+          light: this.light,
+          locale: this.locale,
+          min: this.internalActivePicker === "DATE" ? this.minMonth : this.minYear,
+          max: this.internalActivePicker === "DATE" ? this.maxMonth : this.maxYear,
+          nextAriaLabel: this.internalActivePicker === "DATE" ? this.nextMonthAriaLabel : this.nextYearAriaLabel,
+          prevAriaLabel: this.internalActivePicker === "DATE" ? this.prevMonthAriaLabel : this.prevYearAriaLabel,
+          prevIcon: this.prevIcon,
+          readonly: this.readonly,
+          value: this.internalActivePicker === "DATE" ? `${l(this.tableYear, 4)}-${l(this.tableMonth + 1)}` : `${l(this.tableYear, 4)}`
+        },
+        on: {
+          toggle: () => this.internalActivePicker = this.internalActivePicker === "DATE" ? "MONTH" : "YEAR",
+          input: (t) => this.tableDate = t
+        }
+      });
+    },
+    genDateTable() {
+      return this.$createElement(lt, {
+        props: {
+          allowedDates: this.allowedDates,
+          color: this.color,
+          current: this.current,
+          dark: this.dark,
+          disabled: this.disabled,
+          events: this.events,
+          eventColor: this.eventColor,
+          firstDayOfWeek: this.firstDayOfWeek,
+          format: this.dayFormat,
+          light: this.light,
+          locale: this.locale,
+          localeFirstDayOfYear: this.localeFirstDayOfYear,
+          min: this.min,
+          max: this.max,
+          range: this.range,
+          readonly: this.readonly,
+          scrollable: this.scrollable,
+          showAdjacentMonths: this.showAdjacentMonths,
+          showWeek: this.showWeek,
+          tableDate: `${l(this.tableYear, 4)}-${l(this.tableMonth + 1)}`,
+          value: this.value,
+          weekdayFormat: this.weekdayFormat
+        },
+        ref: "table",
+        on: {
+          input: this.dateClick,
+          "update:table-date": (t) => this.tableDate = t,
+          ...T(this, ":date")
+        }
+      });
+    },
+    genMonthTable() {
+      return this.$createElement(ot, {
+        props: {
+          allowedDates: this.type === "month" ? this.allowedDates : null,
+          color: this.color,
+          current: this.current ? h(this.current, "month") : null,
+          dark: this.dark,
+          disabled: this.disabled,
+          events: this.type === "month" ? this.events : null,
+          eventColor: this.type === "month" ? this.eventColor : null,
+          format: this.monthFormat,
+          light: this.light,
+          locale: this.locale,
+          min: this.minMonth,
+          max: this.maxMonth,
+          range: this.range,
+          readonly: this.readonly && this.type === "month",
+          scrollable: this.scrollable,
+          value: this.selectedMonths,
+          tableDate: `${l(this.tableYear, 4)}`
+        },
+        ref: "table",
+        on: {
+          input: this.monthClick,
+          "update:table-date": (t) => this.tableDate = t,
+          ...T(this, ":month")
+        }
+      });
+    },
+    genYears() {
+      return this.$createElement(ht, {
+        props: {
+          color: this.color,
+          format: this.yearFormat,
+          locale: this.locale,
+          min: this.minYear,
+          max: this.maxYear,
+          value: this.tableYear
+        },
+        on: {
+          input: this.yearClick,
+          ...T(this, ":year")
+        }
+      });
+    },
+    genPickerBody() {
+      const t = this.internalActivePicker === "YEAR" ? [this.genYears()] : [this.genTableHeader(), this.internalActivePicker === "DATE" ? this.genDateTable() : this.genMonthTable()];
+      return this.$createElement("div", {
+        key: this.internalActivePicker
+      }, t);
+    },
+    setInputDate() {
+      if (this.lastValue) {
+        const t = this.lastValue.split("-");
+        this.inputYear = parseInt(t[0], 10), this.inputMonth = parseInt(t[1], 10) - 1, this.type === "date" && (this.inputDay = parseInt(t[2], 10));
+      } else
+        this.inputYear = this.inputYear || this.now.getFullYear(), this.inputMonth = this.inputMonth == null ? this.inputMonth : this.now.getMonth(), this.inputDay = this.inputDay || this.now.getDate();
+    }
+  },
+  render() {
+    return this.genPicker("v-picker--date");
+  }
+});
+function dt(t) {
+  return M.extend({
+    name: `v-${t}`,
+    functional: !0,
+    props: {
+      id: String,
+      tag: {
+        type: String,
+        default: "div"
+      }
+    },
+    render(e, {
+      props: i,
+      data: s,
+      children: n
+    }) {
+      s.staticClass = `${t} ${s.staticClass || ""}`.trim();
+      const {
+        attrs: r
+      } = s;
+      if (r) {
+        s.attrs = {};
+        const a = Object.keys(r).filter((o) => {
+          if (o === "slot")
+            return !1;
+          const u = r[o];
+          return o.startsWith("data-") ? (s.attrs[o] = u, !1) : u || typeof u == "string";
+        });
+        a.length && (s.staticClass += ` ${a.join(" ")}`);
+      }
+      return i.id && (s.domProps = s.domProps || {}, s.domProps.id = i.id), e(i.tag, s, n);
+    }
+  });
+}
+const mt = dt("container").extend({
+  name: "v-container",
+  functional: !0,
+  props: {
+    id: String,
+    tag: {
+      type: String,
+      default: "div"
+    },
+    fluid: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  render(t, {
+    props: e,
+    data: i,
+    children: s
+  }) {
+    let n;
+    const {
+      attrs: r
+    } = i;
+    return r && (i.attrs = {}, n = Object.keys(r).filter((a) => {
+      if (a === "slot")
+        return !1;
+      const o = r[a];
+      return a.startsWith("data-") ? (i.attrs[a] = o, !1) : o || typeof o == "string";
+    })), e.id && (i.domProps = i.domProps || {}, i.domProps.id = e.id), t(e.tag, R(i, {
+      staticClass: "container",
+      class: Array({
+        "container--fluid": e.fluid
+      }).concat(n || [])
+    }), s);
+  }
+}), pt = {
+  value: { type: Array },
+  minDate: {
+    default: m().format("YYYY-MM-DD"),
+    type: String,
+    required: !1
+  }
+}, ft = M.extend({
+  name: "BDateRangePicker",
+  mixins: [W("components/ui/BDateRangePicker"), N],
+  props: pt,
+  data() {
+    return {
+      model: this.value,
+      dateFrom: this.value && this.value[0],
+      dateTo: this.value && this.value[1],
+      monthFrom: this.value && this.value[0],
+      monthTo: this.value && m(this.value[0]).add(1, "month").format("YYYY-MM-DD")
+    };
+  },
+  computed: {
+    nightCount() {
+      return !this.model || this.model.length < 2 ? 0 : m(this.model[1]).diff(m(this.model[0]), "day");
+    },
+    eventDateMarkers() {
+      const t = window.RevolugoElements.config.eventMetadata, e = t == null ? void 0 : t.dateStart, i = t == null ? void 0 : t.dateEnd;
+      let s = null;
+      return e && i && (s = this.getDatesBetween(e, i)), s;
+    }
+  },
+  watch: {
+    monthFrom: {
+      handler() {
+        this.monthTo = m(this.monthFrom).add(1, "month").format("YYYY-MM-DD");
+      }
+    },
+    monthTo: {
+      handler() {
+        this.monthFrom = m(this.monthTo).add(-1, "month").format("YYYY-MM-DD");
+      }
+    },
+    value: {
+      handler(t) {
+        t && (this.model = V(t[0], t[1]), this.dateFrom = this.model[0], this.dateTo = this.model[1], this.$emit("input", this.model));
+      },
+      deep: !0
+    }
+  },
+  methods: {
+    onDateClicked(t) {
+      if (this.dateFrom && this.dateTo || !this.dateFrom && !this.dateTo)
+        this.dateFrom = t, this.dateTo = "";
+      else if (this.dateFrom) {
+        if (t === this.dateFrom)
+          return;
+        this.dateTo = t, this.model = Y([
+          this.dateFrom,
+          this.dateTo
+        ]), this.$emit("input", this.model);
+      }
+    },
+    onDateMouseEntered(t) {
+      this.dateFrom && this.dateTo || !this.dateFrom && !this.dateTo || (this.model = t === this.dateFrom ? [this.dateFrom, this.dateFrom] : Y([
+        this.dateFrom,
+        t
+      ]));
+    },
+    onDateMouseLeft() {
+      this.dateTo || (this.model = [this.dateFrom, this.dateFrom]);
+    },
+    readableDate(t) {
+      if (t)
+        return m(t).toDate().toLocaleString(this.$i18n.locale, {
+          weekday: "short",
+          day: "2-digit",
+          month: "short"
+        });
+    },
+    getDatesBetween(t, e) {
+      const i = [];
+      let s = m(t);
+      for (; s.isBefore(e) || s.isSame(e); )
+        i.push(s.format("YYYY-MM-DD")), s = s.add(1, "day");
+      return i;
+    }
+  }
+});
+var gt = function() {
+  var e = this, i = e._self._c;
+  return e._self._setupProxy, i(mt, { staticClass: "text-center pa-3 px-n6 white" }, [i(D, { attrs: { "no-gutters": "" } }, [i(y, { attrs: { align: e.$breakpointService.xs ? "center" : "right", cols: e.$breakpointService.xs ? 12 : 6 } }, [i(S, { attrs: { color: "secondary", "event-color": "error lighten-1", events: e.eventDateMarkers, "first-day-of-week": 1, "full-width": e.$isCurrentBreakpointBelowOrEqual("sm"), locale: e.$i18n.locale, min: e.minDate || e.today, "next-icon": e.$breakpointService.xs ? "$next" : null, "no-title": "", "picker-date": e.monthFrom, range: "", scrollable: "", "show-current": !1 }, on: { "update:pickerDate": function(s) {
+    e.monthFrom = s;
+  }, "update:picker-date": function(s) {
+    e.monthFrom = s;
+  }, "click:date": e.onDateClicked, "mouseenter:date": e.onDateMouseEntered, "mouseleave:date": e.onDateMouseLeft }, model: { value: e.model, callback: function(s) {
+    e.model = s;
+  }, expression: "model" } })], 1), e.$breakpointService.xs ? e._e() : i(y, { attrs: { align: "left", cols: "6" } }, [i(S, { attrs: { color: "secondary", "event-color": "error lighten-1", events: e.eventDateMarkers, "first-day-of-week": 1, locale: e.$i18n.locale, min: e.minDate, "no-title": "", "picker-date": e.monthTo, "prev-icon": null, range: "", scrollable: "", "show-current": !1 }, on: { "update:pickerDate": function(s) {
+    e.monthTo = s;
+  }, "update:picker-date": function(s) {
+    e.monthTo = s;
+  }, "click:date": e.onDateClicked, "mouseenter:date": e.onDateMouseEntered, "mouseleave:date": e.onDateMouseLeft }, model: { value: e.model, callback: function(s) {
+    e.model = s;
+  }, expression: "model" } })], 1)], 1), i(D, { attrs: { "no-gutters": "" } }, [i(y, [i(X)], 1)], 1), i(D, { staticClass: "mt-0" }, [i(y, [i("p", { staticClass: "mb-1 text-center text-caption" }, [i("b", [e._v(e._s(e.model && e.readableDate(e.model[0]) || e.$t("BDateRangePicker.checkIn")))]), i(w, { staticClass: "mx-2" }, [e._v(" fa-long-arrow-alt-right ")]), i("b", [e._v(e._s(e.model && e.model[0] !== e.model[1] && e.readableDate(e.model[1]) || e.$t("BDateRangePicker.checkOut")))]), e.nightCount > 0 ? i("small", [e._v(" " + e._s(e.$tc("BDateRangePicker.stay", e.nightCount, { count: e.nightCount })) + " ")]) : e._e()], 1)])], 1)], 1);
+}, yt = [], vt = /* @__PURE__ */ U(
+  ft,
+  gt,
+  yt,
+  !1,
+  null,
+  "4d146a78",
+  null,
+  null
+);
+const Et = vt.exports;
+O("css/revolugo.bdaterangepicker.DEh20utH.css");
+export {
+  Et as B,
+  mt as _,
+  S as a
+};
+//# sourceMappingURL=revolugo.bdaterangepicker.DwXWu7y_.min.js.map