@lostgradient/cinder 0.3.0 → 0.4.1

package/dist/server/index.server-06ak422z.js

@@ -0,0 +1,726 @@
+import {
+  Dropdown_label
+} from "./index.server-zdg2zpx1.js";
+import {
+  Dropdown_separator
+} from "./index.server-1k7j69zg.js";
+import {
+  Dropdown_item
+} from "./index.server-r0wzpqh7.js";
+import {
+  Dropdown_menu
+} from "./index.server-4jc5ny87.js";
+import {
+  TypeaheadBuffer,
+  findTypeaheadMatch,
+  isTypeaheadKey
+} from "./index.server-bgcpy5vk.js";
+import {
+  resolveTextDirection
+} from "./index.server-g8kdhzf2.js";
+import {
+  getLocaleContext
+} from "./index.server-sz8sxsj6.js";
+import {
+  setDropdownContext,
+  setDropdownRegister,
+  setDropdownRegisterTrigger,
+  setDropdownSetOpen
+} from "./index.server-et3p2cfq.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/menu-bar/menu-bar.svelte
+import * as $2 from "svelte/internal/server";
+import { tick } from "svelte";
+
+// src/components/menu-bar/menu-bar-dropdown-context.svelte
+import * as $ from "svelte/internal/server";
+import { untrack } from "svelte";
+function Menu_bar_dropdown_context($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const { context, registerMenu, registerTrigger, setOpen, children } = $$props;
+    setDropdownContext(untrack(() => context));
+    setDropdownRegister(untrack(() => registerMenu));
+    setDropdownRegisterTrigger(untrack(() => registerTrigger));
+    setDropdownSetOpen(untrack(() => setOpen));
+    children($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+
+// src/components/menu-bar/menu-bar.svelte
+function Menu_bar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const generatedId = $2.props_id($$renderer2);
+    let {
+      id: providedId,
+      menus,
+      label = "Application menu",
+      labelledBy,
+      class: customClassName,
+      role: _role,
+      dir: providedDirection,
+      "aria-label": _ariaLabel,
+      "aria-labelledby": _ariaLabelledBy,
+      "aria-orientation": _ariaOrientation,
+      onkeydown: consumerOnKeydown,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const rootId = $2.derived(() => providedId ?? generatedId);
+    let rootElement = null;
+    let activeMenuIndex = 0;
+    let openMenuIndex = null;
+    let openSubmenuKey = null;
+    let initialFocus = undefined;
+    let directionRevision = 0;
+    let suppressSubmenuFocusOpen = false;
+    let submenuCloseTimer = null;
+    let pendingSubmenuCloseKey = null;
+    let pendingSubmenuTriggerId = null;
+    let submenuLeavePoint = null;
+    let latestPointerPoint = null;
+    const localeContext = getLocaleContext();
+    const menuElements = new Map;
+    const typeaheadBuffer = new TypeaheadBuffer;
+    const directionElement = $2.derived(() => providedDirection === "auto" ? rootElement : rootElement?.parentElement ?? rootElement);
+    const resolvedDirection = $2.derived(() => {
+      return providedDirection === "rtl" || providedDirection === "ltr" ? providedDirection : resolveTextDirection(directionElement(), localeContext?.direction);
+    });
+    const rootDirection = $2.derived(() => providedDirection === "auto" ? "auto" : resolvedDirection());
+    const renderedRootDirection = $2.derived(() => {
+      if (providedDirection === "auto" || providedDirection === "rtl" || providedDirection === "ltr") {
+        return rootDirection();
+      }
+      return localeContext?.direction ? resolvedDirection() : null;
+    });
+    const enabledIndexes = $2.derived(() => menus.map((menu, index) => ({ menu, index })).filter(({ menu }) => !menu.disabled));
+    function ancestryKey(...parts) {
+      return [rootId(), ...parts].map((part) => String(part).replaceAll(/\s+/g, "-")).join("-");
+    }
+    function topLevelTriggerId(index, menu) {
+      return ancestryKey("menu", index, menu.id, "trigger");
+    }
+    function topLevelMenuId(index, menu) {
+      return ancestryKey("menu", index, menu.id, "menu");
+    }
+    function submenuTriggerId(menuIndex, menu, entryIndex, submenu) {
+      return ancestryKey("menu", menuIndex, menu.id, "submenu", entryIndex, submenu.id, "trigger");
+    }
+    function submenuMenuId(menuIndex, menu, entryIndex, submenu) {
+      return ancestryKey("menu", menuIndex, menu.id, "submenu", entryIndex, submenu.id, "menu");
+    }
+    function focusElement(id) {
+      document.getElementById(id)?.focus();
+    }
+    function findElementById(id) {
+      if (typeof document === "undefined")
+        return null;
+      const element = document.getElementById(id);
+      return element instanceof HTMLElement ? element : null;
+    }
+    function focusSubmenuTriggerAfterClose(id) {
+      suppressSubmenuFocusOpen = true;
+      focusElement(id);
+      tick().then(() => {
+        suppressSubmenuFocusOpen = false;
+      });
+    }
+    function focusTopLevelTrigger(index) {
+      const menu = menus[index];
+      if (!menu)
+        return;
+      focusElement(topLevelTriggerId(index, menu));
+    }
+    function nextEnabledMenuIndex(currentIndex, direction) {
+      if (!enabledIndexes().length)
+        return -1;
+      const indexes = enabledIndexes().map(({ index }) => index);
+      const currentPosition = Math.max(0, indexes.indexOf(currentIndex));
+      return indexes[(currentPosition + direction + indexes.length) % indexes.length] ?? -1;
+    }
+    function horizontalArrowDirection(key) {
+      if (key === "ArrowRight")
+        return resolvedDirection() === "rtl" ? -1 : 1;
+      return resolvedDirection() === "rtl" ? 1 : -1;
+    }
+    function firstEnabledMenuIndex() {
+      return enabledIndexes()[0]?.index ?? -1;
+    }
+    function lastEnabledMenuIndex() {
+      return enabledIndexes().at(-1)?.index ?? -1;
+    }
+    function openMenu(index, focus = "first") {
+      const menu = menus[index];
+      if (!menu || menu.disabled)
+        return;
+      typeaheadBuffer.reset();
+      activeMenuIndex = index;
+      openMenuIndex = index;
+      openSubmenuKey = null;
+      initialFocus = focus;
+    }
+    function openSubmenu(key, focus = "first") {
+      openSubmenuKey = key;
+      initialFocus = focus;
+    }
+    function closeAll() {
+      clearSubmenuCloseTimer();
+      typeaheadBuffer.reset();
+      openMenuIndex = null;
+      openSubmenuKey = null;
+      initialFocus = undefined;
+    }
+    function closeMenuAndFocusTrigger(index) {
+      closeAll();
+      tick().then(() => focusTopLevelTrigger(index));
+    }
+    function labelParts(menu) {
+      if (!menu.accessKey)
+        return null;
+      const index = menu.label.toLocaleLowerCase().indexOf(menu.accessKey.toLocaleLowerCase());
+      if (index < 0)
+        return null;
+      return {
+        before: menu.label.slice(0, index),
+        key: menu.label.slice(index, index + 1),
+        after: menu.label.slice(index + 1)
+      };
+    }
+    function isItem(entry) {
+      return entry.type === undefined || entry.type === "item";
+    }
+    function isSubmenu(entry) {
+      return entry.type === "submenu";
+    }
+    function makeContext(options) {
+      return {
+        get menuId() {
+          return options.menuId;
+        },
+        get isOpen() {
+          return options.isOpen();
+        },
+        get supportsPopover() {
+          return false;
+        },
+        get anchorElement() {
+          return options.anchorElement();
+        },
+        get fallbackPlacement() {
+          return typeof options.fallbackPlacement === "function" ? options.fallbackPlacement() : options.fallbackPlacement ?? "bottom-start";
+        },
+        get widthMode() {
+          return "menu";
+        },
+        get initialFocus() {
+          return initialFocus;
+        },
+        close: options.close,
+        focusTrigger: options.focusTrigger
+      };
+    }
+    function submenuDirection(submenuTriggerId2) {
+      return resolveTextDirection(findElementById(submenuTriggerId2), resolvedDirection());
+    }
+    function submenuFallbackPlacement(submenuTriggerId2) {
+      return submenuDirection(submenuTriggerId2) === "rtl" ? "left-start" : "right-start";
+    }
+    function submenuOpenArrow(submenuTriggerId2) {
+      return submenuDirection(submenuTriggerId2) === "rtl" ? "ArrowLeft" : "ArrowRight";
+    }
+    function makeMenuRegister(menuId) {
+      return (element) => {
+        if (element) {
+          menuElements.set(menuId, element);
+        } else {
+          menuElements.delete(menuId);
+        }
+      };
+    }
+    function isInsideOpenMenu(target) {
+      return Array.from(menuElements.values()).some((element) => element.contains(target));
+    }
+    function isPointerStillInsideCurrentTarget(event) {
+      return event.relatedTarget instanceof Node && event.currentTarget instanceof HTMLElement ? event.currentTarget.contains(event.relatedTarget) : false;
+    }
+    function handleSubmenuPointerOut(event, submenuKey, triggerId) {
+      if (isPointerStillInsideCurrentTarget(event))
+        return;
+      if (openSubmenuKey === submenuKey)
+        scheduleSubmenuClose(submenuKey, triggerId, event);
+    }
+    function clearSubmenuCloseTimer() {
+      if (submenuCloseTimer !== null) {
+        clearTimeout(submenuCloseTimer);
+        submenuCloseTimer = null;
+      }
+      pendingSubmenuCloseKey = null;
+      pendingSubmenuTriggerId = null;
+      submenuLeavePoint = null;
+      latestPointerPoint = null;
+    }
+    function pointInTriangle(point, first, second, third) {
+      const area = 0.5 * (-second.y * third.x + first.y * (-second.x + third.x) + first.x * (second.y - third.y) + second.x * third.y);
+      if (area === 0)
+        return false;
+      const sign = area < 0 ? -1 : 1;
+      const firstWeight = sign * (second.y * third.x - second.x * third.y + (third.y - second.y) * point.x + (second.x - third.x) * point.y) / (2 * Math.abs(area));
+      const secondWeight = sign * (first.x * third.y - first.y * third.x + (first.y - third.y) * point.x + (third.x - first.x) * point.y) / (2 * Math.abs(area));
+      const thirdWeight = 1 - firstWeight - secondWeight;
+      return firstWeight >= 0 && secondWeight >= 0 && thirdWeight >= 0;
+    }
+    function pointInRect(point, rect) {
+      return point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.bottom;
+    }
+    function isPointerInsideSubmenu(submenuKey) {
+      if (!latestPointerPoint)
+        return false;
+      const submenu = menuElements.get(submenuKey);
+      if (!submenu)
+        return false;
+      const submenuRect = submenu.getBoundingClientRect();
+      if (submenuRect.width === 0 && submenuRect.height === 0)
+        return false;
+      return pointInRect(latestPointerPoint, submenuRect);
+    }
+    function isPointerMovingTowardSubmenu(triggerId) {
+      if (!submenuLeavePoint || !latestPointerPoint)
+        return false;
+      if (submenuLeavePoint.x === latestPointerPoint.x && submenuLeavePoint.y === latestPointerPoint.y) {
+        return false;
+      }
+      const submenu = openSubmenuKey ? menuElements.get(openSubmenuKey) : undefined;
+      const trigger = findElementById(triggerId);
+      if (!submenu || !trigger)
+        return false;
+      const submenuRect = submenu.getBoundingClientRect();
+      const triggerRect = trigger.getBoundingClientRect();
+      if (submenuRect.width === 0 && submenuRect.height === 0)
+        return false;
+      const submenuIsInlineStart = submenuRect.right <= triggerRect.left;
+      const nearX = submenuIsInlineStart ? submenuRect.right : submenuRect.left;
+      return pointInTriangle(latestPointerPoint, submenuLeavePoint, { x: nearX, y: submenuRect.top }, { x: nearX, y: submenuRect.bottom });
+    }
+    function clearSubmenuCloseState() {
+      pendingSubmenuCloseKey = null;
+      pendingSubmenuTriggerId = null;
+      submenuLeavePoint = null;
+      latestPointerPoint = null;
+    }
+    function armSubmenuCloseTimer() {
+      submenuCloseTimer = setTimeout(() => {
+        submenuCloseTimer = null;
+        const submenuKey = pendingSubmenuCloseKey;
+        const triggerId = pendingSubmenuTriggerId;
+        if (!submenuKey || !triggerId || openSubmenuKey !== submenuKey) {
+          clearSubmenuCloseState();
+          return;
+        }
+        if (isPointerInsideSubmenu(submenuKey)) {
+          clearSubmenuCloseState();
+          return;
+        }
+        if (isPointerMovingTowardSubmenu(triggerId)) {
+          submenuLeavePoint = latestPointerPoint;
+          armSubmenuCloseTimer();
+          return;
+        }
+        openSubmenuKey = null;
+        clearSubmenuCloseState();
+      }, 150);
+    }
+    function scheduleSubmenuClose(submenuKey, triggerId, event = undefined) {
+      clearSubmenuCloseTimer();
+      pendingSubmenuCloseKey = submenuKey;
+      pendingSubmenuTriggerId = triggerId;
+      if (event) {
+        submenuLeavePoint = { x: event.clientX, y: event.clientY };
+        latestPointerPoint = submenuLeavePoint;
+      }
+      armSubmenuCloseTimer();
+    }
+    function handleDocumentPointermove(event) {
+      if (submenuCloseTimer === null)
+        return;
+      latestPointerPoint = { x: event.clientX, y: event.clientY };
+      const submenuKey = pendingSubmenuCloseKey;
+      const triggerId = pendingSubmenuTriggerId;
+      if (!submenuKey || !triggerId || openSubmenuKey !== submenuKey)
+        return;
+      if (isPointerInsideSubmenu(submenuKey) || isPointerMovingTowardSubmenu(triggerId))
+        return;
+      clearSubmenuCloseTimer();
+      openSubmenuKey = null;
+    }
+    function handleMenuTypeahead(event, menu) {
+      if (!isTypeaheadKey(event))
+        return false;
+      const items = Array.from(menu.querySelectorAll([
+        '[role="menuitem"]:not([data-disabled])',
+        '[role="menuitemcheckbox"]:not([data-disabled])',
+        '[role="menuitemradio"]:not([data-disabled])'
+      ].join(", "))).filter((item) => item.closest('[role="menu"]') === menu);
+      if (!items.length)
+        return false;
+      const currentIndex = items.findIndex((item) => item === document.activeElement);
+      const prefix = typeaheadBuffer.push(event.key);
+      const match = findTypeaheadMatch(items.map((item, index) => ({
+        value: index,
+        label: item.textContent?.trim() ?? "",
+        disabled: item.hasAttribute("data-disabled")
+      })), prefix, currentIndex);
+      if (match !== undefined) {
+        event.preventDefault();
+        items[match]?.focus();
+        return true;
+      }
+      return false;
+    }
+    function handleTriggerKeydown(event, index) {
+      if (event.key === "ArrowRight" || event.key === "ArrowLeft") {
+        event.preventDefault();
+        const nextIndex = nextEnabledMenuIndex(index, horizontalArrowDirection(event.key));
+        if (nextIndex === -1)
+          return;
+        activeMenuIndex = nextIndex;
+        focusTopLevelTrigger(nextIndex);
+        if (openMenuIndex !== null)
+          openMenu(nextIndex);
+        return;
+      }
+      if (event.key === "Home" || event.key === "End") {
+        event.preventDefault();
+        const nextIndex = event.key === "Home" ? firstEnabledMenuIndex() : lastEnabledMenuIndex();
+        if (nextIndex === -1)
+          return;
+        activeMenuIndex = nextIndex;
+        focusTopLevelTrigger(nextIndex);
+        return;
+      }
+      if (event.key === "ArrowDown" || event.key === "Enter" || event.key === " ") {
+        event.preventDefault();
+        openMenu(index, "first");
+        return;
+      }
+      if (event.key === "Escape" && (openMenuIndex !== null || openSubmenuKey !== null)) {
+        event.preventDefault();
+        closeAll();
+        return;
+      }
+      if (event.key === "ArrowUp") {
+        event.preventDefault();
+        openMenu(index, "last");
+      }
+    }
+    function handleRootKeydown(event) {
+      if (consumerOnKeydown) {
+        consumerOnKeydown(event);
+      }
+      if (event.defaultPrevented)
+        return;
+      if (event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey && event.key.length === 1) {
+        const accessKey = event.key.toLocaleLowerCase();
+        const index = menus.findIndex((menu) => !menu.disabled && menu.accessKey?.toLocaleLowerCase() === accessKey);
+        if (index === -1)
+          return;
+        event.preventDefault();
+        openMenu(index, "first");
+        return;
+      }
+      if (openMenuIndex !== null && (event.key === "ArrowRight" || event.key === "ArrowLeft")) {
+        const target = event.target instanceof HTMLElement ? event.target : null;
+        const submenuMenu = target?.closest(".cinder-menu-bar__submenu-menu");
+        if (submenuMenu) {
+          const triggerId = submenuMenu.dataset["cinderMenuBarSubmenuTriggerId"] ?? submenuMenu.closest(".cinder-menu-bar__submenu")?.querySelector("[data-cinder-menu-bar-submenu-trigger]")?.id;
+          const closeArrow = resolveTextDirection(submenuMenu, resolvedDirection()) === "rtl" ? "ArrowRight" : "ArrowLeft";
+          if (event.key === closeArrow) {
+            event.preventDefault();
+            openSubmenuKey = null;
+            if (triggerId)
+              focusSubmenuTriggerAfterClose(triggerId);
+          } else {
+            event.preventDefault();
+            const nextIndex = nextEnabledMenuIndex(openMenuIndex, horizontalArrowDirection(event.key));
+            if (nextIndex !== -1)
+              openMenu(nextIndex, "first");
+          }
+          return;
+        }
+        if (target?.closest('[role="menu"]')) {
+          const menu = target.closest('[role="menu"]');
+          if (menu && handleMenuTypeahead(event, menu))
+            return;
+          event.preventDefault();
+          const nextIndex = nextEnabledMenuIndex(openMenuIndex, horizontalArrowDirection(event.key));
+          if (nextIndex !== -1)
+            openMenu(nextIndex, "first");
+        }
+      } else {
+        const target = event.target instanceof HTMLElement ? event.target : null;
+        const menu = target?.closest('[role="menu"]');
+        if (menu)
+          handleMenuTypeahead(event, menu);
+      }
+    }
+    function handleDocumentPointerdown(event) {
+      if (!rootElement || !(event.target instanceof Node))
+        return;
+      if (isInsideOpenMenu(event.target))
+        return;
+      if (!rootElement.contains(event.target))
+        closeAll();
+    }
+    function handleDocumentFocusin(event) {
+      if (!rootElement || !(event.target instanceof Node))
+        return;
+      tick().then(() => {
+        if (document.activeElement && rootElement?.contains(document.activeElement))
+          return;
+        if (document.activeElement && isInsideOpenMenu(document.activeElement))
+          return;
+        closeAll();
+      });
+    }
+    function handleDocumentKeydown(event) {
+      if (!rootElement || !(event.target instanceof Node))
+        return;
+      if (rootElement.contains(event.target))
+        return;
+      if (!isInsideOpenMenu(event.target))
+        return;
+      handleRootKeydown(event);
+    }
+    $$renderer2.push(`<div${$2.attributes({
+      ...rest,
+      ...renderedRootDirection() ? { dir: renderedRootDirection() } : {},
+      id: rootId(),
+      class: $2.clsx(classNames("cinder-menu-bar", customClassName)),
+      role: "menubar",
+      "aria-label": labelledBy ? undefined : label,
+      "aria-labelledby": labelledBy,
+      "aria-orientation": "horizontal"
+    })}><!--[-->`);
+    const each_array = $2.ensure_array_like(menus);
+    for (let menuIndex = 0, $$length = each_array.length;menuIndex < $$length; menuIndex++) {
+      let menu = each_array[menuIndex];
+      const triggerId = topLevelTriggerId(menuIndex, menu);
+      const menuId = topLevelMenuId(menuIndex, menu);
+      const parts = labelParts(menu);
+      $$renderer2.push(`<div class="cinder-menu-bar__menu"><button${$2.attr("id", triggerId)} type="button" class="cinder-menu-bar__trigger" role="menuitem"${$2.attr("aria-label", menu.label)} aria-haspopup="menu"${$2.attr("aria-expanded", openMenuIndex === menuIndex ? "true" : "false")}${$2.attr("aria-controls", menuId)}${$2.attr("aria-disabled", menu.disabled ? "true" : undefined)}${$2.attr("disabled", menu.disabled, true)}${$2.attr("tabindex", !menu.disabled && activeMenuIndex === menuIndex ? 0 : -1)}${$2.attr("data-cinder-state", openMenuIndex === menuIndex ? "open" : "closed")}>`);
+      if (parts) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`${$2.escape(parts.before)}<span class="cinder-menu-bar__access-key">${$2.escape(parts.key)}</span>${$2.escape(parts.after)}`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        $$renderer2.push(`${$2.escape(menu.label)}`);
+      }
+      $$renderer2.push(`<!--]--></button> `);
+      Menu_bar_dropdown_context($$renderer2, {
+        context: makeContext({
+          menuId,
+          anchorElement: () => findElementById(triggerId),
+          fallbackPlacement: "bottom-start",
+          isOpen: () => openMenuIndex === menuIndex,
+          close: () => closeMenuAndFocusTrigger(menuIndex),
+          focusTrigger: () => focusTopLevelTrigger(menuIndex)
+        }),
+        registerMenu: makeMenuRegister(menuId),
+        registerTrigger: () => {},
+        setOpen: (open) => {
+          if (open)
+            openMenu(menuIndex);
+          else
+            closeAll();
+        },
+        children: ($$renderer3) => {
+          Dropdown_menu($$renderer3, {
+            class: "cinder-menu-bar__dropdown-menu",
+            "aria-labelledby": triggerId,
+            children: ($$renderer4) => {
+              $$renderer4.push(`<div class="cinder-menu-bar__dropdown-scroll" role="presentation"><!--[-->`);
+              const each_array_1 = $2.ensure_array_like(menu.items);
+              for (let entryIndex = 0, $$length2 = each_array_1.length;entryIndex < $$length2; entryIndex++) {
+                let entry = each_array_1[entryIndex];
+                if (isItem(entry)) {
+                  $$renderer4.push("<!--[0-->");
+                  Dropdown_item($$renderer4, {
+                    variant: entry.variant ?? "default",
+                    disabled: entry.disabled ?? false,
+                    closeOnSelect: entry.closeOnSelect ?? true,
+                    onclick: (event) => entry.onSelect?.(event),
+                    onfocus: () => {
+                      openSubmenuKey = null;
+                    },
+                    onpointerenter: () => {
+                      clearSubmenuCloseTimer();
+                      openSubmenuKey = null;
+                    },
+                    children: ($$renderer5) => {
+                      $$renderer5.push(`<span class="cinder-menu-bar__item-label">${$2.escape(entry.label)}</span> `);
+                      if (entry.shortcut) {
+                        $$renderer5.push("<!--[0-->");
+                        $$renderer5.push(`<span class="cinder-menu-bar__shortcut" aria-hidden="true">${$2.escape(entry.shortcut)}</span>`);
+                      } else {
+                        $$renderer5.push("<!--[-1-->");
+                      }
+                      $$renderer5.push(`<!--]-->`);
+                    },
+                    $$slots: { default: true }
+                  });
+                } else if (isSubmenu(entry)) {
+                  $$renderer4.push("<!--[1-->");
+                  const submenuKey = submenuMenuId(menuIndex, menu, entryIndex, entry);
+                  const submenuTrigger = submenuTriggerId(menuIndex, menu, entryIndex, entry);
+                  $$renderer4.push(`<div class="cinder-menu-bar__submenu" role="presentation">`);
+                  Dropdown_item($$renderer4, {
+                    id: submenuTrigger,
+                    class: "cinder-menu-bar__submenu-trigger",
+                    disabled: entry.disabled,
+                    closeOnSelect: false,
+                    "aria-haspopup": "menu",
+                    "aria-expanded": openSubmenuKey === submenuKey ? "true" : "false",
+                    "aria-controls": submenuKey,
+                    "data-cinder-menu-bar-submenu-trigger": true,
+                    onclick: () => {
+                      if (!entry.disabled)
+                        openSubmenu(submenuKey);
+                    },
+                    onfocus: () => {
+                      if (!entry.disabled && !suppressSubmenuFocusOpen)
+                        openSubmenu(submenuKey, "none");
+                    },
+                    onpointerenter: () => {
+                      clearSubmenuCloseTimer();
+                      if (openMenuIndex === menuIndex && !entry.disabled)
+                        openSubmenu(submenuKey, "none");
+                    },
+                    onpointerout: (event) => handleSubmenuPointerOut(event, submenuKey, submenuTrigger),
+                    onmouseleave: (event) => handleSubmenuPointerOut(event, submenuKey, submenuTrigger),
+                    onkeydown: (event) => {
+                      if (entry.disabled)
+                        return;
+                      if (event.key === submenuOpenArrow(submenuTrigger) || event.key === "Enter" || event.key === " ") {
+                        event.preventDefault();
+                        event.stopPropagation();
+                        openSubmenu(submenuKey);
+                      }
+                    },
+                    children: ($$renderer5) => {
+                      $$renderer5.push(`<span class="cinder-menu-bar__item-label">${$2.escape(entry.label)}</span> <span class="cinder-menu-bar__submenu-indicator" aria-hidden="true">></span>`);
+                    },
+                    $$slots: { default: true }
+                  });
+                  $$renderer4.push(`<!----> `);
+                  Menu_bar_dropdown_context($$renderer4, {
+                    context: makeContext({
+                      menuId: submenuKey,
+                      anchorElement: () => findElementById(submenuTrigger),
+                      fallbackPlacement: () => submenuFallbackPlacement(submenuTrigger),
+                      isOpen: () => openSubmenuKey === submenuKey,
+                      close: () => closeMenuAndFocusTrigger(menuIndex),
+                      focusTrigger: () => focusSubmenuTriggerAfterClose(submenuTrigger)
+                    }),
+                    registerMenu: makeMenuRegister(submenuKey),
+                    registerTrigger: () => {},
+                    setOpen: (open) => {
+                      if (open)
+                        openSubmenu(submenuKey);
+                      else
+                        openSubmenuKey = null;
+                    },
+                    children: ($$renderer5) => {
+                      Dropdown_menu($$renderer5, {
+                        class: "cinder-menu-bar__submenu-menu",
+                        dir: submenuDirection(submenuTrigger),
+                        "data-cinder-menu-bar-submenu-trigger-id": submenuTrigger,
+                        "aria-labelledby": submenuTrigger,
+                        onfocusin: () => {
+                          clearSubmenuCloseTimer();
+                        },
+                        onpointerenter: () => {
+                          clearSubmenuCloseTimer();
+                        },
+                        onpointerout: (event) => handleSubmenuPointerOut(event, submenuKey, submenuTrigger),
+                        onmouseleave: (event) => handleSubmenuPointerOut(event, submenuKey, submenuTrigger),
+                        children: ($$renderer6) => {
+                          $$renderer6.push(`<!--[-->`);
+                          const each_array_2 = $2.ensure_array_like(entry.items);
+                          for (let submenuEntryIndex = 0, $$length3 = each_array_2.length;submenuEntryIndex < $$length3; submenuEntryIndex++) {
+                            let submenuEntry = each_array_2[submenuEntryIndex];
+                            if (isItem(submenuEntry)) {
+                              $$renderer6.push("<!--[0-->");
+                              Dropdown_item($$renderer6, {
+                                variant: submenuEntry.variant ?? "default",
+                                disabled: submenuEntry.disabled ?? false,
+                                closeOnSelect: submenuEntry.closeOnSelect ?? true,
+                                onclick: (event) => submenuEntry.onSelect?.(event),
+                                children: ($$renderer7) => {
+                                  $$renderer7.push(`<span class="cinder-menu-bar__item-label">${$2.escape(submenuEntry.label)}</span> `);
+                                  if (submenuEntry.shortcut) {
+                                    $$renderer7.push("<!--[0-->");
+                                    $$renderer7.push(`<span class="cinder-menu-bar__shortcut" aria-hidden="true">${$2.escape(submenuEntry.shortcut)}</span>`);
+                                  } else {
+                                    $$renderer7.push("<!--[-1-->");
+                                  }
+                                  $$renderer7.push(`<!--]-->`);
+                                },
+                                $$slots: { default: true }
+                              });
+                            } else if (submenuEntry.type === "label") {
+                              $$renderer6.push("<!--[1-->");
+                              Dropdown_label($$renderer6, {
+                                children: ($$renderer7) => {
+                                  $$renderer7.push(`<!---->${$2.escape(submenuEntry.label)}`);
+                                },
+                                $$slots: { default: true }
+                              });
+                            } else {
+                              $$renderer6.push("<!--[-1-->");
+                              Dropdown_separator($$renderer6, {});
+                            }
+                            $$renderer6.push(`<!--]-->`);
+                          }
+                          $$renderer6.push(`<!--]-->`);
+                        },
+                        $$slots: { default: true }
+                      });
+                    },
+                    $$slots: { default: true }
+                  });
+                  $$renderer4.push(`<!----></div>`);
+                } else if (entry.type === "label") {
+                  $$renderer4.push("<!--[2-->");
+                  Dropdown_label($$renderer4, {
+                    children: ($$renderer5) => {
+                      $$renderer5.push(`<!---->${$2.escape(entry.label)}`);
+                    },
+                    $$slots: { default: true }
+                  });
+                } else {
+                  $$renderer4.push("<!--[-1-->");
+                  Dropdown_separator($$renderer4, {});
+                }
+                $$renderer4.push(`<!--]-->`);
+              }
+              $$renderer4.push(`<!--]--></div>`);
+            },
+            $$slots: { default: true }
+          });
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----></div>`);
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/menu-bar/index.ts
+var menu_bar_default = Menu_bar;
+export { Menu_bar, menu_bar_default };
+
+//# debugId=E2D8C8A2EA2E8CF764756E2164756E21