@siemens/ix 4.4.0 → 5.0.0

package/dist/cjs/{base-button-BvWcXXIH.js → base-button-C-1izOSS.js}

@@ -1,6 +1,7 @@
 'use strict';
 
-var index = require('./index-Dxeom0qd.js');
+var index = require('./index-BKQkUbyE.js');
+var a11y = require('./a11y-C_6YiIMa.js');
 
 /*
  * SPDX-FileCopyrightText: 2023 Siemens AG
@@ -49,14 +50,17 @@ const isIconDecorative = (ariaAttributes, children) => {
     return hasTextContent || hasAriaLabel;
 };
 const BaseButton = (props, children) => {
-    var _a, _b, _c;
-    const extraClasses = (_a = props.extraClasses) !== null && _a !== void 0 ? _a : {};
-    const ariaAttributes = (_b = props.ariaAttributes) !== null && _b !== void 0 ? _b : {};
-    if (!ariaAttributes['aria-disabled'] && props.disabled) {
-        ariaAttributes['aria-disabled'] = 'true';
-    }
+    const extraClasses = props.extraClasses ?? {};
+    const ariaAttributes = props.ariaAttributes ?? {};
     const iconIsDecorative = isIconDecorative(ariaAttributes, children);
-    const commonAttributes = Object.assign(Object.assign({}, ariaAttributes), { tabindex: props.disabled ? -1 : ((_c = props.tabIndex) !== null && _c !== void 0 ? _c : 0), class: Object.assign(Object.assign({}, getButtonClasses(props.variant, props.iconOnly, props.iconOval, props.selected, props.disabled || props.loading)), extraClasses) });
+    const commonAttributes = {
+        ...ariaAttributes,
+        tabindex: props.disabled ? -1 : (props.tabIndex ?? 0),
+        class: {
+            ...getButtonClasses(props.variant, props.iconOnly, props.iconOval, props.selected, props.disabled || props.loading),
+            ...extraClasses,
+        },
+    };
     const buttonContent = [
         props.loading ? (index.h("ix-spinner", { size: getSpinnerSize(props), hideTrack: true })) : null,
         props.icon && !props.loading ? (index.h("ix-icon", { class: "icon", name: props.icon, size: props.iconSize, color: props.iconColor, "aria-hidden": iconIsDecorative ? 'true' : undefined })) : null,
@@ -69,10 +73,10 @@ const BaseButton = (props, children) => {
     ];
     // If href is provided, render as an anchor tag
     if (props.href) {
-        return (index.h("a", Object.assign({}, commonAttributes, { href: props.disabled ? undefined : props.href, target: props.target, role: "button", rel: props.rel, onClick: (e) => handleOnClick(e, props) }), buttonContent));
+        return (index.h("a", { ...commonAttributes, "aria-disabled": a11y.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 (index.h("button", Object.assign({}, commonAttributes, { onClick: (e) => handleOnClick(e, props), type: props.type }), buttonContent));
+    return (index.h("button", { ...commonAttributes, "aria-disabled": a11y.a11yBoolean(props.disabled), onClick: (e) => handleOnClick(e, props), type: props.type }, buttonContent));
 };
 
 exports.BaseButton = BaseButton;

package/dist/cjs/{base-icon-button-DgnV_-qM.js → base-icon-button-BeXf6v9s.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var index = require('./index-Dxeom0qd.js');
-var baseButton = require('./base-button-BvWcXXIH.js');
+var index = require('./index-BKQkUbyE.js');
+var baseButton = require('./base-button-C-1izOSS.js');
 
 /*
  * SPDX-FileCopyrightText: 2023 Siemens AG
@@ -12,7 +12,7 @@ var baseButton = require('./base-button-BvWcXXIH.js');
  * LICENSE file in the root directory of this source tree.
  */
 function BaseIconButton(props) {
-    return index.h(baseButton.BaseButton, Object.assign({}, props, { type: "button" }));
+    return index.h(baseButton.BaseButton, { ...props, type: "button" });
 }
 
 exports.BaseIconButton = BaseIconButton;

package/dist/cjs/component-CYtonfpw.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var focusUtilities = require('./focus-utilities-yx7wWjEO.js');
+var shadowDom = require('./shadow-dom-BG8VqeIu.js');
+
+function detectKeyboardMode(element) {
+    let keyboardMode = false;
+    const ref = document;
+    const onKeydown = (event) => {
+        const keyboardEvent = event;
+        if (!focusUtilities.FOCUS_KEYS.has(keyboardEvent.key)) {
+            return;
+        }
+        keyboardMode = true;
+        ref.dispatchEvent(new CustomEvent('keyboardmodechange', { detail: { keyboardMode } }));
+    };
+    const pointerDown = () => {
+        keyboardMode = false;
+        ref.dispatchEvent(new CustomEvent('keyboardmodechange', { detail: { keyboardMode } }));
+    };
+    ref.addEventListener('keydown', onKeydown);
+    ref.addEventListener('touchstart', pointerDown, {
+        passive: true,
+    });
+    ref.addEventListener('mousedown', pointerDown);
+    const destroy = () => {
+        ref.removeEventListener('keydown', onKeydown);
+        ref.removeEventListener('touchstart', pointerDown);
+        ref.removeEventListener('mousedown', pointerDown);
+    };
+    return { destroy, hasKeyboardMode: () => keyboardMode };
+}
+
+/*
+ * 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.
+ */
+let originalFocus = null;
+let globalKeyboardDetectionInitialized = false;
+let keyboardMode = null;
+function hasKeyboardMode() {
+    return keyboardMode?.hasKeyboardMode() ?? false;
+}
+let currentFocus = [];
+function removeVisibleFocus() {
+    currentFocus.forEach((el) => {
+        el.classList.remove(focusUtilities.IX_FOCUS_VISIBLE_ACTIVE);
+        el.ixFocusVisible = false;
+    });
+}
+class IxFocusVisibleChangeEvent extends CustomEvent {
+    static eventName = 'ixFocusVisibleChange';
+    constructor(detail) {
+        super(IxFocusVisibleChangeEvent.eventName, {
+            detail,
+            bubbles: true,
+            cancelable: true,
+        });
+    }
+}
+function updateFocusState(target) {
+    const composedPath = shadowDom.getComposedPath(target);
+    const focusableElements = composedPath.filter((el) => el.classList.contains(focusUtilities.IX_FOCUS_VISIBLE));
+    // Clear previous focus
+    removeVisibleFocus();
+    // Set new focus if keyboard mode is active
+    if (hasKeyboardMode()) {
+        focusableElements.forEach((el) => {
+            el.classList.add(focusUtilities.IX_FOCUS_VISIBLE_ACTIVE);
+            el.ixFocusVisible = true;
+        });
+        currentFocus = focusableElements;
+    }
+    else {
+        currentFocus = [];
+    }
+    document.dispatchEvent(new IxFocusVisibleChangeEvent({ currentFocus }));
+}
+function applyFocusPatch() {
+    if (typeof HTMLElement !== 'undefined' && !originalFocus) {
+        originalFocus = HTMLElement.prototype.focus;
+        HTMLElement.prototype.focus = function (options) {
+            originalFocus?.call(this, options);
+            updateFocusState(this);
+        };
+        document.addEventListener('focusin', (event) => {
+            const target = event.target;
+            if (target instanceof HTMLElement) {
+                updateFocusState(target);
+            }
+        }, true);
+        document.addEventListener('keyboardmodechange', (event) => {
+            const customEvent = event;
+            const isKeyboardMode = customEvent.detail.keyboardMode;
+            if (!isKeyboardMode) {
+                removeVisibleFocus();
+                return;
+            }
+        });
+        document.addEventListener('focusout', (event) => {
+            const target = event.target;
+            if (target instanceof HTMLElement) {
+                updateFocusState(target);
+            }
+        });
+    }
+}
+/**
+ * Mixin to add global focus visible handling to a component. Mixin will be used via base class IxComponent().
+ * Not necessary to use this mixin directly in components.
+ */
+const SetupMixin = (Base) => {
+    class FocusListenerMixin extends Base {
+        componentDidLoad() {
+            if (super.componentDidLoad) {
+                super.componentDidLoad();
+            }
+            if (!originalFocus) {
+                applyFocusPatch();
+            }
+            if (!globalKeyboardDetectionInitialized) {
+                globalKeyboardDetectionInitialized = true;
+                keyboardMode = detectKeyboardMode();
+            }
+        }
+        disconnectedCallback() {
+            if (super.disconnectedCallback) {
+                super.disconnectedCallback();
+            }
+        }
+    }
+    return FocusListenerMixin;
+};
+
+const DefaultMixins = [SetupMixin];
+
+exports.DefaultMixins = DefaultMixins;
+exports.hasKeyboardMode = hasKeyboardMode;
+exports.removeVisibleFocus = removeVisibleFocus;

package/dist/cjs/{context-CmNuiaNz.js → context-DqdXbKw_.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var typedEvent = require('./typed-event-DxWATHPL.js');
+var typedEvent = require('./typed-event-Bw4IfJC0.js');
 
 /*
  * SPDX-FileCopyrightText: 2024 Siemens AG
@@ -30,6 +30,9 @@ function createContext(name, initialValue) {
  * function to the callback which requesters can invoke to indicate they no longer wish to receive these updates.
  */
 class ContextEvent extends Event {
+    context;
+    callback;
+    subscribe;
     constructor(context, callback, subscribe) {
         super('context-request', { bubbles: true, composed: true });
         this.context = context;
@@ -57,7 +60,7 @@ function useContextProvider(hostElement, context, contextPayload) {
     const requests = new Set();
     hostElement.addEventListener('context-request', (event) => {
         const requestContextEvent = event;
-        if ((requestContextEvent === null || requestContextEvent === void 0 ? void 0 : requestContextEvent.context.name) !== context.name) {
+        if (requestContextEvent?.context.name !== context.name) {
             return;
         }
         requestContextEvent.stopPropagation();

package/dist/cjs/{dropdown-controller-BLOjtc6w.js → dropdown-controller-DeBeUVhj.js}

@@ -14,11 +14,9 @@ function hasDropdownItemWrapperImplemented(item) {
         typeof item.getDropdownItemElement === 'function');
 }
 class DropdownController {
-    constructor() {
-        this.dropdowns = new Map();
-        this.submenuIds = {};
-        this.isWindowListenerActive = false;
-    }
+    dropdowns = new Map();
+    submenuIds = {};
+    isWindowListenerActive = false;
     connected(dropdown) {
         if (!this.isWindowListenerActive) {
             this.addOverlayListeners();
@@ -54,8 +52,7 @@ class DropdownController {
         });
     }
     present(dropdown) {
-        var _a;
-        if (!dropdown.isPresent() && ((_a = dropdown.willPresent) === null || _a === void 0 ? void 0 : _a.call(dropdown))) {
+        if (!dropdown.isPresent() && dropdown.willPresent?.()) {
             this.submenuIds[dropdown.getId()] = dropdown.getAssignedSubmenuIds();
             dropdown.present();
         }
@@ -70,8 +67,7 @@ class DropdownController {
         }
     }
     dismiss(dropdown) {
-        var _a;
-        if (dropdown.isPresent() && ((_a = dropdown.willDismiss) === null || _a === void 0 ? void 0 : _a.call(dropdown))) {
+        if (dropdown.isPresent() && dropdown.willDismiss?.()) {
             this.dismissChildren(dropdown.getId());
             dropdown.dismiss();
             delete this.submenuIds[dropdown.getId()];
@@ -121,6 +117,13 @@ class DropdownController {
         }
         return;
     }
+    getParentDropdownId(dropdownId) {
+        for (const ruleKey of Object.keys(this.submenuIds)) {
+            if (this.submenuIds[ruleKey].includes(dropdownId)) {
+                return ruleKey;
+            }
+        }
+    }
     pathIncludesDropdown(eventTargets) {
         return !!eventTargets.find((element) => element.tagName === 'IX-DROPDOWN');
     }

package/dist/cjs/{floating-ui.dom-CMzYsRR7.js → find-element-DPxOAdgO.js}

@@ -1782,11 +1782,112 @@ const computePosition = (reference, floating, options) => {
   });
 };
 
+/*
+ * 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.
+ */
+/**
+ * Will try to resolve the selector in the light dom, shadow dom or slot
+ * @param selector The selector to resolve
+ * @param hostElement The element to start the search from
+ * @returns Promise with the resolved elements or undefined if not found
+ */
+async function resolveSelector(selector, hostElement) {
+    const elements = Array.from(document.querySelectorAll(selector));
+    if (elements.length > 0) {
+        return Promise.resolve(elements);
+    }
+    if (hostElement === undefined) {
+        return Promise.resolve(undefined);
+    }
+    const shadowRoot = getRootFor(hostElement);
+    if (shadowRoot === undefined || !(shadowRoot instanceof ShadowRoot)) {
+        return Promise.resolve(undefined);
+    }
+    const elementsInShadowRoot = Array.from(shadowRoot.querySelectorAll(selector));
+    const elementsInHost = Array.from(shadowRoot.host.querySelectorAll(selector));
+    const elementsInComponent = [
+        ...elementsInHost,
+        ...elementsInShadowRoot,
+    ];
+    if (elementsInComponent.length > 0) {
+        return Promise.resolve(elementsInComponent);
+    }
+    return Promise.resolve(undefined);
+}
+/**
+ * Walk up the DOM to find the nearest shadow root
+ * @param element The element to get the root for
+ * @param parent This will determine how far up the DOM to travel to find the root
+ * @returns The root element
+ */
+function getRootFor(element, parent = document.body) {
+    if (!element.parentElement && !element.parentNode) {
+        return undefined;
+    }
+    if (element.parentNode instanceof ShadowRoot) {
+        return element.parentNode;
+    }
+    let currentNode = element.parentElement;
+    while (currentNode) {
+        if (currentNode.shadowRoot) {
+            return currentNode.shadowRoot;
+        }
+        else if (currentNode.parentNode instanceof ShadowRoot) {
+            return currentNode.parentNode;
+        }
+        currentNode = currentNode.parentElement;
+    }
+    return parent;
+}
+function waitForSelector(selector, node = document, hostElement) {
+    return new Promise((resolve) => {
+        const waitForElements = () => {
+            resolveSelector(selector, hostElement).then((elements) => {
+                if (elements && elements.length > 0) {
+                    resolve(elements[0]);
+                    observer?.disconnect();
+                }
+            });
+        };
+        waitForElements();
+        const observer = new MutationObserver(() => {
+            waitForElements();
+        });
+        observer.observe(node.body, {
+            childList: true,
+            subtree: true,
+        });
+    });
+}
+/**
+ * Find an element by ID or reference
+ * @param element The element to find
+ * @param hostElement The element to start the search from
+ * @returns A promise that will resolve to the element
+ */
+function findElement(element, hostElement) {
+    if (element instanceof Promise) {
+        return element;
+    }
+    if (typeof element === 'object') {
+        return Promise.resolve(element);
+    }
+    const selector = `#${element}`;
+    return waitForSelector(selector, document, hostElement);
+}
+
 exports.arrow = arrow;
 exports.autoUpdate = autoUpdate;
 exports.computePosition = computePosition;
+exports.findElement = findElement;
 exports.flip = flip;
 exports.hide = hide;
 exports.inline = inline;
 exports.offset = offset;
+exports.resolveSelector = resolveSelector;
 exports.shift = shift;

package/dist/cjs/focus-proxy-BCuVbpDb.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var index = require('./index-BKQkUbyE.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.
+ */
+/**
+ * Add a focus proxy element to the DOM to allow for better keyboard navigation and accessibility.
+ *
+ * Important: Also import the focus proxy mixin in the host component's scss file to ensure the proxy is visually hidden but still accessible to screen readers and keyboard navigation.
+ */
+const FocusProxy = (props) => {
+    return (index.h("ul", { class: "proxy-list", role: "listbox", id: `${props.hostId}-${PROXY_LIST_ID_SUFFIX}`, ...props.otherProps }));
+};
+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;
+        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;
+            if (modifyProxyElement) {
+                modifyProxyElement(item, li);
+            }
+            item.ariaHidden = 'true';
+            proxyListElement.appendChild(li);
+        });
+    }
+};
+
+exports.FocusProxy = FocusProxy;
+exports.PROXY_LISTITEM_ID_SUFFIX = PROXY_LISTITEM_ID_SUFFIX;
+exports.PROXY_LIST_ID_SUFFIX = PROXY_LIST_ID_SUFFIX;
+exports.updateFocusProxyList = updateFocusProxyList;

package/dist/cjs/focus-trap-_cyPFvFq.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var makeRef = require('./make-ref-CHsa3FY7.js');
+var focusUtilities = require('./focus-utilities-yx7wWjEO.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 addFocusTrap = async (element, options) => {
+    let ref = element;
+    if (options?.targetElement) {
+        if (options.targetElement instanceof HTMLElement) {
+            ref = options.targetElement;
+        }
+        else if (makeRef.isMakeRef(options.targetElement)) {
+            ref = await options.targetElement.waitForCurrent();
+        }
+    }
+    const onKeydown = (event) => {
+        const keyboardEvent = event;
+        if (keyboardEvent.key === 'Tab') {
+            const focusTrapRoot = options?.trapFocusInShadowDom
+                ? ref.shadowRoot
+                : ref;
+            const focusableElements = focusUtilities.queryElements(focusTrapRoot, `${focusUtilities.focusableQueryString}, [${TRAP_FOCUS_INCLUDE_ATTRIBUTE}]`);
+            for (let index = 0; index < focusableElements.length; index++) {
+                const includeElement = focusableElements[index];
+                if (!includeElement.hasAttribute(TRAP_FOCUS_INCLUDE_ATTRIBUTE)) {
+                    continue;
+                }
+                const includedFocusableElements = focusUtilities.queryElements(options?.trapFocusInShadowDom && includeElement.shadowRoot
+                    ? includeElement.shadowRoot
+                    : includeElement, focusUtilities.focusableQueryString).filter((element) => element !== includeElement);
+                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;
+            }
+            if (focusableElements.length === 0) {
+                return;
+            }
+            if (options?.excludeElements) {
+                focusableElements.forEach((element) => {
+                    if (element.hasAttribute(TRAP_FOCUS_EXCLUDE_ATTRIBUTE)) {
+                        const index = focusableElements.indexOf(element);
+                        if (index !== -1) {
+                            focusableElements.splice(index, 1);
+                        }
+                    }
+                });
+            }
+            if (focusableElements.length === 0) {
+                return;
+            }
+            const firstElement = focusableElements[0];
+            const lastElement = focusableElements[focusableElements.length - 1];
+            let activeElement = document.activeElement;
+            if (ref instanceof HTMLElement && ref.shadowRoot) {
+                activeElement = ref.shadowRoot.activeElement || activeElement;
+            }
+            if (activeElement?.hasAttribute(TRAP_FOCUS_INCLUDE_ATTRIBUTE) &&
+                activeElement?.shadowRoot &&
+                activeElement.shadowRoot.activeElement) {
+                activeElement = activeElement.shadowRoot.activeElement;
+            }
+            if (keyboardEvent.shiftKey) {
+                if (activeElement === firstElement) {
+                    keyboardEvent.preventDefault();
+                    lastElement.focus();
+                }
+            }
+            else {
+                if (activeElement === lastElement) {
+                    keyboardEvent.preventDefault();
+                    firstElement.focus();
+                }
+            }
+            event.stopImmediatePropagation();
+        }
+    };
+    ref.addEventListener('keydown', onKeydown);
+    const destroy = () => {
+        ref.removeEventListener('keydown', onKeydown);
+    };
+    return {
+        destroy,
+    };
+};
+
+exports.TRAP_FOCUS_EXCLUDE_ATTRIBUTE = TRAP_FOCUS_EXCLUDE_ATTRIBUTE;
+exports.TRAP_FOCUS_INCLUDE_ATTRIBUTE = TRAP_FOCUS_INCLUDE_ATTRIBUTE;
+exports.addFocusTrap = addFocusTrap;

package/dist/cjs/focus-utilities-yx7wWjEO.js

@@ -0,0 +1,119 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2025 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.
+ */
+/**
+ * Originally based on Ionic's focus-visible utility.
+ * Fork of https://github.com/ionic-team/ionic-framework/blob/c37e2a5d9e765cf48d768061c9d453a13b187e13/core/src/utils/focus-visible.ts
+ */
+const IX_FOCUS_VISIBLE_ACTIVE = 'ix-focused';
+const IX_FOCUS_VISIBLE = 'ix-focusable';
+const FOCUS_KEYS = new Set([
+    'Tab',
+    'ArrowDown',
+    'Space',
+    'Escape',
+    ' ',
+    'Shift',
+    'Enter',
+    'ArrowLeft',
+    'ArrowRight',
+    'ArrowUp',
+    'Home',
+    'End',
+]);
+function queryElements(dropdownElement, query) {
+    if (!dropdownElement) {
+        return [];
+    }
+    let items = [];
+    // Collect items from slots if they exist
+    if (dropdownElement.querySelectorAll('slot').length > 0) {
+        const slotElements = Array.from(dropdownElement.querySelectorAll('slot'));
+        items = slotElements.flatMap((slot) => Array.from(slot.assignedElements({ flatten: true })).flatMap((el) => {
+            // Check if the assigned element itself matches the query
+            if (el?.matches(query)) {
+                return [el];
+            }
+            // Otherwise, query its children
+            return Array.from(el.querySelectorAll(query));
+        }));
+    }
+    items = [
+        ...items,
+        ...Array.from(dropdownElement.querySelectorAll(query)),
+    ];
+    return items;
+}
+function tryFocusElement(element, options) {
+    if (!(element instanceof HTMLElement)) {
+        return;
+    }
+    try {
+        element.focus(options);
+    }
+    catch { }
+}
+const focusFirstDescendant = (ref, fallbackElement, options) => {
+    if (options?.focusCheckedItem) {
+        const checkedQueryString = buildFocusableQueryString('[checked]');
+        const checkedElements = queryElements(ref, checkedQueryString);
+        if (checkedElements.length > 0) {
+            focusElementInContext(checkedElements[0], ref);
+            return;
+        }
+    }
+    const inputs = queryElements(ref, focusableQueryString);
+    const firstInput = inputs.length > 0 ? inputs[0] : null;
+    focusElementInContext(firstInput, ref);
+};
+const focusLastDescendant = (ref, fallbackElement) => {
+    const inputs = queryElements(ref, focusableQueryString);
+    const lastInput = inputs.length > 0 ? inputs[inputs.length - 1] : null;
+    focusElementInContext(lastInput, ref);
+};
+const focusElementInContext = (hostToFocus, fallbackElement) => {
+    let elementToFocus = hostToFocus;
+    const shadowRoot = hostToFocus?.shadowRoot;
+    if (shadowRoot) {
+        elementToFocus =
+            shadowRoot.querySelector(focusableQueryString) ||
+                hostToFocus;
+    }
+    if (elementToFocus) {
+        focusElement(elementToFocus);
+    }
+    else {
+        focusElement(fallbackElement);
+    }
+};
+const focusElement = (element, options) => {
+    if (!element) {
+        return;
+    }
+    element.focus(options);
+};
+const focusableBase = ':not([tabindex^="-"]):not([hidden]):not([disabled])';
+const customTags = ['ix-dropdown-item', 'ix-select-item'];
+const buildCustom = (additionalSelector) => customTags
+    .map((tag) => `${tag}${focusableBase}${additionalSelector}`)
+    .join(', ');
+const focusableQueryString = `[tabindex]${focusableBase}, ${buildCustom('')}`;
+const buildFocusableQueryString = (additionalSelector = '') => `[tabindex]${focusableBase}${additionalSelector}, ${buildCustom(additionalSelector)}`;
+
+exports.FOCUS_KEYS = FOCUS_KEYS;
+exports.IX_FOCUS_VISIBLE = IX_FOCUS_VISIBLE;
+exports.IX_FOCUS_VISIBLE_ACTIVE = IX_FOCUS_VISIBLE_ACTIVE;
+exports.focusElement = focusElement;
+exports.focusElementInContext = focusElementInContext;
+exports.focusFirstDescendant = focusFirstDescendant;
+exports.focusLastDescendant = focusLastDescendant;
+exports.focusableQueryString = focusableQueryString;
+exports.queryElements = queryElements;
+exports.tryFocusElement = tryFocusElement;