@siemens/ix 5.0.0 → 5.1.0

package/dist/collection/components/utils/nested-overlay/nested-overlay-stack.js

@@ -0,0 +1,101 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Siemens AG
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { buildComposedPath, buildPathIncluding, removeIdFromHierarchy, } from "./hierarchy";
+export class NestedOverlayStack {
+    policy;
+    dismissInstance;
+    instances = new Map();
+    childIdsByParent = {};
+    constructor(policy, dismissInstance) {
+        this.policy = policy;
+        this.dismissInstance = dismissInstance;
+    }
+    connect(instance) {
+        this.instances.set(instance.getId(), instance);
+    }
+    disconnect(instance) {
+        const id = instance.getId();
+        this.removeFromHierarchy(id);
+        this.instances.delete(id);
+    }
+    get(id) {
+        return this.instances.get(id);
+    }
+    keys() {
+        return [...this.instances.keys()];
+    }
+    forEach(callback) {
+        this.instances.forEach(callback);
+    }
+    values() {
+        return this.instances.values();
+    }
+    setChildIds(parentId, childIds) {
+        this.childIdsByParent[parentId] = childIds;
+    }
+    deleteChildIdsEntry(parentId) {
+        delete this.childIdsByParent[parentId];
+    }
+    getChildIds(parentId) {
+        return this.childIdsByParent[parentId] || [];
+    }
+    getChildIdsByParent() {
+        return this.childIdsByParent;
+    }
+    removeFromHierarchy(id) {
+        removeIdFromHierarchy(id, this.childIdsByParent, this.instances.keys());
+    }
+    buildComposedPath(id, path = new Set()) {
+        return buildComposedPath(id, this.childIdsByParent, path);
+    }
+    buildPathIncluding(id) {
+        return buildPathIncluding(id, this.childIdsByParent);
+    }
+    dismissChildren(parentId) {
+        for (const childId of this.getChildIds(parentId)) {
+            const child = this.instances.get(childId);
+            if (child) {
+                this.dismissInstance(child);
+            }
+        }
+    }
+    dismissAll(options = {}) {
+        const { ignorePolicyForIds = [], ignoreRelatedInHierarchy = false } = options;
+        this.forEach((instance) => {
+            const id = instance.getId();
+            const shouldIgnorePolicy = ignorePolicyForIds.includes(id);
+            const path = buildComposedPath(id, this.childIdsByParent, new Set());
+            if (ignorePolicyForIds.length > 0 && ignoreRelatedInHierarchy) {
+                let skipRelated = false;
+                for (const ignoreId of ignorePolicyForIds) {
+                    if (path.has(ignoreId)) {
+                        skipRelated = true;
+                        break;
+                    }
+                }
+                if (!skipRelated) {
+                    return;
+                }
+            }
+            if (!shouldIgnorePolicy && this.policy.blocksOutsideDismiss(instance)) {
+                return;
+            }
+            this.dismissInstance(instance);
+        });
+    }
+    dismissOthers(activeId) {
+        const path = this.buildPathIncluding(activeId);
+        this.forEach((instance) => {
+            if (!this.policy.blocksOutsideDismiss(instance) &&
+                !path.has(instance.getId())) {
+                this.dismissInstance(instance);
+            }
+        });
+    }
+}

package/dist/collection/components/utils/nested-overlay/path-utils.js

@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Siemens AG
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export function pathIncludesTrigger(eventTargets, triggerAttribute) {
+    for (const eventTarget of eventTargets) {
+        if (eventTarget instanceof HTMLElement &&
+            eventTarget.hasAttribute(triggerAttribute)) {
+            return eventTarget;
+        }
+    }
+    return undefined;
+}

package/dist/collection/components/utils/nested-overlay/types.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/utils/shadow-dom.js

@@ -22,6 +22,18 @@ export function hasSlottedElements(slot) {
     }
     return slot.assignedElements({ flatten: true }).length !== 0;
 }
+export function hasSlottedContent(slot) {
+    if (!slot) {
+        return false;
+    }
+    if (hasSlottedElements(slot)) {
+        return true;
+    }
+    return slot
+        .assignedNodes({ flatten: true })
+        .some((node) => node.nodeType === Node.TEXT_NODE &&
+        (node.textContent ?? '').trim().length > 0);
+}
 export function containsElement(target, element) {
     const hasShadowDom = target.shadowRoot;
     if (hasShadowDom) {

package/dist/collection/components/workflow-step/workflow-step.js

@@ -113,18 +113,18 @@ export class WorkflowStep {
     }
     render() {
         const icons = !this.customIconSlot ? (h(Fragment, null, h("ix-icon", { color: "color-1", name: this.status === 'warning' ? iconTriangleFilled : iconCircleFilled, class: "absolute", size: "24" }), h("ix-icon", { color: this.iconColor, name: this.iconName, class: "absolute", size: "24", "aria-label": this.getIconAriaLabel() }))) : null;
-        return (h(Host, { key: '69060f0b0d9724d1a7e5d88d723454354a0ae179', class: { 'host-vertical': this.vertical }, onClick: () => this.onStepClick() }, h("div", { key: 'e271713f7b57462155e967d2fd74bb911640c6b1', tabIndex: 0, class: {
+        return (h(Host, { key: '9ce5d93c28b5faeab001bd9210a022b32d2635c3', class: { 'host-vertical': this.vertical }, onClick: () => this.onStepClick() }, h("div", { key: 'd3e4dc4bfd15f93461193fd1cc88bd666103160f', tabIndex: 0, class: {
                 step: true,
                 selected: this.selected,
                 vertical: this.vertical,
                 disabled: this.disabled,
                 clickable: this.clickable && !this.disabled,
-            } }, h("div", { key: '28fb3c2e870564f3cfa62a402ba75b62ef84d68f', class: "wrapper" }, h("div", { key: '7178b44d0f6e20202c62e83af8e983392cf00ecd', class: {
+            } }, h("div", { key: 'd9e7ed59ca4a16c28ad973c85b09a19044954f08', class: "wrapper" }, h("div", { key: '89d015629ccebbdb8a94d8c9ee276f3abb8c876f', class: {
                 line: true,
                 selected: this.selected,
                 [this.status]: true,
                 [this.position]: true,
-            } }), h("div", { key: '8f10884a92e4f0685f20a10cb12cd19b39a7a2f9', class: "iconWrapper" }, icons, h("slot", { key: '6e3d96ae17ce0b3b217edef59b1e3999a1d028d5', name: "custom-icon" }))), h("div", { key: '80b1b2adc4f110d505e5fcb4263781b11b58ff49', class: "text" }, h("slot", { key: '07f9b88ce66abffd1190940968ed20ae6cd5ec09' })))));
+            } }), h("div", { key: '56abb531bee9339a25c540019faef59a406a542a', class: "iconWrapper" }, icons, h("slot", { key: 'e903779416603e31faf8cacd15cc85c751e6376a', name: "custom-icon" }))), h("div", { key: '5c93afc3352897a7480e27251590cbb3dce86e9a', class: "text" }, h("slot", { key: '6594f25dccef5bd78bf255839487a9e8fdc7d3ca' })))));
     }
     static get is() { return "ix-workflow-step"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/workflow-steps/workflow-steps.js

@@ -85,7 +85,7 @@ export class WorkflowSteps {
         this.updateSteps();
     }
     render() {
-        return (h(Host, { key: '05f04dea227019aa7f0e0a3b24cecb45ed80c452' }, h("div", { key: '6423cddc50bc1928ae2f1f78d6b22c12dda49c9d', class: { steps: true, vertical: this.vertical } }, h("slot", { key: '44ee3bca297914083a92a66ae3c496e05bd52b94' }))));
+        return (h(Host, { key: 'a1ad0dc5f6ab4753831f1b476c6ad585db6fdb96' }, h("div", { key: '7837c226c1450e022380817676adf4b96ff2ab78', class: { steps: true, vertical: this.vertical } }, h("slot", { key: '96b38116fa2b9c8fbd9d3595393d7514b1bed984' }))));
     }
     static get is() { return "ix-workflow-steps"; }
     static get encapsulation() { return "shadow"; }

package/dist/esm/{a11y-B5k8YVR0.js → a11y-C21npbUc.js}

@@ -140,5 +140,14 @@ const a11yAttributes = [
     'aria-valuenow',
     'aria-valuetext',
 ];
+/**
+ * Usually called by ref={(ref) => forceTabIndex(ref, -1)} to workaround an issue
+ * where the tabIndex is not applied to the element after re-render.
+ */
+const forceTabIndex = (element, tabIndex) => {
+    if (element) {
+        element.tabIndex = tabIndex;
+    }
+};
 
-export { a11yBoolean as a, a11yHostAttributes as b, getFallbackLabelFromIconName as g };
+export { a11yBoolean as a, a11yHostAttributes as b, forceTabIndex as f, getFallbackLabelFromIconName as g };

package/dist/esm/{base-button-hppF0uUM.js → base-button-DZdtpLxn.js}

@@ -1,5 +1,5 @@
-import { h } from './index-Ca5WUunf.js';
-import { a as a11yBoolean } from './a11y-B5k8YVR0.js';
+import { h } from './index-EBgS4zhE.js';
+import { a as a11yBoolean } from './a11y-C21npbUc.js';
 
 /*
  * SPDX-FileCopyrightText: 2023 Siemens AG
@@ -74,7 +74,7 @@ const BaseButton = (props, children) => {
         return (h("a", { ...commonAttributes, "aria-disabled": a11yBoolean(props.disabled), href: props.disabled ? undefined : props.href, target: props.target, role: "button", rel: props.rel, onClick: (e) => handleOnClick(e, props) }, buttonContent));
     }
     // Otherwise, render as a button
-    return (h("button", { ...commonAttributes, "aria-disabled": a11yBoolean(props.disabled), onClick: (e) => handleOnClick(e, props), type: props.type }, buttonContent));
+    return (h("button", { ...commonAttributes, "aria-disabled": a11yBoolean(props.disabled), disabled: props.disabled || props.loading, onClick: (e) => handleOnClick(e, props), type: props.type }, buttonContent));
 };
 
 export { BaseButton as B, getButtonClasses as g };

package/dist/esm/{base-icon-button-_xVULsPr.js → base-icon-button-DufFLJC-.js}

@@ -1,5 +1,5 @@
-import { h } from './index-Ca5WUunf.js';
-import { B as BaseButton } from './base-button-hppF0uUM.js';
+import { h } from './index-EBgS4zhE.js';
+import { B as BaseButton } from './base-button-DZdtpLxn.js';
 
 /*
  * SPDX-FileCopyrightText: 2023 Siemens AG

package/dist/esm/{component-Chfbghog.js → component-DqJSHc3A.js}

@@ -1,5 +1,5 @@
-import { F as FOCUS_KEYS, I as IX_FOCUS_VISIBLE_ACTIVE, a as IX_FOCUS_VISIBLE } from './focus-utilities-DnaItyVQ.js';
-import { g as getComposedPath } from './shadow-dom-BIe8Nw9M.js';
+import { F as FOCUS_KEYS, I as IX_FOCUS_VISIBLE_ACTIVE, a as IX_FOCUS_VISIBLE } from './focus-utilities-6ZxKp7Jn.js';
+import { g as getComposedPath } from './shadow-dom-BClJdFQP.js';
 
 function detectKeyboardMode(element) {
     let keyboardMode = false;

package/dist/esm/dropdown-controller-Jfg3ZWk6.js

@@ -0,0 +1,96 @@
+import { N as NestedOverlayStack, p as pathIncludesTrigger, g as getParentId } from './path-utils-CNLoALIl.js';
+
+/*
+ * SPDX-FileCopyrightText: 2024 Siemens AG
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function hasDropdownItemWrapperImplemented(item) {
+    return (item !== null &&
+        item.getDropdownItemElement !== undefined &&
+        typeof item.getDropdownItemElement === 'function');
+}
+class DropdownController {
+    stack = new NestedOverlayStack({
+        blocksOutsideDismiss: (dropdown) => dropdown.closeBehavior === 'inside' || dropdown.closeBehavior === false,
+    }, (dropdown) => this.dismiss(dropdown));
+    isWindowListenerActive = false;
+    connected(dropdown) {
+        if (!this.isWindowListenerActive) {
+            this.addOverlayListeners();
+        }
+        this.stack.connect(dropdown);
+        if (dropdown.discoverAllSubmenus) {
+            this.discoverSubmenus();
+        }
+    }
+    disconnected(dropdown) {
+        this.stack.disconnect(dropdown);
+    }
+    removeFromSubmenuIds(id) {
+        this.stack.removeFromHierarchy(id);
+    }
+    getDropdownById(id) {
+        return this.stack.get(id);
+    }
+    discoverSubmenus() {
+        this.stack.forEach((dropdown) => {
+            dropdown.discoverSubmenu();
+        });
+    }
+    present(dropdown) {
+        if (!dropdown.isPresent() && dropdown.willPresent?.()) {
+            this.stack.setChildIds(dropdown.getId(), dropdown.getAssignedSubmenuIds());
+            dropdown.present();
+        }
+    }
+    dismissChildren(uid) {
+        this.stack.dismissChildren(uid);
+    }
+    dismiss(dropdown) {
+        if (dropdown.isPresent() && dropdown.willDismiss?.()) {
+            this.stack.dismissChildren(dropdown.getId());
+            dropdown.dismiss();
+            this.stack.deleteChildIdsEntry(dropdown.getId());
+        }
+    }
+    dismissAll(ignoreBehaviorForIds = [], ignoreRelatedDropdowns = false) {
+        this.stack.dismissAll({
+            ignorePolicyForIds: ignoreBehaviorForIds,
+            ignoreRelatedInHierarchy: ignoreRelatedDropdowns,
+        });
+    }
+    dismissOthers(uid) {
+        this.stack.dismissOthers(uid);
+    }
+    pathIncludesTrigger(eventTargets) {
+        return pathIncludesTrigger(eventTargets, 'data-ix-dropdown-trigger');
+    }
+    getParentDropdownId(dropdownId) {
+        return getParentId(dropdownId, this.stack.getChildIdsByParent());
+    }
+    pathIncludesDropdown(eventTargets) {
+        return !!eventTargets.find((element) => element.tagName === 'IX-DROPDOWN');
+    }
+    addOverlayListeners() {
+        this.isWindowListenerActive = true;
+        window.addEventListener('click', (event) => {
+            const hasTrigger = this.pathIncludesTrigger(event.composedPath());
+            const hasDropdown = this.pathIncludesDropdown(event.composedPath());
+            if (!hasTrigger && !hasDropdown) {
+                this.dismissAll();
+            }
+        });
+        window.addEventListener('keydown', (event) => {
+            if (event.key === 'Escape') {
+                this.dismissAll(this.stack.keys());
+            }
+        });
+    }
+}
+const dropdownController = new DropdownController();
+
+export { dropdownController as d, hasDropdownItemWrapperImplemented as h };

package/dist/esm/{focus-proxy-BgLEsVE2.js → focus-proxy-BQyoX-Kl.js}

@@ -1,4 +1,4 @@
-import { h } from './index-Ca5WUunf.js';
+import { h } from './index-EBgS4zhE.js';
 
 /*
  * SPDX-FileCopyrightText: 2026 Siemens AG
@@ -20,14 +20,15 @@ const PROXY_LIST_ID_SUFFIX = 'proxy-listbox';
 const PROXY_LISTITEM_ID_SUFFIX = 'proxy-listbox-item';
 const updateFocusProxyList = (proxyListElement, items, modifyProxyElement) => {
     if (proxyListElement && items.length > 0) {
-        const top = items[0].getBoundingClientRect().top -
-            items[0].getBoundingClientRect().height +
-            8;
+        const itemRect = items[0].getBoundingClientRect();
+        const containerRect = (proxyListElement.offsetParent ?? proxyListElement.parentElement)?.getBoundingClientRect();
+        const top = containerRect
+            ? Math.max(0, itemRect.top - containerRect.top - itemRect.height + 8)
+            : 0;
         proxyListElement.innerHTML = '';
         proxyListElement.style.top = top + 'px';
         proxyListElement.style.padding = '0px';
         proxyListElement.style.margin = '0px';
-        proxyListElement.innerHTML = '';
         items.forEach((item) => {
             const li = document.createElement('li');
             li.id = item.id + '-' + PROXY_LISTITEM_ID_SUFFIX;

package/dist/esm/focus-trap-IK9ialav.js

@@ -0,0 +1,304 @@
+import { i as isMakeRef } from './make-ref-Djkc69iv.js';
+import { q as queryElements, t as tryFocusElement, f as focusElementInContext, b as focusableQueryString } from './focus-utilities-6ZxKp7Jn.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Siemens AG
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const TRAP_FOCUS_EXCLUDE_ATTRIBUTE = 'data-ix-focus-trap-exclude';
+const TRAP_FOCUS_INCLUDE_ATTRIBUTE = 'data-ix-focus-trap-include';
+const POPOVER_TAG = 'IX-POPOVER';
+const POPOVER_HEADER_TAG = 'IX-POPOVER-HEADER';
+const focusTrapQuery = `${focusableQueryString}, [${TRAP_FOCUS_INCLUDE_ATTRIBUTE}]`;
+const mergeUniqueInDocumentOrder = (...lists) => {
+    const unique = [];
+    const seen = new Set();
+    for (const list of lists) {
+        for (const element of list) {
+            if (!seen.has(element)) {
+                seen.add(element);
+                unique.push(element);
+            }
+        }
+    }
+    return unique.sort((a, b) => {
+        const position = a.compareDocumentPosition(b);
+        if (position & Node.DOCUMENT_POSITION_FOLLOWING) {
+            return -1;
+        }
+        if (position & Node.DOCUMENT_POSITION_PRECEDING) {
+            return 1;
+        }
+        return 0;
+    });
+};
+const getDeepActiveElement = () => {
+    let active = document.activeElement;
+    while (active) {
+        if (active instanceof HTMLElement && active.shadowRoot?.activeElement) {
+            const shadowActive = active.shadowRoot.activeElement;
+            if (shadowActive !== active) {
+                active = shadowActive;
+                continue;
+            }
+        }
+        const root = active.getRootNode();
+        if (root instanceof ShadowRoot &&
+            root.activeElement &&
+            root.activeElement !== active) {
+            active = root.activeElement;
+            continue;
+        }
+        break;
+    }
+    return active;
+};
+const resolveFocusTrapActiveElement = (trapHost, focusableElements) => {
+    let activeElement = getDeepActiveElement();
+    if (findActiveFocusableIndex(activeElement, focusableElements) !== -1) {
+        if (activeElement instanceof HTMLElement &&
+            activeElement.hasAttribute(TRAP_FOCUS_INCLUDE_ATTRIBUTE) &&
+            activeElement.shadowRoot?.activeElement) {
+            const includedActive = activeElement.shadowRoot.activeElement;
+            if (findActiveFocusableIndex(includedActive, focusableElements) !== -1) {
+                return includedActive;
+            }
+        }
+        return activeElement;
+    }
+    const shadowActive = trapHost.shadowRoot?.activeElement;
+    if (shadowActive instanceof HTMLElement &&
+        findActiveFocusableIndex(shadowActive, focusableElements) !== -1) {
+        return shadowActive;
+    }
+    return activeElement;
+};
+function findActiveFocusableIndex(active, focusableElements) {
+    if (!(active instanceof HTMLElement)) {
+        return -1;
+    }
+    const directIndex = focusableElements.indexOf(active);
+    if (directIndex !== -1) {
+        return directIndex;
+    }
+    for (let index = 0; index < focusableElements.length; index++) {
+        const candidate = focusableElements[index];
+        if (candidate.shadowRoot?.contains(active)) {
+            return index;
+        }
+        const activeRoot = active.getRootNode();
+        if (activeRoot instanceof ShadowRoot && activeRoot.host === candidate) {
+            return index;
+        }
+        if (candidate.contains(active)) {
+            return index;
+        }
+    }
+    return -1;
+}
+const isOpenPopoverHost = (host) => {
+    if (host.classList.contains('visible')) {
+        return true;
+    }
+    const dialog = host.shadowRoot?.querySelector('dialog');
+    return dialog?.matches(':popover-open') ?? false;
+};
+const isNestedOpenPopoverLayer = (element, trapHost) => {
+    const ownerPopover = getPopoverHostForElement(element);
+    return (ownerPopover !== undefined &&
+        ownerPopover !== trapHost &&
+        isOpenPopoverHost(ownerPopover));
+};
+function getPopoverHostForElement(element) {
+    let current = element;
+    while (current) {
+        if (current instanceof HTMLElement && current.tagName === POPOVER_TAG) {
+            return current;
+        }
+        const root = current.getRootNode();
+        if (root instanceof ShadowRoot) {
+            current = root.host;
+            continue;
+        }
+        current = current.parentElement;
+    }
+    return undefined;
+}
+function isWithinInertSubtree(element) {
+    let current = element;
+    while (current) {
+        if (current instanceof HTMLElement && current.inert) {
+            return true;
+        }
+        if (current instanceof ShadowRoot) {
+            current = current.host;
+            continue;
+        }
+        current = current.parentNode;
+    }
+    return false;
+}
+function shouldExcludeFromFocusTrap(element, trapHost) {
+    if (isWithinInertSubtree(element)) {
+        return true;
+    }
+    const ownerPopover = getPopoverHostForElement(element);
+    if (!ownerPopover || ownerPopover === trapHost) {
+        return false;
+    }
+    return true;
+}
+/** CSS-hidden controls can match the focusable query but are not in tab order. */
+function isHiddenFromTabOrder(element) {
+    const { display, visibility } = getComputedStyle(element);
+    return display === 'none' || visibility === 'hidden';
+}
+/** Drops focusables inside closed or nested child popovers (not tabbable in the active layer). */
+function filterFocusTrapFocusables(focusableElements, trapHost) {
+    return focusableElements.filter((element) => !shouldExcludeFromFocusTrap(element, trapHost));
+}
+function expandFocusTrapIncludes(focusableElements, options) {
+    const useBoth = options?.trapFocusInShadowDom === 'both';
+    for (let index = 0; index < focusableElements.length; index++) {
+        const includeElement = focusableElements[index];
+        if (!includeElement.hasAttribute(TRAP_FOCUS_INCLUDE_ATTRIBUTE)) {
+            continue;
+        }
+        const includedFocusableElements = queryElements(useBoth ||
+            (options?.trapFocusInShadowDom === true && includeElement.shadowRoot)
+            ? (includeElement.shadowRoot ?? includeElement)
+            : includeElement, focusableQueryString, useBoth).filter((element) => element !== includeElement && !isHiddenFromTabOrder(element));
+        for (const includedElement of includedFocusableElements) {
+            const duplicateIndex = focusableElements.indexOf(includedElement);
+            if (duplicateIndex !== -1) {
+                focusableElements.splice(duplicateIndex, 1);
+                if (duplicateIndex < index) {
+                    index--;
+                }
+            }
+        }
+        focusableElements.splice(index, 1, ...includedFocusableElements);
+        index += includedFocusableElements.length - 1;
+    }
+}
+function getFocusTrapFocusables(ref, options) {
+    const useBoth = options?.trapFocusInShadowDom === 'both';
+    let focusableElements;
+    if (useBoth) {
+        const fromShadow = ref.shadowRoot
+            ? queryElements(ref.shadowRoot, focusTrapQuery, false)
+            : [];
+        const fromLight = queryElements(ref, focusTrapQuery, false);
+        focusableElements = mergeUniqueInDocumentOrder(fromShadow, fromLight);
+    }
+    else {
+        const focusTrapRoot = options?.trapFocusInShadowDom === true ? ref.shadowRoot : ref;
+        focusableElements = queryElements(focusTrapRoot, focusTrapQuery, useBoth);
+    }
+    expandFocusTrapIncludes(focusableElements, options);
+    const filtered = filterFocusTrapFocusables(focusableElements, ref).filter((element) => !isHiddenFromTabOrder(element));
+    if (!options?.excludeElements) {
+        return filtered;
+    }
+    return filtered.filter((element) => !element.hasAttribute(TRAP_FOCUS_EXCLUDE_ATTRIBUTE));
+}
+function isHeaderFocusable(element, trapHost) {
+    let current = element;
+    while (current && current !== trapHost) {
+        if (current instanceof HTMLElement &&
+            current.tagName === POPOVER_HEADER_TAG) {
+            return true;
+        }
+        const root = current.getRootNode();
+        if (root instanceof ShadowRoot) {
+            current = root.host;
+            continue;
+        }
+        current = current.parentElement;
+    }
+    return false;
+}
+/** Focus the first content control; falls back to the header close when content has none. */
+function focusFirstFocusTrapElement(ref, options, focusOptions) {
+    const focusableElements = getFocusTrapFocusables(ref, options);
+    const contentFirst = focusableElements.find((element) => !isHeaderFocusable(element, ref));
+    const target = contentFirst ?? focusableElements[0];
+    focusElementInContext(target ?? null, ref, focusOptions);
+}
+const resolveFocusTrapElement = async (target) => {
+    if (target instanceof HTMLElement) {
+        return target;
+    }
+    if (isMakeRef(target)) {
+        return target.waitForCurrent();
+    }
+    throw new Error('Invalid focus trap element reference');
+};
+const addFocusTrap = async (element, options) => {
+    const trapHost = options?.targetElement
+        ? await resolveFocusTrapElement(options.targetElement)
+        : element;
+    let listenerTarget = element;
+    if (options?.listenOnDocument) {
+        listenerTarget = document;
+    }
+    else if (options?.targetElement) {
+        listenerTarget = trapHost;
+    }
+    const onKeydown = (event) => {
+        const keyboardEvent = event;
+        if (keyboardEvent.key !== 'Tab') {
+            return;
+        }
+        if (options?.listenOnDocument) {
+            if (options.shouldDeferTabTrap?.(trapHost)) {
+                return;
+            }
+            const deepActive = getDeepActiveElement();
+            if (deepActive instanceof HTMLElement &&
+                isNestedOpenPopoverLayer(deepActive, trapHost)) {
+                return;
+            }
+        }
+        const focusableElements = getFocusTrapFocusables(trapHost, options);
+        if (focusableElements.length === 0) {
+            return;
+        }
+        const firstElement = focusableElements[0];
+        const lastElement = focusableElements[focusableElements.length - 1];
+        const activeElement = resolveFocusTrapActiveElement(trapHost, focusableElements);
+        const activeIndex = findActiveFocusableIndex(activeElement, focusableElements);
+        let handled = false;
+        if (activeIndex === -1) {
+            return;
+        }
+        if (keyboardEvent.shiftKey) {
+            if (activeIndex === 0) {
+                keyboardEvent.preventDefault();
+                tryFocusElement(lastElement);
+                handled = true;
+            }
+        }
+        else if (activeIndex === focusableElements.length - 1) {
+            keyboardEvent.preventDefault();
+            tryFocusElement(firstElement);
+            handled = true;
+        }
+        if (handled) {
+            event.stopImmediatePropagation();
+        }
+    };
+    listenerTarget.addEventListener('keydown', onKeydown);
+    const destroy = () => {
+        listenerTarget.removeEventListener('keydown', onKeydown);
+    };
+    return {
+        destroy,
+    };
+};
+
+export { TRAP_FOCUS_EXCLUDE_ATTRIBUTE as T, addFocusTrap as a, TRAP_FOCUS_INCLUDE_ATTRIBUTE as b, focusFirstFocusTrapElement as f, getFocusTrapFocusables as g };