@gravionlabs/helix-core 22.0.0

package/fesm2022/gravionlabs-helix-core-uix-utils.mjs

@@ -0,0 +1,1839 @@
+function cn(...args) {
+    if (args) {
+        let classes = [];
+        for (let i = 0; i < args.length; i++) {
+            const className = args[i];
+            if (!className) {
+                continue;
+            }
+            const type = typeof className;
+            if (type === 'string' || type === 'number') {
+                classes.push(className);
+            }
+            else if (type === 'object') {
+                const _classes = Array.isArray(className) ? [cn(...className)] : Object.entries(className).map(([key, value]) => (value ? key : undefined));
+                classes = _classes.length ? classes.concat(_classes.filter((c) => !!c)) : classes;
+            }
+        }
+        return classes.join(' ').trim();
+    }
+    return undefined;
+}
+/**
+ * @deprecated Use `cn` instead.
+ * @param args
+ * @returns
+ */
+function classNames(...args) {
+    return cn(...args);
+}
+
+function hasClass(element, className) {
+    if (element) {
+        if (element.classList)
+            return element.classList.contains(className);
+        else
+            return new RegExp('(^| )' + className + '( |$)', 'gi').test(element.className);
+    }
+    return false;
+}
+
+function addClass(element, className) {
+    if (element && className) {
+        const fn = (_className) => {
+            if (!hasClass(element, _className)) {
+                if (element.classList)
+                    element.classList.add(_className);
+                else
+                    element.className += ' ' + _className;
+            }
+        };
+        [className]
+            .flat()
+            .filter(Boolean)
+            .forEach((_classNames) => _classNames.split(' ').forEach(fn));
+    }
+}
+
+function calculateBodyScrollbarWidth() {
+    return window.innerWidth - document.documentElement.offsetWidth;
+}
+
+function blockBodyScroll(option) {
+    if (typeof option === 'string') {
+        addClass(document.body, option || 'h-overflow-hidden');
+    }
+    else {
+        option?.variableName && document.body.style.setProperty(option.variableName, calculateBodyScrollbarWidth() + 'px');
+        addClass(document.body, option?.className || 'h-overflow-hidden');
+    }
+}
+
+function saveAs(file) {
+    if (file) {
+        const link = document.createElement('a');
+        if (link.download !== undefined) {
+            const { name, src } = file;
+            link.setAttribute('href', src);
+            link.setAttribute('download', name);
+            link.style.display = 'none';
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+            return true;
+        }
+    }
+    return false;
+}
+
+function exportCSV(csv, filename) {
+    const blob = new Blob([csv], {
+        type: 'application/csv;charset=utf-8;'
+    });
+    if (window.navigator.msSaveOrOpenBlob) {
+        navigator.msSaveOrOpenBlob(blob, filename + '.csv');
+    }
+    else {
+        const isDownloaded = saveAs({ name: filename + '.csv', src: URL.createObjectURL(blob) });
+        if (!isDownloaded) {
+            csv = 'data:text/csv;charset=utf-8,' + csv;
+            window.open(encodeURI(csv));
+        }
+    }
+}
+
+function removeClass(element, className) {
+    if (element && className) {
+        const fn = (_className) => {
+            if (element.classList)
+                element.classList.remove(_className);
+            else
+                element.className = element.className.replace(new RegExp('(^|\\b)' + _className.split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
+        };
+        [className]
+            .flat()
+            .filter(Boolean)
+            .forEach((_classNames) => _classNames.split(' ').forEach(fn));
+    }
+}
+
+function unblockBodyScroll(option) {
+    if (typeof option === 'string') {
+        removeClass(document.body, option || 'h-overflow-hidden');
+    }
+    else {
+        if (option?.variableName)
+            document.body.style.removeProperty(option.variableName);
+        removeClass(document.body, option?.className || 'h-overflow-hidden');
+    }
+}
+
+function getCSSVariableByRegex(variableRegex) {
+    for (const sheet of document?.styleSheets) {
+        try {
+            for (const rule of sheet?.cssRules) {
+                for (const property of rule?.style) {
+                    if (variableRegex.test(property)) {
+                        return { name: property, value: rule.style.getPropertyValue(property).trim() };
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+
+function getHiddenElementDimensions(element) {
+    const dimensions = { width: 0, height: 0 };
+    if (element) {
+        const [visibility, display] = [element.style.visibility, element.style.display];
+        const rect = element.getBoundingClientRect();
+        // Temporarily hide the element to get its dimensions
+        element.style.visibility = 'hidden';
+        element.style.display = 'block';
+        dimensions.width = rect.width || element.offsetWidth;
+        dimensions.height = rect.height || element.offsetHeight;
+        element.style.display = display;
+        element.style.visibility = visibility;
+    }
+    return dimensions;
+}
+
+function getViewport() {
+    const win = window, d = document, e = d.documentElement, g = d.getElementsByTagName('body')[0], w = win.innerWidth || e.clientWidth || g.clientWidth, h = win.innerHeight || e.clientHeight || g.clientHeight;
+    return { width: w, height: h };
+}
+
+function getScrollLeft(element) {
+    // for RTL scrollLeft should be negative
+    return element ? Math.abs(element.scrollLeft) : 0;
+}
+
+function getWindowScrollLeft() {
+    const doc = document.documentElement;
+    return (window.pageXOffset || getScrollLeft(doc)) - (doc.clientLeft || 0);
+}
+
+function getWindowScrollTop() {
+    const doc = document.documentElement;
+    return (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);
+}
+
+function isRTL(element) {
+    return element ? getComputedStyle(element).direction === 'rtl' : false;
+}
+
+function absolutePosition(element, target, gutter = true) {
+    if (element) {
+        const elementDimensions = element.offsetParent ? { width: element.offsetWidth, height: element.offsetHeight } : getHiddenElementDimensions(element);
+        const elementOuterHeight = elementDimensions.height;
+        const elementOuterWidth = elementDimensions.width;
+        const targetOuterHeight = target.offsetHeight;
+        const targetOuterWidth = target.offsetWidth;
+        const targetOffset = target.getBoundingClientRect();
+        const windowScrollTop = getWindowScrollTop();
+        const windowScrollLeft = getWindowScrollLeft();
+        const viewport = getViewport();
+        let top, left, origin = 'top';
+        if (targetOffset.top + targetOuterHeight + elementOuterHeight > viewport.height) {
+            top = targetOffset.top + windowScrollTop - elementOuterHeight;
+            origin = 'bottom';
+            if (top < 0) {
+                top = windowScrollTop;
+            }
+        }
+        else {
+            top = targetOuterHeight + targetOffset.top + windowScrollTop;
+        }
+        if (targetOffset.left + elementOuterWidth > viewport.width)
+            left = Math.max(0, targetOffset.left + windowScrollLeft + targetOuterWidth - elementOuterWidth);
+        else
+            left = targetOffset.left + windowScrollLeft;
+        if (isRTL(element)) {
+            element.style.insetInlineEnd = left + 'px';
+        }
+        else {
+            element.style.insetInlineStart = left + 'px';
+        }
+        element.style.top = top + 'px';
+        element.style.transformOrigin = origin;
+        if (gutter)
+            element.style.marginTop = origin === 'bottom' ? `calc(${getCSSVariableByRegex(/-anchor-gutter$/)?.value ?? '2px'} * -1)` : (getCSSVariableByRegex(/-anchor-gutter$/)?.value ?? '');
+    }
+}
+
+function addStyle(element, style) {
+    if (element) {
+        if (typeof style === 'string') {
+            element.style.cssText = style;
+        }
+        else {
+            Object.entries(style || {}).forEach(([key, value]) => (element.style[key] = value));
+        }
+    }
+}
+
+function getOuterWidth(element, margin) {
+    if (element instanceof HTMLElement) {
+        let width = element.offsetWidth;
+        if (margin) {
+            const style = getComputedStyle(element);
+            width += parseFloat(style.marginLeft) + parseFloat(style.marginRight);
+        }
+        return width;
+    }
+    return 0;
+}
+
+function relativePosition(element, target, gutter = true, fixedOrigin = undefined) {
+    if (element) {
+        const elementDimensions = element.offsetParent ? { width: element.offsetWidth, height: element.offsetHeight } : getHiddenElementDimensions(element);
+        const targetHeight = target.offsetHeight;
+        const targetOffset = target.getBoundingClientRect();
+        const viewport = getViewport();
+        let top, left, origin = fixedOrigin ?? 'top';
+        if (!fixedOrigin && targetOffset.top + targetHeight + elementDimensions.height > viewport.height) {
+            top = -1 * elementDimensions.height;
+            origin = 'bottom';
+            if (targetOffset.top + top < 0) {
+                top = -1 * targetOffset.top;
+            }
+        }
+        else {
+            top = targetHeight;
+        }
+        if (elementDimensions.width > viewport.width) {
+            // element wider then viewport and cannot fit on screen (align at left side of viewport)
+            left = targetOffset.left * -1;
+        }
+        else if (targetOffset.left + elementDimensions.width > viewport.width) {
+            // element wider then viewport but can be fit on screen (align at right side of viewport)
+            left = (targetOffset.left + elementDimensions.width - viewport.width) * -1;
+        }
+        else {
+            // element fits on screen (align with target)
+            left = 0;
+        }
+        element.style.top = top + 'px';
+        element.style.insetInlineStart = left + 'px';
+        element.style.transformOrigin = origin;
+        if (gutter) {
+            const gutterValue = getCSSVariableByRegex(/-anchor-gutter$/)?.value;
+            element.style.marginTop = origin === 'bottom' ? `calc(${gutterValue ?? '2px'} * -1)` : (gutterValue ?? '');
+        }
+    }
+}
+
+function alignOverlay(overlay, target, appendTo, calculateMinWidth = true) {
+    if (overlay && target) {
+        if (appendTo === 'self') {
+            relativePosition(overlay, target);
+        }
+        else {
+            if (calculateMinWidth)
+                overlay.style.minWidth = getOuterWidth(target) + 'px';
+            absolutePosition(overlay, target);
+        }
+    }
+}
+
+function getParentNode(element) {
+    if (element) {
+        let parent = element.parentNode;
+        if (parent && parent instanceof ShadowRoot && parent.host) {
+            parent = parent.host;
+        }
+        return parent;
+    }
+    return null;
+}
+
+function isExist(element) {
+    return !!(element !== null && typeof element !== 'undefined' && element.nodeName && getParentNode(element));
+}
+
+function isElement(element) {
+    return typeof Element !== 'undefined' ? element instanceof Element : element !== null && typeof element === 'object' && element.nodeType === 1 && typeof element.nodeName === 'string';
+}
+
+/**
+ * Ported from @primeuix/utils 0.7.2 (main was 0.6.4 at vendor time): adds `value` (signal-style
+ * refs) and recursive `elementRef` unwrapping on top of the 0.6.4 current/el handling.
+ */
+function toElement(element) {
+    if (isElement(element)) {
+        return element;
+    }
+    if (!element || typeof element !== 'object') {
+        return undefined;
+    }
+    let target = element;
+    if (Object.hasOwn(element, 'current')) {
+        // For React
+        target = toElement(element.current) ?? element.current;
+    }
+    else if (Object.hasOwn(element, 'value')) {
+        // For Angular signals / Vue refs
+        target = element.value;
+    }
+    else if (Object.hasOwn(element, 'nativeElement')) {
+        // For Angular ElementRef
+        target = element.nativeElement;
+    }
+    else if (Object.hasOwn(element, 'el')) {
+        const el = element.el;
+        if (el && typeof el === 'object' && Object.hasOwn(el, 'nativeElement')) {
+            // For Angular
+            target = el.nativeElement;
+        }
+        else {
+            // For Vue
+            target = element.el;
+        }
+    }
+    else if (Object.hasOwn(element, 'elementRef')) {
+        return toElement(element.elementRef);
+    }
+    return isElement(target) ? target : undefined;
+}
+
+function getTargetElement(target, currentElement) {
+    if (!target)
+        return undefined;
+    switch (target) {
+        case 'document':
+            return document;
+        case 'window':
+            return window;
+        case 'body':
+            return document.body;
+        case '@next':
+            return currentElement?.nextElementSibling;
+        case '@prev':
+            return currentElement?.previousElementSibling;
+        case '@first':
+            return currentElement?.firstElementChild;
+        case '@last':
+            return currentElement?.lastElementChild;
+        case '@child':
+            return currentElement?.children?.[0];
+        case '@parent':
+            return currentElement?.parentElement;
+        case '@grandparent':
+            return currentElement?.parentElement?.parentElement;
+        default: {
+            if (typeof target === 'string') {
+                // child selector
+                const match = target.match(/^@child\[(\d+)]/);
+                if (match) {
+                    return currentElement?.children?.[parseInt(match[1], 10)] || null;
+                }
+                return document.querySelector(target) || null;
+            }
+            const isFunction = (value) => typeof value === 'function' && 'call' in value && 'apply' in value;
+            const computedTarget = isFunction(target) ? target() : target;
+            const element = toElement(computedTarget);
+            return isExist(element) ? element : computedTarget?.nodeType === 9 ? computedTarget : undefined;
+        }
+    }
+}
+
+function appendChild(element, child) {
+    const target = getTargetElement(element, child);
+    if (target)
+        target.appendChild(child);
+    else
+        throw new Error('Cannot append ' + child + ' to ' + element);
+}
+
+let calculatedScrollbarHeight = undefined;
+function calculateScrollbarHeight(element) {
+    if (element) {
+        const style = getComputedStyle(element);
+        return element.offsetHeight - element.clientHeight - parseFloat(style.borderTopWidth) - parseFloat(style.borderBottomWidth);
+    }
+    else {
+        if (calculatedScrollbarHeight != null)
+            return calculatedScrollbarHeight;
+        const scrollDiv = document.createElement('div');
+        addStyle(scrollDiv, {
+            width: '100px',
+            height: '100px',
+            overflow: 'scroll',
+            position: 'absolute',
+            top: '-9999px'
+        });
+        document.body.appendChild(scrollDiv);
+        const scrollbarHeight = scrollDiv.offsetHeight - scrollDiv.clientHeight;
+        document.body.removeChild(scrollDiv);
+        calculatedScrollbarHeight = scrollbarHeight;
+        return scrollbarHeight;
+    }
+}
+
+let calculatedScrollbarWidth = undefined;
+function calculateScrollbarWidth(element) {
+    if (element) {
+        const style = getComputedStyle(element);
+        return element.offsetWidth - element.clientWidth - parseFloat(style.borderLeftWidth) - parseFloat(style.borderRightWidth);
+    }
+    else {
+        if (calculatedScrollbarWidth != null)
+            return calculatedScrollbarWidth;
+        const scrollDiv = document.createElement('div');
+        addStyle(scrollDiv, {
+            width: '100px',
+            height: '100px',
+            overflow: 'scroll',
+            position: 'absolute',
+            top: '-9999px'
+        });
+        document.body.appendChild(scrollDiv);
+        const scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
+        document.body.removeChild(scrollDiv);
+        calculatedScrollbarWidth = scrollbarWidth;
+        return scrollbarWidth;
+    }
+}
+
+function clearSelection() {
+    if (window.getSelection) {
+        const selection = window.getSelection() || {};
+        if (selection.empty) {
+            selection.empty();
+        }
+        else if (selection.removeAllRanges && selection.rangeCount > 0 && selection.getRangeAt(0).getClientRects().length > 0) {
+            selection.removeAllRanges();
+        }
+    }
+}
+
+function setAttributes(element, attributes = {}) {
+    if (isElement(element)) {
+        const computedStyles = (rule, value) => {
+            const styles = element?.$attrs?.[rule] ? [element?.$attrs?.[rule]] : [];
+            return [value].flat().reduce((cv, v) => {
+                if (v !== null && v !== undefined) {
+                    const type = typeof v;
+                    if (type === 'string' || type === 'number') {
+                        cv.push(v);
+                    }
+                    else if (type === 'object') {
+                        const _cv = Array.isArray(v) ? computedStyles(rule, v) : Object.entries(v).map(([_k, _v]) => (rule === 'style' && (!!_v || _v === 0) ? `${_k.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()}:${_v}` : _v ? _k : undefined));
+                        cv = _cv.length ? cv.concat(_cv.filter((c) => !!c)) : cv;
+                    }
+                }
+                return cv;
+            }, styles);
+        };
+        Object.entries(attributes).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                const matchedEvent = key.match(/^on(.+)/);
+                if (matchedEvent) {
+                    element.addEventListener(matchedEvent[1].toLowerCase(), value);
+                }
+                else if (key === 'h-bind' || key === 'pBind') {
+                    setAttributes(element, value);
+                }
+                else {
+                    value = key === 'class' ? [...new Set(computedStyles('class', value))].join(' ').trim() : key === 'style' ? computedStyles('style', value).join(';').trim() : value;
+                    (element.$attrs = element.$attrs || {}) && (element.$attrs[key] = value);
+                    element.setAttribute(key, value);
+                }
+            }
+        });
+    }
+}
+
+function createElement(type, attributes = {}, ...children) {
+    if (type) {
+        const element = document.createElement(type);
+        setAttributes(element, attributes);
+        element.append(...children);
+        return element;
+    }
+    return undefined;
+}
+
+function createStyleMarkup(css, attributes = {}) {
+    return css ? `<style${Object.entries(attributes).reduce((s, [k, v]) => s + ` ${k}="${v}"`, '')}>${css}</style>` : '';
+}
+
+/**
+ * @deprecated Use `createStyleMarkup` instead.
+ */
+function createStyleAsString(css, options = {}) {
+    return createStyleMarkup(css, options);
+}
+
+function createStyleElement(css, attributes = {}, container) {
+    const element = createElement('style', attributes, css);
+    container?.appendChild(element);
+    return element;
+}
+
+/**
+ * @deprecated Use `createStyleElement` instead.
+ */
+function createStyleTag(attributes = {}, container) {
+    return createStyleElement('', attributes, container || document.head);
+}
+
+function fadeIn(element, duration) {
+    if (element) {
+        element.style.opacity = '0';
+        let last = +new Date();
+        let opacity = '0';
+        const tick = function () {
+            opacity = `${+element.style.opacity + (new Date().getTime() - last) / duration}`;
+            element.style.opacity = opacity;
+            last = +new Date();
+            if (+opacity < 1) {
+                if ('requestAnimationFrame' in window)
+                    requestAnimationFrame(tick);
+                else
+                    setTimeout(tick, 16);
+            }
+        };
+        tick();
+    }
+}
+
+function fadeOut(element, duration) {
+    if (element) {
+        let opacity = 1;
+        const interval = 50;
+        const gap = interval / duration;
+        const fading = setInterval(() => {
+            opacity -= gap;
+            if (opacity <= 0) {
+                opacity = 0;
+                clearInterval(fading);
+            }
+            element.style.opacity = opacity.toString();
+        }, interval);
+    }
+}
+
+function find(element, selector) {
+    return isElement(element) ? Array.from(element.querySelectorAll(selector)) : [];
+}
+
+function findSingle(element, selector) {
+    return isElement(element) ? (element.matches(selector) ? element : element.querySelector(selector)) : null;
+}
+
+function focus(element, options) {
+    if (element && document.activeElement !== element)
+        element.focus(options);
+}
+
+function getAttribute(element, name) {
+    if (isElement(element)) {
+        const value = element.getAttribute(name);
+        if (!isNaN(value)) {
+            return +value;
+        }
+        if (value === 'true' || value === 'false') {
+            return value === 'true';
+        }
+        return value;
+    }
+    return undefined;
+}
+
+function resolveUserAgent() {
+    const ua = navigator.userAgent.toLowerCase();
+    const match = /(chrome)[ ]([\w.]+)/.exec(ua) || /(webkit)[ ]([\w.]+)/.exec(ua) || /(opera)(?:.*version|)[ ]([\w.]+)/.exec(ua) || /(msie) ([\w.]+)/.exec(ua) || (ua.indexOf('compatible') < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua)) || [];
+    return {
+        browser: match[1] || '',
+        version: match[2] || '0'
+    };
+}
+
+let browser = null;
+function getBrowser() {
+    if (!browser) {
+        browser = {};
+        const matched = resolveUserAgent();
+        if (matched.browser) {
+            browser[matched.browser] = true;
+            browser['version'] = matched.version;
+        }
+        if (browser['chrome']) {
+            browser['webkit'] = true;
+        }
+        else if (browser['webkit']) {
+            browser['safari'] = true;
+        }
+    }
+    return browser;
+}
+
+function getBrowserLanguage() {
+    return (navigator.languages && navigator.languages.length && navigator.languages[0]) || navigator.language || 'en';
+}
+
+function getCSSProperty(element, property, inline) {
+    if (element && property) {
+        return inline ? element?.style?.getPropertyValue(property) : getComputedStyle(element).getPropertyValue(property);
+    }
+    return null;
+}
+
+/**
+ * Ported from @primeuix/utils 0.7.2 (new in 0.7.x; not present in main's 0.6.4 at vendor time).
+ */
+function isCssSupported(property, value) {
+    if (typeof CSS === 'undefined' || !CSS.supports) {
+        return false;
+    }
+    if (value !== undefined) {
+        const cssProperty = property.toString().replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+        return CSS.supports(cssProperty, value);
+    }
+    return CSS.supports(property.toString());
+}
+
+function getCursorOffset(element, prevText, nextText, currentText) {
+    if (element) {
+        const style = getComputedStyle(element);
+        const ghostDiv = document.createElement('div');
+        ghostDiv.style.position = 'absolute';
+        ghostDiv.style.top = '0px';
+        ghostDiv.style.left = '0px';
+        ghostDiv.style.visibility = 'hidden';
+        ghostDiv.style.pointerEvents = 'none';
+        ghostDiv.style.overflow = style.overflow;
+        ghostDiv.style.width = style.width;
+        ghostDiv.style.height = style.height;
+        ghostDiv.style.padding = style.padding;
+        ghostDiv.style.border = style.border;
+        ghostDiv.style.overflowWrap = style.overflowWrap;
+        ghostDiv.style.whiteSpace = style.whiteSpace;
+        ghostDiv.style.lineHeight = style.lineHeight;
+        ghostDiv.innerHTML = prevText.replace(/\r\n|\r|\n/g, '<br />');
+        const ghostSpan = document.createElement('span');
+        ghostSpan.textContent = currentText;
+        ghostDiv.appendChild(ghostSpan);
+        const text = document.createTextNode(nextText);
+        ghostDiv.appendChild(text);
+        document.body.appendChild(ghostDiv);
+        const { offsetLeft, offsetTop, clientHeight } = ghostSpan;
+        document.body.removeChild(ghostDiv);
+        return {
+            left: Math.abs(offsetLeft - element.scrollLeft),
+            top: Math.abs(offsetTop - element.scrollTop) + clientHeight
+        };
+    }
+    return {
+        top: 'auto',
+        left: 'auto'
+    };
+}
+
+function getFocusableElements(element, selector = '') {
+    const focusableElements = find(element, `button:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            [href]:not([tabindex = "-1"]):not([style*="display:none"]):not([hidden])${selector},
+            input:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            select:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            textarea:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            [tabIndex]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            [contenteditable]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector}`);
+    const visibleFocusableElements = [];
+    for (const focusableElement of focusableElements) {
+        if (getComputedStyle(focusableElement).display != 'none' && getComputedStyle(focusableElement).visibility != 'hidden')
+            visibleFocusableElements.push(focusableElement);
+    }
+    return visibleFocusableElements;
+}
+
+function getFirstFocusableElement(element, selector) {
+    const focusableElements = getFocusableElements(element, selector);
+    return focusableElements.length > 0 ? focusableElements[0] : null;
+}
+
+function getHeight(element) {
+    if (element) {
+        let height = element.offsetHeight;
+        const style = getComputedStyle(element);
+        height -= parseFloat(style.paddingTop) + parseFloat(style.paddingBottom) + parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
+        return height;
+    }
+    return 0;
+}
+
+function getHiddenElementOuterHeight(element) {
+    if (element) {
+        const [visibility, display] = [element.style.visibility, element.style.display];
+        // Temporarily hide the element to get its outer height
+        element.style.visibility = 'hidden';
+        element.style.display = 'block';
+        const elementHeight = element.offsetHeight;
+        element.style.display = display;
+        element.style.visibility = visibility;
+        return elementHeight;
+    }
+    return 0;
+}
+
+function getHiddenElementOuterWidth(element) {
+    if (element) {
+        const [visibility, display] = [element.style.visibility, element.style.display];
+        // Temporarily hide the element to get its outer width
+        element.style.visibility = 'hidden';
+        element.style.display = 'block';
+        const elementWidth = element.offsetWidth;
+        element.style.display = display;
+        element.style.visibility = visibility;
+        return elementWidth;
+    }
+    return 0;
+}
+
+function getIndex(element) {
+    if (element) {
+        const children = getParentNode(element)?.childNodes;
+        let num = 0;
+        if (children) {
+            for (let i = 0; i < children.length; i++) {
+                if (children[i] === element)
+                    return num;
+                if (children[i].nodeType === 1)
+                    num++;
+            }
+        }
+    }
+    return -1;
+}
+
+function getInnerWidth(element) {
+    if (element) {
+        let width = element.offsetWidth;
+        const style = getComputedStyle(element);
+        width -= parseFloat(style.borderLeft) + parseFloat(style.borderRight);
+        return width;
+    }
+    return 0;
+}
+
+function getLastFocusableElement(element, selector) {
+    const focusableElements = getFocusableElements(element, selector);
+    return focusableElements.length > 0 ? focusableElements[focusableElements.length - 1] : null;
+}
+
+function getNextElementSibling(element, selector) {
+    let nextElement = element.nextElementSibling;
+    while (nextElement) {
+        if (nextElement.matches(selector)) {
+            return nextElement;
+        }
+        else {
+            nextElement = nextElement.nextElementSibling;
+        }
+    }
+    return null;
+}
+
+function getNextFocusableElement(container, element, selector) {
+    const focusableElements = getFocusableElements(container, selector);
+    const index = focusableElements.length > 0 ? focusableElements.findIndex((el) => el === element) : -1;
+    const nextIndex = index > -1 && focusableElements.length >= index + 1 ? index + 1 : -1;
+    return nextIndex > -1 ? focusableElements[nextIndex] : null;
+}
+
+function getOffset(element) {
+    if (element) {
+        const rect = element.getBoundingClientRect();
+        return {
+            top: rect.top + (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
+            left: rect.left + (window.pageXOffset || getScrollLeft(document.documentElement) || getScrollLeft(document.body) || 0)
+        };
+    }
+    return {
+        top: 'auto',
+        left: 'auto'
+    };
+}
+
+function getOuterHeight(element, margin) {
+    if (element) {
+        let height = element.offsetHeight;
+        if (margin) {
+            const style = getComputedStyle(element);
+            height += parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+        }
+        return height;
+    }
+    return 0;
+}
+
+function getParents(element, parents = []) {
+    const parent = getParentNode(element);
+    return parent === null ? parents : getParents(parent, parents.concat([parent]));
+}
+
+function getPreviousElementSibling(element, selector) {
+    let previousElement = element.previousElementSibling;
+    while (previousElement) {
+        if (previousElement.matches(selector)) {
+            return previousElement;
+        }
+        else {
+            previousElement = previousElement.previousElementSibling;
+        }
+    }
+    return null;
+}
+
+function getScrollableParents(element) {
+    const scrollableParents = [];
+    if (element) {
+        const parents = getParents(element);
+        const overflowRegex = /(auto|scroll)/;
+        const overflowCheck = (node) => {
+            try {
+                const styleDeclaration = window['getComputedStyle'](node, null);
+                return overflowRegex.test(styleDeclaration.getPropertyValue('overflow')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowX')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowY'));
+            }
+            catch {
+                return false;
+            }
+        };
+        for (const parent of parents) {
+            const scrollSelectors = parent.nodeType === 1 && parent.dataset['scrollselectors'];
+            if (scrollSelectors) {
+                const selectors = scrollSelectors.split(',');
+                for (const selector of selectors) {
+                    const el = findSingle(parent, selector);
+                    if (el && overflowCheck(el)) {
+                        scrollableParents.push(el);
+                    }
+                }
+            }
+            if (parent.nodeType !== 9 && overflowCheck(parent)) {
+                scrollableParents.push(parent);
+            }
+        }
+    }
+    return scrollableParents;
+}
+
+function getSelection() {
+    if (window.getSelection)
+        return window.getSelection().toString();
+    else if (document.getSelection)
+        return document.getSelection().toString();
+    return undefined;
+}
+
+function getUserAgent() {
+    return navigator.userAgent;
+}
+
+function getWidth(element) {
+    if (element) {
+        let width = element.offsetWidth;
+        const style = getComputedStyle(element);
+        width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight) + parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
+        return width;
+    }
+    return 0;
+}
+
+function hasCSSAnimation(element) {
+    if (element) {
+        const style = getComputedStyle(element);
+        const animationDuration = parseFloat(style.getPropertyValue('animation-duration') || '0');
+        return animationDuration > 0;
+    }
+    return false;
+}
+
+function hasCSSTransition(element) {
+    if (element) {
+        const style = getComputedStyle(element);
+        const transitionDuration = parseFloat(style.getPropertyValue('transition-duration') || '0');
+        return transitionDuration > 0;
+    }
+    return false;
+}
+
+function invokeElementMethod(element, methodName, args) {
+    const method = element[methodName];
+    if (typeof method === 'function') {
+        method.apply(element, args ?? []);
+    }
+}
+
+function isAndroid() {
+    return /(android)/i.test(navigator.userAgent);
+}
+
+function isAttributeEquals(element, name, value) {
+    return isElement(element) ? getAttribute(element, name) === value : false;
+}
+
+function isAttributeNotEquals(element, name, value) {
+    return !isAttributeEquals(element, name, value);
+}
+
+function isClickable(element) {
+    if (element) {
+        const targetNode = element.nodeName;
+        const parentNode = element.parentElement && element.parentElement.nodeName;
+        return (targetNode === 'INPUT' ||
+            targetNode === 'TEXTAREA' ||
+            targetNode === 'BUTTON' ||
+            targetNode === 'A' ||
+            parentNode === 'INPUT' ||
+            parentNode === 'TEXTAREA' ||
+            parentNode === 'BUTTON' ||
+            parentNode === 'A' ||
+            !!element.closest('.h-button, .h-checkbox, .h-radiobutton') // @todo Add [data-pc-section="button"]
+        );
+    }
+    return false;
+}
+
+function isClient() {
+    return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+}
+
+function isFocusableElement(element, selector = '') {
+    return isElement(element)
+        ? element.matches(`button:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            [href][clientHeight][clientWidth]:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            input:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            select:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            textarea:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            [tabIndex]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
+            [contenteditable]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector}`)
+        : false;
+}
+
+function isVisible(element) {
+    return !!(element && element.offsetParent != null);
+}
+
+function isHidden(element) {
+    return !isVisible(element);
+}
+
+function isIOS() {
+    return /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window);
+}
+
+function isPrefersReducedMotion() {
+    if (typeof window === 'undefined' || !window.matchMedia) {
+        return false;
+    }
+    const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+    return mediaQuery.matches;
+}
+
+function isServer() {
+    return !isClient();
+}
+
+function isTouchDevice() {
+    return 'ontouchstart' in window || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
+}
+
+function nestedPosition(element, level) {
+    if (element) {
+        const parentItem = element.parentElement;
+        const elementOffset = getOffset(parentItem);
+        const viewport = getViewport();
+        const sublistWidth = element.offsetParent ? element.offsetWidth : getHiddenElementOuterWidth(element);
+        const sublistHeight = element.offsetParent ? element.offsetHeight : getHiddenElementOuterHeight(element);
+        const itemOuterWidth = getOuterWidth(parentItem?.children?.[0]);
+        const itemOuterHeight = getOuterHeight(parentItem?.children?.[0]);
+        let left = '';
+        let top = '';
+        if (elementOffset.left + itemOuterWidth + sublistWidth > viewport.width - calculateScrollbarWidth()) {
+            if (elementOffset.left < sublistWidth) {
+                // for too small screens
+                if (level % 2 === 1) {
+                    left = elementOffset.left ? '-' + elementOffset.left + 'px' : '100%';
+                }
+                else if (level % 2 === 0) {
+                    left = viewport.width - sublistWidth - calculateScrollbarWidth() + 'px';
+                }
+            }
+            else {
+                left = '-100%';
+            }
+        }
+        else {
+            left = '100%';
+        }
+        // getBoundingClientRect returns a top position from the current visible viewport area
+        if (element.getBoundingClientRect().top + itemOuterHeight + sublistHeight > viewport.height) {
+            top = `-${sublistHeight - itemOuterHeight}px`;
+        }
+        else {
+            top = '0px';
+        }
+        element.style.top = top;
+        element.style.insetInlineStart = left;
+    }
+}
+
+function nextFrame() {
+    return new Promise((resolve) => {
+        requestAnimationFrame(() => {
+            requestAnimationFrame(resolve);
+        });
+    });
+}
+
+function remove(element) {
+    if (element) {
+        if (!('remove' in Element.prototype))
+            element.parentNode?.removeChild(element);
+        else
+            element.remove();
+    }
+}
+
+function removeChild(element, child) {
+    const target = toElement(element);
+    if (target)
+        target.removeChild(child);
+    else
+        throw new Error('Cannot remove ' + child + ' from ' + element);
+}
+
+function removeStyleTag(element) {
+    if (isExist(element)) {
+        try {
+            element.parentNode?.removeChild(element);
+        }
+        catch {
+            // style element may have already been removed in a fast refresh
+        }
+        return null;
+    }
+    return element;
+}
+
+function scrollInView(container, item) {
+    const borderTopValue = getComputedStyle(container).getPropertyValue('borderTopWidth');
+    const borderTop = borderTopValue ? parseFloat(borderTopValue) : 0;
+    const paddingTopValue = getComputedStyle(container).getPropertyValue('paddingTop');
+    const paddingTop = paddingTopValue ? parseFloat(paddingTopValue) : 0;
+    const containerRect = container.getBoundingClientRect();
+    const itemRect = item.getBoundingClientRect();
+    const offset = itemRect.top + document.body.scrollTop - (containerRect.top + document.body.scrollTop) - borderTop - paddingTop;
+    const scroll = container.scrollTop;
+    const elementHeight = container.clientHeight;
+    const itemHeight = getOuterHeight(item);
+    if (offset < 0) {
+        container.scrollTop = scroll + offset;
+    }
+    else if (offset + itemHeight > elementHeight) {
+        container.scrollTop = scroll + offset - elementHeight + itemHeight;
+    }
+}
+
+/**
+ * Ported from @primeuix/utils 0.7.2 (main was 0.6.4 at vendor time): `attribute === 'style'` with
+ * an object value sets each CSS property via `style.setProperty` instead of stringifying it into
+ * a plain attribute value.
+ */
+function setAttribute(element, attribute = '', value) {
+    if (isElement(element) && value !== null && value !== undefined) {
+        if (attribute === 'style' && typeof value === 'object') {
+            Object.entries(value).forEach(([property, propertyValue]) => {
+                if (propertyValue == null) {
+                    return;
+                }
+                const cssProperty = property.startsWith('--') ? property : property.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+                element.style.setProperty(cssProperty, String(propertyValue));
+            });
+            return;
+        }
+        if (attribute === 'style' && typeof value === 'string') {
+            element.style.cssText = value;
+            return;
+        }
+        element.setAttribute(attribute, value);
+    }
+}
+
+function setCSSProperty(element, property, value = null, priority) {
+    property && element?.style?.setProperty(property, value, priority);
+}
+
+function EventBus() {
+    const allHandlers = new Map();
+    return {
+        on(type, handler) {
+            let handlers = allHandlers.get(type);
+            if (!handlers)
+                handlers = [handler];
+            else
+                handlers.push(handler);
+            allHandlers.set(type, handlers);
+            return this;
+        },
+        off(type, handler) {
+            const handlers = allHandlers.get(type);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+            return this;
+        },
+        emit(type, evt) {
+            const handlers = allHandlers.get(type);
+            if (handlers) {
+                handlers.forEach((handler) => {
+                    handler(evt);
+                });
+            }
+        },
+        clear() {
+            allHandlers.clear();
+        }
+    };
+}
+
+function isEmpty(value) {
+    return value === null || value === undefined || value === '' || (Array.isArray(value) && value.length === 0) || (!(value instanceof Date) && typeof value === 'object' && Object.keys(value).length === 0);
+}
+
+function compare(value1, value2, comparator, order = 1) {
+    let result = -1;
+    const emptyValue1 = isEmpty(value1);
+    const emptyValue2 = isEmpty(value2);
+    if (emptyValue1 && emptyValue2)
+        result = 0;
+    else if (emptyValue1)
+        result = order;
+    else if (emptyValue2)
+        result = -order;
+    else if (typeof value1 === 'string' && typeof value2 === 'string')
+        result = comparator(value1, value2);
+    else
+        result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;
+    return result;
+}
+
+function _deepEquals(obj1, obj2, visited = new WeakSet()) {
+    // Base case: same object reference
+    if (obj1 === obj2)
+        return true;
+    // If one of them is null or not an object, directly return false
+    if (!obj1 || !obj2 || typeof obj1 !== 'object' || typeof obj2 !== 'object')
+        return false;
+    // Check for circular references
+    if (visited.has(obj1) || visited.has(obj2))
+        return false;
+    // Add objects to the visited set
+    visited.add(obj1).add(obj2);
+    const arrObj1 = Array.isArray(obj1);
+    const arrObj2 = Array.isArray(obj2);
+    let i, length, key;
+    if (arrObj1 && arrObj2) {
+        length = obj1.length;
+        if (length != obj2.length)
+            return false;
+        for (i = length; i-- !== 0;)
+            if (!_deepEquals(obj1[i], obj2[i], visited))
+                return false;
+        return true;
+    }
+    if (arrObj1 != arrObj2)
+        return false;
+    const dateObj1 = obj1 instanceof Date, dateObj2 = obj2 instanceof Date;
+    if (dateObj1 != dateObj2)
+        return false;
+    if (dateObj1 && dateObj2)
+        return obj1.getTime() == obj2.getTime();
+    const regexpObj1 = obj1 instanceof RegExp, regexpObj2 = obj2 instanceof RegExp;
+    if (regexpObj1 != regexpObj2)
+        return false;
+    if (regexpObj1 && regexpObj2)
+        return obj1.toString() == obj2.toString();
+    const keys = Object.keys(obj1);
+    length = keys.length;
+    if (length !== Object.keys(obj2).length)
+        return false;
+    for (i = length; i-- !== 0;)
+        if (!Object.prototype.hasOwnProperty.call(obj2, keys[i]))
+            return false;
+    for (i = length; i-- !== 0;) {
+        key = keys[i];
+        if (!_deepEquals(obj1[key], obj2[key], visited))
+            return false;
+    }
+    return true;
+}
+function deepEquals(obj1, obj2) {
+    return _deepEquals(obj1, obj2);
+}
+
+function isFunction(value) {
+    return typeof value === 'function' && 'call' in value && 'apply' in value;
+}
+
+function isNotEmpty(value) {
+    return !isEmpty(value);
+}
+
+function resolveFieldData(data, field) {
+    if (!data || !field) {
+        // short circuit if there is nothing to resolve
+        return null;
+    }
+    try {
+        const value = data[field];
+        if (isNotEmpty(value))
+            return value;
+    }
+    catch {
+        // Performance optimization: https://github.com/primefaces/primereact/issues/4797
+        // do nothing and continue to other methods to resolve field data
+    }
+    if (Object.keys(data).length) {
+        if (isFunction(field)) {
+            return field(data);
+        }
+        else if (field.indexOf('.') === -1) {
+            return data[field];
+        }
+        else {
+            const fields = field.split('.');
+            let value = data;
+            for (let i = 0, len = fields.length; i < len; ++i) {
+                if (value == null) {
+                    return null;
+                }
+                value = value[fields[i]];
+            }
+            return value;
+        }
+    }
+    return null;
+}
+
+function equals(obj1, obj2, field) {
+    if (field)
+        return resolveFieldData(obj1, field) === resolveFieldData(obj2, field);
+    else
+        return deepEquals(obj1, obj2);
+}
+
+function contains(value, list) {
+    if (value != null && list && list.length) {
+        for (const val of list) {
+            if (equals(value, val))
+                return true;
+        }
+    }
+    return false;
+}
+
+function isObject(value, empty = true) {
+    return value instanceof Object && value.constructor === Object && (empty || Object.keys(value).length !== 0);
+}
+
+function _deepMerge(target = {}, source = {}) {
+    const mergedObj = { ...target };
+    Object.keys(source).forEach((key) => {
+        const typedKey = key;
+        if (isObject(source[typedKey]) && typedKey in target && isObject(target[typedKey])) {
+            mergedObj[typedKey] = _deepMerge(target[typedKey], source[typedKey]);
+        }
+        else {
+            mergedObj[typedKey] = source[typedKey];
+        }
+    });
+    return mergedObj;
+}
+/**
+ * Merges multiple objects into one.
+ * @param args - Objects to merge.
+ * @returns Merged object.
+ */
+function deepMerge(...args) {
+    return args.reduce((acc, obj, i) => (i === 0 ? obj : _deepMerge(acc, obj)), {});
+}
+
+function filter(value, fields, filterValue) {
+    const filteredItems = [];
+    if (value) {
+        for (const item of value) {
+            for (const field of fields) {
+                if (String(resolveFieldData(item, field)).toLowerCase().indexOf(filterValue.toLowerCase()) > -1) {
+                    filteredItems.push(item);
+                    break;
+                }
+            }
+        }
+    }
+    return filteredItems;
+}
+
+function findIndexInList(value, list) {
+    let index = -1;
+    if (list) {
+        for (let i = 0; i < list.length; i++) {
+            if (list[i] === value) {
+                index = i;
+                break;
+            }
+        }
+    }
+    return index;
+}
+
+/**
+ * Firefox-v103 does not currently support the "findLast" method. It is stated that this method will be supported with Firefox-v104.
+ * https://caniuse.com/mdn-javascript_builtins_array_findlast
+ */
+function findLast(arr, callback) {
+    let item;
+    if (isNotEmpty(arr)) {
+        try {
+            item = arr.findLast(callback);
+        }
+        catch {
+            item = [...arr].reverse().find(callback);
+        }
+    }
+    return item;
+}
+
+/**
+ * Firefox-v103 does not currently support the "findLastIndex" method. It is stated that this method will be supported with Firefox-v104.
+ * https://caniuse.com/mdn-javascript_builtins_array_findlastindex
+ */
+function findLastIndex(arr, callback) {
+    let index = -1;
+    if (isNotEmpty(arr)) {
+        try {
+            index = arr.findLastIndex(callback);
+        }
+        catch {
+            index = arr.lastIndexOf([...arr].reverse().find(callback));
+        }
+    }
+    return index;
+}
+
+function resolve(obj, ...params) {
+    return isFunction(obj) ? obj(...params) : obj;
+}
+
+function isString(value, empty = true) {
+    return typeof value === 'string' && (empty || value !== '');
+}
+
+function toFlatCase(str) {
+    // convert snake, kebab, camel and pascal cases to flat case
+    return isString(str) ? str.replace(/(-|_)/g, '').toLowerCase() : str;
+}
+
+function getKeyValue(obj, key = '', params = {}) {
+    const fKeys = toFlatCase(key).split('.');
+    const fKey = fKeys.shift();
+    if (fKey) {
+        if (isObject(obj)) {
+            const matchedKey = Object.keys(obj).find((k) => toFlatCase(k) === fKey) || '';
+            return getKeyValue(resolve(obj[matchedKey], params), fKeys.join('.'), params);
+        }
+        return undefined;
+    }
+    return resolve(obj, params);
+}
+
+function insertIntoOrderedArray(item, index, arr, sourceArr) {
+    if (arr.length > 0) {
+        let injected = false;
+        for (let i = 0; i < arr.length; i++) {
+            const currentItemIndex = findIndexInList(arr[i], sourceArr);
+            if (currentItemIndex > index) {
+                arr.splice(i, 0, item);
+                injected = true;
+                break;
+            }
+        }
+        if (!injected) {
+            arr.push(item);
+        }
+    }
+    else {
+        arr.push(item);
+    }
+}
+
+function isArray(value, empty = true) {
+    return Array.isArray(value) && (empty || value.length !== 0);
+}
+
+function isDate(value) {
+    return value instanceof Date;
+}
+
+function isLetter(char) {
+    return /^[a-zA-Z\u00C0-\u017F]$/.test(char);
+}
+
+function isNumber(value) {
+    return isNotEmpty(value) && !isNaN(value);
+}
+
+function isPrintableCharacter(char = '') {
+    return isNotEmpty(char) && char.length === 1 && !!char.match(/\S| /);
+}
+
+function isScalar(value) {
+    return value != null && (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint' || typeof value === 'boolean');
+}
+
+function localeComparator() {
+    //performance gain using Int.Collator. It is not recommended to use localeCompare against large arrays.
+    return new Intl.Collator(undefined, { numeric: true }).compare;
+}
+
+function matchRegex(str, regex) {
+    if (regex) {
+        const match = regex.test(str);
+        regex.lastIndex = 0;
+        return match;
+    }
+    return false;
+}
+
+/**
+ * @deprecated Use `deepMerge` instead.
+ *
+ * Merges multiple objects into one.
+ * @param args - Objects to merge.
+ * @returns Merged object.
+ */
+function mergeKeys(...args) {
+    return deepMerge(...args);
+}
+
+function minifyCSS(css) {
+    return css
+        ? css
+            .replace(/\/\*(?:(?!\*\/)[\s\S])*\*\/|[\r\n\t]+/g, '')
+            .replace(/ {2,}/g, ' ')
+            .replace(/ ([{:}]) /g, '$1')
+            .replace(/([;,]) /g, '$1')
+            .replace(/ !/g, '!')
+            .replace(/: /g, ':')
+            .trim()
+        : css;
+}
+
+function nestedKeys(obj = {}, parentKey = '') {
+    return Object.entries(obj).reduce((o, [key, value]) => {
+        const currentKey = parentKey ? `${parentKey}.${key}` : key;
+        isObject(value) ? (o = o.concat(nestedKeys(value, currentKey))) : o.push(currentKey);
+        return o;
+    }, []);
+}
+
+function omit(obj, ...keys) {
+    if (!isObject(obj))
+        return obj;
+    const copy = { ...obj };
+    keys?.flat().forEach((key) => delete copy[key]);
+    return copy;
+}
+
+function removeAccents(str) {
+    // Regular expression to check for any accented characters 'Latin-1 Supplement' and 'Latin Extended-A'
+    const accentCheckRegex = /[\xC0-\xFF\u0100-\u017E]/;
+    if (str && accentCheckRegex.test(str)) {
+        const accentsMap = {
+            A: /[\xC0-\xC5\u0100\u0102\u0104]/g,
+            AE: /[\xC6]/g,
+            C: /[\xC7\u0106\u0108\u010A\u010C]/g,
+            D: /[\xD0\u010E\u0110]/g,
+            E: /[\xC8-\xCB\u0112\u0114\u0116\u0118\u011A]/g,
+            G: /[\u011C\u011E\u0120\u0122]/g,
+            H: /[\u0124\u0126]/g,
+            I: /[\xCC-\xCF\u0128\u012A\u012C\u012E\u0130]/g,
+            IJ: /[\u0132]/g,
+            J: /[\u0134]/g,
+            K: /[\u0136]/g,
+            L: /[\u0139\u013B\u013D\u013F\u0141]/g,
+            N: /[\xD1\u0143\u0145\u0147\u014A]/g,
+            O: /[\xD2-\xD6\xD8\u014C\u014E\u0150]/g,
+            OE: /[\u0152]/g,
+            R: /[\u0154\u0156\u0158]/g,
+            S: /[\u015A\u015C\u015E\u0160]/g,
+            T: /[\u0162\u0164\u0166]/g,
+            U: /[\xD9-\xDC\u0168\u016A\u016C\u016E\u0170\u0172]/g,
+            W: /[\u0174]/g,
+            Y: /[\xDD\u0176\u0178]/g,
+            Z: /[\u0179\u017B\u017D]/g,
+            a: /[\xE0-\xE5\u0101\u0103\u0105]/g,
+            ae: /[\xE6]/g,
+            c: /[\xE7\u0107\u0109\u010B\u010D]/g,
+            d: /[\u010F\u0111]/g,
+            e: /[\xE8-\xEB\u0113\u0115\u0117\u0119\u011B]/g,
+            g: /[\u011D\u011F\u0121\u0123]/g,
+            i: /[\xEC-\xEF\u0129\u012B\u012D\u012F\u0131]/g,
+            ij: /[\u0133]/g,
+            j: /[\u0135]/g,
+            k: /[\u0137,\u0138]/g,
+            l: /[\u013A\u013C\u013E\u0140\u0142]/g,
+            n: /[\xF1\u0144\u0146\u0148\u014B]/g,
+            p: /[\xFE]/g,
+            o: /[\xF2-\xF6\xF8\u014D\u014F\u0151]/g,
+            oe: /[\u0153]/g,
+            r: /[\u0155\u0157\u0159]/g,
+            s: /[\u015B\u015D\u015F\u0161]/g,
+            t: /[\u0163\u0165\u0167]/g,
+            u: /[\xF9-\xFC\u0169\u016B\u016D\u016F\u0171\u0173]/g,
+            w: /[\u0175]/g,
+            y: /[\xFD\xFF\u0177]/g,
+            z: /[\u017A\u017C\u017E]/g
+        };
+        for (const key in accentsMap) {
+            str = str.replace(accentsMap[key], key);
+        }
+    }
+    return str;
+}
+
+function reorderArray(value, from, to) {
+    if (value && from !== to) {
+        if (to >= value.length) {
+            to %= value.length;
+            from %= value.length;
+        }
+        value.splice(to, 0, value.splice(from, 1)[0]);
+    }
+}
+
+/**
+ * Shallow equal for React/Vue props comparison
+ * Ignores functions (common in props)
+ */
+function shallowEqualProps(propsA, propsB) {
+    if (propsA === propsB)
+        return true;
+    const keysA = Object.keys(propsA);
+    const keysB = Object.keys(propsB);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        const valueA = propsA[key];
+        const valueB = propsB[key];
+        // Skip function comparison (they rarely change)
+        if (typeof valueA === 'function' && typeof valueB === 'function') {
+            continue;
+        }
+        if (!Object.is(valueA, valueB)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Checks if two values are shallowly equal
+ * - Primitives: compared by value (===)
+ * - Objects/Arrays: compared by reference and first-level properties
+ *
+ * @param objA - First value to compare
+ * @param objB - Second value to compare
+ * @returns True if values are shallowly equal, false otherwise
+ *
+ * @example
+ * shallowEquals(1, 1) // true
+ * shallowEquals('a', 'a') // true
+ * shallowEquals({ a: 1 }, { a: 1 }) // true (shallow)
+ * shallowEquals({ a: { b: 1 } }, { a: { b: 1 } }) // false (nested objects are different references)
+ * shallowEquals([1, 2], [1, 2]) // true (shallow)
+ * shallowEquals([1, [2]], [1, [2]]) // false (nested arrays are different references)
+ */
+function shallowEquals(objA, objB) {
+    // Fast path: same reference
+    if (objA === objB)
+        return true;
+    // Fast path: different types or null
+    if (typeof objA !== typeof objB || objA === null || objB === null) {
+        return false;
+    }
+    // Fast path: primitives
+    if (typeof objA !== 'object') {
+        return objA === objB;
+    }
+    // Same reference (including null === null, undefined === undefined)
+    if (Object.is(objA, objB)) {
+        return true;
+    }
+    // If either is not an object or is null, they're not equal
+    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+        return false;
+    }
+    // Compare arrays
+    if (Array.isArray(objA) && Array.isArray(objB)) {
+        if (objA.length !== objB.length) {
+            return false;
+        }
+        for (let i = 0; i < objA.length; i++) {
+            if (!Object.is(objA[i], objB[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // If only one is array, they're not equal
+    if (Array.isArray(objA) || Array.isArray(objB)) {
+        return false;
+    }
+    // Compare object keys
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    // Check if all keys and values match
+    for (const key of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(objB, key) || !Object.is(objA[key], objB[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function sort(value1, value2, order = 1, comparator, nullSortOrder = 1) {
+    const result = compare(value1, value2, comparator, order);
+    let finalSortOrder = order;
+    // nullSortOrder == 1 means Excel like sort nulls at bottom
+    if (isEmpty(value1) || isEmpty(value2)) {
+        finalSortOrder = nullSortOrder === 1 ? order : nullSortOrder;
+    }
+    return finalSortOrder * result;
+}
+
+function stringify(value, indent = 2, currentIndent = 0) {
+    const currentIndentStr = ' '.repeat(currentIndent);
+    const nextIndentStr = ' '.repeat(currentIndent + indent);
+    if (isArray(value)) {
+        return '[' + value.map((v) => stringify(v, indent, currentIndent + indent)).join(', ') + ']';
+    }
+    else if (isDate(value)) {
+        return value.toISOString();
+    }
+    else if (isFunction(value)) {
+        return value.toString();
+    }
+    else if (isObject(value)) {
+        return ('{\n' +
+            Object.entries(value)
+                .map(([k, v]) => `${nextIndentStr}${k}: ${stringify(v, indent, currentIndent + indent)}`)
+                .join(',\n') +
+            `\n${currentIndentStr}` +
+            '}');
+    }
+    else {
+        return JSON.stringify(value);
+    }
+}
+
+function toCamelCase(str) {
+    // convert snake, kebab and pascal cases to camel case
+    return isString(str) ? str.replace(/[-_](\w)/g, (_, c) => (c ? c.toUpperCase() : '')) : str;
+}
+
+function toCapitalCase(str) {
+    return isString(str, false) ? str[0].toUpperCase() + str.slice(1) : str;
+}
+
+function toKebabCase(str) {
+    // convert snake, camel and pascal cases to kebab case
+    return isString(str)
+        ? str
+            .replace(/(_)/g, '-')
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .toLowerCase()
+        : str;
+}
+
+function toMs(value) {
+    if (value === 'auto')
+        return 0;
+    if (typeof value === 'number')
+        return value;
+    return Number(value.replace(/[^\d.]/g, '').replace(',', '.')) * 1000;
+}
+
+function toTokenKey(str) {
+    return isString(str) ? str.replace(/[A-Z]/g, (c, i) => (i === 0 ? c : '.' + c.toLowerCase())).toLowerCase() : str;
+}
+
+function toValue(value) {
+    if (value && typeof value === 'object') {
+        if (Object.hasOwn(value, 'current')) {
+            // For React
+            return value.current;
+        }
+        else if (Object.hasOwn(value, 'value')) {
+            // For Vue
+            return value.value;
+        }
+    }
+    // For Angular signals and functions usage
+    return resolve(value);
+}
+
+function _mergeProps({ skipUndefined = false }, ...props) {
+    return props?.reduce((merged, ps = {}) => {
+        for (const key in ps) {
+            const value = ps[key];
+            if (skipUndefined && value === undefined)
+                continue;
+            if (key === 'style') {
+                merged['style'] = { ...merged['style'], ...ps['style'] };
+            }
+            else if (key === 'class' || key === 'className') {
+                merged[key] = cn(merged[key], ps[key]);
+            }
+            else if (isFunction(value)) {
+                const fn = merged[key];
+                merged[key] = fn
+                    ? (...args) => {
+                        fn(...args);
+                        value(...args);
+                    }
+                    : value;
+            }
+            else {
+                merged[key] = value;
+            }
+        }
+        return merged;
+    }, {});
+}
+function mergeProps(...props) {
+    return _mergeProps({ skipUndefined: false }, ...props);
+}
+function mergeDefaultProps(...props) {
+    return _mergeProps({ skipUndefined: true }, ...props);
+}
+
+const lastIds = {};
+function uuid(prefix = 'pui_id_') {
+    if (!Object.hasOwn(lastIds, prefix)) {
+        lastIds[prefix] = 0;
+    }
+    lastIds[prefix]++;
+    return `${prefix}${lastIds[prefix]}`;
+}
+
+function handler() {
+    let zIndexes = [];
+    const generateZIndex = (key, autoZIndex, baseZIndex = 999) => {
+        const lastZIndex = getLastZIndex(key, autoZIndex, baseZIndex);
+        const newZIndex = lastZIndex.value + (lastZIndex.key === key ? 0 : baseZIndex) + 1;
+        zIndexes.push({ key, value: newZIndex });
+        return newZIndex;
+    };
+    const revertZIndex = (zIndex) => {
+        zIndexes = zIndexes.filter((obj) => obj.value !== zIndex);
+    };
+    const getCurrentZIndex = (key, autoZIndex) => {
+        return getLastZIndex(key, autoZIndex).value;
+    };
+    const getLastZIndex = (key, autoZIndex, baseZIndex = 0) => {
+        return [...zIndexes].reverse().find((obj) => (autoZIndex ? true : obj.key === key)) || { key, value: baseZIndex };
+    };
+    const getZIndex = (element) => {
+        return element ? parseInt(element.style.zIndex, 10) || 0 : 0;
+    };
+    return {
+        get: getZIndex,
+        set: (key, element, baseZIndex) => {
+            if (element) {
+                element.style.zIndex = String(generateZIndex(key, true, baseZIndex));
+            }
+        },
+        clear: (element) => {
+            if (element) {
+                revertZIndex(getZIndex(element));
+                element.style.zIndex = '';
+            }
+        },
+        getCurrent: (key) => getCurrentZIndex(key, true)
+    };
+}
+const ZIndex = handler();
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { EventBus, ZIndex, absolutePosition, addClass, addStyle, alignOverlay, appendChild, blockBodyScroll, calculateBodyScrollbarWidth, calculateScrollbarHeight, calculateScrollbarWidth, classNames, clearSelection, cn, compare, contains, createElement, createStyleAsString, createStyleElement, createStyleMarkup, createStyleTag, deepEquals, deepMerge, equals, exportCSV, fadeIn, fadeOut, filter, find, findIndexInList, findLast, findLastIndex, findSingle, focus, getAttribute, getBrowser, getBrowserLanguage, getCSSProperty, getCSSVariableByRegex, getCursorOffset, getFirstFocusableElement, getFocusableElements, getHeight, getHiddenElementDimensions, getHiddenElementOuterHeight, getHiddenElementOuterWidth, getIndex, getInnerWidth, getKeyValue, getLastFocusableElement, getNextElementSibling, getNextFocusableElement, getOffset, getOuterHeight, getOuterWidth, getParentNode, getParents, getPreviousElementSibling, getScrollLeft, getScrollableParents, getSelection, getTargetElement, getUserAgent, getViewport, getWidth, getWindowScrollLeft, getWindowScrollTop, hasCSSAnimation, hasCSSTransition, hasClass, insertIntoOrderedArray, invokeElementMethod, isAndroid, isArray, isAttributeEquals, isAttributeNotEquals, isClickable, isClient, isCssSupported, isDate, isElement, isEmpty, isExist, isFocusableElement, isFunction, isHidden, isIOS, isLetter, isNotEmpty, isNumber, isObject, isPrefersReducedMotion, isPrintableCharacter, isRTL, isScalar, isServer, isString, isTouchDevice, isVisible, localeComparator, matchRegex, mergeDefaultProps, mergeKeys, mergeProps, minifyCSS, nestedKeys, nestedPosition, nextFrame, omit, relativePosition, remove, removeAccents, removeChild, removeClass, removeStyleTag, reorderArray, resolve, resolveFieldData, resolveUserAgent, saveAs, scrollInView, setAttribute, setAttributes, setCSSProperty, shallowEqualProps, shallowEquals, sort, stringify, toCamelCase, toCapitalCase, toElement, toFlatCase, toKebabCase, toMs, toTokenKey, toValue, unblockBodyScroll, uuid };
+//# sourceMappingURL=gravionlabs-helix-core-uix-utils.mjs.map