@threadlabs/looma 0.1.0

package/dist/index.cjs

@@ -0,0 +1,4062 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/esm/ui-avatar-group.entry.js
+var ui_avatar_group_entry_exports = {};
+__export(ui_avatar_group_entry_exports, {
+  ui_avatar_group: () => UIAvatarGroup
+});
+var uiAvatarGroupCss, OVERFLOW_ATTR, UIAvatarGroup;
+var init_ui_avatar_group_entry = __esm({
+  "dist/esm/ui-avatar-group.entry.js"() {
+    init_index_CEeiinfk();
+    uiAvatarGroupCss = () => `:host{display:flex;align-items:center;flex-direction:row-reverse;gap:0}::slotted(*:not([data-ui-avatar-group-overflow])){margin-inline-end:-0.5rem;flex-shrink:0}::slotted(*:last-of-type:not([data-ui-avatar-group-overflow])){margin-inline-end:0}.overflow{margin-inline-end:-0.5rem;display:inline-flex;align-items:center;justify-content:center;inline-size:2.5rem;block-size:2.5rem;border-radius:999px;border:1px solid var(--ui-border-default);background:var(--ui-surface-muted);color:var(--ui-text-secondary);font:inherit;font-size:0.75rem;font-weight:600;flex-shrink:0}`;
+    OVERFLOW_ATTR = "data-ui-avatar-group-overflow";
+    UIAvatarGroup = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      max = 5;
+      label = "People";
+      overflowCount = 0;
+      slotRef;
+      syncOverflow() {
+        this.updateOverflow();
+      }
+      componentDidLoad() {
+        this.slotRef?.addEventListener("slotchange", () => this.updateOverflow());
+        this.updateOverflow();
+      }
+      componentDidUpdate() {
+        this.updateOverflow();
+      }
+      updateOverflow() {
+        const slot = this.host.shadowRoot?.querySelector("slot");
+        const nodes = slot?.assignedElements() ?? Array.from(this.host.children);
+        const children = nodes.filter((el) => !el.hasAttribute(OVERFLOW_ATTR));
+        const total = children.length;
+        const visibleCount = Math.min(this.max, total);
+        const overflowCount = total > this.max ? total - this.max : 0;
+        children.forEach((el, i) => {
+          el.hidden = i >= visibleCount;
+          el.setAttribute("aria-hidden", String(i >= visibleCount));
+        });
+        this.overflowCount = overflowCount;
+      }
+      render() {
+        return h(Host, { key: "9c8fbeb6e8c87ef4d86778a70a52f48b62717728", role: "list", "aria-label": this.label || void 0 }, h("slot", { key: "432877b335f2a75f6b17a14b4be768c68ba04bfa" }), this.overflowCount > 0 && h("span", { key: "ccf8007947e5d97edcdf42b7f4740db33560956b", class: "overflow", role: "listitem", "aria-label": `${this.overflowCount} more`, "data-ui-avatar-group-overflow": true }, "+", this.overflowCount));
+      }
+      static get watchers() {
+        return {
+          "max": [{
+            "syncOverflow": 0
+          }]
+        };
+      }
+    };
+    UIAvatarGroup.style = uiAvatarGroupCss();
+  }
+});
+
+// dist/esm/ui-avatar.entry.js
+var ui_avatar_entry_exports = {};
+__export(ui_avatar_entry_exports, {
+  ui_avatar: () => UIAvatar
+});
+function toInitials(value) {
+  const tokens = value.trim().split(/\s+/).filter((token) => token.length > 0);
+  if (tokens.length === 0)
+    return "?";
+  if (tokens.length === 1)
+    return tokens[0].slice(0, 2).toUpperCase();
+  return `${tokens[0][0] ?? ""}${tokens[1][0] ?? ""}`.toUpperCase();
+}
+var uiAvatarCss, UIAvatar;
+var init_ui_avatar_entry = __esm({
+  "dist/esm/ui-avatar.entry.js"() {
+    init_index_CEeiinfk();
+    uiAvatarCss = () => `:host{display:inline-grid;place-items:center;overflow:hidden;inline-size:2.5rem;block-size:2.5rem;border-radius:999px;border:1px solid var(--ui-border-default);background:var(--ui-surface-muted);color:var(--ui-text-secondary);font:inherit;font-size:0.875rem;font-weight:600;text-transform:uppercase}.avatar{display:contents}.avatar img{grid-area:1 / 1;inline-size:100%;block-size:100%;object-fit:cover}.avatar .fallback{grid-area:1 / 1;display:inline-flex;align-items:center;justify-content:center;inline-size:100%;block-size:100%}`;
+    UIAvatar = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      src = "";
+      alt = "";
+      name = "";
+      fallback = "";
+      hasImage = false;
+      watchSrc() {
+        this.hasImage = false;
+      }
+      onImageLoad = () => {
+        this.hasImage = true;
+      };
+      onImageError = () => {
+        this.hasImage = false;
+      };
+      render() {
+        const fallbackText = this.fallback || toInitials(this.name || this.alt);
+        const label = this.alt || this.name || "Avatar";
+        return h(Host, { key: "f61c3a4e5556be947b9f573591d4db0687fd01fd", role: "img", "aria-label": label, "data-has-image": this.hasImage ? "" : void 0 }, h("div", { key: "03d4a3d1c86bb1d1779ad007ba12407230478dac", class: "avatar" }, h("img", { key: "512015d68f9118bf8b8181b5b5118c133e783baf", src: this.src, alt: label, onLoad: this.onImageLoad, onError: this.onImageError, hidden: !this.hasImage, "aria-hidden": this.hasImage ? "false" : "true" }), h("span", { key: "48b0f1f81a6465c6021d4c867af67a559b9b8a67", class: "fallback", hidden: this.hasImage, "aria-hidden": this.hasImage ? "true" : "false" }, fallbackText)));
+      }
+      static get watchers() {
+        return {
+          "src": [{
+            "watchSrc": 0
+          }]
+        };
+      }
+    };
+    UIAvatar.style = uiAvatarCss();
+  }
+});
+
+// dist/esm/ui-badge.entry.js
+var ui_badge_entry_exports = {};
+__export(ui_badge_entry_exports, {
+  ui_badge: () => UIBadge
+});
+var uiBadgeCss, UIBadge;
+var init_ui_badge_entry = __esm({
+  "dist/esm/ui-badge.entry.js"() {
+    init_index_CEeiinfk();
+    uiBadgeCss = () => `:host{display:inline-flex;align-items:center;justify-content:center;border:1px solid var(--ui-border-default);border-radius:999px;background:var(--ui-surface-muted);color:var(--ui-text-secondary);font:inherit;font-size:0.75rem;line-height:1;padding:0.25em 0.6em;white-space:nowrap}:host([data-tone='accent']){background:var(--ui-accent-solid);border-color:var(--ui-accent-solid);color:var(--ui-text-on-accent)}:host([data-tone='danger']){background:var(--ui-danger-solid);border-color:var(--ui-danger-solid);color:var(--ui-text-on-accent)}:host([data-tone='success']){background:var(--ui-success-solid);border-color:var(--ui-success-solid);color:var(--ui-text-on-accent)}:host([data-tone='warning']){background:var(--ui-warning-solid);border-color:var(--ui-warning-solid);color:var(--ui-text-primary)}:host([data-tone='info']){background:var(--ui-info-solid);border-color:var(--ui-info-solid);color:var(--ui-text-on-accent)}:host([data-variant='subtle'][data-tone='accent']){background:var(--ui-accent-soft);border-color:var(--ui-accent-soft);color:var(--ui-accent-solid)}:host([data-variant='subtle'][data-tone='danger']){background:var(--ui-danger-soft);border-color:var(--ui-danger-soft);color:var(--ui-danger-solid)}:host([data-variant='subtle'][data-tone='success']){background:var(--ui-success-soft);border-color:var(--ui-success-soft);color:var(--ui-success-solid)}:host([data-variant='subtle'][data-tone='warning']){background:var(--ui-warning-soft);border-color:var(--ui-warning-soft);color:var(--ui-warning-solid)}:host([data-variant='subtle'][data-tone='info']){background:var(--ui-info-soft);border-color:var(--ui-info-soft);color:var(--ui-info-solid)}`;
+    UIBadge = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      variant;
+      tone;
+      render() {
+        return h(Host, { key: "53eba0640816bc09ae198de29f9a1ac97c1d5f1d", "data-variant": this.variant || void 0, "data-tone": this.tone || void 0 }, h("slot", { key: "abc8a9e09c2001f222f9aa8f164da76ff8343e01" }));
+      }
+    };
+    UIBadge.style = uiBadgeCss();
+  }
+});
+
+// dist/esm/events-JwSoedEO.js
+function eventToTrigger(event) {
+  if (event instanceof KeyboardEvent)
+    return "keyboard";
+  if (event instanceof PointerEvent || event instanceof MouseEvent)
+    return "pointer";
+  return "programmatic";
+}
+function isActivationKey(event) {
+  return event.key === "Enter" || event.key === " ";
+}
+function dispatchDetail(el, name, detail) {
+  el.dispatchEvent(new CustomEvent(name, { detail, bubbles: true, composed: true }));
+}
+var init_events_JwSoedEO = __esm({
+  "dist/esm/events-JwSoedEO.js"() {
+  }
+});
+
+// dist/esm/ui-button.entry.js
+var ui_button_entry_exports = {};
+__export(ui_button_entry_exports, {
+  ui_button: () => UIButton
+});
+var uiButtonCss, UIButton;
+var init_ui_button_entry = __esm({
+  "dist/esm/ui-button.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiButtonCss = () => `:host{display:inline-flex;vertical-align:middle;color:var(--ui-text-primary)}::slotted(button){appearance:none;border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-2);background:var(--ui-surface-default);color:inherit;font:inherit;font-weight:var(--ui-font-medium, 500);line-height:var(--ui-line-height-tight);padding:var(--ui-space-2) var(--ui-space-3);cursor:pointer;transition:background-color var(--ui-motion-fast) var(--ui-motion-ease),     border-color var(--ui-motion-fast) var(--ui-motion-ease),     color var(--ui-motion-fast) var(--ui-motion-ease),     box-shadow var(--ui-motion-fast) var(--ui-motion-ease);margin:0}:host([data-size='sm'])::slotted(button){padding:var(--ui-space-1) var(--ui-space-2);font-size:0.875rem}:host([data-size='lg'])::slotted(button){padding:var(--ui-space-3) var(--ui-space-4);font-size:1rem}::slotted(button:hover:enabled){background:var(--ui-surface-muted);border-color:var(--ui-border-strong)}::slotted(button:active:enabled){background:var(--ui-surface-subtle)}:host([data-variant='solid'])::slotted(button){border-color:var(--ui-accent-solid);background:var(--ui-accent-solid);color:var(--ui-text-on-accent);box-shadow:var(--ui-shadow-xs)}:host([data-variant='solid'])::slotted(button:hover:enabled){background:var(--ui-accent-hover);border-color:var(--ui-accent-hover);box-shadow:var(--ui-shadow-sm)}:host([data-variant='solid'])::slotted(button:active:enabled){background:var(--ui-accent-active);border-color:var(--ui-accent-active);box-shadow:none}:host([data-variant='destructive'])::slotted(button){border-color:var(--ui-danger-solid);background:var(--ui-danger-solid);color:var(--ui-text-on-accent);box-shadow:var(--ui-shadow-xs)}:host([data-variant='destructive'])::slotted(button:hover:enabled){background:var(--ui-danger-hover);border-color:var(--ui-danger-hover);box-shadow:var(--ui-shadow-sm)}:host([data-variant='ghost'])::slotted(button){border-color:transparent;background:transparent}:host([data-variant='ghost'])::slotted(button:hover:enabled){background:var(--ui-surface-muted);border-color:transparent}:host([data-variant='ghost'])::slotted(button:active:enabled){background:var(--ui-surface-subtle);border-color:transparent}::slotted(button:focus-visible){outline:2px solid var(--ui-focus-ring);outline-offset:2px}::slotted(button:disabled),:host([data-disabled]){opacity:0.6;cursor:not-allowed}`;
+    UIButton = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      variant;
+      size;
+      disabled = false;
+      slotRef;
+      syncToButton() {
+        const btn = this.getButton();
+        if (!btn)
+          return;
+        this.host.dataset.variant = this.variant || "";
+        this.host.dataset.size = this.size || "";
+        this.host.dataset.disabled = this.disabled ? "true" : "";
+        btn.disabled = this.disabled;
+      }
+      componentDidLoad() {
+        this.slotRef?.addEventListener("slotchange", () => this.syncToButton());
+        this.syncToButton();
+      }
+      componentDidUpdate() {
+        this.syncToButton();
+      }
+      getButton() {
+        const slot = this.host.shadowRoot?.querySelector("slot");
+        const nodes = slot?.assignedElements() ?? Array.from(this.host.children);
+        return nodes.find((el) => el.tagName === "BUTTON") ?? null;
+      }
+      onKeydown = (e) => {
+        const btn = this.getButton();
+        if (btn || this.disabled || !isActivationKey(e))
+          return;
+        e.preventDefault();
+        this.host.click();
+      };
+      render() {
+        return h(Host, { key: "01011aa13228b9e8d10ed11b99c95ef1df91326d", "data-variant": this.variant || void 0, "data-size": this.size || void 0, "data-disabled": this.disabled ? "" : void 0, onKeyDown: this.onKeydown }, h("slot", { key: "2bf0274d2732ea46fdf016a46d85bbe6e0d96bba", ref: (el) => this.slotRef = el }));
+      }
+      static get watchers() {
+        return {
+          "variant": [{
+            "syncToButton": 0
+          }],
+          "size": [{
+            "syncToButton": 0
+          }],
+          "disabled": [{
+            "syncToButton": 0
+          }]
+        };
+      }
+    };
+    UIButton.style = uiButtonCss();
+  }
+});
+
+// dist/esm/ui-checkbox.entry.js
+var ui_checkbox_entry_exports = {};
+__export(ui_checkbox_entry_exports, {
+  ui_checkbox: () => UICheckbox
+});
+var uiCheckboxCss, UICheckbox;
+var init_ui_checkbox_entry = __esm({
+  "dist/esm/ui-checkbox.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiCheckboxCss = () => `:host{display:inline-flex;align-items:center;gap:var(--ui-space-2);color:var(--ui-text-primary)}:host([aria-disabled='true']),:host([data-disabled='true']){opacity:0.6;cursor:not-allowed}::slotted(input[type='checkbox']){accent-color:var(--ui-accent-solid);width:1.125em;height:1.125em;cursor:pointer}::slotted(input[type='checkbox']:focus-visible){outline:2px solid var(--ui-accent-solid);outline-offset:2px}`;
+    UICheckbox = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      checked = false;
+      defaultChecked = false;
+      disabled = false;
+      indeterminate = false;
+      required = false;
+      value = "on";
+      internalChecked = false;
+      slotRef;
+      syncFromProp() {
+        this.internalChecked = this.checked;
+      }
+      syncToInput() {
+        const input = this.getInput();
+        if (!input)
+          return;
+        this.host.dataset.disabled = this.disabled ? "true" : "";
+        this.host.setAttribute("aria-disabled", String(this.disabled));
+        input.checked = this.internalChecked;
+        input.indeterminate = this.indeterminate;
+        input.disabled = this.disabled;
+        input.required = this.required;
+        input.value = this.value;
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.internalChecked = this.internalChecked || this.defaultChecked;
+        this.slotRef?.addEventListener("slotchange", () => this.syncToInput());
+        this.syncToInput();
+        const input = this.getInput();
+        input?.addEventListener("change", this.onInputChange);
+      }
+      disconnectedCallback() {
+        const input = this.getInput();
+        input?.removeEventListener("change", this.onInputChange);
+      }
+      componentDidUpdate() {
+        this.syncToInput();
+      }
+      getInput() {
+        const slot = this.host.shadowRoot?.querySelector("slot");
+        const nodes = slot?.assignedElements() ?? Array.from(this.host.children);
+        return nodes.find((el) => el instanceof HTMLInputElement && el.type === "checkbox") ?? null;
+      }
+      onInputChange = (e) => {
+        const input = e.target;
+        if (!input)
+          return;
+        this.internalChecked = input.checked;
+        this.indeterminate = input.indeterminate;
+        dispatchDetail(this.host, "change", {
+          checked: this.internalChecked,
+          value: this.value,
+          trigger: eventToTrigger(e)
+        });
+      };
+      render() {
+        return h(Host, { key: "c125eb000960f63f48ae8a96e8f001c843f8baa7", role: "checkbox", "aria-checked": this.indeterminate ? "mixed" : String(this.internalChecked), "aria-disabled": String(this.disabled), "data-disabled": this.disabled ? "" : void 0 }, h("slot", { key: "8eade76069c56e00d160488c5d91dae7b46ccc99", ref: (el) => this.slotRef = el }));
+      }
+      static get watchers() {
+        return {
+          "checked": [{
+            "syncFromProp": 0
+          }],
+          "internalChecked": [{
+            "syncToInput": 0
+          }],
+          "indeterminate": [{
+            "syncToInput": 0
+          }],
+          "disabled": [{
+            "syncToInput": 0
+          }],
+          "required": [{
+            "syncToInput": 0
+          }]
+        };
+      }
+    };
+    UICheckbox.style = uiCheckboxCss();
+  }
+});
+
+// dist/esm/manager-CR7f2MQC.js
+function syncScrollLock() {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const root = document.documentElement;
+  if (modalCount > 0) {
+    root.setAttribute(scrollLockAttribute, "true");
+    root.style.overflow = "hidden";
+    return;
+  }
+  root.removeAttribute(scrollLockAttribute);
+  root.style.removeProperty("overflow");
+}
+function getOverlayDismissible(record) {
+  return record.dismissible ?? true;
+}
+function handleEscape(event) {
+  if (event.key !== "Escape") {
+    return;
+  }
+  requestTopOverlayClose("escape", "keyboard");
+}
+function handleLightDismiss(event) {
+  const top = getTopOverlay();
+  if (!top || !getOverlayDismissible(top)) {
+    return;
+  }
+  const target = event.target;
+  if (target instanceof Node && top.element.contains(target)) {
+    return;
+  }
+  requestTopOverlayClose("light-dismiss", "pointer");
+}
+function ensureListeners() {
+  if (listenersAttached || typeof document === "undefined") {
+    return;
+  }
+  document.addEventListener("keydown", handleEscape);
+  document.addEventListener("pointerdown", handleLightDismiss, { capture: true });
+  listenersAttached = true;
+}
+function removeListenersIfIdle() {
+  if (!listenersAttached || stack.length > 0 || typeof document === "undefined") {
+    return;
+  }
+  document.removeEventListener("keydown", handleEscape);
+  document.removeEventListener("pointerdown", handleLightDismiss, { capture: true });
+  listenersAttached = false;
+}
+function openOverlay(record) {
+  closeOverlay(record.id);
+  stack.push(record);
+  if (record.modal) {
+    modalCount += 1;
+    syncScrollLock();
+  }
+  ensureListeners();
+}
+function closeOverlay(id) {
+  const index = stack.findIndex((record) => record.id === id);
+  if (index >= 0) {
+    const [record] = stack.splice(index, 1);
+    if (record?.modal) {
+      modalCount = Math.max(0, modalCount - 1);
+      syncScrollLock();
+    }
+  }
+  removeListenersIfIdle();
+}
+function getTopOverlay() {
+  return stack.at(-1);
+}
+function requestTopOverlayClose(reason, trigger) {
+  const top = getTopOverlay();
+  if (!top) {
+    return false;
+  }
+  if (!getOverlayDismissible(top) && (reason === "escape" || reason === "light-dismiss")) {
+    return false;
+  }
+  top.requestClose(reason, trigger);
+  return true;
+}
+var stack, scrollLockAttribute, modalCount, listenersAttached;
+var init_manager_CR7f2MQC = __esm({
+  "dist/esm/manager-CR7f2MQC.js"() {
+    stack = [];
+    scrollLockAttribute = "data-ui-scroll-lock";
+    modalCount = 0;
+    listenersAttached = false;
+  }
+});
+
+// dist/esm/ui-context-menu.entry.js
+var ui_context_menu_entry_exports = {};
+__export(ui_context_menu_entry_exports, {
+  ui_context_menu: () => UIContextMenu
+});
+var uiContextMenuCss, UIContextMenu;
+var init_ui_context_menu_entry = __esm({
+  "dist/esm/ui-context-menu.entry.js"() {
+    init_index_CEeiinfk();
+    init_manager_CR7f2MQC();
+    init_events_JwSoedEO();
+    uiContextMenuCss = () => `:host{display:contents}.menu{position:fixed;z-index:var(--ui-z-overlay, 1000);min-width:12rem}.menu[data-open]{display:block}.menu:not([data-open]){display:none !important}`;
+    UIContextMenu = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      /** Controls the menu when the consumer owns open state. */
+      open = false;
+      /** Opens the menu on first client render. */
+      defaultOpen = false;
+      /** Optional id of the region that should also respond to a context-menu gesture. */
+      for;
+      internalOpen = false;
+      overlayId = `ui-context-menu-${Math.random().toString(36).slice(2, 11)}`;
+      trigger = null;
+      contextTarget = null;
+      pointerX = 0;
+      pointerY = 0;
+      syncFromProp() {
+        this.internalOpen = this.open;
+      }
+      syncTarget() {
+        this.resolveTargets();
+        this.attachTargetListeners();
+      }
+      syncOverlay() {
+        this.syncTriggerState();
+        if (this.internalOpen) {
+          openOverlay({
+            id: this.overlayId,
+            modal: false,
+            element: this.host,
+            dismissible: true,
+            requestClose: (reason, trigger) => this.closeMenu(reason, trigger)
+          });
+        } else {
+          closeOverlay(this.overlayId);
+        }
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.internalOpen = this.internalOpen || this.defaultOpen;
+        this.resolveTargets();
+        this.attachTargetListeners();
+        this.syncTriggerState();
+        this.syncOverlay();
+      }
+      componentDidUpdate() {
+        this.resolveTargets();
+        this.attachTargetListeners();
+        this.syncTriggerState();
+      }
+      disconnectedCallback() {
+        this.detachTargetListeners();
+        closeOverlay(this.overlayId);
+      }
+      resolveTargets() {
+        const previousTrigger = this.trigger;
+        const previousContextTarget = this.contextTarget;
+        const explicitTrigger = this.host.querySelector('[slot="trigger"]');
+        const referencedTarget = this.for ? document.getElementById(this.for) : null;
+        this.trigger = explicitTrigger;
+        this.contextTarget = referencedTarget ?? explicitTrigger ?? this.host.parentElement;
+        if (previousTrigger !== this.trigger || previousContextTarget !== this.contextTarget) {
+          previousTrigger?.removeEventListener("click", this.onTriggerClick);
+          previousTrigger?.removeEventListener("keydown", this.onTriggerKeydown);
+          previousContextTarget?.removeEventListener("contextmenu", this.onContextMenu);
+        }
+      }
+      attachTargetListeners() {
+        this.detachTargetListeners();
+        this.trigger?.addEventListener("click", this.onTriggerClick);
+        this.trigger?.addEventListener("keydown", this.onTriggerKeydown);
+        this.contextTarget?.addEventListener("contextmenu", this.onContextMenu);
+      }
+      detachTargetListeners() {
+        this.trigger?.removeEventListener("click", this.onTriggerClick);
+        this.trigger?.removeEventListener("keydown", this.onTriggerKeydown);
+        this.contextTarget?.removeEventListener("contextmenu", this.onContextMenu);
+      }
+      syncTriggerState() {
+        if (!this.trigger)
+          return;
+        this.trigger.setAttribute("aria-haspopup", "menu");
+        this.trigger.setAttribute("aria-expanded", this.internalOpen ? "true" : "false");
+      }
+      getItems() {
+        return Array.from(this.host.querySelectorAll("ui-menu-item")).filter((item) => !this.isItemDisabled(item));
+      }
+      focusFirstItem() {
+        requestAnimationFrame(() => this.getItems()[0]?.focus());
+      }
+      openMenu(x, y, trigger) {
+        this.pointerX = x;
+        this.pointerY = y;
+        this.internalOpen = true;
+        dispatchDetail(this.host, "open", {
+          open: true,
+          reason: "action",
+          trigger
+        });
+        this.focusFirstItem();
+      }
+      openFromTrigger(trigger) {
+        if (!this.trigger)
+          return;
+        const rect = this.trigger.getBoundingClientRect();
+        this.openMenu(rect.left, rect.bottom, trigger);
+      }
+      closeMenu(reason, trigger, returnFocus = true) {
+        if (!this.internalOpen)
+          return;
+        this.internalOpen = false;
+        dispatchDetail(this.host, "close", {
+          open: false,
+          reason,
+          trigger
+        });
+        if (returnFocus) {
+          this.trigger?.focus();
+        }
+      }
+      onTriggerClick = (event) => {
+        if (this.internalOpen) {
+          this.closeMenu("action", event.detail === 0 ? "keyboard" : "pointer");
+          return;
+        }
+        this.openFromTrigger(event.detail === 0 ? "keyboard" : "pointer");
+      };
+      onTriggerKeydown = (event) => {
+        if (event.key !== "Enter" && event.key !== " " && event.key !== "ArrowDown")
+          return;
+        event.preventDefault();
+        if (!this.internalOpen) {
+          this.openFromTrigger("keyboard");
+          return;
+        }
+        this.focusFirstItem();
+      };
+      onContextMenu = (event) => {
+        event.preventDefault();
+        this.openMenu(event.clientX, event.clientY, "pointer");
+      };
+      isItemDisabled(item) {
+        return item.getAttribute("aria-disabled") === "true" || item.hasAttribute("disabled") || item.getAttribute("disabled") === "true" || item.disabled === true;
+      }
+      onKeydown = (event) => {
+        if (!this.internalOpen)
+          return;
+        if (event.key === "Escape") {
+          event.preventDefault();
+          requestTopOverlayClose("escape", "keyboard");
+          return;
+        }
+        if (event.key === "Enter" || event.key === " ") {
+          const target = event.target.closest?.("ui-menu-item");
+          if (!target || this.isItemDisabled(target))
+            return;
+          event.preventDefault();
+          const value = target.getAttribute("value") ?? target.getAttribute("data-value") ?? "";
+          dispatchDetail(this.host, "select", { value, trigger: "keyboard" });
+          this.closeMenu("action", "keyboard");
+        }
+      };
+      onItemClick = (event) => {
+        const item = event.target.closest?.("ui-menu-item");
+        if (!item || this.isItemDisabled(item))
+          return;
+        const value = item.getAttribute("value") ?? item.getAttribute("data-value") ?? "";
+        dispatchDetail(this.host, "select", { value, trigger: "pointer" });
+        this.closeMenu("action", "pointer");
+      };
+      render() {
+        return h(Host, { key: "c57c08724714d1de8c22a4a1e86e3a790f45fa20", "data-open": this.internalOpen ? "" : void 0, onKeyDown: this.onKeydown, onClick: this.onItemClick }, h("slot", { key: "4048abb040de1125b8eb02358480914c97ea6b06", name: "trigger" }), h("div", { key: "6ce80f67142319260093903d289456070d49bfcc", class: "menu", "data-open": this.internalOpen ? "" : void 0, style: { left: `${this.pointerX}px`, top: `${this.pointerY}px` } }, h("ui-menu", { key: "2a2c22f0a797ca3a70a1399de41de2b18257abf8", open: this.internalOpen }, h("slot", { key: "252cc6e973704cd561301b5bf96f98481c6c74ff" }))));
+      }
+      static get watchers() {
+        return {
+          "open": [{
+            "syncFromProp": 0
+          }],
+          "for": [{
+            "syncTarget": 0
+          }],
+          "internalOpen": [{
+            "syncOverlay": 0
+          }]
+        };
+      }
+    };
+    UIContextMenu.style = uiContextMenuCss();
+  }
+});
+
+// dist/esm/ui-dialog.entry.js
+var ui_dialog_entry_exports = {};
+__export(ui_dialog_entry_exports, {
+  ui_dialog: () => UIDialog
+});
+var uiDialogCss, UIDialog;
+var init_ui_dialog_entry = __esm({
+  "dist/esm/ui-dialog.entry.js"() {
+    init_index_CEeiinfk();
+    init_manager_CR7f2MQC();
+    init_events_JwSoedEO();
+    uiDialogCss = () => `:host{display:block}:host:not([open]){display:none}:host dialog{--ui-dialog-duration:var(--ui-motion-base);position:fixed;inset:var(--ui-space-4);width:min(100%, 440px);max-width:min(100%, 440px);margin:auto;padding:var(--ui-space-4);background:var(--ui-surface-elevated);border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-dialog);box-shadow:var(--ui-shadow-dialog);visibility:hidden;pointer-events:none;opacity:0;transform:scale(0.96);transition:opacity var(--ui-dialog-duration) var(--ui-motion-ease),     transform var(--ui-dialog-duration) var(--ui-motion-ease),     visibility var(--ui-dialog-duration),     display var(--ui-dialog-duration) var(--ui-motion-ease) allow-discrete,     overlay var(--ui-dialog-duration) var(--ui-motion-ease) allow-discrete}:host dialog[open]{visibility:visible;pointer-events:auto;opacity:1;transform:scale(1);animation:ui-dialog-enter var(--ui-dialog-duration) var(--ui-motion-ease)}@keyframes ui-dialog-enter{from{opacity:0;transform:scale(0.96)}}:host dialog::backdrop{background-color:transparent;transition:background-color var(--ui-dialog-duration) var(--ui-motion-ease),     display var(--ui-dialog-duration) var(--ui-motion-ease) allow-discrete,     overlay var(--ui-dialog-duration) var(--ui-motion-ease) allow-discrete}:host dialog[open]::backdrop{background-color:var(--ui-overlay-backdrop);animation:ui-dialog-backdrop-enter var(--ui-dialog-duration) var(--ui-motion-ease)}@keyframes ui-dialog-backdrop-enter{from{background-color:transparent}}`;
+    UIDialog = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      open = false;
+      defaultOpen = false;
+      modal = true;
+      dismissible = true;
+      internalOpen = false;
+      overlayId = `ui-dialog-${Math.random().toString(36).slice(2, 11)}`;
+      dialogRef;
+      syncFromProp() {
+        this.internalOpen = this.open;
+      }
+      syncOpen() {
+        if (this.dialogRef) {
+          if (this.internalOpen) {
+            this.dialogRef.showModal();
+            openOverlay({
+              id: this.overlayId,
+              modal: this.modal,
+              element: this.host,
+              dismissible: this.dismissible,
+              requestClose: (reason, trigger) => this.handleRequestClose(reason, trigger)
+            });
+          } else {
+            this.dialogRef.close();
+            closeOverlay(this.overlayId);
+          }
+        }
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.internalOpen = this.internalOpen || this.defaultOpen;
+        this.dialogRef?.addEventListener("close", this.onDialogClose);
+        this.syncOpen();
+      }
+      disconnectedCallback() {
+        this.dialogRef?.removeEventListener("close", this.onDialogClose);
+        closeOverlay(this.overlayId);
+      }
+      componentDidUpdate() {
+        this.syncOpen();
+      }
+      handleRequestClose(reason, trigger) {
+        this.internalOpen = false;
+        dispatchDetail(this.host, "close", {
+          open: false,
+          reason,
+          trigger
+        });
+      }
+      onDialogClose = () => {
+        if (this.internalOpen) {
+          this.internalOpen = false;
+          closeOverlay(this.overlayId);
+          dispatchDetail(this.host, "close", {
+            open: false,
+            reason: "programmatic",
+            trigger: "programmatic"
+          });
+        }
+      };
+      onKeydown = (e) => {
+        if (e.key === "Escape") {
+          requestTopOverlayClose("escape", "keyboard");
+        }
+      };
+      render() {
+        return h(Host, { key: "2a2fcdfa1e3fac5eb3c0e3d6748cebdf388c216d", "data-open": this.internalOpen ? "" : void 0, onKeyDown: this.onKeydown }, h("dialog", { key: "c3eef2bb3bec77fa518269fce38c19c2ededda49", ref: (el) => this.dialogRef = el, open: this.internalOpen }, h("slot", { key: "9ae5c30d57096184ec287fd9dd134ff566b9fd39" })));
+      }
+      static get watchers() {
+        return {
+          "open": [{
+            "syncFromProp": 0
+          }],
+          "internalOpen": [{
+            "syncOpen": 0
+          }]
+        };
+      }
+    };
+    UIDialog.style = uiDialogCss();
+  }
+});
+
+// dist/esm/id-hgBUJRDa.js
+function createId(prefix) {
+  nextId += 1;
+  return `ui-core-${prefix}-${nextId}`;
+}
+var nextId;
+var init_id_hgBUJRDa = __esm({
+  "dist/esm/id-hgBUJRDa.js"() {
+    nextId = 0;
+  }
+});
+
+// dist/esm/ui-disclosure.entry.js
+var ui_disclosure_entry_exports = {};
+__export(ui_disclosure_entry_exports, {
+  ui_disclosure: () => UIDisclosure
+});
+var uiDisclosureCss, UIDisclosure;
+var init_ui_disclosure_entry = __esm({
+  "dist/esm/ui-disclosure.entry.js"() {
+    init_index_CEeiinfk();
+    init_id_hgBUJRDa();
+    init_events_JwSoedEO();
+    uiDisclosureCss = () => `:host{display:block}::slotted([hidden]){display:none !important}`;
+    UIDisclosure = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      open = false;
+      defaultOpen = false;
+      disabled = false;
+      internalOpen = false;
+      contentId = "";
+      trigger = null;
+      content = null;
+      syncFromProp() {
+        this.internalOpen = this.open;
+      }
+      syncState() {
+        if (this.trigger) {
+          this.trigger.setAttribute("aria-expanded", String(this.internalOpen));
+        }
+        if (this.content) {
+          this.content.hidden = !this.internalOpen;
+        }
+      }
+      componentDidLoad() {
+        this.resolveParts();
+        this.syncFromProp();
+        this.internalOpen = this.internalOpen || this.defaultOpen;
+        this.syncState();
+        this.trigger?.addEventListener("click", this.onTriggerClick);
+        this.trigger?.addEventListener("keydown", this.onTriggerKeydown);
+      }
+      disconnectedCallback() {
+        this.trigger?.removeEventListener("click", this.onTriggerClick);
+        this.trigger?.removeEventListener("keydown", this.onTriggerKeydown);
+      }
+      componentDidUpdate() {
+        this.syncState();
+      }
+      resolveParts() {
+        this.trigger = this.host.querySelector("[data-ui-disclosure-trigger], button, [aria-controls]");
+        const controlsId = this.trigger?.getAttribute("aria-controls") ?? "";
+        if (controlsId) {
+          this.content = document.getElementById(controlsId);
+        } else {
+          const children = Array.from(this.host.children);
+          this.content = children.find((c) => c !== this.trigger) ?? null;
+        }
+        if (this.trigger && this.content) {
+          if (!this.content.id) {
+            this.content.id = createId("disclosure-content");
+          }
+          this.trigger.setAttribute("aria-controls", this.content.id);
+          this.contentId = this.content.id;
+        }
+        if (this.trigger instanceof HTMLButtonElement) {
+          this.trigger.disabled = this.disabled;
+        } else if (this.trigger) {
+          this.trigger.setAttribute("aria-disabled", String(this.disabled));
+        }
+      }
+      setOpen(next, action) {
+        if (this.internalOpen === next)
+          return;
+        this.internalOpen = next;
+        dispatchDetail(this.host, next ? "open" : "close", {
+          open: next,
+          reason: action.reason,
+          trigger: action.trigger
+        });
+      }
+      onTriggerClick = (e) => {
+        if (this.disabled) {
+          e.preventDefault();
+          return;
+        }
+        this.setOpen(!this.internalOpen, { reason: "action", trigger: eventToTrigger(e) });
+      };
+      onTriggerKeydown = (e) => {
+        if (this.disabled || !isActivationKey(e))
+          return;
+        e.preventDefault();
+        this.setOpen(!this.internalOpen, { reason: "action", trigger: "keyboard" });
+      };
+      render() {
+        return h(Host, { key: "433d2a0f6efe939e1a1ae60e27464139571004db" }, h("slot", { key: "7533ae794a7ce8be044c2ff0b5d3d1b72c01575c" }));
+      }
+      static get watchers() {
+        return {
+          "open": [{
+            "syncFromProp": 0
+          }],
+          "internalOpen": [{
+            "syncState": 0
+          }]
+        };
+      }
+    };
+    UIDisclosure.style = uiDisclosureCss();
+  }
+});
+
+// dist/esm/ui-floating-action-button.entry.js
+var ui_floating_action_button_entry_exports = {};
+__export(ui_floating_action_button_entry_exports, {
+  ui_floating_action_button: () => UIFloatingActionButton
+});
+var uiFloatingActionButtonCss, UIFloatingActionButton;
+var init_ui_floating_action_button_entry = __esm({
+  "dist/esm/ui-floating-action-button.entry.js"() {
+    init_index_CEeiinfk();
+    uiFloatingActionButtonCss = () => `:host{position:fixed;inset-block-end:calc(     var(--ui-floating-action-button-bottom, var(--ui-space-6, 1.5rem)) + env(safe-area-inset-bottom)   );inset-inline-end:var(--ui-floating-action-button-inline-end, var(--ui-space-5, 1.25rem));inline-size:var(--ui-floating-action-button-size, 56px);block-size:var(--ui-floating-action-button-size, 56px);display:inline-flex;z-index:var(--ui-floating-action-button-z-index, 100)}button{appearance:none;inline-size:100%;block-size:100%;border:none;border-radius:999px;margin:0;padding:0;display:inline-flex;align-items:center;justify-content:center;background:var(--ui-floating-action-button-bg, var(--ui-accent-solid));color:var(--ui-floating-action-button-color, var(--ui-text-on-accent));box-shadow:var(     --ui-floating-action-button-shadow,     0 4px 12px color-mix(in srgb, var(--ui-accent-solid) 40%, transparent)   );cursor:pointer;transition:background-color var(--ui-motion-fast, 160ms) var(--ui-motion-ease, ease),     transform var(--ui-motion-fast, 160ms) var(--ui-motion-ease, ease),     box-shadow var(--ui-motion-fast, 160ms) var(--ui-motion-ease, ease)}button:hover:enabled{background:var(--ui-floating-action-button-hover-bg, var(--ui-accent-hover));box-shadow:var(     --ui-floating-action-button-hover-shadow,     0 6px 16px color-mix(in srgb, var(--ui-accent-solid) 50%, transparent)   )}button:active:enabled{transform:scale(var(--ui-floating-action-button-active-scale, 0.94))}button:focus-visible{outline:2px solid var(--ui-focus-ring);outline-offset:2px}button:disabled,:host([disabled]){opacity:0.6;cursor:not-allowed}::slotted(svg){inline-size:var(--ui-floating-action-button-icon-size, 24px);block-size:var(--ui-floating-action-button-icon-size, 24px);flex-shrink:0}@media (min-width: 768px){:host([mobile-only]){display:none}}`;
+    UIFloatingActionButton = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      disabled = false;
+      mobileOnly = false;
+      label = "";
+      render() {
+        return h(Host, { key: "4b5b5eb530e4ab424e1189cff83d697f28432d84", "data-disabled": this.disabled ? "" : void 0 }, h("button", { key: "f8a4b8ac90bf306434b2b905030b46c1fcbcb000", type: "button", "aria-label": this.label || void 0, disabled: this.disabled }, h("slot", { key: "500d0606ea7166669f104e42813591395fc81c3f" })));
+      }
+    };
+    UIFloatingActionButton.style = uiFloatingActionButtonCss();
+  }
+});
+
+// dist/esm/ui-form-field.entry.js
+var ui_form_field_entry_exports = {};
+__export(ui_form_field_entry_exports, {
+  ui_form_field: () => UIFormField
+});
+var uiFormFieldCss, UIFormField;
+var init_ui_form_field_entry = __esm({
+  "dist/esm/ui-form-field.entry.js"() {
+    init_index_CEeiinfk();
+    init_id_hgBUJRDa();
+    uiFormFieldCss = () => `:host{display:grid;gap:var(--ui-space-2);color:var(--ui-text-primary)}::slotted(label){color:var(--ui-text-secondary);font-size:0.95rem}::slotted([data-slot='help']){color:var(--ui-text-muted);font-size:0.875rem}::slotted([data-slot='error']),::slotted([role='alert']){color:var(--ui-accent-active);font-size:0.875rem}`;
+    UIFormField = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      invalid = false;
+      disabled = false;
+      required = false;
+      componentDidLoad() {
+        this.wire();
+      }
+      componentDidUpdate() {
+        this.wire();
+      }
+      wire() {
+        const label = this.host.querySelector("label");
+        const input = this.host.querySelector("input, textarea, select");
+        const help = this.host.querySelector('[data-slot="help"]');
+        const error = this.host.querySelector('[data-slot="error"], [role="alert"]');
+        if (!input)
+          return;
+        if (!input.id) {
+          input.id = createId("form-field-input");
+        }
+        if (label && !label.getAttribute("for")) {
+          label.setAttribute("for", input.id);
+        }
+        const describedIds = [];
+        if (help) {
+          if (!help.id)
+            help.id = createId("form-field-help");
+          describedIds.push(help.id);
+        }
+        if (error) {
+          if (!error.id)
+            error.id = createId("form-field-error");
+          describedIds.push(error.id);
+        }
+        if (describedIds.length) {
+          input.setAttribute("aria-describedby", describedIds.join(" "));
+        }
+        input.disabled = this.disabled;
+        input.required = this.required;
+        input.setAttribute("aria-invalid", this.invalid ? "true" : "false");
+      }
+      render() {
+        return h(Host, { key: "f2eb3a7bf493c0630ef27ee21fca1ffee94be536", "data-invalid": this.invalid ? "" : void 0, "data-disabled": this.disabled ? "" : void 0, "data-required": this.required ? "" : void 0 }, h("slot", { key: "f5f30e388ed9473ee50103f12527a1dd9cfb0b0b" }));
+      }
+    };
+    UIFormField.style = uiFormFieldCss();
+  }
+});
+
+// dist/esm/ui-icon-button.entry.js
+var ui_icon_button_entry_exports = {};
+__export(ui_icon_button_entry_exports, {
+  ui_icon_button: () => UIIconButton
+});
+var uiIconButtonCss, UIIconButton;
+var init_ui_icon_button_entry = __esm({
+  "dist/esm/ui-icon-button.entry.js"() {
+    init_index_CEeiinfk();
+    uiIconButtonCss = () => `:host{display:inline-flex;color:var(--ui-text-secondary)}button{appearance:none;inline-size:var(--ui-icon-button-size, 2.5rem);block-size:var(--ui-icon-button-size, 2.5rem);min-inline-size:var(--ui-icon-button-size, 2.5rem);min-block-size:var(--ui-icon-button-size, 2.5rem);padding:0;margin:0;border:1px solid transparent;border-radius:var(--ui-icon-button-radius, var(--ui-radius-2));background:var(--ui-icon-button-bg, transparent);color:inherit;display:inline-flex;align-items:center;justify-content:center;cursor:pointer;transition:background-color var(--ui-motion-fast) var(--ui-motion-ease),     border-color var(--ui-motion-fast) var(--ui-motion-ease),     color var(--ui-motion-fast) var(--ui-motion-ease),     box-shadow var(--ui-motion-fast) var(--ui-motion-ease),     transform var(--ui-motion-fast) var(--ui-motion-ease)}:host([size='sm']) button{inline-size:var(--ui-icon-button-size-sm, 2rem);block-size:var(--ui-icon-button-size-sm, 2rem);min-inline-size:var(--ui-icon-button-size-sm, 2rem);min-block-size:var(--ui-icon-button-size-sm, 2rem)}:host([size='lg']) button{inline-size:var(--ui-icon-button-size-lg, 2.75rem);block-size:var(--ui-icon-button-size-lg, 2.75rem);min-inline-size:var(--ui-icon-button-size-lg, 2.75rem);min-block-size:var(--ui-icon-button-size-lg, 2.75rem)}:host([variant='outline']) button{border-color:var(--ui-icon-button-border, var(--ui-border-default));background:var(--ui-icon-button-outline-bg, var(--ui-surface-default));color:var(--ui-icon-button-outline-color, var(--ui-text-primary))}:host([variant='solid']) button{background:var(--ui-icon-button-solid-bg, var(--ui-accent-solid));color:var(--ui-icon-button-solid-color, var(--ui-text-on-accent));box-shadow:var(     --ui-icon-button-solid-shadow,     0 1px 2px color-mix(in srgb, var(--ui-accent-solid) 18%, transparent)   )}button:hover:enabled{background:var(--ui-icon-button-hover-bg, var(--ui-surface-muted));color:var(--ui-icon-button-hover-color, var(--ui-text-primary))}:host([variant='outline']) button:hover:enabled{border-color:var(--ui-icon-button-hover-border, var(--ui-border-strong))}:host([variant='solid']) button:hover:enabled{background:var(--ui-icon-button-solid-hover-bg, var(--ui-accent-hover))}button:active:enabled{transform:scale(var(--ui-icon-button-active-scale, 0.96))}button:focus-visible{outline:2px solid var(--ui-focus-ring);outline-offset:2px}button:disabled,:host([disabled]){opacity:0.6;cursor:not-allowed}::slotted(svg){inline-size:var(--ui-icon-button-icon-size, 1.125rem);block-size:var(--ui-icon-button-icon-size, 1.125rem);flex-shrink:0;stroke-width:var(--ui-icon-button-icon-stroke-width, 1.75)}`;
+    UIIconButton = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      disabled = false;
+      label = "";
+      size = "md";
+      variant = "ghost";
+      render() {
+        return h(Host, { key: "8f4c7271505fa061da954f1e989fc526dc980407", "data-disabled": this.disabled ? "" : void 0 }, h("button", { key: "c56009d4028a557cd6f7f19833b0af6412b90c1c", type: "button", "aria-label": this.label || void 0, disabled: this.disabled }, h("slot", { key: "ac2f201b0fbedb23106f72135ff8c3b6f25fca60" })));
+      }
+    };
+    UIIconButton.style = uiIconButtonCss();
+  }
+});
+
+// dist/esm/ui-input.entry.js
+var ui_input_entry_exports = {};
+__export(ui_input_entry_exports, {
+  ui_input: () => UIInput
+});
+var uiInputCss, UIInput;
+var init_ui_input_entry = __esm({
+  "dist/esm/ui-input.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiInputCss = () => `:host{display:inline-flex;color:var(--ui-text-primary)}::slotted(input){width:100%;appearance:none;border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-2);background:var(--ui-surface-default);color:inherit;font:inherit;line-height:var(--ui-line-height-md);padding:var(--ui-space-2) var(--ui-space-3);margin:0;transition:border-color var(--ui-motion-fast) var(--ui-motion-ease),     box-shadow var(--ui-motion-fast) var(--ui-motion-ease),     background-color var(--ui-motion-fast) var(--ui-motion-ease)}::slotted(input:hover:not(:focus):not(:disabled)){border-color:var(--ui-border-strong)}::slotted(input:focus){border-color:var(--ui-focus-ring);box-shadow:0 0 0 3px var(--ui-accent-soft)}:host([data-invalid='true'])::slotted(input),::slotted(input[aria-invalid='true']){border-color:var(--ui-accent-active)}::slotted(input:disabled){background:var(--ui-surface-muted);color:var(--ui-text-muted);cursor:not-allowed}::slotted(input:focus-visible){outline:2px solid var(--ui-focus-ring);outline-offset:2px}`;
+    UIInput = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      value = "";
+      defaultValue = "";
+      disabled = false;
+      invalid = false;
+      readOnly = false;
+      internalValue = "";
+      slotRef;
+      syncFromProp() {
+        this.internalValue = this.value;
+      }
+      syncToInput() {
+        const input = this.getInput();
+        if (!input)
+          return;
+        this.host.dataset.invalid = this.invalid ? "true" : "";
+        input.value = this.internalValue;
+        input.defaultValue = this.defaultValue;
+        input.disabled = this.disabled;
+        input.readOnly = this.readOnly;
+        input.setAttribute("aria-invalid", this.invalid ? "true" : "false");
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.slotRef?.addEventListener("slotchange", () => this.syncToInput());
+        this.syncToInput();
+        const input = this.getInput();
+        input?.addEventListener("input", this.onInput);
+        input?.addEventListener("change", this.onChange);
+      }
+      disconnectedCallback() {
+        const input = this.getInput();
+        input?.removeEventListener("input", this.onInput);
+        input?.removeEventListener("change", this.onChange);
+      }
+      componentDidUpdate() {
+        this.syncToInput();
+      }
+      getInput() {
+        const slot = this.host.shadowRoot?.querySelector("slot");
+        const nodes = slot?.assignedElements() ?? Array.from(this.host.children);
+        return nodes.find((el) => el.tagName === "INPUT") ?? null;
+      }
+      onInput = (e) => {
+        const input = e.target;
+        if (!input)
+          return;
+        this.internalValue = input.value;
+        dispatchDetail(this.host, "input", {
+          value: this.internalValue,
+          trigger: eventToTrigger(e)
+        });
+      };
+      onChange = (e) => {
+        const input = this.getInput();
+        if (!input)
+          return;
+        this.internalValue = input.value;
+        dispatchDetail(this.host, "change", {
+          value: this.internalValue,
+          trigger: eventToTrigger(e)
+        });
+      };
+      render() {
+        return h(Host, { key: "73f518c7f12fa483d592041d185498bd91f9bb8b", "data-invalid": this.invalid ? "" : void 0 }, h("slot", { key: "7ef93ef7c5d36ccdfa66cfb4d14f08707e9ea790", ref: (el) => this.slotRef = el }));
+      }
+      static get watchers() {
+        return {
+          "value": [{
+            "syncFromProp": 0
+          }],
+          "internalValue": [{
+            "syncToInput": 0
+          }],
+          "defaultValue": [{
+            "syncToInput": 0
+          }],
+          "disabled": [{
+            "syncToInput": 0
+          }],
+          "invalid": [{
+            "syncToInput": 0
+          }],
+          "readOnly": [{
+            "syncToInput": 0
+          }]
+        };
+      }
+    };
+    UIInput.style = uiInputCss();
+  }
+});
+
+// dist/esm/ui-menu-item.entry.js
+var ui_menu_item_entry_exports = {};
+__export(ui_menu_item_entry_exports, {
+  ui_menu_item: () => UIMenuItem
+});
+var uiMenuItemCss, UIMenuItem;
+var init_ui_menu_item_entry = __esm({
+  "dist/esm/ui-menu-item.entry.js"() {
+    init_index_CEeiinfk();
+    uiMenuItemCss = () => `:host{display:block;width:100%;padding:var(--ui-space-2) var(--ui-space-3);text-align:left;background:none;border:none;border-radius:var(--ui-radius-2);color:var(--ui-text-primary);font-size:var(--ui-font-size-md);font-weight:var(--ui-font-medium, 500);cursor:pointer;transition:background-color var(--ui-motion-fast) var(--ui-motion-ease),     color var(--ui-motion-fast) var(--ui-motion-ease)}:host(:hover:not([aria-disabled='true']):not([disabled])){background:var(--ui-surface-subtle)}:host([aria-disabled='true']),:host([disabled]){opacity:0.6;cursor:not-allowed}`;
+    UIMenuItem = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      disabled = false;
+      value = "";
+      render() {
+        return h(Host, { key: "485ac24af80b72a751f6fc13a084847ba0f7605e", role: "menuitem", tabIndex: this.disabled ? -1 : 0, "aria-disabled": this.disabled ? "true" : void 0, "data-value": this.value || void 0 }, h("slot", { key: "b2bde48d9b819b0e55fbe00c2939ccd44f63bc15" }));
+      }
+    };
+    UIMenuItem.style = uiMenuItemCss();
+  }
+});
+
+// dist/esm/ui-menu.entry.js
+var ui_menu_entry_exports = {};
+__export(ui_menu_entry_exports, {
+  ui_menu: () => UIMenu
+});
+var uiMenuCss, UIMenu;
+var init_ui_menu_entry = __esm({
+  "dist/esm/ui-menu.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiMenuCss = () => `:host{display:flex;flex-direction:column;min-width:12rem;padding:var(--ui-space-1);background:var(--ui-surface-elevated);border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-3);box-shadow:var(--ui-shadow-lg)}::slotted(ui-menu-item){display:block;width:100%;padding:var(--ui-space-2) var(--ui-space-3);text-align:left;background:none;border:none;border-radius:var(--ui-radius-2);color:var(--ui-text-primary);font-size:var(--ui-font-size-md);font-weight:var(--ui-font-medium, 500);cursor:pointer;transition:background-color var(--ui-motion-fast) var(--ui-motion-ease),     color var(--ui-motion-fast) var(--ui-motion-ease)}::slotted(ui-menu-item:hover:not([aria-disabled='true']):not([disabled])){background:var(--ui-surface-subtle)}::slotted(ui-menu-item[aria-disabled='true']),::slotted(ui-menu-item[disabled]){opacity:0.6;cursor:not-allowed}`;
+    UIMenu = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      open = false;
+      defaultOpen = false;
+      internalOpen = false;
+      syncFromProp() {
+        this.internalOpen = this.open;
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.internalOpen = this.internalOpen || this.defaultOpen;
+        this.host.addEventListener("click", this.onItemClick);
+        this.host.addEventListener("keydown", this.onKeydown);
+      }
+      disconnectedCallback() {
+        this.host.removeEventListener("click", this.onItemClick);
+        this.host.removeEventListener("keydown", this.onKeydown);
+      }
+      getItems() {
+        return Array.from(this.host.querySelectorAll("ui-menu-item"));
+      }
+      isItemDisabled(item) {
+        return item.getAttribute("aria-disabled") === "true" || item.hasAttribute("disabled") || item.getAttribute("disabled") === "true" || item.disabled === true;
+      }
+      onItemClick = (e) => {
+        const item = e.target.closest?.("ui-menu-item");
+        if (!item || item.getRootNode() !== this.host.getRootNode())
+          return;
+        if (this.isItemDisabled(item))
+          return;
+        const value = item.getAttribute("value") ?? item.getAttribute("data-value") ?? "";
+        dispatchDetail(this.host, "select", { value, trigger: eventToTrigger(e) });
+        dispatchDetail(this.host, "close", {
+          open: false,
+          reason: "action",
+          trigger: eventToTrigger(e)
+        });
+        this.internalOpen = false;
+      };
+      onKeydown = (e) => {
+        const items = this.getItems().filter((i) => !this.isItemDisabled(i));
+        if (items.length === 0)
+          return;
+        const target = e.target.closest?.("ui-menu-item");
+        const currentIndex = target && target instanceof HTMLElement ? items.indexOf(target) : -1;
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          if (target && currentIndex >= 0) {
+            const value = target.getAttribute("value") ?? target.getAttribute("data-value") ?? "";
+            dispatchDetail(this.host, "select", { value, trigger: "keyboard" });
+            dispatchDetail(this.host, "close", {
+              open: false,
+              reason: "action",
+              trigger: "keyboard"
+            });
+            this.internalOpen = false;
+          }
+          return;
+        }
+        if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+          e.preventDefault();
+          const nextIndex = e.key === "ArrowDown" ? currentIndex < 0 ? 0 : Math.min(currentIndex + 1, items.length - 1) : currentIndex <= 0 ? items.length - 1 : currentIndex - 1;
+          items[nextIndex].focus();
+        }
+      };
+      render() {
+        return h(Host, { key: "f06ad0f8c09060495757ced2da095817409720b7", role: "menu", "aria-orientation": "vertical", "data-open": this.internalOpen ? "" : void 0 }, h("slot", { key: "d504fd3c33894d0e464b957ce67c75fe8a24899c" }));
+      }
+      static get watchers() {
+        return {
+          "open": [{
+            "syncFromProp": 0
+          }]
+        };
+      }
+    };
+    UIMenu.style = uiMenuCss();
+  }
+});
+
+// dist/esm/ui-popover.entry.js
+var ui_popover_entry_exports = {};
+__export(ui_popover_entry_exports, {
+  ui_popover: () => UIPopover
+});
+var uiPopoverCss, UIPopover;
+var init_ui_popover_entry = __esm({
+  "dist/esm/ui-popover.entry.js"() {
+    init_index_CEeiinfk();
+    init_manager_CR7f2MQC();
+    init_events_JwSoedEO();
+    uiPopoverCss = () => `:host{padding:var(--ui-space-3);background:var(--ui-surface-elevated);border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-3);box-shadow:var(--ui-shadow-lg);max-width:min(20rem, 90vw)}`;
+    UIPopover = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      open = false;
+      defaultOpen = false;
+      internalOpen = false;
+      overlayId = `ui-popover-${Math.random().toString(36).slice(2, 11)}`;
+      syncFromProp() {
+        this.internalOpen = this.open;
+      }
+      onOpenChange() {
+        this.syncOverlay();
+        if (this.internalOpen) {
+          dispatchDetail(this.host, "open", {
+            open: true,
+            reason: "programmatic",
+            trigger: "programmatic"
+          });
+        } else {
+          dispatchDetail(this.host, "close", {
+            open: false,
+            reason: "programmatic",
+            trigger: "programmatic"
+          });
+        }
+      }
+      syncOverlay() {
+        if (this.internalOpen) {
+          openOverlay({
+            id: this.overlayId,
+            modal: false,
+            element: this.host,
+            dismissible: true,
+            requestClose: (reason, trigger) => this.handleRequestClose(reason, trigger)
+          });
+        } else {
+          closeOverlay(this.overlayId);
+        }
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.internalOpen = this.internalOpen || this.defaultOpen;
+        this.host.addEventListener("keydown", this.onKeydown);
+        this.syncOverlay();
+      }
+      disconnectedCallback() {
+        this.host.removeEventListener("keydown", this.onKeydown);
+        closeOverlay(this.overlayId);
+      }
+      componentDidUpdate() {
+        this.syncOverlay();
+      }
+      handleRequestClose(reason, trigger) {
+        this.internalOpen = false;
+        dispatchDetail(this.host, "close", {
+          open: false,
+          reason,
+          trigger
+        });
+      }
+      onKeydown = (e) => {
+        if (e.key === "Escape") {
+          requestTopOverlayClose("escape", "keyboard");
+        }
+      };
+      render() {
+        return h(Host, { key: "121482cf2fe9ba972ae6b902568389790b9accaa", "data-open": this.internalOpen ? "" : void 0, onKeyDown: this.onKeydown }, h("slot", { key: "095ce0c147ed8c8411114563c9efcb5fe775fcae" }));
+      }
+      static get watchers() {
+        return {
+          "open": [{
+            "syncFromProp": 0
+          }],
+          "internalOpen": [{
+            "onOpenChange": 0
+          }]
+        };
+      }
+    };
+    UIPopover.style = uiPopoverCss();
+  }
+});
+
+// dist/esm/ui-radio-group.entry.js
+var ui_radio_group_entry_exports = {};
+__export(ui_radio_group_entry_exports, {
+  ui_radio_group: () => UIRadioGroup
+});
+var uiRadioGroupCss, UIRadioGroup;
+var init_ui_radio_group_entry = __esm({
+  "dist/esm/ui-radio-group.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiRadioGroupCss = () => `:host{display:inline-flex;align-items:center;gap:var(--ui-space-2)}:host([data-orientation='vertical']){display:inline-grid;justify-items:start}`;
+    UIRadioGroup = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      value = "";
+      name = "";
+      orientation = "horizontal";
+      disabled = false;
+      required = false;
+      internalValue = "";
+      syncFromProp() {
+        this.internalValue = this.value;
+      }
+      syncToRadios() {
+        const radios = this.getRadios();
+        radios.forEach((radio) => {
+          radio.checked = (radio.getAttribute("value") ?? "") === this.internalValue;
+          radio.name = this.name || this.groupId;
+          if (this.disabled) {
+            radio.setAttribute("aria-disabled", "true");
+            radio.setAttribute("data-disabled", "true");
+          } else {
+            radio.removeAttribute("aria-disabled");
+            radio.removeAttribute("data-disabled");
+          }
+        });
+        this.updateRovingTabindex();
+      }
+      groupId = `ui-radio-group-${Math.random().toString(36).slice(2, 9)}`;
+      componentDidLoad() {
+        this.syncFromProp();
+        this.syncToRadios();
+        this.host.addEventListener("change", this.onRadioChange);
+        this.host.addEventListener("keydown", this.onKeydown);
+      }
+      disconnectedCallback() {
+        this.host.removeEventListener("change", this.onRadioChange);
+        this.host.removeEventListener("keydown", this.onKeydown);
+      }
+      componentDidUpdate() {
+        this.syncToRadios();
+      }
+      getRadios() {
+        return Array.from(this.host.querySelectorAll("ui-radio"));
+      }
+      updateRovingTabindex() {
+        const radios = this.getRadios();
+        const currentIndex = radios.findIndex((r) => (r.getAttribute("value") ?? "") === this.internalValue);
+        radios.forEach((r, i) => {
+          const input = r.querySelector('input[type="radio"]');
+          if (input) {
+            input.tabIndex = i === (currentIndex >= 0 ? currentIndex : 0) ? 0 : -1;
+          }
+        });
+      }
+      setValue(newValue, trigger) {
+        const prev = this.internalValue;
+        this.internalValue = newValue;
+        this.syncToRadios();
+        dispatchDetail(this.host, "select", { value: newValue, previousValue: prev, trigger });
+        dispatchDetail(this.host, "change", {
+          checked: true,
+          value: newValue,
+          trigger
+        });
+      }
+      onRadioChange = (e) => {
+        const target = e.target.closest?.("ui-radio");
+        if (!target || target.getRootNode() !== this.host.getRootNode())
+          return;
+        const value = target.getAttribute("value") ?? "";
+        if (value && value !== this.internalValue) {
+          this.setValue(value, eventToTrigger(e));
+        }
+      };
+      onKeydown = (e) => {
+        const radios = this.getRadios();
+        if (radios.length === 0)
+          return;
+        const currentIndex = radios.findIndex((r) => (r.getAttribute("value") ?? "") === this.internalValue);
+        const axis = this.orientation === "vertical" ? "vertical" : "horizontal";
+        const isPrev = axis === "horizontal" ? e.key === "ArrowLeft" : e.key === "ArrowUp";
+        const isNext = axis === "horizontal" ? e.key === "ArrowRight" : e.key === "ArrowDown";
+        if (!isPrev && !isNext)
+          return;
+        e.preventDefault();
+        let nextIndex;
+        if (isNext) {
+          nextIndex = currentIndex < 0 ? 0 : Math.min(currentIndex + 1, radios.length - 1);
+        } else {
+          nextIndex = currentIndex <= 0 ? radios.length - 1 : currentIndex - 1;
+        }
+        const nextRadio = radios[nextIndex];
+        const nextValue = nextRadio?.getAttribute("value") ?? "";
+        if (nextValue) {
+          this.setValue(nextValue, "keyboard");
+          nextRadio?.querySelector('input[type="radio"]')?.focus();
+        }
+      };
+      render() {
+        return h(Host, { key: "5182efff607bcf9add3f0981ce2af3a42bd356b8", role: "radiogroup", "aria-orientation": this.orientation, "data-orientation": this.orientation, "data-disabled": this.disabled ? "" : void 0 }, h("slot", { key: "2889bc2abecddf3e7cf81cd54053bdd608559dfc" }));
+      }
+      static get watchers() {
+        return {
+          "value": [{
+            "syncFromProp": 0
+          }],
+          "internalValue": [{
+            "syncToRadios": 0
+          }],
+          "name": [{
+            "syncToRadios": 0
+          }],
+          "orientation": [{
+            "syncToRadios": 0
+          }],
+          "disabled": [{
+            "syncToRadios": 0
+          }]
+        };
+      }
+    };
+    UIRadioGroup.style = uiRadioGroupCss();
+  }
+});
+
+// dist/esm/ui-radio.entry.js
+var ui_radio_entry_exports = {};
+__export(ui_radio_entry_exports, {
+  ui_radio: () => UIRadio
+});
+var uiRadioCss, UIRadio;
+var init_ui_radio_entry = __esm({
+  "dist/esm/ui-radio.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiRadioCss = () => `:host{display:inline-flex;align-items:center;gap:var(--ui-space-2);color:var(--ui-text-primary)}:host([data-disabled='true']),:host([aria-disabled='true']){opacity:0.6;cursor:not-allowed}::slotted(input[type='radio']){accent-color:var(--ui-accent-solid);cursor:pointer}::slotted(input[type='radio']:focus-visible){outline:2px solid var(--ui-accent-solid);outline-offset:2px}`;
+    UIRadio = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      checked = false;
+      defaultChecked = false;
+      disabled = false;
+      name = "";
+      required = false;
+      value = "on";
+      slotRef;
+      syncToInput() {
+        const input = this.getInput();
+        if (!input)
+          return;
+        this.host.dataset.disabled = this.disabled ? "true" : "";
+        input.checked = this.checked;
+        input.disabled = this.disabled;
+        input.name = this.name;
+        input.required = this.required;
+        input.value = this.value;
+      }
+      componentDidLoad() {
+        if (!this.checked && this.defaultChecked) {
+          this.checked = true;
+        }
+        this.slotRef?.addEventListener("slotchange", () => this.syncToInput());
+        this.syncToInput();
+        const input = this.getInput();
+        input?.addEventListener("change", this.onInputChange);
+      }
+      disconnectedCallback() {
+        const input = this.getInput();
+        input?.removeEventListener("change", this.onInputChange);
+      }
+      componentDidUpdate() {
+        this.syncToInput();
+      }
+      getInput() {
+        const slot = this.host.shadowRoot?.querySelector("slot");
+        const nodes = slot?.assignedElements() ?? Array.from(this.host.children);
+        return nodes.find((el) => el instanceof HTMLInputElement && el.type === "radio") ?? null;
+      }
+      onInputChange = (e) => {
+        const input = e.target;
+        if (!input || !input.checked)
+          return;
+        dispatchDetail(this.host, "change", {
+          checked: true,
+          value: this.value,
+          trigger: eventToTrigger(e)
+        });
+      };
+      render() {
+        return h(Host, { key: "85a3e7f7903c910f6ccbc324ab38bf94ebaf93e0", role: "radio", "aria-checked": String(this.checked), "aria-disabled": String(this.disabled), "data-disabled": this.disabled ? "" : void 0 }, h("slot", { key: "9117391004b9ed10cb4e819a629f66d32661d7d3", ref: (el) => this.slotRef = el }));
+      }
+      static get watchers() {
+        return {
+          "checked": [{
+            "syncToInput": 0
+          }],
+          "disabled": [{
+            "syncToInput": 0
+          }],
+          "name": [{
+            "syncToInput": 0
+          }],
+          "required": [{
+            "syncToInput": 0
+          }],
+          "value": [{
+            "syncToInput": 0
+          }]
+        };
+      }
+    };
+    UIRadio.style = uiRadioCss();
+  }
+});
+
+// dist/esm/ui-search-result-row.entry.js
+var ui_search_result_row_entry_exports = {};
+__export(ui_search_result_row_entry_exports, {
+  ui_search_result_row: () => UISearchResultRow
+});
+function slotHasContent(slot) {
+  if (!slot) {
+    return false;
+  }
+  return slot.assignedNodes({ flatten: true }).some((node) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      return Boolean(node.textContent?.trim());
+    }
+    return true;
+  });
+}
+var uiSearchResultRowCss, UISearchResultRow;
+var init_ui_search_result_row_entry = __esm({
+  "dist/esm/ui-search-result-row.entry.js"() {
+    init_index_CEeiinfk();
+    uiSearchResultRowCss = () => `:host{display:block}.search-result-row{appearance:none;inline-size:100%;min-block-size:var(--ui-search-result-row-min-height, 56px);margin:0;padding-block:var(--ui-search-result-row-padding-block, var(--ui-space-3, 0.75rem));padding-inline:var(--ui-search-result-row-padding-inline, var(--ui-space-4, 1rem));display:flex;align-items:flex-start;gap:var(--ui-search-result-row-gap, var(--ui-space-3, 0.75rem));background:var(--ui-search-result-row-bg, transparent);border:none;border-block-end:1px solid var(--ui-search-result-row-border, var(--ui-border, #e5e7eb));color:inherit;cursor:pointer;text-align:left;transition:background-color var(--ui-motion-fast, 160ms) var(--ui-motion-ease, ease)}:host(:last-child) .search-result-row{border-block-end:none}.search-result-row:hover:enabled{background:var(--ui-search-result-row-hover-bg, color-mix(in srgb, var(--ui-surface, #ffffff) 85%, black 3%))}:host([selected]) .search-result-row{background:var(     --ui-search-result-row-selected-bg,     var(--ui-search-result-row-hover-bg, color-mix(in srgb, var(--ui-surface, #ffffff) 85%, black 3%))   )}.search-result-row:focus-visible{outline:2px solid var(--ui-focus-ring, #2563eb);outline-offset:-2px}.search-result-row:disabled,:host([disabled]) .search-result-row{opacity:0.6;cursor:not-allowed}.search-result-row__leading,.search-result-row__trailing{display:inline-flex;align-items:flex-start;flex-shrink:0}.search-result-row__content{min-inline-size:0;flex:1;display:flex;flex-direction:column}.search-result-row__title,.search-result-row__meta,.search-result-row__excerpt{display:block;min-inline-size:0}[hidden]{display:none}::slotted([slot='title']),::slotted([slot='meta']),::slotted([slot='excerpt']){display:block;margin:0}`;
+    UISearchResultRow = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      disabled = false;
+      selected = false;
+      hasLeading = false;
+      hasMeta = false;
+      hasExcerpt = false;
+      hasTrailing = false;
+      leadingSlot;
+      metaSlot;
+      excerptSlot;
+      trailingSlot;
+      componentDidLoad() {
+        this.syncSlots();
+      }
+      syncSlots = () => {
+        this.hasLeading = slotHasContent(this.leadingSlot);
+        this.hasMeta = slotHasContent(this.metaSlot);
+        this.hasExcerpt = slotHasContent(this.excerptSlot);
+        this.hasTrailing = slotHasContent(this.trailingSlot);
+      };
+      render() {
+        return h(Host, { key: "abd055ed3b7a9140f024181377fd6c0e9b270578" }, h("button", { key: "af6758ec890a63d11e11180f3cccfd94112b9804", class: "search-result-row", type: "button", disabled: this.disabled, part: "button" }, h("span", { key: "e7321d522ac45566e836382d525463825c855afc", class: "search-result-row__leading", part: "leading", hidden: !this.hasLeading }, h("slot", { key: "90f578306f8b9c321128f705369531b64d54cca2", name: "leading", ref: (el) => this.leadingSlot = el, onSlotchange: this.syncSlots })), h("span", { key: "37a8ab0b4b19215d1a4c79d92646b18e010be8a0", class: "search-result-row__content", part: "content" }, h("span", { key: "1728598d9e9578cf6f04f13c1691e333b7d5ca25", class: "search-result-row__title", part: "title" }, h("slot", { key: "556b9da285b7e64298527870a970ef8c02e71988", name: "title" })), h("span", { key: "ed47e52ad83968ca763e01ae7d9d3d66d444145a", class: "search-result-row__meta", part: "meta", hidden: !this.hasMeta }, h("slot", { key: "c374d6328951530227892eec688edd60514e7e04", name: "meta", ref: (el) => this.metaSlot = el, onSlotchange: this.syncSlots })), h("span", { key: "17965c7934d9256ce243a1d3a3e880716fcd42e1", class: "search-result-row__excerpt", part: "excerpt", hidden: !this.hasExcerpt }, h("slot", { key: "67cad2d2ea2310944cdf5a7685a1f4e3f537e683", name: "excerpt", ref: (el) => this.excerptSlot = el, onSlotchange: this.syncSlots }))), h("span", { key: "43cb13c90187851fc30cc0c29847658f9f4cb069", class: "search-result-row__trailing", part: "trailing", hidden: !this.hasTrailing }, h("slot", { key: "2b262ad21cb605daea5e4ade8c377a60820a1f11", name: "trailing", ref: (el) => this.trailingSlot = el, onSlotchange: this.syncSlots }))));
+      }
+    };
+    UISearchResultRow.style = uiSearchResultRowCss();
+  }
+});
+
+// dist/esm/ui-search-shell.entry.js
+var ui_search_shell_entry_exports = {};
+__export(ui_search_shell_entry_exports, {
+  ui_search_shell: () => UISearchShell
+});
+function slotHasContent2(slot) {
+  if (!slot) {
+    return false;
+  }
+  return slot.assignedNodes({ flatten: true }).some((node) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      return Boolean(node.textContent?.trim());
+    }
+    return true;
+  });
+}
+var uiSearchShellCss, UISearchShell;
+var init_ui_search_shell_entry = __esm({
+  "dist/esm/ui-search-shell.entry.js"() {
+    init_index_CEeiinfk();
+    uiSearchShellCss = () => `:host{position:fixed;inset:0;z-index:var(--ui-search-shell-z-index, 400);display:block}.search-shell{position:absolute;inset:0;display:flex;align-items:flex-start;justify-content:center;padding-block-start:var(--ui-search-shell-padding-top, 10vh)}.search-shell__panel{position:relative;inline-size:min(     calc(100% - (var(--ui-search-shell-margin-inline, var(--ui-space-4, 1rem)) * 2)),     var(--ui-search-shell-max-width, 640px)   );max-block-size:var(--ui-search-shell-max-height, 80vh);display:flex;flex-direction:column;overflow:hidden;background:var(--ui-search-shell-bg, var(--ui-surface, #ffffff));border:1px solid var(--ui-search-shell-border, var(--ui-border, #e5e7eb));border-radius:var(--ui-search-shell-radius, var(--ui-radius-xl, 1rem));box-shadow:var(--ui-search-shell-shadow, var(--ui-shadow-lg, 0 8px 24px rgba(0, 0, 0, 0.12)))}.search-shell__search,.search-shell__status,.search-shell__footer{flex-shrink:0}.search-shell__body{flex:1;min-block-size:0}[hidden]{display:none}@media (max-width: 767px){.search-shell{padding-block-start:0;align-items:stretch}.search-shell__panel{inline-size:100%;max-block-size:100dvh;border-radius:0;border-inline:none;border-block-start:none}}`;
+    UISearchShell = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      hasStatus = false;
+      hasFooter = false;
+      statusSlot;
+      footerSlot;
+      componentDidLoad() {
+        this.syncSlots();
+      }
+      syncSlots = () => {
+        this.hasStatus = slotHasContent2(this.statusSlot);
+        this.hasFooter = slotHasContent2(this.footerSlot);
+      };
+      render() {
+        return h("div", { key: "3e8fb4f419a588c441abd5bd137093ba2f730b76", class: "search-shell", part: "base" }, h("slot", { key: "4772932f9e077b0e4f68c50657945f3ea30afb8d", name: "backdrop" }), h("div", { key: "c7877bb3ade588797d8419b3c7efc0680ac32b78", class: "search-shell__panel", part: "panel" }, h("div", { key: "d1e7c16a031896187550181be63a1ca14a04b127", class: "search-shell__search", part: "search" }, h("slot", { key: "b61475159d7e18a623246a2872d4897e1ff8388a", name: "search" })), h("div", { key: "877a9847bb453d026b5e6c117ffa8ad44562195a", class: "search-shell__status", part: "status", hidden: !this.hasStatus }, h("slot", { key: "6b46e668586fa97a30e2d02fc7d46d53483ecdb5", name: "status", ref: (el) => this.statusSlot = el, onSlotchange: this.syncSlots })), h("div", { key: "41622e5fe3b02d8c842a6d07b66119ac68f22bc0", class: "search-shell__body", part: "body" }, h("slot", { key: "f36dc433657d95bb7afa1191351bbbbeaed4f6ed", name: "body" })), h("div", { key: "bcbf35d5e37c0fe48b29dde935745ea792722646", class: "search-shell__footer", part: "footer", hidden: !this.hasFooter }, h("slot", { key: "02f99e3442476dbefc57b3a38dc5a4ad0f3e9f00", name: "footer", ref: (el) => this.footerSlot = el, onSlotchange: this.syncSlots }))));
+      }
+    };
+    UISearchShell.style = uiSearchShellCss();
+  }
+});
+
+// dist/esm/ui-select.entry.js
+var ui_select_entry_exports = {};
+__export(ui_select_entry_exports, {
+  ui_select: () => UISelect
+});
+var uiSelectCss, UISelect;
+var init_ui_select_entry = __esm({
+  "dist/esm/ui-select.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiSelectCss = () => `:host{display:inline-flex;color:var(--ui-text-primary)}::slotted(select){width:100%;appearance:none;border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-2);background-color:var(--ui-surface-default);color:inherit;font:inherit;line-height:var(--ui-line-height-md);padding-block:var(--ui-select-padding-block, var(--ui-space-2));padding-inline-start:var(--ui-select-padding-inline-start, var(--ui-space-3));padding-inline-end:var(--ui-select-padding-inline-end, calc(var(--ui-space-6) + var(--ui-space-3)));margin:0;background-image:linear-gradient(45deg, transparent 50%, currentColor 50%),     linear-gradient(135deg, currentColor 50%, transparent 50%);background-position:calc(100% - 1rem) calc(50% - 2px),     calc(100% - 0.7rem) calc(50% - 2px);background-size:0.35rem 0.35rem, 0.35rem 0.35rem;background-repeat:no-repeat;transition:border-color var(--ui-motion-fast) var(--ui-motion-ease),     box-shadow var(--ui-motion-fast) var(--ui-motion-ease),     background-color var(--ui-motion-fast) var(--ui-motion-ease)}::slotted(select:hover:not(:focus):not(:disabled)){border-color:var(--ui-border-strong)}::slotted(select:focus){border-color:var(--ui-focus-ring);box-shadow:0 0 0 3px var(--ui-accent-soft)}:host([data-invalid='true'])::slotted(select),::slotted(select[aria-invalid='true']){border-color:var(--ui-accent-active)}::slotted(select:disabled){background-color:var(--ui-surface-muted);color:var(--ui-text-muted);cursor:not-allowed}::slotted(select:focus-visible){outline:2px solid var(--ui-focus-ring);outline-offset:2px}::slotted(select[multiple]),::slotted(select[size]:not([size='1'])){background-image:none;padding-inline-end:var(--ui-select-padding-inline-start, var(--ui-space-3))}`;
+    UISelect = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      value = "";
+      defaultValue = "";
+      disabled = false;
+      invalid = false;
+      required = false;
+      internalValue = "";
+      slotRef;
+      syncFromProp() {
+        this.internalValue = this.value;
+      }
+      syncToSelect() {
+        const select = this.getSelect();
+        if (!select)
+          return;
+        this.host.dataset.invalid = this.invalid ? "true" : "";
+        select.value = this.internalValue || this.defaultValue;
+        select.disabled = this.disabled;
+        select.required = this.required;
+        select.setAttribute("aria-invalid", this.invalid ? "true" : "false");
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.slotRef?.addEventListener("slotchange", () => this.syncToSelect());
+        this.syncToSelect();
+        const select = this.getSelect();
+        select?.addEventListener("input", this.onInput);
+        select?.addEventListener("change", this.onChange);
+      }
+      disconnectedCallback() {
+        const select = this.getSelect();
+        select?.removeEventListener("input", this.onInput);
+        select?.removeEventListener("change", this.onChange);
+      }
+      componentDidUpdate() {
+        this.syncToSelect();
+      }
+      getSelect() {
+        const slot = this.host.shadowRoot?.querySelector("slot");
+        const nodes = slot?.assignedElements() ?? Array.from(this.host.children);
+        return nodes.find((el) => el.tagName === "SELECT") ?? null;
+      }
+      onInput = (e) => {
+        const select = e.target;
+        if (!select)
+          return;
+        this.internalValue = select.value;
+        dispatchDetail(this.host, "input", {
+          value: this.internalValue,
+          trigger: eventToTrigger(e)
+        });
+      };
+      onChange = (e) => {
+        const select = this.getSelect();
+        if (!select)
+          return;
+        this.internalValue = select.value;
+        dispatchDetail(this.host, "change", {
+          value: this.internalValue,
+          trigger: eventToTrigger(e)
+        });
+      };
+      render() {
+        return h(Host, { key: "eebea3f7fafafba901e5bd33cbd711565feb251e", "data-invalid": this.invalid ? "" : void 0 }, h("slot", { key: "bbb49202d8298fac0912accb3848c8450cab00c9", ref: (el) => this.slotRef = el }));
+      }
+      static get watchers() {
+        return {
+          "value": [{
+            "syncFromProp": 0
+          }],
+          "internalValue": [{
+            "syncToSelect": 0
+          }],
+          "defaultValue": [{
+            "syncToSelect": 0
+          }],
+          "disabled": [{
+            "syncToSelect": 0
+          }],
+          "invalid": [{
+            "syncToSelect": 0
+          }],
+          "required": [{
+            "syncToSelect": 0
+          }]
+        };
+      }
+    };
+    UISelect.style = uiSelectCss();
+  }
+});
+
+// dist/esm/ui-switch.entry.js
+var ui_switch_entry_exports = {};
+__export(ui_switch_entry_exports, {
+  ui_switch: () => UISwitch
+});
+var uiSwitchCss, UISwitch;
+var init_ui_switch_entry = __esm({
+  "dist/esm/ui-switch.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiSwitchCss = () => `:host{display:inline-flex;align-items:center;gap:var(--ui-space-2);color:var(--ui-text-primary)}:host([aria-disabled='true']),:host([data-disabled='true']){opacity:0.6;cursor:not-allowed}:host([role='switch']){cursor:pointer}:host input[type='checkbox']{appearance:none;-webkit-appearance:none;display:block;position:relative;width:2.25rem;height:1.25rem;padding:0;border:1px solid var(--ui-border-default);border-radius:999px;background:var(--ui-surface-muted);cursor:pointer;transition:background-color var(--ui-motion-fast) var(--ui-motion-ease),     border-color var(--ui-motion-fast) var(--ui-motion-ease);margin:0}:host input[type='checkbox']::after{content:'';position:absolute;top:2px;left:2px;width:0.875rem;height:0.875rem;border-radius:999px;background:var(--ui-surface-default);border:1px solid var(--ui-border-default);transition:transform var(--ui-motion-fast) var(--ui-motion-ease)}:host input[type='checkbox']:checked{background:var(--ui-accent-solid);border-color:var(--ui-accent-solid)}:host input[type='checkbox']:checked::after{transform:translateX(calc(2.25rem - 0.875rem - 4px));background:var(--ui-text-on-accent);border-color:var(--ui-text-on-accent)}:host input[type='checkbox']:focus-visible{outline:2px solid var(--ui-accent-solid);outline-offset:2px}`;
+    UISwitch = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      checked = false;
+      defaultChecked = false;
+      disabled = false;
+      required = false;
+      value = "on";
+      internalChecked = false;
+      syncFromProp() {
+        this.internalChecked = this.checked;
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.internalChecked = this.internalChecked || this.defaultChecked;
+      }
+      toggle = (trigger) => {
+        if (this.disabled)
+          return;
+        this.internalChecked = !this.internalChecked;
+        dispatchDetail(this.host, "change", {
+          checked: this.internalChecked,
+          value: this.value,
+          trigger
+        });
+      };
+      onKeydown = (e) => {
+        if (e.key !== " " || this.disabled)
+          return;
+        e.preventDefault();
+        this.toggle("keyboard");
+      };
+      onClick = (e) => {
+        if (e.target === this.host?.shadowRoot?.querySelector("input"))
+          return;
+        this.toggle("pointer");
+      };
+      render() {
+        return h(Host, { key: "d4e39c8865afa98414dbedcbbff5bdeeef7f4478", role: "switch", "aria-checked": String(this.internalChecked), "aria-disabled": String(this.disabled), "data-disabled": this.disabled ? "" : void 0, tabIndex: this.disabled ? -1 : 0, onKeyDown: this.onKeydown, onClick: this.onClick }, h("input", { key: "498774428224b9d09a8657924d4d8b6a2196fddf", type: "checkbox", checked: this.internalChecked, disabled: this.disabled, required: this.required, value: this.value, "aria-hidden": "true", tabIndex: -1, onChange: (e) => {
+          this.internalChecked = e.target.checked;
+          dispatchDetail(this.host, "change", {
+            checked: this.internalChecked,
+            value: this.value,
+            trigger: "pointer"
+          });
+        } }), h("slot", { key: "b8f8c3947a9dd058e12270b9afdfe2a654164987" }));
+      }
+      static get watchers() {
+        return {
+          "checked": [{
+            "syncFromProp": 0
+          }]
+        };
+      }
+    };
+    UISwitch.style = uiSwitchCss();
+  }
+});
+
+// dist/esm/ui-tabs.entry.js
+var ui_tabs_entry_exports = {};
+__export(ui_tabs_entry_exports, {
+  ui_tabs: () => UITabs
+});
+var uiTabsCss, UITabs;
+var init_ui_tabs_entry = __esm({
+  "dist/esm/ui-tabs.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiTabsCss = () => `:host{display:flex;flex-direction:column;gap:0}:host([data-orientation='vertical']){flex-direction:row}::slotted([role='tablist']){display:flex;gap:0;border-bottom:1px solid var(--ui-border-default)}:host([data-orientation='vertical']) ::slotted([role='tablist']){flex-direction:column;border-bottom:none;border-inline-end:1px solid var(--ui-border-default)}::slotted(button[role='tab']),::slotted([role='tab']),::slotted(ui-button) button[role='tab']{padding:var(--ui-space-2) var(--ui-space-3);font-size:var(--ui-font-size-sm);font-weight:var(--ui-font-medium, 500);color:var(--ui-text-secondary);background:none;border:none;border-bottom:2px solid transparent;margin-bottom:-1px;cursor:pointer;transition:color var(--ui-motion-fast) var(--ui-motion-ease);box-shadow:none}::slotted(button[role='tab']:hover),::slotted([role='tab']:hover){color:var(--ui-text-primary)}::slotted(button[role='tab'][aria-selected='true']),::slotted([role='tab'][aria-selected='true']){color:var(--ui-accent-solid);border-bottom-color:var(--ui-accent-solid)}:host([data-orientation='vertical']) ::slotted(button[role='tab']),:host([data-orientation='vertical']) ::slotted([role='tab']){border-bottom:none;border-inline-end:2px solid transparent;margin-bottom:0;margin-inline-end:-1px}:host([data-orientation='vertical']) ::slotted(button[role='tab'][aria-selected='true']),:host([data-orientation='vertical']) ::slotted([role='tab'][aria-selected='true']){border-inline-end-color:var(--ui-accent-solid)}::slotted([role='tabpanel']){padding:var(--ui-space-4)}`;
+    UITabs = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      value = "";
+      defaultValue = "";
+      orientation = "horizontal";
+      internalValue = "";
+      syncFromProp() {
+        this.internalValue = this.value;
+      }
+      syncState() {
+        const tabs = this.getTabs();
+        if (tabs.length === 0)
+          return;
+        tabs.forEach((tab) => {
+          const tabId = tab.id ?? tab.getAttribute("aria-controls") ?? "";
+          const isSelected = tabId === this.internalValue;
+          tab.setAttribute("aria-selected", String(isSelected));
+          tab.tabIndex = isSelected ? 0 : -1;
+          const controlsId = tab.getAttribute("aria-controls");
+          if (controlsId) {
+            const panel = this.host.querySelector(`#${CSS.escape(controlsId)}`) ?? document.getElementById(controlsId);
+            if (panel) {
+              panel.hidden = !isSelected;
+            }
+          }
+        });
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        if (!this.internalValue && this.defaultValue) {
+          this.internalValue = this.defaultValue;
+        }
+        if (!this.internalValue) {
+          const tabs = this.getTabs();
+          if (tabs.length > 0) {
+            this.internalValue = tabs[0]?.id ?? tabs[0]?.getAttribute("aria-controls") ?? "";
+          }
+        }
+        this.syncState();
+        this.host.addEventListener("keydown", this.onKeydown);
+        this.host.addEventListener("click", this.onClick);
+      }
+      disconnectedCallback() {
+        this.host.removeEventListener("keydown", this.onKeydown);
+        this.host.removeEventListener("click", this.onClick);
+      }
+      componentDidUpdate() {
+        this.syncState();
+      }
+      getTabs() {
+        return Array.from(this.host.querySelectorAll('[role="tab"]'));
+      }
+      setValueFromTab(tab, trigger) {
+        const newValue = tab.id ?? tab.getAttribute("aria-controls") ?? "";
+        if (!newValue)
+          return;
+        const prev = this.internalValue;
+        this.internalValue = newValue;
+        this.syncState();
+        dispatchDetail(this.host, "select", { value: newValue, previousValue: prev || void 0, trigger });
+      }
+      onClick = (e) => {
+        const tab = e.target.closest?.('[role="tab"]');
+        if (!tab || !this.host.contains(tab))
+          return;
+        this.setValueFromTab(tab, eventToTrigger(e));
+      };
+      onKeydown = (e) => {
+        const tab = e.target.closest?.('[role="tab"]');
+        if (!tab || !this.host.contains(tab))
+          return;
+        const tabs = this.getTabs();
+        if (tabs.length === 0)
+          return;
+        const currentIndex = tabs.indexOf(tab);
+        const isVertical = this.orientation === "vertical";
+        const prevKey = isVertical ? "ArrowUp" : "ArrowLeft";
+        const nextKey = isVertical ? "ArrowDown" : "ArrowRight";
+        if (e.key === nextKey || e.key === prevKey) {
+          e.preventDefault();
+          const nextIndex = e.key === nextKey ? Math.min(currentIndex + 1, tabs.length - 1) : currentIndex <= 0 ? tabs.length - 1 : currentIndex - 1;
+          this.setValueFromTab(tabs[nextIndex], "keyboard");
+          tabs[nextIndex].focus();
+        }
+      };
+      render() {
+        return h(Host, { key: "d73e97facf3ffa020f349642bc6c0136f39fc463", orientation: this.orientation, "data-orientation": this.orientation }, h("slot", { key: "a7bd47a4b48780ddf1f21a917fd1cb747376640b" }));
+      }
+      static get watchers() {
+        return {
+          "value": [{
+            "syncFromProp": 0
+          }],
+          "internalValue": [{
+            "syncState": 0
+          }],
+          "orientation": [{
+            "syncState": 0
+          }]
+        };
+      }
+    };
+    UITabs.style = uiTabsCss();
+  }
+});
+
+// dist/esm/ui-textarea.entry.js
+var ui_textarea_entry_exports = {};
+__export(ui_textarea_entry_exports, {
+  ui_textarea: () => UITextarea
+});
+var uiTextareaCss, UITextarea;
+var init_ui_textarea_entry = __esm({
+  "dist/esm/ui-textarea.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiTextareaCss = () => `:host{display:inline-flex;color:var(--ui-text-primary)}::slotted(textarea){width:100%;appearance:none;border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-2);background:var(--ui-surface-default);color:inherit;font:inherit;line-height:var(--ui-line-height-md);min-block-size:calc(var(--ui-space-12, 3rem) * 2);padding:var(--ui-space-2) var(--ui-space-3);margin:0;resize:vertical;transition:border-color var(--ui-motion-fast) var(--ui-motion-ease),     box-shadow var(--ui-motion-fast) var(--ui-motion-ease),     background-color var(--ui-motion-fast) var(--ui-motion-ease)}::slotted(textarea:hover:not(:focus):not(:disabled)){border-color:var(--ui-border-strong)}::slotted(textarea:focus){border-color:var(--ui-focus-ring);box-shadow:0 0 0 3px var(--ui-accent-soft)}:host([data-invalid='true'])::slotted(textarea),::slotted(textarea[aria-invalid='true']){border-color:var(--ui-accent-active)}::slotted(textarea:disabled){background:var(--ui-surface-muted);color:var(--ui-text-muted);cursor:not-allowed}::slotted(textarea:focus-visible){outline:2px solid var(--ui-focus-ring);outline-offset:2px}`;
+    UITextarea = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      value = "";
+      defaultValue = "";
+      disabled = false;
+      invalid = false;
+      readOnly = false;
+      rows = 4;
+      internalValue = "";
+      slotRef;
+      syncFromProp() {
+        this.internalValue = this.value;
+      }
+      syncToTextarea() {
+        const textarea = this.getTextarea();
+        if (!textarea)
+          return;
+        this.host.dataset.invalid = this.invalid ? "true" : "";
+        textarea.value = this.internalValue;
+        textarea.defaultValue = this.defaultValue;
+        textarea.disabled = this.disabled;
+        textarea.readOnly = this.readOnly;
+        textarea.rows = this.rows;
+        textarea.setAttribute("aria-invalid", this.invalid ? "true" : "false");
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.slotRef?.addEventListener("slotchange", () => this.syncToTextarea());
+        this.syncToTextarea();
+        const textarea = this.getTextarea();
+        textarea?.addEventListener("input", this.onInput);
+        textarea?.addEventListener("change", this.onChange);
+      }
+      disconnectedCallback() {
+        const textarea = this.getTextarea();
+        textarea?.removeEventListener("input", this.onInput);
+        textarea?.removeEventListener("change", this.onChange);
+      }
+      componentDidUpdate() {
+        this.syncToTextarea();
+      }
+      getTextarea() {
+        const slot = this.host.shadowRoot?.querySelector("slot");
+        const nodes = slot?.assignedElements() ?? Array.from(this.host.children);
+        return nodes.find((el) => el.tagName === "TEXTAREA") ?? null;
+      }
+      onInput = (e) => {
+        const textarea = e.target;
+        if (!textarea)
+          return;
+        this.internalValue = textarea.value;
+        dispatchDetail(this.host, "input", {
+          value: this.internalValue,
+          trigger: eventToTrigger(e)
+        });
+      };
+      onChange = (e) => {
+        const textarea = this.getTextarea();
+        if (!textarea)
+          return;
+        this.internalValue = textarea.value;
+        dispatchDetail(this.host, "change", {
+          value: this.internalValue,
+          trigger: eventToTrigger(e)
+        });
+      };
+      render() {
+        return h(Host, { key: "d52719875939fa9b2f757a35fb4cd1aa31a194c5", "data-invalid": this.invalid ? "" : void 0 }, h("slot", { key: "e40ba71b60cae07437219d6ab4b5879b26af1ac2", ref: (el) => this.slotRef = el }));
+      }
+      static get watchers() {
+        return {
+          "value": [{
+            "syncFromProp": 0
+          }],
+          "internalValue": [{
+            "syncToTextarea": 0
+          }],
+          "defaultValue": [{
+            "syncToTextarea": 0
+          }],
+          "disabled": [{
+            "syncToTextarea": 0
+          }],
+          "invalid": [{
+            "syncToTextarea": 0
+          }],
+          "readOnly": [{
+            "syncToTextarea": 0
+          }],
+          "rows": [{
+            "syncToTextarea": 0
+          }]
+        };
+      }
+    };
+    UITextarea.style = uiTextareaCss();
+  }
+});
+
+// dist/esm/ui-toast-region.entry.js
+var ui_toast_region_entry_exports = {};
+__export(ui_toast_region_entry_exports, {
+  ui_toast_region: () => UIToastRegion
+});
+var uiToastRegionCss, UIToastRegion;
+var init_ui_toast_region_entry = __esm({
+  "dist/esm/ui-toast-region.entry.js"() {
+    init_index_CEeiinfk();
+    init_events_JwSoedEO();
+    uiToastRegionCss = () => `:host{position:fixed;top:var(--ui-space-4);left:50%;transform:translateX(-50%);z-index:9999;display:grid;gap:var(--ui-space-2);max-width:min(24rem, 90vw);pointer-events:none}:host>*{pointer-events:auto}::slotted([data-ui-toast]){display:grid;grid-template-columns:1fr auto;gap:var(--ui-space-2);align-items:start;border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-3);padding:var(--ui-space-3) var(--ui-space-4);background:var(--ui-surface-elevated);color:var(--ui-text-primary);box-shadow:var(--ui-shadow-lg);animation:ui-toast-enter 0.25s var(--ui-motion-ease) forwards}@keyframes ui-toast-enter{from{opacity:0;transform:translateY(-0.5rem)}to{opacity:1;transform:translateY(0)}}::slotted([data-ui-toast][aria-hidden='true']){display:none}::slotted([data-ui-toast-dismiss]){border:0;background:transparent;color:var(--ui-text-secondary);cursor:pointer;font:inherit}`;
+    UIToastRegion = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      open = true;
+      internalOpen = true;
+      syncFromProp() {
+        this.internalOpen = this.open;
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.host.addEventListener("click", this.onClick);
+      }
+      disconnectedCallback() {
+        this.host.removeEventListener("click", this.onClick);
+      }
+      getToasts() {
+        return Array.from(this.host.querySelectorAll("[data-ui-toast]"));
+      }
+      updateOpenState() {
+        const toasts = this.getToasts();
+        this.internalOpen = toasts.length > 0;
+      }
+      onClick = (e) => {
+        const dismissBtn = e.target.closest?.("[data-ui-toast-dismiss]");
+        if (!dismissBtn)
+          return;
+        const toast = dismissBtn.closest?.("[data-ui-toast]");
+        if (!toast)
+          return;
+        const id = toast.id ?? "";
+        toast.setAttribute("aria-hidden", "true");
+        toast.remove();
+        dispatchDetail(this.host, "dismiss", {
+          id,
+          reason: "action",
+          trigger: eventToTrigger(e)
+        });
+        this.updateOpenState();
+        if (this.getToasts().length === 0) {
+          dispatchDetail(this.host, "close", {
+            open: false,
+            reason: "action",
+            trigger: eventToTrigger(e)
+          });
+        }
+      };
+      render() {
+        return h(Host, { key: "8e99577d8770984b8d6d29e442931570c1f1bc4d", role: "region", "aria-label": "Notifications", "data-open": this.internalOpen ? "" : void 0 }, h("slot", { key: "06f2c6cf39c4795afc0937669aa2104821aef3d6" }));
+      }
+      static get watchers() {
+        return {
+          "open": [{
+            "syncFromProp": 0
+          }]
+        };
+      }
+    };
+    UIToastRegion.style = uiToastRegionCss();
+  }
+});
+
+// dist/esm/ui-tooltip.entry.js
+var ui_tooltip_entry_exports = {};
+__export(ui_tooltip_entry_exports, {
+  ui_tooltip: () => UITooltip
+});
+var uiTooltipCss, UITooltip;
+var init_ui_tooltip_entry = __esm({
+  "dist/esm/ui-tooltip.entry.js"() {
+    init_index_CEeiinfk();
+    init_manager_CR7f2MQC();
+    init_events_JwSoedEO();
+    uiTooltipCss = () => `:host{display:inline-block;border:1px solid var(--ui-border-default);border-radius:var(--ui-radius-2);background:var(--ui-surface-elevated);color:var(--ui-text-primary);padding:var(--ui-space-2) var(--ui-space-3);font-size:var(--ui-font-size-sm);box-shadow:var(--ui-shadow-md)}:host([hidden]){display:none !important}`;
+    UITooltip = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      for = "";
+      open = false;
+      defaultOpen = false;
+      internalOpen = false;
+      overlayId = `ui-tooltip-${Math.random().toString(36).slice(2, 11)}`;
+      trigger = null;
+      syncFromProp() {
+        this.internalOpen = this.open;
+      }
+      syncOverlay() {
+        if (this.internalOpen) {
+          openOverlay({
+            id: this.overlayId,
+            modal: false,
+            element: this.host,
+            dismissible: true,
+            requestClose: (reason, trigger) => this.handleRequestClose(reason, trigger)
+          });
+        } else {
+          closeOverlay(this.overlayId);
+        }
+      }
+      componentDidLoad() {
+        this.syncFromProp();
+        this.internalOpen = this.internalOpen || this.defaultOpen;
+        this.resolveTrigger();
+        this.attachTriggerListeners();
+        this.host.addEventListener("keydown", this.onKeydown);
+        this.syncOverlay();
+      }
+      componentDidUpdate() {
+        this.resolveTrigger();
+        this.attachTriggerListeners();
+        this.syncOverlay();
+      }
+      disconnectedCallback() {
+        this.detachTriggerListeners();
+        this.host.removeEventListener("keydown", this.onKeydown);
+        closeOverlay(this.overlayId);
+      }
+      resolveTrigger() {
+        if (this.for) {
+          this.trigger = document.getElementById(this.for);
+        } else {
+          this.trigger = this.host.previousElementSibling;
+        }
+      }
+      attachTriggerListeners() {
+        this.detachTriggerListeners();
+        if (!this.trigger)
+          return;
+        this.trigger.addEventListener("pointerenter", this.onTriggerEnter);
+        this.trigger.addEventListener("pointerleave", this.onTriggerLeave);
+        this.trigger.addEventListener("focusin", this.onTriggerFocusIn);
+        this.trigger.addEventListener("focusout", this.onTriggerFocusOut);
+      }
+      detachTriggerListeners() {
+        if (!this.trigger)
+          return;
+        this.trigger.removeEventListener("pointerenter", this.onTriggerEnter);
+        this.trigger.removeEventListener("pointerleave", this.onTriggerLeave);
+        this.trigger.removeEventListener("focusin", this.onTriggerFocusIn);
+        this.trigger.removeEventListener("focusout", this.onTriggerFocusOut);
+      }
+      onTriggerEnter = () => {
+        this.internalOpen = true;
+        dispatchDetail(this.host, "open", { open: true, reason: "action", trigger: "pointer" });
+        this.syncOverlay();
+      };
+      onTriggerLeave = () => {
+        this.internalOpen = false;
+        dispatchDetail(this.host, "close", { open: false, reason: "action", trigger: "pointer" });
+        this.syncOverlay();
+      };
+      onTriggerFocusIn = () => {
+        this.internalOpen = true;
+        dispatchDetail(this.host, "open", { open: true, reason: "action", trigger: "keyboard" });
+        this.syncOverlay();
+      };
+      onTriggerFocusOut = (e) => {
+        const related = e.relatedTarget;
+        if (related && this.host.contains(related))
+          return;
+        this.internalOpen = false;
+        dispatchDetail(this.host, "close", { open: false, reason: "action", trigger: "keyboard" });
+        this.syncOverlay();
+      };
+      handleRequestClose(reason, trigger) {
+        if (reason === "escape") {
+          this.internalOpen = false;
+          dispatchDetail(this.host, "close", {
+            open: false,
+            reason: "escape",
+            trigger
+          });
+          this.trigger?.focus();
+        }
+      }
+      onKeydown = (e) => {
+        if (e.key === "Escape") {
+          requestTopOverlayClose("escape", "keyboard");
+        }
+      };
+      render() {
+        return h(Host, { key: "900ec6fc08ea7a7965195e8203fd779e70cfa6e6", role: "tooltip", hidden: !this.internalOpen, "data-open": this.internalOpen ? "" : void 0, onKeyDown: this.onKeydown }, h("slot", { key: "b384f779fa9a229cf635be5adb3476ca93270c24" }));
+      }
+      static get watchers() {
+        return {
+          "open": [{
+            "syncFromProp": 0
+          }],
+          "internalOpen": [{
+            "syncOverlay": 0
+          }]
+        };
+      }
+    };
+    UITooltip.style = uiTooltipCss();
+  }
+});
+
+// dist/esm/ui-top-bar.entry.js
+var ui_top_bar_entry_exports = {};
+__export(ui_top_bar_entry_exports, {
+  ui_top_bar: () => UITopBar
+});
+function slotHasContent3(slot) {
+  if (!slot) {
+    return false;
+  }
+  return slot.assignedNodes({ flatten: true }).some((node) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      return Boolean(node.textContent?.trim());
+    }
+    return true;
+  });
+}
+var uiTopBarCss, UITopBar;
+var init_ui_top_bar_entry = __esm({
+  "dist/esm/ui-top-bar.entry.js"() {
+    init_index_CEeiinfk();
+    uiTopBarCss = () => `:host{position:sticky;inset-block-start:0;z-index:var(--ui-top-bar-z-index, 100);display:block}.top-bar{min-block-size:var(--ui-top-bar-height, 56px);display:flex;align-items:center;gap:var(--ui-top-bar-gap, var(--ui-space-3, 0.75rem));padding-inline:var(--ui-top-bar-padding-inline, var(--ui-space-4, 1rem));background:var(--ui-top-bar-bg, var(--ui-surface, #ffffff));border-block-end:1px solid var(--ui-top-bar-border, var(--ui-border, #e5e7eb))}.top-bar__leading,.top-bar__search,.top-bar__actions{display:flex;align-items:center;flex-shrink:0}.top-bar__actions{gap:var(--ui-top-bar-actions-gap, var(--ui-space-1, 0.25rem))}.top-bar__title{min-inline-size:0;flex:1}[hidden]{display:none}@media (min-width: 768px){:host{display:none}}`;
+    UITopBar = class {
+      constructor(hostRef) {
+        registerInstance(this, hostRef);
+      }
+      get host() {
+        return getElement(this);
+      }
+      hasLeading = false;
+      hasSearch = false;
+      hasActions = false;
+      leadingSlot;
+      searchSlot;
+      actionsSlot;
+      componentDidLoad() {
+        this.syncSlots();
+      }
+      syncSlots = () => {
+        this.hasLeading = slotHasContent3(this.leadingSlot);
+        this.hasSearch = slotHasContent3(this.searchSlot);
+        this.hasActions = slotHasContent3(this.actionsSlot);
+      };
+      render() {
+        return h(Host, { key: "23cbff2fdb06a40f0380dbf217d064cb1b9f7a9c" }, h("header", { key: "9472960f4445f8ed7d0800d71db3cbac020fca3f", class: "top-bar", part: "base" }, h("div", { key: "d408be025d90fdcf1416213b9e76f3b780f47d97", class: "top-bar__leading", hidden: !this.hasLeading }, h("slot", { key: "3dc4db316a040ff10a8b8b218b42799d3e1a7b97", name: "leading", ref: (el) => this.leadingSlot = el, onSlotchange: this.syncSlots })), h("div", { key: "1b362f19f9a738600afb266e9641c0ee5c8870c9", class: "top-bar__title" }, h("slot", { key: "bb93d34a3dea15c697dcd19dc0ecc3488ee390c8" })), h("div", { key: "3d61d781b654ee1d91a6ce5ba64db9732ee1f8ee", class: "top-bar__search", hidden: !this.hasSearch }, h("slot", { key: "5731817be644f10ed745fdc0868b85b66a9c06d4", name: "search", ref: (el) => this.searchSlot = el, onSlotchange: this.syncSlots })), h("div", { key: "2ee868b93f5195832830900382545b2131e78bb8", class: "top-bar__actions", hidden: !this.hasActions }, h("slot", { key: "1d410fa60f112904cfb866cff5a3f2fb18021c93", name: "actions", ref: (el) => this.actionsSlot = el, onSlotchange: this.syncSlots }))));
+      }
+    };
+    UITopBar.style = uiTopBarCss();
+  }
+});
+
+// import("./**/*.entry.js") in dist/esm/index-CEeiinfk.js
+var globImport_entry_js;
+var init_ = __esm({
+  'import("./**/*.entry.js") in dist/esm/index-CEeiinfk.js'() {
+    globImport_entry_js = __glob({
+      "./ui-avatar-group.entry.js": () => Promise.resolve().then(() => (init_ui_avatar_group_entry(), ui_avatar_group_entry_exports)),
+      "./ui-avatar.entry.js": () => Promise.resolve().then(() => (init_ui_avatar_entry(), ui_avatar_entry_exports)),
+      "./ui-badge.entry.js": () => Promise.resolve().then(() => (init_ui_badge_entry(), ui_badge_entry_exports)),
+      "./ui-button.entry.js": () => Promise.resolve().then(() => (init_ui_button_entry(), ui_button_entry_exports)),
+      "./ui-checkbox.entry.js": () => Promise.resolve().then(() => (init_ui_checkbox_entry(), ui_checkbox_entry_exports)),
+      "./ui-context-menu.entry.js": () => Promise.resolve().then(() => (init_ui_context_menu_entry(), ui_context_menu_entry_exports)),
+      "./ui-dialog.entry.js": () => Promise.resolve().then(() => (init_ui_dialog_entry(), ui_dialog_entry_exports)),
+      "./ui-disclosure.entry.js": () => Promise.resolve().then(() => (init_ui_disclosure_entry(), ui_disclosure_entry_exports)),
+      "./ui-floating-action-button.entry.js": () => Promise.resolve().then(() => (init_ui_floating_action_button_entry(), ui_floating_action_button_entry_exports)),
+      "./ui-form-field.entry.js": () => Promise.resolve().then(() => (init_ui_form_field_entry(), ui_form_field_entry_exports)),
+      "./ui-icon-button.entry.js": () => Promise.resolve().then(() => (init_ui_icon_button_entry(), ui_icon_button_entry_exports)),
+      "./ui-input.entry.js": () => Promise.resolve().then(() => (init_ui_input_entry(), ui_input_entry_exports)),
+      "./ui-menu-item.entry.js": () => Promise.resolve().then(() => (init_ui_menu_item_entry(), ui_menu_item_entry_exports)),
+      "./ui-menu.entry.js": () => Promise.resolve().then(() => (init_ui_menu_entry(), ui_menu_entry_exports)),
+      "./ui-popover.entry.js": () => Promise.resolve().then(() => (init_ui_popover_entry(), ui_popover_entry_exports)),
+      "./ui-radio-group.entry.js": () => Promise.resolve().then(() => (init_ui_radio_group_entry(), ui_radio_group_entry_exports)),
+      "./ui-radio.entry.js": () => Promise.resolve().then(() => (init_ui_radio_entry(), ui_radio_entry_exports)),
+      "./ui-search-result-row.entry.js": () => Promise.resolve().then(() => (init_ui_search_result_row_entry(), ui_search_result_row_entry_exports)),
+      "./ui-search-shell.entry.js": () => Promise.resolve().then(() => (init_ui_search_shell_entry(), ui_search_shell_entry_exports)),
+      "./ui-select.entry.js": () => Promise.resolve().then(() => (init_ui_select_entry(), ui_select_entry_exports)),
+      "./ui-switch.entry.js": () => Promise.resolve().then(() => (init_ui_switch_entry(), ui_switch_entry_exports)),
+      "./ui-tabs.entry.js": () => Promise.resolve().then(() => (init_ui_tabs_entry(), ui_tabs_entry_exports)),
+      "./ui-textarea.entry.js": () => Promise.resolve().then(() => (init_ui_textarea_entry(), ui_textarea_entry_exports)),
+      "./ui-toast-region.entry.js": () => Promise.resolve().then(() => (init_ui_toast_region_entry(), ui_toast_region_entry_exports)),
+      "./ui-tooltip.entry.js": () => Promise.resolve().then(() => (init_ui_tooltip_entry(), ui_tooltip_entry_exports)),
+      "./ui-top-bar.entry.js": () => Promise.resolve().then(() => (init_ui_top_bar_entry(), ui_top_bar_entry_exports))
+    });
+  }
+});
+
+// dist/esm/index-CEeiinfk.js
+function getPropertyDescriptor(obj, memberName, getOnly) {
+  const stopAt = typeof HTMLElement !== "undefined" ? HTMLElement.prototype : null;
+  while (obj && obj !== stopAt) {
+    const desc = Object.getOwnPropertyDescriptor(obj, memberName);
+    if (desc && (!getOnly || desc.get)) return desc;
+    obj = Object.getPrototypeOf(obj);
+  }
+  return void 0;
+}
+function createStyleSheetIfNeededAndSupported(styles2) {
+  return void 0;
+}
+function createShadowRoot(cmpMeta) {
+  var _a;
+  const opts = { mode: "open" };
+  const shadowRoot = this.attachShadow(opts);
+  if (globalStyleSheet === void 0) globalStyleSheet = (_a = createStyleSheetIfNeededAndSupported()) != null ? _a : null;
+  if (globalStyleSheet) {
+    if (supportsMutableAdoptedStyleSheets) {
+      shadowRoot.adoptedStyleSheets.push(globalStyleSheet);
+    } else {
+      shadowRoot.adoptedStyleSheets = [...shadowRoot.adoptedStyleSheets, globalStyleSheet];
+    }
+  }
+}
+function queryNonceMetaTagContent(doc) {
+  var _a, _b, _c;
+  return (_c = (_b = (_a = doc.head) == null ? void 0 : _a.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : _b.getAttribute("content")) != null ? _c : void 0;
+}
+function sortedAttrNames(attrNames) {
+  return attrNames.includes("ref") ? (
+    // we need to sort these to ensure that `'ref'` is the last attr
+    [...attrNames.filter((attr) => attr !== "ref"), "ref"]
+  ) : (
+    // no need to sort, return the original array
+    attrNames
+  );
+}
+function transformTag(tag) {
+  return tag;
+}
+var NAMESPACE, BUILD, reWireGetterSetter, getHostRef, registerInstance, registerHost, isMemberInElement, consoleError, cmpModules, loadModule, styles, HYDRATED_CSS, SLOT_FB_CSS, win, plt, promiseResolve, supportsConstructableStylesheets, supportsMutableAdoptedStyleSheets, queuePending, queueDomReads, queueDomWrites, queueTask, consume, flush, nextTick, writeTask, globalStyleSheet, createTime, uniqueTime, rootAppliedStyles, registerStyle, addStyle, attachStyles, getScopeId, isComplexType, h, newVNode, Host, isHost, parsePropertyValue, getElement, emitEvent, setAccessor, parseClassListRegex, parseClassList, CAPTURE_EVENT_SUFFIX, CAPTURE_EVENT_REGEX, updateElement, hostTagName, useNativeShadowDom, isSvgMode, refCallbacksToRemove, refCallbacksToAttach, createElm, relocateToHostRoot, addVnodes, removeVnodes, updateChildren, isSameVnode, patch, nullifyVNodeRefs, queueRefAttachment, flushQueuedRefCallbacks, insertBefore, renderVdom, attachToAncestor, scheduleUpdate, dispatchHooks, enqueue, isPromisey, updateComponent, callRender, postUpdateComponent, appDidLoad, safeCall, addHydratedFlag, getValue, setValue, proxyComponent, initializeComponent, fireConnectedCallback, connectedCallback, disconnectInstance, disconnectedCallback, bootstrapLazy;
+var init_index_CEeiinfk = __esm({
+  "dist/esm/index-CEeiinfk.js"() {
+    /* @vite-ignore */
+    /* webpackInclude: /\.entry\.js$/ */
+    /* webpackExclude: /\.system\.entry\.js$/ */
+    /* webpackMode: "lazy" */
+    init_();
+    NAMESPACE = "looma";
+    BUILD = /* looma */
+    { hotModuleReplacement: false, hydratedSelectorName: "hydrated", lazyLoad: true, propChangeCallback: true, state: true, updatable: true };
+    reWireGetterSetter = (instance, hostRef) => {
+      var _a;
+      const cmpMeta = hostRef.$cmpMeta$;
+      const members = Object.entries((_a = cmpMeta.$members$) != null ? _a : {});
+      members.map(([memberName, [memberFlags]]) => {
+        if (memberFlags & 31 || memberFlags & 32) {
+          const ogValue = instance[memberName];
+          const ogDescriptor = getPropertyDescriptor(Object.getPrototypeOf(instance), memberName, true) || Object.getOwnPropertyDescriptor(instance, memberName);
+          if (ogDescriptor) {
+            Object.defineProperty(instance, memberName, {
+              get() {
+                return ogDescriptor.get.call(this);
+              },
+              set(newValue) {
+                ogDescriptor.set.call(this, newValue);
+              },
+              configurable: true,
+              enumerable: true
+            });
+          }
+          if (hostRef.$instanceValues$.has(memberName)) {
+            instance[memberName] = hostRef.$instanceValues$.get(memberName);
+          } else if (ogValue !== void 0) {
+            instance[memberName] = ogValue;
+          }
+        }
+      });
+    };
+    getHostRef = (ref) => {
+      if (ref.__stencil__getHostRef) {
+        return ref.__stencil__getHostRef();
+      }
+      return void 0;
+    };
+    registerInstance = (lazyInstance, hostRef) => {
+      if (!hostRef) return;
+      lazyInstance.__stencil__getHostRef = () => hostRef;
+      hostRef.$lazyInstance$ = lazyInstance;
+      if (hostRef.$cmpMeta$.$flags$ & 512 && BUILD.state) {
+        reWireGetterSetter(lazyInstance, hostRef);
+      }
+    };
+    registerHost = (hostElement, cmpMeta) => {
+      const hostRef = {
+        $flags$: 0,
+        $hostElement$: hostElement,
+        $cmpMeta$: cmpMeta,
+        $instanceValues$: /* @__PURE__ */ new Map(),
+        $serializerValues$: /* @__PURE__ */ new Map()
+      };
+      {
+        hostRef.$onReadyPromise$ = new Promise((r) => hostRef.$onReadyResolve$ = r);
+        hostElement["s-p"] = [];
+        hostElement["s-rc"] = [];
+      }
+      {
+        hostRef.$fetchedCbList$ = [];
+      }
+      const ref = hostRef;
+      hostElement.__stencil__getHostRef = () => ref;
+      return ref;
+    };
+    isMemberInElement = (elm, memberName) => memberName in elm;
+    consoleError = (e, el) => (0, console.error)(e, el);
+    cmpModules = /* @__PURE__ */ new Map();
+    loadModule = (cmpMeta, hostRef, hmrVersionId) => {
+      const exportName = cmpMeta.$tagName$.replace(/-/g, "_");
+      const bundleId = cmpMeta.$lazyBundleId$;
+      if (!bundleId) {
+        return void 0;
+      }
+      const module2 = cmpModules.get(bundleId);
+      if (module2) {
+        return module2[exportName];
+      }
+      return globImport_entry_js(`./${bundleId}.entry.js${""}`).then(
+        (importedModule) => {
+          {
+            cmpModules.set(bundleId, importedModule);
+          }
+          return importedModule[exportName];
+        },
+        (e) => {
+          consoleError(e, hostRef.$hostElement$);
+        }
+      );
+    };
+    styles = /* @__PURE__ */ new Map();
+    HYDRATED_CSS = "{visibility:hidden}.hydrated{visibility:inherit}";
+    SLOT_FB_CSS = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+    win = typeof window !== "undefined" ? window : {};
+    plt = {
+      $flags$: 0,
+      $resourcesUrl$: "",
+      jmp: (h2) => h2(),
+      raf: (h2) => requestAnimationFrame(h2),
+      ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts),
+      rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),
+      ce: (eventName, opts) => new CustomEvent(eventName, opts)
+    };
+    promiseResolve = (v) => Promise.resolve(v);
+    supportsConstructableStylesheets = /* @__PURE__ */ (() => {
+      try {
+        if (!win.document.adoptedStyleSheets) {
+          return false;
+        }
+        new CSSStyleSheet();
+        return typeof new CSSStyleSheet().replaceSync === "function";
+      } catch (e) {
+      }
+      return false;
+    })();
+    supportsMutableAdoptedStyleSheets = supportsConstructableStylesheets ? /* @__PURE__ */ (() => !!win.document && Object.getOwnPropertyDescriptor(win.document.adoptedStyleSheets, "length").writable)() : false;
+    queuePending = false;
+    queueDomReads = [];
+    queueDomWrites = [];
+    queueTask = (queue, write) => (cb) => {
+      queue.push(cb);
+      if (!queuePending) {
+        queuePending = true;
+        if (write && plt.$flags$ & 4) {
+          nextTick(flush);
+        } else {
+          plt.raf(flush);
+        }
+      }
+    };
+    consume = (queue) => {
+      for (let i2 = 0; i2 < queue.length; i2++) {
+        try {
+          queue[i2](performance.now());
+        } catch (e) {
+          consoleError(e);
+        }
+      }
+      queue.length = 0;
+    };
+    flush = () => {
+      consume(queueDomReads);
+      {
+        consume(queueDomWrites);
+        if (queuePending = queueDomReads.length > 0) {
+          plt.raf(flush);
+        }
+      }
+    };
+    nextTick = (cb) => promiseResolve().then(cb);
+    writeTask = /* @__PURE__ */ queueTask(queueDomWrites, true);
+    createTime = (fnName, tagName = "") => {
+      {
+        return () => {
+          return;
+        };
+      }
+    };
+    uniqueTime = (key, measureText) => {
+      {
+        return () => {
+          return;
+        };
+      }
+    };
+    rootAppliedStyles = /* @__PURE__ */ new WeakMap();
+    registerStyle = (scopeId2, cssText, allowCS) => {
+      let style = styles.get(scopeId2);
+      if (supportsConstructableStylesheets && allowCS) {
+        style = style || new CSSStyleSheet();
+        if (typeof style === "string") {
+          style = cssText;
+        } else {
+          style.replaceSync(cssText);
+        }
+      } else {
+        style = cssText;
+      }
+      styles.set(scopeId2, style);
+    };
+    addStyle = (styleContainerNode, cmpMeta, mode) => {
+      var _a, _b, _c;
+      const scopeId2 = getScopeId(cmpMeta);
+      const style = styles.get(scopeId2);
+      if (!win.document) {
+        return scopeId2;
+      }
+      styleContainerNode = styleContainerNode.nodeType === 11 ? styleContainerNode : win.document;
+      if (style) {
+        if (typeof style === "string") {
+          styleContainerNode = styleContainerNode.head || styleContainerNode;
+          let appliedStyles = rootAppliedStyles.get(styleContainerNode);
+          let styleElm;
+          if (!appliedStyles) {
+            rootAppliedStyles.set(styleContainerNode, appliedStyles = /* @__PURE__ */ new Set());
+          }
+          if (!appliedStyles.has(scopeId2)) {
+            styleElm = win.document.createElement("style");
+            styleElm.textContent = style;
+            const nonce = (_a = plt.$nonce$) != null ? _a : queryNonceMetaTagContent(win.document);
+            if (nonce != null) {
+              styleElm.setAttribute("nonce", nonce);
+            }
+            if (!(cmpMeta.$flags$ & 1)) {
+              if (styleContainerNode.nodeName === "HEAD") {
+                const preconnectLinks = styleContainerNode.querySelectorAll("link[rel=preconnect]");
+                const referenceNode2 = preconnectLinks.length > 0 ? preconnectLinks[preconnectLinks.length - 1].nextSibling : styleContainerNode.querySelector("style");
+                styleContainerNode.insertBefore(
+                  styleElm,
+                  (referenceNode2 == null ? void 0 : referenceNode2.parentNode) === styleContainerNode ? referenceNode2 : null
+                );
+              } else if ("host" in styleContainerNode) {
+                if (supportsConstructableStylesheets) {
+                  const currentWindow = (_b = styleContainerNode.defaultView) != null ? _b : styleContainerNode.ownerDocument.defaultView;
+                  const stylesheet = new currentWindow.CSSStyleSheet();
+                  stylesheet.replaceSync(style);
+                  if (supportsMutableAdoptedStyleSheets) {
+                    styleContainerNode.adoptedStyleSheets.unshift(stylesheet);
+                  } else {
+                    styleContainerNode.adoptedStyleSheets = [stylesheet, ...styleContainerNode.adoptedStyleSheets];
+                  }
+                } else {
+                  const existingStyleContainer = styleContainerNode.querySelector("style");
+                  if (existingStyleContainer && true) {
+                    existingStyleContainer.textContent = style + existingStyleContainer.textContent;
+                  } else {
+                    styleContainerNode.prepend(styleElm);
+                  }
+                }
+              } else {
+                styleContainerNode.append(styleElm);
+              }
+            }
+            if (cmpMeta.$flags$ & 1) {
+              styleContainerNode.insertBefore(styleElm, null);
+            }
+            if (cmpMeta.$flags$ & 4) {
+              styleElm.textContent += SLOT_FB_CSS;
+            }
+            if (appliedStyles) {
+              appliedStyles.add(scopeId2);
+            }
+          }
+        } else {
+          let appliedStyles = rootAppliedStyles.get(styleContainerNode);
+          if (!appliedStyles) {
+            rootAppliedStyles.set(styleContainerNode, appliedStyles = /* @__PURE__ */ new Set());
+          }
+          if (!appliedStyles.has(scopeId2)) {
+            const currentWindow = (_c = styleContainerNode.defaultView) != null ? _c : styleContainerNode.ownerDocument.defaultView;
+            let stylesheet;
+            if (style.constructor === currentWindow.CSSStyleSheet) {
+              stylesheet = style;
+            } else {
+              stylesheet = new currentWindow.CSSStyleSheet();
+              for (let i2 = 0; i2 < style.cssRules.length; i2++) {
+                stylesheet.insertRule(style.cssRules[i2].cssText, i2);
+              }
+            }
+            if (supportsMutableAdoptedStyleSheets) {
+              styleContainerNode.adoptedStyleSheets.push(stylesheet);
+            } else {
+              styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, stylesheet];
+            }
+            appliedStyles.add(scopeId2);
+          }
+        }
+      }
+      return scopeId2;
+    };
+    attachStyles = (hostRef) => {
+      const cmpMeta = hostRef.$cmpMeta$;
+      const elm = hostRef.$hostElement$;
+      const flags = cmpMeta.$flags$;
+      const endAttachStyles = createTime("attachStyles", cmpMeta.$tagName$);
+      const scopeId2 = addStyle(
+        elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(),
+        cmpMeta
+      );
+      if (flags & 10) {
+        elm["s-sc"] = scopeId2;
+        elm.classList.add(scopeId2 + "-h");
+      }
+      endAttachStyles();
+    };
+    getScopeId = (cmp, mode) => "sc-" + cmp.$tagName$;
+    isComplexType = (o) => {
+      o = typeof o;
+      return o === "object" || o === "function";
+    };
+    h = (nodeName, vnodeData, ...children) => {
+      if (typeof nodeName === "string") {
+        nodeName = transformTag(nodeName);
+      }
+      let child = null;
+      let key = null;
+      let simple = false;
+      let lastSimple = false;
+      const vNodeChildren = [];
+      const walk = (c) => {
+        for (let i2 = 0; i2 < c.length; i2++) {
+          child = c[i2];
+          if (Array.isArray(child)) {
+            walk(child);
+          } else if (child != null && typeof child !== "boolean") {
+            if (simple = typeof nodeName !== "function" && !isComplexType(child)) {
+              child = String(child);
+            }
+            if (simple && lastSimple) {
+              vNodeChildren[vNodeChildren.length - 1].$text$ += child;
+            } else {
+              vNodeChildren.push(simple ? newVNode(null, child) : child);
+            }
+            lastSimple = simple;
+          }
+        }
+      };
+      walk(children);
+      if (vnodeData) {
+        if (vnodeData.key) {
+          key = vnodeData.key;
+        }
+        {
+          const classData = vnodeData.className || vnodeData.class;
+          if (classData) {
+            vnodeData.class = typeof classData !== "object" ? classData : Object.keys(classData).filter((k) => classData[k]).join(" ");
+          }
+        }
+      }
+      const vnode = newVNode(nodeName, null);
+      vnode.$attrs$ = vnodeData;
+      if (vNodeChildren.length > 0) {
+        vnode.$children$ = vNodeChildren;
+      }
+      {
+        vnode.$key$ = key;
+      }
+      return vnode;
+    };
+    newVNode = (tag, text) => {
+      const vnode = {
+        $flags$: 0,
+        $tag$: tag,
+        // Normalize undefined to null to prevent rendering "undefined" as text
+        $text$: text != null ? text : null,
+        $elm$: null,
+        $children$: null
+      };
+      {
+        vnode.$attrs$ = null;
+      }
+      {
+        vnode.$key$ = null;
+      }
+      return vnode;
+    };
+    Host = {};
+    isHost = (node) => node && node.$tag$ === Host;
+    parsePropertyValue = (propValue, propType, isFormAssociated) => {
+      if (propValue != null && !isComplexType(propValue)) {
+        if (propType & 4) {
+          {
+            return propValue === "false" ? false : propValue === "" || !!propValue;
+          }
+        }
+        if (propType & 2) {
+          return typeof propValue === "string" ? parseFloat(propValue) : typeof propValue === "number" ? propValue : NaN;
+        }
+        if (propType & 1) {
+          return String(propValue);
+        }
+        return propValue;
+      }
+      return propValue;
+    };
+    getElement = (ref) => {
+      var _a;
+      return (_a = getHostRef(ref)) == null ? void 0 : _a.$hostElement$;
+    };
+    emitEvent = (elm, name, opts) => {
+      const ev = plt.ce(name, opts);
+      elm.dispatchEvent(ev);
+      return ev;
+    };
+    setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags, initialRender) => {
+      if (oldValue === newValue) {
+        return;
+      }
+      let isProp = isMemberInElement(elm, memberName);
+      let ln = memberName.toLowerCase();
+      if (memberName === "class") {
+        const classList = elm.classList;
+        const oldClasses = parseClassList(oldValue);
+        let newClasses = parseClassList(newValue);
+        {
+          classList.remove(...oldClasses.filter((c) => c && !newClasses.includes(c)));
+          classList.add(...newClasses.filter((c) => c && !oldClasses.includes(c)));
+        }
+      } else if (memberName === "style") {
+        {
+          for (const prop in oldValue) {
+            if (!newValue || newValue[prop] == null) {
+              if (prop.includes("-")) {
+                elm.style.removeProperty(prop);
+              } else {
+                elm.style[prop] = "";
+              }
+            }
+          }
+        }
+        for (const prop in newValue) {
+          if (!oldValue || newValue[prop] !== oldValue[prop]) {
+            if (prop.includes("-")) {
+              elm.style.setProperty(prop, newValue[prop]);
+            } else {
+              elm.style[prop] = newValue[prop];
+            }
+          }
+        }
+      } else if (memberName === "key") ;
+      else if (memberName === "ref") {
+        if (newValue) {
+          queueRefAttachment(newValue, elm);
+        }
+      } else if (!isProp && memberName[0] === "o" && memberName[1] === "n") {
+        if (memberName[2] === "-") {
+          memberName = memberName.slice(3);
+        } else if (isMemberInElement(win, ln)) {
+          memberName = ln.slice(2);
+        } else {
+          memberName = ln[2] + memberName.slice(3);
+        }
+        if (oldValue || newValue) {
+          const capture = memberName.endsWith(CAPTURE_EVENT_SUFFIX);
+          memberName = memberName.replace(CAPTURE_EVENT_REGEX, "");
+          if (oldValue) {
+            plt.rel(elm, memberName, oldValue, capture);
+          }
+          if (newValue) {
+            plt.ael(elm, memberName, newValue, capture);
+          }
+        }
+      } else if (memberName[0] === "a" && memberName.startsWith("attr:")) {
+        const propName = memberName.slice(5);
+        let attrName;
+        {
+          const hostRef = getHostRef(elm);
+          if (hostRef && hostRef.$cmpMeta$ && hostRef.$cmpMeta$.$members$) {
+            const memberMeta = hostRef.$cmpMeta$.$members$[propName];
+            if (memberMeta && memberMeta[1]) {
+              attrName = memberMeta[1];
+            }
+          }
+        }
+        if (!attrName) {
+          attrName = propName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+        }
+        if (newValue == null || newValue === false) {
+          if (newValue !== false || elm.getAttribute(attrName) === "") {
+            elm.removeAttribute(attrName);
+          }
+        } else {
+          elm.setAttribute(attrName, newValue === true ? "" : newValue);
+        }
+        return;
+      } else if (memberName[0] === "p" && memberName.startsWith("prop:")) {
+        const propName = memberName.slice(5);
+        try {
+          elm[propName] = newValue;
+        } catch (e) {
+        }
+        return;
+      } else {
+        const isComplex = isComplexType(newValue);
+        if ((isProp || isComplex && newValue !== null) && !isSvg) {
+          try {
+            if (!elm.tagName.includes("-")) {
+              const n = newValue == null ? "" : newValue;
+              if (memberName === "list") {
+                isProp = false;
+              } else if (oldValue == null || elm[memberName] !== n) {
+                if (typeof elm.__lookupSetter__(memberName) === "function") {
+                  elm[memberName] = n;
+                } else {
+                  elm.setAttribute(memberName, n);
+                }
+              }
+            } else if (elm[memberName] !== newValue) {
+              elm[memberName] = newValue;
+            }
+          } catch (e) {
+          }
+        }
+        if (newValue == null || newValue === false) {
+          if (newValue !== false || elm.getAttribute(memberName) === "") {
+            {
+              elm.removeAttribute(memberName);
+            }
+          }
+        } else if ((!isProp || flags & 4 || isSvg) && !isComplex && elm.nodeType === 1) {
+          newValue = newValue === true ? "" : newValue;
+          {
+            elm.setAttribute(memberName, newValue);
+          }
+        }
+      }
+    };
+    parseClassListRegex = /\s/;
+    parseClassList = (value) => {
+      if (typeof value === "object" && value && "baseVal" in value) {
+        value = value.baseVal;
+      }
+      if (!value || typeof value !== "string") {
+        return [];
+      }
+      return value.split(parseClassListRegex);
+    };
+    CAPTURE_EVENT_SUFFIX = "Capture";
+    CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + "$");
+    updateElement = (oldVnode, newVnode, isSvgMode2, isInitialRender) => {
+      const elm = newVnode.$elm$.nodeType === 11 && newVnode.$elm$.host ? newVnode.$elm$.host : newVnode.$elm$;
+      const oldVnodeAttrs = oldVnode && oldVnode.$attrs$ || {};
+      const newVnodeAttrs = newVnode.$attrs$ || {};
+      {
+        for (const memberName of sortedAttrNames(Object.keys(oldVnodeAttrs))) {
+          if (!(memberName in newVnodeAttrs)) {
+            setAccessor(
+              elm,
+              memberName,
+              oldVnodeAttrs[memberName],
+              void 0,
+              isSvgMode2,
+              newVnode.$flags$
+            );
+          }
+        }
+      }
+      for (const memberName of sortedAttrNames(Object.keys(newVnodeAttrs))) {
+        setAccessor(
+          elm,
+          memberName,
+          oldVnodeAttrs[memberName],
+          newVnodeAttrs[memberName],
+          isSvgMode2,
+          newVnode.$flags$
+        );
+      }
+    };
+    useNativeShadowDom = false;
+    isSvgMode = false;
+    refCallbacksToRemove = [];
+    refCallbacksToAttach = [];
+    createElm = (oldParentVNode, newParentVNode, childIndex) => {
+      const newVNode2 = newParentVNode.$children$[childIndex];
+      let i2 = 0;
+      let elm;
+      let childNode;
+      if (newVNode2.$text$ != null) {
+        elm = newVNode2.$elm$ = win.document.createTextNode(newVNode2.$text$);
+      } else {
+        if (!win.document) {
+          throw new Error("You are trying to render a Stencil component in an environment that doesn't support the DOM.");
+        }
+        elm = newVNode2.$elm$ = win.document.createElement(
+          newVNode2.$tag$
+        );
+        {
+          updateElement(null, newVNode2, isSvgMode);
+        }
+        if (newVNode2.$children$) {
+          const appendTarget = newVNode2.$tag$ === "template" ? elm.content : elm;
+          for (i2 = 0; i2 < newVNode2.$children$.length; ++i2) {
+            childNode = createElm(oldParentVNode, newVNode2, i2);
+            if (childNode) {
+              appendTarget.appendChild(childNode);
+            }
+          }
+        }
+      }
+      elm["s-hn"] = hostTagName;
+      return elm;
+    };
+    relocateToHostRoot = (parentElm) => {
+      plt.$flags$ |= 1;
+      const host = parentElm.closest(hostTagName.toLowerCase());
+      if (host != null) {
+        const contentRefNode = Array.from(host.__childNodes || host.childNodes).find(
+          (ref) => ref["s-cr"]
+        );
+        const childNodeArray = Array.from(
+          parentElm.__childNodes || parentElm.childNodes
+        );
+        for (const childNode of contentRefNode ? childNodeArray.reverse() : childNodeArray) {
+          if (childNode["s-sh"] != null) {
+            insertBefore(host, childNode, contentRefNode != null ? contentRefNode : null);
+            childNode["s-sh"] = void 0;
+          }
+        }
+      }
+      plt.$flags$ &= -2;
+    };
+    addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => {
+      let containerElm = parentElm;
+      let childNode;
+      if (containerElm.shadowRoot && containerElm.tagName === hostTagName) {
+        containerElm = containerElm.shadowRoot;
+      }
+      if (parentVNode.$tag$ === "template") {
+        containerElm = containerElm.content;
+      }
+      for (; startIdx <= endIdx; ++startIdx) {
+        if (vnodes[startIdx]) {
+          childNode = createElm(null, parentVNode, startIdx);
+          if (childNode) {
+            vnodes[startIdx].$elm$ = childNode;
+            insertBefore(containerElm, childNode, before);
+          }
+        }
+      }
+    };
+    removeVnodes = (vnodes, startIdx, endIdx) => {
+      for (let index = startIdx; index <= endIdx; ++index) {
+        const vnode = vnodes[index];
+        if (vnode) {
+          const elm = vnode.$elm$;
+          nullifyVNodeRefs(vnode);
+          if (elm) {
+            elm.remove();
+          }
+        }
+      }
+    };
+    updateChildren = (parentElm, oldCh, newVNode2, newCh, isInitialRender = false) => {
+      let oldStartIdx = 0;
+      let newStartIdx = 0;
+      let idxInOld = 0;
+      let i2 = 0;
+      let oldEndIdx = oldCh.length - 1;
+      let oldStartVnode = oldCh[0];
+      let oldEndVnode = oldCh[oldEndIdx];
+      let newEndIdx = newCh.length - 1;
+      let newStartVnode = newCh[0];
+      let newEndVnode = newCh[newEndIdx];
+      let node;
+      let elmToMove;
+      const containerElm = newVNode2.$tag$ === "template" ? parentElm.content : parentElm;
+      while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+        if (oldStartVnode == null) {
+          oldStartVnode = oldCh[++oldStartIdx];
+        } else if (oldEndVnode == null) {
+          oldEndVnode = oldCh[--oldEndIdx];
+        } else if (newStartVnode == null) {
+          newStartVnode = newCh[++newStartIdx];
+        } else if (newEndVnode == null) {
+          newEndVnode = newCh[--newEndIdx];
+        } else if (isSameVnode(oldStartVnode, newStartVnode, isInitialRender)) {
+          patch(oldStartVnode, newStartVnode, isInitialRender);
+          oldStartVnode = oldCh[++oldStartIdx];
+          newStartVnode = newCh[++newStartIdx];
+        } else if (isSameVnode(oldEndVnode, newEndVnode, isInitialRender)) {
+          patch(oldEndVnode, newEndVnode, isInitialRender);
+          oldEndVnode = oldCh[--oldEndIdx];
+          newEndVnode = newCh[--newEndIdx];
+        } else if (isSameVnode(oldStartVnode, newEndVnode, isInitialRender)) {
+          patch(oldStartVnode, newEndVnode, isInitialRender);
+          insertBefore(containerElm, oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling);
+          oldStartVnode = oldCh[++oldStartIdx];
+          newEndVnode = newCh[--newEndIdx];
+        } else if (isSameVnode(oldEndVnode, newStartVnode, isInitialRender)) {
+          patch(oldEndVnode, newStartVnode, isInitialRender);
+          insertBefore(containerElm, oldEndVnode.$elm$, oldStartVnode.$elm$);
+          oldEndVnode = oldCh[--oldEndIdx];
+          newStartVnode = newCh[++newStartIdx];
+        } else {
+          idxInOld = -1;
+          {
+            for (i2 = oldStartIdx; i2 <= oldEndIdx; ++i2) {
+              if (oldCh[i2] && oldCh[i2].$key$ !== null && oldCh[i2].$key$ === newStartVnode.$key$) {
+                idxInOld = i2;
+                break;
+              }
+            }
+          }
+          if (idxInOld >= 0) {
+            elmToMove = oldCh[idxInOld];
+            if (elmToMove.$tag$ !== newStartVnode.$tag$) {
+              node = createElm(oldCh && oldCh[newStartIdx], newVNode2, idxInOld);
+            } else {
+              patch(elmToMove, newStartVnode, isInitialRender);
+              oldCh[idxInOld] = void 0;
+              node = elmToMove.$elm$;
+            }
+            newStartVnode = newCh[++newStartIdx];
+          } else {
+            node = createElm(oldCh && oldCh[newStartIdx], newVNode2, newStartIdx);
+            newStartVnode = newCh[++newStartIdx];
+          }
+          if (node) {
+            {
+              insertBefore(oldStartVnode.$elm$.parentNode, node, oldStartVnode.$elm$);
+            }
+          }
+        }
+      }
+      if (oldStartIdx > oldEndIdx) {
+        addVnodes(
+          parentElm,
+          newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$,
+          newVNode2,
+          newCh,
+          newStartIdx,
+          newEndIdx
+        );
+      } else if (newStartIdx > newEndIdx) {
+        removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+      }
+    };
+    isSameVnode = (leftVNode, rightVNode, isInitialRender = false) => {
+      if (leftVNode.$tag$ === rightVNode.$tag$) {
+        if (!isInitialRender) {
+          return leftVNode.$key$ === rightVNode.$key$;
+        }
+        if (isInitialRender && !leftVNode.$key$ && rightVNode.$key$) {
+          leftVNode.$key$ = rightVNode.$key$;
+        }
+        return true;
+      }
+      return false;
+    };
+    patch = (oldVNode, newVNode2, isInitialRender = false) => {
+      const elm = newVNode2.$elm$ = oldVNode.$elm$;
+      const oldChildren = oldVNode.$children$;
+      const newChildren = newVNode2.$children$;
+      const tag = newVNode2.$tag$;
+      const text = newVNode2.$text$;
+      if (text == null) {
+        {
+          if (tag === "slot" && !useNativeShadowDom) {
+            if (oldVNode.$name$ !== newVNode2.$name$) {
+              newVNode2.$elm$["s-sn"] = newVNode2.$name$ || "";
+              relocateToHostRoot(newVNode2.$elm$.parentElement);
+            }
+          }
+          updateElement(oldVNode, newVNode2, isSvgMode);
+        }
+        if (oldChildren !== null && newChildren !== null) {
+          updateChildren(elm, oldChildren, newVNode2, newChildren, isInitialRender);
+        } else if (newChildren !== null) {
+          if (oldVNode.$text$ !== null) {
+            elm.textContent = "";
+          }
+          addVnodes(elm, null, newVNode2, newChildren, 0, newChildren.length - 1);
+        } else if (
+          // don't do this on initial render as it can cause non-hydrated content to be removed
+          !isInitialRender && BUILD.updatable && oldChildren !== null
+        ) {
+          removeVnodes(oldChildren, 0, oldChildren.length - 1);
+        } else ;
+      } else if (oldVNode.$text$ !== text) {
+        elm.data = text;
+      }
+    };
+    nullifyVNodeRefs = (vNode) => {
+      {
+        if (vNode.$attrs$ && vNode.$attrs$.ref) {
+          refCallbacksToRemove.push(() => vNode.$attrs$.ref(null));
+        }
+        vNode.$children$ && vNode.$children$.map(nullifyVNodeRefs);
+      }
+    };
+    queueRefAttachment = (refCallback, elm) => {
+      {
+        refCallbacksToAttach.push(() => refCallback(elm));
+      }
+    };
+    flushQueuedRefCallbacks = () => {
+      {
+        refCallbacksToRemove.forEach((cb) => cb());
+        refCallbacksToRemove.length = 0;
+        refCallbacksToAttach.forEach((cb) => cb());
+        refCallbacksToAttach.length = 0;
+      }
+    };
+    insertBefore = (parent, newNode, reference, isInitialLoad) => {
+      if (parent.__insertBefore) {
+        return parent.__insertBefore(newNode, reference);
+      } else {
+        return parent == null ? void 0 : parent.insertBefore(newNode, reference);
+      }
+    };
+    renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
+      const hostElm = hostRef.$hostElement$;
+      const cmpMeta = hostRef.$cmpMeta$;
+      const oldVNode = hostRef.$vnode$ || newVNode(null, null);
+      const isHostElement = isHost(renderFnResults);
+      const rootVnode = isHostElement ? renderFnResults : h(null, null, renderFnResults);
+      hostTagName = hostElm.tagName;
+      if (cmpMeta.$attrsToReflect$) {
+        rootVnode.$attrs$ = rootVnode.$attrs$ || {};
+        cmpMeta.$attrsToReflect$.forEach(([propName, attribute]) => {
+          {
+            rootVnode.$attrs$[attribute] = hostElm[propName];
+          }
+        });
+      }
+      if (isInitialLoad && rootVnode.$attrs$) {
+        for (const key of Object.keys(rootVnode.$attrs$)) {
+          if (hostElm.hasAttribute(key) && !["key", "ref", "style", "class"].includes(key)) {
+            rootVnode.$attrs$[key] = hostElm[key];
+          }
+        }
+      }
+      rootVnode.$tag$ = null;
+      rootVnode.$flags$ |= 4;
+      hostRef.$vnode$ = rootVnode;
+      rootVnode.$elm$ = oldVNode.$elm$ = hostElm.shadowRoot || hostElm;
+      useNativeShadowDom = !!(cmpMeta.$flags$ & 1) && !(cmpMeta.$flags$ & 128);
+      patch(oldVNode, rootVnode, isInitialLoad);
+      flushQueuedRefCallbacks();
+    };
+    attachToAncestor = (hostRef, ancestorComponent) => {
+      if (ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent["s-p"]) {
+        const index = ancestorComponent["s-p"].push(
+          new Promise(
+            (r) => hostRef.$onRenderResolve$ = () => {
+              ancestorComponent["s-p"].splice(index - 1, 1);
+              r();
+            }
+          )
+        );
+      }
+    };
+    scheduleUpdate = (hostRef, isInitialLoad) => {
+      {
+        hostRef.$flags$ |= 16;
+      }
+      if (hostRef.$flags$ & 4) {
+        hostRef.$flags$ |= 512;
+        return;
+      }
+      attachToAncestor(hostRef, hostRef.$ancestorComponent$);
+      const dispatch = () => dispatchHooks(hostRef, isInitialLoad);
+      if (isInitialLoad) {
+        queueMicrotask(() => {
+          dispatch();
+        });
+        return;
+      }
+      return writeTask(dispatch);
+    };
+    dispatchHooks = (hostRef, isInitialLoad) => {
+      const elm = hostRef.$hostElement$;
+      const endSchedule = createTime("scheduleUpdate", hostRef.$cmpMeta$.$tagName$);
+      const instance = hostRef.$lazyInstance$;
+      if (!instance) {
+        throw new Error(
+          `Can't render component <${elm.tagName.toLowerCase()} /> with invalid Stencil runtime! Make sure this imported component is compiled with a \`externalRuntime: true\` flag. For more information, please refer to https://stenciljs.com/docs/custom-elements#externalruntime`
+        );
+      }
+      let maybePromise;
+      if (isInitialLoad) {
+        {
+          if (hostRef.$fetchedCbList$.length) {
+            hostRef.$fetchedCbList$.forEach((cb) => cb(elm));
+          }
+        }
+        maybePromise = safeCall(instance, "componentWillLoad", void 0, elm);
+      } else {
+        maybePromise = safeCall(instance, "componentWillUpdate", void 0, elm);
+      }
+      maybePromise = enqueue(maybePromise, () => safeCall(instance, "componentWillRender", void 0, elm));
+      endSchedule();
+      return enqueue(maybePromise, () => updateComponent(hostRef, instance, isInitialLoad));
+    };
+    enqueue = (maybePromise, fn) => isPromisey(maybePromise) ? maybePromise.then(fn).catch((err) => {
+      console.error(err);
+      fn();
+    }) : fn();
+    isPromisey = (maybePromise) => maybePromise instanceof Promise || maybePromise && maybePromise.then && typeof maybePromise.then === "function";
+    updateComponent = async (hostRef, instance, isInitialLoad) => {
+      var _a;
+      const elm = hostRef.$hostElement$;
+      const endUpdate = createTime("update", hostRef.$cmpMeta$.$tagName$);
+      const rc = elm["s-rc"];
+      if (isInitialLoad) {
+        attachStyles(hostRef);
+      }
+      const endRender = createTime("render", hostRef.$cmpMeta$.$tagName$);
+      {
+        callRender(hostRef, instance, elm, isInitialLoad);
+      }
+      if (rc) {
+        rc.map((cb) => cb());
+        elm["s-rc"] = void 0;
+      }
+      endRender();
+      endUpdate();
+      {
+        const childrenPromises = (_a = elm["s-p"]) != null ? _a : [];
+        const postUpdate = () => postUpdateComponent(hostRef);
+        if (childrenPromises.length === 0) {
+          postUpdate();
+        } else {
+          Promise.all(childrenPromises).then(postUpdate).catch(postUpdate);
+          hostRef.$flags$ |= 4;
+          childrenPromises.length = 0;
+        }
+      }
+    };
+    callRender = (hostRef, instance, elm, isInitialLoad) => {
+      try {
+        instance = instance.render();
+        {
+          hostRef.$flags$ &= -17;
+        }
+        {
+          hostRef.$flags$ |= 2;
+        }
+        {
+          {
+            {
+              renderVdom(hostRef, instance, isInitialLoad);
+            }
+          }
+        }
+      } catch (e) {
+        consoleError(e, hostRef.$hostElement$);
+      }
+      return null;
+    };
+    postUpdateComponent = (hostRef) => {
+      const tagName = hostRef.$cmpMeta$.$tagName$;
+      const elm = hostRef.$hostElement$;
+      const endPostUpdate = createTime("postUpdate", tagName);
+      const instance = hostRef.$lazyInstance$;
+      const ancestorComponent = hostRef.$ancestorComponent$;
+      safeCall(instance, "componentDidRender", void 0, elm);
+      if (!(hostRef.$flags$ & 64)) {
+        hostRef.$flags$ |= 64;
+        {
+          addHydratedFlag(elm);
+        }
+        safeCall(instance, "componentDidLoad", void 0, elm);
+        endPostUpdate();
+        {
+          hostRef.$onReadyResolve$(elm);
+          if (!ancestorComponent) {
+            appDidLoad();
+          }
+        }
+      } else {
+        safeCall(instance, "componentDidUpdate", void 0, elm);
+        endPostUpdate();
+      }
+      {
+        if (hostRef.$onRenderResolve$) {
+          hostRef.$onRenderResolve$();
+          hostRef.$onRenderResolve$ = void 0;
+        }
+        if (hostRef.$flags$ & 512) {
+          nextTick(() => scheduleUpdate(hostRef, false));
+        }
+        hostRef.$flags$ &= -517;
+      }
+    };
+    appDidLoad = (who) => {
+      nextTick(() => emitEvent(win, "appload", { detail: { namespace: NAMESPACE } }));
+    };
+    safeCall = (instance, method, arg, elm) => {
+      if (instance && instance[method]) {
+        try {
+          return instance[method](arg);
+        } catch (e) {
+          consoleError(e, elm);
+        }
+      }
+      return void 0;
+    };
+    addHydratedFlag = (elm) => {
+      var _a;
+      return elm.classList.add((_a = BUILD.hydratedSelectorName) != null ? _a : "hydrated");
+    };
+    getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName);
+    setValue = (ref, propName, newVal, cmpMeta) => {
+      const hostRef = getHostRef(ref);
+      if (!hostRef) {
+        return;
+      }
+      if (!hostRef) {
+        throw new Error(
+          `Couldn't find host element for "${cmpMeta.$tagName$}" as it is unknown to this Stencil runtime. This usually happens when integrating a 3rd party Stencil component with another Stencil component or application. Please reach out to the maintainers of the 3rd party Stencil component or report this on the Stencil Discord server (https://chat.stenciljs.com) or comment on this similar [GitHub issue](https://github.com/stenciljs/core/issues/5457).`
+        );
+      }
+      const elm = hostRef.$hostElement$;
+      const oldVal = hostRef.$instanceValues$.get(propName);
+      const flags = hostRef.$flags$;
+      const instance = hostRef.$lazyInstance$;
+      newVal = parsePropertyValue(
+        newVal,
+        cmpMeta.$members$[propName][0]
+      );
+      const areBothNaN = Number.isNaN(oldVal) && Number.isNaN(newVal);
+      const didValueChange = newVal !== oldVal && !areBothNaN;
+      if ((!(flags & 8) || oldVal === void 0) && didValueChange) {
+        hostRef.$instanceValues$.set(propName, newVal);
+        if (cmpMeta.$watchers$) {
+          const watchMethods = cmpMeta.$watchers$[propName];
+          if (watchMethods) {
+            watchMethods.map((watcher) => {
+              try {
+                const [[watchMethodName, watcherFlags]] = Object.entries(watcher);
+                if (flags & 128 || watcherFlags & 1) {
+                  if (!instance) {
+                    hostRef.$fetchedCbList$.push(() => {
+                      hostRef.$lazyInstance$[watchMethodName](newVal, oldVal, propName);
+                    });
+                  } else {
+                    instance[watchMethodName](newVal, oldVal, propName);
+                  }
+                }
+              } catch (e) {
+                consoleError(e, elm);
+              }
+            });
+          }
+        }
+        if (flags & 2) {
+          if (instance.componentShouldUpdate) {
+            const shouldUpdate = instance.componentShouldUpdate(newVal, oldVal, propName);
+            if (shouldUpdate === false && !(flags & 16)) {
+              return;
+            }
+          }
+          if (!(flags & 16)) {
+            scheduleUpdate(hostRef, false);
+          }
+        }
+      }
+    };
+    proxyComponent = (Cstr, cmpMeta, flags) => {
+      var _a, _b;
+      const prototype = Cstr.prototype;
+      if (cmpMeta.$members$ || BUILD.propChangeCallback) {
+        {
+          if (Cstr.watchers && !cmpMeta.$watchers$) {
+            cmpMeta.$watchers$ = Cstr.watchers;
+          }
+          if (Cstr.deserializers && !cmpMeta.$deserializers$) {
+            cmpMeta.$deserializers$ = Cstr.deserializers;
+          }
+          if (Cstr.serializers && !cmpMeta.$serializers$) {
+            cmpMeta.$serializers$ = Cstr.serializers;
+          }
+        }
+        const members = Object.entries((_a = cmpMeta.$members$) != null ? _a : {});
+        members.map(([memberName, [memberFlags]]) => {
+          if (memberFlags & 31 || flags & 2 && memberFlags & 32) {
+            const { get: origGetter, set: origSetter } = getPropertyDescriptor(prototype, memberName) || {};
+            if (origGetter) cmpMeta.$members$[memberName][0] |= 2048;
+            if (origSetter) cmpMeta.$members$[memberName][0] |= 4096;
+            if (flags & 1 || !origGetter) {
+              Object.defineProperty(prototype, memberName, {
+                get() {
+                  {
+                    if ((cmpMeta.$members$[memberName][0] & 2048) === 0) {
+                      return getValue(this, memberName);
+                    }
+                    const ref = getHostRef(this);
+                    const instance = ref ? ref.$lazyInstance$ : prototype;
+                    if (!instance) return;
+                    return instance[memberName];
+                  }
+                },
+                configurable: true,
+                enumerable: true
+              });
+            }
+            Object.defineProperty(prototype, memberName, {
+              set(newValue) {
+                const ref = getHostRef(this);
+                if (!ref) {
+                  return;
+                }
+                if (origSetter) {
+                  const currentValue = memberFlags & 32 ? this[memberName] : ref.$hostElement$[memberName];
+                  if (typeof currentValue === "undefined" && ref.$instanceValues$.get(memberName)) {
+                    newValue = ref.$instanceValues$.get(memberName);
+                  }
+                  origSetter.apply(this, [
+                    parsePropertyValue(
+                      newValue,
+                      memberFlags
+                    )
+                  ]);
+                  newValue = memberFlags & 32 ? this[memberName] : ref.$hostElement$[memberName];
+                  setValue(this, memberName, newValue, cmpMeta);
+                  return;
+                }
+                {
+                  if ((flags & 1) === 0 || (cmpMeta.$members$[memberName][0] & 4096) === 0) {
+                    setValue(this, memberName, newValue, cmpMeta);
+                    if (flags & 1 && !ref.$lazyInstance$) {
+                      ref.$fetchedCbList$.push(() => {
+                        if (cmpMeta.$members$[memberName][0] & 4096 && ref.$lazyInstance$[memberName] !== ref.$instanceValues$.get(memberName)) {
+                          ref.$lazyInstance$[memberName] = newValue;
+                        }
+                      });
+                    }
+                    return;
+                  }
+                  const setterSetVal = () => {
+                    const currentValue = ref.$lazyInstance$[memberName];
+                    if (!ref.$instanceValues$.get(memberName) && currentValue) {
+                      ref.$instanceValues$.set(memberName, currentValue);
+                    }
+                    ref.$lazyInstance$[memberName] = parsePropertyValue(
+                      newValue,
+                      memberFlags
+                    );
+                    setValue(this, memberName, ref.$lazyInstance$[memberName], cmpMeta);
+                  };
+                  if (ref.$lazyInstance$) {
+                    setterSetVal();
+                  } else {
+                    ref.$fetchedCbList$.push(() => {
+                      setterSetVal();
+                    });
+                  }
+                }
+              }
+            });
+          }
+        });
+        if (flags & 1) {
+          const attrNameToPropName = /* @__PURE__ */ new Map();
+          prototype.attributeChangedCallback = function(attrName, oldValue, newValue) {
+            plt.jmp(() => {
+              var _a2;
+              const propName = attrNameToPropName.get(attrName);
+              const hostRef = getHostRef(this);
+              if (this.hasOwnProperty(propName) && BUILD.lazyLoad) {
+                newValue = this[propName];
+                delete this[propName];
+              }
+              if (prototype.hasOwnProperty(propName) && typeof this[propName] === "number" && // cast type to number to avoid TS compiler issues
+              this[propName] == newValue) {
+                return;
+              } else if (propName == null) {
+                const flags2 = hostRef == null ? void 0 : hostRef.$flags$;
+                if (hostRef && flags2 && !(flags2 & 8) && newValue !== oldValue) {
+                  const instance = hostRef.$lazyInstance$;
+                  const entry = (_a2 = cmpMeta.$watchers$) == null ? void 0 : _a2[attrName];
+                  entry == null ? void 0 : entry.forEach((watcher) => {
+                    const [[watchMethodName, watcherFlags]] = Object.entries(watcher);
+                    if (instance[watchMethodName] != null && (flags2 & 128 || watcherFlags & 1)) {
+                      instance[watchMethodName].call(instance, newValue, oldValue, attrName);
+                    }
+                  });
+                }
+                return;
+              }
+              const propFlags = members.find(([m]) => m === propName);
+              if (propFlags && propFlags[1][0] & 4) {
+                newValue = newValue === null || newValue === "false" ? false : true;
+              }
+              const propDesc = Object.getOwnPropertyDescriptor(prototype, propName);
+              if (newValue != this[propName] && (!propDesc.get || !!propDesc.set)) {
+                this[propName] = newValue;
+              }
+            });
+          };
+          Cstr.observedAttributes = Array.from(
+            /* @__PURE__ */ new Set([
+              ...Object.keys((_b = cmpMeta.$watchers$) != null ? _b : {}),
+              ...members.filter(
+                ([_, m]) => m[0] & 31
+                /* HasAttribute */
+              ).map(([propName, m]) => {
+                var _a2;
+                const attrName = m[1] || propName;
+                attrNameToPropName.set(attrName, propName);
+                if (m[0] & 512) {
+                  (_a2 = cmpMeta.$attrsToReflect$) == null ? void 0 : _a2.push([propName, attrName]);
+                }
+                return attrName;
+              })
+            ])
+          );
+        }
+      }
+      return Cstr;
+    };
+    initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
+      let Cstr;
+      try {
+        if ((hostRef.$flags$ & 32) === 0) {
+          hostRef.$flags$ |= 32;
+          const bundleId = cmpMeta.$lazyBundleId$;
+          if (bundleId) {
+            const CstrImport = loadModule(cmpMeta, hostRef);
+            if (CstrImport && "then" in CstrImport) {
+              const endLoad = uniqueTime();
+              Cstr = await CstrImport;
+              endLoad();
+            } else {
+              Cstr = CstrImport;
+            }
+            if (!Cstr) {
+              throw new Error(`Constructor for "${cmpMeta.$tagName$}#${hostRef.$modeName$}" was not found`);
+            }
+            if (!Cstr.isProxied) {
+              {
+                cmpMeta.$watchers$ = Cstr.watchers;
+                cmpMeta.$serializers$ = Cstr.serializers;
+                cmpMeta.$deserializers$ = Cstr.deserializers;
+              }
+              proxyComponent(
+                Cstr,
+                cmpMeta,
+                2
+                /* proxyState */
+              );
+              Cstr.isProxied = true;
+            }
+            const endNewInstance = createTime("createInstance", cmpMeta.$tagName$);
+            {
+              hostRef.$flags$ |= 8;
+            }
+            try {
+              new Cstr(hostRef);
+            } catch (e) {
+              consoleError(e, elm);
+            }
+            {
+              hostRef.$flags$ &= -9;
+            }
+            {
+              hostRef.$flags$ |= 128;
+            }
+            endNewInstance();
+            {
+              fireConnectedCallback(hostRef.$lazyInstance$, elm);
+            }
+          } else {
+            Cstr = elm.constructor;
+            const cmpTag = elm.localName;
+            customElements.whenDefined(cmpTag).then(
+              () => hostRef.$flags$ |= 128
+              /* isWatchReady */
+            );
+          }
+          if (Cstr && Cstr.style) {
+            let style;
+            if (typeof Cstr.style === "string") {
+              style = Cstr.style;
+            }
+            const scopeId2 = getScopeId(cmpMeta);
+            if (!styles.has(scopeId2) || BUILD.hotModuleReplacement) {
+              const endRegisterStyles = createTime("registerStyles", cmpMeta.$tagName$);
+              registerStyle(scopeId2, style, !!(cmpMeta.$flags$ & 1));
+              endRegisterStyles();
+            }
+          }
+        }
+        const ancestorComponent = hostRef.$ancestorComponent$;
+        const schedule = () => scheduleUpdate(hostRef, true);
+        if (ancestorComponent && ancestorComponent["s-rc"]) {
+          ancestorComponent["s-rc"].push(schedule);
+        } else {
+          schedule();
+        }
+      } catch (e) {
+        consoleError(e, elm);
+        if (hostRef.$onRenderResolve$) {
+          hostRef.$onRenderResolve$();
+          hostRef.$onRenderResolve$ = void 0;
+        }
+        if (hostRef.$onReadyResolve$) {
+          hostRef.$onReadyResolve$(elm);
+        }
+      }
+    };
+    fireConnectedCallback = (instance, elm) => {
+      {
+        safeCall(instance, "connectedCallback", void 0, elm);
+      }
+    };
+    connectedCallback = (elm) => {
+      if ((plt.$flags$ & 1) === 0) {
+        const hostRef = getHostRef(elm);
+        if (!hostRef) {
+          return;
+        }
+        const cmpMeta = hostRef.$cmpMeta$;
+        const endConnected = createTime("connectedCallback", cmpMeta.$tagName$);
+        if (!(hostRef.$flags$ & 1)) {
+          hostRef.$flags$ |= 1;
+          {
+            let ancestorComponent = elm;
+            while (ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host) {
+              if (ancestorComponent["s-p"]) {
+                attachToAncestor(hostRef, hostRef.$ancestorComponent$ = ancestorComponent);
+                break;
+              }
+            }
+          }
+          if (cmpMeta.$members$) {
+            Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => {
+              if (memberFlags & 31 && Object.prototype.hasOwnProperty.call(elm, memberName)) {
+                const value = elm[memberName];
+                delete elm[memberName];
+                elm[memberName] = value;
+              }
+            });
+          }
+          {
+            initializeComponent(elm, hostRef, cmpMeta);
+          }
+        } else {
+          if (hostRef == null ? void 0 : hostRef.$lazyInstance$) {
+            fireConnectedCallback(hostRef.$lazyInstance$, elm);
+          } else if (hostRef == null ? void 0 : hostRef.$onReadyPromise$) {
+            hostRef.$onReadyPromise$.then(() => fireConnectedCallback(hostRef.$lazyInstance$, elm));
+          }
+        }
+        endConnected();
+      }
+    };
+    disconnectInstance = (instance, elm) => {
+      {
+        safeCall(instance, "disconnectedCallback", void 0, elm || instance);
+      }
+    };
+    disconnectedCallback = async (elm) => {
+      if ((plt.$flags$ & 1) === 0) {
+        const hostRef = getHostRef(elm);
+        if (hostRef == null ? void 0 : hostRef.$lazyInstance$) {
+          disconnectInstance(hostRef.$lazyInstance$, elm);
+        } else if (hostRef == null ? void 0 : hostRef.$onReadyPromise$) {
+          hostRef.$onReadyPromise$.then(() => disconnectInstance(hostRef.$lazyInstance$, elm));
+        }
+      }
+      if (rootAppliedStyles.has(elm)) {
+        rootAppliedStyles.delete(elm);
+      }
+      if (elm.shadowRoot && rootAppliedStyles.has(elm.shadowRoot)) {
+        rootAppliedStyles.delete(elm.shadowRoot);
+      }
+    };
+    bootstrapLazy = (lazyBundles, options = {}) => {
+      var _a;
+      if (!win.document) {
+        console.warn("Stencil: No document found. Skipping bootstrapping lazy components.");
+        return;
+      }
+      const endBootstrap = createTime();
+      const cmpTags = [];
+      const exclude = options.exclude || [];
+      const customElements2 = win.customElements;
+      const head = win.document.head;
+      const metaCharset = /* @__PURE__ */ head.querySelector("meta[charset]");
+      const dataStyles = /* @__PURE__ */ win.document.createElement("style");
+      const deferredConnectedCallbacks = [];
+      let appLoadFallback;
+      let isBootstrapping = true;
+      Object.assign(plt, options);
+      plt.$resourcesUrl$ = new URL(options.resourcesUrl || "./", win.document.baseURI).href;
+      lazyBundles.map((lazyBundle) => {
+        lazyBundle[1].map((compactMeta) => {
+          var _a2, _b, _c;
+          const cmpMeta = {
+            $flags$: compactMeta[0],
+            $tagName$: compactMeta[1],
+            $members$: compactMeta[2],
+            $listeners$: compactMeta[3]
+          };
+          {
+            cmpMeta.$members$ = compactMeta[2];
+          }
+          {
+            cmpMeta.$attrsToReflect$ = [];
+          }
+          {
+            cmpMeta.$watchers$ = (_a2 = compactMeta[4]) != null ? _a2 : {};
+            cmpMeta.$serializers$ = (_b = compactMeta[5]) != null ? _b : {};
+            cmpMeta.$deserializers$ = (_c = compactMeta[6]) != null ? _c : {};
+          }
+          const tagName = transformTag(cmpMeta.$tagName$);
+          const HostElement = class extends HTMLElement {
+            ["s-p"];
+            ["s-rc"];
+            hasRegisteredEventListeners = false;
+            // StencilLazyHost
+            constructor(self) {
+              super(self);
+              self = this;
+              registerHost(self, cmpMeta);
+              if (cmpMeta.$flags$ & 1) {
+                {
+                  if (!self.shadowRoot) {
+                    createShadowRoot.call(self, cmpMeta);
+                  } else {
+                    if (self.shadowRoot.mode !== "open") {
+                      throw new Error(
+                        `Unable to re-use existing shadow root for ${cmpMeta.$tagName$}! Mode is set to ${self.shadowRoot.mode} but Stencil only supports open shadow roots.`
+                      );
+                    }
+                  }
+                }
+              }
+            }
+            connectedCallback() {
+              const hostRef = getHostRef(this);
+              if (!hostRef) {
+                return;
+              }
+              if (!this.hasRegisteredEventListeners) {
+                this.hasRegisteredEventListeners = true;
+              }
+              if (appLoadFallback) {
+                clearTimeout(appLoadFallback);
+                appLoadFallback = null;
+              }
+              if (isBootstrapping) {
+                deferredConnectedCallbacks.push(this);
+              } else {
+                plt.jmp(() => connectedCallback(this));
+              }
+            }
+            disconnectedCallback() {
+              plt.jmp(() => disconnectedCallback(this));
+              plt.raf(() => {
+                var _a3;
+                const hostRef = getHostRef(this);
+                if (!hostRef) {
+                  return;
+                }
+                const i2 = deferredConnectedCallbacks.findIndex((host) => host === this);
+                if (i2 > -1) {
+                  deferredConnectedCallbacks.splice(i2, 1);
+                }
+                if (((_a3 = hostRef == null ? void 0 : hostRef.$vnode$) == null ? void 0 : _a3.$elm$) instanceof Node && !hostRef.$vnode$.$elm$.isConnected) {
+                  delete hostRef.$vnode$.$elm$;
+                }
+              });
+            }
+            componentOnReady() {
+              var _a3;
+              return (_a3 = getHostRef(this)) == null ? void 0 : _a3.$onReadyPromise$;
+            }
+          };
+          cmpMeta.$lazyBundleId$ = lazyBundle[0];
+          if (!exclude.includes(tagName) && !customElements2.get(tagName)) {
+            cmpTags.push(tagName);
+            customElements2.define(
+              tagName,
+              proxyComponent(
+                HostElement,
+                cmpMeta,
+                1
+                /* isElementConstructor */
+              )
+            );
+          }
+        });
+      });
+      if (cmpTags.length > 0) {
+        {
+          dataStyles.textContent += cmpTags.sort() + HYDRATED_CSS;
+        }
+        if (dataStyles.innerHTML.length) {
+          dataStyles.setAttribute("data-styles", "");
+          const nonce = (_a = plt.$nonce$) != null ? _a : queryNonceMetaTagContent(win.document);
+          if (nonce != null) {
+            dataStyles.setAttribute("nonce", nonce);
+          }
+          head.insertBefore(dataStyles, metaCharset ? metaCharset.nextSibling : head.firstChild);
+        }
+      }
+      isBootstrapping = false;
+      if (deferredConnectedCallbacks.length) {
+        deferredConnectedCallbacks.map((host) => host.connectedCallback());
+      } else {
+        {
+          plt.jmp(() => appLoadFallback = setTimeout(appDidLoad, 30));
+        }
+      }
+      endBootstrap();
+    };
+  }
+});
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  closeOverlay: () => closeOverlay2,
+  getTopOverlay: () => getTopOverlay2,
+  isTopOverlay: () => isTopOverlay,
+  openOverlay: () => openOverlay2,
+  requestTopOverlayClose: () => requestTopOverlayClose2
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/esm/loader.js
+init_index_CEeiinfk();
+init_index_CEeiinfk();
+
+// dist/esm/app-globals-DQuL1Twl.js
+var globalScripts = () => {
+};
+
+// dist/esm/loader.js
+var defineCustomElements = async (win2, options) => {
+  if (typeof window === "undefined") return void 0;
+  await globalScripts();
+  return bootstrapLazy([["ui-context-menu", [[769, "ui-context-menu", { "open": [4], "defaultOpen": [4, "default-open"], "for": [1], "internalOpen": [32] }, null, { "open": [{ "syncFromProp": 0 }], "for": [{ "syncTarget": 0 }], "internalOpen": [{ "syncOverlay": 0 }] }]]], ["ui-avatar", [[513, "ui-avatar", { "src": [1], "alt": [1], "name": [1], "fallback": [1], "hasImage": [32] }, null, { "src": [{ "watchSrc": 0 }] }]]], ["ui-avatar-group", [[769, "ui-avatar-group", { "max": [2], "label": [1], "overflowCount": [32] }, null, { "max": [{ "syncOverflow": 0 }] }]]], ["ui-badge", [[769, "ui-badge", { "variant": [1], "tone": [1] }]]], ["ui-button", [[769, "ui-button", { "variant": [1], "size": [1], "disabled": [4] }, null, { "variant": [{ "syncToButton": 0 }], "size": [{ "syncToButton": 0 }], "disabled": [{ "syncToButton": 0 }] }]]], ["ui-checkbox", [[769, "ui-checkbox", { "checked": [4], "defaultChecked": [4, "default-checked"], "disabled": [4], "indeterminate": [4], "required": [4], "value": [1], "internalChecked": [32] }, null, { "checked": [{ "syncFromProp": 0 }], "internalChecked": [{ "syncToInput": 0 }], "indeterminate": [{ "syncToInput": 0 }], "disabled": [{ "syncToInput": 0 }], "required": [{ "syncToInput": 0 }] }]]], ["ui-dialog", [[769, "ui-dialog", { "open": [4], "defaultOpen": [4, "default-open"], "modal": [4], "dismissible": [4], "internalOpen": [32] }, null, { "open": [{ "syncFromProp": 0 }], "internalOpen": [{ "syncOpen": 0 }] }]]], ["ui-disclosure", [[769, "ui-disclosure", { "open": [4], "defaultOpen": [4, "default-open"], "disabled": [4], "internalOpen": [32], "contentId": [32] }, null, { "open": [{ "syncFromProp": 0 }], "internalOpen": [{ "syncState": 0 }] }]]], ["ui-floating-action-button", [[769, "ui-floating-action-button", { "disabled": [516], "mobileOnly": [516, "mobile-only"], "label": [1] }]]], ["ui-form-field", [[769, "ui-form-field", { "invalid": [4], "disabled": [4], "required": [4] }]]], ["ui-icon-button", [[769, "ui-icon-button", { "disabled": [516], "label": [1], "size": [513], "variant": [513] }]]], ["ui-input", [[769, "ui-input", { "value": [1], "defaultValue": [1, "default-value"], "disabled": [4], "invalid": [4], "readOnly": [4, "readonly"], "internalValue": [32] }, null, { "value": [{ "syncFromProp": 0 }], "internalValue": [{ "syncToInput": 0 }], "defaultValue": [{ "syncToInput": 0 }], "disabled": [{ "syncToInput": 0 }], "invalid": [{ "syncToInput": 0 }], "readOnly": [{ "syncToInput": 0 }] }]]], ["ui-menu-item", [[769, "ui-menu-item", { "disabled": [516], "value": [1] }]]], ["ui-popover", [[769, "ui-popover", { "open": [4], "defaultOpen": [4, "default-open"], "internalOpen": [32] }, null, { "open": [{ "syncFromProp": 0 }], "internalOpen": [{ "onOpenChange": 0 }] }]]], ["ui-radio", [[769, "ui-radio", { "checked": [4], "defaultChecked": [4, "default-checked"], "disabled": [4], "name": [1], "required": [4], "value": [1] }, null, { "checked": [{ "syncToInput": 0 }], "disabled": [{ "syncToInput": 0 }], "name": [{ "syncToInput": 0 }], "required": [{ "syncToInput": 0 }], "value": [{ "syncToInput": 0 }] }]]], ["ui-radio-group", [[769, "ui-radio-group", { "value": [1], "name": [1], "orientation": [1], "disabled": [4], "required": [4], "internalValue": [32] }, null, { "value": [{ "syncFromProp": 0 }], "internalValue": [{ "syncToRadios": 0 }], "name": [{ "syncToRadios": 0 }], "orientation": [{ "syncToRadios": 0 }], "disabled": [{ "syncToRadios": 0 }] }]]], ["ui-search-result-row", [[769, "ui-search-result-row", { "disabled": [516], "selected": [516], "hasLeading": [32], "hasMeta": [32], "hasExcerpt": [32], "hasTrailing": [32] }]]], ["ui-search-shell", [[769, "ui-search-shell", { "hasStatus": [32], "hasFooter": [32] }]]], ["ui-select", [[769, "ui-select", { "value": [1], "defaultValue": [1, "default-value"], "disabled": [4], "invalid": [4], "required": [4], "internalValue": [32] }, null, { "value": [{ "syncFromProp": 0 }], "internalValue": [{ "syncToSelect": 0 }], "defaultValue": [{ "syncToSelect": 0 }], "disabled": [{ "syncToSelect": 0 }], "invalid": [{ "syncToSelect": 0 }], "required": [{ "syncToSelect": 0 }] }]]], ["ui-switch", [[769, "ui-switch", { "checked": [4], "defaultChecked": [4, "default-checked"], "disabled": [4], "required": [4], "value": [1], "internalChecked": [32] }, null, { "checked": [{ "syncFromProp": 0 }] }]]], ["ui-tabs", [[769, "ui-tabs", { "value": [1], "defaultValue": [1, "default-value"], "orientation": [1], "internalValue": [32] }, null, { "value": [{ "syncFromProp": 0 }], "internalValue": [{ "syncState": 0 }], "orientation": [{ "syncState": 0 }] }]]], ["ui-textarea", [[769, "ui-textarea", { "value": [1], "defaultValue": [1, "default-value"], "disabled": [4], "invalid": [4], "readOnly": [4, "readonly"], "rows": [2], "internalValue": [32] }, null, { "value": [{ "syncFromProp": 0 }], "internalValue": [{ "syncToTextarea": 0 }], "defaultValue": [{ "syncToTextarea": 0 }], "disabled": [{ "syncToTextarea": 0 }], "invalid": [{ "syncToTextarea": 0 }], "readOnly": [{ "syncToTextarea": 0 }], "rows": [{ "syncToTextarea": 0 }] }]]], ["ui-toast-region", [[769, "ui-toast-region", { "open": [4], "internalOpen": [32] }, null, { "open": [{ "syncFromProp": 0 }] }]]], ["ui-tooltip", [[769, "ui-tooltip", { "for": [1], "open": [4], "defaultOpen": [4, "default-open"], "internalOpen": [32] }, null, { "open": [{ "syncFromProp": 0 }], "internalOpen": [{ "syncOverlay": 0 }] }]]], ["ui-top-bar", [[769, "ui-top-bar", { "hasLeading": [32], "hasSearch": [32], "hasActions": [32] }]]], ["ui-menu", [[769, "ui-menu", { "open": [4], "defaultOpen": [4, "default-open"], "internalOpen": [32] }, null, { "open": [{ "syncFromProp": 0 }] }]]]], options);
+};
+
+// loader/index.js
+(function() {
+  if ("undefined" !== typeof window && void 0 !== window.Reflect && void 0 !== window.customElements) {
+    var a = HTMLElement;
+    window.HTMLElement = function() {
+      return Reflect.construct(a, [], this.constructor);
+    };
+    HTMLElement.prototype = a.prototype;
+    HTMLElement.prototype.constructor = HTMLElement;
+    Object.setPrototypeOf(HTMLElement, a);
+  }
+})();
+
+// src/overlay/manager.ts
+var stack2 = [];
+var scrollLockAttribute2 = "data-ui-scroll-lock";
+var modalCount2 = 0;
+var listenersAttached2 = false;
+function syncScrollLock2() {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const root = document.documentElement;
+  if (modalCount2 > 0) {
+    root.setAttribute(scrollLockAttribute2, "true");
+    root.style.overflow = "hidden";
+    return;
+  }
+  root.removeAttribute(scrollLockAttribute2);
+  root.style.removeProperty("overflow");
+}
+function getOverlayDismissible2(record) {
+  return record.dismissible ?? true;
+}
+function handleEscape2(event) {
+  if (event.key !== "Escape") {
+    return;
+  }
+  requestTopOverlayClose2("escape", "keyboard");
+}
+function handleLightDismiss2(event) {
+  const top = getTopOverlay2();
+  if (!top || !getOverlayDismissible2(top)) {
+    return;
+  }
+  const target = event.target;
+  if (target instanceof Node && top.element.contains(target)) {
+    return;
+  }
+  requestTopOverlayClose2("light-dismiss", "pointer");
+}
+function ensureListeners2() {
+  if (listenersAttached2 || typeof document === "undefined") {
+    return;
+  }
+  document.addEventListener("keydown", handleEscape2);
+  document.addEventListener("pointerdown", handleLightDismiss2, { capture: true });
+  listenersAttached2 = true;
+}
+function removeListenersIfIdle2() {
+  if (!listenersAttached2 || stack2.length > 0 || typeof document === "undefined") {
+    return;
+  }
+  document.removeEventListener("keydown", handleEscape2);
+  document.removeEventListener("pointerdown", handleLightDismiss2, { capture: true });
+  listenersAttached2 = false;
+}
+function openOverlay2(record) {
+  closeOverlay2(record.id);
+  stack2.push(record);
+  if (record.modal) {
+    modalCount2 += 1;
+    syncScrollLock2();
+  }
+  ensureListeners2();
+}
+function closeOverlay2(id) {
+  const index = stack2.findIndex((record) => record.id === id);
+  if (index >= 0) {
+    const [record] = stack2.splice(index, 1);
+    if (record?.modal) {
+      modalCount2 = Math.max(0, modalCount2 - 1);
+      syncScrollLock2();
+    }
+  }
+  removeListenersIfIdle2();
+}
+function getTopOverlay2() {
+  return stack2.at(-1);
+}
+function isTopOverlay(id) {
+  return getTopOverlay2()?.id === id;
+}
+function requestTopOverlayClose2(reason, trigger) {
+  const top = getTopOverlay2();
+  if (!top) {
+    return false;
+  }
+  if (!getOverlayDismissible2(top) && (reason === "escape" || reason === "light-dismiss")) {
+    return false;
+  }
+  top.requestClose(reason, trigger);
+  return true;
+}
+
+// index.ts
+defineCustomElements();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  closeOverlay,
+  getTopOverlay,
+  isTopOverlay,
+  openOverlay,
+  requestTopOverlayClose
+});
+/*!__STENCIL_STATIC_IMPORT_SWITCH__*/