@stimulus-plumbers/controllers 0.2.0

package/dist/stimulus-plumbers-controllers.es.js

@@ -0,0 +1,1459 @@
+import { Controller as u } from "@hotwired/stimulus";
+const H = [
+  "a[href]",
+  "area[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])',
+  "audio[controls]",
+  "video[controls]",
+  '[contenteditable]:not([contenteditable="false"])'
+].join(",");
+function V(s) {
+  return Array.from(s.querySelectorAll(H)).filter((t) => v(t));
+}
+function v(s) {
+  return !!(s.offsetWidth || s.offsetHeight || s.getClientRects().length);
+}
+function $(s) {
+  const t = V(s);
+  return t.length > 0 ? (t[0].focus(), !0) : !1;
+}
+class j {
+  constructor(t, e = {}) {
+    this.container = t, this.previouslyFocused = null, this.options = e, this.isActive = !1;
+  }
+  activate() {
+    this.isActive || (this.previouslyFocused = document.activeElement, this.isActive = !0, this.options.initialFocus ? this.options.initialFocus.focus() : $(this.container), this.container.addEventListener("keydown", this.handleKeyDown));
+  }
+  deactivate() {
+    if (!this.isActive) return;
+    this.isActive = !1, this.container.removeEventListener("keydown", this.handleKeyDown);
+    const t = this.options.returnFocus || this.previouslyFocused;
+    t && v(t) && t.focus();
+  }
+  handleKeyDown = (t) => {
+    if (t.key === "Escape" && this.options.escapeDeactivates) {
+      t.preventDefault(), this.deactivate();
+      return;
+    }
+    if (t.key !== "Tab") return;
+    const e = V(this.container);
+    if (e.length === 0) return;
+    const i = e[0], n = e[e.length - 1];
+    t.shiftKey && document.activeElement === i ? (t.preventDefault(), n.focus()) : !t.shiftKey && document.activeElement === n && (t.preventDefault(), i.focus());
+  };
+}
+class ot {
+  constructor() {
+    this.savedElement = null;
+  }
+  save() {
+    this.savedElement = document.activeElement;
+  }
+  restore() {
+    this.savedElement && v(this.savedElement) && (this.savedElement.focus(), this.savedElement = null);
+  }
+}
+function lt(s, t) {
+  return s.key === t;
+}
+function ht(s) {
+  return s.key === "Enter" || s.key === " ";
+}
+function ct(s) {
+  return ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(s.key);
+}
+function dt(s) {
+  s.preventDefault(), s.stopPropagation();
+}
+class ut {
+  constructor(t, e = 0) {
+    this.items = t, this.currentIndex = e, this.updateTabIndex();
+  }
+  handleKeyDown(t) {
+    let e;
+    switch (t.key) {
+      case "ArrowDown":
+      case "ArrowRight":
+        t.preventDefault(), e = (this.currentIndex + 1) % this.items.length;
+        break;
+      case "ArrowUp":
+      case "ArrowLeft":
+        t.preventDefault(), e = this.currentIndex === 0 ? this.items.length - 1 : this.currentIndex - 1;
+        break;
+      case "Home":
+        t.preventDefault(), e = 0;
+        break;
+      case "End":
+        t.preventDefault(), e = this.items.length - 1;
+        break;
+      default:
+        return;
+    }
+    this.setCurrentIndex(e);
+  }
+  setCurrentIndex(t) {
+    t >= 0 && t < this.items.length && (this.currentIndex = t, this.updateTabIndex(), this.items[t].focus());
+  }
+  updateTabIndex() {
+    this.items.forEach((t, e) => {
+      t.tabIndex = e === this.currentIndex ? 0 : -1;
+    });
+  }
+  updateItems(t) {
+    this.items = t, this.currentIndex = Math.min(this.currentIndex, t.length - 1), this.updateTabIndex();
+  }
+}
+const N = (s, t, e) => {
+  let i = document.querySelector(`[data-live-region="${s}"]`);
+  return i || (i = document.createElement("div"), i.className = "sr-only", i.dataset.liveRegion = s, i.setAttribute("aria-live", s), i.setAttribute("aria-atomic", t.toString()), i.setAttribute("aria-relevant", e), document.body.appendChild(i)), i;
+};
+function k(s, t = {}) {
+  const { politeness: e = "polite", atomic: i = !0, relevant: n = "additions text" } = t, a = N(e, i, n);
+  a.textContent = "", setTimeout(() => {
+    a.textContent = s;
+  }, 100);
+}
+const _ = (s = "a11y") => `${s}-${Math.random().toString(36).substr(2, 9)}`, ft = (s, t = "element") => s.id || (s.id = _(t)), b = (s, t, e) => {
+  s.setAttribute(t, e.toString());
+}, mt = (s, t) => b(s, "aria-expanded", t), gt = (s, t) => b(s, "aria-pressed", t), yt = (s, t) => b(s, "aria-checked", t);
+function pt(s, t) {
+  b(s, "aria-disabled", t), t ? s.setAttribute("tabindex", "-1") : s.removeAttribute("tabindex");
+}
+const P = {
+  menu: "menu",
+  listbox: "listbox",
+  tree: "tree",
+  grid: "grid",
+  dialog: "dialog"
+}, C = (s, t, e) => {
+  Object.entries(t).forEach(([i, n]) => {
+    s.setAttribute(i, n), e[i] = n;
+  });
+}, p = (s, t, e) => e || !s.hasAttribute(t);
+function q({ trigger: s, target: t, role: e = null, override: i = !1 }) {
+  const n = { trigger: {}, target: {} };
+  if (!s || !t) return n;
+  const a = {}, r = {};
+  if (e && p(t, "role", i) && (r.role = e), t.id && (p(s, "aria-controls", i) && (a["aria-controls"] = t.id), e === "tooltip" && p(s, "aria-describedby", i) && (a["aria-describedby"] = t.id)), e && p(s, "aria-haspopup", i)) {
+    const o = P[e] || "true";
+    a["aria-haspopup"] = o;
+  }
+  return C(t, r, n.target), C(s, a, n.trigger), n;
+}
+const E = (s, t) => {
+  t.forEach((e) => {
+    s.hasAttribute(e) && s.removeAttribute(e);
+  });
+};
+function bt({ trigger: s, target: t, attributes: e = null }) {
+  if (!s || !t) return;
+  E(s, e || ["aria-controls", "aria-haspopup", "aria-describedby"]), (!e || e.includes("role")) && E(t, ["role"]);
+}
+const I = {
+  get visibleOnly() {
+    return !0;
+  },
+  hiddenClass: null
+}, R = {
+  get top() {
+    return "bottom";
+  },
+  get bottom() {
+    return "top";
+  },
+  get left() {
+    return "right";
+  },
+  get right() {
+    return "left";
+  }
+};
+function d({ x: s, y: t, width: e, height: i }) {
+  return {
+    x: s,
+    y: t,
+    width: e,
+    height: i,
+    left: s,
+    right: s + e,
+    top: t,
+    bottom: t + i
+  };
+}
+function T() {
+  return d({
+    x: 0,
+    y: 0,
+    width: window.innerWidth || document.documentElement.clientWidth,
+    height: window.innerHeight || document.documentElement.clientHeight
+  });
+}
+function B(s) {
+  if (!(s instanceof HTMLElement)) return !1;
+  const t = T(), e = s.getBoundingClientRect(), i = e.top <= t.height && e.top + e.height > 0, n = e.left <= t.width && e.left + e.width > 0;
+  return i && n;
+}
+function g(s) {
+  return s instanceof Date && !isNaN(s);
+}
+function m(...s) {
+  if (s.length === 0) throw "Missing values to parse as date";
+  if (s.length === 1) {
+    const t = new Date(s[0]);
+    if (s[0] && g(t)) return t;
+  } else {
+    const t = new Date(...s);
+    if (g(t)) return t;
+  }
+}
+const z = {
+  element: null,
+  visible: null,
+  dispatch: !0,
+  prefix: ""
+};
+class y {
+  /**
+   * Creates a new Plumber instance.
+   * @param {Object} controller - Stimulus controller instance
+   * @param {Object} options - Configuration options
+   * @param {HTMLElement} [options.element] - Target element (defaults to controller.element)
+   * @param {boolean|string} [options.visible=true] - Visibility check configuration
+   * @param {boolean} [options.dispatch=true] - Enable event dispatching
+   * @param {string} [options.prefix] - Event prefix (defaults to controller.identifier)
+   */
+  constructor(t, e = {}) {
+    this.controller = t;
+    const i = Object.assign({}, z, e), { element: n, visible: a, dispatch: r, prefix: o } = i;
+    this.element = n || t.element, this.visibleOnly = typeof a == "boolean" ? a : I.visibleOnly, this.visibleCallback = typeof a == "string" ? a : null, this.notify = !!r, this.prefix = typeof o == "string" && o ? o : t.identifier;
+  }
+  /**
+   * Checks if the element is visible in viewport.
+   * @returns {boolean} True if element is visible
+   */
+  get visible() {
+    return this.element instanceof HTMLElement ? this.visibleOnly ? B(this.element) && this.isVisible(this.element) : !0 : !1;
+  }
+  /**
+   * Determines if a target element is visible.
+   * @param {HTMLElement} target - Element to check
+   * @returns {boolean} True if element is visible
+   */
+  isVisible(t) {
+    if (this.visibleCallback) {
+      const e = this.findCallback(this.visibleCallback);
+      if (typeof e == "function") return e(t);
+    }
+    return t instanceof HTMLElement ? !t.hasAttribute("hidden") : !1;
+  }
+  /**
+   * Dispatches a custom event from the controller.
+   * @param {string} name - Event name
+   * @param {Object} [options] - Event options
+   * @param {HTMLElement} [options.target] - Event target element
+   * @param {string} [options.prefix] - Event prefix
+   * @param {*} [options.detail] - Event detail data
+   * @returns {boolean|undefined} Dispatch result
+   */
+  dispatch(t, { target: e = null, prefix: i = null, detail: n = null } = {}) {
+    if (this.notify)
+      return this.controller.dispatch(t, {
+        target: e || this.element,
+        prefix: i || this.prefix,
+        detail: n
+      });
+  }
+  /**
+   * Finds and binds a callback function by name from controller or plumber.
+   * @param {string} name - Callback name or dot-notation path
+   * @returns {Function|undefined} Bound callback function
+   */
+  findCallback(t) {
+    if (typeof t != "string") return;
+    const e = this, i = t.split(".").reduce((a, r) => a && a[r], e.controller);
+    if (typeof i == "function")
+      return i.bind(e.controller);
+    const n = t.split(".").reduce((a, r) => a && a[r], e);
+    if (typeof n == "function")
+      return n.bind(e);
+  }
+  /**
+   * Executes a callback function and awaits if it returns a Promise.
+   * @param {string|Function} callback - Callback name or function
+   * @param {...*} args - Arguments to pass to callback
+   * @returns {Promise<*>} Result of callback execution
+   */
+  async awaitCallback(t, ...e) {
+    if (typeof t == "string" && (t = this.findCallback(t)), typeof t == "function") {
+      const i = t(...e);
+      return i instanceof Promise ? await i : i;
+    }
+  }
+}
+const L = 7, A = {
+  locales: ["default"],
+  today: "",
+  day: null,
+  month: null,
+  year: null,
+  since: null,
+  till: null,
+  disabledDates: [],
+  disabledWeekdays: [],
+  disabledDays: [],
+  disabledMonths: [],
+  disabledYears: [],
+  firstDayOfWeek: 0,
+  onNavigated: "navigated"
+};
+class K extends y {
+  /**
+   * Creates a new Calendar plumber instance with date navigation and validation.
+   * @param {Object} controller - Stimulus controller instance
+   * @param {Object} [options] - Configuration options
+   * @param {string[]} [options.locales=['default']] - Locale identifiers for date formatting
+   * @param {string|Date} [options.today=''] - Initial "today" date
+   * @param {number} [options.day] - Initial day
+   * @param {number} [options.month] - Initial month (0-11)
+   * @param {number} [options.year] - Initial year
+   * @param {string|Date} [options.since] - Minimum selectable date
+   * @param {string|Date} [options.till] - Maximum selectable date
+   * @param {Array<string|Date>} [options.disabledDates=[]] - Array of disabled dates
+   * @param {string[]|number[]} [options.disabledWeekdays=[]] - Array of disabled weekdays
+   * @param {string[]|number[]} [options.disabledDays=[]] - Array of disabled day numbers
+   * @param {string[]|number[]} [options.disabledMonths=[]] - Array of disabled months
+   * @param {string[]|number[]} [options.disabledYears=[]] - Array of disabled years
+   * @param {number} [options.firstDayOfWeek=0] - First day of week (0=Sunday, 1=Monday, etc.)
+   * @param {string} [options.onNavigated='navigated'] - Callback name when navigated
+   */
+  constructor(t, e = {}) {
+    super(t, e);
+    const i = Object.assign({}, A, e), { onNavigated: n, since: a, till: r, firstDayOfWeek: o } = i;
+    this.onNavigated = n, this.since = m(a), this.till = m(r), this.firstDayOfWeek = 0 <= o && o < 7 ? o : A.firstDayOfWeek;
+    const { disabledDates: l, disabledWeekdays: c, disabledDays: h, disabledMonths: f, disabledYears: D } = i;
+    this.disabledDates = Array.isArray(l) ? l : [], this.disabledWeekdays = Array.isArray(c) ? c : [], this.disabledDays = Array.isArray(h) ? h : [], this.disabledMonths = Array.isArray(f) ? f : [], this.disabledYears = Array.isArray(D) ? D : [];
+    const { today: Y, day: x, month: O, year: M } = i;
+    this.now = m(Y) || /* @__PURE__ */ new Date(), typeof M == "number" && typeof O == "number" && typeof x == "number" ? this.current = m(M, O, x) : this.current = this.now, this.build(), this.enhance();
+  }
+  /**
+   * Builds all calendar data structures (days of week, days of month, months of year).
+   */
+  build() {
+    this.daysOfWeek = this.buildDaysOfWeek(), this.daysOfMonth = this.buildDaysOfMonth(), this.monthsOfYear = this.buildMonthsOfYear();
+  }
+  /**
+   * Builds array of weekday objects with localized names.
+   * @returns {Array<Object>} Array of weekday objects
+   */
+  buildDaysOfWeek() {
+    const t = new Intl.DateTimeFormat(this.localesValue, { weekday: "long" }), e = new Intl.DateTimeFormat(this.localesValue, { weekday: "short" }), i = /* @__PURE__ */ new Date("2024-10-06"), n = [];
+    for (let a = this.firstDayOfWeek, r = a + 7; a < r; a++) {
+      const o = new Date(i);
+      o.setDate(i.getDate() + a), n.push({
+        date: o,
+        value: o.getDay(),
+        long: t.format(o),
+        short: e.format(o)
+      });
+    }
+    return n;
+  }
+  /**
+   * Builds array of day objects for the current month view, including overflow from adjacent months.
+   * @returns {Array<Object>} Array of day objects with metadata
+   */
+  buildDaysOfMonth() {
+    const t = this.month, e = this.year, i = [], n = (h) => ({
+      current: this.month === h.getMonth() && this.year === h.getFullYear(),
+      date: h,
+      value: h.getDate(),
+      month: h.getMonth(),
+      year: h.getFullYear(),
+      iso: h.toISOString()
+    }), a = new Date(e, t).getDay(), r = this.firstDayOfWeek - a;
+    for (let h = r > 0 ? r - 7 : r; h < 0; h++) {
+      const f = new Date(e, t, h + 1);
+      i.push(n(f));
+    }
+    const o = new Date(e, t + 1, 0).getDate();
+    for (let h = 1; h <= o; h++) {
+      const f = new Date(e, t, h);
+      i.push(n(f));
+    }
+    const l = i.length % L, c = l === 0 ? 0 : L - l;
+    for (let h = 1; h <= c; h++) {
+      const f = new Date(e, t + 1, h);
+      i.push(n(f));
+    }
+    return i;
+  }
+  /**
+   * Builds array of month objects with localized names for the current year.
+   * @returns {Array<Object>} Array of month objects
+   */
+  buildMonthsOfYear() {
+    const t = new Intl.DateTimeFormat(this.localesValue, { month: "long" }), e = new Intl.DateTimeFormat(this.localesValue, { month: "short" }), i = new Intl.DateTimeFormat(this.localesValue, { month: "numeric" }), n = [];
+    for (let a = 0; a < 12; a++) {
+      const r = new Date(this.year, a);
+      n.push({
+        date: r,
+        value: r.getMonth(),
+        long: t.format(r),
+        short: e.format(r),
+        numeric: i.format(r)
+      });
+    }
+    return n;
+  }
+  /**
+   * Gets the current "today" reference date.
+   * @returns {Date} Today's date
+   */
+  get today() {
+    return this.now;
+  }
+  /**
+   * Sets the "today" reference date.
+   * @param {Date} value - New today date
+   */
+  set today(t) {
+    if (!g(t)) return;
+    const e = this.month ? this.month : t.getMonth(), i = this.year ? this.year : t.getFullYear(), n = e == t.getMonth() && i == t.getFullYear(), a = this.hasDayValue ? this.day : n ? t.getDate() : 1;
+    this.now = new Date(i, e, a).toISOString();
+  }
+  /**
+   * Gets the current selected date.
+   * @returns {Date|null} Current date or null if not fully specified
+   */
+  get current() {
+    return typeof this.year == "number" && typeof this.month == "number" && typeof this.day == "number" ? m(this.year, this.month, this.day) : null;
+  }
+  /**
+   * Sets the current selected date.
+   * @param {Date} value - New current date
+   */
+  set current(t) {
+    g(t) && (this.day = t.getDate(), this.month = t.getMonth(), this.year = t.getFullYear());
+  }
+  /**
+   * Navigates to a specific date, dispatching events and rebuilding calendar.
+   * @param {Date} to - Target date to navigate to
+   * @returns {Promise<void>}
+   */
+  navigate = async (t) => {
+    if (!g(t)) return;
+    const e = this.current, i = t.toISOString(), n = e.toISOString();
+    this.dispatch("navigate", { detail: { from: n, to: i } }), this.current = t, this.build(), await this.awaitCallback(this.onNavigated, { from: n, to: i }), this.dispatch("navigated", { detail: { from: n, to: i } });
+  };
+  /**
+   * Steps the calendar by a given amount in a specific unit (year, month, or day).
+   * @param {string} type - Type of step ('year', 'month', 'day')
+   * @param {number} value - Number of units to step (positive or negative)
+   * @returns {Promise<void>}
+   */
+  step = async (t, e) => {
+    if (e === 0) return;
+    const i = this.current;
+    switch (t) {
+      case "year": {
+        i.setFullYear(i.getFullYear() + e);
+        break;
+      }
+      case "month": {
+        i.setMonth(i.getMonth() + e);
+        break;
+      }
+      case "day": {
+        i.setDate(i.getDate() + e);
+        break;
+      }
+      default:
+        return;
+    }
+    await this.navigate(i);
+  };
+  /**
+   * Checks if a date is disabled based on configured rules.
+   * @param {Date} date - Date to check
+   * @returns {boolean} True if date is disabled
+   */
+  isDisabled = (t) => {
+    if (!g(t)) return !1;
+    if (this.disabledDates.length) {
+      const e = t.getTime();
+      for (const i of this.disabledDates)
+        if (e === new Date(i).getTime()) return !0;
+    }
+    if (this.disabledWeekdays.length) {
+      const e = t.getDay(), i = this.daysOfWeek, n = i.findIndex((a) => a.value === e);
+      if (n >= 0) {
+        const a = i[n];
+        for (const r of this.disabledWeekdays)
+          if (a.value == r || a.short === r || a.long === r) return !0;
+      }
+    }
+    if (this.disabledDays.length) {
+      const e = t.getDate();
+      for (const i of this.disabledDays)
+        if (e == i) return !0;
+    }
+    if (this.disabledMonths.length) {
+      const e = t.getMonth(), i = this.monthsOfYear, n = i.findIndex((a) => a.value === e);
+      if (n >= 0) {
+        const a = i[n];
+        for (const r of this.disabledMonths)
+          if (a.value == r || a.short === r || a.long === r) return !0;
+      }
+    }
+    if (this.disabledYears.length) {
+      const e = t.getFullYear();
+      for (const i of this.disabledYears)
+        if (e == i) return !0;
+    }
+    return !1;
+  };
+  /**
+   * Checks if a date is within the allowed range (since/till).
+   * @param {Date} date - Date to check
+   * @returns {boolean} True if date is within range
+   */
+  isWithinRange = (t) => {
+    if (!g(t)) return !1;
+    let e = !0;
+    return this.since && (e = e && t >= this.since), this.till && (e = e && t <= this.till), e;
+  };
+  enhance() {
+    const t = this;
+    Object.assign(this.controller, {
+      get calendar() {
+        return {
+          get today() {
+            return t.today;
+          },
+          get current() {
+            return t.current;
+          },
+          get day() {
+            return t.day;
+          },
+          get month() {
+            return t.month;
+          },
+          get year() {
+            return t.year;
+          },
+          get since() {
+            return t.since;
+          },
+          get till() {
+            return t.till;
+          },
+          get firstDayOfWeek() {
+            return t.firstDayOfWeek;
+          },
+          get disabledDates() {
+            return t.disabledDates;
+          },
+          get disabledWeekdays() {
+            return t.disabledWeekdays;
+          },
+          get disabledDays() {
+            return t.disabledDays;
+          },
+          get disabledMonths() {
+            return t.disabledMonths;
+          },
+          get disabledYears() {
+            return t.disabledYears;
+          },
+          get daysOfWeek() {
+            return t.daysOfWeek;
+          },
+          get daysOfMonth() {
+            return t.daysOfMonth;
+          },
+          get monthsOfYear() {
+            return t.monthsOfYear;
+          },
+          navigate: async (e) => await t.navigate(e),
+          step: async (e, i) => await t.step(e, i),
+          isDisabled: (e) => t.isDisabled(e),
+          isWithinRange: (e) => t.isWithinRange(e)
+        };
+      }
+    });
+  }
+}
+const U = (s, t) => new K(s, t), w = {
+  content: null,
+  url: "",
+  reload: "never",
+  stale: 3600,
+  onLoad: "contentLoad",
+  onLoading: "contentLoading",
+  onLoaded: "contentLoaded"
+};
+class X extends y {
+  /**
+   * Creates a new ContentLoader plumber instance for async content loading.
+   * @param {Object} controller - Stimulus controller instance
+   * @param {Object} [options] - Configuration options
+   * @param {*} [options.content] - Initial content value
+   * @param {string} [options.url=''] - URL to fetch content from
+   * @param {string} [options.reload='never'] - Reload strategy ('never', 'always', or 'stale')
+   * @param {number} [options.stale=3600] - Seconds before content becomes stale
+   * @param {string} [options.onLoad='contentLoad'] - Callback name to check if loadable
+   * @param {string} [options.onLoading='contentLoading'] - Callback name to load content
+   * @param {string} [options.onLoaded='contentLoaded'] - Callback name after loading
+   */
+  constructor(t, e = {}) {
+    super(t, e);
+    const i = Object.assign({}, w, e), { content: n, url: a, reload: r, stale: o } = i;
+    this.content = n, this.url = a, this.reload = typeof r == "string" ? r : w.reload, this.stale = typeof o == "number" ? o : w.stale;
+    const { onLoad: l, onLoading: c, onLoaded: h } = i;
+    this.onLoad = l, this.onLoading = c, this.onLoaded = h, this.enhance();
+  }
+  /**
+   * Checks if content should be reloaded based on reload strategy.
+   * @returns {boolean} True if content should be reloaded
+   */
+  get reloadable() {
+    switch (this.reload) {
+      case "never":
+        return !1;
+      case "always":
+        return !0;
+      default: {
+        const t = m(this.loadedAt);
+        return t && /* @__PURE__ */ new Date() - t > this.stale * 1e3;
+      }
+    }
+  }
+  /**
+   * Checks if content should be loaded based on URL presence.
+   * Override this method to provide custom loading conditions.
+   * @param {Object} params - Load parameters
+   * @param {string} params.url - URL to load from
+   * @returns {Promise<boolean>} True if content should be loaded
+   */
+  contentLoadable = ({ url: t }) => !!t;
+  /**
+   * Loads content from remote or local source.
+   * Override this method to provide custom loading logic.
+   * @param {Object} params - Load parameters
+   * @param {string} params.url - URL to load from
+   * @returns {Promise<string>} Loaded content
+   */
+  contentLoading = async ({ url: t }) => t ? await this.remoteContentLoader(t) : await this.contentLoader();
+  /**
+   * Provides local/static content when no URL is available.
+   * Override this method to provide static content.
+   * @returns {Promise<string>} Local content
+   */
+  contentLoader = async () => "";
+  /**
+   * Fetches content from a remote URL.
+   * Override this method to customize remote loading.
+   * @param {string} url - URL to fetch from
+   * @returns {Promise<string>} Fetched content
+   */
+  remoteContentLoader = async (t) => (await fetch(t)).text();
+  /**
+   * Loads content from remote or local source with lifecycle events.
+   * Checks if loadable via onLoad, fetches content via onLoading,
+   * and notifies via onLoaded callback.
+   * @returns {Promise<void>}
+   */
+  load = async () => {
+    if (this.loadedAt && !this.reloadable) return;
+    const t = this.findCallback(this.onLoad), e = await this.awaitCallback(t || this.contentLoadable, { url: this.url });
+    if (this.dispatch("load", { detail: { url: this.url } }), !e) return;
+    const i = this.url ? await this.remoteContentLoader(this.url) : await this.contentLoader();
+    this.dispatch("loading", { detail: { url: this.url } }), i && (await this.awaitCallback(this.onLoaded, { url: this.url, content: i }), this.loadedAt = (/* @__PURE__ */ new Date()).getTime(), this.dispatch("loaded", { detail: { url: this.url, content: i } }));
+  };
+  enhance() {
+    const t = this;
+    Object.assign(this.controller, {
+      load: t.load.bind(t)
+    });
+  }
+}
+const G = (s, t) => new X(s, t), J = {
+  trigger: null,
+  events: ["click"],
+  onDismissed: "dismissed"
+};
+class Q extends y {
+  /**
+   * Creates a new Dismisser plumber instance for handling outside-click dismissals.
+   * @param {Object} controller - Stimulus controller instance
+   * @param {Object} [options] - Configuration options
+   * @param {HTMLElement} [options.trigger] - Trigger element (defaults to controller element)
+   * @param {string[]} [options.events=['click']] - Events to listen for dismissal
+   * @param {string} [options.onDismissed='dismissed'] - Callback name when dismissed
+   */
+  constructor(t, e = {}) {
+    super(t, e);
+    const { trigger: i, events: n, onDismissed: a } = Object.assign({}, J, e);
+    this.onDismissed = a, this.trigger = i || this.element, this.events = n, this.enhance(), this.observe();
+  }
+  /**
+   * Handles dismissal when clicking outside the element.
+   * @param {Event} event - DOM event
+   * @returns {Promise<void>}
+   */
+  dismiss = async (t) => {
+    const { target: e } = t;
+    e instanceof HTMLElement && (this.element.contains(e) || this.visible && (this.dispatch("dismiss"), await this.awaitCallback(this.onDismissed, { target: this.trigger }), this.dispatch("dismissed")));
+  };
+  /**
+   * Starts observing configured events for dismissal.
+   */
+  observe() {
+    this.events.forEach((t) => {
+      window.addEventListener(t, this.dismiss, !0);
+    });
+  }
+  /**
+   * Stops observing events for dismissal.
+   */
+  unobserve() {
+    this.events.forEach((t) => {
+      window.removeEventListener(t, this.dismiss, !0);
+    });
+  }
+  enhance() {
+    const t = this, e = t.controller.disconnect.bind(t.controller);
+    Object.assign(this.controller, {
+      disconnect: () => {
+        t.unobserve(), e();
+      }
+    });
+  }
+}
+const W = (s, t) => new Q(s, t), Z = {
+  anchor: null,
+  events: ["click"],
+  placement: "bottom",
+  alignment: "start",
+  onFlipped: "flipped",
+  ariaRole: null,
+  respectMotion: !0
+};
+class tt extends y {
+  /**
+   * Creates a new Flipper plumber instance for smart positioning relative to an anchor.
+   * @param {Object} controller - Stimulus controller instance
+   * @param {Object} [options] - Configuration options
+   * @param {HTMLElement} [options.anchor] - Anchor element for positioning
+   * @param {string[]} [options.events=['click']] - Events triggering flip calculation
+   * @param {string} [options.placement='bottom'] - Initial placement direction ('top', 'bottom', 'left', 'right')
+   * @param {string} [options.alignment='start'] - Alignment ('start', 'center', 'end')
+   * @param {string} [options.onFlipped='flipped'] - Callback name when flipped
+   * @param {string} [options.ariaRole=null] - ARIA role to set on element
+   * @param {boolean} [options.respectMotion=true] - Respect prefers-reduced-motion preference
+   */
+  constructor(t, e = {}) {
+    super(t, e);
+    const { anchor: i, events: n, placement: a, alignment: r, onFlipped: o, ariaRole: l, respectMotion: c } = Object.assign(
+      {},
+      Z,
+      e
+    );
+    this.anchor = i, this.events = n, this.placement = a, this.alignment = r, this.onFlipped = o, this.ariaRole = l, this.respectMotion = c, this.prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches, this.anchor && this.element && q({
+      trigger: this.anchor,
+      target: this.element,
+      role: this.ariaRole
+    }), this.enhance(), this.observe();
+  }
+  /**
+   * Attempts to place element in configured direction, flipping to opposite direction if needed.
+   * For example, if placement is 'bottom' but no space below anchor, flips to 'top'.
+   * @returns {Promise<void>}
+   */
+  flip = async () => {
+    if (!this.visible) return;
+    this.dispatch("flip"), window.getComputedStyle(this.element).position != "absolute" && (this.element.style.position = "absolute");
+    const e = this.flippedRect(this.anchor.getBoundingClientRect(), this.element.getBoundingClientRect());
+    this.element.style.transition = this.respectMotion && this.prefersReducedMotion ? "none" : "";
+    for (const [i, n] of Object.entries(e))
+      this.element.style[i] = n;
+    await this.awaitCallback(this.onFlipped, { target: this.element, placement: e }), this.dispatch("flipped", { detail: { placement: e } });
+  };
+  /**
+   * Determines the best position that fits within viewport boundaries.
+   * @param {DOMRect} anchorRect - Anchor element's bounding rect
+   * @param {DOMRect} referenceRect - Reference element's bounding rect
+   * @returns {Object} Position object with top and left styles
+   */
+  flippedRect(t, e) {
+    const i = this.quadrumRect(t, T()), n = [this.placement, R[this.placement]];
+    let a = {};
+    for (; !Object.keys(a).length && n.length > 0; ) {
+      const r = n.shift();
+      if (!this.biggerRectThan(i[r], e)) continue;
+      const o = this.quadrumPlacement(t, r, e), l = this.quadrumAlignment(t, r, o);
+      a.top = `${l.top + window.scrollY}px`, a.left = `${l.left + window.scrollX}px`;
+    }
+    return Object.keys(a).length || (a.top = "", a.left = ""), a;
+  }
+  /**
+   * Calculates available space in each direction around the inner rect within outer rect.
+   * @param {Object} inner - Inner rect object
+   * @param {Object} outer - Outer rect object
+   * @returns {Object} Rect objects for each direction (left, right, top, bottom)
+   */
+  quadrumRect(t, e) {
+    return {
+      left: d({
+        x: e.x,
+        y: e.y,
+        width: t.x - e.x,
+        height: e.height
+      }),
+      right: d({
+        x: t.x + t.width,
+        y: e.y,
+        width: e.width - (t.x + t.width),
+        height: e.height
+      }),
+      top: d({
+        x: e.x,
+        y: e.y,
+        width: e.width,
+        height: t.y - e.y
+      }),
+      bottom: d({
+        x: e.x,
+        y: t.y + t.height,
+        width: e.width,
+        height: e.height - (t.y + t.height)
+      })
+    };
+  }
+  /**
+   * Calculates placement rect for reference element in given direction from anchor.
+   * @param {Object} anchor - Anchor rect object
+   * @param {string} direction - Direction ('top', 'bottom', 'left', 'right')
+   * @param {Object} reference - Reference rect object
+   * @returns {Object} Placed rect object
+   * @throws {string} If direction is invalid
+   */
+  quadrumPlacement(t, e, i) {
+    switch (e) {
+      case "top":
+        return d({
+          x: i.x,
+          y: t.y - i.height,
+          width: i.width,
+          height: i.height
+        });
+      case "bottom":
+        return d({
+          x: i.x,
+          y: t.y + t.height,
+          width: i.width,
+          height: i.height
+        });
+      case "left":
+        return d({
+          x: t.x - i.width,
+          y: i.y,
+          width: i.width,
+          height: i.height
+        });
+      case "right":
+        return d({
+          x: t.x + t.width,
+          y: i.y,
+          width: i.width,
+          height: i.height
+        });
+      default:
+        throw `Unable place at the quadrum, ${e}`;
+    }
+  }
+  /**
+   * Applies alignment adjustment to placed rect based on configuration.
+   * @param {Object} anchor - Anchor rect object
+   * @param {string} direction - Direction ('top', 'bottom', 'left', 'right')
+   * @param {Object} reference - Reference rect object
+   * @returns {Object} Aligned rect object
+   * @throws {string} If direction is invalid
+   */
+  quadrumAlignment(t, e, i) {
+    switch (e) {
+      case "top":
+      case "bottom": {
+        let n = t.x;
+        return this.alignment === "center" ? n = t.x + t.width / 2 - i.width / 2 : this.alignment === "end" && (n = t.x + t.width - i.width), d({
+          x: n,
+          y: i.y,
+          width: i.width,
+          height: i.height
+        });
+      }
+      case "left":
+      case "right": {
+        let n = t.y;
+        return this.alignment === "center" ? n = t.y + t.height / 2 - i.height / 2 : this.alignment === "end" && (n = t.y + t.height - i.height), d({
+          x: i.x,
+          y: n,
+          width: i.width,
+          height: i.height
+        });
+      }
+      default:
+        throw `Unable align at the quadrum, ${e}`;
+    }
+  }
+  /**
+   * Checks if the big rect can contain the small rect dimensions.
+   * @param {Object} big - Larger rect object
+   * @param {Object} small - Smaller rect object
+   * @returns {boolean} True if big rect can contain small rect
+   */
+  biggerRectThan(t, e) {
+    return t.height >= e.height && t.width >= e.width;
+  }
+  /**
+   * Starts observing configured events for flipping.
+   */
+  observe() {
+    this.events.forEach((t) => {
+      window.addEventListener(t, this.flip, !0);
+    });
+  }
+  /**
+   * Stops observing events for flipping.
+   */
+  unobserve() {
+    this.events.forEach((t) => {
+      window.removeEventListener(t, this.flip, !0);
+    });
+  }
+  enhance() {
+    const t = this, e = t.controller.disconnect.bind(t.controller);
+    Object.assign(this.controller, {
+      disconnect: () => {
+        t.unobserve(), e();
+      },
+      flip: t.flip.bind(t)
+    });
+  }
+}
+const et = (s, t) => new tt(s, t), it = {
+  events: ["resize"],
+  boundaries: ["top", "left", "right"],
+  onShifted: "shifted",
+  respectMotion: !0
+};
+class st extends y {
+  /**
+   * Creates a new Shifter plumber instance for viewport boundary shifting.
+   * @param {Object} controller - Stimulus controller instance
+   * @param {Object} [options] - Configuration options
+   * @param {string[]} [options.events=['resize']] - Events triggering shift calculation
+   * @param {string[]} [options.boundaries=['top','left','right']] - Boundaries to check (valid values: 'top', 'bottom', 'left', 'right')
+   * @param {string} [options.onShifted='shifted'] - Callback name when shifted
+   * @param {boolean} [options.respectMotion=true] - Respect prefers-reduced-motion preference
+   */
+  constructor(t, e = {}) {
+    super(t, e);
+    const { onShifted: i, events: n, boundaries: a, respectMotion: r } = Object.assign({}, it, e);
+    this.onShifted = i, this.events = n, this.boundaries = a, this.respectMotion = r, this.prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches, this.enhance(), this.observe();
+  }
+  /**
+   * Calculates and applies transform to shift element within viewport boundaries.
+   * @returns {Promise<void>}
+   */
+  shift = async () => {
+    if (!this.visible) return;
+    this.dispatch("shift");
+    const t = this.overflowRect(this.element.getBoundingClientRect(), this.elementTranslations(this.element)), e = t.left || t.right || 0, i = t.top || t.bottom || 0;
+    this.element.style.transition = this.respectMotion && this.prefersReducedMotion ? "none" : "", this.element.style.transform = `translate(${e}px, ${i}px)`, await this.awaitCallback(this.onShifted, t), this.dispatch("shifted", { detail: t });
+  };
+  /**
+   * Calculates overflow distances for each boundary direction.
+   * @param {DOMRect} targetRect - Target element's bounding rect
+   * @param {Object} translations - Current transform translations
+   * @returns {Object} Overflow distances by direction
+   */
+  overflowRect(t, e) {
+    const i = {}, n = T(), a = d({
+      x: t.x - e.x,
+      y: t.y - e.y,
+      width: t.width,
+      height: t.height
+    });
+    for (const r of this.boundaries) {
+      const o = this.directionDistance(a, r, n), l = R[r];
+      o < 0 ? a[l] + o >= n[l] && !i[l] && (i[r] = o) : i[r] = "";
+    }
+    return i;
+  }
+  /**
+   * Calculates distance from inner rect to outer boundary in given direction.
+   * @param {Object} inner - Inner rect object
+   * @param {string} direction - Direction ('top', 'bottom', 'left', 'right')
+   * @param {Object} outer - Outer rect object
+   * @returns {number} Distance to boundary (negative if overflowing)
+   * @throws {string} If direction is invalid
+   */
+  directionDistance(t, e, i) {
+    switch (e) {
+      case "top":
+      case "left":
+        return t[e] - i[e];
+      case "bottom":
+      case "right":
+        return i[e] - t[e];
+      default:
+        throw `Invalid direction to calcuate distance, ${e}`;
+    }
+  }
+  /**
+   * Extracts current translate values from element's transform style.
+   * @param {HTMLElement} target - Target element
+   * @returns {Object} Translation object with x and y values
+   */
+  elementTranslations(t) {
+    const e = window.getComputedStyle(t), i = e.transform || e.webkitTransform || e.mozTransform;
+    if (i === "none" || typeof i > "u")
+      return { x: 0, y: 0 };
+    const n = i.includes("3d") ? "3d" : "2d", a = i.match(/matrix.*\((.+)\)/)[1].split(", ");
+    return n === "2d" ? { x: Number(a[4]), y: Number(a[5]) } : { x: 0, y: 0 };
+  }
+  /**
+   * Starts observing configured events for shifting.
+   */
+  observe() {
+    this.events.forEach((t) => {
+      window.addEventListener(t, this.shift, !0);
+    });
+  }
+  /**
+   * Stops observing events for shifting.
+   */
+  unobserve() {
+    this.events.forEach((t) => {
+      window.removeEventListener(t, this.shift, !0);
+    });
+  }
+  enhance() {
+    const t = this, e = t.controller.disconnect.bind(t.controller);
+    Object.assign(this.controller, {
+      disconnect: () => {
+        t.unobserve(), e();
+      },
+      shift: t.shift.bind(t)
+    });
+  }
+}
+const nt = (s, t) => new st(s, t), F = {
+  visibility: "visibility",
+  onShown: "shown",
+  onHidden: "hidden"
+};
+class at extends y {
+  /**
+   * Creates a new Visibility plumber instance.
+   * @param {Object} controller - Stimulus controller instance
+   * @param {Object} [options] - Configuration options
+   * @param {string} [options.visibility='visibility'] - Namespace for visibility helpers
+   * @param {string} [options.onShown='shown'] - Method name on plumber instance called after showing
+   * @param {string} [options.onHidden='hidden'] - Method name on plumber instance called after hiding
+   */
+  constructor(t, e = {}) {
+    const { visibility: i, onShown: n, onHidden: a, activator: r } = Object.assign({}, F, e), o = typeof i == "string" ? i : F.namespace, l = typeof e.visible == "string" ? e.visible : "isVisible";
+    (typeof e.visible != "boolean" || e.visible) && (e.visible = `${o}.${l}`), super(t, e), this.visibility = o, this.visibilityResolver = l, this.onShown = n, this.onHidden = a, this.activator = r instanceof HTMLElement ? r : null, this.enhance(), this.element instanceof HTMLElement && this.activate(this.isVisible(this.element));
+  }
+  /**
+   * Checks if a target element is visible.
+   * @param {HTMLElement} target - Element to check
+   * @returns {boolean} True if element is visible
+   */
+  isVisible(t) {
+    if (!(t instanceof HTMLElement)) return !1;
+    const e = I.hiddenClass;
+    return e ? !t.classList.contains(e) : !t.hasAttribute("hidden");
+  }
+  /**
+   * Toggles element visibility using class or hidden attribute.
+   * @param {HTMLElement} target - Element to toggle
+   * @param {boolean} visible - True to show, false to hide
+   */
+  toggle(t, e) {
+    t instanceof HTMLElement && (e ? t.removeAttribute("hidden") : t.setAttribute("hidden", !0));
+  }
+  /**
+   * Sets aria-expanded on the activator element.
+   * @param {boolean} isExpanded - True to mark as expanded, false to mark as collapsed
+   */
+  activate(t) {
+    this.activator && this.activator.setAttribute("aria-expanded", t ? "true" : "false");
+  }
+  /**
+   * Shows the element and dispatches show events.
+   * @returns {Promise<void>}
+   */
+  async show() {
+    !(this.element instanceof HTMLElement) || this.isVisible(this.element) || (this.dispatch("show"), this.toggle(this.element, !0), this.activate(!0), await this.awaitCallback(this.onShown, { target: this.element }), this.dispatch("shown"));
+  }
+  /**
+   * Hides the element and dispatches hide events.
+   * @returns {Promise<void>}
+   */
+  async hide() {
+    !(this.element instanceof HTMLElement) || !this.isVisible(this.element) || (this.dispatch("hide"), this.toggle(this.element, !1), this.activate(!1), await this.awaitCallback(this.onHidden, { target: this.element }), this.dispatch("hidden"));
+  }
+  enhance() {
+    const t = this, e = {
+      show: t.show.bind(t),
+      hide: t.hide.bind(t)
+    };
+    Object.defineProperty(e, "visible", {
+      get() {
+        return t.isVisible(t.element);
+      }
+    }), Object.defineProperty(e, this.visibilityResolver, {
+      value: t.isVisible.bind(t)
+    }), Object.defineProperty(this.controller, this.visibility, {
+      get() {
+        return e;
+      }
+    });
+  }
+}
+const S = (s, t) => new at(s, t);
+class wt extends u {
+  static targets = ["modal", "overlay"];
+  connect() {
+    if (!this.hasModalTarget) {
+      console.error('ModalController requires a modal target. Add data-modal-target="modal" to your element.');
+      return;
+    }
+    this.isNativeDialog = this.modalTarget instanceof HTMLDialogElement, this.isNativeDialog ? (this.modalTarget.addEventListener("cancel", this.close), this.modalTarget.addEventListener("click", this.handleBackdropClick)) : (this.focusTrap = new j(this.modalTarget, {
+      escapeDeactivates: !0
+    }), W(this, { element: this.modalTarget }));
+  }
+  dismissed = () => {
+    this.close();
+  };
+  disconnect() {
+    this.isNativeDialog && (this.modalTarget.removeEventListener("cancel", this.close), this.modalTarget.removeEventListener("click", this.handleBackdropClick));
+  }
+  open(t) {
+    if (t && t.preventDefault(), !!this.hasModalTarget) {
+      if (this.isNativeDialog)
+        this.previouslyFocused = document.activeElement, this.modalTarget.showModal();
+      else {
+        const e = this.hasOverlayTarget ? this.overlayTarget : this.modalTarget;
+        e.hidden = !1, document.body.style.overflow = "hidden", this.focusTrap && this.focusTrap.activate();
+      }
+      k("Modal opened");
+    }
+  }
+  close(t) {
+    if (t && t.preventDefault(), !!this.hasModalTarget) {
+      if (this.isNativeDialog)
+        this.modalTarget.close(), this.previouslyFocused && this.previouslyFocused.isConnected && setTimeout(() => {
+          this.previouslyFocused.focus();
+        }, 0);
+      else {
+        const e = this.hasOverlayTarget ? this.overlayTarget : this.modalTarget;
+        e.hidden = !0, document.body.style.overflow = "", this.focusTrap && this.focusTrap.deactivate();
+      }
+      k("Modal closed");
+    }
+  }
+  handleBackdropClick = (t) => {
+    const e = this.modalTarget.getBoundingClientRect();
+    (t.clientY < e.top || t.clientY > e.bottom || t.clientX < e.left || t.clientX > e.right) && this.close();
+  };
+}
+class vt extends u {
+  static targets = ["trigger"];
+  connect() {
+    W(this, { trigger: this.hasTriggerTarget ? this.triggerTarget : null });
+  }
+}
+class Tt extends u {
+  static targets = ["anchor", "reference"];
+  static values = {
+    placement: { type: String, default: "bottom" },
+    alignment: { type: String, default: "start" },
+    role: { type: String, default: "tooltip" }
+  };
+  connect() {
+    if (!this.hasReferenceTarget) {
+      console.error(
+        'FlipperController requires a reference target. Add data-flipper-target="reference" to your element.'
+      );
+      return;
+    }
+    if (!this.hasAnchorTarget) {
+      console.error('FlipperController requires an anchor target. Add data-flipper-target="anchor" to your element.');
+      return;
+    }
+    et(this, {
+      element: this.referenceTarget,
+      anchor: this.anchorTarget,
+      placement: this.placementValue,
+      alignment: this.alignmentValue,
+      ariaRole: this.roleValue
+    });
+  }
+}
+class Dt extends u {
+  static targets = ["content", "template", "loader", "activator"];
+  static classes = ["hidden"];
+  static values = {
+    url: String,
+    loadedAt: String,
+    reload: { type: String, default: "never" },
+    staleAfter: { type: Number, default: 3600 }
+  };
+  connect() {
+    G(this, {
+      element: this.hasContentTarget ? this.contentTarget : null,
+      url: this.hasUrlValue ? this.urlValue : null
+    }), this.hasContentTarget && S(this, {
+      element: this.contentTarget,
+      activator: this.hasActivatorTarget ? this.activatorTarget : null
+    }), this.hasLoaderTarget && S(this, { element: this.loaderTarget, visibility: "contentLoaderVisibility" });
+  }
+  async show() {
+    await this.visibility.show();
+  }
+  async hide() {
+    await this.visibility.hide();
+  }
+  async shown() {
+    await this.load();
+  }
+  contentLoad() {
+    return this.hasContentTarget && this.contentTarget.tagName.toLowerCase() === "turbo-frame" ? (this.hasUrlValue && this.contentTarget.setAttribute("src", this.urlValue), !1) : !0;
+  }
+  async contentLoading() {
+    this.hasLoaderTarget && await this.contentLoaderVisibility.show();
+  }
+  async contentLoaded({ content: t }) {
+    this.hasContentTarget && this.contentTarget.replaceChildren(this.getContentNode(t)), this.hasLoaderTarget && await this.contentLoaderVisibility.hide();
+  }
+  getContentNode(t) {
+    if (typeof t == "string") {
+      const e = document.createElement("template");
+      return e.innerHTML = t, document.importNode(e.content, !0);
+    }
+    return document.importNode(t, !0);
+  }
+  contentLoader() {
+    if (this.hasTemplateTarget)
+      return this.templateTarget instanceof HTMLTemplateElement ? this.templateTarget.content : this.templateTarget.innerHTML;
+  }
+}
+class xt extends u {
+  static targets = ["daysOfWeek", "daysOfMonth"];
+  static classes = ["dayOfWeek", "dayOfMonth"];
+  static values = {
+    locales: { type: Array, default: ["default"] },
+    weekdayFormat: { type: String, default: "short" },
+    dayFormat: { type: String, default: "numeric" },
+    daysOfOtherMonth: { type: Boolean, default: !1 }
+  };
+  initialize() {
+    U(this);
+  }
+  connect() {
+    this.draw();
+  }
+  navigated() {
+    this.draw();
+  }
+  draw() {
+    this.drawDaysOfWeek(), this.drawDaysOfMonth();
+  }
+  createDayElement(t, { selectable: e = !1, disabled: i = !1 } = {}) {
+    const n = document.createElement(e ? "button" : "div");
+    return n.tabIndex = -1, t ? n.textContent = t : n.setAttribute("aria-hidden", "true"), i && (n instanceof HTMLButtonElement ? n.disabled = !0 : n.setAttribute("aria-disabled", "true")), n;
+  }
+  drawDaysOfWeek() {
+    if (!this.hasDaysOfWeekTarget) return;
+    const t = new Intl.DateTimeFormat(this.localesValue, {
+      weekday: this.weekdayFormatValue
+    }), e = [];
+    for (const n of this.calendar.daysOfWeek) {
+      const a = this.createDayElement(t.format(n.date));
+      a.setAttribute("role", "columnheader"), a.title = n.long, this.hasDayOfWeekClass && a.classList.add(...this.dayOfWeekClasses), e.push(a);
+    }
+    const i = document.createElement("div");
+    i.setAttribute("role", "row"), i.replaceChildren(...e), this.daysOfWeekTarget.replaceChildren(i);
+  }
+  drawDaysOfMonth() {
+    if (!this.hasDaysOfMonthTarget) return;
+    const t = this.calendar.today, e = new Date(t.getFullYear(), t.getMonth(), t.getDate()).getTime(), i = [];
+    for (const a of this.calendar.daysOfMonth) {
+      const r = !a.current || this.calendar.isDisabled(a.date) || !this.calendar.isWithinRange(a.date), o = a.current || this.daysOfOtherMonthValue ? a.value : "", l = this.createDayElement(o, {
+        selectable: a.current,
+        disabled: r
+      });
+      e === a.date.getTime() && l.setAttribute("aria-current", "date"), this.hasDayOfMonthClass && l.classList.add(...this.dayOfMonthClasses);
+      const c = document.createElement("time");
+      c.dateTime = a.iso, l.appendChild(c), i.push(l);
+    }
+    const n = [];
+    for (let a = 0; a < i.length; a += 7) {
+      const r = document.createElement("div");
+      r.setAttribute("role", "row");
+      for (const o of i.slice(a, a + 7))
+        o.setAttribute("role", "gridcell"), r.appendChild(o);
+      n.push(r);
+    }
+    this.daysOfMonthTarget.replaceChildren(...n);
+  }
+}
+class Ot extends u {
+  select(t) {
+    if (!(t.target instanceof HTMLElement)) return;
+    t.preventDefault();
+    const e = t.target instanceof HTMLTimeElement ? t.target.parentElement : t.target;
+    if (e.disabled || e.getAttribute("aria-disabled") === "true") return;
+    this.dispatch("select", { target: e });
+    const i = t.target instanceof HTMLTimeElement ? t.target : t.target.querySelector("time");
+    if (!i) return console.error(`unable to locate time element within ${e}`);
+    const n = m(i.dateTime);
+    if (!n) return console.error(`unable to parse ${i.dateTime} found within the time element`);
+    this.dispatch("selected", {
+      target: e,
+      detail: { epoch: n.getTime(), iso: n.toISOString() }
+    });
+  }
+}
+class Mt extends u {
+  static targets = ["previous", "next", "day", "month", "year", "input", "display"];
+  static outlets = ["calendar-month"];
+  static values = {
+    locales: { type: Array, default: ["default"] },
+    dayFormat: { type: String, default: "numeric" },
+    monthFormat: { type: String, default: "long" },
+    yearFormat: { type: String, default: "numeric" }
+  };
+  initialize() {
+    this.previous = this.previous.bind(this), this.next = this.next.bind(this);
+  }
+  async calendarMonthOutletConnected() {
+    if (this.hasInputTarget && this.inputTarget.value) {
+      const t = m(this.inputTarget.value);
+      t && await this.calendarMonthOutlet.calendar.navigate(t);
+    }
+    this.draw();
+  }
+  selected(t) {
+    this.hasInputTarget && (this.inputTarget.value = t.detail.iso), this.hasDisplayTarget && (this.displayTarget.value = this.formatDate(new Date(t.detail.iso)));
+  }
+  formatDate(t) {
+    return new Intl.DateTimeFormat(this.localesValue, {
+      day: this.dayFormatValue,
+      month: this.monthFormatValue,
+      year: this.yearFormatValue
+    }).format(t);
+  }
+  previousTargetConnected(t) {
+    t.addEventListener("click", this.previous);
+  }
+  previousTargetDisconnected(t) {
+    t.removeEventListener("click", this.previous);
+  }
+  async previous() {
+    await this.calendarMonthOutlet.calendar.step("month", -1), this.draw();
+  }
+  nextTargetConnected(t) {
+    t.addEventListener("click", this.next);
+  }
+  nextTargetDisconnected(t) {
+    t.removeEventListener("click", this.next);
+  }
+  async next() {
+    await this.calendarMonthOutlet.calendar.step("month", 1), this.draw();
+  }
+  draw() {
+    this.drawDay(), this.drawMonth(), this.drawYear();
+  }
+  drawDay() {
+    if (!this.hasDayTarget || !this.hasCalendarMonthOutlet) return;
+    const { year: t, month: e, day: i } = this.calendarMonthOutlet.calendar, n = new Intl.DateTimeFormat(this.localesValue, { day: this.dayFormatValue });
+    this.dayTarget.textContent = n.format(new Date(t, e, i));
+  }
+  drawMonth() {
+    if (!this.hasMonthTarget || !this.hasCalendarMonthOutlet) return;
+    const { year: t, month: e } = this.calendarMonthOutlet.calendar, i = new Intl.DateTimeFormat(this.localesValue, { month: this.monthFormatValue });
+    this.monthTarget.textContent = i.format(new Date(t, e));
+  }
+  drawYear() {
+    if (!this.hasYearTarget || !this.hasCalendarMonthOutlet) return;
+    const { year: t } = this.calendarMonthOutlet.calendar, e = new Intl.DateTimeFormat(this.localesValue, { year: this.yearFormatValue });
+    this.yearTarget.textContent = e.format(new Date(t, 0));
+  }
+}
+class kt extends u {
+  static targets = ["content"];
+  connect() {
+    nt(this, { element: this.hasContentTarget ? this.contentTarget : null });
+  }
+}
+class Ct extends u {
+  static targets = ["input"];
+  toggle() {
+    this.inputTarget.type = this.inputTarget.type === "password" ? "text" : "password";
+  }
+}
+class Et extends u {
+  connect() {
+    this.resize(), this.element.addEventListener("input", this.resize.bind(this));
+  }
+  disconnect() {
+    this.element.removeEventListener("input", this.resize.bind(this));
+  }
+  resize() {
+    this.element.style.height = "auto", this.element.style.height = `${this.element.scrollHeight}px`;
+  }
+}
+export {
+  P as ARIA_HASPOPUP_VALUES,
+  Et as AutoResizeController,
+  xt as CalendarMonthController,
+  Ot as CalendarMonthObserverController,
+  Mt as DatepickerController,
+  vt as DismisserController,
+  H as FOCUSABLE_SELECTOR,
+  Tt as FlipperController,
+  ot as FocusRestoration,
+  j as FocusTrap,
+  wt as ModalController,
+  kt as PannerController,
+  Ct as PasswordRevealController,
+  Dt as PopoverController,
+  ut as RovingTabIndex,
+  k as announce,
+  q as connectTriggerToTarget,
+  bt as disconnectTriggerFromTarget,
+  ft as ensureId,
+  $ as focusFirst,
+  _ as generateId,
+  V as getFocusableElements,
+  ht as isActivationKey,
+  ct as isArrowKey,
+  lt as isKey,
+  v as isVisible,
+  dt as preventDefault,
+  b as setAriaState,
+  yt as setChecked,
+  pt as setDisabled,
+  mt as setExpanded,
+  gt as setPressed
+};