@adyen/bento-vue3 1.91.0 → 1.92.0

package/dist/chunks/date-range-picker.BXzTT4AF.js

@@ -0,0 +1,1038 @@
+import { reactive as Te, defineComponent as sa, useSlots as Oa, ref as C, computed as c, onMounted as oa, openBlock as S, createElementBlock as ye, createElementVNode as z, normalizeClass as Me, unref as u, renderSlot as Ge, createCommentVNode as F, createBlock as N, withCtx as $, createTextVNode as ne, toDisplayString as ge, createVNode as V, createSlots as Ee, toRaw as Oe, watch as he, useAttrs as _a, toRef as Se, withDirectives as qa, withKeys as Le } from "vue";
+import { j as Ba } from "./index.DDwcHPb6.js";
+import { B as Ca } from "./divider.BIY84UH7.js";
+import { h as Na, B as xa } from "./button-actions.7Oi2Ra4p.js";
+import { B as _e, d as Qe } from "./typography.B3J6_tYk.js";
+import { B as Pa, D as Ua } from "./dropdown.CuIBYLdy.js";
+import { g as ue } from "./generate-uid.DBWe4g6T.js";
+import { u as qe } from "./index.B875RXHM.js";
+import { h as de, i as B, j as T, k as Va, l as Je, m as Ga, s as je, n as La, o as Qa, q as Ja, r as We, t as ja, b as U, u as Wa, e as za, f as $a, v as _, p as ze, w as $e, g as Ha } from "./calendar.DfMwuOIR.js";
+import { u as Be, a as Ka } from "./use-date-input-formatter.BH4hdEJW.js";
+import { t as H, n as Xa, c as Za } from "./en-US.BR6y7foR.js";
+import { u as et } from "./use-form-layout-loading.CWbjZiwP.js";
+import { B as at } from "./directive.C8kY-ZW-.js";
+import { u as tt } from "./form-field.D_2g7vaP.js";
+import { B as nt } from "./alert.RD0qOLhx.js";
+import { B as He } from "./input-field.FkzBZDWS.js";
+import { B as Ke, i as Xe } from "./input-time.DlvANG4O.js";
+import { B as rt } from "./segmented-control.CQWOO1-J.js";
+import { d as Ze } from "./use-cached-selected-values.DUWGSMvO.js";
+import { u as lt } from "./use-has-slot.CyMiImRQ.js";
+import { u as st } from "./use-touch-device.DTqFAbXh.js";
+import { e as x, a as ea } from "./differenceInMonths.yz4Dfe-b.js";
+import { s as aa } from "./startOfWeek.muMEhS7U.js";
+import { c as ot } from "./constructNow.DyOJDyZZ.js";
+import { _ as ia } from "./_plugin-vue_export-helper.CHgC5LLL.js";
+import { F as it } from "./field-label.DZYFjFgr.js";
+import { E as ta } from "./error-message.Dyvrw6ZB.js";
+import { B as ut } from "./button-actions.types.BptAXjD8.js";
+import "../assets/date-range-picker.css";
+function na(n, m) {
+  return H(n, m?.in).getFullYear();
+}
+function we(n, m) {
+  return +H(n) == +H(m);
+}
+function dt(n, m, v) {
+  const [o, p] = Xa(
+    v?.in,
+    n,
+    m
+  );
+  return +de(o) == +de(p);
+}
+function ra(n, m) {
+  const v = H(n, m?.in);
+  return v.setMilliseconds(0), v;
+}
+function Fe(n, m) {
+  return +ra(n) == +ra(m);
+}
+function ct(n, m) {
+  return B(
+    Za(n, n),
+    ot(n)
+  );
+}
+function mt(n, m, v) {
+  const o = H(n, v?.in);
+  return o.setHours(m), o;
+}
+function la(n, m, v) {
+  const o = H(n, v?.in);
+  return o.setMilliseconds(m), o;
+}
+function Dt(n, m, v) {
+  const o = H(n, v?.in);
+  return o.setMinutes(m), o;
+}
+function pt(n, m, v) {
+  const o = H(n, v?.in);
+  return o.setSeconds(m), o;
+}
+const vt = ({
+  firstDayOfWeek: n,
+  min: m,
+  max: v
+}) => ({ getGranularCalendarLimits: (p) => {
+  if (!m && !v)
+    return { min: null, max: null };
+  let a = m ? T(m) : null, i = v ? x(v) : null;
+  if (p?.type === "weekly") {
+    if (p.earliest)
+      a = T(p.earliest);
+    else if (a) {
+      const f = aa(a, { weekStartsOn: n });
+      B(a, f) || (a = T(Va(Je(a, { weekStartsOn: n }), 1)));
+    }
+    if (p.latest)
+      i = x(p.latest);
+    else if (i) {
+      const f = Je(i, { weekStartsOn: n });
+      B(i, f) || (i = x(Ga(aa(i, { weekStartsOn: n }), 1)));
+    }
+  }
+  if (p?.type === "monthly") {
+    if (p.earliest)
+      a = T(p.earliest);
+    else if (a) {
+      const f = je(a);
+      B(a, f) || (a = je(La(a, 1)));
+    }
+    if (p.latest)
+      i = x(p.latest);
+    else if (i) {
+      const f = ea(i);
+      B(i, f) || (i = ea(Qa(i, 1)));
+    }
+  }
+  if (p?.type === "quarterly") {
+    if (p.earliest)
+      a = de(p.earliest);
+    else if (a) {
+      const f = de(a);
+      B(a, f) || (a = de(Ja(a, 1)));
+    }
+    if (p.latest)
+      i = x(p.latest);
+    else if (i) {
+      const f = We(i);
+      B(i, f) || (i = We(ja(i, 1)));
+    }
+  }
+  return { min: a, max: i };
+} }), ft = () => {
+  const n = Te({
+    daily: null,
+    weekly: null,
+    monthly: null,
+    quarterly: null
+  });
+  return {
+    savedRanges: n,
+    saveRange: (o, p) => {
+      n[o] = p;
+    },
+    resetSavedRanges: () => {
+      n.daily = null, n.weekly = null, n.monthly = null, n.quarterly = null;
+    }
+  };
+};
+var D = /* @__PURE__ */ ((n) => (n.CUSTOM_RANGE = "custom-range", n.INPUT = "input", n.ERROR = "error", n.FORM_DATE = "form-date", n.START_DATE_SELECTED = "start-date-selected", n))(D || {});
+const ua = {
+  "de-DE": { "DD-MM-YYYY": "TT-MM-JJJJ", "MM-DD-YYYY": "JJJJ-MM-TT", "YYYY-MM-DD": "JJJJ-MM-TT", customRange: "Benutzerdefinierter Bereich", daily: "Täglich", dateFrom: "Datum von", dateTo: "Datum bis", lastMonth: "Letzter Monat", lastSevenDays: "Letzte 7 Tage", lastThreeMonths: "Letzte drei Monate", monthly: "Monatlich", quarterly: "Vierteljährlich", timeFrom: "Zeit von", timeTo: "Zeit bis", weekly: "Wöchentlich" },
+  "en-GB": { "DD-MM-YYYY": "DD-MM-YYYY", "MM-DD-YYYY": "MM-DD-YYYY", "YYYY-MM-DD": "YYYY-MM-DD", customRange: "Custom range", daily: "Daily", dateFrom: "Date from", dateTo: "Date to", lastMonth: "Last month", lastSevenDays: "Last 7 days", lastThreeMonths: "The last three months", monthly: "Monthly", quarterly: "Quarterly", timeFrom: "Time from", timeTo: "Time to", weekly: "Weekly" },
+  "en-US": { "DD-MM-YYYY": "DD-MM-YYYY", "MM-DD-YYYY": "MM-DD-YYYY", "YYYY-MM-DD": "YYYY-MM-DD", customRange: "Custom range", daily: "Daily", dateFrom: "Date from", dateTo: "Date to", lastMonth: "Last month", lastSevenDays: "Last 7 days", lastThreeMonths: "Last three months", maxRangeDays: "You can select up to {count} day | You can select up to {count} days", maxRangeMonths: "You can select up to {count} month | You can select up to {count} months", maxRangeQuarters: "You can select up to {count} quarter | You can select up to {count} quarters", maxRangeWeeks: "You can select up to {count} week | You can select up to {count} weeks", monthly: "Monthly", quarterly: "Quarterly", timeFrom: "Time from", timeTo: "Time to", weekly: "Weekly" },
+  "es-ES": { "DD-MM-YYYY": "DD-MM-AAAA", "MM-DD-YYYY": "MM-DD-AAAA", "YYYY-MM-DD": "AAAA-MM-DD", customRange: "Rango personalizado", daily: "Diario", dateFrom: "Fecha desde", dateTo: "Fecha hasta", lastMonth: "El mes pasado", lastSevenDays: "Últimos 7 días", lastThreeMonths: "Últimos tres meses", monthly: "Mensualmente", quarterly: "Trimestral", timeFrom: "Hora desde", timeTo: "Hora hasta", weekly: "Semanal" },
+  "es-MX": { "DD-MM-YYYY": "DD-MM-AAAA", "MM-DD-YYYY": "MM-DD-AAAA", "YYYY-MM-DD": "AAAA-MM-DD", customRange: "Rango personalizado", daily: "Diario", dateFrom: "Fecha de", dateTo: "Fecha hasta", lastMonth: "El mes pasado", lastSevenDays: "Últimos 7 días", lastThreeMonths: "Últimos tres meses", monthly: "Mensual", quarterly: "Trimestral", timeFrom: "Tiempo desde", timeTo: "Es hora de", weekly: "Semanal" },
+  "fr-FR": { "DD-MM-YYYY": "JJ-MM-AAAA", "MM-DD-YYYY": "MM-JJ-AAAA", "YYYY-MM-DD": "AAAA-MM-JJ", customRange: "Plage personnalisée", daily: "Quotidien", dateFrom: "Date de début", dateTo: "Date de fin", lastMonth: "Le mois dernier", lastSevenDays: "7 derniers jours", lastThreeMonths: "Trois derniers mois", monthly: "Mensuel", quarterly: "Trimestriel", timeFrom: "Heure de début", timeTo: "Heure de fin", weekly: "Hebdomadaire" },
+  "it-IT": { "DD-MM-YYYY": "GG-MM-AAAA", "MM-DD-YYYY": "MM-GG-AAAA", "YYYY-MM-DD": "AAAA-MM-GG", customRange: "Intervallo personalizzato", daily: "Giornaliero", dateFrom: "Data da", dateTo: "Da", lastMonth: "Il mese scorso", lastSevenDays: "Ultimi 7 giorni", lastThreeMonths: "Gli ultimi tre mesi", monthly: "Mensile", quarterly: "Trimestrale", timeFrom: "Tempo dal", timeTo: "Tempo fino al", weekly: "Settimanale" },
+  "ja-JP": { "DD-MM-YYYY": "DD-MM-YYYY", "MM-DD-YYYY": "MM-DD-YYYY", "YYYY-MM-DD": "YYYY-MM-DD", customRange: "カスタム範囲", daily: "毎日", dateFrom: "開始日", dateTo: "終了日", lastMonth: "先月", lastSevenDays: "過去 7 日間", lastThreeMonths: "過去3か月", monthly: "毎月", quarterly: "四半期ごと", timeFrom: "開始時刻", timeTo: "終了時刻", weekly: "毎週" },
+  "pt-BR": { "DD-MM-YYYY": "DD-MM-AAAA", "MM-DD-YYYY": "MM-DD-AAAA", "YYYY-MM-DD": "AAAA-MM-DD", customRange: "Intervalo personalizado", daily: "Diário", dateFrom: "Data a partir de", dateTo: "Data até", lastMonth: "Último mês", lastSevenDays: "Últimos 7 dias", lastThreeMonths: "Últimos 3 meses", monthly: "Mensal", quarterly: "Trimestral", timeFrom: "Horário a partir de", timeTo: "Horário até", weekly: "Semanal" },
+  "zh-CN": { "DD-MM-YYYY": "日-月-年", "MM-DD-YYYY": "YYYY-MM-DD", "YYYY-MM-DD": "年-月-日", customRange: "自定义范围", daily: "每日", dateFrom: "日期自", dateTo: "日期至", lastMonth: "上个月", lastSevenDays: "最近 7 天", lastThreeMonths: "过去三个月", monthly: "每月", quarterly: "每季度", timeFrom: "时间自", timeTo: "是时候", weekly: "每周" }
+}, yt = { class: "b-date-range-picker-calendar" }, Mt = { class: "b-date-range-picker-calendar__form" }, gt = { key: 0 }, ht = {
+  key: 0,
+  class: "b-date-range-picker-calendar__calendars-container",
+  "data-testid": "date-range-picker-calendar-calendar-container"
+}, Tt = {
+  name: "date-range-picker-calendar",
+  i18n: { messages: ua }
+}, Yt = /* @__PURE__ */ sa({
+  ...Tt,
+  props: {
+    /**
+     * Allows user to enter time values in the form
+     */
+    allowTimeInput: { type: Boolean, default: !1 },
+    /**
+     * Ranges form persistance data
+     */
+    dateFormData: {
+      type: Object,
+      default: () => ({ startDate: void 0, endDate: void 0, startTime: void 0, endTime: void 0 })
+    },
+    /**
+     * Allows you to set the first day of the week. 0 is sunday, 1 is monday, 6 is saturday
+     */
+    firstDayOfWeek: U.props.firstDayOfWeek,
+    /**
+     * A list of available granularities.
+     * If present, the date picker will display a segmented control to change granularity.
+     */
+    granularities: {
+      type: Array,
+      default: null
+    },
+    /**
+     * Indicate if a date should be disabled or not
+     */
+    isDateDisabled: U.props.isDateDisabled,
+    /**
+     * Set a maximum number of dates to be selectable by the range.
+     */
+    maxRange: U.props.maxRange,
+    /**
+     * Sets a minimum limit for selectable dates - dates before `min` will not be selectable
+     */
+    min: U.props.min,
+    /**
+     * Sets a maximum limit for selectable dates - dates after `max` will not be selectable
+     */
+    max: U.props.max,
+    /**
+     * Number of months rendered on pane
+     */
+    numberOfMonths: {
+      type: U.props.numberOfMonths.type,
+      default: U.props.numberOfMonths.default,
+      validator: (n) => n >= 0
+    },
+    /**
+     * Displays the end date's month when the calendar is opened. Defaults to false i.e. the start date's month is displayed.
+     */
+    showEndDateOnOpen: { type: Boolean, default: !1 },
+    /**
+     * Enables the custom range selector.
+     * If provided, must be an array that sets the custom range dropdown items. Items are of the structure:
+     * `label` - label of custom range item.
+     * `value` - a unique key of the custom range item.
+     * `data` - an object `{ startDate: Date; endDate: Date }` to set the date picker range to upon selecting.
+     */
+    quickSelectRanges: {
+      type: Array,
+      default: void 0
+    },
+    /**
+     * Selected date
+     */
+    value: { type: Object, default: void 0 },
+    /**
+     * The type of calendar to display. Defaults to showing days.
+     */
+    variant: U.props.variant
+  },
+  emits: [
+    D.CUSTOM_RANGE,
+    D.INPUT,
+    D.ERROR,
+    D.FORM_DATE,
+    D.START_DATE_SELECTED
+  ],
+  setup(n, { emit: m }) {
+    const o = "customRange", p = {
+      daily: "maxRangeDays",
+      weekly: "maxRangeWeeks",
+      monthly: "maxRangeMonths",
+      quarterly: "maxRangeQuarters"
+    }, a = n, i = m, f = Oa(), G = lt(f), { t: Y, tc: R } = qe({ messages: ua }), { isTouchDevice: k } = st(), {
+      dateFormat: re,
+      isFormatValid: b,
+      parseDate: g,
+      onKeyDown: P,
+      autoFormat: L,
+      formatDate: le
+    } = Be(), A = C({}), ae = c(() => a.variant === "month" ? "monthly" : "daily"), w = c(() => a.numberOfMonths === 0), r = Te({
+      startDate: a.value?.startDate,
+      endDate: a.value?.endDate,
+      range: a.value?.range,
+      ...a.granularities ? {
+        granularity: a.value?.granularity || ae.value
+      } : {}
+    }), E = c(() => (
+      // eslint-disable-next-line consistent-return
+      a?.quickSelectRanges?.find(({ value: e, data: t }) => {
+        if (!t.endDate) {
+          if (t.isRelativeToNow) {
+            const d = A.value?.[e];
+            return d ? we(d.startDate, r.startDate) && we(d.endDate, r.endDate) : (
+              // If not stored calculated dates, fall back to comparing the quick select item's value
+              // with the internal range's stored range identifier.
+              e === r.range
+            );
+          }
+          return we(t.startDate, r.startDate) && ct(r.endDate) && (!a.allowTimeInput || Fe(r.endDate, x(r.endDate))) && (a.granularities ? t.granularity === r.granularity : !0);
+        }
+        if (a.allowTimeInput)
+          return Fe(t.startDate, r.startDate) && Fe(t.endDate, r.endDate) && (a.granularities ? t.granularity === r.granularity : !0);
+        if (t.endDate)
+          return B(t.startDate, r.startDate) && B(t.endDate, r.endDate) && (a.granularities ? t.granularity === r.granularity : !0);
+      })?.value ?? o
+    )), se = c(() => ({
+      "b-date-range-picker-calendar__form-input-wrapper": a.allowTimeInput
+    })), oe = c(() => [
+      { label: Y("customRange"), value: o },
+      ...a.quickSelectRanges ? a.quickSelectRanges : []
+    ]), K = c(
+      () => a.granularities?.find(({ type: e }) => e === r.granularity) || null
+    ), Ye = c(
+      () => a.granularities?.map(({ type: e, disabled: t }) => ({
+        label: Y(e),
+        value: e,
+        disabled: t
+      })) ?? []
+    ), { getGranularCalendarLimits: ce } = vt(a), M = c(
+      () => a.granularities ? ce(K.value) : { min: a.min ? T(a.min) : null, max: a.max ? x(a.max) : null }
+    ), {
+      adjustDateForQuarterly: h,
+      adjustDateForMonthly: be,
+      adjustDateForWeekly: X,
+      adjustStartDateInputForWeekly: Ae,
+      adjustEndDateInputForWeekly: me,
+      adjustStartDateInputForMonthly: De,
+      adjustEndDateInputForMonthly: Q,
+      adjustStartDateInputForQuarterly: te,
+      adjustEndDateInputForQuarterly: Re
+    } = Wa(a.firstDayOfWeek), { savedRanges: J, saveRange: ke, resetSavedRanges: pe } = ft(), I = (e) => e ? le(e) : "", Z = C(!1), ee = C(!1), l = Te({
+      startDate: a.dateFormData.startDate,
+      endDate: a.dateFormData.endDate,
+      startTime: a.dateFormData.startTime,
+      endTime: a.dateFormData.endTime
+    }), ve = (e, t) => {
+      let d = new Date(e);
+      const [y, W, Ea] = t.split(":");
+      return d = mt(d, parseInt(y, 10)), d = Dt(d, parseInt(W, 10)), d = pt(d, parseInt(Ea, 10)), d;
+    }, s = (e, t) => {
+      const d = () => {
+        if (t && j(t)) {
+          const y = ve(g(t), e);
+          if (a.min && y < la(a.min, 0) || a.max && y > la(a.max, 0))
+            return !1;
+        }
+        return !0;
+      };
+      return Xe(e) && d();
+    }, O = c(() => a.variant === "month"), ie = (e) => e ? O.value ? za(e) : $a(e) : "", da = c(() => ie(r.startDate)), ca = c(() => ie(r.endDate)), Ne = c(() => k.value ? O.value ? "month" : "date" : "text"), ma = c(() => k.value ? da.value : l.startDate), Da = c(() => k.value ? ca.value : l.endDate), q = (e, t) => !t || !Xe(t) || a.variant === "month" ? e : ve(new Date(e), t), pa = (e) => {
+      l.startTime = _(
+        a.min && a.allowTimeInput && B(a.min, e.startDate) ? a.min : T(e.startDate)
+      ), l.endTime = _(
+        a.max && a.allowTimeInput && B(a.max, e.endDate) ? a.max : x(e.endDate)
+      ), r.startDate = q(e.startDate, l.startTime), r.endDate = q(e.endDate, l.endTime), r.range = null, a.granularities && pe(), i(D.INPUT, {
+        ...r,
+        range: E.value
+      });
+    }, j = (e) => {
+      if (!e)
+        return !1;
+      const t = (d) => a.min && T(d) < T(a.min) || a.max && T(d) > T(a.max) ? !1 : a.isDateDisabled ? !a.isDateDisabled(T(d)) : !0;
+      return b(e) && t(g(e));
+    };
+    oa(() => {
+      Z.value = !!(a.dateFormData.startDate && !j(a.dateFormData.startDate)), ee.value = !!(a.dateFormData.endDate && !j(a.dateFormData.endDate));
+    });
+    const va = (e) => {
+      l.startDate = I(e), l.startTime || (l.startTime = _(e)), Z.value = !1, i(D.START_DATE_SELECTED, e);
+    }, fa = (e) => {
+      l.endDate = I(e), l.endTime || (l.endTime = _(x(e))), ee.value = !1;
+    }, Ie = (e) => {
+      const t = a.value[e];
+      if (t)
+        return t;
+      if (a.dateFormData[e] && j(a.dateFormData[e]))
+        return g(a.dateFormData[e]);
+    }, xe = (e) => {
+      if (j(e)) {
+        let t = e;
+        switch (Z.value = !1, K.value?.type) {
+          case "weekly":
+            t = Ae(
+              e,
+              I,
+              M.value.min,
+              M.value.max
+            ), l.startDate = t;
+            break;
+          case "monthly":
+            t = De(
+              e,
+              I,
+              M.value.min,
+              M.value.max
+            ), l.startDate = t;
+            break;
+          case "quarterly":
+            t = te(
+              e,
+              I,
+              M.value.min,
+              M.value.max
+            ), l.startDate = t;
+            break;
+        }
+        const d = T(g(t));
+        r.startDate = q(d, l.startTime), r.endDate = q(
+          T(g(l.endDate)),
+          l.endTime
+        ), j(l.endDate) && (r.endDate = q(
+          T(g(l.endDate)),
+          l.endTime
+        ));
+        const y = Ie("endDate");
+        r.range = null, i(D.FORM_DATE, {
+          startDate: d,
+          endDate: y
+        }), i(D.INPUT, {
+          ...r,
+          range: E.value
+        });
+      } else
+        Z.value = !0, i(D.ERROR, { ...l });
+    }, ya = Ze(xe, 300), Ma = (e) => {
+      if (l.startDate = k.value && O.value ? e : L(e), k.value)
+        if (O.value && e) {
+          const t = ze(e);
+          r.startDate = q(t, l.startTime), r.range = null, i(D.INPUT, {
+            ...r,
+            range: E.value
+          });
+        } else
+          xe(l.startDate);
+      else
+        ya(l.startDate);
+    }, Pe = (e) => {
+      if (j(e)) {
+        let t = e;
+        switch (ee.value = !1, K.value?.type) {
+          case "weekly":
+            t = me(
+              e,
+              I,
+              M.value.min,
+              M.value.max
+            ), l.endDate = t;
+            break;
+          case "monthly":
+            t = Q(
+              e,
+              I,
+              M.value.min,
+              M.value.max
+            ), l.endDate = t;
+            break;
+          case "quarterly":
+            t = Re(
+              e,
+              I,
+              M.value.min,
+              M.value.max
+            ), l.endDate = t;
+            break;
+        }
+        const d = T(g(t));
+        r.endDate = q(d, l.endTime), j(l.startDate) && (r.startDate = q(
+          T(g(l.startDate)),
+          l.startTime
+        ));
+        const y = Ie("startDate");
+        r.range = null, i(D.FORM_DATE, {
+          startDate: y,
+          endDate: d
+        }), i(D.INPUT, {
+          ...r,
+          range: E.value
+        });
+      } else
+        ee.value = !0, i(D.ERROR, { ...l });
+    }, ga = Ze(Pe, 300), ha = (e) => {
+      if (l.endDate = k.value && O.value ? e : L(e), k.value)
+        if (O.value && e) {
+          const t = ze(e);
+          r.endDate = q(t, l.endTime), r.range = null, i(D.INPUT, {
+            ...r,
+            range: E.value
+          });
+        } else
+          Pe(l.endDate);
+      else
+        ga(l.endDate);
+    }, Ue = (e) => {
+      P(e);
+    }, Ta = () => {
+      i(D.ERROR, { ...l });
+    }, Ya = () => {
+      const e = l.startTime;
+      if (!s(e, l.startDate)) {
+        i(D.ERROR, { ...l });
+        return;
+      }
+      r.startDate = q(r.startDate, e);
+      const t = Ie("endDate");
+      i(D.FORM_DATE, {
+        startDate: r.startDate,
+        endDate: t,
+        startTime: e,
+        endTime: l.endTime ?? a.dateFormData.endTime
+      }), i(D.INPUT, {
+        ...r,
+        range: E.value
+      });
+    }, ba = () => {
+      i(D.ERROR, { ...l });
+    }, Aa = () => {
+      const e = l.endTime;
+      if (!s(e, l.endDate)) {
+        i(D.ERROR, { ...l });
+        return;
+      }
+      r.endDate = q(r.endDate, e), i(D.FORM_DATE, {
+        startDate: r.startDate,
+        endDate: r.endDate,
+        startTime: l.startTime ?? a.dateFormData.startTime,
+        endTime: e
+      }), i(D.INPUT, {
+        ...r,
+        range: E.value
+      });
+    }, Ra = (e) => {
+      l.startTime = e;
+    }, ka = (e) => {
+      l.endTime = e;
+    }, fe = (e, t, d, y) => {
+      r.startDate = e, r.endDate = t, d && (r.granularity = d), y && (r.range = y);
+    }, Ia = (e) => {
+      const t = a.quickSelectRanges?.find(({ value: d }) => d === e);
+      if (t) {
+        pe();
+        const d = t.data, y = d.endDate || (d.isRelativeToNow ? new Date(Date.now()) : x(new Date(Date.now()))), W = d.isRelativeToNow && d.timeDifference ? new Date(y.getTime() - d.timeDifference) : d.startDate;
+        l.endDate = I(y), l.startDate = I(W), fe(W, y, null, e), a.granularities && (r.granularity = d.granularity || ae.value), l.startTime = _(W), l.endTime = _(y), r.startDate = W, r.endDate = y, d.isRelativeToNow && (A.value = {
+          ...A.value,
+          [e]: {
+            startDate: W,
+            endDate: y
+          }
+        }), i(D.CUSTOM_RANGE, {
+          ...t.data,
+          startDate: W,
+          endDate: y,
+          range: t.value
+        });
+      }
+    }, Sa = {
+      weekly: X,
+      monthly: be,
+      quarterly: h
+    }, wa = (e) => {
+      const t = r.granularity;
+      if (r.granularity = e, t && ke(t, structuredClone(Oe(r))), r.startDate && r.endDate) {
+        switch (e) {
+          case "quarterly":
+          case "monthly":
+          case "weekly": {
+            if (J[e]) {
+              fe(J[e].startDate, J[e].endDate, e);
+              break;
+            }
+            const { startDate: d, endDate: y } = Sa[e](
+              r.startDate,
+              r.endDate,
+              M.value.min,
+              M.value.max
+            );
+            fe(d, y, e);
+            break;
+          }
+          case "daily":
+            J.daily && fe(J.daily.startDate, J.daily.endDate, e);
+            break;
+        }
+        l.startDate = I(r.startDate), l.endDate = I(r.endDate), i(D.INPUT, {
+          ...r,
+          range: E.value
+        });
+      }
+    }, Fa = c(() => ({
+      "b-date-range-picker-calendar__form-container--no-calendars": w.value
+    })), Ve = c(() => {
+      const e = K.value, t = e?.maxRange || a.maxRange;
+      if (!t)
+        return null;
+      const d = p[e?.type ?? "daily"];
+      return R(d, t, { count: t });
+    });
+    return (e, t) => (S(), ye("div", yt, [
+      z("div", {
+        class: Me(["b-date-range-picker-calendar__form-container", Fa.value]),
+        "data-testid": "date-range-picker-calendar-form-container"
+      }, [
+        z("div", Mt, [
+          u(G)("title") ? Ge(e.$slots, "title", { key: 0 }, void 0, !0) : F("", !0),
+          n.quickSelectRanges ? (S(), N(Pa, {
+            key: 1,
+            "aria-label": u(Y)("customRange"),
+            items: oe.value,
+            "model-value": E.value,
+            "onUpdate:modelValue": Ia
+          }, null, 8, ["aria-label", "items", "model-value"])) : F("", !0),
+          n.granularities ? (S(), N(u(rt), {
+            key: 2,
+            items: Ye.value,
+            "model-value": r.granularity,
+            "full-width": "",
+            "onUpdate:modelValue": wa
+          }, null, 8, ["items", "model-value"])) : F("", !0),
+          Ve.value ? (S(), N(u(nt), {
+            key: 3,
+            variant: "tip"
+          }, {
+            description: $(() => [
+              ne(ge(Ve.value), 1)
+            ]),
+            _: 1
+          })) : F("", !0),
+          z("div", null, [
+            V(u(_e), {
+              stronger: "",
+              el: "span",
+              class: "b-date-range-picker-calendar__label"
+            }, {
+              default: $(() => t[0] || (t[0] = [
+                ne(" From ")
+              ])),
+              _: 1
+            }),
+            z("div", {
+              class: Me(se.value)
+            }, [
+              V(u(He), {
+                "aria-label": u(Y)("dateFrom"),
+                "model-value": ma.value,
+                error: Z.value,
+                class: "b-date-range-picker-calendar__form-input",
+                type: Ne.value,
+                "onUpdate:modelValue": Ma,
+                onKeydown: Ue
+              }, Ee({ _: 2 }, [
+                u(k) ? void 0 : {
+                  name: "description",
+                  fn: $(() => [
+                    ne(ge(u(Y)(u(re))), 1)
+                  ]),
+                  key: "0"
+                }
+              ]), 1032, ["aria-label", "model-value", "error", "type"]),
+              n.allowTimeInput ? (S(), N(u(Ke), {
+                key: 0,
+                "aria-label": u(Y)("timeFrom"),
+                "model-value": l.startTime,
+                class: "b-date-range-picker-calendar__form-input",
+                "onUpdate:modelValue": Ra,
+                "onInput:error": Ta,
+                "onInput:valid": Ya
+              }, null, 8, ["aria-label", "model-value"])) : F("", !0)
+            ], 2)
+          ]),
+          z("div", null, [
+            V(u(_e), {
+              stronger: "",
+              el: "span",
+              class: "b-date-range-picker-calendar__label"
+            }, {
+              default: $(() => t[1] || (t[1] = [
+                ne(" To ")
+              ])),
+              _: 1
+            }),
+            z("div", {
+              class: Me(se.value)
+            }, [
+              V(u(He), {
+                class: "b-date-range-picker-calendar__form-input",
+                "aria-label": u(Y)("dateTo"),
+                "model-value": Da.value,
+                error: ee.value,
+                type: Ne.value,
+                "onUpdate:modelValue": ha,
+                onKeydown: Ue
+              }, Ee({ _: 2 }, [
+                u(k) ? void 0 : {
+                  name: "description",
+                  fn: $(() => [
+                    ne(ge(u(Y)(u(re))), 1)
+                  ]),
+                  key: "0"
+                }
+              ]), 1032, ["aria-label", "model-value", "error", "type"]),
+              n.allowTimeInput ? (S(), N(u(Ke), {
+                key: 0,
+                "aria-label": u(Y)("timeTo"),
+                "model-value": l.endTime,
+                class: "b-date-range-picker-calendar__form-input",
+                "onUpdate:modelValue": ka,
+                "onInput:error": ba,
+                "onInput:valid": Aa
+              }, null, 8, ["aria-label", "model-value"])) : F("", !0)
+            ], 2)
+          ])
+        ]),
+        u(G)("actions") ? (S(), ye("div", gt, [
+          Ge(e.$slots, "actions", {}, void 0, !0)
+        ])) : F("", !0)
+      ], 2),
+      !w.value && !u(k) ? (S(), ye("div", ht, [
+        V(u(U), {
+          value: r,
+          "first-day-of-week": n.firstDayOfWeek,
+          "is-date-disabled": n.isDateDisabled,
+          "max-range": n.maxRange,
+          min: M.value.min,
+          max: M.value.max,
+          "number-of-months": n.numberOfMonths,
+          "show-end-date-on-open": n.showEndDateOnOpen,
+          granularity: K.value,
+          variant: n.variant,
+          "is-range": "",
+          onInput: pa,
+          onStartDateSelected: va,
+          onEndDateSelected: fa
+        }, null, 8, ["value", "first-day-of-week", "is-date-disabled", "max-range", "min", "max", "number-of-months", "show-end-date-on-open", "granularity", "variant"])
+      ])) : F("", !0)
+    ]));
+  }
+}), bt = /* @__PURE__ */ ia(Yt, [["__scopeId", "data-v-91390acb"]]), Ce = {
+  "de-DE": { apply: "Anwenden", cancel: "Abbrechen", dateRangePicker: "Datumsbereichauswahl {name}", provideDateInAFormat: "Geben Sie das Datum im Format YYYY-MM-DD an", quarter: "Q{quarter} {year}", selectDate: "Wählen Sie ein Datum", selectDateRange: "Wählen Sie einen Datumsbereich aus", selectedDateIsNotAvailable: "Ausgewähltes Datum ist nicht verfügbar" },
+  "en-GB": { apply: "Apply", cancel: "Cancel", dateRangePicker: "Date range picker {name}", provideDateInAFormat: "Enter date in YYYY-MM-DD format", quarter: "Q{quarter} {year}", selectDate: "Select a date", selectDateRange: "Select a date range", selectedDateIsNotAvailable: "Selected date is not available" },
+  "en-US": { apply: "Apply", cancel: "Cancel", dateRangePicker: "Date range picker {name}", provideDateInAFormat: "Provide date in a YYYY-MM-DD format", quarter: "Q{quarter} {year}", selectDate: "Select a date", selectDateRange: "Select a date range", selectedDateIsNotAvailable: "Selected date is not available" },
+  "es-ES": { apply: "Aplicar", cancel: "Cancelar", dateRangePicker: "Selector de intervalos de fechas {name}", provideDateInAFormat: "Proporciona la fecha en formato AAAAA-MM-DD", quarter: "T{quarter} {year}", selectDate: "Selecciona una fecha", selectDateRange: "Selecciona un rango de fechas", selectedDateIsNotAvailable: "La fecha seleccionada no está disponible" },
+  "es-MX": { apply: "Aplicar", cancel: "Cancelar", dateRangePicker: "Selector de intervalos de fechas {name}", provideDateInAFormat: "Proporciona la fecha en formato AAAA-MM-DD", quarter: "T{quarter} {year}", selectDate: "Selecciona una fecha", selectDateRange: "Selecciona un rango de fechas", selectedDateIsNotAvailable: "La fecha seleccionada no está disponible" },
+  "fr-FR": { apply: "Appliquer", cancel: "Annuler", dateRangePicker: "Sélecteur de plages de dates {name}", provideDateInAFormat: "Fournissez la date au format AAAA-MM-JJ", quarter: "T{quarter} {year}", selectDate: "Sélectionnez une date", selectDateRange: "Sélectionnez une plage de dates", selectedDateIsNotAvailable: "La date sélectionnée n’est pas disponible" },
+  "it-IT": { apply: "Applica", cancel: "Annulla", dateRangePicker: "Selettore intervallo di date {name}", provideDateInAFormat: "Inserisci la data nel formato AAAA-MM-GG", quarter: "Q{quarter} {year}", selectDate: "Seleziona una data", selectDateRange: "Seleziona un intervallo di date", selectedDateIsNotAvailable: "La data selezionata non è disponibile" },
+  "ja-JP": { apply: "適用", cancel: "キャンセル", dateRangePicker: "日付範囲ピッカー {name}", provideDateInAFormat: "YYYY-MM-DD形式で日付を入力してください", quarter: "{year}年第{quarter}四半期", selectDate: "日付を選択", selectDateRange: "日付範囲を選択", selectedDateIsNotAvailable: "選択した日付は利用できません" },
+  "pt-BR": { apply: "Aplicar", cancel: "Cancelar", dateRangePicker: "Seletor de intervalo de datas {name}", provideDateInAFormat: "Inclua a data no formato AAAA-MM-DD", quarter: "{quarter}º trimestre de {year}", selectDate: "Selecione uma data", selectDateRange: "Selecione um intervalo de datas", selectedDateIsNotAvailable: "A data selecionada não está disponível" },
+  "zh-CN": { apply: "应用", cancel: "取消", dateRangePicker: "日期范围选择器 {name}", provideDateInAFormat: "提供 YYYY-MM-DD 格式的日期", quarter: "{year} {quarter} 季度", selectDate: "选择日期", selectDateRange: "选择日期范围", selectedDateIsNotAvailable: "所选日期不可用" }
+}, At = ({
+  datePickerValue: n,
+  isDateIncorrect: m,
+  quickSelectRanges: v,
+  isMonthVariant: o,
+  withTimeInput: p,
+  placeholder: a
+}) => {
+  const { locale: i, t: f } = qe({ messages: Ce }), { dateToInputDateString: G } = Be(), Y = (b) => !!b && !isNaN(b.getTime()), R = Te({
+    startDate: null,
+    endDate: null,
+    startTime: null,
+    endTime: null
+  });
+  return he(
+    n,
+    (b) => {
+      R.startDate = G(b?.startDate), R.endDate = G(b?.endDate), R.startTime = _(b?.startDate), R.endTime = _(b?.endDate);
+    },
+    { immediate: !0 }
+  ), {
+    // Values
+    dateDisplayValue: c(() => {
+      if (m.value)
+        return `${R.startDate || ""} - ${R.endDate || ""}`;
+      if (!n.value || !n.value.startDate && !n.value.endDate)
+        return a?.value || f("selectDateRange");
+      if (v.value?.length) {
+        const g = v.value.find(({ value: P }) => P === n.value?.range);
+        if (g)
+          return g.label;
+      }
+      if (n.value.granularity === "quarterly") {
+        const { startDate: g, endDate: P } = n.value, L = f("quarter", { quarter: $e(g), year: na(g) });
+        if (dt(g, P))
+          return L;
+        const le = f("quarter", { quarter: $e(P), year: na(P) });
+        return `${L} - ${le}`;
+      }
+      if (!Y(n.value.startDate) || !Y(n.value.endDate))
+        return `${R.startDate || ""} - ${R.endDate || ""}`;
+      let b = o?.value ? { month: "long", year: "numeric" } : { month: "short", day: "2-digit", year: "numeric" };
+      return p.value && (b = {
+        ...b,
+        hour: "numeric",
+        minute: "numeric",
+        second: "numeric",
+        hour12: !1
+      }), Ha(i.value, b).formatRange(
+        n.value.startDate,
+        n.value.endDate
+      );
+    }),
+    textInputDisplayValue: R,
+    // Methods
+    formatTextInputDisplayValue: () => ""
+  };
+}, Rt = { class: "b-date-range-picker" }, kt = { class: "b-date-range-picker__footer" }, It = {
+  i18n: { messages: Ce },
+  name: "bento-date-range-picker",
+  model: { prop: "modelValue" }
+}, St = /* @__PURE__ */ sa({
+  ...It,
+  props: {
+    allowTimeInput: { type: Boolean },
+    firstDayOfWeek: { default: void 0 },
+    granularities: {},
+    isDateDisabled: { type: Function, default: void 0 },
+    showEndDateOnOpen: { type: Boolean, default: !1 },
+    quickSelectRanges: { default: void 0 },
+    maxRange: { default: null },
+    min: { default: null },
+    max: { default: null },
+    numberOfMonths: { default: void 0 },
+    modelValue: { default: null },
+    value: { default: null },
+    variant: { default: void 0 },
+    hasActions: { type: Boolean, default: !1 },
+    description: { default: void 0 },
+    disabled: { type: Boolean, default: !1 },
+    errorMessage: { default: null },
+    label: { default: void 0 },
+    optional: { type: Boolean, default: !1 },
+    placeholder: { default: null },
+    readonly: { type: Boolean, default: !1 },
+    required: { type: Boolean, default: !1 },
+    tooltipText: { default: null }
+  },
+  emits: ["update:model-value", "input"],
+  setup(n, { emit: m }) {
+    const v = m, o = n, p = _a(), { t: a } = qe({ messages: Ce }), { dateToInputDateString: i } = Be(), f = ue("bento-date-range-picker-container"), G = ue("bento-date-range-picker-label"), Y = ue("bento-date-range-picker-description"), R = ue("bento-date-range-picker-error"), k = ue("bento-date-range-picker-date-error"), re = c(() => o.label || a("dateRangePicker", { name: f })), { resolvedFirstDayOfWeek: b } = Ka(Se(o, "firstDayOfWeek")), g = Ba({
+      none: 0,
+      one: 710,
+      // width of date range picker with one panes
+      two: 1030,
+      // width of date range picker with two panes
+      three: 1290
+      // width of date range picker with three panes
+    }), P = c(() => {
+      const s = g.active().value, O = {
+        none: 0,
+        one: 1,
+        two: 2
+      };
+      if (s in O) {
+        const ie = O[s];
+        return o.numberOfMonths === void 0 ? ie : Math.min(o.numberOfMonths, ie);
+      }
+      return o.numberOfMonths;
+    }), L = c(() => o?.quickSelectRanges && o.quickSelectRanges.map((s) => {
+      const O = s.data.endDate ? void 0 : new Date(Date.now()).getTime() - s.data.startDate.getTime();
+      return {
+        ...s,
+        data: {
+          ...s.data,
+          // Adding timeDifference to calculate an up-to-date endDate on range selection
+          timeDifference: O
+        }
+      };
+    })), le = c(() => o.label ? G : p?.["aria-labelledby"] ?? null), A = C(!1), ae = C(null), w = C(!1), { isReadOnly: r } = et(Se(o, "readonly")), { emitValue: E } = tt(v);
+    he(
+      () => o.disabled,
+      () => {
+        o.disabled && w.value && (w.value = !1);
+      }
+    );
+    const se = c(() => o.modelValue || o.value), oe = c(() => o.hasActions ? !te.value && A.value : A.value), K = c(() => ({
+      "b-date-range-picker__description--error": !!o.errorMessage || oe.value
+    })), Ye = c(() => o.variant === "month"), ce = c(() => o.allowTimeInput && o.variant !== "month"), { dateDisplayValue: M, textInputDisplayValue: h } = At({
+      datePickerValue: se,
+      isDateIncorrect: A,
+      quickSelectRanges: L,
+      isMonthVariant: Ye,
+      withTimeInput: ce,
+      placeholder: Se(o, "placeholder")
+    }), be = c(
+      () => `${o.description ? Y : ""} ${o.errorMessage ? R : ""} ${A.value ? k : ""}`.trim() || null
+    ), X = () => {
+      w.value = !1;
+    }, Ae = () => {
+      w.value = !0;
+    }, me = C(M.value), De = C(
+      // textInputDisplayValue is a reactive object
+      structuredClone(Oe(h))
+    ), Q = C(o.modelValue ?? o.value), te = C(!0), Re = c(
+      () => o.hasActions ? De.value : h
+    ), J = c(
+      () => o.hasActions ? me.value : M.value
+    );
+    oa(() => {
+      if (o.hasActions || Qe(
+        'BentoDateRangePicker "hasActions" property',
+        `Set the BentoDateRangePicker "hasActions" property true which will display the "Apply" and "Cancel" buttons.
+                        This will be the default behavior in the v2 and "hasActions" will be removed.`,
+        "2.0.0"
+      ), o.value && Qe(
+        'BentoDateRangePicker "value" property',
+        'The use of "value" prop in "BentoDateRangePicker" is no longer supported. Use the "v-model" or "model-value" property instead.',
+        "2.0.0"
+      ), o.granularities && o.variant !== "month" && o.granularities.find(({ type: s }) => s === "quarterly"))
+        throw new Error('Quarterly granularity is only supported by BentoDateRangePicker with variant: "month"');
+    }), he([() => o.value, () => o.modelValue], () => {
+      me.value = M.value, De.value = structuredClone(Oe(h));
+    });
+    const ke = c(() => [
+      {
+        title: a("apply"),
+        event: () => {
+          E(Q.value), X(), te.value = !0;
+        },
+        disabled: te.value
+      },
+      {
+        title: a("cancel"),
+        event: X
+      }
+    ]);
+    he(Q, (s) => {
+      if (o.hasActions) {
+        te.value = A.value;
+        return;
+      }
+      E(s);
+    });
+    const pe = (s) => {
+      A.value = !1, h.startDate = i(s.startDate), h.endDate = i(s.endDate), h.startTime = _(s.startDate), h.endTime = _(s.endDate), Q.value = s;
+    }, I = async () => {
+      A.value && (A.value = !1), Q.value = null;
+    }, Z = () => {
+      if (!w.value) {
+        w.value = !0;
+        return;
+      }
+      A.value || (w.value = !1);
+    }, ee = (s) => {
+      A.value = !1, s.startTime && (h.startTime = s.startTime), s.endTime && (h.endTime = s.endTime);
+    }, l = (s) => {
+      A.value = !0, h.startDate = s.startDate, h.endDate = s.endDate, Q.value = { startDate: null, endDate: null };
+    }, ve = (s) => {
+      s && (h.startDate = i(s.startDate), h.endDate = i(s.endDate), h.startTime = _(s.startDate), h.endTime = _(s.endDate), Q.value = s);
+    };
+    return (s, O) => qa((S(), ye("div", Rt, [
+      s.label ? (S(), N(u(it), {
+        key: 0,
+        id: u(G),
+        label: s.label,
+        "tooltip-text": s.tooltipText,
+        optional: s.optional,
+        required: s.required
+      }, null, 8, ["id", "label", "tooltip-text", "optional", "required"])) : F("", !0),
+      z("div", {
+        onKeydown: Le(Z, ["enter"])
+      }, [
+        V(u(Ua), {
+          ref_key: "inputContainerRef",
+          ref: ae,
+          "always-combobox-is-input": "",
+          ariaControls: u(f),
+          ariaExpanded: w.value,
+          "aria-labelledby": le.value,
+          "aria-describedby": be.value,
+          "aria-required": s.required,
+          disabled: s.disabled,
+          "is-invalid": !!s.errorMessage || oe.value,
+          open: w.value,
+          "display-value": J.value,
+          readonly: u(r),
+          onOpen: Ae,
+          onClear: I,
+          onClose: X
+        }, null, 8, ["ariaControls", "ariaExpanded", "aria-labelledby", "aria-describedby", "aria-required", "disabled", "is-invalid", "open", "display-value", "readonly"])
+      ], 32),
+      oe.value ? (S(), N(u(ta), {
+        key: 1,
+        id: u(k),
+        "error-message": u(a)("provideDateInAFormat"),
+        class: "b-date-range-picker__error-message"
+      }, null, 8, ["id", "error-message"])) : F("", !0),
+      s.errorMessage ? (S(), N(u(ta), {
+        key: 2,
+        id: u(R),
+        "error-message": s.errorMessage,
+        class: "b-date-range-picker__error-message"
+      }, null, 8, ["id", "error-message"])) : F("", !0),
+      s.description ? (S(), N(u(_e), {
+        key: 3,
+        id: u(Y),
+        class: Me(["b-date-range-picker__description", K.value]),
+        el: "span"
+      }, {
+        default: $(() => [
+          ne(ge(s.description), 1)
+        ]),
+        _: 1
+      }, 8, ["id", "class"])) : F("", !0),
+      ae.value ? (S(), N(u(Na), {
+        key: 4,
+        id: u(f),
+        class: "b-date-range-picker__container",
+        open: w.value,
+        "target-element": ae.value,
+        "aria-label": re.value,
+        position: "bottom-start",
+        "without-space": "",
+        "fit-content": "",
+        "trap-all": "",
+        "overflow-visible": "",
+        onKeydown: Le(X, ["esc", "native"])
+      }, {
+        default: $(() => [
+          V(u(bt), {
+            "allow-time-input": ce.value,
+            "quick-select-ranges": L.value,
+            value: se.value,
+            "first-day-of-week": u(b),
+            granularities: s.granularities,
+            "is-date-disabled": s.isDateDisabled,
+            "max-range": s.maxRange,
+            min: s.min,
+            max: s.max,
+            "number-of-months": P.value,
+            "show-end-date-on-open": s.showEndDateOnOpen,
+            "date-form-data": Re.value,
+            variant: s.variant,
+            onCustomRange: ve,
+            onInput: pe,
+            onError: l,
+            onFormDate: ee
+          }, Ee({ _: 2 }, [
+            s.hasActions ? {
+              name: "actions",
+              fn: $(() => [
+                V(u(Ca)),
+                z("div", kt, [
+                  V(u(xa), {
+                    actions: ke.value,
+                    layout: u(ut).SPACE_BETWEEN
+                  }, null, 8, ["actions", "layout"])
+                ])
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["allow-time-input", "quick-select-ranges", "value", "first-day-of-week", "granularities", "is-date-disabled", "max-range", "min", "max", "number-of-months", "show-end-date-on-open", "date-form-data", "variant"])
+        ]),
+        _: 1
+      }, 8, ["id", "open", "target-element", "aria-label"])) : F("", !0)
+    ])), [
+      [u(at), X]
+    ]);
+  }
+}), nn = /* @__PURE__ */ ia(St, [["__scopeId", "data-v-e00826fe"]]);
+export {
+  nn as B,
+  bt as D,
+  ct as a,
+  we as i
+};
+//# sourceMappingURL=date-range-picker.BXzTT4AF.js.map