@wpmoo/ui 0.9.0 → 1.0.0-rc.10

package/dist/js/moo-ui.js

@@ -0,0 +1,3947 @@
+/*!
+ * Moo UI moo-ui.js v1.0.0-rc.10 (https://wpmoo.org/)
+ * Copyright 2026 WPMoo Authors
+ * Licensed under MIT (https://github.com/wpmoo-org/ui/blob/main/LICENSE)
+ */
+
+// src/js/components/combobox.js
+var instances = /* @__PURE__ */ new WeakMap();
+var normalize = (value) => value.trim().toLowerCase();
+var Combobox = class _Combobox {
+  static getInstance(element) {
+    return element?.nodeType === 1 ? instances.get(element) || null : null;
+  }
+  static getOrCreateInstance(element, config = {}) {
+    return _Combobox.getInstance(element) || new _Combobox(element, config);
+  }
+  constructor(element, config = {}) {
+    if (element?.nodeType !== 1 || !element.matches(".combobox")) {
+      throw new TypeError("Combobox requires a .combobox root element.");
+    }
+    const existing = instances.get(element);
+    if (existing) {
+      return existing;
+    }
+    this._element = element;
+    this._document = element.ownerDocument;
+    this._window = this._document.defaultView;
+    this._config = { noResultsText: "No results found.", ...config };
+    this._input = element.querySelector(".combobox-input");
+    this._menu = element.querySelector(".combobox-menu");
+    this._options = Array.from(element.querySelectorAll(".combobox-option"));
+    if (!this._input || !this._menu || this._options.length === 0) {
+      throw new TypeError("Combobox requires an input, menu, and at least one option.");
+    }
+    this._isMultiple = element.dataset.comboboxMultiple === "true";
+    this._hidden = this._isMultiple ? null : element.querySelector('input[type="hidden"]');
+    this._chipValue = element.querySelector(".combobox-value");
+    this._valueStore = element.querySelector("[data-combobox-value-store]");
+    this._chipIconTemplate = element.querySelector("[data-combobox-chip-icon]");
+    this._clearTrigger = element.querySelector("[data-combobox-clear]");
+    this._indicator = element.querySelector(".combobox-indicator");
+    this._groups = Array.from(element.querySelectorAll("[data-combobox-group]"));
+    this._separators = Array.from(element.querySelectorAll("[data-combobox-separator]"));
+    this._listeners = [];
+    this._generated = [];
+    this._startsOpen = this._menu.classList.contains("show");
+    this._empty = this._menu.querySelector("[data-combobox-empty]");
+    if (!this._empty) {
+      this._empty = this._document.createElement("li");
+      this._empty.className = "combobox-empty";
+      this._empty.hidden = true;
+      this._empty.dataset.comboboxEmpty = "true";
+      this._empty.textContent = this._config.noResultsText;
+      this._menu.appendChild(this._empty);
+      this._generated.push(this._empty);
+    }
+    this._liveRegion = element.querySelector("[data-combobox-live]");
+    if (!this._liveRegion) {
+      this._liveRegion = this._document.createElement("span");
+      this._liveRegion.className = "visually-hidden";
+      this._liveRegion.setAttribute("aria-live", "polite");
+      this._liveRegion.dataset.comboboxLive = "true";
+      element.appendChild(this._liveRegion);
+      this._generated.push(this._liveRegion);
+    }
+    instances.set(element, this);
+    this._bindEvents();
+    this._toggleClear(
+      this._input.dataset.comboboxSelected === "true" || element.dataset.comboboxSelected === "true"
+    );
+    this._syncMultipleValue();
+    this._filterOptions({ open: this._startsOpen, activate: this._startsOpen });
+    if (!this._startsOpen) {
+      this._closeMenu(false);
+    }
+  }
+  dispose() {
+    this._listeners.forEach(({ target, type, handler, options }) => {
+      target.removeEventListener(type, handler, options);
+    });
+    this._listeners = [];
+    this._closeMenu(false);
+    this._generated.forEach((element) => element.remove());
+    this._generated = [];
+    this._chipValue?.querySelectorAll("[data-combobox-generated]").forEach((item) => item.remove());
+    this._valueStore?.querySelectorAll("[data-combobox-generated]").forEach((item) => item.remove());
+    instances.delete(this._element);
+  }
+  _listen(target, type, handler, options) {
+    target?.addEventListener(type, handler, options);
+    if (target) {
+      this._listeners.push({ target, type, handler, options });
+    }
+  }
+  _trigger(name, detail = {}) {
+    return this._element.dispatchEvent(
+      new this._window.CustomEvent(`${name}.moo.combobox`, {
+        bubbles: true,
+        cancelable: name === "show" || name === "hide",
+        detail
+      })
+    );
+  }
+  _optionGroupIsHidden(option) {
+    return option.closest("[data-combobox-group]")?.hidden || false;
+  }
+  _visibleOptions() {
+    return this._options.filter(
+      (option) => !option.hidden && !option.disabled && !this._optionGroupIsHidden(option)
+    );
+  }
+  _syncGroupVisibility() {
+    if (this._groups.length === 0) {
+      return;
+    }
+    let visibleGroupCount = 0;
+    this._groups.forEach((group) => {
+      const visible = Array.from(group.querySelectorAll(".combobox-option")).some(
+        (option) => !option.hidden
+      );
+      group.hidden = !visible;
+      visibleGroupCount += visible ? 1 : 0;
+    });
+    this._separators.forEach((separator) => {
+      separator.hidden = visibleGroupCount < 2;
+    });
+  }
+  _openMenu(emit = true) {
+    if (this._menu.classList.contains("show")) {
+      this._input.setAttribute("aria-expanded", "true");
+      return;
+    }
+    if (emit && !this._trigger("show")) {
+      return;
+    }
+    this._menu.classList.add("show");
+    this._input.setAttribute("aria-expanded", "true");
+    if (emit) {
+      this._trigger("shown");
+    }
+  }
+  _closeMenu(emit = true) {
+    const wasOpen = this._menu.classList.contains("show");
+    if (wasOpen && emit && !this._trigger("hide")) {
+      return;
+    }
+    this._menu.classList.remove("show");
+    this._input.setAttribute("aria-expanded", "false");
+    this._input.removeAttribute("aria-activedescendant");
+    this._options.forEach((option) => {
+      option.removeAttribute("aria-current");
+      option.classList.remove("active");
+    });
+    if (wasOpen && emit) {
+      this._trigger("hidden");
+    }
+  }
+  _optionLabel(option) {
+    return option?.querySelector(".combobox-option__label")?.textContent?.trim() || "";
+  }
+  _selectedOptions() {
+    return this._options.filter((option) => option.getAttribute("aria-selected") === "true");
+  }
+  _toggleClear(selected) {
+    const value = selected ? "true" : "false";
+    this._element.dataset.comboboxSelected = value;
+    this._input.dataset.comboboxSelected = value;
+    if (this._clearTrigger) {
+      this._clearTrigger.hidden = !selected;
+      if (this._indicator) {
+        this._indicator.hidden = selected;
+      }
+    }
+  }
+  _createChip(option) {
+    const value = option.dataset.value || "";
+    const label = this._optionLabel(option);
+    const chip = this._document.createElement("span");
+    chip.className = "badge text-bg-secondary combobox-chip";
+    chip.dataset.value = value;
+    chip.dataset.comboboxGenerated = "true";
+    const labelElement = this._document.createElement("span");
+    labelElement.className = "combobox-chip__label";
+    labelElement.textContent = label;
+    chip.appendChild(labelElement);
+    const remove = this._document.createElement("button");
+    remove.className = "combobox-chip__remove";
+    remove.type = "button";
+    remove.dataset.value = value;
+    remove.dataset.comboboxChipRemove = "true";
+    remove.setAttribute("aria-label", `Remove ${label}`);
+    remove.append(this._chipIconTemplate?.content.cloneNode(true) || "x");
+    chip.appendChild(remove);
+    return chip;
+  }
+  _syncMultipleValue() {
+    if (!this._isMultiple) {
+      return;
+    }
+    const selected = this._selectedOptions();
+    if (this._chipValue) {
+      this._chipValue.replaceChildren(...selected.map((option) => this._createChip(option)));
+    }
+    if (this._valueStore) {
+      this._valueStore.replaceChildren();
+      const name = this._valueStore.dataset.comboboxName || "";
+      selected.forEach((option) => {
+        const field = this._document.createElement("input");
+        field.type = "hidden";
+        field.name = name;
+        field.value = option.dataset.value || "";
+        field.dataset.comboboxGenerated = "true";
+        this._valueStore.appendChild(field);
+      });
+    }
+    this._toggleClear(selected.length > 0);
+  }
+  _emitChange() {
+    const selected = this._selectedOptions();
+    this._trigger("change", {
+      values: selected.map((option) => option.dataset.value || "")
+    });
+  }
+  _removeChip(value) {
+    const option = this._options.find((candidate) => candidate.dataset.value === value);
+    if (!option) {
+      return;
+    }
+    option.setAttribute("aria-selected", "false");
+    this._syncMultipleValue();
+    this._emitChange();
+  }
+  _clearSelection(emit = true) {
+    if (this._hidden) {
+      this._hidden.value = "";
+    }
+    this._options.forEach((option) => option.setAttribute("aria-selected", "false"));
+    if (this._isMultiple) {
+      this._syncMultipleValue();
+    } else {
+      this._toggleClear(false);
+    }
+    if (emit) {
+      this._emitChange();
+    }
+  }
+  _clearStaleSelection() {
+    if (this._isMultiple) {
+      this._input.value = "";
+      this._options.forEach((option) => {
+        option.hidden = false;
+      });
+      this._syncGroupVisibility();
+      this._empty.hidden = true;
+      return;
+    }
+    const selected = this._selectedOptions()[0] || null;
+    const label = this._optionLabel(selected);
+    if (!this._input.value || label && normalize(this._input.value) === normalize(label)) {
+      return;
+    }
+    this._clearSelection();
+    this._input.value = "";
+  }
+  _activeOption() {
+    const activeId = this._input.getAttribute("aria-activedescendant");
+    if (!activeId) {
+      return null;
+    }
+    return this._visibleOptions().find((option) => option.id === activeId) || null;
+  }
+  _selectedOption() {
+    if (this._isMultiple) {
+      return null;
+    }
+    return this._visibleOptions().find(
+      (option) => option.getAttribute("aria-selected") === "true"
+    ) || null;
+  }
+  _preferredActiveOption() {
+    return this._selectedOption() || this._visibleOptions()[0] || null;
+  }
+  _activatePreferredOptionIfNeeded() {
+    if (!this._activeOption()) {
+      this._setActiveOption(this._preferredActiveOption());
+    }
+  }
+  _setActiveOption(option, { scroll = true } = {}) {
+    this._options.forEach((candidate) => {
+      const active = candidate === option;
+      if (active) {
+        candidate.setAttribute("aria-current", "true");
+      } else {
+        candidate.removeAttribute("aria-current");
+      }
+      candidate.classList.toggle("active", active);
+    });
+    if (!option) {
+      this._input.removeAttribute("aria-activedescendant");
+      return;
+    }
+    this._input.setAttribute("aria-activedescendant", option.id);
+    if (scroll) {
+      const optionRect = option.getBoundingClientRect();
+      const menuRect = this._menu.getBoundingClientRect();
+      if (optionRect.top < menuRect.top) {
+        this._menu.scrollTop -= menuRect.top - optionRect.top;
+      } else if (optionRect.bottom > menuRect.bottom) {
+        this._menu.scrollTop += optionRect.bottom - menuRect.bottom;
+      }
+    }
+  }
+  _activateOptionFromPointer(option, event) {
+    if (event.pointerType === "touch" || option.disabled || option.getAttribute("aria-disabled") === "true" || option === this._activeOption()) {
+      return;
+    }
+    this._setActiveOption(option, { scroll: false });
+  }
+  _restoreSelectedActiveOption() {
+    if (!this._menu.classList.contains("show")) {
+      return;
+    }
+    const selected = this._selectedOption();
+    if (selected) {
+      this._setActiveOption(selected, { scroll: false });
+    }
+  }
+  _chooseOption(option) {
+    if (!option || option.disabled) {
+      return;
+    }
+    if (this._isMultiple) {
+      option.setAttribute(
+        "aria-selected",
+        option.getAttribute("aria-selected") === "true" ? "false" : "true"
+      );
+      this._input.value = "";
+      this._syncMultipleValue();
+      this._filterOptions();
+      this._setActiveOption(option);
+      this._emitChange();
+      return;
+    }
+    this._options.forEach((candidate) => {
+      candidate.setAttribute("aria-selected", candidate === option ? "true" : "false");
+    });
+    this._input.value = this._optionLabel(option);
+    if (this._hidden) {
+      this._hidden.value = option.dataset.value || "";
+    }
+    this._toggleClear(true);
+    this._setActiveOption(option);
+    this._emitChange();
+  }
+  _filterOptions({ open = true, activate = true, resetActive = false } = {}) {
+    if (open) {
+      this._openMenu();
+    }
+    const needle = normalize(this._input.value);
+    let count = 0;
+    this._options.forEach((option) => {
+      const matches = !needle || normalize(option.textContent).includes(needle);
+      option.hidden = !matches;
+      count += matches ? 1 : 0;
+    });
+    this._syncGroupVisibility();
+    this._empty.hidden = count !== 0;
+    this._liveRegion.textContent = count === 0 ? "No results" : `${count} result${count === 1 ? "" : "s"}`;
+    if (resetActive) {
+      this._setActiveOption(null, { scroll: false });
+    }
+    if (activate) {
+      this._activatePreferredOptionIfNeeded();
+    }
+  }
+  _bindEvents() {
+    this._listen(this._input, "focus", () => {
+      this._openMenu();
+      if (!this._isMultiple && this._input.dataset.comboboxSelected === "true") {
+        this._input.select();
+      }
+      this._activatePreferredOptionIfNeeded();
+    });
+    this._listen(this._input, "input", () => {
+      if (!this._isMultiple) {
+        this._clearSelection();
+      }
+      this._filterOptions({ resetActive: true });
+    });
+    this._listen(this._input, "blur", (event) => {
+      const nextTarget = event.relatedTarget;
+      if (nextTarget instanceof this._window.Node && this._element.contains(nextTarget)) {
+        return;
+      }
+      this._clearStaleSelection();
+    });
+    this._listen(this._input, "click", () => {
+      this._openMenu();
+      this._setActiveOption(this._preferredActiveOption());
+    });
+    this._listen(this._input, "keydown", (event) => this._handleKeydown(event));
+    this._options.forEach((option) => {
+      this._listen(option, "keydown", (event) => this._handleKeydown(event));
+      this._listen(option, "pointerenter", (event) => {
+        this._activateOptionFromPointer(option, event);
+      });
+      this._listen(option, "click", () => {
+        this._chooseOption(option);
+        if (this._isMultiple) {
+          this._input.focus();
+        } else {
+          this._closeMenu();
+        }
+      });
+    });
+    this._listen(this._clearTrigger, "click", (event) => {
+      event.preventDefault();
+      this._clearSelection();
+      this._input.value = "";
+      this._input.focus();
+      this._filterOptions({ resetActive: true });
+    });
+    this._listen(this._menu, "pointerleave", () => this._restoreSelectedActiveOption());
+    this._listen(this._element, "click", (event) => this._handleRootClick(event));
+    this._listen(this._document, "click", (event) => {
+      if (event.target instanceof this._window.Node && !this._element.contains(event.target)) {
+        this._closeMenu();
+      }
+    });
+  }
+  _handleRootClick(event) {
+    const target = event.target;
+    const trigger = target instanceof this._window.Element ? target.closest("[data-combobox-chip-remove]") : null;
+    if (trigger) {
+      event.preventDefault();
+      this._removeChip(trigger.dataset.value || "");
+      this._input.focus();
+    } else if (this._isMultiple && target instanceof this._window.Element && target.closest(".combobox-chips")) {
+      this._input.focus();
+    }
+  }
+  _handleKeydown(event) {
+    const available = this._visibleOptions();
+    const current = available.findIndex(
+      (option) => option.id === this._input.getAttribute("aria-activedescendant")
+    );
+    const isNextKey = event.key === "ArrowDown" || event.key === "Down";
+    const isPreviousKey = event.key === "ArrowUp" || event.key === "Up";
+    if (this._isMultiple && event.key === "Backspace" && this._input.value === "") {
+      const selected = this._selectedOptions();
+      const last = selected[selected.length - 1];
+      if (last) {
+        event.preventDefault();
+        this._removeChip(last.dataset.value || "");
+      }
+    } else if ((isNextKey || isPreviousKey) && available.length) {
+      event.preventDefault();
+      this._openMenu();
+      const offset = isNextKey ? 1 : -1;
+      const next = current === -1 ? 0 : (current + offset + available.length) % available.length;
+      this._setActiveOption(available[next]);
+      if (event.target !== this._input) {
+        this._input.focus({ preventScroll: true });
+      }
+    } else if (event.key === "Enter") {
+      const option = available[current];
+      if (option) {
+        event.preventDefault();
+        this._chooseOption(option);
+        if (!this._isMultiple) {
+          this._closeMenu();
+        }
+      }
+    } else if (event.key === "Escape") {
+      this._closeMenu();
+      this._input.focus();
+    } else if (event.key === "Tab") {
+      this._closeMenu();
+    }
+  }
+};
+
+// src/js/components/context-menu.js
+var instances2 = /* @__PURE__ */ new WeakMap();
+function pointerRect(event) {
+  const { clientX: x, clientY: y } = event;
+  return { top: y, left: x, right: x, bottom: y, width: 0, height: 0, x, y };
+}
+function isDisabledTrigger(trigger) {
+  return Boolean(trigger?.disabled || trigger?.getAttribute?.("aria-disabled") === "true");
+}
+function menuItemFromEvent(event) {
+  const target = event.target;
+  const item = target.closest?.(".dropdown-item");
+  if (item) {
+    return item;
+  }
+  return target.closest?.("li")?.querySelector(":scope > .dropdown-item") || null;
+}
+var ContextMenu = class _ContextMenu {
+  static getInstance(element) {
+    return element?.nodeType === 1 ? instances2.get(element) || null : null;
+  }
+  static getOrCreateInstance(element, config = {}) {
+    return _ContextMenu.getInstance(element) || new _ContextMenu(element, config);
+  }
+  constructor(element, config = {}) {
+    if (element?.nodeType !== 1 || !element.matches(".context-menu")) {
+      throw new TypeError("ContextMenu requires a .context-menu root element.");
+    }
+    const existing = instances2.get(element);
+    if (existing) {
+      return existing;
+    }
+    this._element = element;
+    this._document = element.ownerDocument;
+    this._window = this._document.defaultView;
+    this._menu = element.querySelector(":scope > .context-menu-menu");
+    this._fallback = element.querySelector(":scope > [data-context-menu-fallback]");
+    if (!this._menu) {
+      throw new TypeError("ContextMenu requires a .context-menu-menu element.");
+    }
+    if (!this._fallback) {
+      throw new TypeError("ContextMenu requires an explicit fallback trigger.");
+    }
+    const Dropdown = this._bootstrap("Dropdown");
+    if (!Dropdown) {
+      throw new TypeError("ContextMenu requires bootstrap.Dropdown (bootstrap.bundle.js).");
+    }
+    this._config = { ...config };
+    this._listeners = [];
+    this._invoker = null;
+    this._pointerRect = null;
+    this._openMethod = null;
+    this._reference = {
+      getBoundingClientRect: () => this._currentRect(),
+      contextElement: this._fallback
+    };
+    this._dropdown = new Dropdown(this._fallback, {
+      reference: this._reference,
+      autoClose: "outside"
+    });
+    instances2.set(element, this);
+    this._bindEvents();
+  }
+  dispose() {
+    this._listeners.forEach(({ target, type, handler, options }) => {
+      target.removeEventListener(type, handler, options);
+    });
+    this._listeners = [];
+    this._dropdown.dispose();
+    this._syncExpanded(false);
+    this._invoker = null;
+    this._pointerRect = null;
+    instances2.delete(this._element);
+  }
+  show(anchor = this._fallback) {
+    this._open(anchor, null);
+  }
+  hide() {
+    this._dropdown.hide();
+  }
+  _listen(target, type, handler, options) {
+    target.addEventListener(type, handler, options);
+    this._listeners.push({ target, type, handler, options });
+  }
+  _bootstrap(name) {
+    return this._window.bootstrap?.[name] || null;
+  }
+  _currentRect() {
+    if (this._pointerRect) {
+      return this._pointerRect;
+    }
+    return (this._invoker || this._fallback).getBoundingClientRect();
+  }
+  _trigger(name, cancelable = false) {
+    return this._element.dispatchEvent(
+      new this._window.CustomEvent(`${name}.moo.context-menu`, {
+        bubbles: true,
+        cancelable
+      })
+    );
+  }
+  _triggers() {
+    return Array.from(this._element.querySelectorAll(":scope > .context-menu-trigger"));
+  }
+  _syncExpanded(expanded) {
+    this._triggers().forEach((trigger) => {
+      trigger.setAttribute("aria-expanded", String(expanded));
+    });
+  }
+  _menuItems() {
+    return Array.from(this._menu.querySelectorAll(".dropdown-item")).filter(
+      (item) => !isDisabledTrigger(item) && !item.classList.contains("disabled")
+    );
+  }
+  _open(trigger, pointerEvent, openMethod) {
+    if (isDisabledTrigger(trigger)) {
+      return;
+    }
+    if (this._menu.classList.contains("show")) {
+      this._dropdown.hide();
+    }
+    this._invoker = trigger;
+    this._pointerRect = pointerEvent ? pointerRect(pointerEvent) : null;
+    this._openMethod = openMethod;
+    this._dropdown.show();
+  }
+  _handleContextMenu(event) {
+    const trigger = event.target.closest(".context-menu-trigger");
+    if (!trigger || !this._element.contains(trigger)) {
+      return;
+    }
+    event.preventDefault();
+    this._open(trigger, event, "pointer");
+  }
+  _handleKeydown(event) {
+    const trigger = event.target.closest(".context-menu-trigger");
+    if (!trigger || !this._element.contains(trigger)) {
+      return;
+    }
+    const isShiftF10 = event.shiftKey && event.key === "F10";
+    const isContextMenuKey = event.key === "ContextMenu";
+    if (!isShiftF10 && !isContextMenuKey) {
+      return;
+    }
+    event.preventDefault();
+    this._open(trigger, null, "keyboard");
+  }
+  _handleFallbackClick() {
+    this._invoker = this._fallback;
+    this._pointerRect = null;
+    this._openMethod = "pointer";
+  }
+  _handleFallbackKeydown(event) {
+    if (event.key !== " " && event.key !== "Spacebar") {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    if (this._menu.classList.contains("show")) {
+      this._dropdown.hide();
+      return;
+    }
+    this._open(this._fallback, null, "fallback-keyboard");
+  }
+  _handleMenuClick(event) {
+    const item = menuItemFromEvent(event);
+    if (!item) {
+      return;
+    }
+    const persistentItem = item.matches(".dropdown-item-check, [data-context-menu-persistent]");
+    const disabledItem = item.matches('.dropdown-item.disabled, .dropdown-item[aria-disabled="true"], .dropdown-item:disabled') || isDisabledTrigger(item);
+    if (disabledItem) {
+      event.preventDefault();
+      event.stopPropagation();
+      return;
+    }
+    const radioButton = item.matches("[data-context-menu-radio-group]") ? item : null;
+    if (radioButton) {
+      event.preventDefault();
+      event.stopPropagation();
+      const group = radioButton.dataset.contextMenuRadioGroup;
+      this._menu.querySelectorAll(`[data-context-menu-radio-group="${group}"]`).forEach((button) => {
+        const checked = button === radioButton;
+        button.classList.toggle("active", checked);
+        button.setAttribute("aria-pressed", String(checked));
+      });
+      return;
+    }
+    if (persistentItem) {
+      return;
+    }
+    this._dropdown.hide();
+  }
+  _bindEvents() {
+    this._listen(this._element, "contextmenu", (event) => this._handleContextMenu(event));
+    this._listen(this._element, "keydown", (event) => this._handleKeydown(event));
+    this._listen(this._fallback, "click", () => this._handleFallbackClick());
+    this._listen(this._fallback, "keydown", (event) => this._handleFallbackKeydown(event));
+    this._listen(this._menu, "click", (event) => this._handleMenuClick(event));
+    this._listen(this._fallback, "show.bs.dropdown", (event) => {
+      if (!this._trigger("show", true)) {
+        event.preventDefault();
+      }
+    });
+    this._listen(this._fallback, "shown.bs.dropdown", () => {
+      this._syncExpanded(true);
+      if (this._openMethod === "fallback-keyboard") {
+        this._fallback.focus();
+      } else if (this._openMethod === "keyboard") {
+        this._menuItems()[0]?.focus();
+      } else {
+        this._menu.focus();
+      }
+      this._trigger("shown");
+    });
+    this._listen(this._fallback, "hide.bs.dropdown", (event) => {
+      if (!this._trigger("hide", true)) {
+        event.preventDefault();
+      }
+    });
+    this._listen(this._fallback, "hidden.bs.dropdown", () => {
+      this._syncExpanded(false);
+      const invoker = this._invoker;
+      this._pointerRect = null;
+      this._invoker = null;
+      this._openMethod = null;
+      this._trigger("hidden");
+      queueMicrotask(() => {
+        if (invoker && invoker !== this._fallback && this._document.activeElement === this._fallback) {
+          invoker.focus();
+        }
+      });
+    });
+  }
+};
+
+// src/js/theme-owner.js
+var OWNER_SELECTOR = '.moo-ui[data-bs-theme="light"], .moo-ui[data-bs-theme="dark"]';
+var PORTAL_SELECTOR = "[data-moo-overlay-host]";
+function documentFor(node) {
+  if (node?.nodeType === 9) return node;
+  if (node?.ownerDocument) return node.ownerDocument;
+  return typeof document === "undefined" ? null : document;
+}
+function isResolvedOwner(node) {
+  return Boolean(node?.matches?.(OWNER_SELECTOR));
+}
+function ownerRootFor(node) {
+  const ownerDocument = documentFor(node);
+  if (node?.nodeType === 9 || node === ownerDocument?.body) {
+    return ownerDocument?.body?.firstElementChild || null;
+  }
+  return node;
+}
+function findThemeOwner(node = typeof document === "undefined" ? null : document) {
+  const start = ownerRootFor(node);
+  if (!start) return null;
+  if (isResolvedOwner(start)) return start;
+  return start.closest?.(OWNER_SELECTOR) || null;
+}
+function ownerPortalRoot(owner) {
+  if (!owner) return null;
+  return Array.from(owner.children || []).find(
+    (child) => child.matches?.(PORTAL_SELECTOR)
+  ) || owner;
+}
+
+// src/js/components/datatable.js
+var instances3 = /* @__PURE__ */ new WeakMap();
+function normalize2(value) {
+  return (value ?? "").toString().trim().toLowerCase();
+}
+var DataTable = class _DataTable {
+  static getInstance(element) {
+    return element?.nodeType === 1 ? instances3.get(element) || null : null;
+  }
+  static getOrCreateInstance(element, config = {}) {
+    return _DataTable.getInstance(element) || new _DataTable(element, config);
+  }
+  constructor(element, config = {}) {
+    if (element?.nodeType !== 1 || !element.matches(".datatable")) {
+      throw new TypeError("DataTable requires a .datatable root element.");
+    }
+    const existing = instances3.get(element);
+    if (existing) {
+      return existing;
+    }
+    this._element = element;
+    this._document = element.ownerDocument;
+    this._window = this._document.defaultView;
+    this._table = element.querySelector(":scope .datatable-table");
+    this._tbody = this._table?.querySelector(":scope > tbody");
+    if (!this._table || !this._tbody) {
+      throw new TypeError("DataTable requires a .datatable-table with a tbody.");
+    }
+    this._cards = element.querySelector("[data-datatable-cards]");
+    const cardById = new Map(
+      Array.from(element.querySelectorAll("[data-datatable-card]")).map((card) => [card.dataset.datatableCardFor, card])
+    );
+    this._config = { ...config };
+    this._listeners = [];
+    this._pageSize = Number(element.dataset.datatablePageSize) || 10;
+    this._currentPage = 1;
+    this._sortKey = null;
+    this._sortDirection = null;
+    this._selectedIds = /* @__PURE__ */ new Set();
+    this._facetSelections = /* @__PURE__ */ new Map();
+    this._visibleFacets = /* @__PURE__ */ new Map();
+    this._searchTerm = "";
+    this._tooltips = [];
+    this._filterMode = element.dataset.datatableFilterMode || "inline";
+    this._reparentedRowMenus = /* @__PURE__ */ new Map();
+    this._reparentedRowMenuByTrigger = /* @__PURE__ */ new WeakMap();
+    this._reparentedSortMenus = /* @__PURE__ */ new Map();
+    this._reparentedSortMenuByTrigger = /* @__PURE__ */ new WeakMap();
+    this._rows = Array.from(this._tbody.querySelectorAll(":scope > tr[data-datatable-row]")).map((tr, index) => ({
+      element: tr,
+      cardElement: cardById.get(tr.id) || null,
+      index,
+      search: normalize2(tr.dataset.datatableSearch),
+      facets: this._readFacets(tr)
+    }));
+    this._readInitialFacetVisibility();
+    this._readInitialSort();
+    instances3.set(element, this);
+    this._bindEvents();
+    this._render();
+    this._initBulkTooltips();
+    this._initViewToggle();
+    this._initRowActionDropdowns();
+    this._initSortDropdowns();
+  }
+  dispose() {
+    this._disposeRowActionDropdowns();
+    this._disposeSortDropdowns();
+    this._restoreRowActionMenus();
+    this._restoreSortMenus();
+    this._listeners.forEach(({ target, type, handler, options }) => {
+      target.removeEventListener(type, handler, options);
+    });
+    this._listeners = [];
+    this._tooltips.forEach((tooltip) => tooltip.dispose());
+    this._tooltips = [];
+    instances3.delete(this._element);
+  }
+  getSelectedIds() {
+    return Array.from(this._selectedIds);
+  }
+  _listen(target, type, handler, options) {
+    if (!target) {
+      return;
+    }
+    target.addEventListener(type, handler, options);
+    this._listeners.push({ target, type, handler, options });
+  }
+  // Row menus are authored next to their trigger so the public HTML stays
+  // inspectable, but when opened they are temporarily moved to their nearest
+  // Moo owner portal.
+  // That keeps the menu out of the scroll wrapper's layout math, so Safari
+  // cannot clip it at the rounded frame edge or shift the visible table
+  // slice while Popper positions it against the viewport.
+  // Public Dropdown compositions need the same behavior as the built-in
+  // row actions. Scope by row/card ownership so toolbar and sort menus keep
+  // their own lifecycle.
+  _rowActionTriggers() {
+    return this._element.querySelectorAll(
+      'tr[data-datatable-row] .dropdown [data-bs-toggle="dropdown"], [data-datatable-card] .dropdown [data-bs-toggle="dropdown"]'
+    );
+  }
+  _initRowActionDropdowns() {
+    const Dropdown = this._bootstrap("Dropdown");
+    if (!Dropdown) {
+      return;
+    }
+    this._rowActionTriggers().forEach((trigger) => {
+      Dropdown.getOrCreateInstance(trigger, {
+        popperConfig: (defaultConfig) => this._clippingSafePopperConfig(defaultConfig)
+      });
+    });
+  }
+  _sortTriggers() {
+    return this._element.querySelectorAll(
+      '.datatable-sort [data-bs-toggle="dropdown"]'
+    );
+  }
+  _initSortDropdowns() {
+    const Dropdown = this._bootstrap("Dropdown");
+    if (!Dropdown) {
+      return;
+    }
+    this._sortTriggers().forEach((trigger) => {
+      Dropdown.getOrCreateInstance(trigger, {
+        popperConfig: (defaultConfig) => this._clippingSafePopperConfig(defaultConfig)
+      });
+    });
+  }
+  _clippingSafePopperConfig(defaultConfig) {
+    return {
+      ...defaultConfig,
+      strategy: "fixed",
+      modifiers: [
+        ...defaultConfig.modifiers || [],
+        {
+          name: "flip",
+          options: {
+            fallbackPlacements: ["top-end", "top-start", "bottom-end", "bottom-start"]
+          }
+        },
+        {
+          name: "preventOverflow",
+          options: {
+            boundary: "viewport",
+            padding: 8
+          }
+        }
+      ]
+    };
+  }
+  // dispose() alone leaves any open row-action Dropdown's show/aria-expanded/
+  // data-bs-popper state and Bootstrap instance behind; hide and dispose each
+  // one first so a subsequent re-init starts from a clean state.
+  _disposeRowActionDropdowns() {
+    const Dropdown = this._bootstrap("Dropdown");
+    if (!Dropdown) {
+      return;
+    }
+    this._rowActionTriggers().forEach((trigger) => {
+      const instance = Dropdown.getInstance(trigger);
+      if (!instance) {
+        return;
+      }
+      instance.hide();
+      instance.dispose();
+    });
+  }
+  _disposeSortDropdowns() {
+    const Dropdown = this._bootstrap("Dropdown");
+    if (!Dropdown) {
+      return;
+    }
+    this._sortTriggers().forEach((trigger) => {
+      const instance = Dropdown.getInstance(trigger);
+      if (!instance) {
+        return;
+      }
+      instance.hide();
+      instance.dispose();
+    });
+  }
+  _rowActionMenuForTrigger(trigger) {
+    if (!trigger?.closest?.("tr[data-datatable-row], [data-datatable-card]")) {
+      return null;
+    }
+    return trigger.closest(".dropdown")?.querySelector(":scope > .dropdown-menu") || null;
+  }
+  _rowActionOwnerIdForTrigger(trigger) {
+    const rowId = trigger?.closest?.("tr[data-datatable-row]")?.id;
+    if (rowId) {
+      return rowId;
+    }
+    return trigger?.closest?.("[data-datatable-card]")?.getAttribute("data-datatable-card-for") || "";
+  }
+  _reparentRowActionMenu(trigger) {
+    const menu = this._rowActionMenuForTrigger(trigger);
+    if (!menu || this._reparentedRowMenus.has(menu)) {
+      return;
+    }
+    const ownerId = this._rowActionOwnerIdForTrigger(trigger);
+    if (ownerId) {
+      menu.setAttribute("data-datatable-row-action-owner", ownerId);
+    }
+    if (trigger.id) {
+      menu.setAttribute("data-datatable-row-action-trigger", trigger.id);
+    }
+    this._reparentedRowMenus.set(menu, {
+      parent: menu.parentNode,
+      nextSibling: menu.nextSibling,
+      trigger,
+      owner: findThemeOwner(trigger)
+    });
+    this._reparentedRowMenuByTrigger.set(trigger, menu);
+    this._portalRoot(trigger).appendChild(menu);
+  }
+  _restoreRowActionMenuForTrigger(trigger) {
+    const menu = this._reparentedRowMenuByTrigger.get(trigger) || this._rowActionMenuForTrigger(trigger);
+    if (menu) {
+      this._restoreRowActionMenu(menu);
+    }
+  }
+  _restoreRowActionMenu(menu) {
+    const original = this._reparentedRowMenus.get(menu);
+    if (!original) {
+      return;
+    }
+    const { parent, nextSibling, trigger, owner } = original;
+    if (owner?.isConnected === false) {
+      menu.remove();
+    } else if (parent?.isConnected) {
+      if (nextSibling?.parentNode === parent) {
+        parent.insertBefore(menu, nextSibling);
+      } else {
+        parent.appendChild(menu);
+      }
+    } else {
+      menu.remove();
+    }
+    if (trigger) {
+      this._reparentedRowMenuByTrigger.delete(trigger);
+    }
+    menu.removeAttribute("data-datatable-row-action-owner");
+    menu.removeAttribute("data-datatable-row-action-trigger");
+    this._reparentedRowMenus.delete(menu);
+  }
+  _restoreRowActionMenus() {
+    Array.from(this._reparentedRowMenus.keys()).forEach((menu) => {
+      this._restoreRowActionMenu(menu);
+    });
+  }
+  _sortMenuForTrigger(trigger) {
+    if (!trigger?.closest?.(".datatable-sort")) {
+      return null;
+    }
+    return this._reparentedSortMenuByTrigger.get(trigger) || trigger?.closest?.(".dropdown")?.querySelector(":scope > .dropdown-menu") || null;
+  }
+  // Sort menus are authored inside their table header, but must leave the
+  // overflow frame while open just like row-action menus do.
+  _reparentSortMenu(trigger) {
+    const menu = this._sortMenuForTrigger(trigger);
+    if (!menu || this._reparentedSortMenus.has(menu)) {
+      return;
+    }
+    this._reparentedSortMenus.set(menu, {
+      parent: menu.parentNode,
+      nextSibling: menu.nextSibling,
+      trigger,
+      owner: trigger.closest(".datatable-sort"),
+      themeOwner: findThemeOwner(trigger)
+    });
+    this._reparentedSortMenuByTrigger.set(trigger, menu);
+    this._portalRoot(trigger).appendChild(menu);
+  }
+  _restoreSortMenuForTrigger(trigger) {
+    const menu = this._reparentedSortMenuByTrigger.get(trigger) || this._sortMenuForTrigger(trigger);
+    if (menu) {
+      this._restoreSortMenu(menu);
+    }
+  }
+  _restoreSortMenu(menu) {
+    const original = this._reparentedSortMenus.get(menu);
+    if (!original) {
+      return;
+    }
+    const { parent, nextSibling, trigger, themeOwner } = original;
+    if (themeOwner?.isConnected === false) {
+      menu.remove();
+    } else if (parent?.isConnected) {
+      if (nextSibling?.parentNode === parent) {
+        parent.insertBefore(menu, nextSibling);
+      } else {
+        parent.appendChild(menu);
+      }
+    } else {
+      menu.remove();
+    }
+    if (trigger) {
+      this._reparentedSortMenuByTrigger.delete(trigger);
+    }
+    this._reparentedSortMenus.delete(menu);
+  }
+  _restoreSortMenus() {
+    Array.from(this._reparentedSortMenus.keys()).forEach((menu) => {
+      this._restoreSortMenu(menu);
+    });
+  }
+  _bootstrap(name) {
+    return this._window.bootstrap?.[name] || null;
+  }
+  _portalRoot(trigger = this._element) {
+    return ownerPortalRoot(findThemeOwner(trigger)) || this._document.body || this._document.documentElement;
+  }
+  // The bulk-actions bar's icon-only buttons carry data-bs-title instead of
+  // a bare title attribute so Bootstrap's own Tooltip owns the hover/focus
+  // affordance (matching the rest of Moo's icon-button contracts) rather
+  // than the browser's unstyled, delayed native tooltip. Tooltip has no
+  // Data API auto-init the way Dropdown does, so it needs this explicit,
+  // one-time setup; the bar's markup is static, so it never needs re-init.
+  // animation: false keeps show()/hide() synchronous -- with the default
+  // CSS fade, a click on a tooltip's own dropdown-toggle button fires
+  // "show.bs.dropdown" while the hover-triggered tooltip is still mid-fade,
+  // so the hide() below (see show.bs.dropdown in _bindEvents) would find
+  // it not yet fully shown and no-op, leaving it stuck open over the menu.
+  _initBulkTooltips() {
+    const Tooltip = this._bootstrap("Tooltip");
+    if (!Tooltip) {
+      return;
+    }
+    this._element.querySelectorAll('[data-datatable-bulk-actions] [data-bs-title]:not([data-bs-toggle="dropdown"])').forEach((trigger) => {
+      this._tooltips.push(Tooltip.getOrCreateInstance(trigger, {
+        animation: false,
+        container: this._portalRoot(trigger)
+      }));
+    });
+  }
+  _hideBulkTooltips({ blur = false } = {}) {
+    this._tooltips.forEach((tooltip) => {
+      tooltip.hide();
+    });
+    if (!blur) {
+      return;
+    }
+    const active = this._document.activeElement;
+    if (active?.closest?.("[data-datatable-bulk-actions]")) {
+      active.blur();
+    }
+  }
+  // Auto mode remembers independent narrow/wide choices; toggle mode keeps
+  // its existing viewport-independent preference.
+  _initViewToggle() {
+    const toggles = Array.from(this._element.querySelectorAll(".datatable-view-toggle"));
+    if (!toggles.length) {
+      return;
+    }
+    const inputs = toggles.flatMap((toggle) => Array.from(toggle.querySelectorAll("input")));
+    const breakpoint = this._window.getComputedStyle(this._element).getPropertyValue("--moo-datatable-responsive-breakpoint").trim();
+    const auto = this._element.hasAttribute("data-datatable-responsive-breakpoint");
+    const media = auto && breakpoint ? this._window.matchMedia(`(min-width: ${breakpoint})`) : null;
+    const preferences = /* @__PURE__ */ new Map();
+    const storageKey = () => `moo-datatable-view:${this._element.id}${media ? media.matches ? ":wide" : ":narrow" : ""}`;
+    const setView = (value, { persist = false } = {}) => {
+      if (this._element.dataset.datatableView !== value) {
+        const Dropdown = this._bootstrap("Dropdown");
+        [...this._rowActionTriggers(), ...this._sortTriggers()].forEach((trigger) => {
+          Dropdown?.getInstance(trigger)?.hide();
+        });
+      }
+      this._element.dataset.datatableView = value;
+      inputs.forEach((input) => {
+        input.checked = input.value === value;
+      });
+      if (persist) {
+        preferences.set(storageKey(), value);
+        try {
+          this._window.localStorage.setItem(storageKey(), value);
+        } catch {
+        }
+      }
+    };
+    const restoreView = () => {
+      let stored = preferences.get(storageKey());
+      try {
+        stored ?? (stored = this._window.localStorage.getItem(storageKey()));
+      } catch {
+      }
+      setView(stored === "table" || stored === "cards" ? stored : media ? media.matches ? "table" : "cards" : this._element.dataset.datatableView);
+    };
+    if (!auto || media) {
+      restoreView();
+    } else {
+      inputs.forEach((input) => {
+        input.checked = false;
+      });
+    }
+    if (media) this._listen(media, "change", restoreView);
+    toggles.forEach((toggle) => {
+      this._listen(toggle, "change", (event) => {
+        const value = event.target.value;
+        if (value !== "table" && value !== "cards") {
+          return;
+        }
+        setView(value, { persist: true });
+      });
+    });
+  }
+  _readFacets(tr) {
+    const facets = {};
+    Array.from(tr.attributes).forEach((attr) => {
+      const match = /^data-datatable-facet-(.+)$/.exec(attr.name);
+      if (match) {
+        facets[match[1]] = attr.value;
+      }
+    });
+    return facets;
+  }
+  _readInitialFacetVisibility() {
+    this._element.querySelectorAll("[data-datatable-facet]").forEach((facetRoot) => {
+      const key = facetRoot.dataset.datatableFacet;
+      if (key) {
+        this._visibleFacets.set(key, !facetRoot.hidden);
+      }
+    });
+    this._element.querySelectorAll("[data-datatable-filter-group]").forEach((group) => {
+      const key = group.dataset.datatableFilterGroup;
+      if (key && !this._visibleFacets.has(key)) {
+        this._visibleFacets.set(key, false);
+      }
+    });
+    this._element.querySelectorAll("[data-datatable-filter-option-key]").forEach((option) => {
+      const key = option.dataset.datatableFilterOptionKey;
+      if (key && !this._visibleFacets.has(key)) {
+        this._visibleFacets.set(key, false);
+      }
+    });
+  }
+  _readInitialSort() {
+    const th = this._element.querySelector("th[data-datatable-initial-sort][data-datatable-column]");
+    const direction = th?.dataset.datatableInitialSort;
+    if (direction !== "asc" && direction !== "desc") {
+      return;
+    }
+    this._sortKey = th.dataset.datatableColumn || null;
+    this._sortDirection = this._sortKey ? direction : null;
+  }
+  _trigger(name, detail = {}) {
+    this._element.dispatchEvent(
+      new this._window.CustomEvent(`${name}.moo.datatable`, {
+        bubbles: true,
+        detail
+      })
+    );
+  }
+  _sortValue(row, key) {
+    const cell = row.element.querySelector(`:scope > [data-datatable-column="${key}"]`);
+    if (!cell) {
+      return "";
+    }
+    return normalize2(cell.dataset.datatableSortValue ?? cell.textContent);
+  }
+  _matchesFilters(row) {
+    if (this._searchTerm && !row.search.includes(this._searchTerm)) {
+      return false;
+    }
+    for (const [facetKey, selected] of this._facetSelections) {
+      if (selected.size === 0) {
+        continue;
+      }
+      if (!selected.has(row.facets[facetKey])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  _visibleRows() {
+    const filtered = this._rows.filter((row) => this._matchesFilters(row));
+    if (this._sortKey) {
+      const direction = this._sortDirection === "desc" ? -1 : 1;
+      filtered.sort((a, b) => {
+        const aValue = this._sortValue(a, this._sortKey);
+        const bValue = this._sortValue(b, this._sortKey);
+        if (aValue === bValue) {
+          return a.index - b.index;
+        }
+        return aValue > bValue ? direction : -direction;
+      });
+    } else {
+      filtered.sort((a, b) => a.index - b.index);
+    }
+    return filtered;
+  }
+  _pageCount(rowCount) {
+    return Math.max(1, Math.ceil(rowCount / this._pageSize));
+  }
+  _render() {
+    const filtered = this._visibleRows();
+    const pageCount = this._pageCount(filtered.length);
+    this._currentPage = Math.min(Math.max(1, this._currentPage), pageCount);
+    const start = (this._currentPage - 1) * this._pageSize;
+    const pageRows = filtered.slice(start, start + this._pageSize);
+    const pageRowIds = new Set(pageRows.map((row) => row.element.id));
+    this._rows.forEach((row) => {
+      const isVisible = pageRowIds.has(row.element.id);
+      row.element.hidden = !isVisible;
+      if (row.cardElement) {
+        row.cardElement.hidden = !isVisible;
+      }
+    });
+    const currentOrder = Array.from(this._tbody.children).filter((element) => pageRowIds.has(element.id)).map((element) => element.id);
+    const desiredOrder = pageRows.map((row) => row.element.id);
+    const orderChanged = currentOrder.length !== desiredOrder.length || currentOrder.some((id, index) => id !== desiredOrder[index]);
+    if (orderChanged) {
+      pageRows.forEach((row) => {
+        this._tbody.appendChild(row.element);
+        if (this._cards && row.cardElement) {
+          this._cards.appendChild(row.cardElement);
+        }
+      });
+    }
+    this._renderToolbarState();
+    this._renderSortHeaders();
+    this._renderSelection(pageRows);
+    this._renderFrameState(filtered.length);
+    this._renderEmptyState(filtered.length);
+    this._renderPagination(filtered.length, pageCount);
+    this._renderPageSize();
+    this._renderBulkActions();
+  }
+  _renderToolbarState() {
+    const hasSearch = Boolean(this._searchTerm);
+    const hasFacets = Array.from(this._facetSelections.values()).some((set) => set.size > 0);
+    const resetButton = this._element.querySelector("[data-datatable-reset]");
+    if (resetButton) {
+      resetButton.hidden = !(hasSearch || hasFacets);
+    }
+    this._element.querySelectorAll("[data-datatable-facet]").forEach((facetRoot) => {
+      const key = facetRoot.dataset.datatableFacet;
+      const selected = this._facetSelections.get(key) || /* @__PURE__ */ new Set();
+      if (this._visibleFacets.has(key)) {
+        facetRoot.hidden = !this._visibleFacets.get(key);
+      }
+      const trigger = facetRoot.querySelector(".datatable-facet-trigger");
+      trigger?.classList.toggle("datatable-facet-trigger-active", selected.size > 0);
+      const summary = facetRoot.querySelector("[data-datatable-facet-summary]");
+      if (summary) {
+        summary.hidden = selected.size === 0;
+        summary.replaceChildren();
+        if (selected.size > 2) {
+          summary.appendChild(this._createFacetBadge(`${selected.size} selected`));
+        } else {
+          selected.forEach((value) => {
+            const option = facetRoot.querySelector(`[data-datatable-facet-option="${value}"]`);
+            const label = option?.querySelector("[data-datatable-facet-option-label]")?.textContent ?? value;
+            summary.appendChild(this._createFacetBadge(label));
+          });
+        }
+      }
+      facetRoot.querySelectorAll("[data-datatable-facet-option]").forEach((option) => {
+        const isSelected = selected.has(option.dataset.datatableFacetOption);
+        option.classList.toggle("active", isSelected);
+        option.setAttribute("aria-pressed", String(isSelected));
+      });
+    });
+    this._element.querySelectorAll("[data-datatable-filter-toggle]").forEach((toggle) => {
+      const key = toggle.dataset.datatableFilterToggle;
+      const visible = this._visibleFacets.get(key) ?? true;
+      toggle.classList.toggle("active", visible);
+      toggle.setAttribute("aria-pressed", visible ? "true" : "false");
+    });
+    this._element.querySelectorAll("[data-datatable-filter-option]").forEach((option) => {
+      const key = option.dataset.datatableFilterOptionKey;
+      const selected = this._facetSelections.get(key) || /* @__PURE__ */ new Set();
+      const active = selected.has(option.dataset.datatableFilterOption);
+      option.classList.toggle("active", active);
+      option.setAttribute("aria-pressed", active ? "true" : "false");
+    });
+    this._element.querySelectorAll("[data-datatable-filter-group-summary]").forEach((summary) => {
+      const selected = this._facetSelections.get(summary.dataset.datatableFilterGroupSummary) || /* @__PURE__ */ new Set();
+      summary.hidden = selected.size === 0;
+      summary.textContent = selected.size > 0 ? `${selected.size} selected` : "";
+    });
+  }
+  _createFacetBadge(text) {
+    const badge = this._document.createElement("span");
+    badge.className = "datatable-facet-badge";
+    badge.textContent = text;
+    return badge;
+  }
+  _renderSelection(pageRows) {
+    const selectAllControls = Array.from(this._element.querySelectorAll("[data-datatable-select-all]"));
+    pageRows.forEach((row) => {
+      [row.element, row.cardElement].forEach((container) => {
+        const checkbox = container?.querySelector("[data-datatable-select-row]");
+        if (checkbox) {
+          checkbox.checked = this._selectedIds.has(row.element.id);
+        }
+        container?.classList.toggle("datatable-row-selected", this._selectedIds.has(row.element.id));
+      });
+    });
+    const total = pageRows.length;
+    const checked = pageRows.filter((row) => this._selectedIds.has(row.element.id)).length;
+    selectAllControls.forEach((control) => {
+      control.checked = total > 0 && checked === total;
+      control.indeterminate = checked > 0 && checked < total;
+    });
+  }
+  _renderBulkActions() {
+    const bar = this._element.querySelector("[data-datatable-bulk-actions]");
+    if (!bar) {
+      return;
+    }
+    bar.hidden = this._selectedIds.size === 0;
+    const count = bar.querySelector("[data-datatable-bulk-count]");
+    if (count) {
+      count.textContent = String(this._selectedIds.size);
+    }
+  }
+  _renderFrameState(totalRows) {
+    const isEmpty = totalRows === 0;
+    this._element.querySelectorAll(".datatable-frame, .datatable-card-frame").forEach((frame) => {
+      frame.hidden = isEmpty;
+    });
+  }
+  _renderEmptyState(totalRows) {
+    const empty = this._element.querySelector("[data-datatable-empty]");
+    if (!empty) {
+      return;
+    }
+    const hasRows = this._rows.length > 0;
+    empty.hidden = totalRows !== 0;
+    empty.querySelector(".datatable-empty-title")?.replaceChildren(
+      this._document.createTextNode(hasRows ? "No matching results" : "No rows to display")
+    );
+    const copy = empty.querySelector(".datatable-empty-copy");
+    if (copy) {
+      copy.hidden = !hasRows;
+    }
+    const reset = empty.querySelector("[data-datatable-empty-reset]");
+    if (reset) {
+      reset.hidden = !hasRows;
+    }
+  }
+  _sortAriaValue(direction) {
+    if (direction === "asc") {
+      return "ascending";
+    }
+    if (direction === "desc") {
+      return "descending";
+    }
+    return "none";
+  }
+  _renderSortHeaders() {
+    this._element.querySelectorAll("th[data-datatable-column]").forEach((th) => {
+      const trigger = th.querySelector("[data-datatable-sort-key]");
+      if (!trigger) {
+        delete th.dataset.datatableSortState;
+        delete th.dataset.datatableSortDirection;
+        th.removeAttribute("aria-sort");
+        return;
+      }
+      const key = th.dataset.datatableColumn;
+      const direction = key && key === this._sortKey ? this._sortDirection : "none";
+      th.dataset.datatableSortState = direction || "none";
+      th.setAttribute("aria-sort", this._sortAriaValue(direction));
+      if (direction === "asc" || direction === "desc") {
+        th.dataset.datatableSortDirection = direction;
+      } else {
+        delete th.dataset.datatableSortDirection;
+      }
+    });
+  }
+  _renderPagination(totalRows, pageCount) {
+    const first = this._element.querySelector("[data-datatable-page-first]");
+    const prev = this._element.querySelector("[data-datatable-page-prev]");
+    const next = this._element.querySelector("[data-datatable-page-next]");
+    const last = this._element.querySelector("[data-datatable-page-last]");
+    const atStart = this._currentPage <= 1;
+    const atEnd = this._currentPage >= pageCount;
+    [first, prev].forEach((button) => this._setPageItemDisabled(button, atStart));
+    [next, last].forEach((button) => this._setPageItemDisabled(button, atEnd));
+    const summary = this._element.querySelector("[data-datatable-results-summary]");
+    if (summary) {
+      if (totalRows === 0) {
+        summary.textContent = "No results";
+      } else {
+        const start = (this._currentPage - 1) * this._pageSize + 1;
+        const end = Math.min(this._currentPage * this._pageSize, totalRows);
+        summary.textContent = `Showing ${start}-${end} of ${totalRows}`;
+      }
+    }
+    const template = this._element.querySelector("template[data-datatable-page-numbers]");
+    if (!template) {
+      return;
+    }
+    const pages = this._pageWindow(this._currentPage, pageCount);
+    const existing = Array.from(
+      template.parentNode.querySelectorAll(
+        "[data-datatable-page-number], [data-datatable-page-ellipsis]"
+      )
+    );
+    const existingWindow = existing.map(
+      (node) => node.dataset.datatablePageEllipsis === void 0 ? Number(node.dataset.datatablePageNumber) : "\u2026"
+    );
+    const windowChanged = existingWindow.length !== pages.length || existingWindow.some((page, index) => page !== pages[index]);
+    if (windowChanged) {
+      existing.forEach((node) => node.remove());
+      const fragment = this._document.createDocumentFragment();
+      pages.forEach((page) => {
+        const li = this._document.createElement("li");
+        li.className = "page-item";
+        if (page === "\u2026") {
+          li.dataset.datatablePageEllipsis = "";
+          li.innerHTML = '<span class="page-link">\u2026</span>';
+        } else {
+          li.dataset.datatablePageNumber = String(page);
+          const button = this._document.createElement("button");
+          button.type = "button";
+          button.className = "page-link";
+          button.textContent = String(page);
+          button.setAttribute("aria-label", `Go to page ${page}`);
+          button.dataset.datatablePageGo = String(page);
+          li.appendChild(button);
+        }
+        fragment.appendChild(li);
+      });
+      template.parentNode.insertBefore(fragment, template);
+    }
+    template.parentNode.querySelectorAll("[data-datatable-page-number]").forEach((li) => {
+      const isActive = Number(li.dataset.datatablePageNumber) === this._currentPage;
+      li.classList.toggle("active", isActive);
+      if (isActive) {
+        li.setAttribute("aria-current", "page");
+      } else {
+        li.removeAttribute("aria-current");
+      }
+    });
+  }
+  _renderPageSize() {
+    const currentSize = String(this._pageSize);
+    const value = this._element.querySelector("[data-datatable-page-size-value]");
+    if (value) {
+      value.textContent = currentSize;
+    }
+    const select = this._element.querySelector("[data-datatable-page-size-select]");
+    if (select) {
+      select.value = currentSize;
+    }
+    this._element.querySelectorAll("[data-datatable-page-size-option]").forEach((option) => {
+      const active = option.dataset.datatablePageSizeOption === currentSize;
+      option.classList.toggle("active", active);
+      option.setAttribute("aria-pressed", active ? "true" : "false");
+    });
+  }
+  _setPageItemDisabled(button, disabled) {
+    if (!button) {
+      return;
+    }
+    button.disabled = disabled;
+    button.closest(".page-item")?.classList.toggle("disabled", disabled);
+  }
+  _pageWindow(current, total) {
+    if (total <= 7) {
+      return Array.from({ length: total }, (_, index) => index + 1);
+    }
+    const pages = /* @__PURE__ */ new Set([1, total, current - 1, current, current + 1]);
+    const sorted = Array.from(pages).filter((page) => page >= 1 && page <= total).sort((a, b) => a - b);
+    const withEllipsis = [];
+    sorted.forEach((page, index) => {
+      if (index > 0 && page - sorted[index - 1] > 1) {
+        withEllipsis.push("\u2026");
+      }
+      withEllipsis.push(page);
+    });
+    return withEllipsis;
+  }
+  _isColumnFixed(key) {
+    return this._element.querySelector(`th[data-datatable-column="${key}"]`)?.hasAttribute("data-datatable-column-fixed") || false;
+  }
+  _setColumnVisible(key, visible, { syncViewToggle = true } = {}) {
+    if (!visible && this._isColumnFixed(key)) {
+      return;
+    }
+    this._element.querySelectorAll(`[data-datatable-column="${key}"], [data-datatable-detail-column="${key}"]`).forEach((cell) => {
+      cell.classList.toggle("datatable-col-hidden", !visible);
+    });
+    if (syncViewToggle) {
+      this._element.querySelectorAll(`[data-datatable-column-toggle="${key}"]`).forEach((toggle) => {
+        toggle.classList.toggle("active", visible);
+        toggle.setAttribute("aria-pressed", String(visible));
+      });
+    }
+  }
+  _setSort(key, direction) {
+    const validDirection = direction === "asc" || direction === "desc" ? direction : null;
+    this._sortKey = validDirection ? key : null;
+    this._sortDirection = validDirection;
+    this._render();
+    this._trigger("sort", { key: this._sortKey, direction: this._sortDirection });
+  }
+  _handleSortAction(event) {
+    const trigger = event.target.closest("[data-datatable-sort-action]");
+    if (!trigger) {
+      return;
+    }
+    const menu = trigger.closest(".dropdown-menu");
+    const sort = menu?.closest(".datatable-sort") || this._reparentedSortMenus.get(menu)?.owner;
+    if (!sort || !this._element.contains(sort)) {
+      return;
+    }
+    const key = sort.querySelector("[data-datatable-sort-key]")?.dataset.datatableSortKey;
+    if (!key) {
+      return;
+    }
+    const action = trigger.dataset.datatableSortAction;
+    if (action === "hide") {
+      this._setColumnVisible(key, false);
+      return;
+    }
+    this._setSort(key, action);
+  }
+  _handleFacetClick(event) {
+    const option = event.target.closest("[data-datatable-facet-option]");
+    const clear = event.target.closest("[data-datatable-facet-clear]");
+    if (!option && !clear) {
+      return;
+    }
+    const facetRoot = event.target.closest("[data-datatable-facet]");
+    const key = facetRoot?.dataset.datatableFacet;
+    if (!key) {
+      return;
+    }
+    const selected = this._facetSelections.get(key) || /* @__PURE__ */ new Set();
+    if (clear) {
+      selected.clear();
+    } else {
+      const value = option.dataset.datatableFacetOption;
+      if (selected.has(value)) {
+        selected.delete(value);
+      } else {
+        selected.add(value);
+      }
+    }
+    this._facetSelections.set(key, selected);
+    if (this._filterMode === "picker" && selected.size === 0) {
+      this._visibleFacets.set(key, false);
+    }
+    this._currentPage = 1;
+    this._render();
+    this._trigger("filter");
+  }
+  _handleFacetSearch(event) {
+    const search = event.target.closest("[data-datatable-facet-search]");
+    if (!search) {
+      return;
+    }
+    const facetRoot = search.closest("[data-datatable-facet]");
+    const query = normalize2(search.value);
+    facetRoot?.querySelectorAll("[data-datatable-facet-option]").forEach((option) => {
+      const label = normalize2(option.querySelector("[data-datatable-facet-option-label]")?.textContent || option.textContent);
+      option.closest("li")?.classList.toggle("datatable-facet-search-hidden", query.length > 0 && !label.includes(query));
+    });
+  }
+  // Bootstrap's own dropdown keyboard navigation moves focus between
+  // .dropdown-item siblings, but it deliberately leaves focus alone while an
+  // <input> has it (arrow keys inside a text field move the caret, not a
+  // list). A facet's own search box needs an explicit bridge so ArrowDown
+  // hands off to the first result instead of doing nothing.
+  _handleFacetSearchKeydown(event) {
+    if (event.key !== "ArrowDown") {
+      return;
+    }
+    const search = event.target.closest("[data-datatable-facet-search]");
+    if (!search) {
+      return;
+    }
+    const facetRoot = search.closest("[data-datatable-facet]");
+    const options = Array.from(facetRoot?.querySelectorAll("[data-datatable-facet-option]") || []);
+    const firstVisible = options.find(
+      (option) => !option.closest("li")?.classList.contains("datatable-facet-search-hidden")
+    );
+    if (firstVisible) {
+      event.preventDefault();
+      firstVisible.focus();
+    }
+  }
+  _handleFilterOptionClick(event) {
+    const option = event.target.closest("[data-datatable-filter-option]");
+    if (!option) {
+      return;
+    }
+    const key = option.dataset.datatableFilterOptionKey;
+    const value = option.dataset.datatableFilterOption;
+    if (!key || !this._visibleFacets.has(key)) {
+      return;
+    }
+    this._visibleFacets.set(key, true);
+    const selected = this._facetSelections.get(key) || /* @__PURE__ */ new Set();
+    if (selected.has(value)) {
+      selected.delete(value);
+    } else {
+      selected.add(value);
+    }
+    this._facetSelections.set(key, selected);
+    if (selected.size === 0) {
+      this._visibleFacets.set(key, false);
+    }
+    this._currentPage = 1;
+    this._render();
+    this._trigger("filter");
+  }
+  _showFilterPickerPanel(key = null) {
+    this._element.querySelectorAll("[data-datatable-filter-panel]").forEach((panel) => {
+      const isFacetList = panel.dataset.datatableFilterPanel === "facets";
+      const isRequestedOptions = panel.dataset.datatableFilterPanelKey === key;
+      panel.hidden = key ? !isRequestedOptions : !isFacetList;
+    });
+    this._element.querySelector(".datatable-search-filter-menu")?.setAttribute("data-datatable-filter-menu-panel", key ? "options" : "facets");
+  }
+  _handleFilterPickerClick(event) {
+    const group = event.target.closest("[data-datatable-filter-group]");
+    if (group) {
+      const key = group.dataset.datatableFilterGroup;
+      this._showFilterPickerPanel(key);
+      const search = this._element.querySelector(`[data-datatable-filter-option-search="${key}"]`);
+      const option = this._element.querySelector(`[data-datatable-filter-option-key="${key}"]`);
+      (search || option)?.focus({ preventScroll: true });
+      return;
+    }
+    if (event.target.closest("[data-datatable-filter-back]")) {
+      this._showFilterPickerPanel();
+    }
+  }
+  _handleFilterOptionSearch(event) {
+    const search = event.target.closest("[data-datatable-filter-option-search]");
+    if (!search) {
+      return;
+    }
+    const key = search.dataset.datatableFilterOptionSearch;
+    const query = normalize2(search.value);
+    this._element.querySelectorAll(`[data-datatable-filter-option-key="${key}"]`).forEach((option) => {
+      const label = normalize2(option.querySelector("[data-datatable-filter-option-label]")?.textContent || option.textContent);
+      option.closest("li")?.classList.toggle("datatable-filter-option-search-hidden", query.length > 0 && !label.includes(query));
+    });
+  }
+  // Same bridge as _handleFacetSearchKeydown, for the filter-picker's
+  // drill-down option search box.
+  _handleFilterOptionSearchKeydown(event) {
+    if (event.key !== "ArrowDown") {
+      return;
+    }
+    const search = event.target.closest("[data-datatable-filter-option-search]");
+    if (!search) {
+      return;
+    }
+    const key = search.dataset.datatableFilterOptionSearch;
+    const options = Array.from(
+      this._element.querySelectorAll(`[data-datatable-filter-option-key="${key}"]`)
+    );
+    const firstVisible = options.find(
+      (option) => !option.closest("li")?.classList.contains("datatable-filter-option-search-hidden")
+    );
+    if (firstVisible) {
+      event.preventDefault();
+      firstVisible.focus();
+    }
+  }
+  _handleFilterToggleClick(event) {
+    const toggle = event.target.closest("[data-datatable-filter-toggle]");
+    if (!toggle) {
+      return;
+    }
+    const key = toggle.dataset.datatableFilterToggle;
+    if (!key || !this._visibleFacets.has(key)) {
+      return;
+    }
+    const nextVisible = !this._visibleFacets.get(key);
+    this._visibleFacets.set(key, nextVisible);
+    if (!nextVisible) {
+      this._facetSelections.get(key)?.clear();
+      this._currentPage = 1;
+      this._trigger("filter");
+    }
+    this._render();
+  }
+  _handleColumnToggleClick(event) {
+    const toggle = event.target.closest("[data-datatable-column-toggle]");
+    if (!toggle) {
+      return;
+    }
+    const key = toggle.dataset.datatableColumnToggle;
+    const visible = toggle.getAttribute("aria-pressed") === "true";
+    this._setColumnVisible(key, visible, { syncViewToggle: false });
+  }
+  _handleReset() {
+    const search = this._element.querySelector("[data-datatable-search]");
+    if (search) {
+      search.value = "";
+    }
+    this._searchTerm = "";
+    this._facetSelections.forEach((selected) => selected.clear());
+    if (this._filterMode === "picker") {
+      this._visibleFacets.forEach((value, key) => {
+        this._visibleFacets.set(key, false);
+      });
+    }
+    this._currentPage = 1;
+    this._render();
+    this._trigger("filter");
+  }
+  _handleSelectAll(event) {
+    const checked = event.target.checked;
+    const filtered = this._visibleRows();
+    const start = (this._currentPage - 1) * this._pageSize;
+    const pageRows = filtered.slice(start, start + this._pageSize);
+    pageRows.forEach((row) => {
+      if (checked) {
+        this._selectedIds.add(row.element.id);
+      } else {
+        this._selectedIds.delete(row.element.id);
+      }
+    });
+    this._render();
+    this._trigger("select");
+  }
+  _handleSelectRow(event) {
+    const checkbox = event.target.closest("[data-datatable-select-row]");
+    if (!checkbox) {
+      return;
+    }
+    const row = checkbox.closest("[data-datatable-row]");
+    const card = checkbox.closest("[data-datatable-card]");
+    const rowId = row?.id || card?.dataset.datatableCardFor;
+    if (!rowId) {
+      return;
+    }
+    if (checkbox.checked) {
+      this._selectedIds.add(rowId);
+    } else {
+      this._selectedIds.delete(rowId);
+    }
+    this._render();
+    this._trigger("select");
+  }
+  _handleBulkClick(event) {
+    if (event.target.closest("[data-datatable-bulk-clear]")) {
+      this._clearSelection();
+      return;
+    }
+    const updateTrigger = event.target.closest("[data-datatable-bulk-update]");
+    if (updateTrigger) {
+      const key = updateTrigger.dataset.datatableBulkUpdate;
+      const value = updateTrigger.dataset.datatableBulkUpdateValue;
+      this._applyBulkUpdate(key, value, updateTrigger);
+      return;
+    }
+    const actionTrigger = event.target.closest("[data-datatable-bulk-action]");
+    if (actionTrigger) {
+      const action = actionTrigger.dataset.datatableBulkAction;
+      if (action === "delete") {
+        this._applyBulkDelete();
+        return;
+      }
+      this._trigger(`bulk-${action}`, { ids: this.getSelectedIds() });
+    }
+  }
+  _clearSelection() {
+    this._hideBulkTooltips({ blur: true });
+    this._selectedIds.clear();
+    this._render();
+    this._trigger("select");
+  }
+  _applyBulkUpdate(key, value, trigger) {
+    const icon = trigger.querySelector("svg")?.cloneNode(true);
+    const label = trigger.querySelector("span")?.textContent?.trim() ?? value;
+    this._selectedIds.forEach((id) => {
+      const row = this._rows.find((candidate) => candidate.element.id === id);
+      if (!row) {
+        return;
+      }
+      row.element.setAttribute(`data-datatable-facet-${key}`, value);
+      row.facets[key] = value;
+      const cell = row.element.querySelector(`[data-datatable-column="${key}"]`);
+      if (!cell) {
+        return;
+      }
+      const labelTarget = cell.querySelector("[data-datatable-cell-label]");
+      if (labelTarget) {
+        labelTarget.textContent = label;
+      } else {
+        cell.textContent = label;
+      }
+      const currentIcon = cell.querySelector("svg");
+      if (currentIcon && icon) {
+        currentIcon.replaceWith(icon.cloneNode(true));
+      }
+      const cardValue = row.cardElement?.querySelector(`[data-datatable-detail-column="${key}"] .datatable-card-value`);
+      if (cardValue) {
+        cardValue.innerHTML = cell.innerHTML;
+      }
+    });
+    this._render();
+    this._trigger("bulk-update", { key, value, ids: this.getSelectedIds() });
+  }
+  _applyBulkDelete() {
+    const ids = this.getSelectedIds();
+    ids.forEach((id) => {
+      const index = this._rows.findIndex((row) => row.element.id === id);
+      if (index !== -1) {
+        this._rows[index].element.remove();
+        this._rows[index].cardElement?.remove();
+        this._rows.splice(index, 1);
+      }
+    });
+    this._selectedIds.clear();
+    this._render();
+    this._trigger("bulk-delete", { ids });
+  }
+  _handlePageClick(event) {
+    const goButton = event.target.closest("[data-datatable-page-go]");
+    if (goButton) {
+      this._currentPage = Number(goButton.dataset.datatablePageGo);
+      this._render();
+      return;
+    }
+    if (event.target.closest("[data-datatable-page-first]")) {
+      this._currentPage = 1;
+      this._render();
+      return;
+    }
+    if (event.target.closest("[data-datatable-page-prev]")) {
+      this._currentPage -= 1;
+      this._render();
+      return;
+    }
+    if (event.target.closest("[data-datatable-page-next]")) {
+      this._currentPage += 1;
+      this._render();
+      return;
+    }
+    if (event.target.closest("[data-datatable-page-last]")) {
+      this._currentPage = this._pageCount(this._visibleRows().length);
+      this._render();
+    }
+  }
+  _setPageSize(value) {
+    const nextPageSize = Number(value);
+    if (!Number.isFinite(nextPageSize) || nextPageSize <= 0) {
+      return;
+    }
+    this._pageSize = nextPageSize;
+    this._element.dataset.datatablePageSize = String(nextPageSize);
+    this._currentPage = 1;
+    this._render();
+  }
+  _bindEvents() {
+    const search = this._element.querySelector("[data-datatable-search]");
+    this._listen(search, "input", (event) => {
+      this._searchTerm = normalize2(event.target.value);
+      this._currentPage = 1;
+      this._render();
+      this._trigger("filter");
+    });
+    this._listen(search, "keydown", (event) => {
+      if (event.key !== "Enter") {
+        return;
+      }
+      event.preventDefault();
+      const trigger = this._element.querySelector("[data-datatable-filter-menu-trigger]");
+      const Dropdown = this._bootstrap("Dropdown");
+      if (trigger && Dropdown) {
+        Dropdown.getOrCreateInstance(trigger).hide();
+      }
+    });
+    this._listen(this._element, "click", (event) => {
+      this._handleFilterPickerClick(event);
+      this._handleFilterOptionClick(event);
+      this._handleFilterToggleClick(event);
+      this._handleFacetClick(event);
+      this._handleColumnToggleClick(event);
+      this._handlePageClick(event);
+      this._handleBulkClick(event);
+      if (event.target.closest("[data-datatable-empty-reset]")) {
+        this._handleReset();
+      }
+      if (event.target.closest("[data-datatable-select-row]")) {
+        this._handleSelectRow(event);
+      }
+    });
+    this._listen(this._document, "click", (event) => this._handleSortAction(event));
+    this._listen(this._document, "keydown", (event) => {
+      if (event.key === "Escape" && this._selectedIds.size > 0) {
+        this._clearSelection();
+      }
+    });
+    this._listen(this._element, "show.bs.dropdown", (event) => {
+      this._reparentRowActionMenu(event.target);
+      this._reparentSortMenu(event.target);
+      const tooltip = this._bootstrap("Tooltip")?.getInstance(event.target);
+      tooltip?.hide();
+      tooltip?.disable();
+    });
+    this._listen(this._element, "hidden.bs.dropdown", (event) => {
+      this._restoreRowActionMenuForTrigger(event.target);
+      this._restoreSortMenuForTrigger(event.target);
+      this._bootstrap("Tooltip")?.getInstance(event.target)?.enable();
+      if (event.target.matches("[data-datatable-filter-menu-trigger]")) {
+        this._showFilterPickerPanel();
+      }
+    });
+    this._element.querySelectorAll("[data-datatable-filter-option-search]").forEach((searchInput) => {
+      this._listen(searchInput, "input", (event) => this._handleFilterOptionSearch(event));
+      this._listen(searchInput, "keydown", (event) => this._handleFilterOptionSearchKeydown(event));
+    });
+    this._element.querySelectorAll("[data-datatable-facet-search]").forEach((searchInput) => {
+      this._listen(searchInput, "input", (event) => this._handleFacetSearch(event));
+      this._listen(searchInput, "keydown", (event) => this._handleFacetSearchKeydown(event));
+    });
+    const resetButton = this._element.querySelector("[data-datatable-reset]");
+    this._listen(resetButton, "click", () => this._handleReset());
+    this._element.querySelectorAll("[data-datatable-select-all]").forEach((selectAll) => {
+      this._listen(selectAll, "change", (event) => this._handleSelectAll(event));
+    });
+    const pageSizeSelect = this._element.querySelector("[data-datatable-page-size-select]");
+    this._listen(pageSizeSelect, "change", (event) => this._setPageSize(event.target.value));
+    this._element.querySelectorAll("[data-datatable-page-size-option]").forEach((option) => {
+      this._listen(option, "click", () => {
+        this._setPageSize(option.dataset.datatablePageSizeOption);
+      });
+    });
+  }
+};
+
+// src/js/components/datepicker.js
+var datepickerInstances = /* @__PURE__ */ new WeakMap();
+var calendarInstances = /* @__PURE__ */ new WeakMap();
+var rangePickerInstances = /* @__PURE__ */ new WeakMap();
+var DEFAULT_LOCALE = "en";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var WEEKDAY_BASE_SUNDAY = new Date(2026, 7, 16);
+var POPOVER_VIEWPORT_PADDING = 8;
+function isElement(element, selector) {
+  return element?.nodeType === 1 && Boolean(element.matches?.(selector));
+}
+function addListener(listeners, target, type, handler, options) {
+  if (!target) return;
+  target.addEventListener(type, handler, options);
+  listeners.push({ target, type, handler, options });
+}
+function removeListeners(listeners) {
+  listeners.forEach(({ target, type, handler, options }) => {
+    target.removeEventListener(type, handler, options);
+  });
+  listeners.length = 0;
+}
+function parseDate(value) {
+  if (!value) return null;
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) return null;
+    return new Date(value.getFullYear(), value.getMonth(), value.getDate());
+  }
+  if (typeof value === "number") {
+    return parseDate(new Date(value));
+  }
+  const text = String(value).trim();
+  const iso = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (iso) {
+    const date = new Date(Number(iso[1]), Number(iso[2]) - 1, Number(iso[3]));
+    if (date.getFullYear() === Number(iso[1]) && date.getMonth() === Number(iso[2]) - 1 && date.getDate() === Number(iso[3])) {
+      return date;
+    }
+    return null;
+  }
+  return null;
+}
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function toIso(date) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function compareDates(left, right) {
+  if (!left || !right) return 0;
+  return left.getTime() - right.getTime();
+}
+function sameDate(left, right) {
+  return Boolean(left && right && toIso(left) === toIso(right));
+}
+function addDays(date, amount) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + amount);
+}
+function addMonths(date, amount) {
+  const targetStart = new Date(date.getFullYear(), date.getMonth() + amount, 1);
+  const targetDay = Math.min(
+    date.getDate(),
+    daysInMonth(targetStart.getFullYear(), targetStart.getMonth())
+  );
+  return new Date(targetStart.getFullYear(), targetStart.getMonth(), targetDay);
+}
+function firstDayOfWeek(locale = DEFAULT_LOCALE) {
+  try {
+    if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+      const intlLocale = new Intl.Locale(locale || DEFAULT_LOCALE);
+      const weekInfo = intlLocale.weekInfo || intlLocale.getWeekInfo?.();
+      if (Number.isInteger(weekInfo?.firstDay)) {
+        return weekInfo.firstDay % 7;
+      }
+    }
+  } catch {
+  }
+  return 0;
+}
+function weekdayDates(locale = DEFAULT_LOCALE) {
+  const firstDay = firstDayOfWeek(locale);
+  return Array.from({ length: 7 }, (_, offset) => addDays(WEEKDAY_BASE_SUNDAY, (firstDay + offset) % 7));
+}
+function startOfMonth(date) {
+  return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+function daysInMonth(year, month) {
+  return new Date(year, month + 1, 0).getDate();
+}
+function limitToRange(date, minDate, maxDate) {
+  if (minDate && compareDates(date, minDate) < 0) return new Date(minDate);
+  if (maxDate && compareDates(date, maxDate) > 0) return new Date(maxDate);
+  return date;
+}
+function parseDateList(value) {
+  if (Array.isArray(value)) {
+    return value.map(parseDate).filter(Boolean).map(toIso);
+  }
+  if (!value) return [];
+  const text = String(value).trim();
+  if (!text) return [];
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) {
+      return parsed.map(parseDate).filter(Boolean).map(toIso);
+    }
+  } catch {
+  }
+  return text.split(",").map(parseDate).filter(Boolean).map(toIso);
+}
+function formatDisplay(date, locale = DEFAULT_LOCALE) {
+  if (!date) return "";
+  return new Intl.DateTimeFormat(locale || DEFAULT_LOCALE, {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  }).format(date);
+}
+function formatMonthYear(date, locale = DEFAULT_LOCALE) {
+  return new Intl.DateTimeFormat(locale || DEFAULT_LOCALE, {
+    month: "long",
+    year: "numeric"
+  }).format(date);
+}
+function formatReturn(date, format, locale = DEFAULT_LOCALE) {
+  if (!date) return void 0;
+  if (format === "yyyy-mm-dd") return toIso(date);
+  if (format) return formatDisplay(date, locale);
+  return new Date(date);
+}
+function readDataConfig(element, config = {}) {
+  const dataset = element.dataset || {};
+  const locale = config.locale || dataset.datepickerLocale || dataset.calendarLocale || DEFAULT_LOCALE;
+  const minDate = parseDate(config.minDate || dataset.calendarMinDate || dataset.datepickerMinDate);
+  const maxDate = parseDate(config.maxDate || dataset.calendarMaxDate || dataset.datepickerMaxDate);
+  return {
+    locale,
+    mode: config.mode || dataset.calendarMode || dataset.datepickerMode || "single",
+    placeholder: config.placeholder || dataset.datepickerPlaceholder || "Pick a date",
+    value: config.value || dataset.calendarValue || dataset.datepickerValue || "",
+    startValue: config.startValue || dataset.calendarStartValue || dataset.datepickerStartValue || "",
+    endValue: config.endValue || dataset.calendarEndValue || dataset.datepickerEndValue || "",
+    minDate,
+    maxDate,
+    disabledDates: parseDateList(config.disabledDates || dataset.calendarDisabledDates || dataset.datepickerDisabledDates),
+    captionLayout: config.captionLayout || dataset.calendarCaptionLayout || "",
+    showPresets: config.showPresets ?? (dataset.calendarShowPresets === "true" || dataset.datepickerShowPresets === "true")
+  };
+}
+function dispatch(element, window2, name, detail = {}, cancelable = false) {
+  return element.dispatchEvent(
+    new window2.CustomEvent(name, {
+      bubbles: true,
+      cancelable,
+      detail
+    })
+  );
+}
+function setHiddenValue(input, value) {
+  if (!input) return;
+  input.value = value || "";
+}
+function setValidationValue(input, value) {
+  if (!input) return;
+  input.value = value || "";
+}
+function setDatepickerInvalid(element, trigger, invalid) {
+  if (invalid) {
+    element.dataset.invalid = "true";
+    trigger.classList.add("is-invalid");
+    trigger.setAttribute("aria-invalid", "true");
+    return;
+  }
+  delete element.dataset.invalid;
+  trigger.classList.remove("is-invalid");
+  trigger.removeAttribute("aria-invalid");
+}
+function syncDatepickerValidation(element, trigger, validationInput) {
+  if (validationInput?.required && validationInput.checkValidity()) {
+    setDatepickerInvalid(element, trigger, false);
+  }
+}
+function clamp(value, min, max) {
+  if (max < min) return min;
+  return Math.min(Math.max(value, min), max);
+}
+function cssPixelValue(element, property, fallback) {
+  const view = element?.ownerDocument?.defaultView || window;
+  const value = element ? view.getComputedStyle(element).getPropertyValue(property).trim() : "";
+  const parsed = Number.parseFloat(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  if (value.endsWith("rem")) {
+    const root = element.ownerDocument.documentElement;
+    const fontSize = Number.parseFloat(view.getComputedStyle(root).fontSize);
+    return Number.isFinite(fontSize) ? parsed * fontSize : fallback;
+  }
+  if (value.endsWith("em")) {
+    const fontSize = Number.parseFloat(view.getComputedStyle(element).fontSize);
+    return Number.isFinite(fontSize) ? parsed * fontSize : fallback;
+  }
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function datepickerContains(instance, target) {
+  return Boolean(
+    target && (instance._element.contains(target) || instance._popover.contains(target))
+  );
+}
+function syncPortaledPopoverContext(instance) {
+  const owner = findThemeOwner(instance._trigger);
+  const theme = owner?.getAttribute("data-bs-theme") || null;
+  const direction = instance._document.defaultView?.getComputedStyle(
+    instance._trigger
+  ).direction;
+  if (theme) {
+    instance._popover.setAttribute("data-bs-theme", theme);
+  } else {
+    instance._popover.removeAttribute("data-bs-theme");
+  }
+  if (direction === "ltr" || direction === "rtl") {
+    instance._popover.setAttribute("dir", direction);
+  } else {
+    instance._popover.removeAttribute("dir");
+  }
+}
+function portalDatepickerPopover(instance) {
+  const popover = instance._popover;
+  const owner = findThemeOwner(instance._trigger);
+  const portalRoot = ownerPortalRoot(owner) || instance._document.body || instance._document.documentElement;
+  if (!portalRoot) {
+    return;
+  }
+  if (instance._popoverPortal?.portal === portalRoot && popover.parentElement === portalRoot) {
+    syncPortaledPopoverContext(instance);
+    return;
+  }
+  restoreDatepickerPopover(instance);
+  instance._popoverPortal = {
+    parent: popover.parentNode,
+    nextSibling: popover.nextSibling,
+    owner,
+    portal: portalRoot,
+    hadTheme: popover.hasAttribute("data-bs-theme"),
+    theme: popover.getAttribute("data-bs-theme"),
+    hadDirection: popover.hasAttribute("dir"),
+    direction: popover.getAttribute("dir")
+  };
+  portalRoot.appendChild(popover);
+  syncPortaledPopoverContext(instance);
+}
+function restoreDatepickerPopover(instance) {
+  const portal = instance._popoverPortal;
+  if (!portal) return;
+  const popover = instance._popover;
+  if (portal.owner?.isConnected === false) {
+    popover.remove();
+  } else if (portal.parent?.isConnected) {
+    if (portal.nextSibling?.parentNode === portal.parent) {
+      portal.parent.insertBefore(popover, portal.nextSibling);
+    } else {
+      portal.parent.appendChild(popover);
+    }
+  } else {
+    popover.remove();
+  }
+  if (portal.hadTheme) {
+    popover.setAttribute("data-bs-theme", portal.theme);
+  } else {
+    popover.removeAttribute("data-bs-theme");
+  }
+  if (portal.hadDirection) {
+    popover.setAttribute("dir", portal.direction);
+  } else {
+    popover.removeAttribute("dir");
+  }
+  instance._popoverPortal = null;
+}
+function positionDatepickerPopover(trigger, popover, root, window2) {
+  const offset = cssPixelValue(root, "--moo-datepicker-popover-offset", 6);
+  const direction = getComputedStyle(trigger).direction;
+  popover.style.position = "fixed";
+  popover.style.inset = "auto";
+  popover.style.right = "auto";
+  popover.style.bottom = "auto";
+  popover.style.maxHeight = "";
+  popover.style.overflowY = "";
+  const triggerRect = trigger.getBoundingClientRect();
+  const popoverRect = popover.getBoundingClientRect();
+  const viewportWidth = window2.innerWidth;
+  const viewportHeight = window2.innerHeight;
+  const preferredLeft = direction === "rtl" ? triggerRect.right - popoverRect.width : triggerRect.left;
+  const left = clamp(
+    preferredLeft,
+    POPOVER_VIEWPORT_PADDING,
+    viewportWidth - popoverRect.width - POPOVER_VIEWPORT_PADDING
+  );
+  const spaceBelow = triggerRect.bottom + offset <= viewportHeight ? viewportHeight - triggerRect.bottom - offset - POPOVER_VIEWPORT_PADDING : 0;
+  const spaceAbove = triggerRect.top - offset - POPOVER_VIEWPORT_PADDING;
+  const placeAbove = popoverRect.height > spaceBelow && spaceAbove > spaceBelow;
+  const placement = placeAbove ? "top" : "bottom";
+  const availableHeight = Math.max(
+    0,
+    placeAbove ? spaceAbove : spaceBelow
+  );
+  const renderedHeight = Math.min(popoverRect.height, availableHeight);
+  const top = placeAbove ? triggerRect.top - offset - renderedHeight : triggerRect.bottom + offset;
+  popover.style.left = `${Math.round(left)}px`;
+  popover.style.top = `${Math.round(clamp(
+    top,
+    POPOVER_VIEWPORT_PADDING,
+    viewportHeight - renderedHeight - POPOVER_VIEWPORT_PADDING
+  ))}px`;
+  if (availableHeight > 0) {
+    popover.style.maxHeight = `${Math.floor(availableHeight)}px`;
+    popover.style.overflowY = "auto";
+  }
+  popover.dataset.datepickerPlacement = placement;
+}
+function clearDatepickerPopoverPosition(popover) {
+  popover.style.position = "";
+  popover.style.inset = "";
+  popover.style.right = "";
+  popover.style.bottom = "";
+  popover.style.left = "";
+  popover.style.top = "";
+  popover.style.maxHeight = "";
+  popover.style.overflowY = "";
+  delete popover.dataset.datepickerPlacement;
+}
+function startDatepickerPopoverPositioning(instance) {
+  removeListeners(instance._floatingListeners);
+  portalDatepickerPopover(instance);
+  const update = () => {
+    if (instance.isOpen()) {
+      positionDatepickerPopover(
+        instance._trigger,
+        instance._popover,
+        instance._element,
+        instance._window
+      );
+    }
+  };
+  instance._positionPopover = update;
+  update();
+  addListener(instance._floatingListeners, instance._window, "resize", update);
+  addListener(instance._floatingListeners, instance._window, "scroll", update, true);
+  addListener(instance._floatingListeners, instance._document, "scroll", update, true);
+}
+function stopDatepickerPopoverPositioning(instance) {
+  removeListeners(instance._floatingListeners);
+  instance._positionPopover = null;
+  clearDatepickerPopoverPosition(instance._popover);
+  restoreDatepickerPopover(instance);
+}
+function monthName(monthIndex, locale) {
+  return new Intl.DateTimeFormat(locale || DEFAULT_LOCALE, { month: "short" }).format(new Date(2026, monthIndex, 1));
+}
+function yearOptions(minDate, maxDate, viewDate) {
+  const min = minDate ? minDate.getFullYear() : viewDate.getFullYear() - 100;
+  const max = maxDate ? maxDate.getFullYear() : viewDate.getFullYear() + 20;
+  const years = [];
+  for (let year = min; year <= max; year += 1) {
+    years.push(year);
+  }
+  return years;
+}
+function createIcon(document2, glyph, className = "") {
+  const span = document2.createElement("span");
+  span.className = className;
+  span.setAttribute("aria-hidden", "true");
+  span.textContent = glyph;
+  return span;
+}
+var MooCalendar = class _MooCalendar {
+  static getInstance(element) {
+    return element?.nodeType === 1 ? calendarInstances.get(element) || null : null;
+  }
+  static getOrCreateInstance(element, config = {}) {
+    return _MooCalendar.getInstance(element) || new _MooCalendar(element, config);
+  }
+  constructor(element, config = {}) {
+    if (!isElement(element, "[data-calendar]")) {
+      throw new TypeError("MooCalendar requires a [data-calendar] root element.");
+    }
+    const existing = calendarInstances.get(element);
+    if (existing) return existing;
+    this._element = element;
+    this._document = element.ownerDocument;
+    this._window = this._document.defaultView || window;
+    this._listeners = [];
+    this._disposed = false;
+    this._config = readDataConfig(element, config);
+    this._mode = this._config.mode === "range" ? "range" : "single";
+    this._disabledDates = new Set(this._config.disabledDates);
+    this._selectedDate = parseDate(this._config.value);
+    this._rangeStart = parseDate(this._config.startValue);
+    this._rangeEnd = parseDate(this._config.endValue);
+    this._activeDate = this._nearestEnabledDate(
+      this._rangeStart || this._selectedDate || /* @__PURE__ */ new Date()
+    );
+    this._viewDate = startOfMonth(this._activeDate);
+    this._captionId = this._element.id ? `${this._element.id}-caption` : `moo-calendar-caption-${Math.random().toString(36).slice(2)}`;
+    this._labelId = this._element.id ? `${this._element.id}-label` : `moo-calendar-label-${Math.random().toString(36).slice(2)}`;
+    calendarInstances.set(element, this);
+    this._bindEvents();
+    this._render();
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    removeListeners(this._listeners);
+    this._element.replaceChildren();
+    if (calendarInstances.get(this._element) === this) {
+      calendarInstances.delete(this._element);
+    }
+  }
+  getDate(format = void 0) {
+    if (this._mode === "range") {
+      return this.getDates(format);
+    }
+    return formatReturn(this._selectedDate, format, this._config.locale);
+  }
+  getDates(format = void 0) {
+    return [
+      formatReturn(this._rangeStart, format, this._config.locale),
+      formatReturn(this._rangeEnd, format, this._config.locale)
+    ];
+  }
+  setDate(date, options = {}) {
+    if (this._mode !== "single") return false;
+    const parsed = parseDate(date);
+    if (!parsed || this._isDisabled(parsed)) return false;
+    this._selectedDate = parsed;
+    this._activeDate = parsed;
+    this._viewDate = startOfMonth(parsed);
+    this._render();
+    if (options.emit !== false) {
+      this._emitChange(true);
+    }
+    return true;
+  }
+  setDates(startDate, endDate, options = {}) {
+    if (this._mode !== "range") return false;
+    const start = parseDate(startDate);
+    const end = parseDate(endDate);
+    if (start && this._isDisabled(start)) return false;
+    if (end && this._isDisabled(end)) return false;
+    this._rangeStart = start;
+    this._rangeEnd = end;
+    if (this._rangeStart && this._rangeEnd && compareDates(this._rangeStart, this._rangeEnd) > 0) {
+      [this._rangeStart, this._rangeEnd] = [this._rangeEnd, this._rangeStart];
+    }
+    this._activeDate = this._rangeEnd || this._rangeStart || this._activeDate;
+    this._viewDate = startOfMonth(this._activeDate);
+    this._render();
+    if (options.emit !== false) {
+      this._emitChange(Boolean(this._rangeStart && this._rangeEnd));
+    }
+    return true;
+  }
+  clear(options = {}) {
+    this._selectedDate = null;
+    this._rangeStart = null;
+    this._rangeEnd = null;
+    this._render();
+    if (options.emit !== false) {
+      this._emitChange(false);
+    }
+  }
+  focusActiveDay() {
+    this._dayButton(this._activeDate)?.focus();
+  }
+  _bindEvents() {
+    addListener(this._listeners, this._element, "click", (event) => {
+      const target = event.target;
+      const day = target.closest?.("[data-calendar-day]");
+      const prev = target.closest?.("[data-calendar-prev]");
+      const next = target.closest?.("[data-calendar-next]");
+      const preset = target.closest?.("[data-calendar-preset]");
+      if (prev) {
+        this._changeMonth(-1, true);
+      } else if (next) {
+        this._changeMonth(1, true);
+      } else if (preset) {
+        this._selectPreset(preset.dataset.calendarPreset);
+      } else if (day) {
+        this._selectDate(parseDate(day.dataset.calendarDay), true);
+      }
+    });
+    addListener(this._listeners, this._element, "keydown", (event) => {
+      const day = event.target.closest?.("[data-calendar-day]");
+      if (!day) return;
+      this._handleDayKeydown(event);
+    });
+    addListener(this._listeners, this._element, "change", (event) => {
+      if (event.target.matches?.("[data-calendar-month]")) {
+        this._setActiveMonth(
+          this._viewDate.getFullYear(),
+          Number(event.target.value),
+          true
+        );
+      }
+      if (event.target.matches?.("[data-calendar-year]")) {
+        this._setActiveMonth(
+          Number(event.target.value),
+          this._viewDate.getMonth(),
+          true
+        );
+      }
+    });
+  }
+  _emitChange(complete) {
+    dispatch(this._element, this._window, "change.moo.calendar", {
+      date: this._selectedDate ? new Date(this._selectedDate) : void 0,
+      value: this._selectedDate ? toIso(this._selectedDate) : "",
+      startDate: this._rangeStart ? new Date(this._rangeStart) : void 0,
+      endDate: this._rangeEnd ? new Date(this._rangeEnd) : void 0,
+      startValue: this._rangeStart ? toIso(this._rangeStart) : "",
+      endValue: this._rangeEnd ? toIso(this._rangeEnd) : "",
+      complete
+    });
+  }
+  _changeMonth(amount, focus) {
+    const nextView = startOfMonth(addMonths(this._viewDate, amount));
+    this._setActiveMonth(nextView.getFullYear(), nextView.getMonth(), focus);
+  }
+  _setActiveMonth(year, month, focus = false) {
+    const activeDay = Math.min(
+      this._activeDate.getDate(),
+      daysInMonth(year, month)
+    );
+    this._activeDate = this._nearestEnabledDate(new Date(year, month, activeDay));
+    this._viewDate = startOfMonth(this._activeDate);
+    this._render();
+    if (focus) this.focusActiveDay();
+  }
+  _selectPreset(name) {
+    if (!name) return;
+    const today = /* @__PURE__ */ new Date();
+    const offsets = {
+      today: 0,
+      tomorrow: 1,
+      "in-3-days": 3,
+      "in-a-week": 7,
+      "in-2-weeks": 14
+    };
+    if (!(name in offsets)) return;
+    this._selectDate(addDays(today, offsets[name]), true);
+  }
+  _handleDayKeydown(event) {
+    const focusedDay = event.target.closest?.("[data-calendar-day]");
+    const focusedDate = parseDate(focusedDay?.dataset?.calendarDay);
+    if (focusedDate && compareDates(focusedDate, this._activeDate) !== 0) {
+      this._activeDate = focusedDate;
+    }
+    const keyMap = {
+      ArrowRight: 1,
+      ArrowLeft: -1,
+      ArrowDown: 7,
+      ArrowUp: -7
+    };
+    let nextDate = null;
+    if (event.key in keyMap) {
+      nextDate = addDays(this._activeDate, keyMap[event.key]);
+    } else if (event.key === "Home") {
+      const weekStart = firstDayOfWeek(this._config.locale);
+      const weekdayOffset = (this._activeDate.getDay() - weekStart + 7) % 7;
+      nextDate = addDays(this._activeDate, -weekdayOffset);
+    } else if (event.key === "End") {
+      const weekStart = firstDayOfWeek(this._config.locale);
+      const weekdayOffset = (this._activeDate.getDay() - weekStart + 7) % 7;
+      nextDate = addDays(this._activeDate, 6 - weekdayOffset);
+    } else if (event.key === "PageUp") {
+      nextDate = addMonths(this._activeDate, -1);
+    } else if (event.key === "PageDown") {
+      nextDate = addMonths(this._activeDate, 1);
+    } else if (event.key === "Enter" || event.key === " " || event.key === "Spacebar") {
+      event.preventDefault();
+      this._selectDate(this._activeDate, true);
+      return;
+    } else {
+      return;
+    }
+    event.preventDefault();
+    this._setActiveDate(nextDate, true, compareDates(nextDate, this._activeDate) < 0 ? -1 : 1);
+  }
+  _setActiveDate(date, focus = false, step = 0) {
+    const nextDate = step === 0 ? this._nearestEnabledDate(date) : this._nextEnabledDate(date, step);
+    this._activeDate = nextDate;
+    this._viewDate = startOfMonth(nextDate);
+    this._render();
+    if (focus) this.focusActiveDay();
+  }
+  _nextEnabledDate(date, step) {
+    let candidate = parseDate(date);
+    if (!candidate) return this._activeDate;
+    const dayStep = step < 0 ? -1 : 1;
+    for (let guard = 0; guard < 366; guard += 1) {
+      if (this._config.minDate && compareDates(candidate, this._config.minDate) < 0) break;
+      if (this._config.maxDate && compareDates(candidate, this._config.maxDate) > 0) break;
+      if (!this._isDisabled(candidate)) return candidate;
+      candidate = addDays(candidate, dayStep);
+    }
+    return this._activeDate;
+  }
+  _nearestEnabledDate(date) {
+    const preferred = limitToRange(
+      parseDate(date) || /* @__PURE__ */ new Date(),
+      this._config.minDate,
+      this._config.maxDate
+    );
+    if (!this._isDisabled(preferred)) return preferred;
+    const monthStart = startOfMonth(preferred);
+    const monthLength = daysInMonth(monthStart.getFullYear(), monthStart.getMonth());
+    for (let day = 1; day <= monthLength; day += 1) {
+      const candidate = new Date(monthStart.getFullYear(), monthStart.getMonth(), day);
+      if (!this._isDisabled(candidate)) return candidate;
+    }
+    return preferred;
+  }
+  _selectDate(date, emit) {
+    if (!date || this._isDisabled(date)) return;
+    this._activeDate = date;
+    this._viewDate = startOfMonth(date);
+    if (this._mode === "range") {
+      if (!this._rangeStart || this._rangeEnd || compareDates(date, this._rangeStart) < 0) {
+        this._rangeStart = date;
+        this._rangeEnd = null;
+      } else {
+        this._rangeEnd = date;
+      }
+      this._render();
+      if (emit) this._emitChange(Boolean(this._rangeStart && this._rangeEnd));
+      return;
+    }
+    this._selectedDate = date;
+    this._render();
+    if (emit) this._emitChange(true);
+  }
+  _isDisabled(date) {
+    if (!date) return true;
+    if (this._config.minDate && compareDates(date, this._config.minDate) < 0) return true;
+    if (this._config.maxDate && compareDates(date, this._config.maxDate) > 0) return true;
+    return this._disabledDates.has(toIso(date));
+  }
+  _isSelected(date) {
+    if (this._mode === "range") {
+      return sameDate(date, this._rangeStart) || sameDate(date, this._rangeEnd);
+    }
+    return sameDate(date, this._selectedDate);
+  }
+  _rangeState(date) {
+    if (this._mode !== "range" || !this._rangeStart) return "";
+    if (sameDate(date, this._rangeStart)) return "start";
+    if (sameDate(date, this._rangeEnd)) return "end";
+    if (this._rangeStart && this._rangeEnd && compareDates(date, this._rangeStart) > 0 && compareDates(date, this._rangeEnd) < 0) {
+      return "middle";
+    }
+    return "";
+  }
+  _dayButton(date) {
+    return this._element.querySelector(`[data-calendar-day="${toIso(date)}"]`);
+  }
+  _render() {
+    const document2 = this._document;
+    const fragment = document2.createDocumentFragment();
+    const header = document2.createElement("div");
+    header.className = "moo-calendar__header";
+    const prev = document2.createElement("button");
+    prev.className = "btn btn-ghost btn-icon-sm moo-calendar__nav";
+    prev.type = "button";
+    prev.dataset.calendarPrev = "true";
+    prev.setAttribute("aria-label", "Previous month");
+    prev.appendChild(createIcon(document2, "\u2039", "moo-calendar__nav-icon"));
+    const next = document2.createElement("button");
+    next.className = "btn btn-ghost btn-icon-sm moo-calendar__nav";
+    next.type = "button";
+    next.dataset.calendarNext = "true";
+    next.setAttribute("aria-label", "Next month");
+    next.appendChild(createIcon(document2, "\u203A", "moo-calendar__nav-icon"));
+    const caption = document2.createElement("div");
+    caption.className = "moo-calendar__caption";
+    caption.id = this._captionId;
+    caption.setAttribute("aria-live", "polite");
+    if (this._config.captionLayout === "dropdown") {
+      const month = document2.createElement("select");
+      month.className = "moo-calendar__select";
+      month.dataset.calendarMonth = "true";
+      month.setAttribute("aria-label", "Month");
+      for (let index = 0; index < 12; index += 1) {
+        const option = document2.createElement("option");
+        option.value = String(index);
+        option.textContent = monthName(index, this._config.locale);
+        option.selected = index === this._viewDate.getMonth();
+        month.appendChild(option);
+      }
+      const year = document2.createElement("select");
+      year.className = "moo-calendar__select";
+      year.dataset.calendarYear = "true";
+      year.setAttribute("aria-label", "Year");
+      yearOptions(this._config.minDate, this._config.maxDate, this._viewDate).forEach((value) => {
+        const option = document2.createElement("option");
+        option.value = String(value);
+        option.textContent = String(value);
+        option.selected = value === this._viewDate.getFullYear();
+        year.appendChild(option);
+      });
+      caption.append(month, year);
+    } else {
+      caption.textContent = formatMonthYear(this._viewDate, this._config.locale);
+    }
+    header.append(prev, caption, next);
+    fragment.appendChild(header);
+    const gridLabel = document2.createElement("div");
+    gridLabel.id = this._labelId;
+    gridLabel.className = "visually-hidden";
+    gridLabel.textContent = this._element.getAttribute("aria-label") || formatMonthYear(this._viewDate, this._config.locale);
+    fragment.appendChild(gridLabel);
+    const weekdays = document2.createElement("div");
+    weekdays.className = "moo-calendar__weekdays";
+    weekdays.setAttribute("role", "row");
+    weekdayDates(this._config.locale).forEach((date) => {
+      const label = document2.createElement("span");
+      label.className = "moo-calendar__weekday";
+      label.setAttribute("role", "columnheader");
+      label.textContent = new Intl.DateTimeFormat(this._config.locale, { weekday: "narrow" }).format(date);
+      weekdays.appendChild(label);
+    });
+    const grid = document2.createElement("div");
+    grid.className = "moo-calendar__grid";
+    grid.setAttribute("role", "grid");
+    grid.setAttribute("aria-labelledby", this._labelId);
+    grid.appendChild(weekdays);
+    const first = startOfMonth(this._viewDate);
+    const weekStart = firstDayOfWeek(this._config.locale);
+    const start = addDays(first, -((first.getDay() - weekStart + 7) % 7));
+    for (let week = 0; week < 6; week += 1) {
+      const row = document2.createElement("div");
+      row.className = "moo-calendar__week";
+      row.setAttribute("role", "row");
+      for (let day = 0; day < 7; day += 1) {
+        const date = addDays(start, week * 7 + day);
+        const iso = toIso(date);
+        const cell = document2.createElement("div");
+        cell.className = "moo-calendar__cell";
+        cell.setAttribute("role", "gridcell");
+        const button = document2.createElement("button");
+        button.className = "moo-calendar__day";
+        button.type = "button";
+        button.dataset.calendarDay = iso;
+        button.textContent = String(date.getDate());
+        button.tabIndex = sameDate(date, this._activeDate) ? 0 : -1;
+        button.setAttribute("aria-label", formatDisplay(date, this._config.locale));
+        const selected = this._isSelected(date);
+        button.dataset.calendarSelected = String(selected);
+        cell.setAttribute("aria-selected", selected ? "true" : "false");
+        if (date.getMonth() !== this._viewDate.getMonth()) {
+          button.dataset.calendarOutside = "true";
+        }
+        if (sameDate(date, /* @__PURE__ */ new Date())) {
+          button.dataset.calendarToday = "true";
+          button.setAttribute("aria-current", "date");
+        }
+        const rangeState = this._rangeState(date);
+        if (rangeState) {
+          button.dataset.calendarRange = rangeState;
+        }
+        if (this._isDisabled(date)) {
+          button.disabled = true;
+          button.setAttribute("aria-disabled", "true");
+        }
+        cell.appendChild(button);
+        row.appendChild(cell);
+      }
+      grid.appendChild(row);
+    }
+    fragment.appendChild(grid);
+    if (this._config.showPresets) {
+      const presets = document2.createElement("div");
+      presets.className = "moo-calendar__presets";
+      [
+        ["today", "Today"],
+        ["tomorrow", "Tomorrow"],
+        ["in-3-days", "In 3 days"],
+        ["in-a-week", "In a week"],
+        ["in-2-weeks", "In 2 weeks"]
+      ].forEach(([value, label]) => {
+        const button = document2.createElement("button");
+        button.className = "btn btn-outline-secondary btn-sm moo-calendar__preset";
+        button.type = "button";
+        button.dataset.calendarPreset = value;
+        button.textContent = label;
+        presets.appendChild(button);
+      });
+      fragment.appendChild(presets);
+    }
+    this._element.classList.add("moo-calendar");
+    this._element.dataset.calendar = this._element.dataset.calendar || "";
+    this._element.dataset.calendarMode = this._mode;
+    this._element.dataset.calendarActiveDate = toIso(this._activeDate);
+    if (this._mode === "single" && this._selectedDate) {
+      this._element.dataset.calendarValue = toIso(this._selectedDate);
+    } else {
+      delete this._element.dataset.calendarValue;
+    }
+    if (this._mode === "range") {
+      this._element.dataset.calendarStartValue = this._rangeStart ? toIso(this._rangeStart) : "";
+      this._element.dataset.calendarEndValue = this._rangeEnd ? toIso(this._rangeEnd) : "";
+    } else {
+      delete this._element.dataset.calendarStartValue;
+      delete this._element.dataset.calendarEndValue;
+    }
+    this._element.replaceChildren(fragment);
+  }
+};
+var MooDatepicker = class _MooDatepicker {
+  static getInstance(element) {
+    return element?.nodeType === 1 ? datepickerInstances.get(element) || null : null;
+  }
+  static getOrCreateInstance(element, config = {}) {
+    return _MooDatepicker.getInstance(element) || new _MooDatepicker(element, config);
+  }
+  constructor(element, config = {}) {
+    if (!isElement(element, "[data-datepicker]")) {
+      throw new TypeError("MooDatepicker requires a [data-datepicker] root element.");
+    }
+    const existing = datepickerInstances.get(element);
+    if (existing) return existing;
+    this._element = element;
+    this._document = element.ownerDocument;
+    this._window = this._document.defaultView || window;
+    this._listeners = [];
+    this._floatingListeners = [];
+    this._disposed = false;
+    this._positionPopover = null;
+    this._popoverPortal = null;
+    this._trigger = element.querySelector("[data-datepicker-trigger]");
+    this._popover = element.querySelector("[data-datepicker-popover]");
+    this._label = element.querySelector("[data-datepicker-label]");
+    this._input = element.querySelector("[data-datepicker-input]") || element.querySelector('input[type="hidden"]');
+    this._validationInput = element.querySelector("[data-datepicker-validation]");
+    this._calendarRoot = element.querySelector("[data-calendar]");
+    if (!this._trigger || !this._popover || !this._label || !this._input || !this._calendarRoot) {
+      throw new TypeError("MooDatepicker requires a trigger, popover, calendar, and hidden input.");
+    }
+    this._config = readDataConfig(element, {
+      ...config,
+      value: config.value || this._input.value || element.dataset.datepickerValue
+    });
+    this._placeholder = this._config.placeholder;
+    this._defaultValue = this._input.defaultValue || this._input.getAttribute("value") || "";
+    this.calendar = MooCalendar.getOrCreateInstance(this._calendarRoot, {
+      ...this._config,
+      mode: "single",
+      value: this._input.value || this._config.value
+    });
+    datepickerInstances.set(element, this);
+    this._syncFromCalendar();
+    this._bindEvents();
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    removeListeners(this._listeners);
+    this.hide(false);
+    stopDatepickerPopoverPositioning(this);
+    restoreDatepickerPopover(this);
+    removeListeners(this._floatingListeners);
+    this.calendar?.dispose();
+    if (datepickerInstances.get(this._element) === this) {
+      datepickerInstances.delete(this._element);
+    }
+  }
+  show() {
+    if (this._trigger.disabled || this._element.dataset.datepickerDisabled === "true") return;
+    if (this.isOpen()) return;
+    if (!dispatch(this._element, this._window, "show.moo.datepicker", {}, true)) return;
+    this._popover.hidden = false;
+    this._popover.classList.add("show");
+    startDatepickerPopoverPositioning(this);
+    this._trigger.setAttribute("aria-expanded", "true");
+    this.calendar.focusActiveDay();
+    dispatch(this._element, this._window, "shown.moo.datepicker");
+  }
+  hide(returnFocus = true) {
+    const wasOpen = this.isOpen();
+    if (!wasOpen) return;
+    if (!dispatch(this._element, this._window, "hide.moo.datepicker", {}, true)) return;
+    this._popover.hidden = true;
+    this._popover.classList.remove("show");
+    stopDatepickerPopoverPositioning(this);
+    this._trigger.setAttribute("aria-expanded", "false");
+    if (returnFocus) this._trigger.focus();
+    dispatch(this._element, this._window, "hidden.moo.datepicker");
+  }
+  toggle() {
+    if (this.isOpen()) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  }
+  isOpen() {
+    return !this._popover.hidden;
+  }
+  getDate(format = void 0) {
+    return this.calendar.getDate(format);
+  }
+  setDate(date, options = {}) {
+    const changed = this.calendar.setDate(date, { emit: false });
+    if (changed) {
+      this._syncFromCalendar();
+      if (options.emit !== false) this._emitChange();
+    }
+    return changed;
+  }
+  clear(options = {}) {
+    this.calendar.clear({ emit: false });
+    this._syncFromCalendar();
+    if (options.emit !== false) this._emitChange();
+  }
+  _bindEvents() {
+    addListener(this._listeners, this._trigger, "click", () => this.toggle());
+    addListener(this._listeners, this._popover, "keydown", (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        this.hide();
+      }
+    });
+    addListener(this._listeners, this._document, "pointerdown", (event) => {
+      if (this.isOpen() && !datepickerContains(this, event.target)) {
+        this._window.setTimeout(() => {
+          if (this.isOpen() && !datepickerContains(this, event.target)) {
+            this.hide();
+          }
+        }, 0);
+      }
+    });
+    addListener(this._listeners, this._calendarRoot, "change.moo.calendar", (event) => {
+      this._syncFromCalendar();
+      this._emitChange();
+      if (event.detail.complete) {
+        this.hide();
+      }
+    });
+    const form = this._input.form || this._element.closest("form");
+    addListener(this._listeners, this._validationInput, "invalid", (event) => {
+      event.preventDefault();
+      setDatepickerInvalid(this._element, this._trigger, true);
+      this._trigger.focus({ preventScroll: true });
+    });
+    addListener(this._listeners, form, "reset", () => {
+      this._window.setTimeout(() => {
+        if (this._defaultValue) {
+          this.setDate(this._defaultValue, { emit: false });
+        } else {
+          this.clear({ emit: false });
+        }
+      }, 0);
+    });
+  }
+  _syncFromCalendar() {
+    const value = this.calendar.getDate("yyyy-mm-dd") || "";
+    setHiddenValue(this._input, value);
+    setValidationValue(this._validationInput, value);
+    syncDatepickerValidation(this._element, this._trigger, this._validationInput);
+    this._element.dataset.datepickerValue = value;
+    this._label.textContent = value ? formatDisplay(parseDate(value), this._config.locale) : this._placeholder;
+  }
+  _emitChange() {
+    dispatch(this._element, this._window, "change.moo.datepicker", {
+      date: this.getDate(),
+      value: this.getDate("yyyy-mm-dd") || ""
+    });
+  }
+};
+var MooDateRangePicker = class _MooDateRangePicker {
+  static getInstance(element) {
+    return element?.nodeType === 1 ? rangePickerInstances.get(element) || null : null;
+  }
+  static getOrCreateInstance(element, config = {}) {
+    return _MooDateRangePicker.getInstance(element) || new _MooDateRangePicker(element, config);
+  }
+  constructor(element, config = {}) {
+    if (!isElement(element, "[data-datepicker-range]")) {
+      throw new TypeError("MooDateRangePicker requires a [data-datepicker-range] root element.");
+    }
+    const existing = rangePickerInstances.get(element);
+    if (existing) return existing;
+    this._element = element;
+    this._document = element.ownerDocument;
+    this._window = this._document.defaultView || window;
+    this._listeners = [];
+    this._floatingListeners = [];
+    this._disposed = false;
+    this._positionPopover = null;
+    this._popoverPortal = null;
+    this._trigger = element.querySelector("[data-datepicker-trigger]");
+    this._popover = element.querySelector("[data-datepicker-popover]");
+    this._label = element.querySelector("[data-datepicker-label]");
+    this._startInput = element.querySelector("[data-datepicker-range-start]");
+    this._endInput = element.querySelector("[data-datepicker-range-end]");
+    this._validationInput = element.querySelector("[data-datepicker-validation]");
+    this._calendarRoot = element.querySelector("[data-calendar]");
+    if (!this._trigger || !this._popover || !this._label || !this._startInput || !this._endInput || !this._calendarRoot) {
+      throw new TypeError("MooDateRangePicker requires a trigger, popover, calendar, and start/end hidden inputs.");
+    }
+    this._config = readDataConfig(element, {
+      ...config,
+      mode: "range",
+      startValue: config.startValue || this._startInput.value || element.dataset.datepickerStartValue,
+      endValue: config.endValue || this._endInput.value || element.dataset.datepickerEndValue
+    });
+    this._placeholder = this._config.placeholder;
+    this._defaultStartValue = this._startInput.defaultValue || this._startInput.getAttribute("value") || "";
+    this._defaultEndValue = this._endInput.defaultValue || this._endInput.getAttribute("value") || "";
+    this.calendar = MooCalendar.getOrCreateInstance(this._calendarRoot, this._config);
+    rangePickerInstances.set(element, this);
+    this._syncFromCalendar();
+    this._bindEvents();
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    removeListeners(this._listeners);
+    this.hide(false);
+    stopDatepickerPopoverPositioning(this);
+    restoreDatepickerPopover(this);
+    removeListeners(this._floatingListeners);
+    this.calendar?.dispose();
+    if (rangePickerInstances.get(this._element) === this) {
+      rangePickerInstances.delete(this._element);
+    }
+  }
+  show() {
+    if (this._trigger.disabled || this._element.dataset.datepickerDisabled === "true") return;
+    if (this.isOpen()) return;
+    if (!dispatch(this._element, this._window, "show.moo.datepicker", {}, true)) return;
+    this._popover.hidden = false;
+    this._popover.classList.add("show");
+    startDatepickerPopoverPositioning(this);
+    this._trigger.setAttribute("aria-expanded", "true");
+    this.calendar.focusActiveDay();
+    dispatch(this._element, this._window, "shown.moo.datepicker");
+  }
+  hide(returnFocus = true) {
+    const wasOpen = this.isOpen();
+    if (!wasOpen) return;
+    if (!dispatch(this._element, this._window, "hide.moo.datepicker", {}, true)) return;
+    this._popover.hidden = true;
+    this._popover.classList.remove("show");
+    stopDatepickerPopoverPositioning(this);
+    this._trigger.setAttribute("aria-expanded", "false");
+    if (returnFocus) this._trigger.focus();
+    dispatch(this._element, this._window, "hidden.moo.datepicker");
+  }
+  toggle() {
+    if (this.isOpen()) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  }
+  isOpen() {
+    return !this._popover.hidden;
+  }
+  getDates(format = void 0) {
+    return this.calendar.getDates(format);
+  }
+  setDates(startDate, endDate, options = {}) {
+    const changed = this.calendar.setDates(startDate, endDate, { emit: false });
+    if (changed) {
+      this._syncFromCalendar();
+      if (options.emit !== false) this._emitChange();
+    }
+    return changed;
+  }
+  clear(options = {}) {
+    this.calendar.clear({ emit: false });
+    this._syncFromCalendar();
+    if (options.emit !== false) this._emitChange();
+  }
+  _bindEvents() {
+    addListener(this._listeners, this._trigger, "click", () => this.toggle());
+    addListener(this._listeners, this._popover, "keydown", (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        this.hide();
+      }
+    });
+    addListener(this._listeners, this._document, "pointerdown", (event) => {
+      if (this.isOpen() && !datepickerContains(this, event.target)) {
+        this._window.setTimeout(() => {
+          if (this.isOpen() && !datepickerContains(this, event.target)) {
+            this.hide();
+          }
+        }, 0);
+      }
+    });
+    const closeWhenFocusLeaves = () => {
+      this._window.setTimeout(() => {
+        if (this.isOpen() && !datepickerContains(this, this._document.activeElement)) {
+          this.hide(false);
+        }
+      }, 0);
+    };
+    addListener(this._listeners, this._element, "focusout", closeWhenFocusLeaves);
+    addListener(this._listeners, this._popover, "focusout", closeWhenFocusLeaves);
+    addListener(this._listeners, this._calendarRoot, "change.moo.calendar", (event) => {
+      this._syncFromCalendar();
+      this._emitChange();
+      if (event.detail.complete) {
+        this.hide();
+      } else {
+        this.calendar.focusActiveDay();
+      }
+    });
+    const form = this._startInput.form || this._element.closest("form");
+    addListener(this._listeners, this._validationInput, "invalid", (event) => {
+      event.preventDefault();
+      setDatepickerInvalid(this._element, this._trigger, true);
+      this._trigger.focus({ preventScroll: true });
+    });
+    addListener(this._listeners, form, "reset", () => {
+      this._window.setTimeout(() => {
+        this.setDates(this._defaultStartValue, this._defaultEndValue, { emit: false });
+      }, 0);
+    });
+  }
+  _syncFromCalendar() {
+    const [startValue = "", endValue = ""] = this.calendar.getDates("yyyy-mm-dd");
+    setHiddenValue(this._startInput, startValue || "");
+    setHiddenValue(this._endInput, endValue || "");
+    setValidationValue(this._validationInput, startValue && endValue ? `${startValue} - ${endValue}` : "");
+    syncDatepickerValidation(this._element, this._trigger, this._validationInput);
+    this._element.dataset.datepickerStartValue = startValue || "";
+    this._element.dataset.datepickerEndValue = endValue || "";
+    if (startValue && endValue) {
+      this._label.textContent = `${formatDisplay(parseDate(startValue), this._config.locale)} - ${formatDisplay(parseDate(endValue), this._config.locale)}`;
+    } else if (startValue) {
+      this._label.textContent = formatDisplay(parseDate(startValue), this._config.locale);
+    } else {
+      this._label.textContent = this._placeholder;
+    }
+  }
+  _emitChange() {
+    const [startDate, endDate] = this.getDates();
+    const [startValue = "", endValue = ""] = this.getDates("yyyy-mm-dd");
+    dispatch(this._element, this._window, "change.moo.datepicker", {
+      startDate,
+      endDate,
+      startValue,
+      endValue
+    });
+  }
+};
+
+// src/js/components/sidebar.js
+var instances4 = /* @__PURE__ */ new WeakMap();
+var Sidebar = class _Sidebar {
+  static getInstance(element) {
+    return element?.nodeType === 1 ? instances4.get(element) || null : null;
+  }
+  static getOrCreateInstance(element, config = {}) {
+    return _Sidebar.getInstance(element) || new _Sidebar(element, config);
+  }
+  constructor(element, config = {}) {
+    if (element?.nodeType !== 1 || !element.matches('[data-slot="sidebar-wrapper"]')) {
+      throw new TypeError("Sidebar requires a [data-slot=sidebar-wrapper] root.");
+    }
+    const existing = instances4.get(element);
+    if (existing) {
+      return existing;
+    }
+    this._element = element;
+    this._document = element.ownerDocument;
+    this._window = this._document.defaultView;
+    this._documentElement = this._document.documentElement;
+    this._root = findThemeOwner(element) || this._document.body || this._documentElement;
+    this._sidebar = element.querySelector('[data-slot="sidebar"]');
+    this._config = {
+      breakpoint: "(min-width: 992px)",
+      storagePrefix: "moo-sidebar:",
+      keyboard: true,
+      ...config
+    };
+    this._listeners = [];
+    this._tooltipAnchors = /* @__PURE__ */ new Set();
+    this._flyout = null;
+    this._flyoutOwner = null;
+    this._offcanvas = null;
+    this._offcanvasTrigger = null;
+    instances4.set(element, this);
+    this._bindEvents();
+    this._restoreState();
+    this._scrollActiveItemIntoView();
+    this._element.setAttribute("data-sidebar-ready", "");
+    this._observeDirection();
+  }
+  dispose() {
+    this._listeners.forEach(({ target, type, handler, options }) => {
+      target.removeEventListener(type, handler, options);
+    });
+    this._listeners = [];
+    this._directionObserver?.disconnect();
+    this._closeFlyouts();
+    this._element.querySelectorAll("[data-sidebar-dropdown-positioned]").forEach((item) => this._clearDropdownPosition(item));
+    this._element.querySelectorAll("[data-sidebar-tooltip]").forEach((control) => this._disposeTooltip(control));
+    this._offcanvas?.dispose();
+    this._offcanvas = null;
+    this._offcanvasTrigger = null;
+    this._element.removeAttribute("data-sidebar-ready");
+    instances4.delete(this._element);
+  }
+  _listen(target, type, handler, options) {
+    target?.addEventListener(type, handler, options);
+    if (target) {
+      this._listeners.push({ target, type, handler, options });
+    }
+  }
+  _bootstrap(name) {
+    return this._window.bootstrap?.[name] || null;
+  }
+  _portalRoot(trigger = this._element) {
+    return ownerPortalRoot(findThemeOwner(trigger)) || this._document.body || this._documentElement;
+  }
+  _isDesktop() {
+    return this._window.matchMedia(this._config.breakpoint).matches;
+  }
+  _isCollapsed() {
+    return this._isDesktop() && this._sidebar?.dataset?.collapsible === "icon" && this._element.dataset.sidebarState === "collapsed";
+  }
+  _trigger(name, detail = {}) {
+    return this._element.dispatchEvent(
+      new this._window.CustomEvent(`${name}.moo.sidebar`, {
+        bubbles: true,
+        cancelable: name === "show" || name === "hide",
+        detail
+      })
+    );
+  }
+  _observeDirection() {
+    const Observer = this._window.MutationObserver;
+    if (!Observer) {
+      return;
+    }
+    this._directionObserver = new Observer(() => {
+      this._closeFlyouts();
+      this._syncTooltips();
+    });
+    this._directionObserver.observe(this._documentElement, {
+      attributes: true,
+      attributeFilter: ["dir"]
+    });
+  }
+  _restoreState() {
+    const key = this._element.dataset.sidebarKey;
+    let stored = null;
+    if (key) {
+      try {
+        stored = this._window.localStorage.getItem(this._config.storagePrefix + key);
+      } catch (_) {
+        stored = null;
+      }
+    }
+    const initial = stored === "collapsed" || stored === "expanded" ? stored : this._element.dataset.sidebarState === "collapsed" ? "collapsed" : "expanded";
+    this._setState(initial, false, false);
+  }
+  _scrollActiveItemIntoView() {
+    const activeRoute = this._element.querySelector(
+      '[data-slot="sidebar-content"] a[data-slot="sidebar-menu-button"][aria-current="page"], [data-slot="sidebar-content"] a.sidebar-menu-button[aria-current="page"], [data-slot="sidebar-content"] a.sidebar-menu-button.active'
+    );
+    const active = activeRoute || this._element.querySelector(
+      '[data-slot="sidebar-content"] [data-slot="sidebar-menu-button"][aria-current="page"], [data-slot="sidebar-content"] .sidebar-menu-button[aria-current="page"], [data-slot="sidebar-content"] .sidebar-menu-button.active'
+    );
+    const content = active?.closest?.('[data-slot="sidebar-content"]');
+    if (!active || !content || content.clientHeight <= 0) {
+      return;
+    }
+    const maxScrollTop = content.scrollHeight - content.clientHeight;
+    if (maxScrollTop <= 0) {
+      return;
+    }
+    const contentRect = content.getBoundingClientRect();
+    const activeRect = active.getBoundingClientRect();
+    if (contentRect.height <= 0 || activeRect.height <= 0) {
+      return;
+    }
+    const targetScrollTop = content.scrollTop + activeRect.top - contentRect.top - (content.clientHeight - activeRect.height) / 2;
+    content.scrollTop = Math.round(
+      Math.min(Math.max(targetScrollTop, 0), maxScrollTop)
+    );
+  }
+  _setState(state, persist = true, emit = true) {
+    const next = state === "collapsed" ? "collapsed" : "expanded";
+    const previous = this._element.dataset.sidebarState;
+    this._element.dataset.sidebarState = next;
+    const key = this._element.dataset.sidebarKey;
+    if (key === "catalog-shell") {
+      this._root.dataset.sidebarCatalogState = next;
+    }
+    if (persist && key) {
+      try {
+        this._window.localStorage.setItem(this._config.storagePrefix + key, next);
+      } catch (_) {
+      }
+    }
+    this._syncControls();
+    if (next === "expanded") {
+      this._element.querySelectorAll(".sidebar-menu-item").forEach((item) => this._resetFlyoutTrigger(item));
+    }
+    this._syncTooltips();
+    if (emit && previous !== next) {
+      this._trigger("change", { state: next, previousState: previous || null });
+    }
+  }
+  _toggle() {
+    this._setState(
+      this._element.dataset.sidebarState === "collapsed" ? "expanded" : "collapsed"
+    );
+  }
+  _syncControls() {
+    const expanded = this._isDesktop() ? this._element.dataset.sidebarState === "expanded" : this._sidebar?.classList.contains("show") || false;
+    this._element.querySelectorAll("[data-sidebar-trigger], [data-sidebar-rail]").forEach((control) => control.setAttribute("aria-expanded", String(expanded)));
+  }
+  _resetFlyoutTrigger(item, expanded = null) {
+    const trigger = item?.querySelector(":scope > .sidebar-menu-sub-trigger");
+    const submenu = item?.querySelector(":scope > .sidebar-menu-sub");
+    if (trigger && submenu) {
+      trigger.setAttribute(
+        "aria-expanded",
+        String(expanded ?? submenu.classList.contains("show"))
+      );
+    }
+  }
+  _clearDropdownPosition(control) {
+    const item = control?.matches?.(".sidebar-menu-item") ? control : control?.closest?.(".sidebar-menu-item");
+    if (!item) {
+      return;
+    }
+    delete item.dataset.sidebarDropdownPositioned;
+    item.style.removeProperty("--moo-sidebar-dropdown-block-start");
+    item.style.removeProperty("--moo-sidebar-dropdown-block-end");
+    item.style.removeProperty("--moo-sidebar-dropdown-left");
+    item.style.removeProperty("--moo-sidebar-dropdown-right");
+  }
+  _closeDropdowns(exceptControl = null) {
+    const Dropdown = this._bootstrap("Dropdown");
+    this._element.querySelectorAll('[data-bs-toggle="dropdown"][aria-expanded="true"]').forEach((control) => {
+      if (control === exceptControl) {
+        return;
+      }
+      if (Dropdown) {
+        Dropdown.getOrCreateInstance(control).hide();
+      } else {
+        control.setAttribute("aria-expanded", "false");
+        control.closest(".dropdown")?.querySelector(".dropdown-menu.show")?.classList.remove("show");
+        this._clearDropdownPosition(control);
+      }
+    });
+  }
+  _positionDropdown(control) {
+    const item = control?.closest?.(".sidebar-menu-item");
+    const isHeaderWorkspace = control?.classList.contains("sidebar-menu-button--workspace") && control.closest('[data-slot="sidebar-header"]');
+    const isFooterAccount = control?.closest(".sidebar-menu-item--account") && control.closest('[data-slot="sidebar-footer"]');
+    if (!control || !item || !(isHeaderWorkspace || isFooterAccount) || !this._isDesktop()) {
+      this._clearDropdownPosition(control);
+      return;
+    }
+    this._closeFlyouts();
+    const rect = control.getBoundingClientRect();
+    const gap = 4;
+    const sidebar = control.closest('[data-slot="sidebar"]');
+    const side = sidebar?.dataset.side || "left";
+    if (side === "right") {
+      const right = this._window.innerWidth - rect.left + gap;
+      item.style.setProperty(
+        "--moo-sidebar-dropdown-right",
+        `${Math.round(right)}px`
+      );
+      item.style.removeProperty("--moo-sidebar-dropdown-left");
+    } else {
+      const left = rect.right + gap;
+      item.style.setProperty(
+        "--moo-sidebar-dropdown-left",
+        `${Math.round(left)}px`
+      );
+      item.style.removeProperty("--moo-sidebar-dropdown-right");
+    }
+    if (isHeaderWorkspace) {
+      item.style.setProperty(
+        "--moo-sidebar-dropdown-block-start",
+        `${Math.round(rect.bottom + gap)}px`
+      );
+      item.style.removeProperty("--moo-sidebar-dropdown-block-end");
+    } else {
+      item.style.setProperty(
+        "--moo-sidebar-dropdown-block-end",
+        `${Math.round(this._window.innerHeight - rect.top + gap)}px`
+      );
+      item.style.removeProperty("--moo-sidebar-dropdown-block-start");
+    }
+    item.dataset.sidebarDropdownPositioned = "";
+  }
+  _removeFlyoutPortal() {
+    this._flyout?.remove();
+    if (this._flyoutOwner) {
+      this._resetFlyoutTrigger(this._flyoutOwner, false);
+    }
+    this._flyout = null;
+    this._flyoutOwner = null;
+  }
+  _closeFlyouts() {
+    this._removeFlyoutPortal();
+    this._element.querySelectorAll(".sidebar-menu-item--flyout-open").forEach((item) => {
+      item.classList.remove("sidebar-menu-item--flyout-open");
+      item.style.removeProperty("--moo-sidebar-flyout-block-start");
+      item.style.removeProperty("--moo-sidebar-flyout-left");
+      this._resetFlyoutTrigger(item, false);
+    });
+  }
+  _openFlyout(item) {
+    const submenu = item?.querySelector(":scope > .sidebar-menu-sub");
+    const trigger = item?.querySelector(":scope > .sidebar-menu-sub-trigger");
+    if (!item || !submenu || !this._isCollapsed()) {
+      return;
+    }
+    if (this._flyoutOwner === item && this._flyout) {
+      return;
+    }
+    this._closeDropdowns();
+    this._closeFlyouts();
+    const rect = item.getBoundingClientRect();
+    const sidebar = this._sidebar;
+    const sidebarRect = sidebar?.getBoundingClientRect() || rect;
+    const gap = 4;
+    const flyout = submenu.cloneNode(true);
+    flyout.removeAttribute("id");
+    flyout.classList.remove("collapse", "show", "collapsing");
+    flyout.classList.add("sidebar-menu-flyout");
+    flyout.dataset.sidebarFlyout = "";
+    flyout.removeAttribute("style");
+    flyout.style.setProperty("--moo-sidebar-flyout-block-start", `${Math.round(rect.top)}px`);
+    const side = sidebar?.dataset.side || "left";
+    this._portalRoot(item).appendChild(flyout);
+    const flyoutWidth = flyout.getBoundingClientRect().width;
+    const left = side === "right" ? sidebarRect.left - flyoutWidth - gap : sidebarRect.right + gap;
+    const boundedLeft = Math.max(0, Math.min(this._window.innerWidth - flyoutWidth, left));
+    flyout.style.setProperty("--moo-sidebar-flyout-left", `${Math.round(boundedLeft)}px`);
+    this._flyout = flyout;
+    this._flyoutOwner = item;
+    item.classList.add("sidebar-menu-item--flyout-open");
+    trigger?.setAttribute("aria-expanded", "true");
+  }
+  _tooltipAnchor(control) {
+    return control.closest("li") || control;
+  }
+  _isIdentityTrigger(control) {
+    return control.closest(".sidebar-menu-item--account") || control.classList.contains("sidebar-menu-button--workspace");
+  }
+  _disposeTooltip(control) {
+    const Tooltip = this._bootstrap("Tooltip");
+    if (!Tooltip || !control) {
+      return;
+    }
+    const anchor = this._tooltipAnchor(control);
+    Tooltip.getInstance(anchor)?.dispose();
+    this._tooltipAnchors.delete(anchor);
+    anchor.removeAttribute("title");
+    anchor.removeAttribute("data-bs-title");
+    anchor.removeAttribute("data-bs-original-title");
+    anchor.removeAttribute("aria-describedby");
+  }
+  _syncTooltips() {
+    const Tooltip = this._bootstrap("Tooltip");
+    if (!Tooltip) {
+      return;
+    }
+    const collapsed = this._isCollapsed();
+    const side = this._sidebar?.dataset.side || "left";
+    const placement = side === "right" ? "left" : "right";
+    this._element.querySelectorAll("[data-sidebar-tooltip]").forEach((control) => {
+      this._disposeTooltip(control);
+      if (!collapsed || this._isIdentityTrigger(control) || control.closest(".sidebar-menu-item")?.querySelector(":scope > .sidebar-menu-sub")) {
+        return;
+      }
+      const anchor = this._tooltipAnchor(control);
+      new Tooltip(anchor, {
+        title: control.getAttribute("data-sidebar-tooltip"),
+        placement,
+        // Bootstrap's default tooltip offset is 6px. The icon rail's
+        // boundary calculation still lets the tooltip box overlap the
+        // physical Sidebar edge at that distance, so keep an explicit 8px
+        // separation for both physical placements.
+        offset: [0, 8],
+        container: this._portalRoot(control),
+        trigger: "hover focus"
+      });
+      this._tooltipAnchors.add(anchor);
+    });
+  }
+  _bindEvents() {
+    this._listen(this._sidebar, "shown.bs.offcanvas", () => this._syncControls());
+    this._listen(this._sidebar, "hidden.bs.offcanvas", () => {
+      this._syncControls();
+      const trigger = this._offcanvasTrigger;
+      this._offcanvasTrigger = null;
+      if (trigger?.isConnected) {
+        trigger.focus();
+      }
+    });
+    this._listen(this._document, "show.bs.dropdown", (event) => {
+      const control = this._dropdownControl(event.target);
+      if (!control) {
+        return;
+      }
+      this._closeDropdowns(control);
+      this._disposeTooltip(control);
+      this._positionDropdown(control);
+    });
+    this._listen(this._document, "hidden.bs.dropdown", (event) => {
+      const control = this._dropdownControl(event.target);
+      if (!control) {
+        return;
+      }
+      this._clearDropdownPosition(control);
+      this._syncTooltips();
+    });
+    this._listen(this._element, "click", (event) => this._handleControlClick(event));
+    this._listen(this._window, "click", (event) => this._handleSubmenuClick(event), true);
+    this._listen(this._document, "click", (event) => this._handleOutsideFlyoutClick(event));
+    this._listen(this._document, "keydown", (event) => this._handleShortcut(event));
+    this._listen(this._window, "resize", () => {
+      this._closeFlyouts();
+      this._element.querySelectorAll("[data-sidebar-dropdown-positioned]").forEach((item) => this._clearDropdownPosition(item));
+      this._syncControls();
+      this._syncTooltips();
+    });
+  }
+  _dropdownControl(target) {
+    if (!(target instanceof this._window.Element) || !this._element.contains(target)) {
+      return null;
+    }
+    if (target.matches('[data-bs-toggle="dropdown"][data-sidebar-tooltip]')) {
+      return target;
+    }
+    return target.querySelector?.(
+      '[data-bs-toggle="dropdown"][data-sidebar-tooltip]'
+    ) || null;
+  }
+  _handleControlClick(event) {
+    const target = event.target;
+    const control = target instanceof this._window.Element ? target.closest("[data-sidebar-trigger], [data-sidebar-rail]") : null;
+    if (!control || !this._element.contains(control)) {
+      return;
+    }
+    if (this._isDesktop()) {
+      event.preventDefault();
+      this._closeFlyouts();
+      this._toggle();
+      return;
+    }
+    if (!control.matches("[data-sidebar-trigger]")) {
+      return;
+    }
+    const sidebar = this._document.getElementById(control.getAttribute("aria-controls"));
+    const Offcanvas = this._bootstrap("Offcanvas");
+    if (sidebar && Offcanvas) {
+      this._offcanvasTrigger = control;
+      this._offcanvas = Offcanvas.getOrCreateInstance(sidebar);
+      this._offcanvas.toggle();
+    }
+  }
+  _handleSubmenuClick(event) {
+    const target = event.target;
+    const trigger = target instanceof this._window.Element ? target.closest(".sidebar-menu-sub-trigger") : null;
+    const item = trigger?.closest(".sidebar-menu-item");
+    if (!trigger || !item || !this._element.contains(item) || !this._isCollapsed()) {
+      return;
+    }
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    if (this._flyoutOwner === item && this._flyout) {
+      this._closeFlyouts();
+    } else {
+      this._openFlyout(item);
+    }
+  }
+  _handleOutsideFlyoutClick(event) {
+    if (!this._flyout) {
+      return;
+    }
+    if (this._flyout.contains(event.target)) {
+      this._closeFlyouts();
+    } else if (!this._flyoutOwner?.contains(event.target)) {
+      this._closeFlyouts();
+    }
+  }
+  _handleShortcut(event) {
+    const target = event.target;
+    const isEditable = target instanceof this._window.Element && (target.matches("input, textarea, select") || target.isContentEditable);
+    if (event.defaultPrevented || event.isComposing || isEditable || !this._config.keyboard || !(event.metaKey || event.ctrlKey) || event.key.toLowerCase() !== "b" || !this._isDesktop()) {
+      return;
+    }
+    const preferred = this._document.querySelector(
+      '[data-slot="sidebar-wrapper"][data-sidebar-key]'
+    ) || this._document.querySelector('[data-slot="sidebar-wrapper"]');
+    if (preferred !== this._element) {
+      return;
+    }
+    event.preventDefault();
+    this._closeFlyouts();
+    this._toggle();
+  }
+};
+
+// src/js/components/slider.js
+var instances5 = /* @__PURE__ */ new WeakMap();
+function asNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+function inputMinimum(input) {
+  return asNumber(input.min, 0);
+}
+function inputMaximum(input) {
+  return asNumber(input.max, 100);
+}
+function inputStep(input) {
+  if (!input.step || input.step === "any") {
+    return 1;
+  }
+  const step = Number(input.step);
+  return Number.isFinite(step) && step > 0 ? step : 1;
+}
+function clamp2(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function decimalPlaces(value) {
+  const text = String(value);
+  if (!text.includes(".")) {
+    return 0;
+  }
+  return text.split(".").at(-1).length;
+}
+function snapToStep(value, input) {
+  const min = inputMinimum(input);
+  const max = inputMaximum(input);
+  if (input.step === "any") {
+    return Number(clamp2(value, min, max).toFixed(4));
+  }
+  const step = inputStep(input);
+  const snapped = min + Math.round((value - min) / step) * step;
+  const precision = Math.max(decimalPlaces(step), decimalPlaces(min));
+  return clamp2(Number(snapped.toFixed(precision)), min, max);
+}
+function valuePercent(input) {
+  const min = inputMinimum(input);
+  const max = inputMaximum(input);
+  if (max <= min) {
+    return 0;
+  }
+  return (asNumber(input.value, min) - min) / (max - min) * 100;
+}
+function displayValue(input) {
+  return input.value || String(inputMinimum(input));
+}
+var MooSlider = class _MooSlider {
+  static getInstance(element) {
+    return element?.nodeType === 1 ? instances5.get(element) || null : null;
+  }
+  static getOrCreateInstance(element, config = {}) {
+    return _MooSlider.getInstance(element) || new _MooSlider(element, config);
+  }
+  constructor(element, config = {}) {
+    if (element?.nodeType !== 1 || !element.matches("[data-slider]")) {
+      throw new TypeError("MooSlider requires a [data-slider] root element.");
+    }
+    const existing = instances5.get(element);
+    if (existing) {
+      return existing;
+    }
+    this._element = element;
+    this._document = element.ownerDocument;
+    this._window = this._document.defaultView;
+    this._config = { ...config };
+    this._listeners = [];
+    this._dragListeners = [];
+    this._draggingInput = null;
+    this._disposed = false;
+    this._inputs = Array.from(
+      element.querySelectorAll(':scope input[type="range"][data-slider-input]')
+    );
+    this._track = element.querySelector("[data-slider-track]");
+    this._output = element.querySelector("[data-slider-output]");
+    if (this._inputs.length < 1 || this._inputs.length > 2) {
+      throw new TypeError("MooSlider requires one or two native range inputs.");
+    }
+    if (!this._track) {
+      throw new TypeError("MooSlider requires a [data-slider-track] element.");
+    }
+    instances5.set(element, this);
+    this._bindEvents();
+    this._sync();
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._clearDragListeners();
+    this._clearPointerFocus();
+    this._listeners.forEach(({ target, type, handler, options }) => {
+      target.removeEventListener(type, handler, options);
+    });
+    this._listeners = [];
+    if (instances5.get(this._element) === this) {
+      instances5.delete(this._element);
+    }
+  }
+  _listen(target, type, handler, options) {
+    if (!target) {
+      return;
+    }
+    target.addEventListener(type, handler, options);
+    this._listeners.push({ target, type, handler, options });
+  }
+  _listenDuringDrag(target, type, handler, options) {
+    if (!target) {
+      return;
+    }
+    target.addEventListener(type, handler, options);
+    this._dragListeners.push({ target, type, handler, options });
+  }
+  _clearDragListeners() {
+    this._dragListeners.forEach(({ target, type, handler, options }) => {
+      target.removeEventListener(type, handler, options);
+    });
+    this._dragListeners = [];
+    this._draggingInput = null;
+    this._element.removeAttribute("data-slider-dragging");
+  }
+  _bindEvents() {
+    this._inputs.forEach((input) => {
+      this._listen(input, "input", () => this._sync(input));
+      this._listen(input, "change", () => {
+        this._sync(input);
+        this._trigger("change");
+      });
+      this._listen(input, "keydown", () => this._clearPointerFocus());
+      this._listen(input, "focusout", () => this._clearPointerFocus());
+    });
+    const forms = new Set(
+      this._inputs.map((input) => input.form || input.closest?.("form")).filter(Boolean)
+    );
+    forms.forEach((form) => {
+      this._listen(form, "reset", () => {
+        this._window.setTimeout(() => this._sync(), 0);
+      });
+    });
+    this._listen(this._track, "pointerdown", (event) => this._handleTrackPointer(event));
+  }
+  _trigger(name) {
+    this._element.dispatchEvent(
+      new this._window.CustomEvent(`${name}.moo.slider`, {
+        bubbles: true
+      })
+    );
+  }
+  _isRange() {
+    return this._inputs.length === 2;
+  }
+  _sync(changedInput = null) {
+    if (this._isRange()) {
+      const [startInput, endInput] = this._inputs;
+      const start = asNumber(startInput.value, inputMinimum(startInput));
+      const end = asNumber(endInput.value, inputMaximum(endInput));
+      if (start > end) {
+        if (changedInput === endInput) {
+          endInput.value = startInput.value;
+        } else {
+          startInput.value = endInput.value;
+        }
+      }
+      this._writeFill(valuePercent(startInput), valuePercent(endInput));
+      this._writeOutput(`${displayValue(startInput)} - ${displayValue(endInput)}`);
+      this._syncAria(startInput);
+      this._syncAria(endInput);
+      return;
+    }
+    const input = this._inputs[0];
+    this._writeFill(0, valuePercent(input));
+    this._writeOutput(displayValue(input));
+    this._syncAria(input);
+  }
+  _syncAria(input) {
+    input.setAttribute("aria-valuemin", String(inputMinimum(input)));
+    input.setAttribute("aria-valuemax", String(inputMaximum(input)));
+    input.setAttribute("aria-valuenow", displayValue(input));
+  }
+  _writeFill(start, end) {
+    const clampedStart = clamp2(start, 0, 100);
+    const clampedEnd = clamp2(end, 0, 100);
+    this._element.style.setProperty("--moo-slider-start", `${Math.min(clampedStart, clampedEnd)}%`);
+    this._element.style.setProperty("--moo-slider-end", `${Math.max(clampedStart, clampedEnd)}%`);
+  }
+  _writeOutput(value) {
+    if (this._output) {
+      this._output.textContent = value;
+    }
+  }
+  _handleTrackPointer(event) {
+    if (event.button !== void 0 && event.button !== 0) {
+      return;
+    }
+    const enabledInputs = this._inputs.filter((input) => !input.disabled);
+    if (!enabledInputs.length) {
+      return;
+    }
+    event.preventDefault?.();
+    const percent = this._pointerPercent(event);
+    const target = this._nearestInput(percent * 100, enabledInputs);
+    this._setPointerFocus();
+    this._startDrag(target, event);
+    this._setInputFromPointer(target, event);
+  }
+  _setPointerFocus() {
+    this._element.setAttribute("data-slider-pointer-focus", "true");
+  }
+  _clearPointerFocus() {
+    this._element.removeAttribute("data-slider-pointer-focus");
+  }
+  _startDrag(input, event) {
+    this._clearDragListeners();
+    this._draggingInput = input;
+    this._element.setAttribute("data-slider-dragging", "true");
+    this._track.setPointerCapture?.(event.pointerId);
+    const pointerId = event.pointerId;
+    const samePointer = (nextEvent) => pointerId === void 0 || nextEvent.pointerId === pointerId;
+    const onMove = (moveEvent) => {
+      if (!samePointer(moveEvent) || this._draggingInput !== input) {
+        return;
+      }
+      moveEvent.preventDefault?.();
+      this._setInputFromPointer(input, moveEvent);
+    };
+    const onEnd = (endEvent) => {
+      if (!samePointer(endEvent) || this._draggingInput !== input) {
+        return;
+      }
+      endEvent.preventDefault?.();
+      this._setInputFromPointer(input, endEvent, false);
+      input.dispatchEvent(new this._window.Event("change", { bubbles: true }));
+      this._track.releasePointerCapture?.(pointerId);
+      this._clearDragListeners();
+    };
+    this._listenDuringDrag(this._document, "pointermove", onMove);
+    this._listenDuringDrag(this._document, "pointerup", onEnd);
+    this._listenDuringDrag(this._document, "pointercancel", onEnd);
+  }
+  _setInputFromPointer(input, event, emitInput = true) {
+    const percent = this._pointerPercent(event);
+    const min = inputMinimum(input);
+    const max = inputMaximum(input);
+    input.value = String(snapToStep(min + percent * (max - min), input));
+    input.focus({ preventScroll: true });
+    this._sync(input);
+    if (emitInput) {
+      input.dispatchEvent(new this._window.Event("input", { bubbles: true }));
+    }
+  }
+  _pointerPercent(event) {
+    const rect = this._track.getBoundingClientRect();
+    const orientation = this._element.dataset.sliderOrientation || "horizontal";
+    if (orientation === "vertical") {
+      return clamp2((rect.bottom - event.clientY) / (rect.height || 1), 0, 1);
+    }
+    return this._horizontalPointerPercent(event, rect);
+  }
+  _horizontalPointerPercent(event, rect) {
+    const direction = this._window.getComputedStyle?.(this._element).direction;
+    const offset = direction === "rtl" ? rect.right - event.clientX : event.clientX - rect.left;
+    return clamp2(offset / (rect.width || 1), 0, 1);
+  }
+  _nearestInput(percent, inputs) {
+    if (inputs.length === 1) {
+      return inputs[0];
+    }
+    const [startInput, endInput] = inputs;
+    const startPercent = valuePercent(startInput);
+    const endPercent = valuePercent(endInput);
+    const startDistance = Math.abs(startPercent - percent);
+    const endDistance = Math.abs(endPercent - percent);
+    if (startDistance === endDistance) {
+      return percent >= startPercent ? endInput : startInput;
+    }
+    return endDistance < startDistance ? endInput : startInput;
+  }
+};
+
+// src/js/components/sheet.js
+var states = /* @__PURE__ */ new WeakMap();
+function initSheets(root = document) {
+  if (states.has(root)) {
+    return states.get(root);
+  }
+  const documentRoot = root.nodeType === 9 ? root : root.ownerDocument;
+  const Offcanvas = documentRoot?.defaultView?.bootstrap?.Offcanvas;
+  if (!Offcanvas) {
+    return () => {
+    };
+  }
+  const sheets = Array.from(root.querySelectorAll(".offcanvas.sheet"));
+  const focusInitialField = (event) => {
+    if (event.target === event.currentTarget) {
+      event.currentTarget.querySelector("[autofocus]:not(:disabled)")?.focus();
+    }
+  };
+  const dispose = () => {
+    if (states.get(root) !== dispose) {
+      return;
+    }
+    sheets.forEach((sheet) => {
+      sheet.removeEventListener("shown.bs.offcanvas", focusInitialField);
+    });
+    states.delete(root);
+  };
+  states.set(root, dispose);
+  sheets.forEach((sheet) => {
+    sheet.addEventListener("shown.bs.offcanvas", focusInitialField);
+    if (sheet.dataset.sheetOpenOnLoad === "true") {
+      sheet.removeAttribute("data-sheet-open-on-load");
+      Offcanvas.getOrCreateInstance(sheet).show();
+    }
+  });
+  return dispose;
+}
+
+// src/js/moo-ui.js
+async function loadChart() {
+  const { default: Chart } = await import("./chart.js");
+  return Chart;
+}
+var MooUI = {
+  loadChart,
+  Combobox,
+  ContextMenu,
+  DataTable,
+  Datepicker: MooDatepicker,
+  MooCalendar,
+  MooDateRangePicker,
+  Sidebar,
+  Slider: MooSlider,
+  initSheets
+};
+var moo_ui_default = MooUI;
+export {
+  Combobox,
+  ContextMenu,
+  DataTable,
+  MooDatepicker as Datepicker,
+  MooCalendar,
+  MooDateRangePicker,
+  Sidebar,
+  MooSlider as Slider,
+  moo_ui_default as default,
+  initSheets,
+  loadChart
+};