@sekiui/elements 0.1.5 → 0.1.6

package/dist/cdn/index.js

@@ -1,1242 +0,0 @@
-import { g as globalScripts } from './p-jMliCqbB.js';
-export { a as getAssetPath, r as render, s as setAssetPath, b as setNonce, c as setPlatformOptions } from './p-jMliCqbB.js';
-export { S as SekiSwitch } from './p-CM1qYW9i.js';
-export { S as SekiLabel } from './p-C3WFySZp.js';
-export { a as SekiSonner, S as SekiSonnerElement } from './p-DQcofZe0.js';
-export { t as toast } from './p-BNAT-Ecg.js';
-
-/**
- * Keyboard Service
- * Provides normalized keyboard event handling and shortcut management
- * Handles cross-platform shortcuts (Ctrl/Cmd combinations)
- */
-/**
- * KeyboardService - Centralized keyboard event management
- * Provides:
- * - Normalized keyboard shortcuts (handles Ctrl vs Cmd on Mac)
- * - Cross-platform shortcut registration
- * - Event cleanup and teardown
- */
-class KeyboardService {
-    constructor() {
-        this.shortcuts = new Map();
-        this.listeners = new Map();
-    }
-    /**
-     * Register a keyboard shortcut
-     * @param id - Unique identifier for this shortcut
-     * @param options - Shortcut configuration
-     */
-    registerShortcut(id, options) {
-        if (typeof window === 'undefined')
-            return;
-        const { key, ctrl = false, shift = false, alt = false, meta = false, handler, preventDefault = true } = options;
-        const handleKeyDown = (event) => {
-            const keyboardEvent = event;
-            const keyMatches = keyboardEvent.key.toLowerCase() === key.toLowerCase();
-            const ctrlMatches = ctrl ? keyboardEvent.ctrlKey : true;
-            const shiftMatches = shift ? keyboardEvent.shiftKey : !keyboardEvent.shiftKey;
-            const altMatches = alt ? keyboardEvent.altKey : !keyboardEvent.altKey;
-            // metaKey matches both metaKey (Mac Cmd) and ctrlKey (Windows/Linux) for cross-platform support
-            const metaMatches = meta ? keyboardEvent.metaKey || keyboardEvent.ctrlKey : !keyboardEvent.metaKey && !keyboardEvent.ctrlKey;
-            if (keyMatches && ctrlMatches && shiftMatches && altMatches && metaMatches) {
-                if (preventDefault) {
-                    keyboardEvent.preventDefault();
-                }
-                handler(keyboardEvent);
-            }
-        };
-        this.shortcuts.set(id, {
-            key,
-            ctrlKey: ctrl,
-            shiftKey: shift,
-            altKey: alt,
-            metaKey: meta,
-            handler: handleKeyDown,
-        });
-        this.listeners.set(id, handleKeyDown);
-        window.addEventListener('keydown', handleKeyDown);
-    }
-    /**
-     * Register a shortcut that works with Ctrl on Windows/Linux and Cmd on Mac
-     * @param id - Unique identifier for this shortcut
-     * @param key - The key to listen for
-     * @param handler - Callback when shortcut is triggered
-     * @param preventDefault - Whether to prevent default browser behavior
-     */
-    registerCtrlOrCmdShortcut(id, key, handler, preventDefault = true) {
-        if (typeof window === 'undefined')
-            return;
-        const handleKeyDown = (event) => {
-            const keyboardEvent = event;
-            const keyMatches = keyboardEvent.key.toLowerCase() === key.toLowerCase();
-            const modifierMatches = keyboardEvent.ctrlKey || keyboardEvent.metaKey;
-            if (keyMatches && modifierMatches && !keyboardEvent.shiftKey && !keyboardEvent.altKey) {
-                if (preventDefault) {
-                    keyboardEvent.preventDefault();
-                }
-                handler(keyboardEvent);
-            }
-        };
-        this.listeners.set(id, handleKeyDown);
-        window.addEventListener('keydown', handleKeyDown);
-    }
-    /**
-     * Unregister a keyboard shortcut
-     * @param id - The identifier of the shortcut to remove
-     */
-    unregisterShortcut(id) {
-        if (typeof window === 'undefined')
-            return;
-        const listener = this.listeners.get(id);
-        if (listener) {
-            window.removeEventListener('keydown', listener);
-            this.listeners.delete(id);
-        }
-        this.shortcuts.delete(id);
-    }
-    /**
-     * Unregister all shortcuts and clean up
-     */
-    cleanup() {
-        if (typeof window === 'undefined')
-            return;
-        this.listeners.forEach((listener) => {
-            window.removeEventListener('keydown', listener);
-        });
-        this.listeners.clear();
-        this.shortcuts.clear();
-    }
-    /**
-     * Check if a keyboard event matches a specific key combination
-     * @param event - The keyboard event to check
-     * @param key - The key to match
-     * @param ctrl - Whether Ctrl/Cmd should be pressed
-     * @param shift - Whether Shift should be pressed
-     * @param alt - Whether Alt should be pressed
-     */
-    matchesShortcut(event, key, ctrl = false, shift = false, alt = false) {
-        const keyMatches = event.key.toLowerCase() === key.toLowerCase();
-        const ctrlMatches = ctrl ? event.ctrlKey || event.metaKey : !event.ctrlKey && !event.metaKey;
-        const shiftMatches = shift ? event.shiftKey : !event.shiftKey;
-        const altMatches = alt ? event.altKey : !event.altKey;
-        return keyMatches && ctrlMatches && shiftMatches && altMatches;
-    }
-}
-// Singleton instance
-let keyboardServiceInstance = null;
-/**
- * Get the singleton KeyboardService instance
- */
-function getKeyboardService() {
-    if (!keyboardServiceInstance) {
-        keyboardServiceInstance = new KeyboardService();
-    }
-    return keyboardServiceInstance;
-}
-/**
- * Create a new isolated KeyboardService instance
- * Useful for testing or when you need independent event handling
- */
-function createKeyboardService() {
-    return new KeyboardService();
-}
-
-/**
- * Focus Management Service
- * Provides utilities for focus management, focus traps, and focus restoration
- */
-/**
- * FocusService - Centralized focus management
- * Provides:
- * - Focus trap implementation
- * - Focus restoration
- * - Focusable element detection
- * - Focus utilities for accessibility
- */
-class FocusService {
-    constructor() {
-        this.focusTrapStack = new Map();
-        this.previouslyFocusedElement = null;
-    }
-    /**
-     * Get all focusable elements within a container
-     * Includes buttons, links, inputs, textareas, selects, and elements with tabindex
-     */
-    getFocusableElements(container = document) {
-        const focusableSelectors = [
-            'button:not([disabled])',
-            'a[href]',
-            'input:not([disabled])',
-            'textarea:not([disabled])',
-            'select:not([disabled])',
-            '[tabindex]:not([tabindex="-1"])',
-        ].join(',');
-        const elements = Array.from(container.querySelectorAll(focusableSelectors));
-        return elements.filter((el) => {
-            // Exclude hidden elements
-            const style = window.getComputedStyle(el);
-            return style.display !== 'none' && style.visibility !== 'hidden';
-        });
-    }
-    /**
-     * Check if an element is focusable
-     */
-    isFocusable(element) {
-        const focusableSelectors = [
-            'button',
-            'a[href]',
-            'input',
-            'textarea',
-            'select',
-            '[tabindex]',
-        ];
-        return focusableSelectors.some((selector) => element.matches(selector)) && !element.hasAttribute('disabled');
-    }
-    /**
-     * Set focus to an element with optional callbacks
-     */
-    setFocus(element, options) {
-        var _a;
-        if (!element)
-            return false;
-        try {
-            element.focus({ preventScroll: (_a = options === null || options === void 0 ? void 0 : options.preventScroll) !== null && _a !== void 0 ? _a : false });
-            return document.activeElement === element;
-        }
-        catch (error) {
-            console.warn('Failed to set focus:', error);
-            return false;
-        }
-    }
-    /**
-     * Trap focus within a container (keyboard navigation stays within bounds)
-     * @param container - The element to trap focus within
-     * @param options - Focus trap options
-     */
-    createFocusTrap(container, options = {}) {
-        if (typeof window === 'undefined')
-            return;
-        const { initialFocus, restoreFocus = true } = options;
-        // Store the previously focused element for restoration
-        if (restoreFocus) {
-            this.previouslyFocusedElement = document.activeElement;
-        }
-        // Set initial focus
-        if (initialFocus) {
-            this.setFocus(initialFocus);
-        }
-        else {
-            const focusableElements = this.getFocusableElements(container);
-            if (focusableElements.length > 0) {
-                this.setFocus(focusableElements[0]);
-            }
-        }
-        // Handle Tab key for focus trap
-        const handleKeyDown = (event) => {
-            if (event.key !== 'Tab')
-                return;
-            const focusableElements = this.getFocusableElements(container);
-            if (focusableElements.length === 0)
-                return;
-            const currentFocusIndex = focusableElements.indexOf(document.activeElement);
-            if (event.shiftKey) {
-                // Shift+Tab - move backwards
-                const previousIndex = currentFocusIndex - 1;
-                const targetElement = previousIndex >= 0 ? focusableElements[previousIndex] : focusableElements[focusableElements.length - 1];
-                event.preventDefault();
-                this.setFocus(targetElement);
-            }
-            else {
-                // Tab - move forwards
-                const nextIndex = currentFocusIndex + 1;
-                const targetElement = nextIndex < focusableElements.length ? focusableElements[nextIndex] : focusableElements[0];
-                event.preventDefault();
-                this.setFocus(targetElement);
-            }
-        };
-        container.addEventListener('keydown', handleKeyDown);
-        this.focusTrapStack.set(container, this.previouslyFocusedElement);
-        // Store the handler for potential later cleanup
-        // Note: Manual cleanup should be done via releaseFocusTrap()
-    }
-    /**
-     * Release focus trap from a container
-     */
-    releaseFocusTrap(container, restoreFocus = true) {
-        const previousElement = this.focusTrapStack.get(container);
-        this.focusTrapStack.delete(container);
-        if (restoreFocus && previousElement) {
-            this.setFocus(previousElement);
-        }
-    }
-    /**
-     * Get the first focusable element in a container
-     */
-    getFirstFocusable(container = document) {
-        const focusable = this.getFocusableElements(container);
-        return focusable.length > 0 ? focusable[0] : null;
-    }
-    /**
-     * Get the last focusable element in a container
-     */
-    getLastFocusable(container = document) {
-        const focusable = this.getFocusableElements(container);
-        return focusable.length > 0 ? focusable[focusable.length - 1] : null;
-    }
-    /**
-     * Move focus to the next focusable element
-     */
-    focusNext(container = document) {
-        const focusable = this.getFocusableElements(container);
-        const currentIndex = focusable.indexOf(document.activeElement);
-        const nextIndex = (currentIndex + 1) % focusable.length;
-        if (focusable.length > 0) {
-            this.setFocus(focusable[nextIndex]);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Move focus to the previous focusable element
-     */
-    focusPrevious(container = document) {
-        const focusable = this.getFocusableElements(container);
-        const currentIndex = focusable.indexOf(document.activeElement);
-        const previousIndex = (currentIndex - 1 + focusable.length) % focusable.length;
-        if (focusable.length > 0) {
-            this.setFocus(focusable[previousIndex]);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Clear all focus traps
-     */
-    clearFocusTraps() {
-        this.focusTrapStack.clear();
-    }
-}
-// Singleton instance
-let focusServiceInstance = null;
-/**
- * Get the singleton FocusService instance
- */
-function getFocusService() {
-    if (!focusServiceInstance) {
-        focusServiceInstance = new FocusService();
-    }
-    return focusServiceInstance;
-}
-/**
- * Create a new isolated FocusService instance
- */
-function createFocusService() {
-    return new FocusService();
-}
-
-/**
- * Media Query Service
- * Provides utilities for responsive design and media query management
- */
-/**
- * Default breakpoints (Tailwind-inspired)
- */
-const DEFAULT_BREAKPOINTS = {
-    sm: '640px',
-    md: '768px',
-    lg: '1024px',
-    xl: '1280px',
-    '2xl': '1536px',
-};
-/**
- * MediaQueryService - Centralized media query management
- * Provides:
- * - Media query listener registration
- * - Breakpoint detection
- * - Window resize handling
- * - Current viewport information
- */
-class MediaQueryService {
-    constructor(breakpoints = DEFAULT_BREAKPOINTS) {
-        this.listeners = new Map();
-        this.resizeObserver = null;
-        this.resizeListeners = new Map();
-        this.breakpoints = breakpoints;
-    }
-    /**
-     * Register a media query listener
-     * @param id - Unique identifier for this listener
-     * @param query - CSS media query string
-     * @param handler - Callback when media query matches/unmatches
-     */
-    registerMediaQuery(id, query, handler) {
-        if (typeof window === 'undefined')
-            return;
-        try {
-            const matcher = window.matchMedia(query);
-            const listener = { query, handler, matcher };
-            // Call handler with initial state
-            handler(matcher.matches);
-            // Listen for changes
-            matcher.addEventListener('change', (e) => handler(e.matches));
-            this.listeners.set(id, listener);
-        }
-        catch (error) {
-            console.warn(`Failed to register media query "${query}":`, error);
-        }
-    }
-    /**
-     * Register a breakpoint listener (easier than raw media queries)
-     * @param id - Unique identifier
-     * @param breakpoint - Breakpoint name (sm, md, lg, xl, 2xl)
-     * @param type - Type of match: 'min' (mobile-first) or 'max' (desktop-first)
-     * @param handler - Callback when breakpoint matches
-     */
-    registerBreakpoint(id, breakpoint, type = 'min', handler) {
-        const size = this.breakpoints[breakpoint];
-        if (!size) {
-            console.warn(`Unknown breakpoint: ${breakpoint}`);
-            return;
-        }
-        const query = type === 'min' ? `(min-width: ${size})` : `(max-width: ${size})`;
-        this.registerMediaQuery(id, query, handler);
-    }
-    /**
-     * Unregister a media query listener
-     */
-    unregisterMediaQuery(id) {
-        const listener = this.listeners.get(id);
-        if (listener && listener.matcher) {
-            listener.matcher.removeEventListener('change', () => { });
-        }
-        this.listeners.delete(id);
-    }
-    /**
-     * Check if a media query currently matches
-     */
-    isMatching(query) {
-        if (typeof window === 'undefined')
-            return false;
-        try {
-            return window.matchMedia(query).matches;
-        }
-        catch (error) {
-            console.warn(`Failed to check media query "${query}":`, error);
-            return false;
-        }
-    }
-    /**
-     * Check if a breakpoint is currently active
-     */
-    isBreakpointActive(breakpoint, type = 'min') {
-        const size = this.breakpoints[breakpoint];
-        if (!size)
-            return false;
-        const query = type === 'min' ? `(min-width: ${size})` : `(max-width: ${size})`;
-        return this.isMatching(query);
-    }
-    /**
-     * Get the current viewport width
-     */
-    getViewportWidth() {
-        if (typeof window === 'undefined')
-            return 0;
-        return window.innerWidth;
-    }
-    /**
-     * Get the current viewport height
-     */
-    getViewportHeight() {
-        if (typeof window === 'undefined')
-            return 0;
-        return window.innerHeight;
-    }
-    /**
-     * Check if viewport is mobile-sized (< 768px)
-     */
-    isMobile() {
-        return this.getViewportWidth() < 768;
-    }
-    /**
-     * Check if viewport is tablet-sized (768px - 1024px)
-     */
-    isTablet() {
-        const width = this.getViewportWidth();
-        return width >= 768 && width < 1024;
-    }
-    /**
-     * Check if viewport is desktop-sized (>= 1024px)
-     */
-    isDesktop() {
-        return this.getViewportWidth() >= 1024;
-    }
-    /**
-     * Check if prefers-reduced-motion is enabled
-     */
-    prefersReducedMotion() {
-        if (typeof window === 'undefined')
-            return false;
-        try {
-            return window.matchMedia('(prefers-reduced-motion: reduce)').matches;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Check if dark mode is preferred
-     */
-    prefersDarkMode() {
-        if (typeof window === 'undefined')
-            return false;
-        try {
-            return window.matchMedia('(prefers-color-scheme: dark)').matches;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Get the current device orientation
-     */
-    getOrientation() {
-        if (typeof window === 'undefined')
-            return 'portrait';
-        return window.innerHeight > window.innerWidth ? 'portrait' : 'landscape';
-    }
-    /**
-     * Register a window resize listener
-     * @param id - Unique identifier
-     * @param handler - Callback with (width, height)
-     * @param debounceMs - Debounce delay in milliseconds
-     */
-    registerResizeListener(id, handler, debounceMs = 0) {
-        if (typeof window === 'undefined')
-            return;
-        let timeoutId = null;
-        const eventListener = () => {
-            if (timeoutId)
-                clearTimeout(timeoutId);
-            if (debounceMs > 0) {
-                timeoutId = setTimeout(() => {
-                    handler(this.getViewportWidth(), this.getViewportHeight());
-                }, debounceMs);
-            }
-            else {
-                handler(this.getViewportWidth(), this.getViewportHeight());
-            }
-        };
-        this.resizeListeners.set(id, { handler, eventListener });
-        window.addEventListener('resize', eventListener);
-        // Call handler with initial dimensions
-        handler(this.getViewportWidth(), this.getViewportHeight());
-    }
-    /**
-     * Unregister a resize listener
-     */
-    unregisterResizeListener(id) {
-        if (typeof window === 'undefined')
-            return;
-        const entry = this.resizeListeners.get(id);
-        if (entry) {
-            window.removeEventListener('resize', entry.eventListener);
-            this.resizeListeners.delete(id);
-        }
-    }
-    /**
-     * Clean up all listeners
-     */
-    cleanup() {
-        this.listeners.forEach((listener) => {
-            if (listener.matcher) {
-                listener.matcher.removeEventListener('change', () => { });
-            }
-        });
-        this.listeners.clear();
-        if (typeof window !== 'undefined') {
-            this.resizeListeners.forEach((entry) => {
-                window.removeEventListener('resize', entry.eventListener);
-            });
-        }
-        this.resizeListeners.clear();
-        if (this.resizeObserver) {
-            this.resizeObserver.disconnect();
-            this.resizeObserver = null;
-        }
-    }
-    /**
-     * Update breakpoint configuration
-     */
-    setBreakpoints(breakpoints) {
-        this.breakpoints = Object.assign(Object.assign({}, DEFAULT_BREAKPOINTS), breakpoints);
-    }
-}
-// Singleton instance
-let mediaQueryServiceInstance = null;
-/**
- * Get the singleton MediaQueryService instance
- */
-function getMediaQueryService(breakpoints) {
-    if (!mediaQueryServiceInstance) {
-        mediaQueryServiceInstance = new MediaQueryService(breakpoints);
-    }
-    return mediaQueryServiceInstance;
-}
-/**
- * Create a new isolated MediaQueryService instance
- */
-function createMediaQueryService(breakpoints) {
-    return new MediaQueryService(breakpoints || DEFAULT_BREAKPOINTS);
-}
-
-/**
- * Common Utilities
- * Shared utility functions used across the component library
- */
-/* eslint-disable no-undef, @typescript-eslint/no-explicit-any */
-let idCounter = 0;
-/**
- * Generate a unique ID with optional prefix
- * @param prefix - Optional prefix for the ID (default: 'id')
- */
-function generateUniqueId(prefix = 'id') {
-    return `${prefix}-${++idCounter}-${Math.random().toString(36).substr(2, 9)}`;
-}
-/**
- * Reset ID counter (useful for testing)
- */
-function resetIdCounter() {
-    idCounter = 0;
-}
-/**
- * Debounce a function
- * @param fn - Function to debounce
- * @param delay - Delay in milliseconds
- */
-function debounce(fn, delay) {
-    let timeoutId = null;
-    return (...args) => {
-        if (timeoutId)
-            clearTimeout(timeoutId);
-        timeoutId = setTimeout(() => fn(...args), delay);
-    };
-}
-/**
- * Throttle a function
- * @param fn - Function to throttle
- * @param delay - Delay in milliseconds
- */
-function throttle(fn, delay) {
-    let lastCall = 0;
-    let timeoutId = null;
-    return (...args) => {
-        const now = Date.now();
-        if (now - lastCall >= delay) {
-            lastCall = now;
-            fn(...args);
-        }
-        else {
-            if (timeoutId)
-                clearTimeout(timeoutId);
-            timeoutId = setTimeout(() => {
-                lastCall = Date.now();
-                fn(...args);
-            }, delay - (now - lastCall));
-        }
-    };
-}
-/**
- * Add a class to an element
- * @param element - The element
- * @param className - Class name to add
- */
-function addClass(element, className) {
-    element.classList.add(className);
-}
-/**
- * Remove a class from an element
- * @param element - The element
- * @param className - Class name to remove
- */
-function removeClass(element, className) {
-    element.classList.remove(className);
-}
-/**
- * Toggle a class on an element
- * @param element - The element
- * @param className - Class name to toggle
- * @param force - Optional force add/remove
- */
-function toggleClass(element, className, force) {
-    element.classList.toggle(className, force);
-}
-/**
- * Check if element has a class
- * @param element - The element
- * @param className - Class name to check
- */
-function hasClass(element, className) {
-    return element.classList.contains(className);
-}
-/**
- * Get all data attributes from an element as an object
- */
-function getDataAttributes(element) {
-    const data = {};
-    Array.from(element.attributes).forEach((attr) => {
-        if (attr.name.startsWith('data-')) {
-            const key = attr.name.slice(5); // Remove 'data-' prefix
-            data[key] = attr.value;
-        }
-    });
-    return data;
-}
-/**
- * Set a data attribute on an element
- * @param element - The element
- * @param key - Data attribute name (without 'data-' prefix)
- * @param value - The value to set
- */
-function setDataAttribute(element, key, value) {
-    if (value === null) {
-        element.removeAttribute(`data-${key}`);
-    }
-    else {
-        element.setAttribute(`data-${key}`, value);
-    }
-}
-/**
- * Get the value of a data attribute
- * @param element - The element
- * @param key - Data attribute name (without 'data-' prefix)
- */
-function getDataAttribute(element, key) {
-    return element.getAttribute(`data-${key}`) || undefined;
-}
-/**
- * Dispatch a custom event from an element
- * @param element - The element to dispatch from
- * @param eventName - Name of the custom event
- * @param detail - Optional detail object to include in the event
- */
-function dispatchCustomEvent(element, eventName, detail) {
-    const event = new CustomEvent(eventName, {
-        detail,
-        bubbles: true,
-        cancelable: true,
-        composed: true,
-    });
-    element.dispatchEvent(event);
-}
-/**
- * Listen for a custom event
- * @param element - The element to listen on
- * @param eventName - Name of the custom event
- * @param handler - Callback function
- * @returns Cleanup function to remove listener
- */
-function onCustomEvent(element, eventName, handler) {
-    const listener = (event) => {
-        handler(event.detail);
-    };
-    element.addEventListener(eventName, listener);
-    return () => {
-        element.removeEventListener(eventName, listener);
-    };
-}
-/**
- * Get the offset position of an element relative to the viewport
- */
-function getElementOffset(element) {
-    const rect = element.getBoundingClientRect();
-    return {
-        top: rect.top + window.scrollY,
-        left: rect.left + window.scrollX,
-    };
-}
-/**
- * Check if an element is in the viewport
- */
-function isElementInViewport(element) {
-    const rect = element.getBoundingClientRect();
-    return rect.top < window.innerHeight && rect.bottom > 0 && rect.left < window.innerWidth && rect.right > 0;
-}
-/**
- * Scroll element into view
- * @param element - The element to scroll into view
- * @param options - Scroll behavior options
- */
-function scrollIntoView(element, options = {}) {
-    element.scrollIntoView(Object.assign({ behavior: 'smooth', block: 'nearest', inline: 'nearest' }, options));
-}
-/**
- * Get computed style value
- */
-function getComputedValue(element, property) {
-    return window.getComputedStyle(element).getPropertyValue(property);
-}
-/**
- * Wait for a specific time
- * @param ms - Time in milliseconds
- */
-function wait(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Wait for an element to appear in the DOM
- * @param selector - CSS selector to wait for
- * @param timeout - Timeout in milliseconds (default: 5000)
- */
-function waitForElement(selector, timeout = 5000) {
-    return new Promise((resolve, reject) => {
-        const element = document.querySelector(selector);
-        if (element) {
-            resolve(element);
-            return;
-        }
-        const observer = new MutationObserver(() => {
-            const el = document.querySelector(selector);
-            if (el) {
-                observer.disconnect();
-                resolve(el);
-            }
-        });
-        observer.observe(document.body, { childList: true, subtree: true });
-        setTimeout(() => {
-            observer.disconnect();
-            reject(new Error(`Element "${selector}" not found within ${timeout}ms`));
-        }, timeout);
-    });
-}
-/**
- * Clone an object deeply
- */
-function deepClone(obj) {
-    if (obj === null || typeof obj !== 'object')
-        return obj;
-    if (obj instanceof Date)
-        return new Date(obj.getTime());
-    if (obj instanceof Array)
-        return obj.map((item) => deepClone(item));
-    if (obj instanceof Object) {
-        const cloned = {};
-        Object.keys(obj).forEach((key) => {
-            cloned[key] = deepClone(obj[key]);
-        });
-        return cloned;
-    }
-    return obj;
-}
-/**
- * Merge objects
- */
-function mergeObjects(target, ...sources) {
-    return sources.reduce((result, source) => (Object.assign(Object.assign({}, result), source)), target);
-}
-/**
- * Get the prefixed CSS property name (for vendor prefixes)
- */
-function getPrefixedProperty(property) {
-    const element = document.createElement('div');
-    const style = element.style;
-    if (property in style)
-        return property;
-    if (`webkit${property[0].toUpperCase()}${property.slice(1)}` in style)
-        return `webkit${property[0].toUpperCase()}${property.slice(1)}`;
-    if (`moz${property[0].toUpperCase()}${property.slice(1)}` in style)
-        return `moz${property[0].toUpperCase()}${property.slice(1)}`;
-    if (`ms${property[0].toUpperCase()}${property.slice(1)}` in style)
-        return `ms${property[0].toUpperCase()}${property.slice(1)}`;
-    return property;
-}
-/**
- * Check if browser supports a CSS feature
- */
-function supportsCSSFeature(property, value) {
-    const element = document.createElement('div');
-    element.style.setProperty(property, value);
-    return element.style.getPropertyValue(property) !== '';
-}
-/**
- * Request animation frame with promise
- */
-function requestAnimationFramePromise() {
-    return new Promise((resolve) => requestAnimationFrame(resolve));
-}
-/**
- * Convert camelCase to kebab-case
- */
-function camelToKebab(str) {
-    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-}
-/**
- * Convert kebab-case to camelCase
- */
-function kebabToCamel(str) {
-    return str.replace(/-./g, (x) => x[1].toUpperCase());
-}
-/**
- * Check if an element has slotted content for a given slot name
- * @param el - The host element to check
- * @param name - The slot name to check for
- * @param checkTextContent - Whether to check text content for default slot (default: false)
- */
-function hasSlot(el, name, checkTextContent = false) {
-    var _a;
-    const slot = el.querySelector(`[slot="${name}"]`);
-    if (slot)
-        return true;
-    if (checkTextContent && name === 'default') {
-        return ((_a = el.textContent) === null || _a === void 0 ? void 0 : _a.trim()) !== '';
-    }
-    return false;
-}
-/**
- * Build a class string from a record of class names and their active states
- * @param classes - Object with class names as keys and boolean values for active state
- */
-function buildClassString(classes) {
-    return Object.entries(classes)
-        .filter(([, active]) => active)
-        .map(([name]) => name)
-        .join(' ');
-}
-
-/**
- * Accessibility Utilities
- * Provides helpers for ARIA attributes, keyboard navigation, and accessibility features
- */
-/**
- * Generate a unique ID for ARIA relationships
- * @param prefix - Optional prefix for the ID
- * @param suffix - Optional suffix for the ID
- */
-function generateAriaId(prefix = 'aria', suffix) {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substr(2, 9);
-    const finalSuffix = suffix ? `-${suffix}` : '';
-    return `${prefix}-${timestamp}-${random}${finalSuffix}`;
-}
-/**
- * Set ARIA attributes on an element
- * @param element - The element to set attributes on
- * @param attributes - Object with attribute names and values
- */
-function setAriaAttributes(element, attributes) {
-    Object.entries(attributes).forEach(([key, value]) => {
-        if (value === null || value === false) {
-            element.removeAttribute(`aria-${key}`);
-        }
-        else if (value === true) {
-            element.setAttribute(`aria-${key}`, 'true');
-        }
-        else {
-            element.setAttribute(`aria-${key}`, String(value));
-        }
-    });
-}
-/**
- * Add accessible label to an element
- * @param element - The element to label
- * @param label - The label text or element ID
- * @param useAriaLabel - If true, uses aria-label; if false, uses aria-labelledby
- */
-function addAriaLabel(element, label, useAriaLabel = true) {
-    if (useAriaLabel) {
-        element.setAttribute('aria-label', label);
-    }
-    else {
-        element.setAttribute('aria-labelledby', label);
-    }
-}
-/**
- * Add accessible description to an element
- * @param element - The element to describe
- * @param description - The description text or element ID
- * @param useAriaDescription - If true, uses aria-description; if false, uses aria-describedby
- */
-function addAriaDescription(element, description, useAriaDescription = false) {
-    if (useAriaDescription) {
-        element.setAttribute('aria-description', description);
-    }
-    else {
-        element.setAttribute('aria-describedby', description);
-    }
-}
-/**
- * Set ARIA live region announcement
- * @param element - The element to make a live region
- * @param message - The message to announce
- * @param politeness - 'polite' (default), 'assertive', or 'off'
- * @param atomic - Whether to announce the entire region
- */
-function announceAriaLive(element, message, politeness = 'polite', atomic = false) {
-    element.setAttribute('aria-live', politeness);
-    if (atomic) {
-        element.setAttribute('aria-atomic', 'true');
-    }
-    element.textContent = message;
-}
-/**
- * Mark an element as disabled with ARIA attributes
- * @param element - The element to mark as disabled
- * @param disabled - Whether the element is disabled
- */
-function setAriaDisabled(element, disabled) {
-    if (disabled) {
-        element.setAttribute('aria-disabled', 'true');
-        element.style.pointerEvents = 'none';
-        element.style.opacity = '0.5';
-    }
-    else {
-        element.removeAttribute('aria-disabled');
-        element.style.pointerEvents = '';
-        element.style.opacity = '';
-    }
-}
-/**
- * Mark an element as expanded/collapsed (for collapsible sections)
- * @param element - The element to mark
- * @param expanded - Whether the element is expanded
- * @param targetId - ID of the element being controlled (optional)
- */
-function setAriaExpanded(element, expanded, targetId) {
-    element.setAttribute('aria-expanded', expanded ? 'true' : 'false');
-    if (targetId) {
-        element.setAttribute('aria-controls', targetId);
-    }
-}
-/**
- * Mark an element as selected
- * @param element - The element to mark
- * @param selected - Whether the element is selected
- */
-function setAriaSelected(element, selected) {
-    element.setAttribute('aria-selected', selected ? 'true' : 'false');
-}
-/**
- * Mark an element as checked (for checkboxes and radio buttons)
- * @param element - The element to mark
- * @param checked - The checked state ('true', 'false', or 'mixed')
- */
-function setAriaChecked(element, checked) {
-    element.setAttribute('aria-checked', checked);
-}
-/**
- * Set the current value of an element (for sliders, spinbuttons, etc.)
- * @param element - The element
- * @param current - Current value
- * @param min - Minimum value
- * @param max - Maximum value
- * @param text - Optional text description of the value
- */
-function setAriaValueNow(element, current, min, max, text) {
-    element.setAttribute('aria-valuenow', String(current));
-    if (min !== undefined)
-        element.setAttribute('aria-valuemin', String(min));
-    if (max !== undefined)
-        element.setAttribute('aria-valuemax', String(max));
-    if (text !== undefined)
-        element.setAttribute('aria-valuetext', text);
-}
-/**
- * Mark an element as having a popup (for menus, popovers, etc.)
- * @param element - The element with the popup trigger
- * @param type - Type of popup: 'menu', 'listbox', 'tree', 'grid', 'dialog'
- * @param popupId - ID of the popup element
- */
-function setAriaPopup(element, type = 'menu', popupId) {
-    element.setAttribute('aria-haspopup', type);
-    if (popupId) {
-        element.setAttribute('aria-owns', popupId);
-    }
-}
-/**
- * Set role for an element
- * @param element - The element
- * @param role - The role (button, menu, menuitem, etc.)
- */
-function setRole(element, role) {
-    element.setAttribute('role', role);
-}
-/**
- * Get the accessible name of an element
- * Follows ARIA naming convention: aria-labelledby > aria-label > title > textContent
- */
-function getAccessibleName(element) {
-    // Check aria-labelledby
-    const labelledby = element.getAttribute('aria-labelledby');
-    if (labelledby) {
-        const labelElement = document.getElementById(labelledby);
-        if (labelElement)
-            return labelElement.textContent || '';
-    }
-    // Check aria-label
-    const ariaLabel = element.getAttribute('aria-label');
-    if (ariaLabel)
-        return ariaLabel;
-    // Check title
-    const title = element.getAttribute('title');
-    if (title)
-        return title;
-    // Fall back to textContent
-    return element.textContent || '';
-}
-/**
- * Create a skip link for keyboard navigation
- * @param text - Link text
- * @param targetId - ID of element to skip to
- */
-function createSkipLink(text, targetId) {
-    const link = document.createElement('a');
-    link.href = `#${targetId}`;
-    link.textContent = text;
-    link.className = 'sr-only'; // Visually hidden but accessible to screen readers
-    link.style.position = 'absolute';
-    link.style.top = '-9999px';
-    link.style.left = '-9999px';
-    // Show on focus
-    link.addEventListener('focus', () => {
-        link.style.top = '0';
-        link.style.left = '0';
-    });
-    // Hide on blur
-    link.addEventListener('blur', () => {
-        link.style.top = '-9999px';
-        link.style.left = '-9999px';
-    });
-    return link;
-}
-/**
- * Check if element should be hidden from screen readers
- */
-function isAriaHidden(element) {
-    return element.getAttribute('aria-hidden') === 'true';
-}
-/**
- * Hide element from screen readers but keep visually visible
- */
-function setAriaHidden(element, hidden) {
-    if (hidden) {
-        element.setAttribute('aria-hidden', 'true');
-    }
-    else {
-        element.removeAttribute('aria-hidden');
-    }
-}
-/**
- * Announce a message to screen readers immediately (without ARIA live regions)
- * @param message - The message to announce
- * @param politeness - 'polite' (default) or 'assertive'
- */
-function announceToScreenReader(message, politeness = 'polite') {
-    if (typeof document === 'undefined')
-        return;
-    const announcement = document.createElement('div');
-    announcement.setAttribute('aria-live', politeness);
-    announcement.setAttribute('aria-atomic', 'true');
-    announcement.className = 'sr-only';
-    announcement.style.position = 'absolute';
-    announcement.style.left = '-9999px';
-    announcement.style.top = '-9999px';
-    announcement.textContent = message;
-    document.body.appendChild(announcement);
-    // Remove after announcement is made
-    setTimeout(() => {
-        announcement.remove();
-    }, 1000);
-}
-/**
- * Set proper heading hierarchy
- * @param element - The heading element
- * @param level - Heading level (1-6)
- */
-function setHeadingLevel(element, level) {
-    const tag = `h${level}`;
-    if (element.tagName.toLowerCase() !== tag) {
-        // If element is not correct tag, set role as fallback
-        element.setAttribute('role', tag);
-    }
-}
-/**
- * Enable keyboard navigation for a custom component
- * @param element - The element that should handle keyboard
- * @param keys - Map of key to handler function
- */
-function enableKeyboardNavigation(element, keys) {
-    const handleKeyDown = (event) => {
-        const handler = keys[event.key.toLowerCase()];
-        if (handler) {
-            event.preventDefault();
-            handler(event);
-        }
-    };
-    element.addEventListener('keydown', handleKeyDown);
-    // Return cleanup function
-    return () => {
-        element.removeEventListener('keydown', handleKeyDown);
-    };
-}
-/**
- * Check if element has accessible focus styling
- */
-function hasAccessibleFocus(element) {
-    const styles = window.getComputedStyle(element);
-    return !!(styles.outline || styles.boxShadow || styles.border);
-}
-/**
- * Ensure focus visible styling (for focus-visible pseudo-class)
- */
-function ensureFocusVisible(element) {
-    if (!hasAccessibleFocus(element)) {
-        element.style.outline = '2px solid #4A90E2';
-        element.style.outlineOffset = '2px';
-    }
-}
-
-/**
- * SekiUI Type Definitions
- * Central export point for all type definitions across components and services
- */
-// ============================================================================
-// NOTE: Types from ./components/sidebar/types and ./utils/select/types
-// are already re-exported at the top of this file via the main index.ts
-// ============================================================================
-// ============================================================================
-// TYPE GUARDS AND UTILITY TYPES
-// ============================================================================
-/**
- * Type guard to check if a value is a valid sidebar variant
- */
-function isSidebarVariant(value) {
-    return ['sidebar', 'floating', 'inset'].includes(value);
-}
-/**
- * Type guard to check if a value is a valid collapse mode
- */
-function isCollapseMode(value) {
-    return ['offcanvas', 'icon', 'none'].includes(value);
-}
-/**
- * Type guard to check if a value is a valid button size
- */
-function isButtonSize(value) {
-    return ['sm', 'md', 'lg', 'icon-sm', 'icon', 'icon-lg'].includes(value);
-}
-/**
- * Type guard to check if a value is a valid button variant
- */
-function isButtonVariant(value) {
-    return ['primary', 'secondary', 'outline', 'ghost', 'destructive', 'link'].includes(value);
-}
-/**
- * Type guard to check if a value is a valid tooltip side
- */
-function isTooltipSide(value) {
-    return ['top', 'right', 'bottom', 'left'].includes(value);
-}
-
-globalScripts();
-
-export { DEFAULT_BREAKPOINTS, FocusService, KeyboardService, MediaQueryService, addAriaDescription, addAriaLabel, addClass, announceAriaLive, announceToScreenReader, buildClassString, camelToKebab, createFocusService, createKeyboardService, createMediaQueryService, createSkipLink, debounce, deepClone, dispatchCustomEvent, enableKeyboardNavigation, ensureFocusVisible, generateAriaId, generateUniqueId, getAccessibleName, getComputedValue, getDataAttribute, getDataAttributes, getElementOffset, getFocusService, getKeyboardService, getMediaQueryService, getPrefixedProperty, hasAccessibleFocus, hasClass, hasSlot, isAriaHidden, isButtonSize, isButtonVariant, isCollapseMode, isElementInViewport, isSidebarVariant, isTooltipSide, kebabToCamel, mergeObjects, onCustomEvent, removeClass, requestAnimationFramePromise, resetIdCounter, scrollIntoView, setAriaAttributes, setAriaChecked, setAriaDisabled, setAriaExpanded, setAriaHidden, setAriaPopup, setAriaSelected, setAriaValueNow, setDataAttribute, setHeadingLevel, setRole, supportsCSSFeature, throttle, toggleClass, wait, waitForElement };