@revolugo/elements 5.5.4 → 5.5.5-beta.0

package/dist/revolugo.parsed-height.DRzHRmIo.min.js

@@ -0,0 +1,2492 @@
+import { q as Bt, J as T, h as x, y as nt, d as rt, K as C, k as kt, j as G, E as D } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+import { V as h, o as Rt, I as wt, d as St, e as Ot, P as Y, Q as Tt, R as It, A as j, S as q, N as at } from "./revolugo.i18n.DF3U6VhD.min.js";
+import { C as Ft } from "./revolugo.cancellationpoliciesbadge.BTwUNf7h.min.js";
+import { H as Vt } from "./revolugo.hotelofferitemlayout.BrulX_X4.min.js";
+import { B as At } from "./revolugo.bbreakfastoptionbadge.DND6bz7J.min.js";
+import { m as B, C as I, T as ot, n as m, h as Dt, B as Et, l as b, _ as v, a as u } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+import { _ as l } from "./revolugo.vbtn.CP4AezmI.min.js";
+import { S as Lt, _ as g } from "./revolugo.index.sTY3URQu.min.js";
+import { B as Nt } from "./revolugo.bhotelroomsdetails.8yoNt-KM.min.js";
+import { B as Ht } from "./revolugo.hotelroomofferlist.BltT6U-0.min.js";
+import { a as Pt, b as zt, B as Wt } from "./revolugo.bstarrating.B-PUaeDZ.min.js";
+import { B as Ut } from "./revolugo.btag.DD6eI8G4.min.js";
+import { H as Gt, B as Yt, b as jt, c as qt } from "./revolugo.hoteldescriptionview.C9XjZcdv.min.js";
+import { b as M } from "./revolugo.breakpoint-service.CwWRBzMQ.min.js";
+import { d as lt } from "./revolugo.dialog-attach.05NirMLv.min.js";
+import { a as ct, d as $, g as d, F as c, P as K, R as X, b as Z, D as w } from "./revolugo.store.DPvvq0Rz.min.js";
+import { H as Kt } from "./revolugo.hotelroomoffersview.4NC1efEJ.min.js";
+import { b as E, c as Xt, a as Zt, m as Jt, _ as Qt } from "./revolugo.hotel-offer.JfkzuZyf.min.js";
+import { e as te, a as ee } from "./revolugo.index.Cn8GgIte.min.js";
+import { O as ie, _ as se } from "./revolugo.vdialog.BAexO59W.min.js";
+import { _ as k } from "./revolugo.vcard.Cy5A2_pV.min.js";
+import { V as P, a as z, b as ne } from "./revolugo.index.owaXEEBO.min.js";
+import { _ as ut } from "./revolugo.vtooltip.B7xN8tzo.min.js";
+import { a as re, V as H, b as ae } from "./revolugo.index.DTZNxZHf.min.js";
+import { _ as oe } from "./revolugo.vautocomplete.C-5OLCEj.min.js";
+import { B as ht } from "./revolugo.bformattedamount.D4xCyTcv.min.js";
+import { V as J } from "./revolugo.vinput.CDpcVlCU.min.js";
+import { L as Q } from "./revolugo.index.BEcLuOn-.min.js";
+import { C as dt, R as le, T as ce } from "./revolugo.vuetify.yojzDMFk.min.js";
+import { _ as tt } from "./revolugo.vtextfield.D2qOTbGQ.min.js";
+import { _ as O } from "./revolugo.parsed-props.B_x1Ob04.min.js";
+import { _ as F } from "./revolugo.vmenu.CtMz9t6s.min.js";
+import { _ as V } from "./revolugo.vbadge.xQq9jf9W.min.js";
+import { D as ue, a as he } from "./revolugo.index.A8BtC3Nq.min.js";
+import { R as de } from "./revolugo.index.tY8MFB9m.min.js";
+import { Y as _, U as y } from "./revolugo.booking-api-client.Du5goV4n.min.js";
+import { B as L } from "./revolugo.vitemgroup.DyY_3pfW.min.js";
+import { a as me } from "./revolugo.vlistitem.CrJxrMpP.min.js";
+import { a as pe } from "./revolugo.vtoolbar.D3HhuFrj.min.js";
+import { S as fe, a as ve } from "./revolugo.index.BUUmIL9V.min.js";
+import { M as mt } from "./revolugo.vslidegroup.BXF0FLd1.min.js";
+function Ct(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 ge = B(L, I).extend({
+  name: "v-list-item-group",
+  provide() {
+    return {
+      isInGroup: !0,
+      listItemGroup: this
+    };
+  },
+  computed: {
+    classes() {
+      return {
+        ...L.options.computed.classes.call(this),
+        "v-list-item-group": !0
+      };
+    }
+  },
+  methods: {
+    genData() {
+      return this.setTextColor(this.color, {
+        ...L.options.methods.genData.call(this),
+        attrs: {
+          role: "listbox"
+        }
+      });
+    }
+  }
+}), _e = B(E, I).extend({
+  name: "v-btn-toggle",
+  props: {
+    backgroundColor: String,
+    borderless: Boolean,
+    dense: Boolean,
+    group: Boolean,
+    rounded: Boolean,
+    shaped: Boolean,
+    tile: Boolean
+  },
+  computed: {
+    classes() {
+      return {
+        ...E.options.computed.classes.call(this),
+        "v-btn-toggle": !0,
+        "v-btn-toggle--borderless": this.borderless,
+        "v-btn-toggle--dense": this.dense,
+        "v-btn-toggle--group": this.group,
+        "v-btn-toggle--rounded": this.rounded,
+        "v-btn-toggle--shaped": this.shaped,
+        "v-btn-toggle--tile": this.tile,
+        ...this.themeClasses
+      };
+    }
+  },
+  methods: {
+    genData() {
+      const e = this.setTextColor(this.color, {
+        ...E.options.methods.genData.call(this)
+      });
+      return this.group ? e : this.setBackgroundColor(this.backgroundColor, e);
+    }
+  }
+}), N = B(
+  J,
+  Q
+  /* @vue/component */
+).extend({
+  name: "v-slider",
+  directives: {
+    ClickOutside: dt
+  },
+  mixins: [Q],
+  props: {
+    disabled: Boolean,
+    inverseLabel: Boolean,
+    max: {
+      type: [Number, String],
+      default: 100
+    },
+    min: {
+      type: [Number, String],
+      default: 0
+    },
+    step: {
+      type: [Number, String],
+      default: 1
+    },
+    thumbColor: String,
+    thumbLabel: {
+      type: [Boolean, String],
+      default: void 0,
+      validator: (e) => typeof e == "boolean" || e === "always"
+    },
+    thumbSize: {
+      type: [Number, String],
+      default: 32
+    },
+    tickLabels: {
+      type: Array,
+      default: () => []
+    },
+    ticks: {
+      type: [Boolean, String],
+      default: !1,
+      validator: (e) => typeof e == "boolean" || e === "always"
+    },
+    tickSize: {
+      type: [Number, String],
+      default: 2
+    },
+    trackColor: String,
+    trackFillColor: String,
+    value: [Number, String],
+    vertical: Boolean
+  },
+  data: () => ({
+    app: null,
+    oldValue: null,
+    thumbPressed: !1,
+    mouseTimeout: -1,
+    isFocused: !1,
+    isActive: !1,
+    noClick: !1,
+    startOffset: 0
+  }),
+  computed: {
+    classes() {
+      return {
+        ...J.options.computed.classes.call(this),
+        "v-input__slider": !0,
+        "v-input__slider--vertical": this.vertical,
+        "v-input__slider--inverse-label": this.inverseLabel
+      };
+    },
+    internalValue: {
+      get() {
+        return this.lazyValue;
+      },
+      set(e) {
+        e = isNaN(e) ? this.minValue : e;
+        const t = this.roundValue(Math.min(Math.max(e, this.minValue), this.maxValue));
+        t !== this.lazyValue && (this.lazyValue = t, this.$emit("input", t));
+      }
+    },
+    trackTransition() {
+      return this.thumbPressed ? this.showTicks || this.stepNumeric ? "0.1s cubic-bezier(0.25, 0.8, 0.5, 1)" : "none" : "";
+    },
+    minValue() {
+      return parseFloat(this.min);
+    },
+    maxValue() {
+      return parseFloat(this.max);
+    },
+    stepNumeric() {
+      return this.step > 0 ? parseFloat(this.step) : 0;
+    },
+    inputWidth() {
+      const e = (this.roundValue(this.internalValue) - this.minValue) / (this.maxValue - this.minValue) * 100;
+      return isNaN(e) ? 0 : e;
+    },
+    trackFillStyles() {
+      const e = this.vertical ? "bottom" : "left", t = this.vertical ? "top" : "right", i = this.vertical ? "height" : "width", s = this.$vuetify.rtl ? "auto" : "0", n = this.$vuetify.rtl ? "0" : "auto", a = this.isDisabled ? `calc(${this.inputWidth}% - 10px)` : `${this.inputWidth}%`;
+      return {
+        transition: this.trackTransition,
+        [e]: s,
+        [t]: n,
+        [i]: a
+      };
+    },
+    trackStyles() {
+      const e = this.vertical ? this.$vuetify.rtl ? "bottom" : "top" : this.$vuetify.rtl ? "left" : "right", t = this.vertical ? "height" : "width", i = "0px", s = this.isDisabled ? `calc(${100 - this.inputWidth}% - 10px)` : `calc(${100 - this.inputWidth}%)`;
+      return {
+        transition: this.trackTransition,
+        [e]: i,
+        [t]: s
+      };
+    },
+    showTicks() {
+      return this.tickLabels.length > 0 || !!(!this.isDisabled && this.stepNumeric && this.ticks);
+    },
+    numTicks() {
+      return Math.ceil((this.maxValue - this.minValue) / this.stepNumeric);
+    },
+    showThumbLabel() {
+      return !this.isDisabled && !!(this.thumbLabel || this.$scopedSlots["thumb-label"]);
+    },
+    computedTrackColor() {
+      if (!this.isDisabled)
+        return this.trackColor ? this.trackColor : this.isDark ? this.validationState : this.validationState || "primary lighten-3";
+    },
+    computedTrackFillColor() {
+      if (!this.isDisabled)
+        return this.trackFillColor ? this.trackFillColor : this.validationState || this.computedColor;
+    },
+    computedThumbColor() {
+      return this.thumbColor ? this.thumbColor : this.validationState || this.computedColor;
+    }
+  },
+  watch: {
+    min(e) {
+      const t = parseFloat(e);
+      t > this.internalValue && this.$emit("input", t);
+    },
+    max(e) {
+      const t = parseFloat(e);
+      t < this.internalValue && this.$emit("input", t);
+    },
+    value: {
+      handler(e) {
+        this.internalValue = e;
+      },
+      immediate: !0
+    }
+  },
+  mounted() {
+    this.app = this.$el.closest("[data-app]") || Bt("Missing v-app or a non-body wrapping element with the [data-app] attribute", this);
+  },
+  methods: {
+    genDefaultSlot() {
+      const e = [this.genLabel()], t = this.genSlider();
+      return this.inverseLabel ? e.unshift(t) : e.push(t), e.push(this.genProgress()), e;
+    },
+    genSlider() {
+      return this.$createElement("div", {
+        class: {
+          "v-slider": !0,
+          "v-slider--horizontal": !this.vertical,
+          "v-slider--vertical": this.vertical,
+          "v-slider--focused": this.isFocused,
+          "v-slider--active": this.isActive,
+          "v-slider--disabled": this.isDisabled,
+          "v-slider--readonly": this.isReadonly,
+          ...this.themeClasses
+        },
+        directives: [{
+          name: "click-outside",
+          value: this.onBlur
+        }],
+        on: {
+          click: this.onSliderClick,
+          mousedown: this.onSliderMouseDown,
+          touchstart: this.onSliderMouseDown
+        }
+      }, this.genChildren());
+    },
+    genChildren() {
+      return [this.genInput(), this.genTrackContainer(), this.genSteps(), this.genThumbContainer(this.internalValue, this.inputWidth, this.isActive, this.isFocused, this.onFocus, this.onBlur)];
+    },
+    genInput() {
+      return this.$createElement("input", {
+        attrs: {
+          value: this.internalValue,
+          id: this.computedId,
+          disabled: !0,
+          readonly: !0,
+          tabindex: -1,
+          ...this.$attrs
+        }
+        // on: this.genListeners(), // TODO: do we need to attach the listeners to input?
+      });
+    },
+    genTrackContainer() {
+      const e = [this.$createElement("div", this.setBackgroundColor(this.computedTrackColor, {
+        staticClass: "v-slider__track-background",
+        style: this.trackStyles
+      })), this.$createElement("div", this.setBackgroundColor(this.computedTrackFillColor, {
+        staticClass: "v-slider__track-fill",
+        style: this.trackFillStyles
+      }))];
+      return this.$createElement("div", {
+        staticClass: "v-slider__track-container",
+        ref: "track"
+      }, e);
+    },
+    genSteps() {
+      if (!this.step || !this.showTicks)
+        return null;
+      const e = parseFloat(this.tickSize), t = T(this.numTicks + 1), i = this.vertical ? "bottom" : this.$vuetify.rtl ? "right" : "left", s = this.vertical ? this.$vuetify.rtl ? "left" : "right" : "top";
+      this.vertical && t.reverse();
+      const n = t.map((a) => {
+        const r = [];
+        this.tickLabels[a] && r.push(this.$createElement("div", {
+          staticClass: "v-slider__tick-label"
+        }, this.tickLabels[a]));
+        const o = a * (100 / this.numTicks), p = this.$vuetify.rtl ? 100 - this.inputWidth < o : o < this.inputWidth;
+        return this.$createElement("span", {
+          key: a,
+          staticClass: "v-slider__tick",
+          class: {
+            "v-slider__tick--filled": p
+          },
+          style: {
+            width: `${e}px`,
+            height: `${e}px`,
+            [i]: `calc(${o}% - ${e / 2}px)`,
+            [s]: `calc(50% - ${e / 2}px)`
+          }
+        }, r);
+      });
+      return this.$createElement("div", {
+        staticClass: "v-slider__ticks-container",
+        class: {
+          "v-slider__ticks-container--always-show": this.ticks === "always" || this.tickLabels.length > 0
+        }
+      }, n);
+    },
+    genThumbContainer(e, t, i, s, n, a, r = "thumb") {
+      const o = [this.genThumb()], p = this.genThumbLabelContent(e);
+      return this.showThumbLabel && o.push(this.genThumbLabel(p)), this.$createElement("div", this.setTextColor(this.computedThumbColor, {
+        ref: r,
+        key: r,
+        staticClass: "v-slider__thumb-container",
+        class: {
+          "v-slider__thumb-container--active": i,
+          "v-slider__thumb-container--focused": s,
+          "v-slider__thumb-container--show-label": this.showThumbLabel
+        },
+        style: this.getThumbContainerStyles(t),
+        attrs: {
+          role: "slider",
+          tabindex: this.isDisabled ? -1 : this.$attrs.tabindex ? this.$attrs.tabindex : 0,
+          "aria-label": this.$attrs["aria-label"] || this.label,
+          "aria-valuemin": this.min,
+          "aria-valuemax": this.max,
+          "aria-valuenow": this.internalValue,
+          "aria-readonly": String(this.isReadonly),
+          "aria-orientation": this.vertical ? "vertical" : "horizontal"
+        },
+        on: {
+          focus: n,
+          blur: a,
+          keydown: this.onKeyDown
+        }
+      }), o);
+    },
+    genThumbLabelContent(e) {
+      return this.$scopedSlots["thumb-label"] ? this.$scopedSlots["thumb-label"]({
+        value: e
+      }) : [this.$createElement("span", [String(e)])];
+    },
+    genThumbLabel(e) {
+      const t = x(this.thumbSize), i = this.vertical ? `translateY(20%) translateY(${Number(this.thumbSize) / 3 - 1}px) translateX(55%) rotate(135deg)` : "translateY(-20%) translateY(-12px) translateX(-50%) rotate(45deg)";
+      return this.$createElement(te, {
+        props: {
+          origin: "bottom center"
+        }
+      }, [this.$createElement("div", {
+        staticClass: "v-slider__thumb-label-container",
+        directives: [{
+          name: "show",
+          value: this.isFocused || this.isActive || this.thumbLabel === "always"
+        }]
+      }, [this.$createElement("div", this.setBackgroundColor(this.computedThumbColor, {
+        staticClass: "v-slider__thumb-label",
+        style: {
+          height: t,
+          width: t,
+          transform: i
+        }
+      }), [this.$createElement("div", e)])])]);
+    },
+    genThumb() {
+      return this.$createElement("div", this.setBackgroundColor(this.computedThumbColor, {
+        staticClass: "v-slider__thumb"
+      }));
+    },
+    getThumbContainerStyles(e) {
+      const t = this.vertical ? "top" : "left";
+      let i = this.$vuetify.rtl ? 100 - e : e;
+      return i = this.vertical ? 100 - i : i, {
+        transition: this.trackTransition,
+        [t]: `${i}%`
+      };
+    },
+    onSliderMouseDown(e) {
+      var t;
+      if (e.preventDefault(), this.oldValue = this.internalValue, this.isActive = !0, !((t = e.target) === null || t === void 0) && t.matches(".v-slider__thumb-container, .v-slider__thumb-container *")) {
+        this.thumbPressed = !0;
+        const a = e.target.getBoundingClientRect(), r = "touches" in e ? e.touches[0] : e;
+        this.startOffset = this.vertical ? r.clientY - (a.top + a.height / 2) : r.clientX - (a.left + a.width / 2);
+      } else
+        this.startOffset = 0, window.clearTimeout(this.mouseTimeout), this.mouseTimeout = window.setTimeout(() => {
+          this.thumbPressed = !0;
+        }, 300);
+      const i = C ? {
+        passive: !0,
+        capture: !0
+      } : !0, s = C ? {
+        passive: !0
+      } : !1, n = "touches" in e;
+      this.onMouseMove(e), this.app.addEventListener(n ? "touchmove" : "mousemove", this.onMouseMove, s), nt(this.app, n ? "touchend" : "mouseup", this.onSliderMouseUp, i), this.$emit("start", this.internalValue);
+    },
+    onSliderMouseUp(e) {
+      e.stopPropagation(), window.clearTimeout(this.mouseTimeout), this.thumbPressed = !1;
+      const t = C ? {
+        passive: !0
+      } : !1;
+      this.app.removeEventListener("touchmove", this.onMouseMove, t), this.app.removeEventListener("mousemove", this.onMouseMove, t), this.$emit("mouseup", e), this.$emit("end", this.internalValue), rt(this.oldValue, this.internalValue) || (this.$emit("change", this.internalValue), this.noClick = !0), this.isActive = !1;
+    },
+    onMouseMove(e) {
+      e.type === "mousemove" && (this.thumbPressed = !0), this.internalValue = this.parseMouseMove(e);
+    },
+    onKeyDown(e) {
+      if (!this.isInteractive)
+        return;
+      const t = this.parseKeyDown(e, this.internalValue);
+      t == null || t < this.minValue || t > this.maxValue || (this.internalValue = t, this.$emit("change", t));
+    },
+    onSliderClick(e) {
+      if (this.noClick) {
+        this.noClick = !1;
+        return;
+      }
+      this.$refs.thumb.focus(), this.onMouseMove(e), this.$emit("change", this.internalValue);
+    },
+    onBlur(e) {
+      this.isFocused = !1, this.$emit("blur", e);
+    },
+    onFocus(e) {
+      this.isFocused = !0, this.$emit("focus", e);
+    },
+    parseMouseMove(e) {
+      const t = this.vertical ? "top" : "left", i = this.vertical ? "height" : "width", s = this.vertical ? "clientY" : "clientX", {
+        [t]: n,
+        [i]: a
+      } = this.$refs.track.getBoundingClientRect(), r = "touches" in e ? e.touches[0][s] : e[s];
+      let o = Math.min(Math.max((r - n - this.startOffset) / a, 0), 1) || 0;
+      return this.vertical && (o = 1 - o), this.$vuetify.rtl && (o = 1 - o), parseFloat(this.min) + o * (this.maxValue - this.minValue);
+    },
+    parseKeyDown(e, t) {
+      if (!this.isInteractive)
+        return;
+      const {
+        pageup: i,
+        pagedown: s,
+        end: n,
+        home: a,
+        left: r,
+        right: o,
+        down: p,
+        up: R
+      } = kt;
+      if (![i, s, n, a, r, o, p, R].includes(e.keyCode))
+        return;
+      e.preventDefault();
+      const A = this.stepNumeric || 1, W = (this.maxValue - this.minValue) / A;
+      if ([r, o, p, R].includes(e.keyCode)) {
+        const xt = (this.$vuetify.rtl ? [r, R] : [o, R]).includes(e.keyCode) ? 1 : -1, $t = e.shiftKey ? 3 : e.ctrlKey ? 2 : 1;
+        t = t + xt * A * $t;
+      } else if (e.keyCode === a)
+        t = this.minValue;
+      else if (e.keyCode === n)
+        t = this.maxValue;
+      else {
+        const U = e.keyCode === s ? 1 : -1;
+        t = t - U * A * (W > 100 ? W / 10 : 10);
+      }
+      return t;
+    },
+    roundValue(e) {
+      if (!this.stepNumeric)
+        return e;
+      const t = this.step.toString().trim(), i = t.indexOf(".") > -1 ? t.length - t.indexOf(".") - 1 : 0, s = this.minValue % this.stepNumeric, n = Math.round((e - s) / this.stepNumeric) * this.stepNumeric + s;
+      return parseFloat(Math.min(n, this.maxValue).toFixed(i));
+    }
+  }
+}), ye = B(ve("left", ["isActive", "isMobile", "miniVariant", "expandOnHover", "permanent", "right", "temporary", "width"]), I, ue, mt, ie, fe, ot), be = ye.extend({
+  name: "v-navigation-drawer",
+  directives: {
+    ClickOutside: dt,
+    Resize: le,
+    Touch: ce
+  },
+  provide() {
+    return {
+      isInNav: this.tag === "nav"
+    };
+  },
+  props: {
+    bottom: Boolean,
+    clipped: Boolean,
+    disableResizeWatcher: Boolean,
+    disableRouteWatcher: Boolean,
+    expandOnHover: Boolean,
+    floating: Boolean,
+    height: {
+      type: [Number, String],
+      default() {
+        return this.app ? "100vh" : "100%";
+      }
+    },
+    miniVariant: Boolean,
+    miniVariantWidth: {
+      type: [Number, String],
+      default: 56
+    },
+    permanent: Boolean,
+    right: Boolean,
+    src: {
+      type: [String, Object],
+      default: ""
+    },
+    stateless: Boolean,
+    tag: {
+      type: String,
+      default() {
+        return this.app ? "nav" : "aside";
+      }
+    },
+    temporary: Boolean,
+    touchless: Boolean,
+    width: {
+      type: [Number, String],
+      default: 256
+    },
+    value: null
+  },
+  data: () => ({
+    isMouseover: !1,
+    touchArea: {
+      left: 0,
+      right: 0
+    },
+    stackMinZIndex: 6
+  }),
+  computed: {
+    /**
+     * Used for setting an app value from a dynamic
+     * property. Called from applicationable.js
+     */
+    applicationProperty() {
+      return this.right ? "right" : "left";
+    },
+    classes() {
+      return {
+        "v-navigation-drawer": !0,
+        "v-navigation-drawer--absolute": this.absolute,
+        "v-navigation-drawer--bottom": this.bottom,
+        "v-navigation-drawer--clipped": this.clipped,
+        "v-navigation-drawer--close": !this.isActive,
+        "v-navigation-drawer--fixed": !this.absolute && (this.app || this.fixed),
+        "v-navigation-drawer--floating": this.floating,
+        "v-navigation-drawer--is-mobile": this.isMobile,
+        "v-navigation-drawer--is-mouseover": this.isMouseover,
+        "v-navigation-drawer--mini-variant": this.isMiniVariant,
+        "v-navigation-drawer--custom-mini-variant": Number(this.miniVariantWidth) !== 56,
+        "v-navigation-drawer--open": this.isActive,
+        "v-navigation-drawer--open-on-hover": this.expandOnHover,
+        "v-navigation-drawer--right": this.right,
+        "v-navigation-drawer--temporary": this.temporary,
+        ...this.themeClasses
+      };
+    },
+    computedMaxHeight() {
+      if (!this.hasApp)
+        return null;
+      const e = this.$vuetify.application.bottom + this.$vuetify.application.footer + this.$vuetify.application.bar;
+      return this.clipped ? e + this.$vuetify.application.top : e;
+    },
+    computedTop() {
+      if (!this.hasApp)
+        return 0;
+      let e = this.$vuetify.application.bar;
+      return e += this.clipped ? this.$vuetify.application.top : 0, e;
+    },
+    computedTransform() {
+      return this.isActive ? 0 : this.isBottom || this.right ? 100 : -100;
+    },
+    computedWidth() {
+      return this.isMiniVariant ? this.miniVariantWidth : this.width;
+    },
+    hasApp() {
+      return this.app && !this.isMobile && !this.temporary;
+    },
+    isBottom() {
+      return this.bottom && this.isMobile;
+    },
+    isMiniVariant() {
+      return !this.expandOnHover && this.miniVariant || this.expandOnHover && !this.isMouseover;
+    },
+    isMobile() {
+      return !this.stateless && !this.permanent && mt.options.computed.isMobile.call(this);
+    },
+    reactsToClick() {
+      return !this.stateless && !this.permanent && (this.isMobile || this.temporary);
+    },
+    reactsToMobile() {
+      return this.app && !this.disableResizeWatcher && !this.permanent && !this.stateless && !this.temporary;
+    },
+    reactsToResize() {
+      return !this.disableResizeWatcher && !this.stateless;
+    },
+    reactsToRoute() {
+      return !this.disableRouteWatcher && !this.stateless && (this.temporary || this.isMobile);
+    },
+    showOverlay() {
+      return !this.hideOverlay && this.isActive && (this.isMobile || this.temporary);
+    },
+    styles() {
+      const e = this.isBottom ? "translateY" : "translateX";
+      return {
+        height: x(this.height),
+        top: this.isBottom ? "auto" : x(this.computedTop),
+        maxHeight: this.computedMaxHeight != null ? `calc(100% - ${x(this.computedMaxHeight)})` : void 0,
+        transform: `${e}(${x(this.computedTransform, "%")})`,
+        width: x(this.computedWidth)
+      };
+    }
+  },
+  watch: {
+    $route: "onRouteChange",
+    isActive(e) {
+      this.$emit("input", e);
+    },
+    /**
+     * When mobile changes, adjust the active state
+     * only when there has been a previous value
+     */
+    isMobile(e, t) {
+      !e && this.isActive && !this.temporary && this.removeOverlay(), !(t == null || !this.reactsToResize || !this.reactsToMobile) && (this.isActive = !e);
+    },
+    permanent(e) {
+      e && (this.isActive = !0);
+    },
+    showOverlay(e) {
+      e ? this.genOverlay() : this.removeOverlay();
+    },
+    value(e) {
+      if (!this.permanent) {
+        if (e == null) {
+          this.init();
+          return;
+        }
+        e !== this.isActive && (this.isActive = e);
+      }
+    },
+    expandOnHover: "updateMiniVariant",
+    isMouseover(e) {
+      this.updateMiniVariant(!e);
+    }
+  },
+  beforeMount() {
+    this.init();
+  },
+  methods: {
+    calculateTouchArea() {
+      const e = this.$el.parentNode;
+      if (!e)
+        return;
+      const t = e.getBoundingClientRect();
+      this.touchArea = {
+        left: t.left + 50,
+        right: t.right - 50
+      };
+    },
+    closeConditional() {
+      return this.isActive && !this._isDestroyed && this.reactsToClick;
+    },
+    genAppend() {
+      return this.genPosition("append");
+    },
+    genBackground() {
+      const e = {
+        height: "100%",
+        width: "100%",
+        src: this.src
+      }, t = this.$scopedSlots.img ? this.$scopedSlots.img(e) : this.$createElement(pe, {
+        props: e
+      });
+      return this.$createElement("div", {
+        staticClass: "v-navigation-drawer__image"
+      }, [t]);
+    },
+    genDirectives() {
+      const e = [{
+        name: "click-outside",
+        value: {
+          handler: () => {
+            this.isActive = !1;
+          },
+          closeConditional: this.closeConditional,
+          include: this.getOpenDependentElements
+        }
+      }];
+      return !this.touchless && !this.stateless && e.push({
+        name: "touch",
+        value: {
+          parent: !0,
+          left: this.swipeLeft,
+          right: this.swipeRight
+        }
+      }), e;
+    },
+    genListeners() {
+      const e = {
+        mouseenter: () => this.isMouseover = !0,
+        mouseleave: () => this.isMouseover = !1,
+        transitionend: (t) => {
+          if (t.target !== t.currentTarget)
+            return;
+          this.$emit("transitionend", t);
+          const i = document.createEvent("UIEvents");
+          i.initUIEvent("resize", !0, !1, window, 0), window.dispatchEvent(i);
+        }
+      };
+      return this.miniVariant && (e.click = () => this.$emit("update:mini-variant", !1)), e;
+    },
+    genPosition(e) {
+      const t = G(this, e);
+      return t && this.$createElement("div", {
+        staticClass: `v-navigation-drawer__${e}`
+      }, t);
+    },
+    genPrepend() {
+      return this.genPosition("prepend");
+    },
+    genContent() {
+      return this.$createElement("div", {
+        staticClass: "v-navigation-drawer__content"
+      }, this.$slots.default);
+    },
+    genBorder() {
+      return this.$createElement("div", {
+        staticClass: "v-navigation-drawer__border"
+      });
+    },
+    init() {
+      this.permanent ? this.isActive = !0 : this.stateless || this.value != null ? this.isActive = this.value : this.temporary || (this.isActive = !this.isMobile);
+    },
+    onRouteChange() {
+      this.reactsToRoute && this.closeConditional() && (this.isActive = !1);
+    },
+    swipeLeft(e) {
+      this.isActive && this.right || (this.calculateTouchArea(), !(Math.abs(e.touchendX - e.touchstartX) < 100) && (this.right && e.touchstartX >= this.touchArea.right ? this.isActive = !0 : !this.right && this.isActive && (this.isActive = !1)));
+    },
+    swipeRight(e) {
+      this.isActive && !this.right || (this.calculateTouchArea(), !(Math.abs(e.touchendX - e.touchstartX) < 100) && (!this.right && e.touchstartX <= this.touchArea.left ? this.isActive = !0 : this.right && this.isActive && (this.isActive = !1)));
+    },
+    /**
+     * Update the application layout
+     */
+    updateApplication() {
+      if (!this.isActive || this.isMobile || this.temporary || !this.$el)
+        return 0;
+      const e = Number(this.miniVariant ? this.miniVariantWidth : this.width);
+      return isNaN(e) ? this.$el.clientWidth : e;
+    },
+    updateMiniVariant(e) {
+      this.expandOnHover && this.miniVariant !== e && this.$emit("update:mini-variant", e);
+    }
+  },
+  render(e) {
+    const t = [this.genPrepend(), this.genContent(), this.genAppend(), this.genBorder()];
+    return (this.src || G(this, "img")) && t.unshift(this.genBackground()), e(this.tag, this.setBackgroundColor(this.color, {
+      class: this.classes,
+      style: this.styles,
+      directives: this.genDirectives(),
+      on: this.genListeners()
+    }), t);
+  }
+}), Me = N.extend({
+  name: "v-range-slider",
+  props: {
+    value: {
+      type: Array,
+      default: () => [0, 0]
+    }
+  },
+  data() {
+    return {
+      activeThumb: null,
+      lazyValue: this.value
+    };
+  },
+  computed: {
+    classes() {
+      return {
+        ...N.options.computed.classes.call(this),
+        "v-input--range-slider": !0
+      };
+    },
+    internalValue: {
+      get() {
+        return this.lazyValue;
+      },
+      set(e) {
+        let t = e.map((i = 0) => this.roundValue(Math.min(Math.max(i, this.minValue), this.maxValue)));
+        if (t[0] > t[1] || t[1] < t[0]) {
+          if (this.activeThumb !== null) {
+            const i = this.activeThumb === 1 ? 0 : 1;
+            this.$refs[`thumb_${i}`].focus();
+          }
+          t = [t[1], t[0]];
+        }
+        this.lazyValue = t, rt(t, this.value) || this.$emit("input", t), this.validate();
+      }
+    },
+    inputWidth() {
+      return this.internalValue.map((e) => (this.roundValue(e) - this.minValue) / (this.maxValue - this.minValue) * 100);
+    }
+  },
+  methods: {
+    getTrackStyle(e, t, i = 0, s = 0) {
+      const n = this.vertical ? this.$vuetify.rtl ? "top" : "bottom" : this.$vuetify.rtl ? "right" : "left", a = this.vertical ? "height" : "width", r = `calc(${e}% + ${i}px)`, o = `calc(${t}% + ${s}px)`;
+      return {
+        transition: this.trackTransition,
+        [n]: r,
+        [a]: o
+      };
+    },
+    getIndexOfClosestValue(e, t) {
+      return Math.abs(e[0] - t) < Math.abs(e[1] - t) ? 0 : 1;
+    },
+    genInput() {
+      return T(2).map((e) => {
+        const t = N.options.methods.genInput.call(this);
+        return t.data = t.data || {}, t.data.attrs = t.data.attrs || {}, t.data.attrs.value = this.internalValue[e], t.data.attrs.id = `input-${e ? "max" : "min"}-${this._uid}`, t;
+      });
+    },
+    genTrackContainer() {
+      const e = [], t = this.isDisabled ? 10 : 0, i = [{
+        class: "v-slider__track-background",
+        color: this.computedTrackColor,
+        styles: [0, this.inputWidth[0], 0, -t]
+      }, {
+        class: this.isDisabled ? "v-slider__track-background" : "v-slider__track-fill",
+        color: this.isDisabled ? this.computedTrackColor : this.computedTrackFillColor,
+        styles: [this.inputWidth[0], Math.abs(this.inputWidth[1] - this.inputWidth[0]), t, t * -2]
+      }, {
+        class: "v-slider__track-background",
+        color: this.computedTrackColor,
+        styles: [this.inputWidth[1], Math.abs(100 - this.inputWidth[1]), t, -t]
+      }];
+      return this.$vuetify.rtl && i.reverse(), e.push(...i.map((s) => this.$createElement("div", this.setBackgroundColor(s.color, {
+        staticClass: s.class,
+        style: this.getTrackStyle(...s.styles)
+      })))), this.$createElement("div", {
+        staticClass: "v-slider__track-container",
+        ref: "track"
+      }, e);
+    },
+    genChildren() {
+      return [this.genInput(), this.genTrackContainer(), this.genSteps(), T(2).map((e) => {
+        const t = this.internalValue[e], i = (o) => {
+          this.isFocused = !0, this.activeThumb = e, this.$emit("focus", o);
+        }, s = (o) => {
+          this.isFocused = !1, this.activeThumb = null, this.$emit("blur", o);
+        }, n = this.inputWidth[e], a = this.isActive && this.activeThumb === e, r = this.isFocused && this.activeThumb === e;
+        return this.genThumbContainer(t, n, a, r, i, s, `thumb_${e}`);
+      })];
+    },
+    reevaluateSelected(e) {
+      this.activeThumb = this.getIndexOfClosestValue(this.internalValue, e);
+      const t = `thumb_${this.activeThumb}`;
+      this.$refs[t].focus();
+    },
+    onSliderMouseDown(e) {
+      var t;
+      const i = this.parseMouseMove(e);
+      if (this.reevaluateSelected(i), this.oldValue = this.internalValue, this.isActive = !0, !((t = e.target) === null || t === void 0) && t.matches(".v-slider__thumb-container, .v-slider__thumb-container *")) {
+        this.thumbPressed = !0;
+        const r = e.target.getBoundingClientRect(), o = "touches" in e ? e.touches[0] : e;
+        this.startOffset = this.vertical ? o.clientY - (r.top + r.height / 2) : o.clientX - (r.left + r.width / 2);
+      } else
+        this.startOffset = 0, window.clearTimeout(this.mouseTimeout), this.mouseTimeout = window.setTimeout(() => {
+          this.thumbPressed = !0;
+        }, 300);
+      const s = C ? {
+        passive: !0,
+        capture: !0
+      } : !0, n = C ? {
+        passive: !0
+      } : !1, a = "touches" in e;
+      this.onMouseMove(e), this.app.addEventListener(a ? "touchmove" : "mousemove", this.onMouseMove, n), nt(this.app, a ? "touchend" : "mouseup", this.onSliderMouseUp, s), this.$emit("start", this.internalValue);
+    },
+    onSliderClick(e) {
+      if (!this.isActive) {
+        if (this.noClick) {
+          this.noClick = !1;
+          return;
+        }
+        const t = this.parseMouseMove(e);
+        this.reevaluateSelected(t), this.setInternalValue(t), this.$emit("change", this.internalValue);
+      }
+    },
+    onMouseMove(e) {
+      const t = this.parseMouseMove(e);
+      e.type === "mousemove" && (this.thumbPressed = !0), this.activeThumb === null && (this.activeThumb = this.getIndexOfClosestValue(this.internalValue, t)), this.setInternalValue(t);
+    },
+    onKeyDown(e) {
+      if (this.activeThumb === null)
+        return;
+      const t = this.parseKeyDown(e, this.internalValue[this.activeThumb]);
+      t != null && (this.setInternalValue(t), this.$emit("change", this.internalValue));
+    },
+    setInternalValue(e) {
+      this.internalValue = this.internalValue.map((t, i) => i === this.activeThumb ? e : Number(t));
+    }
+  }
+}), xe = B(I, he, de, Lt, ot).extend({
+  name: "v-rating",
+  props: {
+    backgroundColor: {
+      type: String,
+      default: "accent"
+    },
+    color: {
+      type: String,
+      default: "primary"
+    },
+    clearable: Boolean,
+    dense: Boolean,
+    emptyIcon: {
+      type: String,
+      default: "$ratingEmpty"
+    },
+    fullIcon: {
+      type: String,
+      default: "$ratingFull"
+    },
+    halfIcon: {
+      type: String,
+      default: "$ratingHalf"
+    },
+    halfIncrements: Boolean,
+    hover: Boolean,
+    length: {
+      type: [Number, String],
+      default: 5
+    },
+    readonly: Boolean,
+    size: [Number, String],
+    value: {
+      type: Number,
+      default: 0
+    },
+    iconLabel: {
+      type: String,
+      default: "$vuetify.rating.ariaLabel.icon"
+    }
+  },
+  data() {
+    return {
+      hoverIndex: -1,
+      internalValue: this.value
+    };
+  },
+  computed: {
+    directives() {
+      return this.readonly || !this.ripple ? [] : [{
+        name: "ripple",
+        value: {
+          circle: !0
+        }
+      }];
+    },
+    iconProps() {
+      const {
+        dark: e,
+        large: t,
+        light: i,
+        medium: s,
+        small: n,
+        size: a,
+        xLarge: r,
+        xSmall: o
+      } = this.$props;
+      return {
+        dark: e,
+        large: t,
+        light: i,
+        medium: s,
+        size: a,
+        small: n,
+        xLarge: r,
+        xSmall: o
+      };
+    },
+    isHovering() {
+      return this.hover && this.hoverIndex >= 0;
+    }
+  },
+  watch: {
+    internalValue(e) {
+      e !== this.value && this.$emit("input", e);
+    },
+    value(e) {
+      this.internalValue = e;
+    }
+  },
+  methods: {
+    createClickFn(e) {
+      return (t) => {
+        if (this.readonly)
+          return;
+        const i = this.genHoverIndex(t, e);
+        this.clearable && this.internalValue === i ? this.internalValue = 0 : this.internalValue = i;
+      };
+    },
+    createProps(e) {
+      const t = {
+        index: e,
+        value: this.internalValue,
+        click: this.createClickFn(e),
+        isFilled: Math.floor(this.internalValue) > e,
+        isHovered: Math.floor(this.hoverIndex) > e
+      };
+      return this.halfIncrements && (t.isHalfHovered = !t.isHovered && (this.hoverIndex - e) % 1 > 0, t.isHalfFilled = !t.isFilled && (this.internalValue - e) % 1 > 0), t;
+    },
+    genHoverIndex(e, t) {
+      let i = this.isHalfEvent(e);
+      return this.halfIncrements && this.$vuetify.rtl && (i = !i), t + (i ? 0.5 : 1);
+    },
+    getIconName(e) {
+      const t = this.isHovering ? e.isHovered : e.isFilled, i = this.isHovering ? e.isHalfHovered : e.isHalfFilled;
+      return t ? this.fullIcon : i ? this.halfIcon : this.emptyIcon;
+    },
+    getColor(e) {
+      if (this.isHovering) {
+        if (e.isHovered || e.isHalfHovered)
+          return this.color;
+      } else if (e.isFilled || e.isHalfFilled)
+        return this.color;
+      return this.backgroundColor;
+    },
+    isHalfEvent(e) {
+      if (this.halfIncrements) {
+        const t = e.target && e.target.getBoundingClientRect();
+        if (t && e.pageX - t.left < t.width / 2)
+          return !0;
+      }
+      return !1;
+    },
+    onMouseEnter(e, t) {
+      this.runDelay("open", () => {
+        this.hoverIndex = this.genHoverIndex(e, t);
+      });
+    },
+    onMouseLeave() {
+      this.runDelay("close", () => this.hoverIndex = -1);
+    },
+    genItem(e) {
+      const t = this.createProps(e);
+      if (this.$scopedSlots.item)
+        return this.$scopedSlots.item(t);
+      const i = {
+        click: t.click
+      };
+      return this.hover && (i.mouseenter = (s) => this.onMouseEnter(s, e), i.mouseleave = this.onMouseLeave, this.halfIncrements && (i.mousemove = (s) => this.onMouseEnter(s, e))), this.$createElement(g, this.setTextColor(this.getColor(t), {
+        attrs: {
+          "aria-label": this.$vuetify.lang.t(this.iconLabel, e + 1, Number(this.length))
+        },
+        directives: this.directives,
+        props: this.iconProps,
+        on: i
+      }), [this.getIconName(t)]);
+    }
+  },
+  render(e) {
+    const t = T(Number(this.length)).map((i) => this.genItem(i));
+    return e("div", {
+      staticClass: "v-rating",
+      class: {
+        "v-rating--readonly": this.readonly,
+        "v-rating--dense": this.dense
+      }
+    }, t);
+  }
+});
+var f = /* @__PURE__ */ ((e) => (e.HotelDescriptionViewDialog = "HotelDescriptionViewDialog", e.HotelRoomOfferList = "HotelRoomOfferList", e.HotelRoomOffersViewDialog = "HotelRoomOffersViewDialog", e.RoomsDetails = "RoomsDetails", e))(f || {});
+const $e = {
+  HotelDescriptionViewDialog: !1,
+  HotelRoomOfferList: !1,
+  HotelRoomOffersViewDialog: !1,
+  RoomsDetails: !0
+}, Ce = {
+  name: "BBtnCloseDialog"
+};
+var Be = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i(l, t._b({ staticClass: "close-btn v-window__next", attrs: { dark: "", icon: "" } }, "v-btn", t.$attrs, !1), [i(g, [t._v("fa-times")])], 1);
+}, ke = [], Re = /* @__PURE__ */ m(
+  Ce,
+  Be,
+  ke,
+  !1,
+  null,
+  "95318f12",
+  null,
+  null
+);
+const we = Re.exports, Se = {
+  adultCount: {
+    type: Number
+  },
+  checkInDate: {
+    type: String
+  },
+  compact: {
+    type: Boolean
+  },
+  features: {
+    default: () => $e,
+    type: Object
+  },
+  hideAction: {
+    default: !1,
+    type: Boolean
+  },
+  hotelOffer: {
+    required: !0,
+    type: Object
+  },
+  imageCountLimit: {
+    type: Number
+  },
+  isNoLongerAvail: {
+    default: !1,
+    type: Boolean
+  },
+  nightCount: {
+    type: Number
+  },
+  singleOffer: {
+    default: !1,
+    type: Boolean
+  }
+}, pt = {
+  clickable: {
+    default: !1,
+    type: Boolean
+  },
+  height: { type: String },
+  imageUrls: { type: Array },
+  lazy: {
+    default: 0,
+    type: Number
+  },
+  limit: {
+    default: 80,
+    type: Number
+  },
+  rounded: { type: Boolean },
+  showThumbnails: { type: Boolean },
+  slide: { type: Number },
+  thumbnailUrls: { type: Array },
+  thumbnailsHeight: {
+    type: [String, Number]
+  },
+  width: { type: String }
+}, et = (e) => {
+  if (!e)
+    return {
+      val: 0
+    };
+  const t = /(-?[\d.]+)([%a-z]*)/u.exec(e.toString());
+  return !t || !t[1] ? {
+    val: 0
+  } : {
+    unit: t[2],
+    val: Number.parseInt(t[1])
+  };
+};
+h.extend({
+  name: "BImageCarousel",
+  components: {
+    "b-image-carousel-thumbnails": Xt
+  },
+  model: {
+    prop: "slide",
+    event: "change"
+  },
+  props: pt,
+  data() {
+    return {
+      currentSlide: this.slide || 0,
+      isActive: !1,
+      isVisible: !1
+    };
+  },
+  computed: {
+    imagesToLoad() {
+      if (!this.isVisible)
+        return [];
+      if (this.lazy === 0)
+        return [this.currentSlide];
+      const e = this.imageUrls.length;
+      return this.lazy < 0 ? Array.from({ length: e }, (t, i) => i) : Array.from(
+        { length: 2 * this.lazy + 1 },
+        (t, i) => (this.currentSlide + i + e - this.lazy) % e
+      );
+    },
+    totalHeight() {
+      const e = et(this.height);
+      if (!e)
+        return "0px";
+      const t = et(
+        this.showThumbnails && this.imageUrls.length > 1 && this.thumbnailsHeight || void 0
+      );
+      if (!t)
+        return e.val + (e.unit || "px");
+      const i = e.unit || t.unit || "px";
+      return e.val + t.val + (i === "px" ? 4 : 0) + i;
+    }
+  },
+  watch: {
+    slide(e) {
+      this.currentSlide = e;
+    }
+  },
+  mounted() {
+    document.addEventListener("keyup", (e) => {
+      this.isActive && (e.key === "ArrowLeft" ? this.moveSlide(-1) : e.key === "ArrowRight" && this.moveSlide(1));
+    });
+  },
+  methods: {
+    moveSlide(e) {
+      const t = this.imageUrls.length;
+      this.currentSlide = (t + this.currentSlide + e) % t, this.onCarouselChange();
+    },
+    onCarouselChange() {
+      this.$emit("change", this.currentSlide), this.isActive = !0;
+    },
+    onClick() {
+      this.$emit("click", this.currentSlide), this.clickable && (this.isActive = !1);
+    },
+    onClickOutside() {
+      this.isActive = !1;
+    },
+    onIntersect(e) {
+      this.isVisible = e[0].isIntersecting;
+    }
+  }
+});
+const Oe = {
+  ...Rt(pt, "imageUrls"),
+  hotelOffer: {
+    required: !0,
+    type: Object
+  },
+  imageCountLimit: {
+    type: Number
+  }
+}, Te = h.extend({
+  name: "HotelOfferItem",
+  components: {
+    BImageCarousel: Zt
+  },
+  mixins: [M],
+  props: Oe,
+  store: ct,
+  computed: {
+    hotelId() {
+      return this.hotelOffer.id;
+    },
+    hotelImages() {
+      return this.$store.get("hotelImages/images", this.hotelId);
+    },
+    imageUrls() {
+      return Jt({
+        hotelImages: this.hotelImages,
+        images: this.hotelOffer.images
+      });
+    },
+    carouselStyle() {
+      return {
+        borderTopLeftRadius: "0px",
+        borderBottomLeftRadius: "0px",
+        borderTopRightRadius: "0px"
+      };
+    }
+  },
+  async mounted() {
+    await $("hotelImages/retrieveHotelImages", {
+      hotelId: this.hotelId,
+      locale: this.config.lang
+    });
+  }
+});
+var Ie = function() {
+  var s, n;
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i("b-image-carousel", { style: t.carouselStyle, attrs: { clickable: "", height: t.height, "image-urls": ((n = (s = t.imageUrls) == null ? void 0 : s.lowres) == null ? void 0 : n.slice(0, t.imageCountLimit)) || [], lazy: 2, limit: 15, rounded: "", width: t.width } });
+}, Fe = [], Ve = /* @__PURE__ */ m(
+  Te,
+  Ie,
+  Fe,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const Ae = Ve.exports, De = h.extend({
+  name: "HotelOfferItem",
+  components: {
+    BBreakfastOptionBadge: At,
+    BBreakpointObserver: Dt,
+    BBtnCloseDialog: we,
+    BErrorOverlay: Et,
+    HotelOfferItemCarousel: Ae,
+    BPriceSummary: Ht,
+    BHotelRoomsDetails: Nt,
+    BStarRating: Pt,
+    BTag: Ut,
+    BTripAdvisorRatingWidget: zt,
+    CancellationPoliciesBadge: Ft,
+    HotelDescriptionView: Gt,
+    HotelOfferItemLayout: Vt,
+    HotelRoomOffersView: Kt,
+    BReviewRating: Wt,
+    BTravelTimes: Yt
+  },
+  mixins: [
+    M,
+    lt,
+    b("components/RevolugoElements/HotelOfferItem")
+  ],
+  store: ct,
+  props: Se,
+  data() {
+    return {
+      showAdditionalContent: !1,
+      mountAdditionalContent: !1,
+      toggleDialog: !1
+    };
+  },
+  computed: {
+    adultCountLocal() {
+      return this.adultCount || this.$store.get("hotelOfferRequest/adultCount");
+    },
+    checkInDateLocal() {
+      return this.checkInDate || this.$store.get("hotelOfferRequest/checkInDate");
+    },
+    dialogComponentName() {
+      if (this.features[f.HotelRoomOffersViewDialog])
+        return "hotel-room-offers-view";
+      if (this.features[f.HotelDescriptionViewDialog])
+        return "hotel-description-view";
+    },
+    formattedDistance() {
+      return this.hotelOffer.distance ? Math.round(this.hotelOffer.distance / 1e3 * 100) / 100 : 0;
+    },
+    hotelId() {
+      return this.hotelOffer.id;
+    },
+    hotelOfferRequest() {
+      return this.$store.get("hotelOfferRequest");
+    },
+    hotelRoomOffer() {
+      return this.hotelOffer.hotelRoomOffers[0];
+    },
+    isTaxIncluded() {
+      return this.hotelRoomOffer.taxes ? this.hotelRoomOffer.taxes.length === 0 : !0;
+    },
+    isRefundable() {
+      return wt({
+        bookingDatetime: St().format(),
+        cancellationPolicies: this.hotelRoomOffer.cancellationPolicies,
+        checkInDate: this.checkInDateLocal,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        timezone: this.hotelOffer.timezone
+      }) === 0;
+    },
+    hotelImages() {
+      return this.$store.get("hotelImages/images", this.hotelId);
+    },
+    nightCountLocal() {
+      return this.nightCount || this.$store.get("hotelOfferRequest/nightCount");
+    },
+    roomCount() {
+      var e;
+      return ((e = this.hotelRoomOffer) == null ? void 0 : e.hotelRooms.reduce(
+        (t, i) => t + (i.count || 0),
+        0
+      )) || 0;
+    },
+    bigTags() {
+      var e, t;
+      return ((t = (e = this.hotelOffer) == null ? void 0 : e.tags) == null ? void 0 : t.filter((i) => i.name.length > 30)) || [];
+    },
+    smallTags() {
+      var e, t;
+      return ((t = (e = this.hotelOffer) == null ? void 0 : e.tags) == null ? void 0 : t.filter((i) => i.name.length <= 30)) || [];
+    },
+    venueTravelTimes() {
+      var e;
+      return (e = this.hotelOffer) == null ? void 0 : e.venues;
+    }
+  },
+  mounted() {
+    this.features[f.HotelRoomOffersViewDialog] && window.RevolugoElements.eventBus.$on(
+      D.BOOKING_POLICY_CREATED,
+      () => {
+        setTimeout(() => {
+          this.toggleDialog = !1;
+        }, 350);
+      }
+    );
+  },
+  methods: {
+    onHotelOfferItemClick() {
+      window.RevolugoElements.eventBus.$emit(
+        D.HOTEL_OFFERS_ITEM_CLICK,
+        this.hotelOffer
+      ), this.features[f.HotelRoomOfferList] ? this.showAdditionalContent ? (this.showAdditionalContent = !1, setTimeout(() => {
+        this.mountAdditionalContent = !1;
+      }, 500)) : (this.mountAdditionalContent = !0, this.$nextTick(() => {
+        this.showAdditionalContent = !0;
+      })) : (this.features[f.HotelDescriptionViewDialog] || this.features[f.HotelRoomOffersViewDialog]) && (this.toggleDialog = !0);
+    },
+    onHotelOfferItemTitleClick() {
+      window.RevolugoElements.eventBus.$emit(
+        D.HOTEL_OFFERS_ITEM_CLICK,
+        this.hotelOffer
+      ), this.toggleDialog = !0, this.features[f.HotelRoomOffersViewDialog] && (this.showAdditionalContent = !1, this.mountAdditionalContent = !1);
+    }
+  }
+});
+var Ee = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i("hotel-offer-item-layout", { staticClass: "hover-card", attrs: { compact: t.compact, "is-rooms-details-visible": t.features.RoomsDetails }, on: { click: t.onHotelOfferItemClick }, scopedSlots: t._u([{ key: "hotel-description-view-dialog", fn: function() {
+    return [t.dialogComponentName ? i(se, { staticClass: "z-index-over-map", attrs: { attach: t.$dialogAttach, light: "", scrollable: "", transition: "slide-x-reverse-transition" }, model: { value: t.toggleDialog, callback: function(s) {
+      t.toggleDialog = s;
+    }, expression: "toggleDialog" } }, [i("b-btn-close-dialog", { nativeOn: { click: function(s) {
+      t.toggleDialog = !1;
+    } } }), i("b-breakpoint-observer", { attrs: { "at-root": "" } }, [i(k, { attrs: { tile: "" } }, [i(P, [i(t.dialogComponentName, t._b({ tag: "component", staticClass: "pt-2 pa-md-6", attrs: { "hotel-id": t.hotelId } }, "component", t.hotelOfferRequest, !1))], 1)], 1)], 1)], 1) : t._e()];
+  }, proxy: !0 }, { key: "carousel", fn: function() {
+    return [i(Qt, { attrs: { height: t.features.RoomsDetails ? "175px" : "140px", width: !t.$breakpointService.xs && !t.compact ? "175px" : "100%" } }, [i("hotel-offer-item-carousel", { attrs: { height: t.features.RoomsDetails ? "175px" : "140px", "hotel-offer": t.hotelOffer, "image-count-limit": t.imageCountLimit, width: !t.$breakpointService.xs && !t.compact ? "175px" : "100%" } })], 1)];
+  }, proxy: !0 }, { key: "heading", fn: function() {
+    var s;
+    return [t.dialogComponentName && t.features.HotelRoomOfferList ? [i(ut, { attrs: { attach: (s = t.$el) == null ? void 0 : s.parent, bottom: "" }, scopedSlots: t._u([{ key: "activator", fn: function({ on: n }) {
+      return [i("span", t._g({ staticClass: "hotel-name subtitle-1 font-weight-black mr-1 primary--text cursor-pointer", on: { click: function(a) {
+        return a.stopPropagation(), t.onHotelOfferItemTitleClick.apply(null, arguments);
+      } } }, n), [t._v(" " + t._s(t.hotelOffer.name) + " ")])];
+    } }], null, !1, 3153989022) }, [t._v(" " + t._s(t.$t("HotelOfferItem.openDialogTooltip", { value: t.formattedDistance })) + " ")])] : [i("span", { staticClass: "hotel-name subtitle-1 font-weight-black mr-1 primary--text cursor-pointer" }, [t._v(" " + t._s(t.hotelOffer.name) + " ")])], i("b-star-rating", { attrs: { count: t.hotelOffer.rating } })];
+  }, proxy: !0 }, { key: "review-rating", fn: function() {
+    return [i("b-review-rating", { attrs: { features: {
+      ReviewRatingDetails: !1
+    }, hotel: t.hotelOffer } })];
+  }, proxy: !0 }, { key: "distance", fn: function() {
+    return [isNaN(t.formattedDistance) ? t._e() : i("span", { staticClass: "grey--text text--darken-2 text-caption mt-n1 d-block" }, [t._v(" " + t._s(t.$t("HotelOfferItem.distance", { value: t.formattedDistance })) + " ")]), t.venueTravelTimes ? i("b-travel-times", { staticClass: "my-n1", attrs: { "venue-travel-times": t.venueTravelTimes } }) : t._e()];
+  }, proxy: !0 }, { key: "big-tags", fn: function() {
+    return t._l(t.bigTags, function(s, n) {
+      return i("div", { key: n, staticClass: "align-self-center d-inline-flex flex-wrap", style: { gap: "0.3em" } }, [i("b-tag", { attrs: { color: s.bg, "pre-icon": `fa-${s.faIcon}`, "text-color": s.color, "tooltip-content": s.description } }, [t._v(" " + t._s(s.name) + " ")])], 1);
+    });
+  }, proxy: !0 }, { key: "tags", fn: function() {
+    return t._l(t.smallTags, function(s, n) {
+      return i("div", { key: n, staticClass: "align-self-center d-inline-flex flex-wrap", style: { gap: "0.3em" } }, [i("b-tag", { attrs: { color: s.bg, "pre-icon": `fa-${s.faIcon}`, "text-color": s.color, "tooltip-content": s.description } }, [t._v(" " + t._s(s.name) + " ")])], 1);
+    });
+  }, proxy: !0 }, { key: "breakfast-option-badge", fn: function() {
+    return [t.hotelRoomOffer.breakfastOption === "INCLUDED" ? i("b-breakfast-option-badge", { attrs: { "breakfast-option": t.hotelRoomOffer.breakfastOption } }) : t._e()];
+  }, proxy: !0 }, t.isRefundable ? { key: "cancellation-policies-badge", fn: function() {
+    return [i("cancellation-policies-badge", { attrs: { "cancellation-policies": t.hotelRoomOffer.cancellationPolicies, "check-in-date": t.checkInDateLocal, timezone: t.hotelOffer.timezone } })];
+  }, proxy: !0 } : null, { key: "package-details", fn: function() {
+    return [i("b-hotel-rooms-details", { attrs: { "hotel-rooms": t.hotelRoomOffer.hotelRooms } })];
+  }, proxy: !0 }, { key: "price-summary", fn: function() {
+    return [t.hotelRoomOffer.price ? i("div", [i("b-price-summary", { attrs: { "adult-count": t.adultCountLocal, "is-starting-price": "", "is-tax-included": t.isTaxIncluded, "night-count": t.nightCountLocal, price: t.hotelRoomOffer.price, "room-count": t.roomCount, "round-mode": "round" } })], 1) : t._e()];
+  }, proxy: !0 }, { key: "footer", fn: function() {
+    return [i("div", { staticClass: "footer white" }, [t.isNoLongerAvail ? i("b-error-overlay", { scopedSlots: t._u([{ key: "title", fn: function() {
+      return [t._v(" " + t._s(t.$t("HotelOfferItem.noLongerAvailable")) + " ")];
+    }, proxy: !0 }], null, !1, 2439747837) }) : t.mountAdditionalContent ? i(ee, [i("div", { directives: [{ name: "show", rawName: "v-show", value: t.features.HotelRoomOfferList && t.showAdditionalContent, expression: "features.HotelRoomOfferList && showAdditionalContent" }], staticClass: "mt-2", staticStyle: { cursor: "auto" } }, [t.mountAdditionalContent ? t._t("default") : t._e()], 2)]) : t._e()], 1)];
+  }, proxy: !0 }], null, !0) });
+}, Le = [], Ne = /* @__PURE__ */ m(
+  De,
+  Ee,
+  Le,
+  !1,
+  null,
+  "9898fa06",
+  null,
+  null
+);
+const $s = Ne.exports;
+var ft = /* @__PURE__ */ ((e) => (e.DEBUG = "DEBUG", e.ERROR = "ERROR", e.INFO = "INFO", e.WARN = "WARN", e))(ft || {});
+function S(e, t = "INFO") {
+  switch (t) {
+    case "DEBUG": {
+      console.log(`[DEBUG] ${e}`);
+      break;
+    }
+    case "INFO": {
+      console.log(`[INFO] ${e}`);
+      break;
+    }
+    case "WARN": {
+      console.warn(`[WARN] ${e}`);
+      break;
+    }
+    case "ERROR": {
+      console.error(`[ERROR] ${e}`);
+      break;
+    }
+    default: {
+      console.log(`[${ft[t]}] ${e}`);
+      break;
+    }
+  }
+}
+const He = {
+  debug: (e) => S(
+    e,
+    "DEBUG"
+    /* DEBUG */
+  ),
+  info: (e) => S(
+    e,
+    "INFO"
+    /* INFO */
+  ),
+  warn: (e) => S(
+    e,
+    "WARN"
+    /* WARN */
+  ),
+  error: (e) => S(
+    e,
+    "ERROR"
+    /* ERROR */
+  )
+}, Pe = {
+  compact: {
+    type: Boolean,
+    default: !0
+  },
+  isFlat: {
+    type: Boolean,
+    default: !0
+  },
+  outlined: {
+    type: Boolean,
+    default: !1
+  },
+  withDetails: {
+    type: Boolean,
+    default: !1
+  },
+  value: {
+    type: Object,
+    default: null
+  },
+  locationContext: {
+    type: Object,
+    default: null
+  }
+}, ze = h.extend({
+  name: "BSearchLocationInput",
+  mixins: [b("components/ui/BSearchLocationInput")],
+  props: Pe,
+  data() {
+    return {
+      selectedLocation: this.value,
+      locations: [],
+      loading: !1,
+      searchInput: ""
+    };
+  },
+  watch: {
+    value(e) {
+      this.selectLocation(e);
+    },
+    selectedLocation(e) {
+      this.$emit("input", e);
+    },
+    async searchInput(e) {
+      if (!e) {
+        this.locations = [];
+        return;
+      }
+      await this.searchLocations();
+    }
+  },
+  mounted() {
+    this.$nextTick(() => {
+      var e, t;
+      this.searchInput = ((t = (e = this.selectedLocation) == null ? void 0 : e.raw) == null ? void 0 : t.title) || "";
+    });
+  },
+  methods: {
+    searchLocations: Ot(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async function() {
+        var t, i;
+        try {
+          this.loading = !0;
+          const n = {
+            q: this.searchInput,
+            apiKey: jt,
+            maxresults: 10
+          };
+          this.locationContext && (n.at = `${(t = this.locationContext) == null ? void 0 : t.latitude},${(i = this.locationContext) == null ? void 0 : i.longitude}`);
+          const a = await qt.get("https://geocode.search.hereapi.com/v1/geocode", {
+            params: n
+          }).then((r) => {
+            var o;
+            return (o = r.data) == null ? void 0 : o.items;
+          });
+          return this.locations = a.map((r) => ({
+            title: Y([
+              r.address.houseNumber,
+              r.address.street
+            ]).join(" "),
+            subtitle: Y([
+              r.address.postalCode,
+              r.address.city,
+              r.address.countryName
+            ]).join(", "),
+            longitude: r.position.lng,
+            latitude: r.position.lat,
+            raw: r
+          })), this.loading = !1, this.locations;
+        } catch (s) {
+          return He.error(s), this.loading = !1, [];
+        }
+      },
+      500,
+      {
+        trailing: !0
+      }
+    ),
+    selectLocation(e) {
+      this.selectedLocation = e;
+    },
+    getSelection(e) {
+      var t;
+      return (t = e == null ? void 0 : e.raw) == null ? void 0 : t.title;
+    }
+  }
+});
+var We = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i(oe, { staticClass: "search-location-input", attrs: { "append-icon": "", attach: "", dense: t.compact, flat: t.isFlat, "hide-details": !t.withDetails, "hide-no-data": "", "item-text": "raw.title", items: t.locations, label: t.$t("BSearchLocationInput.placeholder"), loading: t.loading, "no-filter": "", outlined: t.outlined, "prepend-inner-icon": "fa-solid fa-magnifying-glass", "return-object": "", "search-input": t.searchInput, solo: !t.outlined, value: t.getSelection(t.selectedLocation) }, on: { "update:searchInput": function(s) {
+    t.searchInput = s;
+  }, "update:search-input": function(s) {
+    t.searchInput = s;
+  } }, scopedSlots: t._u([{ key: "item", fn: function({ item: s }) {
+    return [i(re, { on: { click: function(n) {
+      return t.selectLocation(s);
+    } } }, [i(H, [t._v(t._s(s.title))]), i(ae, [t._v(t._s(s.subtitle))])], 1)];
+  } }]) });
+}, Ue = [], Ge = /* @__PURE__ */ m(
+  ze,
+  We,
+  Ue,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const Cs = Ge.exports, Ye = 25, vt = {
+  currency: {
+    required: !0,
+    type: String
+  },
+  disabled: {
+    default: !1,
+    type: Boolean
+  },
+  isLoading: {
+    default: !1,
+    type: Boolean
+  },
+  priceMax: {
+    default: 10,
+    type: Number
+  },
+  priceMin: {
+    default: 5,
+    type: Number
+  },
+  stepCount: {
+    type: Number,
+    default: Ye
+  },
+  value: {
+    type: Array
+  }
+}, it = (e, t) => {
+  const s = t - e, n = s / 40, r = 10 ** (Math.floor(Math.log10(n)) - 1), o = Math.round(n / r) * r, p = Math.max(o, s / 40);
+  return Math.floor(p);
+}, je = h.extend({
+  name: "BFilterByPrice",
+  components: { BFormattedAmount: ht },
+  mixins: [M],
+  props: vt,
+  data() {
+    return {
+      inputMax: Math.max(...this.value) || this.priceMax,
+      inputMin: Math.min(...this.value) || this.priceMin,
+      modelMax: Math.max(...this.value) || this.priceMax,
+      modelMin: Math.min(...this.value) || this.priceMin,
+      rangeSliderModel: [
+        Math.min(...this.value) || this.priceMin,
+        Math.max(...this.value) || this.priceMax
+      ],
+      step: it(this.priceMin, this.priceMax)
+    };
+  },
+  computed: {
+    getChartBarHeight() {
+      return (e) => `${Math.log(e + 1) / Math.log(Math.max(...this.priceHistogram)) * 40}px`;
+    },
+    currencySymbol() {
+      return Tt(this.currency);
+    },
+    hotelOffersCurrency: d("hotelOffers/hotelOffersCurrency"),
+    priceHistogram: d("hotelOffers/priceHistogram"),
+    validPriceRange() {
+      return It([this.priceMin, this.priceMax]);
+    }
+  },
+  watch: {
+    rangeSliderModel(e) {
+      this.inputMin = e[0], this.inputMax = e[1];
+    },
+    value: {
+      handler(e) {
+        this.modelMin = e[0] || this.priceMin, this.modelMax = e[1] || this.priceMax, this.inputMin = this.modelMin, this.inputMax = this.modelMax, this.rangeSliderModel = [this.modelMin, this.modelMax];
+      },
+      deep: !0,
+      immediate: !0
+    }
+  },
+  created() {
+    this.$watch(
+      () => [this.priceMin, this.priceMax],
+      () => {
+        this.step = it(this.priceMin, this.priceMax);
+      }
+    );
+  },
+  methods: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onInputMaxBlur(e) {
+      var t;
+      this.modelMax = Math.max(
+        Math.min(this.validPriceRange[1], Math.ceil((t = e.target) == null ? void 0 : t.value)),
+        this.validPriceRange[0]
+      ), this.inputMax = this.modelMax, this.rangeSliderModel = [this.modelMin, this.modelMax], this.$emit("input", [this.modelMin, this.modelMax]);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onInputMinBlur(e) {
+      var t;
+      this.modelMin = Math.min(
+        Math.max(this.validPriceRange[0], Math.ceil((t = e.target) == null ? void 0 : t.value)),
+        this.validPriceRange[1]
+      ), this.inputMin = this.modelMin, this.rangeSliderModel = [this.modelMin, this.modelMax], this.$emit("input", [this.modelMin, this.modelMax]);
+    },
+    onInputMaxClear() {
+      this.inputMax = this.validPriceRange[1], this.modelMax = this.inputMax, this.rangeSliderModel = [this.modelMin, this.modelMax], this.$emit("input", [this.modelMin, this.modelMax]);
+    },
+    onInputMinClear() {
+      this.inputMin = this.validPriceRange[0], this.modelMin = this.inputMin, this.rangeSliderModel = [this.modelMin, this.modelMax], this.$emit("input", [this.modelMin, this.modelMax]);
+    },
+    onSliderEnd() {
+      this.modelMin = this.rangeSliderModel[0], this.modelMax = this.rangeSliderModel[1], this.$emit("input", [this.modelMin, this.modelMax]);
+    }
+  }
+});
+var qe = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i("div", { staticStyle: { "max-width": "400px" } }, [i(v, { attrs: { "no-gutters": "" } }, [i(u, [i(P, { staticClass: "filter-price-slider pa-0", class: t.disabled && "cursor-not-allowed" }, [t.isLoading ? [i("ul", { staticClass: "chart" }, [t._l(Array.from(
+    { length: 30 },
+    () => Math.random() * 35 + 5
+  ), function(s, n) {
+    return [i("li", { key: n }, [i("span", { staticClass: "loader" })])];
+  })], 2)] : [i("ul", { staticClass: "chart" }, [t._l(t.priceHistogram, function(s, n) {
+    return [i("li", { key: n }, [i("span", { style: { height: t.getChartBarHeight(s), width: "95%" } })])];
+  })], 2)], i(Me, { ref: "range-slider", attrs: { disabled: t.disabled || t.isLoading, max: t.validPriceRange[1], min: t.validPriceRange[0], readonly: t.disabled || t.isLoading, step: t.step, "thumb-label": !1, "track-color": "#e2e2e2" }, on: { end: t.onSliderEnd }, model: { value: t.rangeSliderModel, callback: function(s) {
+    t.rangeSliderModel = s;
+  }, expression: "rangeSliderModel" } })], 2)], 1)], 1), i(v, { staticClass: "mt-10", attrs: { "no-gutters": "" } }, [i(u, [i(tt, { ref: "price-min", attrs: { "append-icon": t.$isCurrentBreakpointBelow("sm") ? null : "fa-circle-xmark", dense: "", disabled: t.disabled || t.isLoading, label: "Min", max: t.inputMax, min: t.validPriceRange[0], outlined: "", prefix: t.currencySymbol, step: t.step, type: "number" }, on: { blur: t.onInputMinBlur, "click:append": t.onInputMinClear }, model: { value: t.inputMin, callback: function(s) {
+    t.inputMin = s;
+  }, expression: "inputMin" } })], 1), i(u, { staticClass: "d-flex align-center", attrs: { cols: "2" } }, [i(O)], 1), i(u, [i(tt, { ref: "price-max", attrs: { "append-icon": t.$isCurrentBreakpointBelow("sm") ? null : "fa-circle-xmark", dense: "", disabled: t.disabled || t.isLoading, label: "Max", max: t.validPriceRange[1], min: t.inputMin, outlined: "", prefix: t.currencySymbol, step: t.step, type: "number" }, on: { blur: t.onInputMaxBlur, "click:append": t.onInputMaxClear }, model: { value: t.inputMax, callback: function(s) {
+    t.inputMax = s;
+  }, expression: "inputMax" } })], 1)], 1)], 1);
+}, Ke = [], Xe = /* @__PURE__ */ m(
+  je,
+  qe,
+  Ke,
+  !1,
+  null,
+  "bc63ec9f",
+  null,
+  null
+);
+const gt = Xe.exports, Ze = h.extend({
+  name: "BFilterByPriceMenu",
+  components: {
+    BFilterByPrice: gt,
+    BFormattedAmount: ht
+  },
+  mixins: [b("components/ui/BFilterByPriceMenu"), M],
+  props: vt,
+  data() {
+    return {
+      isMenuOpen: !1,
+      model: this.value
+    };
+  },
+  computed: {
+    configCurrency() {
+      return this.config.currency ?? j.EUR.code;
+    },
+    currencies() {
+      return Object.values(j);
+    },
+    currencySymbol() {
+      var e;
+      return (e = this.currencies.find(
+        (t) => t.code === this.configCurrency
+      )) == null ? void 0 : e.symbol;
+    },
+    formattedPriceMin() {
+      return q({
+        amount: this.model[0] || this.priceMin,
+        currency: this.config.currency,
+        locale: this.config.lang
+      });
+    },
+    formattedPriceMax() {
+      return q({
+        amount: this.model[1] || this.priceMax,
+        currency: this.config.currency,
+        locale: this.config.lang
+      });
+    },
+    formattedPriceRange() {
+      return `${this.formattedPriceMin} - ${this.formattedPriceMax}`;
+    }
+  },
+  watch: {
+    value: {
+      deep: !0,
+      immediate: !0,
+      handler(e) {
+        this.model = e;
+      }
+    }
+  },
+  methods: {
+    onApply() {
+      this.$emit("input", this.model), this.isMenuOpen = !1;
+    },
+    onCancel() {
+      this.model = this.value, this.isMenuOpen = !1;
+    },
+    onReset() {
+      this.isMenuOpen = !1, this.$emit("reset");
+    }
+  }
+});
+var Je = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i(F, t._b({ attrs: { attach: t.$parent.$el, "close-on-click": "", "close-on-content-click": !1, "max-width": "400px", "offset-overflow": "", "offset-y": "", "open-on-click": "" }, scopedSlots: t._u([{ key: "activator", fn: function({ on: s }) {
+    var n;
+    return [i(V, { staticStyle: { cursor: "pointer" }, attrs: { color: "grey", icon: "fa-times", overlap: "", value: !!t.formattedPriceRange }, nativeOn: { click: function(a) {
+      return t.onReset.apply(null, arguments);
+    } } }, [i(ut, { attrs: { attach: (n = t.$el) == null ? void 0 : n.parent, bottom: "", color: "grey darken-3" }, scopedSlots: t._u([{ key: "activator", fn: function({ on: a }) {
+      return [i(l, t._g({ staticClass: "white--text", attrs: { color: "grey", elevation: 0, outlined: "", small: "" } }, {
+        ...s,
+        ...a
+      }), [i("span", [i("b", [t._v(" " + t._s(t.currencySymbol))])])])];
+    } }], null, !0) }, [t.priceMin !== 0 && t.priceMax !== 0 ? [t._v(" " + t._s(t.formattedPriceRange) + " ")] : t._e()], 2)], 1)];
+  } }]), model: { value: t.isMenuOpen, callback: function(s) {
+    t.isMenuOpen = s;
+  }, expression: "isMenuOpen" } }, "v-menu", t.$attrs, !1), [i(k, { attrs: { elevation: "0" } }, [i("div", { staticClass: "text-center px-10 pt-4" }, [i("p", { staticClass: "font-weight-bold" }, [t._v(" " + t._s(t.$t("BFilterByPriceMenu.title")) + " ")]), i("b-filter-by-price", t._b({ model: { value: t.model, callback: function(s) {
+    t.model = s;
+  }, expression: "model" } }, "b-filter-by-price", t.$props, !1))], 1), i(z, { staticClass: "justify-end mt-2" }, [i(l, { staticClass: "text-right", attrs: { color: "primary", elevation: "0", small: "", text: "" }, on: { click: t.onCancel } }, [t._v(" " + t._s(t.$t("BFilterByPriceMenu.cancel")) + " ")]), i(l, { staticClass: "text-right", attrs: { color: "error", elevation: "0", loading: t.isLoading, small: "", text: "" }, on: { click: t.onReset } }, [t._v(" " + t._s(t.$t("BFilterByPriceMenu.reset")) + " ")]), i(l, { staticClass: "text-right", attrs: { color: "success", elevation: "0", loading: t.isLoading, small: "" }, on: { click: t.onApply } }, [t._v(" " + t._s(t.$t("BFilterByPriceMenu.apply")) + " ")])], 1)], 1)], 1);
+}, Qe = [], ti = /* @__PURE__ */ m(
+  Ze,
+  Je,
+  Qe,
+  !1,
+  null,
+  "38487da2",
+  null,
+  null
+);
+const ei = ti.exports, ii = {
+  value: {
+    type: [Number, void 0]
+  },
+  disabled: { type: Boolean }
+}, si = h.extend({
+  name: "BFilterByReview",
+  props: ii,
+  computed: {
+    model: {
+      get() {
+        return this.value;
+      },
+      set(e) {
+        this.$emit("input", e);
+      }
+    },
+    reviewRatingItems() {
+      return [
+        {
+          label: "3+",
+          value: 3
+        },
+        {
+          label: "3.5+",
+          value: 3.5
+        },
+        {
+          label: "4+",
+          value: 4
+        },
+        {
+          label: "4.5+",
+          value: 4.5
+        }
+      ];
+    }
+  }
+});
+var ni = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i(_e, { staticClass: "d-flex flex-row justify-center", model: { value: t.model, callback: function(s) {
+    t.model = s;
+  }, expression: "model" } }, t._l(t.reviewRatingItems, function(s, n) {
+    return i(l, { key: n, staticClass: "px-0", class: t.disabled && "cursor-not-allowed", attrs: { color: "primary", disabled: t.disabled, outlined: "", small: "", value: s.value } }, [t._v(" " + t._s(s.label) + " ")]);
+  }), 1);
+}, ri = [], ai = /* @__PURE__ */ m(
+  si,
+  ni,
+  ri,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const _t = ai.exports, yt = {
+  value: {
+    type: [Number, void 0]
+  },
+  disabled: { type: Boolean }
+};
+h.extend({
+  name: "BFilterByReview",
+  props: yt,
+  computed: {
+    model: {
+      get() {
+        return this.value;
+      },
+      set(e) {
+        this.$emit("input", e);
+      }
+    },
+    reviewRatingItems() {
+      return [
+        {
+          label: "3+",
+          value: 3
+        },
+        {
+          label: "3.5+",
+          value: 3.5
+        },
+        {
+          label: "4+",
+          value: 4
+        },
+        {
+          label: "4.5+",
+          value: 4.5
+        }
+      ];
+    }
+  }
+});
+const oi = {
+  isLoading: {
+    default: !1,
+    type: Boolean
+  },
+  value: { ...yt.value }
+}, li = h.extend({
+  name: "BFilterByReviewMenu",
+  components: { BFilterByReview: _t },
+  mixins: [b("components/ui/BFilterByReviewMenu"), M],
+  props: oi,
+  data() {
+    return {
+      isMenuOpen: !1,
+      model: this.value
+    };
+  },
+  watch: {
+    value: {
+      immediate: !0,
+      handler(e) {
+        this.model = e;
+      }
+    }
+  },
+  methods: {
+    closeMenu() {
+      this.isMenuOpen = !1;
+    },
+    onApply() {
+      this.closeMenu(), this.$emit("input", this.model);
+    },
+    onCancel() {
+      this.model = this.value, this.closeMenu();
+    },
+    onReset() {
+      this.closeMenu(), this.$emit("reset");
+    }
+  }
+});
+var ci = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i(F, t._b({ attrs: { attach: t.$parent.$el, bottom: "", "close-on-content-click": !1, "content-class": "pa-0", "nudge-left": "130%", "offset-y": "", "open-on-click": "" }, scopedSlots: t._u([{ key: "activator", fn: function({ on: s }) {
+    return [i(V, { staticStyle: { cursor: "pointer" }, attrs: { color: "grey", icon: "fa-times", overlap: "", value: !!t.value }, nativeOn: { click: function(n) {
+      return t.onReset.apply(null, arguments);
+    } } }, [i(l, t._g({ staticClass: "white--text", attrs: { color: "grey", elevation: 0, outlined: "", small: "" } }, s), [i("span", [i("b", [t._v(t._s(t.value) + "+")])])])], 1)];
+  } }]), model: { value: t.isMenuOpen, callback: function(s) {
+    t.isMenuOpen = s;
+  }, expression: "isMenuOpen" } }, "v-menu", t.$attrs, !1), [i(k, { attrs: { elevation: "0" } }, [i("div", { staticClass: "text-center px-10 py-4" }, [i("p", { staticClass: "font-weight-bold" }, [t._v(" " + t._s(t.$t("BFilterByReviewMenu.title")) + " ")]), i("b-filter-by-review", { attrs: { disabled: t.isLoading }, model: { value: t.value, callback: function(s) {
+    t.value = s;
+  }, expression: "value" } })], 1), i(z, { staticClass: "justify-end pa-2" }, [i(l, { staticClass: "text-right", attrs: { color: "primary", elevation: "0", small: "", text: "" }, on: { click: t.closeMenu } }, [t._v(" " + t._s(t.$t("BFilterByReviewMenu.cancel")) + " ")]), i(l, { staticClass: "text-right", attrs: { color: "error", elevation: "0", small: "", text: "" }, on: { click: t.onReset } }, [t._v(" " + t._s(t.$t("BFilterByReviewMenu.reset")) + " ")]), i(l, { staticClass: "text-right", attrs: { color: "success", elevation: "0", small: "" }, on: { click: t.onApply } }, [t._v(" " + t._s(t.$t("BFilterByReviewMenu.apply")) + " ")])], 1)], 1)], 1);
+}, ui = [], hi = /* @__PURE__ */ m(
+  li,
+  ci,
+  ui,
+  !1,
+  null,
+  "07d0a70a",
+  null,
+  null
+);
+const di = hi.exports, mi = {
+  value: {
+    type: [Number, String]
+  },
+  disabled: { type: Boolean }
+}, pi = h.extend({
+  name: "BFilterByStar",
+  props: mi,
+  computed: {
+    color() {
+      return this.disabled ? "grey lighten-1" : "orange";
+    },
+    model: {
+      get() {
+        return Number(this.value.split(",").at(0));
+      },
+      set(e) {
+        const t = at(e, 6).join(",");
+        this.$emit("input", t);
+      }
+    }
+  }
+});
+var fi = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i(xe, { class: t.disabled && "cursor-not-allowed", attrs: { "background-color": t.color, color: t.color, dense: "", disabled: t.disabled, "empty-icon": "$ratingEmpty", hover: "", readonly: t.disabled, size: "24" }, model: { value: t.model, callback: function(s) {
+    t.model = s;
+  }, expression: "model" } });
+}, vi = [], gi = /* @__PURE__ */ m(
+  pi,
+  fi,
+  vi,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const bt = gi.exports, Mt = {
+  value: {
+    type: [Number, String]
+  },
+  disabled: { type: Boolean }
+};
+h.extend({
+  name: "BFilterByStar",
+  props: Mt,
+  computed: {
+    color() {
+      return this.disabled ? "grey lighten-1" : "orange";
+    },
+    model: {
+      get() {
+        return Number(this.value.split(",").at(0));
+      },
+      set(e) {
+        const t = at(e, 6).join(",");
+        this.$emit("input", t);
+      }
+    }
+  }
+});
+const _i = {
+  isLoading: {
+    type: Boolean,
+    default: !1
+  },
+  value: { ...Mt.value }
+}, yi = h.extend({
+  name: "BFilterByStarMenu",
+  components: { BFilterByStar: bt },
+  mixins: [b("components/ui/BFilterByStarMenu"), M],
+  props: _i,
+  data() {
+    return {
+      isMenuOpen: !1,
+      model: this.value
+    };
+  },
+  watch: {
+    value: {
+      immediate: !0,
+      handler(e) {
+        this.model = e;
+      }
+    }
+  },
+  methods: {
+    closeMenu() {
+      this.isMenuOpen = !1;
+    },
+    onApply() {
+      this.closeMenu(), this.$emit("input", this.model);
+    },
+    onCancel() {
+      this.model = this.value, this.isMenuOpen = !1;
+    },
+    onReset() {
+      this.closeMenu(), this.$emit("reset");
+    }
+  }
+});
+var bi = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i(F, t._b({ attrs: { attach: t.$parent.$el, "close-on-content-click": !1, "content-class": "pa-0", "nudge-left": "100%", "offset-overflow": "", "offset-y": "", "open-on-click": "" }, scopedSlots: t._u([{ key: "activator", fn: function({ on: s }) {
+    return [i(V, { staticStyle: { cursor: "pointer" }, attrs: { color: "grey", icon: "fa-times", overlap: "", value: !!t.model }, nativeOn: { click: function(n) {
+      return t.onReset.apply(null, arguments);
+    } } }, [i(l, t._g({ staticClass: "white--text", attrs: { color: "grey", elevation: 0, outlined: "", small: "" } }, s), [i("span", [i("span", [t._v(t._s(t.value.split(",")[0]))]), t.model ? [i(g, { attrs: { id: "star-icon" } }, [t._v(" fa-solid fa-star ")])] : t._e()], 2)])], 1)];
+  } }]), model: { value: t.isMenuOpen, callback: function(s) {
+    t.isMenuOpen = s;
+  }, expression: "isMenuOpen" } }, "v-menu", t.$attrs, !1), [i(k, { attrs: { elevation: "0" } }, [i("div", { staticClass: "text-center px-10 py-4" }, [i("p", { staticClass: "font-weight-bold" }, [t._v(" " + t._s(t.$t("BFilterByStarMenu.title")) + " ")]), i("b-filter-by-star", { model: { value: t.model, callback: function(s) {
+    t.model = s;
+  }, expression: "model" } })], 1), i(z, { staticClass: "justify-end pa-2" }, [i(l, { staticClass: "text-right", attrs: { color: "primary", elevation: "0", small: "", text: "" }, on: { click: t.onCancel } }, [t._v(" " + t._s(t.$t("BFilterByStarMenu.cancel")) + " ")]), i(l, { staticClass: "text-right", attrs: { color: "error", elevation: "0", small: "", text: "" }, on: { click: t.onReset } }, [t._v(" " + t._s(t.$t("BFilterByStarMenu.reset")) + " ")]), i(l, { staticClass: "text-right", attrs: { color: "success", elevation: "0", small: "" }, on: { click: t.onApply } }, [t._v(" " + t._s(t.$t("BFilterByStarMenu.apply")) + " ")])], 1)], 1)], 1);
+}, Mi = [], xi = /* @__PURE__ */ m(
+  yi,
+  bi,
+  Mi,
+  !1,
+  null,
+  "4d9bbf7d",
+  null,
+  null
+);
+const $i = xi.exports, Ci = {
+  attach: {
+    type: [Boolean, Element],
+    default: !0
+  },
+  value: {
+    required: !0,
+    type: Object
+  }
+}, Bi = h.extend({
+  name: "BSortByMenu",
+  mixins: [b("components/ui/BSortByMenu")],
+  props: Ci,
+  data() {
+    return {
+      items: [
+        {
+          value: _.TopPicks,
+          direction: y.Asc
+        },
+        {
+          value: _.Distance,
+          direction: y.Asc
+        },
+        {
+          value: _.Price,
+          direction: y.Asc
+        },
+        {
+          value: _.Price,
+          direction: y.Desc
+        },
+        {
+          value: _.Rating,
+          direction: y.Asc
+        },
+        {
+          value: _.Rating,
+          direction: y.Desc
+        },
+        {
+          value: _.ReviewRating,
+          direction: y.Desc
+        }
+      ],
+      isMenuOpen: !1
+    };
+  },
+  computed: {
+    model: {
+      get() {
+        const e = this.items.findIndex(
+          (t) => t.value === this.value.value && t.direction === this.value.direction
+        );
+        return e === -1 ? 0 : e;
+      },
+      set(e) {
+        this.$emit("input", this.items[e], c.SORT_BY);
+      }
+    }
+  }
+});
+var ki = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i(F, { attrs: { attach: t.attach, eager: "", left: "", "offset-y": "", origin: "top left", transition: "scroll-y-transition" }, scopedSlots: t._u([{ key: "activator", fn: function({ on: s, attrs: n }) {
+    return [i(l, t._g(t._b({ attrs: { color: "secondary", elevation: 0, small: "" } }, "v-btn", n, !1), s), [i("span", [t.$t(
+      `BSortByMenu.options.${t.items[t.model].value}.${t.value.direction}.icon`
+    ).length ? i(g, { staticClass: "mr-1", class: t.$t(
+      `BSortByMenu.options.${t.items[t.model].value}.${t.value.direction}.style`
+    ), attrs: { size: "12" } }, [t._v(" " + t._s(t.$t(`BSortByMenu.options.${t.items[t.model].value}.${t.value.direction}.icon`)) + " ")]) : t._e(), t._v(" " + t._s(t.$t(`BSortByMenu.options.${t.items[t.model].value}.name`)) + " "), i(g, { attrs: { size: "10" } }, [t._v(" fa-chevron-down ")])], 1)])];
+  } }]), model: { value: t.isMenuOpen, callback: function(s) {
+    t.isMenuOpen = s;
+  }, expression: "isMenuOpen" } }, [i(ge, { staticClass: "b-sort-by-list white pa-0", attrs: { mandatory: "" }, model: { value: t.model, callback: function(s) {
+    t.model = s;
+  }, expression: "model" } }, [i(H, { staticClass: "pt-2" }, [i("small", { staticClass: "px-4 font-weight-bold" }, [t._v(t._s(t.$t("BSortByMenu.prefix")))])]), t._l(t.items, function(s, n) {
+    return i(me, { key: n, staticClass: "px-3" }, [i(H, [i("small", { staticClass: "grey--text text--darken-3" }, [t.$t(`BSortByMenu.options.${s.value}.${s.direction}.icon`).length ? i(g, { staticClass: "grey--text text--darken-3", class: t.$t(`BSortByMenu.options.${s.value}.${s.direction}.style`), staticStyle: { "min-width": "24px" }, attrs: { size: "14" } }, [t._v(" " + t._s(t.$t(`BSortByMenu.options.${s.value}.${s.direction}.icon`)) + " ")]) : t._e(), t._v(" " + t._s(t.$t(`BSortByMenu.options.${s.value}.name`)) + " " + t._s(t.$t(`BSortByMenu.options.${s.value}.${s.direction}.wording`)) + " ")], 1)])], 1);
+  })], 2)], 1);
+}, Ri = [], wi = /* @__PURE__ */ m(
+  Bi,
+  ki,
+  Ri,
+  !1,
+  null,
+  "90bc84a5",
+  null,
+  null
+);
+const Si = wi.exports, Oi = {
+  isLoading: {
+    default: !1,
+    type: Boolean
+  },
+  small: {
+    default: !0,
+    type: Boolean
+  },
+  withSort: {
+    default: !0,
+    type: Boolean
+  }
+}, Ti = h.extend({
+  name: "BHotelOffersFiltersBar",
+  components: {
+    BSortByMenu: Si,
+    BFilterByPrice: gt,
+    BFilterByPriceMenu: ei,
+    BFilterByStar: bt,
+    BFilterByStarMenu: $i,
+    BFilterByReview: _t,
+    BFilterByReviewMenu: di
+  },
+  mixins: [
+    M,
+    lt,
+    b("components/ui/BHotelOffersFilterBar")
+  ],
+  props: Oi,
+  data() {
+    return {
+      FILTER_NAMES: c,
+      isDialogOpen: !1,
+      filterByPriceModel: K,
+      filterByReviewRatingModel: X,
+      filterByStarRatingModel: Z,
+      priceUpdatedByUser: !1
+    };
+  },
+  computed: {
+    activeFiltersNumber: d("hotelOffers/activeFiltersNumber"),
+    areFiltersActive: d("hotelOffers/areFiltersActive"),
+    filters: d("hotelOffers/filters"),
+    hotelOfferRequest: d("hotelOfferRequest"),
+    isPriceFilterActive: d("hotelOffers/isPriceFilterActive"),
+    isResetButtonVisible() {
+      var e, t;
+      return ((e = this.filters[c.SORT_BY]) == null ? void 0 : e.value) !== ((t = w[c.SORT_BY]) == null ? void 0 : t.value) || this.isStarRatingFilterActive || this.isReviewRatingFilterActive || this.isPriceFilterActive;
+    },
+    isStarRatingFilterActive: d(
+      "hotelOffers/isStarRatingFilterActive"
+    ),
+    isReviewRatingFilterActive: d(
+      "hotelOffers/isReviewRatingFilterActive"
+    ),
+    priceHistogramStepCount: d("hotelOffers/priceHistogramStepCount"),
+    priceMax: d("hotelOffers/getPriceMax"),
+    priceMin: d("hotelOffers/getPriceMin"),
+    sortByModel: {
+      get() {
+        return this.filters[c.SORT_BY];
+      },
+      async set(e) {
+        await $("hotelOffers/saveFilters", {
+          ...this.filters,
+          [c.SORT_BY]: e
+        });
+      }
+    }
+  },
+  watch: {
+    filters: {
+      deep: !0,
+      immediate: !0,
+      handler() {
+        this.syncFilters();
+      }
+    }
+  },
+  methods: {
+    onCancel() {
+      this.syncFilters(), this.isDialogOpen = !1;
+    },
+    async onSaveFilters() {
+      await $("hotelOffers/saveFilters", {
+        ...this.filters,
+        [c.RATING]: this.filterByStarRatingModel,
+        [c.REVIEW_RATING]: this.filterByReviewRatingModel,
+        [c.PRICE]: [
+          this.filterByPriceModel[0] === this.priceMin ? 0 : this.filterByPriceModel[0],
+          this.filterByPriceModel[1] === this.priceMax ? 0 : this.filterByPriceModel[1]
+        ]
+      }), this.isDialogOpen = !1;
+    },
+    async resetPriceFilter() {
+      await $("hotelOffers/saveFilters", {
+        ...this.filters,
+        [c.PRICE]: K
+      });
+    },
+    async resetStarRatingFilter() {
+      await $("hotelOffers/saveFilters", {
+        ...this.filters,
+        [c.RATING]: Z
+      });
+    },
+    async resetReviewRatingFilter() {
+      await $("hotelOffers/saveFilters", {
+        ...this.filters,
+        [c.REVIEW_RATING]: X
+      });
+    },
+    onResetFilters() {
+      this.filterByPriceModel = w[c.PRICE], this.filterByStarRatingModel = w[c.RATING], this.filterByReviewRatingModel = w[c.REVIEW_RATING];
+    },
+    syncFilters() {
+      this.filterByPriceModel = this.filters[c.PRICE], this.filterByStarRatingModel = this.filters[c.RATING], this.filterByReviewRatingModel = this.filters[c.REVIEW_RATING];
+    }
+  }
+});
+var Ii = function() {
+  var t = this, i = t._self._c;
+  return t._self._setupProxy, i("div", [i(be, { attrs: { absolute: "", "overlay-opacity": "0.3", temporary: "", width: t.$isCurrentBreakpointBelow("sm") ? "100%" : "auto" }, model: { value: t.isDialogOpen, callback: function(s) {
+    t.isDialogOpen = s;
+  }, expression: "isDialogOpen" } }, [i(k, { attrs: { elevation: "0", light: "" } }, [i(ne, { staticClass: "py-1", staticStyle: { "background-color": "#fff", "z-index": "1", position: "fixed", top: "0", width: "100%" } }, [i(v, [i(u, { attrs: { cols: "auto" } }, [i(l, { attrs: { icon: "" }, on: { click: t.onCancel } }, [i(g, [t._v(" fa fa-arrow-left ")])], 1), i("small", {}, [t._v(" " + t._s(t.$t("BHotelFiltersMenu.filterBy")) + " ")])], 1), i(u, { attrs: { align: "end" } }, [i(l, { staticClass: "mr-2", attrs: { color: "primary", small: "", text: "" }, on: { click: t.onCancel } }, [t._v(" " + t._s(t.$t("BHotelFiltersMenu.cancel")) + " ")]), i(l, { staticClass: "mr-2", attrs: { color: "error", small: "", text: "" }, on: { click: t.onResetFilters } }, [t._v(" " + t._s(t.$t("BHotelFiltersMenu.reset")) + " ")]), i(l, { attrs: { color: "success", elevation: "0", small: "" }, on: { click: t.onSaveFilters } }, [t._v(" " + t._s(t.$t("BHotelFiltersMenu.apply")) + " ")])], 1)], 1)], 1), i(O, { staticClass: "mt-11" }), i(P, [i(v, [i(u, { staticClass: "px-8", attrs: { align: "center", cols: "12" } }, [i("p", { staticClass: "font-weight-bold" }, [t._v(" " + t._s(t.$t("BHotelFiltersMenu.price")) + " ")]), i("b-filter-by-price", { attrs: { currency: t.config.currency, "is-loading": t.isLoading, "price-max": t.priceMax, "price-min": t.priceMin, "step-count": t.priceHistogramStepCount }, model: { value: t.filterByPriceModel, callback: function(s) {
+    t.filterByPriceModel = s;
+  }, expression: "filterByPriceModel" } })], 1)], 1), i(O, { staticClass: "my-6 mx-12" }), i(v, [i(u, { attrs: { align: "center", cols: "12" } }, [i("p", { staticClass: "font-weight-bold" }, [t._v(" " + t._s(t.$t("BHotelFiltersMenu.star")) + " ")]), i("b-filter-by-star", { model: { value: t.filterByStarRatingModel, callback: function(s) {
+    t.filterByStarRatingModel = s;
+  }, expression: "filterByStarRatingModel" } })], 1)], 1), i(O, { staticClass: "my-6 mx-12" }), i(v, [i(u, { staticClass: "py-4", attrs: { align: "center", cols: "12" } }, [i("p", { staticClass: "font-weight-bold" }, [t._v(" " + t._s(t.$t("BHotelFiltersMenu.review")) + " ")]), i("b-filter-by-review", { model: { value: t.filterByReviewRatingModel, callback: function(s) {
+    t.filterByReviewRatingModel = s;
+  }, expression: "filterByReviewRatingModel" } })], 1)], 1)], 1)], 1)], 1), i(v, { staticClass: "pa-2", attrs: { justify: "space-between" } }, [i(u, { attrs: { cols: "auto" } }, [i(v, { attrs: { dense: "" } }, [i(u, [i(V, { staticStyle: { cursor: "pointer" }, attrs: { bordered: "", color: "secondary", content: t.activeFiltersNumber, icon: "fa-times", overlap: "", value: t.activeFiltersNumber } }, [i(l, { attrs: { color: "secondary", elevation: 0, small: t.small }, on: { click: function(s) {
+    t.isDialogOpen = !0;
+  } } }, [i(g, { staticClass: "mr-1", attrs: { size: "14" } }, [t._v(" fa-sliders ")]), t._v(t._s(t.$t("BHotelFiltersMenu.filters")) + " ")], 1)], 1)], 1), t.isPriceFilterActive ? i(u, { staticClass: "mx-1" }, [i("b-filter-by-price-menu", { attrs: { currency: t.config.currency, "is-loading": t.isLoading, "price-max": t.priceMax, "price-min": t.priceMin, "step-count": t.priceHistogramStepCount }, on: { input: t.onSaveFilters, reset: t.resetPriceFilter }, model: { value: t.filterByPriceModel, callback: function(s) {
+    t.filterByPriceModel = s;
+  }, expression: "filterByPriceModel" } })], 1) : t._e(), t.isStarRatingFilterActive ? i(u, { staticClass: "mx-1" }, [i("b-filter-by-star-menu", { on: { input: t.onSaveFilters, reset: t.resetStarRatingFilter }, model: { value: t.filterByStarRatingModel, callback: function(s) {
+    t.filterByStarRatingModel = s;
+  }, expression: "filterByStarRatingModel" } })], 1) : t._e(), t.isReviewRatingFilterActive ? i(u, { staticClass: "mx-1" }, [i("b-filter-by-review-menu", { on: { input: t.onSaveFilters, reset: t.resetReviewRatingFilter }, model: { value: t.filterByReviewRatingModel, callback: function(s) {
+    t.filterByReviewRatingModel = s;
+  }, expression: "filterByReviewRatingModel" } })], 1) : t._e()], 1)], 1), t.withSort ? i(u, { attrs: { cols: "auto" } }, [i("b-sort-by-menu", { attrs: { attach: t.$el, "filter-key": t.FILTER_NAMES.SORT_BY, left: "" }, model: { value: t.sortByModel, callback: function(s) {
+    t.sortByModel = s;
+  }, expression: "sortByModel" } })], 1) : t._e()], 1)], 1);
+}, Fi = [], Vi = /* @__PURE__ */ m(
+  Ti,
+  Ii,
+  Fi,
+  !1,
+  null,
+  "c0c65af1",
+  null,
+  null
+);
+const Bs = Vi.exports;
+function Ai(e) {
+  return /^([+-]?\d*\.?\d+([Ee][+-]?\d+)?|[+-]?\d*\.?\d+)(px|em|rem|vw|vh|vmin|vmax|%|cm|mm|in|pt|pc|ch|ex|q)$/u.test(
+    e
+  );
+}
+function st(e) {
+  if (e)
+    return typeof e == "number" ? `${e}px` : typeof e == "string" && (Ai(e) || e.startsWith("var")) ? e : Number.isNaN(e) ? "100%" : `${e}px`;
+}
+const ks = h.extend({
+  data() {
+    return {
+      parsedHeight: st(this.height)
+    };
+  },
+  watch: {
+    height: {
+      immediate: !0,
+      handler(e) {
+        this.parsedHeight = st(e);
+      }
+    }
+  }
+});
+Ct("css/revolugo.parsed-height.Xzhpy3D3.css");
+export {
+  Cs as B,
+  $e as H,
+  f as a,
+  Bs as b,
+  $s as c,
+  ks as p
+};
+//# sourceMappingURL=revolugo.parsed-height.DRzHRmIo.min.js.map