@appius-fr/apx 2.5.0 → 2.6.0

package/dist/APX.dev.mjs

@@ -1480,9 +1480,25 @@ __webpack_require__.r(__webpack_exports__);
 // ESM-first, no side effects on import. DOM only when used.
 
 
+/**
+ * @typedef {Object} PositionObject
+ * @property {'sticky'|'relative'|'anchored'} [type]
+ * @property {string} [x]
+ * @property {string} [y]
+ * @property {HTMLElement} [element]
+ * @property {'top'|'right'|'bottom'|'left'|'above'|'below'|'before'|'after'} [placement]
+ * @property {string} [gap]
+ * @property {boolean} [useNativeCSS]
+ */
+
+/**
+ * @typedef {string|PositionObject} Position
+ */
+
 /**
  * @typedef {Object} ToastConfig
- * @property {'bottom-right'|'bottom-left'|'top-right'|'top-left'} [position]
+ * @property {Position} [position]
+ * @property {'up'|'down'|'auto'} [flow] Flow direction for stacking toasts. 'auto' determines based on position. Default: 'auto'
  * @property {number} [maxToasts]
  * @property {number} [defaultDurationMs]
  * @property {number} [zIndex]
@@ -1491,6 +1507,7 @@ __webpack_require__.r(__webpack_exports__);
  * @property {boolean} [dedupe]
  * @property {string} [containerClass]
  * @property {number} [offset]
+ * @property {string} [id]
  */
 
 /**
@@ -1503,6 +1520,8 @@ __webpack_require__.r(__webpack_exports__);
  * @property {(ref: ToastRef, ev: MouseEvent) => void} [onClick]
  * @property {(ref: ToastRef, reason: 'timeout'|'close'|'api'|'overflow') => void} [onClose]
  * @property {string} [className]
+ * @property {Position} [position]
+ * @property {'up'|'down'|'auto'} [flow] Flow direction for stacking toasts. 'auto' determines based on position. Default: 'auto'
  */
 
 /**
@@ -1518,6 +1537,42 @@ __webpack_require__.r(__webpack_exports__);
 
 const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
 
+// Shared container cache: Map<position, HTMLElement>
+// Containers are shared between managers with the same position
+const _containerCache = new Map();
+
+// Garbage collection: cleanup empty unmanaged containers after a delay
+const GC_DELAY_MS = 20000; // 20 seconds
+let _gcTimeoutId = null;
+
+// Wrapper for all toast containers (keeps DOM clean)
+let _toastWrapper = null;
+
+/**
+ * Get or create the toast containers wrapper
+ * @returns {HTMLElement|null}
+ */
+function getToastWrapper() {
+    if (!isBrowser) return null;
+    
+    if (!_toastWrapper) {
+        _toastWrapper = document.querySelector('.APX-toast-wrapper');
+        if (!_toastWrapper) {
+            _toastWrapper = createEl('div', 'APX-toast-wrapper');
+            _toastWrapper.style.position = 'fixed';
+            _toastWrapper.style.top = '0';
+            _toastWrapper.style.left = '0';
+            _toastWrapper.style.width = '0';
+            _toastWrapper.style.height = '0';
+            _toastWrapper.style.pointerEvents = 'none';
+            _toastWrapper.style.zIndex = '10000'; // Below containers but above most content
+            document.body.appendChild(_toastWrapper);
+        }
+    }
+    
+    return _toastWrapper;
+}
+
 const DEFAULT_CONFIG = {
     position: 'bottom-right',
     maxToasts: 5,
@@ -1541,6 +1596,206 @@ function createEl(tag, classNames) {
     return el;
 }
 
+/**
+ * Normalize placement synonyms to CSS values
+ * @param {string} placement
+ * @returns {'top'|'right'|'bottom'|'left'}
+ */
+function normalizePlacement(placement) {
+    const synonyms = {
+        'above': 'top',
+        'below': 'bottom',
+        'before': 'left',
+        'after': 'right'
+    };
+    return synonyms[placement] || placement;
+}
+
+/**
+ * Determine flow direction based on position
+ * @param {Position} position
+ * @returns {'up'|'down'}
+ */
+function determineFlow(position) {
+    if (typeof position === 'string') {
+        // String positions: top = up, bottom = down
+        if (position.includes('top')) return 'up';
+        if (position.includes('bottom')) return 'down';
+        return 'down'; // default
+    }
+    
+    if (typeof position === 'object' && position !== null) {
+        const type = position.type || (position.x || position.y ? 'sticky' : null);
+        
+        if (type === 'sticky' || (!type && (position.x || position.y))) {
+            // Sticky: determine based on y coordinate
+            if (position.y !== undefined) {
+                // If y starts with '-' or is a small value, likely top (up)
+                // If y is a large value or percentage, likely bottom (down)
+                if (position.y.startsWith('-')) {
+                    // Negative = from bottom, so flow down
+                    return 'down';
+                }
+                const num = parseFloat(position.y);
+                if (!isNaN(num)) {
+                    // If y < 50% of viewport height, likely top (up)
+                    // Otherwise likely bottom (down)
+                    if (position.y.includes('%')) {
+                        return num < 50 ? 'up' : 'down';
+                    }
+                    // For px values, assume < 400px is top (up)
+                    return num < 400 ? 'up' : 'down';
+                }
+            }
+            return 'down'; // default
+        }
+        
+        if (type === 'anchored' && position.placement) {
+            // Anchored: placement determines flow
+            const placement = normalizePlacement(position.placement);
+            if (placement === 'top' || placement === 'above') return 'up';
+            if (placement === 'bottom' || placement === 'below') return 'down';
+            // For left/right, default to down
+            return 'down';
+        }
+        
+        if (type === 'relative') {
+            // Relative: determine based on y offset
+            if (position.y !== undefined) {
+                const num = parseFloat(position.y);
+                if (!isNaN(num)) {
+                    // Negative y = above element = flow up
+                    // Positive y = below element = flow down
+                    return num < 0 ? 'up' : 'down';
+                }
+            }
+            return 'down'; // default
+        }
+    }
+    
+    return 'down'; // default
+}
+
+/**
+ * Garbage collection: remove empty unmanaged containers
+ */
+function cleanupEmptyContainers() {
+    if (!isBrowser) return;
+    
+    const containers = document.querySelectorAll('.APX-toast-container:not([data-apx-toast-managed="true"])');
+    containers.forEach(container => {
+        // Check if container is empty (no toasts)
+        if (container.children.length === 0) {
+            const positionKey = container.getAttribute('data-apx-toast-position');
+            if (positionKey) {
+                _containerCache.delete(positionKey);
+            }
+            container.remove();
+        }
+    });
+    
+    // Clean up wrapper if it's empty (all containers removed)
+    if (_toastWrapper && _toastWrapper.children.length === 0) {
+        _toastWrapper.remove();
+        _toastWrapper = null;
+    }
+    
+    _gcTimeoutId = null;
+}
+
+/**
+ * Schedule garbage collection for empty unmanaged containers
+ */
+function scheduleGarbageCollection() {
+    if (_gcTimeoutId) {
+        clearTimeout(_gcTimeoutId);
+    }
+    _gcTimeoutId = setTimeout(cleanupEmptyContainers, GC_DELAY_MS);
+}
+
+/**
+ * Find all scrollable parent elements
+ * @param {HTMLElement} element
+ * @returns {HTMLElement[]}
+ */
+function findScrollableParents(element) {
+    const scrollables = [];
+    let current = element.parentElement;
+    
+    while (current && current !== document.body && current !== document.documentElement) {
+        const style = window.getComputedStyle(current);
+        const overflow = style.overflow + style.overflowY + style.overflowX;
+        
+        if (overflow.includes('scroll') || overflow.includes('auto')) {
+            scrollables.push(current);
+        }
+        
+        current = current.parentElement;
+    }
+    
+    return scrollables;
+}
+
+/**
+ * Hash an element to create a unique identifier
+ * @param {HTMLElement} el
+ * @returns {string}
+ */
+function hashElement(el) {
+    const rect = el.getBoundingClientRect();
+    const str = `${el.tagName}_${rect.left}_${rect.top}_${rect.width}_${rect.height}`;
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash).toString(36);
+}
+
+/**
+ * Serialize position options into a unique key
+ * @param {Position} position
+ * @returns {string}
+ */
+function serializePosition(position) {
+    if (typeof position === 'string') {
+        return `s:${position}`;
+    }
+    
+    if (typeof position === 'object' && position !== null) {
+        const parts = [];
+        
+        // Type (default: sticky if x/y provided)
+        const type = position.type || (position.x || position.y ? 'sticky' : null);
+        if (type) parts.push(`t:${type}`);
+        
+        // Coordinates
+        if (position.x !== undefined) parts.push(`x:${position.x}`);
+        if (position.y !== undefined) parts.push(`y:${position.y}`);
+        
+        // For relative/anchored: use element ID or hash
+        if (position.element) {
+            const elementId = position.element.id || 
+                             position.element.dataset?.apxToastAnchorId ||
+                             `el_${hashElement(position.element)}`;
+            parts.push(`el:${elementId}`);
+        }
+        
+        if (position.placement) {
+            // Normalize placement for serialization (use CSS values)
+            const normalized = normalizePlacement(position.placement);
+            parts.push(`p:${normalized}`);
+        }
+        if (position.gap !== undefined) parts.push(`g:${position.gap}`);
+        if (position.useNativeCSS) parts.push(`native:true`);
+        
+        return `o:${parts.join('|')}`;
+    }
+    
+    return 's:bottom-right';
+}
+
 /**
  * ToastManager class
  */
@@ -1580,10 +1835,17 @@ class ToastManager {
             return ref;
         }
 
+        // Determine position and flow for this toast (options take precedence over config)
+        const position = options.position || this.config.position || 'bottom-right';
+        const flow = options.flow !== undefined ? options.flow : (this.config.flow !== undefined ? this.config.flow : 'auto');
+        const finalFlow = flow === 'auto' ? determineFlow(position) : flow;
+        
+        // Ensure default container is set (for backward compatibility)
         this.ensureContainer();
 
         const toastEl = createEl('div', `APX-toast APX-toast--${options.type}`);
         toastEl.setAttribute('role', 'status');
+        // Priority: options.id > config.id > auto-generated
         const toastId = options.id || `t_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
         toastEl.dataset.toastId = toastId;
         if (options.className) toastEl.className += ` ${options.className}`;
@@ -1604,7 +1866,171 @@ class ToastManager {
             toastEl.appendChild(closeBtn);
         }
 
-        this.container.appendChild(toastEl);
+        // Get or create container for this specific position
+        let container = null;
+        let positionUpdateFn = null;
+        let positionCleanup = null;
+        let originalElementStyle = null;
+        
+        if (position && typeof position === 'object' && position !== null) {
+            const type = position.type || (position.x || position.y ? 'sticky' : null);
+            
+            if (position.useNativeCSS && (type === 'relative' || type === 'anchored') && position.element) {
+                // useNativeCSS: true - create container in target element using native CSS
+                const targetEl = position.element;
+                originalElementStyle = targetEl.style.position;
+                targetEl.style.position = 'relative';
+                
+                // Create a container for stacking toasts (reuse if exists)
+                const positionKey = serializePosition(position);
+                let nativeContainer = targetEl.querySelector(`[data-apx-toast-position="${positionKey}"]`);
+                if (!nativeContainer) {
+                    nativeContainer = createEl('div', 'APX-toast-container APX-toast-container-native');
+                    nativeContainer.setAttribute('data-apx-toast-position', positionKey);
+                    nativeContainer.style.position = 'absolute';
+                    nativeContainer.style.zIndex = String(this.config.zIndex);
+                    nativeContainer.style.gap = `${this.config.gap}px`;
+                    nativeContainer.setAttribute('aria-live', String(this.config.ariaLive));
+                    nativeContainer.style.flexDirection = finalFlow === 'up' ? 'column-reverse' : 'column';
+                    
+                    // Apply positioning to container
+                    if (type === 'relative') {
+                        // Relative: use x/y directly
+                        if (position.x !== undefined) {
+                            if (position.x.startsWith('-')) {
+                                nativeContainer.style.right = position.x.substring(1);
+                            } else {
+                                nativeContainer.style.left = position.x;
+                            }
+                        }
+                        if (position.y !== undefined) {
+                            if (position.y.startsWith('-')) {
+                                nativeContainer.style.bottom = position.y.substring(1);
+                            } else {
+                                nativeContainer.style.top = position.y;
+                            }
+                        }
+                    } else if (type === 'anchored') {
+                        // Anchored: position outside the element using 100% (element size) + gap
+                        const placement = normalizePlacement(position.placement);
+                        const gap = position.gap || '1em';
+                        
+                        switch (placement) {
+                            case 'top':
+                                nativeContainer.style.bottom = `calc(100% + ${gap})`;
+                                nativeContainer.style.left = '0';
+                                break;
+                            case 'bottom':
+                                nativeContainer.style.top = `calc(100% + ${gap})`;
+                                nativeContainer.style.left = '0';
+                                break;
+                            case 'left':
+                                nativeContainer.style.right = `calc(100% + ${gap})`;
+                                nativeContainer.style.top = '0';
+                                break;
+                            case 'right':
+                                nativeContainer.style.left = `calc(100% + ${gap})`;
+                                nativeContainer.style.top = '0';
+                                break;
+                        }
+                    }
+                    
+                    targetEl.appendChild(nativeContainer);
+                } else {
+                    // Update flow direction if container exists
+                    nativeContainer.style.flexDirection = finalFlow === 'up' ? 'column-reverse' : 'column';
+                }
+                
+                container = nativeContainer;
+                
+                positionCleanup = () => {
+                    if (targetEl && targetEl.parentElement) {
+                        targetEl.style.position = originalElementStyle || '';
+                        // Remove native container if empty
+                        if (nativeContainer && nativeContainer.children.length === 0) {
+                            const positionKey = nativeContainer.getAttribute('data-apx-toast-position');
+                            if (positionKey) {
+                                _containerCache.delete(positionKey);
+                            }
+                            nativeContainer.remove();
+                        }
+                    }
+                };
+            } else {
+                // Default: get or create container for this position
+                container = this.getContainerForPosition(position, finalFlow);
+                
+                const updateContainerPosition = () => {
+                    const styles = this.calculatePosition(position, container);
+                    Object.assign(container.style, styles);
+                };
+                
+                updateContainerPosition();
+                
+                // For relative/anchored, listen to scroll/resize
+                if ((type === 'relative' || type === 'anchored') && position.element) {
+                    let rafId = null;
+                    let lastUpdate = 0;
+                    const throttleMs = 16; // ~60fps
+                    
+                    const throttledUpdate = () => {
+                        const now = Date.now();
+                        if (now - lastUpdate < throttleMs) {
+                            if (rafId) cancelAnimationFrame(rafId);
+                            rafId = requestAnimationFrame(() => {
+                                updateContainerPosition();
+                                lastUpdate = Date.now();
+                            });
+                        } else {
+                            updateContainerPosition();
+                            lastUpdate = now;
+                        }
+                    };
+                    
+                    // Find all scrollable parents
+                    const scrollableParents = findScrollableParents(position.element);
+                    
+                    // Listen to scroll on window and all scrollable parents
+                    window.addEventListener('scroll', throttledUpdate, { passive: true });
+                    window.addEventListener('resize', throttledUpdate, { passive: true });
+                    
+                    // Listen to scroll on all scrollable parent elements
+                    scrollableParents.forEach(parent => {
+                        parent.addEventListener('scroll', throttledUpdate, { passive: true });
+                    });
+                    
+                    // Watch for element removal
+                    const observer = new MutationObserver(() => {
+                        if (!position.element.parentElement) {
+                            ref.close('api');
+                        }
+                    });
+                    observer.observe(document.body, { childList: true, subtree: true });
+                    
+                    positionUpdateFn = updateContainerPosition;
+                    positionCleanup = () => {
+                        window.removeEventListener('scroll', throttledUpdate);
+                        window.removeEventListener('resize', throttledUpdate);
+                        scrollableParents.forEach(parent => {
+                            parent.removeEventListener('scroll', throttledUpdate);
+                        });
+                        observer.disconnect();
+                        if (rafId) cancelAnimationFrame(rafId);
+                    };
+                }
+            }
+        } else {
+            // String position - get or create container for this position
+            container = this.getContainerForPosition(position, finalFlow);
+        }
+        
+        // Append toast to the appropriate container
+        if (container) {
+            container.appendChild(toastEl);
+        } else {
+            // Fallback to default container
+            this.container.appendChild(toastEl);
+        }
 
         // Enter animation
         toastEl.classList.add('APX-toast--enter');
@@ -1680,6 +2106,13 @@ class ToastManager {
             const cleanup = (reason) => {
                 if (!toastEl) return;
                 pauseTimer();
+                
+                // Cleanup position listeners and restore styles
+                if (positionCleanup) {
+                    positionCleanup();
+                    positionCleanup = null;
+                }
+                
                 // If overflow, remove immediately to enforce hard cap
                 if (reason === 'overflow') {
                     if (toastEl.parentElement) toastEl.parentElement.removeChild(toastEl);
@@ -1700,6 +2133,10 @@ class ToastManager {
                     const idx = this.open.indexOf(ref);
                     if (idx >= 0) this.open.splice(idx, 1);
                     this.idToRef.delete(toastId);
+                    
+                    // Schedule garbage collection for unmanaged containers
+                    scheduleGarbageCollection();
+                    
                     finish(reason);
                 };
                 toastEl.addEventListener('transitionend', removeEl);
@@ -1758,37 +2195,251 @@ class ToastManager {
         if (!o.type) o.type = 'info';
         if (typeof o.dismissible !== 'boolean') o.dismissible = true;
         if (typeof o.durationMs !== 'number') o.durationMs = this.config.defaultDurationMs;
+        // Use id from options if provided, otherwise use id from config, otherwise undefined (will be auto-generated)
+        if (!o.id && this.config.id) o.id = this.config.id;
         return o;
     }
 
+    /**
+     * Find or create a container for a specific position
+     * @param {Position} position
+     * @param {'up'|'down'} [flow] Flow direction (already determined, not 'auto')
+     * @param {boolean} [managed] Whether this container is managed by a manager (default: false)
+     * @returns {HTMLElement|null}
+     */
+    getContainerForPosition(position, flow, managed = false) {
+        if (!isBrowser) return null;
+        
+        const positionKey = serializePosition(position);
+        
+        // Flow should already be determined ('up' or 'down'), but fallback to auto if needed
+        const finalFlow = flow && flow !== 'auto' ? flow : determineFlow(position);
+        
+        // 1. Check memory cache
+        let c = _containerCache.get(positionKey);
+        
+        // 2. If not in cache, search in DOM by data attribute
+        if (!c && isBrowser) {
+            c = document.querySelector(`[data-apx-toast-position="${positionKey}"]`);
+            if (c) {
+                _containerCache.set(positionKey, c);
+            }
+        }
+        
+        // 3. If still not found, create new container
+        if (!c) {
+            c = createEl('div', 'APX-toast-container');
+            c.setAttribute('data-apx-toast-position', positionKey);
+            
+            // Mark as managed if created by a manager
+            if (managed) {
+                c.setAttribute('data-apx-toast-managed', 'true');
+            }
+            
+            // Determine position class (for CSS)
+            const posClass = typeof position === 'string' 
+                ? position 
+                : (position.type || 'bottom-right');
+            c.classList.add(`APX-toast-container--${posClass}`);
+            c.setAttribute('aria-live', String(this.config.ariaLive));
+            c.style.zIndex = String(this.config.zIndex);
+            c.style.gap = `${this.config.gap}px`;
+            
+            // Apply flow direction
+            c.style.flexDirection = finalFlow === 'up' ? 'column-reverse' : 'column';
+            
+            // Apply position styles if object position
+            if (typeof position === 'object' && position !== null) {
+                c.style.position = 'fixed';
+                const styles = this.calculatePosition(position, c);
+                Object.assign(c.style, styles);
+            }
+            
+            // Append to wrapper for clean DOM organization
+            const wrapper = getToastWrapper();
+            if (wrapper) {
+                wrapper.appendChild(c);
+            } else {
+                document.body.appendChild(c);
+            }
+            _containerCache.set(positionKey, c);
+        } else {
+            // Update flow direction if container exists (may be shared)
+            c.style.flexDirection = finalFlow === 'up' ? 'column-reverse' : 'column';
+            
+            // If container exists and is now managed, mark it
+            if (managed && !c.hasAttribute('data-apx-toast-managed')) {
+                c.setAttribute('data-apx-toast-managed', 'true');
+            }
+        }
+        
+        return c;
+    }
+
     ensureContainer() {
         if (this.container || !isBrowser) return;
-        const c = createEl('div', 'APX-toast-container');
-        const pos = this.config.position || 'bottom-right';
-        c.classList.add(`APX-toast-container--${pos}`);
-        if (this.config.containerClass) c.classList.add(this.config.containerClass);
-        c.style.zIndex = String(this.config.zIndex);
-        c.style.gap = `${this.config.gap}px`;
-        if (this.config.offset) {
-            const offset = `${this.config.offset}px`;
-            if (pos.includes('bottom')) c.style.bottom = offset; else c.style.top = offset;
-            if (pos.includes('right')) c.style.right = offset; else c.style.left = offset;
-        }
-        c.setAttribute('aria-live', String(this.config.ariaLive));
-        document.body.appendChild(c);
-        this.container = c;
+        
+        const position = this.config.position || 'bottom-right';
+        const flow = this.config.flow !== undefined ? this.config.flow : 'auto';
+        // Containers created by ensureContainer are managed
+        this.container = this.getContainerForPosition(position, flow, true);
         this.applyContainerConfig();
     }
 
     applyContainerConfig() {
         if (!this.container) return;
+        const position = this.config.position || 'bottom-right';
+        const pos = typeof position === 'string' ? position : (position.type || 'bottom-right');
+        
+        // Apply styles (these may be overridden by other managers sharing the container)
         this.container.style.zIndex = String(this.config.zIndex);
         this.container.style.gap = `${this.config.gap}px`;
         this.container.setAttribute('aria-live', String(this.config.ariaLive));
-        // Update position class
-        const posClasses = ['bottom-right','bottom-left','top-right','top-left'].map(p => `APX-toast-container--${p}`);
-        this.container.classList.remove(...posClasses);
-        this.container.classList.add(`APX-toast-container--${this.config.position}`);
+        
+        // Update position class (only for string positions)
+        if (typeof position === 'string') {
+            const posClasses = ['bottom-right','bottom-left','top-right','top-left'].map(p => `APX-toast-container--${p}`);
+            this.container.classList.remove(...posClasses);
+            this.container.classList.add(`APX-toast-container--${pos}`);
+        }
+        
+        // Apply container class if specified
+        if (this.config.containerClass) {
+            this.config.containerClass.split(' ').filter(Boolean).forEach(cls => {
+                this.container.classList.add(cls);
+            });
+        }
+        
+        // Apply offset (only for string positions)
+        if (typeof position === 'string') {
+            if (this.config.offset) {
+                const offset = `${this.config.offset}px`;
+                if (pos.includes('bottom')) this.container.style.bottom = offset;
+                else this.container.style.top = offset;
+                if (pos.includes('right')) this.container.style.right = offset;
+                else this.container.style.left = offset;
+            } else {
+                // Reset offset if not specified
+                if (pos.includes('bottom')) this.container.style.bottom = '';
+                else this.container.style.top = '';
+                if (pos.includes('right')) this.container.style.right = '';
+                else this.container.style.left = '';
+            }
+        } else if (typeof position === 'object' && position !== null) {
+            // For object positions, ensure container has position: fixed
+            this.container.style.position = 'fixed';
+        }
+    }
+
+    /**
+     * Calculate position for a container based on position config
+     * @param {Position} position
+     * @param {HTMLElement} containerEl
+     * @returns {{left?: string, top?: string, right?: string, bottom?: string}}
+     */
+    calculatePosition(position, containerEl) {
+        if (typeof position === 'string') {
+            // String positions are handled by container CSS
+            return {};
+        }
+        
+        if (typeof position === 'object' && position !== null) {
+            const type = position.type || (position.x || position.y ? 'sticky' : null);
+            
+            if (type === 'sticky' || (!type && (position.x || position.y))) {
+                // Sticky: fixed position relative to viewport
+                const styles = {};
+                if (position.x !== undefined) {
+                    if (position.x.startsWith('-')) {
+                        styles.right = position.x.substring(1);
+                    } else {
+                        styles.left = position.x;
+                    }
+                }
+                if (position.y !== undefined) {
+                    if (position.y.startsWith('-')) {
+                        styles.bottom = position.y.substring(1);
+                    } else {
+                        styles.top = position.y;
+                    }
+                }
+                return styles;
+            }
+            
+            if (type === 'relative' && position.element) {
+                // Relative: position relative to element with x/y offset
+                // Use fixed positioning, so getBoundingClientRect() is relative to viewport
+                const rect = position.element.getBoundingClientRect();
+                
+                // Parse x/y offsets (can be px, em, etc.)
+                const parseOffset = (val) => {
+                    if (!val) return 0;
+                    const num = parseFloat(val);
+                    if (val.includes('em')) {
+                        // Convert em to px (approximate: 1em = 16px)
+                        return num * 16;
+                    }
+                    return num;
+                };
+                
+                const offsetX = parseOffset(position.x || '0');
+                const offsetY = parseOffset(position.y || '0');
+                
+                const styles = {
+                    left: `${rect.left + offsetX}px`,
+                    top: `${rect.top + offsetY}px`
+                };
+                return styles;
+            }
+            
+            if (type === 'anchored' && position.element) {
+                // Anchored: position relative to element with placement
+                const rect = position.element.getBoundingClientRect();
+                const gap = position.gap || '1em';
+                
+                // Parse gap (can be px, em, etc.)
+                const parseGap = (val) => {
+                    const num = parseFloat(val);
+                    if (val.includes('em')) {
+                        return num * 16; // Approximate: 1em = 16px
+                    }
+                    return num;
+                };
+                
+                const gapPx = parseGap(gap);
+                const styles = {};
+                
+                // Normalize placement synonyms (above/below/before/after) to CSS values
+                const placement = normalizePlacement(position.placement);
+                
+                switch (placement) {
+                    case 'top':
+                        // Toast above element: bottom of toast = top of element - gap
+                        // bottom = viewport height - (element top - gap) = viewport height - element top + gap
+                        styles.bottom = `${window.innerHeight - rect.top + gapPx}px`;
+                        styles.left = `${rect.left}px`;
+                        break;
+                    case 'bottom':
+                        // Toast below element: top of toast = bottom of element + gap
+                        styles.top = `${rect.bottom + gapPx}px`;
+                        styles.left = `${rect.left}px`;
+                        break;
+                    case 'left':
+                        // Toast to the left: right of toast = left of element - gap
+                        styles.right = `${window.innerWidth - rect.left + gapPx}px`;
+                        styles.top = `${rect.top}px`;
+                        break;
+                    case 'right':
+                        // Toast to the right: left of toast = right of element + gap
+                        styles.left = `${rect.right + gapPx}px`;
+                        styles.top = `${rect.top}px`;
+                        break;
+                }
+                return styles;
+            }
+        }
+        
+        return {};
     }
 }
 
@@ -1852,6 +2503,648 @@ Object.assign(toast, {
 
 
 
+/***/ }),
+
+/***/ "./modules/tools/exports.mjs":
+/*!***********************************!*\
+  !*** ./modules/tools/exports.mjs ***!
+  \***********************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   augmentWithPack: () => (/* reexport safe */ _form_packer_augment_apx_mjs__WEBPACK_IMPORTED_MODULE_0__["default"]),
+/* harmony export */   packFormToJSON: () => (/* reexport safe */ _form_packer_packToJson_mjs__WEBPACK_IMPORTED_MODULE_1__.packFormToJSON),
+/* harmony export */   tools: () => (/* binding */ tools)
+/* harmony export */ });
+/* harmony import */ var _form_packer_augment_apx_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./form-packer/augment-apx.mjs */ "./modules/tools/form-packer/augment-apx.mjs");
+/* harmony import */ var _form_packer_packToJson_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./form-packer/packToJson.mjs */ "./modules/tools/form-packer/packToJson.mjs");
+// Import des fonctions et modules des sous-modules
+
+
+
+// Export de la fonction d'augmentation
+
+
+// Export des fonctions utilitaires
+
+
+// Export d'un objet tools pour faciliter l'utilisation
+const tools = {
+    packFormToJSON: _form_packer_packToJson_mjs__WEBPACK_IMPORTED_MODULE_1__.packFormToJSON
+};
+
+
+
+
+/***/ }),
+
+/***/ "./modules/tools/form-packer/augment-apx.mjs":
+/*!***************************************************!*\
+  !*** ./modules/tools/form-packer/augment-apx.mjs ***!
+  \***************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _packToJson_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./packToJson.mjs */ "./modules/tools/form-packer/packToJson.mjs");
+
+
+/**
+ * Ajoute la méthode pack() aux objets APX pour convertir les formulaires en JSON
+ * @param {Object} apx - L'objet APX à augmenter
+ * @returns {Object} L'objet APX augmenté
+ */
+/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(apx) {
+    /**
+     * Convertit le premier formulaire sélectionné en objet JSON
+     * @returns {Object} L'objet JSON résultant
+     * @throws {Error} Si aucun formulaire n'est trouvé ou si le premier élément n'est pas un formulaire
+     * @example
+     * const data = APX('form.myformclass').pack();
+     */
+    apx.pack = function () {
+        const firstElement = this.first();
+        if (!firstElement) {
+            throw new Error('No element found');
+        }
+        if (firstElement.tagName !== 'FORM') {
+            throw new Error('Element is not a form');
+        }
+        return (0,_packToJson_mjs__WEBPACK_IMPORTED_MODULE_0__.packFormToJSON)(firstElement);
+    };
+    
+    return apx;
+}
+
+
+
+
+/***/ }),
+
+/***/ "./modules/tools/form-packer/packToJson.mjs":
+/*!**************************************************!*\
+  !*** ./modules/tools/form-packer/packToJson.mjs ***!
+  \**************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   packFormToJSON: () => (/* binding */ packFormToJSON)
+/* harmony export */ });
+/**
+ * Convertit un formulaire HTML en objet JSON
+ * @param {HTMLFormElement} form - Le formulaire à convertir
+ * @returns {Object} L'objet JSON résultant
+ * @throws {TypeError} Si form n'est pas un HTMLFormElement
+ */
+const packFormToJSON = (form) => {
+    // Validation de l'entrée
+    if (!form || !(form instanceof HTMLFormElement)) {
+        throw new TypeError('packFormToJSON expects an HTMLFormElement');
+    }
+
+    const formData = new FormData(form);
+    const jsonData = {};
+    
+    /**
+     * Construit une représentation string du chemin pour les messages d'erreur
+     * @param {Array} parts - Les parties du chemin
+     * @returns {string} Le chemin formaté
+     */
+    const buildPathString = (parts) => {
+        return parts.reduce((path, part) => {
+            if (part.type === 'key') {
+                return path ? `${path}[${part.name}]` : part.name;
+            }
+            if (part.type === 'numeric') {
+                return `${path}[${part.index}]`;
+            }
+            if (part.type === 'array') {
+                return `${path}[]`;
+            }
+            return path;
+        }, '');
+    };
+    
+    // ============================================================================
+    // PHASE 1 : ANALYSE ET DÉTECTION DES CONFLITS
+    // ============================================================================
+    
+    /**
+     * Structure pour stocker l'utilisation d'un chemin
+     * @typedef {Object} PathUsage
+     * @property {boolean} isFinal - Le chemin est utilisé comme valeur finale
+     * @property {boolean} isIntermediate - Le chemin est utilisé comme chemin intermédiaire
+     * @property {boolean} hasArraySuffix - Le chemin se termine par [] (crée des valeurs primitives)
+     * @property {string} key - La clé du formulaire qui utilise ce chemin
+     */
+    
+    const pathUsage = new Map(); // Map<pathString, PathUsage>
+    const keyAnalysis = new Map(); // Map<basePath, {hasNumeric: boolean, hasString: boolean}>
+    const allEntries = [];
+    
+    /**
+     * Enregistre l'utilisation d'un chemin dans pathUsage
+     * @param {string} currentPath - Le chemin à enregistrer
+     * @param {boolean} isFinal - Si c'est une valeur finale
+     * @param {boolean} isArraySuffix - Si le chemin se termine par []
+     * @param {string} key - La clé du formulaire
+     */
+    const recordPathUsage = (currentPath, isFinal, isArraySuffix, key) => {
+        const usage = pathUsage.get(currentPath) ?? {
+            isFinal: false,
+            isIntermediate: false,
+            hasArraySuffix: false,
+            key
+        };
+        
+        if (!pathUsage.has(currentPath)) {
+            pathUsage.set(currentPath, usage);
+        }
+        
+        if (isFinal) {
+            usage.isFinal = true;
+            usage.key = key;
+            if (isArraySuffix) {
+                usage.hasArraySuffix = true;
+            }
+        } else {
+            usage.isIntermediate = true;
+            usage.key ??= key;
+        }
+    };
+    
+    // Première passe : analyser toutes les clés et enregistrer les chemins
+    for (const [key, value] of formData.entries()) {
+        if (!key) continue;
+        
+        allEntries.push({ key, value });
+        const parts = parseKey(key);
+        
+        // Construire tous les chemins intermédiaires et le chemin final
+        let currentPath = '';
+        
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLast = i === parts.length - 1;
+            const isArraySuffix = part.type === 'array';
+            
+            // Construire le chemin jusqu'à ce niveau
+            if (part.type === 'key') {
+                currentPath = currentPath ? `${currentPath}[${part.name}]` : part.name;
+            } else if (part.type === 'numeric') {
+                currentPath = `${currentPath}[${part.index}]`;
+            } else if (part.type === 'array') {
+                currentPath = `${currentPath}[]`;
+            }
+            
+            // Enregistrer l'utilisation du chemin
+            recordPathUsage(currentPath, isLast, isArraySuffix && isLast, key);
+        }
+        
+        // Analyser chaque niveau de la hiérarchie pour détecter les conflits (indices numériques vs clés de chaîne)
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            const nextPart = parts[i + 1];
+            
+            // Analyser seulement les clés (pas les indices numériques)
+            if (part.type === 'key') {
+                const basePath = part.name; // Le nom de la première clé dans le chemin
+                
+                const analysis = keyAnalysis.get(basePath) ?? { hasNumeric: false, hasString: false };
+                if (!keyAnalysis.has(basePath)) {
+                    keyAnalysis.set(basePath, analysis);
+                }
+                
+                if (nextPart) {
+                    if (nextPart.type === 'numeric') {
+                        analysis.hasNumeric = true;
+                    } else if (nextPart.type === 'key' || nextPart.type === 'array') {
+                        analysis.hasString = true;
+                    }
+                }
+            }
+        }
+    }
+    
+    /**
+     * Détecte et lève une exception pour tous les conflits de chemins
+     * 
+     * Principe simple : pour chaque chemin final (valeur primitive), vérifier si un chemin
+     * intermédiaire commence par ce chemin suivi de '['. Si c'est le cas, c'est un conflit.
+     * 
+     * Cette approche unifiée couvre tous les cas :
+     * - items[] (final) vs items[0][name] (intermédiaire)
+     * - array[3] (final) vs array[3][nested] (intermédiaire)
+     * - data[key] (final) vs data[key][sub] (intermédiaire)
+     */
+    const detectPathConflicts = () => {
+        // 1. Collecter tous les chemins finaux (valeurs primitives)
+        const finalPaths = new Set();
+        const finalPathKeys = new Map(); // Pour les messages d'erreur
+        
+        for (const [path, usage] of pathUsage.entries()) {
+            if (usage.isFinal) {
+                finalPaths.add(path);
+                finalPathKeys.set(path, usage.key);
+            }
+        }
+        
+        // 2. Pour chaque chemin intermédiaire, vérifier s'il commence par un chemin final
+        for (const [path, usage] of pathUsage.entries()) {
+            if (usage.isIntermediate) {
+                for (const finalPath of finalPaths) {
+                    // Vérifier si ce chemin intermédiaire commence par un chemin final suivi de '['
+                    // Exemple: finalPath = "array[3]", path = "array[3][nested]" → conflit
+                    if (path.startsWith(`${finalPath}[`)) {
+                        throw new Error(
+                            `Path conflict: "${finalPath}" is used as a final value (in field "${finalPathKeys.get(finalPath)}"), ` +
+                            `but "${path}" tries to use it as an intermediate path (in field "${usage.key}"). ` +
+                            `This creates incompatible data structures. ` +
+                            `You cannot use "${finalPath}" as a primitive value and then access it as an object.`
+                        );
+                    }
+                }
+            }
+        }
+    };
+    
+    // Exécuter la détection des conflits
+    detectPathConflicts();
+
+    /**
+     * Vérifie si un chemin de base a un conflit (indices numériques ET clés de chaîne)
+     * @param {string} basePath - Le chemin de base à vérifier
+     * @returns {boolean}
+     */
+    const hasConflict = (basePath) => {
+        if (!basePath) return false;
+        const analysis = keyAnalysis.get(basePath);
+        return analysis?.hasNumeric && analysis?.hasString;
+    };
+
+    /**
+     * Convertit un tableau en objet en préservant les indices numériques comme propriétés
+     * @param {Array} arr - Le tableau à convertir
+     * @returns {Object} L'objet résultant
+     */
+    const arrayToObject = (arr) => {
+        const obj = {};
+        // Copier les indices numériques
+        for (let idx = 0; idx < arr.length; idx++) {
+            obj[idx] = arr[idx];
+        }
+        // Copier les propriétés non-numériques
+        for (const [k, v] of Object.entries(arr)) {
+            const numKey = Number.parseInt(k, 10);
+            if (Number.isNaN(numKey) || k !== String(numKey)) {
+                obj[k] = v;
+            }
+        }
+        return obj;
+    };
+
+    /**
+     * Convertit un objet en tableau en préservant les indices numériques
+     * @param {Object} obj - L'objet à convertir
+     * @returns {Array} Le tableau résultant
+     */
+    const objectToArray = (obj) => {
+        if (Array.isArray(obj)) return obj;
+        const arr = [];
+        if (typeof obj === 'object' && obj !== null) {
+            for (const [k, v] of Object.entries(obj)) {
+                const numKey = Number.parseInt(k, 10);
+                if (!Number.isNaN(numKey)) {
+                    arr[numKey] = v;
+                }
+            }
+        }
+        return arr;
+    };
+
+    /**
+     * Assure qu'un conteneur est un objet, en convertissant si nécessaire
+     * @param {*} container - Le conteneur à vérifier
+     * @param {string|null} key - La clé dans le conteneur parent
+     * @param {Object|null} parent - Le conteneur parent
+     * @param {boolean} forceObject - Forcer la conversion en objet même s'il n'y a pas de conflit
+     * @returns {Object} Le conteneur (converti en objet si nécessaire)
+     */
+    const ensureObject = (container, key, parent, forceObject = false) => {
+        if (Array.isArray(container)) {
+            const obj = arrayToObject(container);
+            if (parent && key !== null) {
+                parent[key] = obj;
+            }
+            return obj;
+        }
+        if (typeof container !== 'object' || container === null) {
+            const obj = {};
+            if (parent && key !== null) {
+                parent[key] = obj;
+            }
+            return obj;
+        }
+        return container;
+    };
+
+    /**
+     * Assure qu'un conteneur est un tableau, en convertissant si nécessaire
+     * @param {*} container - Le conteneur à vérifier
+     * @param {string|null} key - La clé dans le conteneur parent
+     * @param {Object|null} parent - Le conteneur parent
+     * @returns {Array} Le conteneur (converti en tableau si nécessaire)
+     */
+    const ensureArray = (container, key, parent) => {
+        if (!Array.isArray(container)) {
+            const arr = objectToArray(container);
+            if (parent && key !== null) {
+                parent[key] = arr;
+            }
+            return arr;
+        }
+        return container;
+    };
+
+    // ============================================================================
+    // PHASE 2 : TRAITEMENT DES VALEURS
+    // ============================================================================
+    
+    /**
+     * Traite une valeur finale (dernière partie du chemin)
+     * @param {*} container - Le conteneur actuel
+     * @param {Object} part - La partie à traiter
+     * @param {*} value - La valeur à assigner
+     * @param {Object} parent - Le conteneur parent
+     * @param {string} basePath - Le chemin de base pour la détection de conflit
+     */
+    const processFinalValue = (container, part, value, parent, basePath) => {
+        if (part.type === 'array') {
+            // Tableau explicite avec []
+            container[part.name] ??= [];
+            if (Array.isArray(container[part.name])) {
+                container[part.name].push(value);
+            } else {
+                container[part.name] = [container[part.name], value];
+            }
+        } else if (part.type === 'numeric') {
+            // Indice numérique final
+            const { index } = part;
+            container = ensureArray(container, parent.key, parent.container);
+            while (container.length <= index) {
+                container.push(undefined);
+            }
+            container[index] = value;
+        } else {
+            // Clé simple finale
+            const conflict = hasConflict(basePath);
+            
+            if (conflict) {
+                container = ensureObject(container, parent.key, parent.container, true);
+                if (Array.isArray(container[part.name])) {
+                    container[part.name] = arrayToObject(container[part.name]);
+                }
+                if (container[part.name] !== undefined && 
+                    (typeof container[part.name] !== 'object' || container[part.name] === null)) {
+                    container[part.name] = value;
+                } else if (container[part.name] === undefined) {
+                    container[part.name] = value;
+                } else if (Array.isArray(container[part.name])) {
+                    container[part.name].push(value);
+                } else {
+                    container[part.name] = [container[part.name], value];
+                }
+            } else {
+                if (container[part.name] === undefined) {
+                    container[part.name] = value;
+                } else if (Array.isArray(container[part.name])) {
+                    container[part.name].push(value);
+                } else {
+                    container[part.name] = [container[part.name], value];
+                }
+            }
+        }
+    };
+    
+    /**
+     * Traite une partie intermédiaire (crée la structure)
+     * @param {*} container - Le conteneur actuel
+     * @param {Object} part - La partie à traiter
+     * @param {Object|null} nextPart - La partie suivante (peut être null)
+     * @param {Object} parent - Le conteneur parent
+     * @param {string} basePath - Le chemin de base pour la détection de conflit
+     * @param {Array} parts - Toutes les parties du chemin (pour construire le chemin complet dans les erreurs)
+     * @param {number} i - L'index de la partie actuelle (pour construire le chemin complet dans les erreurs)
+     * @param {string} key - La clé du formulaire (pour les messages d'erreur)
+     * @returns {*} Le nouveau conteneur après traitement
+     */
+    const processIntermediatePart = (container, part, nextPart, parent, basePath, parts, i, key) => {
+        if (part.type === 'numeric') {
+            // Indice numérique : le container doit être un tableau ou un objet (selon conflit)
+            const { index } = part;
+            const conflict = hasConflict(basePath);
+            
+            if (conflict) {
+                // Conflit : utiliser un objet (les indices seront des propriétés)
+                container = ensureObject(container, parent.key, parent.container, true);
+                container[index] ??= {};
+                if (typeof container[index] !== 'object' || container[index] === null) {
+                    // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+                    const pathParts = parts.slice(0, i + 1);
+                    const currentPath = buildPathString(pathParts);
+                    throw new Error(
+                        `Cannot access property on primitive value. ` +
+                        `Key "${key}" tries to access "${currentPath}" but it is already a ${typeof container[index]} value: ${JSON.stringify(container[index])}. ` +
+                        `This should have been detected during conflict detection phase.`
+                    );
+                }
+            } else {
+                // Pas de conflit : utiliser un tableau
+                container = ensureArray(container, parent.key, parent.container);
+                while (container.length <= index) {
+                    container.push(undefined);
+                }
+                container[index] ??= {};
+                if (typeof container[index] !== 'object' || container[index] === null) {
+                    // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+                    const pathParts = parts.slice(0, i + 1);
+                    const currentPath = buildPathString(pathParts);
+                    throw new Error(
+                        `Cannot access property on primitive value. ` +
+                        `Key "${key}" tries to access "${currentPath}" but it is already a ${typeof container[index]} value: ${JSON.stringify(container[index])}. ` +
+                        `This should have been detected during conflict detection phase.`
+                    );
+                }
+            }
+            return container[index];
+        }
+        
+        // Clé normale : créer objet ou tableau selon la partie suivante
+        const nextIsNumeric = nextPart?.type === 'numeric';
+        const conflict = hasConflict(basePath);
+        
+        if (conflict) {
+            // Conflit : toujours utiliser un objet
+            container = ensureObject(container, parent.key, parent.container, true);
+            container[part.name] ??= {};
+            if (Array.isArray(container[part.name])) {
+                container[part.name] = arrayToObject(container[part.name]);
+            } else if (typeof container[part.name] !== 'object' || container[part.name] === null) {
+                // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+                const pathParts = parts.slice(0, i + 1);
+                const currentPath = buildPathString(pathParts);
+                throw new Error(
+                    `Cannot access property on primitive value. ` +
+                    `Key "${key}" tries to access "${currentPath}" but it is already a ${typeof container[part.name]} value: ${JSON.stringify(container[part.name])}. ` +
+                    `This should have been detected during conflict detection phase.`
+                );
+            }
+        } else if (container[part.name] === undefined) {
+            // Pas de conflit, créer selon la partie suivante
+            container[part.name] = nextIsNumeric ? [] : {};
+        } else if (nextIsNumeric && !Array.isArray(container[part.name])) {
+            // On a besoin d'un tableau mais c'est un objet
+            const hasStringKeys = Object.keys(container[part.name]).some(k => {
+                const numKey = Number.parseInt(k, 10);
+                return Number.isNaN(numKey) || k !== String(numKey);
+            });
+            if (!hasStringKeys) {
+                container[part.name] = objectToArray(container[part.name]);
+            }
+        } else if (!nextIsNumeric && !isPlainObject(container[part.name])) {
+            // On a besoin d'un objet mais c'est un tableau
+            if (Array.isArray(container[part.name])) {
+                container[part.name] = arrayToObject(container[part.name]);
+            } else {
+                container[part.name] = {};
+            }
+        }
+        
+        // S'assurer que container[part.name] est bien un objet après toutes les conversions
+        if (container[part.name] !== undefined && 
+            (typeof container[part.name] !== 'object' || container[part.name] === null)) {
+            // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+            const pathParts = parts.slice(0, i + 1);
+            const currentPath = buildPathString(pathParts);
+            throw new Error(
+                `Cannot access property on primitive value. ` +
+                `Key "${key}" tries to access "${currentPath}" but it is already a ${typeof container[part.name]} value: ${JSON.stringify(container[part.name])}. ` +
+                `This should have been detected during conflict detection phase.`
+            );
+        }
+        return container[part.name];
+    };
+    
+    // Traiter toutes les entrées
+    for (const { value, key } of allEntries) {
+        if (!key) continue;
+
+        const parts = parseKey(key);
+        const path = [{ container: jsonData, key: null }];
+        let container = jsonData;
+        const basePath = parts[0]?.type === 'key' ? parts[0].name : '';
+
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLast = i === parts.length - 1;
+            const nextPart = i + 1 < parts.length ? parts[i + 1] : null;
+            const parent = path[path.length - 1];
+
+            if (isLast) {
+                // Dernière partie : assigner la valeur
+                processFinalValue(container, part, value, parent, basePath);
+            } else {
+                // Partie intermédiaire : créer la structure
+                const newContainer = processIntermediatePart(container, part, nextPart, parent, basePath, parts, i, key);
+                path.push({ container, key: part.type === 'numeric' ? part.index : part.name });
+                container = newContainer;
+            }
+        }
+    }
+
+    return jsonData;
+};
+
+/**
+ * Parse une clé de formulaire pour extraire les parties (nom, indices, etc.)
+ * @param {string} key - La clé à parser (ex: "user[email]", "tags[]", "items[0][name]")
+ * @returns {Array<{name: string, type: string, index?: number}>} Tableau des parties parsées
+ * @private
+ */
+const parseKey = (key) => {
+    const parts = [];
+    let current = '';
+    let i = 0;
+    const len = key.length;
+
+    while (i < len) {
+        const char = key[i];
+        
+        if (char === '[') {
+            // Sauvegarder la partie précédente si elle existe
+            if (current) {
+                parts.push({ name: current, type: 'key' });
+                current = '';
+            }
+            
+            // Trouver la fin du crochet
+            i++;
+            let bracketContent = '';
+            while (i < len && key[i] !== ']') {
+                bracketContent += key[i];
+                i++;
+            }
+            
+            if (bracketContent === '') {
+                // [] vide = tableau
+                const lastPart = parts[parts.length - 1];
+                if (lastPart) {
+                    lastPart.type = 'array';
+                } else {
+                    // [] au début, créer une partie spéciale
+                    parts.push({ name: '', type: 'array' });
+                }
+            } else {
+                // Contenu dans les crochets
+                const numIndex = Number.parseInt(bracketContent, 10);
+                if (!Number.isNaN(numIndex) && bracketContent === String(numIndex)) {
+                    // Indice numérique
+                    parts.push({ name: String(numIndex), type: 'numeric', index: numIndex });
+                } else {
+                    // Nom de propriété
+                    parts.push({ name: bracketContent, type: 'key' });
+                }
+            }
+            i++; // Passer le ']'
+        } else {
+            current += char;
+            i++;
+        }
+    }
+    
+    // Ajouter la dernière partie si elle existe
+    if (current) {
+        parts.push({ name: current, type: 'key' });
+    }
+    
+    return parts;
+};
+
+/**
+ * Vérifie si une valeur est un objet simple (pas un tableau, pas null)
+ * @param {*} obj - La valeur à vérifier
+ * @returns {boolean}
+ * @private
+ */
+const isPlainObject = (obj) => {
+    return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+};
+
+
 /***/ }),
 
 /***/ "./modules/tristate/tristate.mjs":
@@ -2157,128 +3450,132 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _modules_dialog_dialog_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./modules/dialog/dialog.mjs */ "./modules/dialog/dialog.mjs");
 /* harmony import */ var _modules_toast_toast_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./modules/toast/toast.mjs */ "./modules/toast/toast.mjs");
 /* harmony import */ var _modules_common_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./modules/common.mjs */ "./modules/common.mjs");
-
-
-
-
-
-
-/**
- * Creates an APX object that wraps one or more HTML elements.
- * @param {string|HTMLElement|NodeList|HTMLCollection|Array<HTMLElement>|jQuery|Function} input - The input to create the APX object from.
- * @returns {Object} The APX object.
- * @throws {Error} If the input type is invalid.
- * @example
- * // XPath
- * const apx1 = APX('//div[@class="example"]');
- *
- * // CSS selector
- * const apx2 = APX('.example');
- *
- * // Single element
- * const element = document.querySelector('.example');
- * const apx3 = APX(element);
- *
- * // NodeList or HTMLCollection
- * const nodeList = document.querySelectorAll('.example');
- * const apx4 = APX(nodeList);
- *
- * // Array of elements
- * const elements = [document.querySelector('.example1'), document.querySelector('.example2')];
- * const apx5 = APX(elements);
- *
- * // jQuery object
- * const $example = $('.example');
- * const apx6 = APX($example);
- *
- * // Function returning an APX object
- * const apx7 = APX(() => APX('.example'));
- */
-const APX = function (input, context = document) {
-    let elements;
-
-    // Validate context
-    if (typeof context === 'string') {
-        context = document.querySelector(context);
-    }
-    else if (APX.isAPXObject(context)) {
-        context = context.first();
-    } else if (!(context instanceof HTMLElement || context instanceof Document)) {
-        throw new Error('Invalid context for APX');
-    }
-
-    if (typeof input === 'string' && input.startsWith('//')) {
-        // XPath with context
-        elements = document.evaluate(input, context, null, XPathResult.ANY_TYPE, null);
-        let nodes = [];
-        let node = elements.iterateNext();
-        while (node) {
-            nodes.push(node);
-            node = elements.iterateNext();
-        }
-        elements = nodes;
-    } else if (typeof input === 'string') {
-        // CSS selector with context
-        elements = context.querySelectorAll(input);
-    } else if (input instanceof HTMLElement) {
-        // Single element within context
-        elements = context.contains(input) ? [input] : [];
-    } else if (input instanceof NodeList || input instanceof HTMLCollection) {
-        // NodeList or HTMLCollection within context
-        elements = Array.from(input).filter(el => context.contains(el));
-    } else if (Array.isArray(input) && input.every(el => el instanceof HTMLElement)) {
-        // Array of elements within context
-        elements = input.filter(el => context.contains(el));
-    } else if (typeof jQuery != 'undefined' && input instanceof jQuery) {
-        // jQuery object within context
-        elements = Array.from(input.get()).filter(el => context.contains(el));
-    } else if (typeof input === 'function') {
-        // Function returning an APX object with context
-        elements = APX(input(), context);
-    } else {
-        throw new Error('Invalid input type for APX');
-    }
-
-    var apx = {
-        elements: elements,
-        _isAPXObject: true
-    };
-    apx.length = elements.length;
-    apx.each = function (callback) {
-        if (this.elements instanceof Array) this.elements.forEach(callback);
-        if (this.elements instanceof NodeList) Array.from(this.elements).forEach(callback);
-        return this;
-    };
-    apx.get = function (index) {
-        return this.elements[index];
-    };
-    apx.all = function () {
-        if (this.elements instanceof Array) return this.elements;
-        if (this.elements instanceof NodeList) return Array.from(this.elements);
-        return this;
-    };
-    apx.first = function () {
-        return this.get(0);
-    };
-    (0,_modules_listen_listen_mjs__WEBPACK_IMPORTED_MODULE_0__["default"])(apx);
-    (0,_modules_tristate_tristate_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(apx);
-    return apx;
-};
-
-APX.loadCss = _modules_common_mjs__WEBPACK_IMPORTED_MODULE_4__.loadCss;
-APX.dialog = _modules_dialog_dialog_mjs__WEBPACK_IMPORTED_MODULE_2__["default"];
-APX.toast = _modules_toast_toast_mjs__WEBPACK_IMPORTED_MODULE_3__["default"];
-APX.isAPXObject = function (obj) {
-    return obj && obj._isAPXObject === true;
-}
-APX.is_numeric = (n) => {
-    return !isNaN(n - parseFloat(n));
-}
-
+/* harmony import */ var _modules_tools_exports_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./modules/tools/exports.mjs */ "./modules/tools/exports.mjs");
+
+
+
+
+
+
+
+/**
+ * Creates an APX object that wraps one or more HTML elements.
+ * @param {string|HTMLElement|NodeList|HTMLCollection|Array<HTMLElement>|jQuery|Function} input - The input to create the APX object from.
+ * @returns {Object} The APX object.
+ * @throws {Error} If the input type is invalid.
+ * @example
+ * // XPath
+ * const apx1 = APX('//div[@class="example"]');
+ *
+ * // CSS selector
+ * const apx2 = APX('.example');
+ *
+ * // Single element
+ * const element = document.querySelector('.example');
+ * const apx3 = APX(element);
+ *
+ * // NodeList or HTMLCollection
+ * const nodeList = document.querySelectorAll('.example');
+ * const apx4 = APX(nodeList);
+ *
+ * // Array of elements
+ * const elements = [document.querySelector('.example1'), document.querySelector('.example2')];
+ * const apx5 = APX(elements);
+ *
+ * // jQuery object
+ * const $example = $('.example');
+ * const apx6 = APX($example);
+ *
+ * // Function returning an APX object
+ * const apx7 = APX(() => APX('.example'));
+ */
+const APX = function (input, context = document) {
+    let elements;
+
+    // Validate context
+    if (typeof context === 'string') {
+        context = document.querySelector(context);
+    }
+    else if (APX.isAPXObject(context)) {
+        context = context.first();
+    } else if (!(context instanceof HTMLElement || context instanceof Document)) {
+        throw new Error('Invalid context for APX');
+    }
+
+    if (typeof input === 'string' && input.startsWith('//')) {
+        // XPath with context
+        elements = document.evaluate(input, context, null, XPathResult.ANY_TYPE, null);
+        let nodes = [];
+        let node = elements.iterateNext();
+        while (node) {
+            nodes.push(node);
+            node = elements.iterateNext();
+        }
+        elements = nodes;
+    } else if (typeof input === 'string') {
+        // CSS selector with context
+        elements = context.querySelectorAll(input);
+    } else if (input instanceof HTMLElement) {
+        // Single element within context
+        elements = context.contains(input) ? [input] : [];
+    } else if (input instanceof NodeList || input instanceof HTMLCollection) {
+        // NodeList or HTMLCollection within context
+        elements = Array.from(input).filter(el => context.contains(el));
+    } else if (Array.isArray(input) && input.every(el => el instanceof HTMLElement)) {
+        // Array of elements within context
+        elements = input.filter(el => context.contains(el));
+    } else if (typeof jQuery != 'undefined' && input instanceof jQuery) {
+        // jQuery object within context
+        elements = Array.from(input.get()).filter(el => context.contains(el));
+    } else if (typeof input === 'function') {
+        // Function returning an APX object with context
+        elements = APX(input(), context);
+    } else {
+        throw new Error('Invalid input type for APX');
+    }
+
+    var apx = {
+        elements: elements,
+        _isAPXObject: true
+    };
+    apx.length = elements.length;
+    apx.each = function (callback) {
+        if (this.elements instanceof Array) this.elements.forEach(callback);
+        if (this.elements instanceof NodeList) Array.from(this.elements).forEach(callback);
+        return this;
+    };
+    apx.get = function (index) {
+        return this.elements[index];
+    };
+    apx.all = function () {
+        if (this.elements instanceof Array) return this.elements;
+        if (this.elements instanceof NodeList) return Array.from(this.elements);
+        return this;
+    };
+    apx.first = function () {
+        return this.get(0);
+    };
+    (0,_modules_listen_listen_mjs__WEBPACK_IMPORTED_MODULE_0__["default"])(apx);
+    (0,_modules_tristate_tristate_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(apx);
+    (0,_modules_tools_exports_mjs__WEBPACK_IMPORTED_MODULE_5__.augmentWithPack)(apx);
+    return apx;
+};
+
+APX.loadCss = _modules_common_mjs__WEBPACK_IMPORTED_MODULE_4__.loadCss;
+APX.dialog = _modules_dialog_dialog_mjs__WEBPACK_IMPORTED_MODULE_2__["default"];
+APX.toast = _modules_toast_toast_mjs__WEBPACK_IMPORTED_MODULE_3__["default"];
+APX.tools = _modules_tools_exports_mjs__WEBPACK_IMPORTED_MODULE_5__.tools;
+APX.isAPXObject = function (obj) {
+    return obj && obj._isAPXObject === true;
+}
+APX.is_numeric = (n) => {
+    return !isNaN(n - parseFloat(n));
+}
+
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (APX);
 })();
 
 var __webpack_exports__default = __webpack_exports__["default"];
 export { __webpack_exports__default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"APX.dev.mjs","mappings":";;;;;;;;;;;;;;;;AAAA;AACgH;AACjB;AAC/F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,WAAW;AACX;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,uGAAuG,MAAM,UAAU,UAAU,UAAU,UAAU,UAAU,UAAU,UAAU,UAAU,YAAY,aAAa,OAAO,KAAK,YAAY,WAAW,UAAU,UAAU,YAAY,WAAW,UAAU,YAAY,aAAa,aAAa,OAAO,KAAK,UAAU,OAAO,KAAK,UAAU,UAAU,UAAU,YAAY,aAAa,aAAa,OAAO,MAAM,UAAU,YAAY,WAAW,OAAO,YAAY,SAAS,UAAU,UAAU,YAAY,aAAa,aAAa,aAAa,WAAW,YAAY,aAAa,OAAO,QAAQ,YAAY,aAAa,WAAW,OAAO,YAAY,MAAM,YAAY,aAAa,WAAW,UAAU,YAAY,aAAa,WAAW,UAAU,YAAY,aAAa,OAAO,KAAK,YAAY,aAAa,aAAa,OAAO,KAAK,UAAU,UAAU,UAAU,YAAY,OAAO,YAAY,MAAM,UAAU,YAAY,aAAa,WAAW,UAAU,MAAM,KAAK,UAAU,UAAU,UAAU,YAAY,aAAa,aAAa,aAAa,OAAO,KAAK,sBAAsB,uBAAuB,MAAM,KAAK,UAAU,YAAY,yBAAyB,aAAa,aAAa,aAAa,OAAO,KAAK,wBAAwB,aAAa,OAAO,YAAY,MAAM,UAAU,YAAY,WAAW,UAAU,UAAU,UAAU,YAAY,aAAa,+DAA+D,sBAAsB,wBAAwB,sBAAsB,gBAAgB,eAAe,oBAAoB,qBAAqB,uBAAuB,6CAA6C,wDAAwD,6BAA6B,kCAAkC,sBAAsB,qBAAqB,oBAAoB,yBAAyB,uBAAuB,qBAAqB,2BAA2B,oDAAoD,yDAAyD,KAAK,4BAA4B,qBAAqB,KAAK,2BAA2B,oBAAoB,qBAAqB,wBAAwB,0BAA0B,4DAA4D,KAAK,6DAA6D,oBAAoB,iEAAiE,KAAK,mOAAmO,oBAAoB,sBAAsB,4BAA4B,+BAA+B,2BAA2B,yDAAyD,wBAAwB,+BAA+B,sCAAsC,KAAK,6NAA6N,8BAA8B,mDAAmD,KAAK,2EAA2E,2BAA2B,kCAAkC,uBAAuB,qBAAqB,2BAA2B,2BAA2B,wBAAwB,wBAAwB,kCAAkC,iDAAiD,KAAK,mDAAmD,kCAAkC,oCAAoC,kDAAkD,KAAK,sCAAsC,sBAAsB,kBAAkB,uBAAuB,0CAA0C,kEAAkE,sBAAsB,gCAAgC,4BAA4B,sBAAsB,oBAAoB,KAAK,+CAA+C,oBAAoB,oBAAoB,qBAAqB,kCAAkC,sCAAsC,2BAA2B,sDAAsD,KAAK,oCAAoC,aAAa,0BAA0B,eAAe,4BAA4B,KAAK,iCAAiC,qBAAqB,uCAAuC,8CAA8C,0DAA0D,kCAAkC,mCAAmC,KAAK,2CAA2C,8CAA8C,2DAA2D,KAAK,uFAAuF,oBAAoB,2BAA2B,iBAAiB,gBAAgB,oBAAoB,oBAAoB,6CAA6C,iCAAiC,KAAK,mBAAmB;AAC3qK;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACzJvC;AACgH;AACjB;AAC/F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,aAAa,cAAc;AAChE,oCAAoC,YAAY,cAAc;AAC9D,kCAAkC,aAAa,WAAW;AAC1D,iCAAiC,YAAY,WAAW;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,+CAA+C;AAClE,sBAAsB,kDAAkD;AACxE,sBAAsB,kDAAkD;AACxE,qBAAqB,iDAAiD;AACtE;AACA,sBAAsB;AACtB;AACA;AACA;AACA,cAAc;AACd,iBAAiB;AACjB;AACA,0BAA0B,qBAAqB;AAC/C,6BAA6B;AAC7B,eAAe,oBAAoB,YAAY;AAC/C,qBAAqB,kBAAkB;AACvC,kBAAkB;AAClB;AACA,0BAA0B;AAC1B,0BAA0B,mCAAmC;AAC7D;AACA;AACA,qBAAqB,gBAAgB;AACrC;AACA;AACA;AACA,oBAAoB,YAAY;AAChC,4CAA4C,YAAY;AACxD,mBAAmB,YAAY;AAC/B,0CAA0C,YAAY;AACtD;AACA;AACA,OAAO,8FAA8F,UAAU,UAAU,YAAY,aAAa,aAAa,aAAa,OAAO,4CAA4C,6CAA6C,6CAA6C,8CAA8C,MAAM,YAAY,aAAa,aAAa,aAAa,aAAa,aAAa,WAAW,YAAY,aAAa,aAAa,aAAa,OAAO,oCAAoC,qCAAqC,qCAAqC,sCAAsC,0BAA0B,MAAM,YAAY,qBAAqB,qBAAqB,aAAa,qCAAqC,yBAAyB,2CAA2C,mCAAmC,uBAAuB,MAAM,sBAAsB,qCAAqC,MAAM,UAAU,gCAAgC,OAAO,UAAU,kCAAkC,mCAAmC,mCAAmC,6EAA6E,wBAAwB,sBAAsB,+BAA+B,uCAAuC,iDAAiD,6BAA6B,KAAK,6CAA6C,aAAa,cAAc,wBAAwB,wCAAwC,YAAY,cAAc,0BAA0B,sCAAsC,aAAa,WAAW,wBAAwB,qCAAqC,YAAY,WAAW,0BAA0B,oBAAoB,qDAAqD,qDAAqD,oDAAoD,oDAAoD,wEAAwE,+DAA+D,oBAAoB,yBAAyB,6BAA6B,2BAA2B,6DAA6D,KAAK,2BAA2B,+CAA+C,2CAA2C,0BAA0B,kDAAkD,8CAA8C,0BAA0B,kDAAkD,8CAA8C,yBAAyB,iDAAiD,6CAA6C,8BAA8B,oBAAoB,2BAA2B,2BAA2B,kBAAkB,YAAY,qBAAqB,aAAa,oCAAoC,8BAA8B,qBAAqB,wBAAwB,iCAAiC,oBAAoB,mBAAmB,oBAAoB,YAAY,UAAU,yBAAyB,kBAAkB,yBAAyB,sBAAsB,+BAA+B,KAAK,8BAA8B,aAAa,8BAA8B,mCAAmC,sBAAsB,+BAA+B,qBAAqB,yBAAyB,gBAAgB,mBAAmB,KAAK,gDAAgD,YAAY,6BAA6B,gDAAgD,YAAY,2BAA2B,uBAAuB,YAAY,2BAA2B,8CAA8C,YAAY,6BAA6B,+BAA+B;AACr1H;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;;;ACnEvC;AACgH;AACjB;AACO;AACtG,4CAA4C,ysCAAmlB;AAC/nB,4CAA4C,i/BAAue;AACnhB,4CAA4C,mwCAAgnB;AAC5pB,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F,yCAAyC,sFAA+B;AACxE,yCAAyC,sFAA+B;AACxE,yCAAyC,sFAA+B;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,mCAAmC;AAC/D;AACA;AACA,4BAA4B,mCAAmC;AAC/D;AACA;AACA;AACA;AACA,4BAA4B,mCAAmC;AAC/D;AACA;AACA,CAAC,OAAO,oGAAoG,YAAY,aAAa,aAAa,WAAW,YAAY,WAAW,UAAU,YAAY,aAAa,aAAa,MAAM,KAAK,aAAa,OAAO,KAAK,YAAY,aAAa,aAAa,MAAM,KAAK,aAAa,cAAc,aAAa,yCAAyC,8BAA8B,+BAA+B,2BAA2B,wBAAwB,2BAA2B,uBAAuB,wBAAwB,iCAAiC,gCAAgC,0BAA0B,KAAK,6BAA6B,kmBAAkmB,KAAK,2BAA2B,sfAAsf,qCAAqC,oCAAoC,KAAK,2BAA2B,+nBAA+nB,qCAAqC,oCAAoC,KAAK,mBAAmB;AACloF;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;ACtC1B;;AAEb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA,gDAAgD;AAChD;AACA;AACA,qFAAqF;AACrF;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,iBAAiB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,qBAAqB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,sFAAsF,qBAAqB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,iDAAiD,qBAAqB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,sDAAsD,qBAAqB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACpFa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACzBa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,cAAc;AACrE;AACA;AACA;AACA;AACA;;;;;;;;;;ACfA;AACA,oIAAoI;AACpI;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACFA,MAAqG;AACrG,MAA2F;AAC3F,MAAkG;AAClG,MAAqH;AACrH,MAA8G;AAC9G,MAA8G;AAC9G,MAA0G;AAC1G;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,uFAAO;;;;AAIoD;AAC5E,OAAO,iEAAe,uFAAO,IAAI,uFAAO,UAAU,uFAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAqG;AACrG,MAA2F;AAC3F,MAAkG;AAClG,MAAqH;AACrH,MAA8G;AAC9G,MAA8G;AAC9G,MAAyG;AACzG;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,sFAAO;;;;AAImD;AAC3E,OAAO,iEAAe,sFAAO,IAAI,sFAAO,UAAU,sFAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAqG;AACrG,MAA2F;AAC3F,MAAkG;AAClG,MAAqH;AACrH,MAA8G;AAC9G,MAA8G;AAC9G,MAA4G;AAC5G;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,yFAAO;;;;AAIsD;AAC9E,OAAO,iEAAe,yFAAO,IAAI,yFAAO,UAAU,yFAAO,mBAAmB,EAAC;;;;;;;;;;;AC1BhE;;AAEb;AACA;AACA;AACA,kBAAkB,wBAAwB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,iBAAiB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,4BAA4B;AAChD;AACA;AACA;AACA;AACA;AACA,qBAAqB,6BAA6B;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACnFa;;AAEb;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACjCa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACTa;;AAEb;AACA;AACA,cAAc,KAAwC,GAAG,sBAAiB,GAAG,CAAI;AACjF;AACA;AACA;AACA;AACA;;;;;;;;;;ACTa;;AAEb;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA,iFAAiF;AACjF;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,yDAAyD;AACzD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AC5Da;;AAEb;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;;;;;;;;;;;;;;;;;ACdA;AAC0B;AAC0B;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,8GAA8G,IAAI;AAC9H;AACA;AACA,wBAAwB,uDAAmB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA,UAAU;AACV,mEAAmE,MAAM;AACzE;AACA;AACA;AACA;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA,uFAAuF,IAAI;AAC3F;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,uFAAuF,IAAI;AAC3F;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,2BAA2B;AAC3B,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,iCAAiC;AACtD,sBAAsB,iCAAiC;AACvD,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,gEAAgE;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,+BAA+B,GAAG;AACxE,4CAA4C;AAC5C;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,cAAc;AACd;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA,6CAA6C;AAC7C,qBAAqB;AACrB;AACA;AACA;AACA;AACA,gEAAgE,+BAA+B,IAAI;AACnG;AACA;AACA;AACA,oDAAoD;AACpD;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC,0BAA0B,wBAAwB;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD,cAAc;AACd;AACA,kGAAkG;AAClG,cAAc;AACd;AACA;AACA,cAAc;AACd;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,oBAAoB;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAe,YAAY,EAAC;;;;;;;;;;;;;;;ACrS5B;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA,6BAAe,oCAAU;AACzB;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB,eAAe,QAAQ;AACvB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA,uBAAuB,UAAU;AACjC,yBAAyB,QAAQ;AACjC;AACA;AACA;AACA,gBAAgB;AAChB;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,eAAe,cAAc;AAC7B;AACA;AACA;AACA;AACA;AACA,uCAAuC,iCAAiC;AACxE,UAAU;AACV;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,WAAW;AACnC;AACA,mFAAmF;AACnF;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA,0BAA0B;AAC1B;AACA;AACA,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE;AAChE,wBAAwB,WAAW,GAAG,WAAW,GAAG,QAAQ;AAC5D,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;ACrKA;AACA;AACyB;AACzB;AACA;AACA,aAAa,QAAQ;AACrB,cAAc,qDAAqD;AACnE,cAAc,QAAQ;AACtB,cAAc,QAAQ;AACtB,cAAc,QAAQ;AACtB,cAAc,4BAA4B;AAC1C,cAAc,QAAQ;AACtB,cAAc,SAAS;AACvB,cAAc,QAAQ;AACtB,cAAc,QAAQ;AACtB;AACA;AACA;AACA,aAAa,QAAQ;AACrB,cAAc,aAAa;AAC3B,cAAc,qCAAqC;AACnD,cAAc,QAAQ;AACtB,cAAc,SAAS;AACvB,cAAc,QAAQ;AACtB,cAAc,yCAAyC;AACvD,cAAc,qEAAqE;AACnF,cAAc,QAAQ;AACtB;AACA;AACA;AACA,aAAa,QAAQ;AACrB,cAAc,QAAQ;AACtB,cAAc,aAAa;AAC3B,cAAc,kCAAkC;AAChD,cAAc,0CAA0C;AACxD,cAAc,qBAAqB;AACnC,cAAc,2DAA2D;AACzE,cAAc,qDAAqD;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,uBAAuB;AACvC;AACA,mBAAmB,aAAa;AAChC,wBAAwB,mCAAmC;AAC3D,mBAAmB,kBAAkB;AACrC;AACA,mBAAmB,uBAAuB;AAC1C;AACA,mBAAmB,YAAY;AAC/B;AACA;AACA;AACA,gBAAgB,sBAAsB;AACtC;AACA,wBAAwB,gCAAgC;AACxD;AACA;AACA;AACA,gBAAgB,4BAA4B;AAC5C,wBAAwB,iBAAiB,gBAAgB;AACzD;AACA,kBAAkB,YAAY;AAC9B,sBAAsB;AACtB;AACA,gBAAgB,cAAc;AAC9B;AACA,0CAA0C,KAAK;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,aAAa;AAC7E;AACA,2CAA2C,WAAW,GAAG,uCAAuC;AAChG;AACA,wDAAwD,kBAAkB;AAC1E;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA,sDAAsD;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,uDAAuD,wBAAwB;AAC/E;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA,0GAA0G,EAAE;AAC5G,oDAAoD,YAAY;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,sCAAsC,8BAA8B,uCAAuC;AAC3G,uCAAuC;AACvC;AACA;AACA,uEAAuE,MAAM,WAAW,cAAc;AACtG;AACA;AACA;AACA;AACA;AACA,0BAA0B,gCAAgC;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,sBAAsB,4BAA4B;AAClD;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,mEAAmE,sBAAsB,qBAAqB;AAC9G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,mBAAmB,YAAY,0BAA0B;AACnF,6BAA6B,mBAAmB,YAAY,6BAA6B;AACzF,6BAA6B,mBAAmB,YAAY,6BAA6B;AACzF,4BAA4B,mBAAmB,YAAY,4BAA4B;AACvF;AACA,gBAAgB,kBAAkB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,cAAc;AAC9B;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,IAAI;AACpD;AACA;AACA,yBAAyB,gBAAgB;AACzC;AACA,8BAA8B,mBAAmB;AACjD,iEAAiE;AACjE,+DAA+D;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,gBAAgB;AACtD;AACA;AACA,kHAAkH,EAAE;AACpH;AACA,6DAA6D,qBAAqB;AAClF;AACA;AACA;AACA;AACA,WAAW,uBAAuB;AAClC,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,IAAI;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,6BAA6B;AAC5C,eAAe,uBAAuB;AACtC,iBAAiB;AACjB;AACA;AACA;AACA;AACA,+CAA+C,qBAAqB,GAAG;AACvE;AACA;AACA;AACA;AACA,kCAAkC,sBAAsB,GAAG;AAC3D,KAAK;AACL,eAAe,8BAA8B;AAC7C,cAAc;AACd,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA,iEAAe,KAAK,EAAC;AAC8B;;;;;;;;;;;;;;;;ACrXvB;AAC5B;AACA;AACA;AACA,WAAW,oBAAoB;AAC/B;AACA;AACA;AACA;AACA,6BAAe,oCAAU;AACzB,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,6CAA6C;AAC7C,8CAA8C;AAC9C,MAAM;AACN;AACA;AACA;AACA;AACA,uEAAuE;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C,yDAAyD;AACzD,6CAA6C;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C,8CAA8C;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,iCAAiC;AACjG;AACA;AACA,mEAAmE,2CAA2C;AAC9G;AACA;AACA,4DAA4D,iCAAiC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;SC3KA;SACA;;SAEA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;;SAEA;SACA;;SAEA;SACA;SACA;;SAEA;SACA;;;;;UCzBA;UACA;UACA;UACA;UACA;UACA,iCAAiC,WAAW;UAC5C;UACA;;;;;UCPA;UACA;UACA;UACA;UACA,yCAAyC,wCAAwC;UACjF;UACA;UACA;;;;;UCPA;;;;;UCAA;UACA;UACA;UACA,uDAAuD,iBAAiB;UACxE;UACA,gDAAgD,aAAa;UAC7D;;;;;UCNA;;UAEA;UACA;UACA;UACA;UACA;UACA;;UAEA;;UAEA;;UAEA;;UAEA;;UAEA;;UAEA;;UAEA;;;;;UCrBA;;;;;;;;;;;;;;;;;;;ACA4D;AACM;AACjB;AACH;AACC;AAC/C;AACA;AACA;AACA,WAAW,+EAA+E;AAC1F,aAAa,QAAQ;AACrB,YAAY,OAAO;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,sEAAiB;AACrB,IAAI,0EAAmB;AACvB;AACA;AACA;AACA,cAAc,wDAAO;AACrB,aAAa,kEAAM;AACnB,YAAY,gEAAK;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAe,GAAG,E","sources":["webpack://@appius-fr/apx/./modules/dialog/css/dialog.css","webpack://@appius-fr/apx/./modules/toast/css/toast.css","webpack://@appius-fr/apx/./modules/tristate/css/tristate.css","webpack://@appius-fr/apx/./node_modules/css-loader/dist/runtime/api.js","webpack://@appius-fr/apx/./node_modules/css-loader/dist/runtime/getUrl.js","webpack://@appius-fr/apx/./node_modules/css-loader/dist/runtime/sourceMaps.js","webpack://@appius-fr/apx/./modules/dialog/html/dialog.html","webpack://@appius-fr/apx/./modules/dialog/css/dialog.css?a567","webpack://@appius-fr/apx/./modules/toast/css/toast.css?8a48","webpack://@appius-fr/apx/./modules/tristate/css/tristate.css?a094","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/insertBySelector.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/insertStyleElement.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/styleDomAPI.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/styleTagTransform.js","webpack://@appius-fr/apx/./modules/common.mjs","webpack://@appius-fr/apx/./modules/dialog/dialog.mjs","webpack://@appius-fr/apx/./modules/listen/listen.mjs","webpack://@appius-fr/apx/./modules/toast/toast.mjs","webpack://@appius-fr/apx/./modules/tristate/tristate.mjs","webpack://@appius-fr/apx/webpack/bootstrap","webpack://@appius-fr/apx/webpack/runtime/compat get default export","webpack://@appius-fr/apx/webpack/runtime/define property getters","webpack://@appius-fr/apx/webpack/runtime/hasOwnProperty shorthand","webpack://@appius-fr/apx/webpack/runtime/make namespace object","webpack://@appius-fr/apx/webpack/runtime/jsonp chunk loading","webpack://@appius-fr/apx/webpack/runtime/nonce","webpack://@appius-fr/apx/./APX.mjs"],"sourcesContent":["// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `/* Dialog styling */\r\n.APX-dialog {\r\n    display: none;\r\n    position: fixed;\r\n    z-index: 1002;\r\n    left: 0;\r\n    top: 0;\r\n    width: 100%;\r\n    height: 100%;\r\n    overflow: auto;\r\n    background-color: rgba(0, 0, 0, 0.4);\r\n    /* Dimmed background for focus on dialog */\r\n}\r\n\r\n.APX-dialog-content {\r\n    background-color: #fefefe;\r\n    padding: 40px;\r\n    border: none;\r\n    width: auto;\r\n    min-width: 300px;\r\n    max-width: 80%;\r\n    margin: auto;\r\n    border-radius: 8px;\r\n    box-shadow: 0px 6px 20px rgba(0, 0, 0, 0.1);\r\n    font-family: 'Helvetica Neue', Arial, sans-serif;\r\n}\r\n\r\nh2.APX-dialog-title{\r\n    margin-top:0;\r\n}\r\n\r\n.APX-close-dialog {\r\n    color: #aaa;\r\n    float: right;\r\n    font-size: 24px;\r\n    margin-top: -10px;\r\n    /* Adjust positioning */\r\n    margin-right: -10px;\r\n}\r\n\r\n.APX-close-dialog:hover,\r\n.APX-close-dialog:focus {\r\n    color: #333;\r\n    /* Darker color on hover/focus */\r\n    cursor: pointer;\r\n}\r\n\r\n/* Input fields styling */\r\n.APX-dialog-content input[type=\"text\"],\r\n.APX-dialog-content input[type=\"number\"],\r\n.APX-dialog-content input[type=\"date\"],\r\n.APX-dialog-content input[type=\"datetime-local\"] {\r\n    width: 100%;\r\n    padding: 10px;\r\n    margin-bottom: 20px;\r\n    border: 1px solid #ccc;\r\n    border-radius: 4px;\r\n    font-family: 'Helvetica Neue', Arial, sans-serif;\r\n    font-size: 16px;\r\n    box-sizing: border-box;\r\n    transition: border-color 0.3s;\r\n}\r\n\r\n.APX-dialog-content input[type=\"text\"]:focus,\r\n.APX-dialog-content input[type=\"number\"]:focus,\r\n.APX-dialog-content input[type=\"date\"]:focus,\r\n.APX-dialog-content input[type=\"datetime-local\"]:focus {\r\n    border-color: #2C3E50;\r\n    /* Deep Blue Color */\r\n    outline: none;\r\n}\r\n\r\n/* Button in the dialog */\r\n.APX-dialog-button-container button {\r\n    position: relative;\r\n    background-color: #2C3E50;\r\n    color: #ECF0F1;\r\n    border: none;\r\n    padding: 10px 20px;\r\n    border-radius: 5px;\r\n    font-size: 16px;\r\n    cursor: pointer;\r\n    transition: all 0.3s ease;\r\n    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);\r\n}\r\n\r\n.APX-dialog-button-container button:hover {\r\n    background-color: #34495E;\r\n    transform: translateY(-1px);\r\n    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);\r\n}\r\n\r\n.APX-dialog-button-container {\r\n    display: flex;\r\n    gap: 10px;\r\n    margin-top:1em;\r\n    /* spacing between buttons */\r\n}\r\n\r\n/* Loading indicator */\r\n.APX-dialog-loading-indicator {\r\n    display: flex;\r\n    justify-content: center;\r\n    align-items: center;\r\n    height: 100px;\r\n    width: 100%;\r\n}\r\n\r\n.APX-dialog-loading-indicator::before {\r\n    content: '';\r\n    width: 40px;\r\n    height: 40px;\r\n    border: 4px solid #f3f3f3;\r\n    border-top: 4px solid #2C3E50;\r\n    border-radius: 50%;\r\n    animation: APX-dialog-spin 1s linear infinite;\r\n}\r\n\r\n@keyframes APX-dialog-spin {\r\n    0% { transform: rotate(0deg); }\r\n    100% { transform: rotate(360deg); }\r\n}\r\n.APX-dialog-button-disabled {\r\n    opacity: 0.5;\r\n    cursor: not-allowed !important;\r\n    background-color: #95a5a6 !important; /* Grayed out color */\r\n    box-shadow: none !important;\r\n    transition: all 0.2s ease;\r\n    transform: none !important;\r\n}\r\n\r\n.APX-dialog-button-disabled:hover {\r\n    background-color: #95a5a6 !important; /* Keep gray on hover */\r\n    transform: none !important;\r\n}\r\n\r\n/* Add a subtle strikethrough effect */\r\n.APX-dialog-button-disabled::after {\r\n    content: '';\r\n    position: absolute;\r\n    top: 50%;\r\n    left: 0;\r\n    width: 100%;\r\n    height: 1px;\r\n    background-color: rgba(0, 0, 0, 0.2);\r\n    transform: rotate(-5deg);\r\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./modules/dialog/css/dialog.css\"],\"names\":[],\"mappings\":\"AAAA,mBAAmB;AACnB;IACI,aAAa;IACb,eAAe;IACf,aAAa;IACb,OAAO;IACP,MAAM;IACN,WAAW;IACX,YAAY;IACZ,cAAc;IACd,oCAAoC;IACpC,0CAA0C;AAC9C;;AAEA;IACI,yBAAyB;IACzB,aAAa;IACb,YAAY;IACZ,WAAW;IACX,gBAAgB;IAChB,cAAc;IACd,YAAY;IACZ,kBAAkB;IAClB,2CAA2C;IAC3C,gDAAgD;AACpD;;AAEA;IACI,YAAY;AAChB;;AAEA;IACI,WAAW;IACX,YAAY;IACZ,eAAe;IACf,iBAAiB;IACjB,uBAAuB;IACvB,mBAAmB;AACvB;;AAEA;;IAEI,WAAW;IACX,gCAAgC;IAChC,eAAe;AACnB;;AAEA,yBAAyB;AACzB;;;;IAII,WAAW;IACX,aAAa;IACb,mBAAmB;IACnB,sBAAsB;IACtB,kBAAkB;IAClB,gDAAgD;IAChD,eAAe;IACf,sBAAsB;IACtB,6BAA6B;AACjC;;AAEA;;;;IAII,qBAAqB;IACrB,oBAAoB;IACpB,aAAa;AACjB;;AAEA,yBAAyB;AACzB;IACI,kBAAkB;IAClB,yBAAyB;IACzB,cAAc;IACd,YAAY;IACZ,kBAAkB;IAClB,kBAAkB;IAClB,eAAe;IACf,eAAe;IACf,yBAAyB;IACzB,wCAAwC;AAC5C;;AAEA;IACI,yBAAyB;IACzB,2BAA2B;IAC3B,yCAAyC;AAC7C;;AAEA;IACI,aAAa;IACb,SAAS;IACT,cAAc;IACd,4BAA4B;AAChC;;AAEA,sBAAsB;AACtB;IACI,aAAa;IACb,uBAAuB;IACvB,mBAAmB;IACnB,aAAa;IACb,WAAW;AACf;;AAEA;IACI,WAAW;IACX,WAAW;IACX,YAAY;IACZ,yBAAyB;IACzB,6BAA6B;IAC7B,kBAAkB;IAClB,6CAA6C;AACjD;;AAEA;IACI,KAAK,uBAAuB,EAAE;IAC9B,OAAO,yBAAyB,EAAE;AACtC;AACA;IACI,YAAY;IACZ,8BAA8B;IAC9B,oCAAoC,EAAE,qBAAqB;IAC3D,2BAA2B;IAC3B,yBAAyB;IACzB,0BAA0B;AAC9B;;AAEA;IACI,oCAAoC,EAAE,uBAAuB;IAC7D,0BAA0B;AAC9B;;AAEA,sCAAsC;AACtC;IACI,WAAW;IACX,kBAAkB;IAClB,QAAQ;IACR,OAAO;IACP,WAAW;IACX,WAAW;IACX,oCAAoC;IACpC,wBAAwB;AAC5B\",\"sourcesContent\":[\"/* Dialog styling */\\r\\n.APX-dialog {\\r\\n    display: none;\\r\\n    position: fixed;\\r\\n    z-index: 1002;\\r\\n    left: 0;\\r\\n    top: 0;\\r\\n    width: 100%;\\r\\n    height: 100%;\\r\\n    overflow: auto;\\r\\n    background-color: rgba(0, 0, 0, 0.4);\\r\\n    /* Dimmed background for focus on dialog */\\r\\n}\\r\\n\\r\\n.APX-dialog-content {\\r\\n    background-color: #fefefe;\\r\\n    padding: 40px;\\r\\n    border: none;\\r\\n    width: auto;\\r\\n    min-width: 300px;\\r\\n    max-width: 80%;\\r\\n    margin: auto;\\r\\n    border-radius: 8px;\\r\\n    box-shadow: 0px 6px 20px rgba(0, 0, 0, 0.1);\\r\\n    font-family: 'Helvetica Neue', Arial, sans-serif;\\r\\n}\\r\\n\\r\\nh2.APX-dialog-title{\\r\\n    margin-top:0;\\r\\n}\\r\\n\\r\\n.APX-close-dialog {\\r\\n    color: #aaa;\\r\\n    float: right;\\r\\n    font-size: 24px;\\r\\n    margin-top: -10px;\\r\\n    /* Adjust positioning */\\r\\n    margin-right: -10px;\\r\\n}\\r\\n\\r\\n.APX-close-dialog:hover,\\r\\n.APX-close-dialog:focus {\\r\\n    color: #333;\\r\\n    /* Darker color on hover/focus */\\r\\n    cursor: pointer;\\r\\n}\\r\\n\\r\\n/* Input fields styling */\\r\\n.APX-dialog-content input[type=\\\"text\\\"],\\r\\n.APX-dialog-content input[type=\\\"number\\\"],\\r\\n.APX-dialog-content input[type=\\\"date\\\"],\\r\\n.APX-dialog-content input[type=\\\"datetime-local\\\"] {\\r\\n    width: 100%;\\r\\n    padding: 10px;\\r\\n    margin-bottom: 20px;\\r\\n    border: 1px solid #ccc;\\r\\n    border-radius: 4px;\\r\\n    font-family: 'Helvetica Neue', Arial, sans-serif;\\r\\n    font-size: 16px;\\r\\n    box-sizing: border-box;\\r\\n    transition: border-color 0.3s;\\r\\n}\\r\\n\\r\\n.APX-dialog-content input[type=\\\"text\\\"]:focus,\\r\\n.APX-dialog-content input[type=\\\"number\\\"]:focus,\\r\\n.APX-dialog-content input[type=\\\"date\\\"]:focus,\\r\\n.APX-dialog-content input[type=\\\"datetime-local\\\"]:focus {\\r\\n    border-color: #2C3E50;\\r\\n    /* Deep Blue Color */\\r\\n    outline: none;\\r\\n}\\r\\n\\r\\n/* Button in the dialog */\\r\\n.APX-dialog-button-container button {\\r\\n    position: relative;\\r\\n    background-color: #2C3E50;\\r\\n    color: #ECF0F1;\\r\\n    border: none;\\r\\n    padding: 10px 20px;\\r\\n    border-radius: 5px;\\r\\n    font-size: 16px;\\r\\n    cursor: pointer;\\r\\n    transition: all 0.3s ease;\\r\\n    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);\\r\\n}\\r\\n\\r\\n.APX-dialog-button-container button:hover {\\r\\n    background-color: #34495E;\\r\\n    transform: translateY(-1px);\\r\\n    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);\\r\\n}\\r\\n\\r\\n.APX-dialog-button-container {\\r\\n    display: flex;\\r\\n    gap: 10px;\\r\\n    margin-top:1em;\\r\\n    /* spacing between buttons */\\r\\n}\\r\\n\\r\\n/* Loading indicator */\\r\\n.APX-dialog-loading-indicator {\\r\\n    display: flex;\\r\\n    justify-content: center;\\r\\n    align-items: center;\\r\\n    height: 100px;\\r\\n    width: 100%;\\r\\n}\\r\\n\\r\\n.APX-dialog-loading-indicator::before {\\r\\n    content: '';\\r\\n    width: 40px;\\r\\n    height: 40px;\\r\\n    border: 4px solid #f3f3f3;\\r\\n    border-top: 4px solid #2C3E50;\\r\\n    border-radius: 50%;\\r\\n    animation: APX-dialog-spin 1s linear infinite;\\r\\n}\\r\\n\\r\\n@keyframes APX-dialog-spin {\\r\\n    0% { transform: rotate(0deg); }\\r\\n    100% { transform: rotate(360deg); }\\r\\n}\\r\\n.APX-dialog-button-disabled {\\r\\n    opacity: 0.5;\\r\\n    cursor: not-allowed !important;\\r\\n    background-color: #95a5a6 !important; /* Grayed out color */\\r\\n    box-shadow: none !important;\\r\\n    transition: all 0.2s ease;\\r\\n    transform: none !important;\\r\\n}\\r\\n\\r\\n.APX-dialog-button-disabled:hover {\\r\\n    background-color: #95a5a6 !important; /* Keep gray on hover */\\r\\n    transform: none !important;\\r\\n}\\r\\n\\r\\n/* Add a subtle strikethrough effect */\\r\\n.APX-dialog-button-disabled::after {\\r\\n    content: '';\\r\\n    position: absolute;\\r\\n    top: 50%;\\r\\n    left: 0;\\r\\n    width: 100%;\\r\\n    height: 1px;\\r\\n    background-color: rgba(0, 0, 0, 0.2);\\r\\n    transform: rotate(-5deg);\\r\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.APX-toast-container {\r\n    position: fixed;\r\n    display: flex;\r\n    flex-direction: column;\r\n    gap: var(--apx-toast-gap, 8px);\r\n    z-index: var(--apx-toast-z-index, 11000);\r\n    pointer-events: none;\r\n}\r\n\r\n.APX-toast-container--bottom-right { right: 12px; bottom: 12px; align-items: flex-end; }\r\n.APX-toast-container--bottom-left { left: 12px; bottom: 12px; align-items: flex-start; }\r\n.APX-toast-container--top-right { right: 12px; top: 12px; align-items: flex-end; }\r\n.APX-toast-container--top-left { left: 12px; top: 12px; align-items: flex-start; }\r\n\r\n.APX-toast {\r\n    min-width: var(--apx-toast-min-width, 260px);\r\n    max-width: var(--apx-toast-max-width, 420px);\r\n    font-size: var(--apx-toast-font-size, 14px);\r\n    border-radius: var(--apx-toast-radius, 6px);\r\n    box-shadow: var(--apx-toast-shadow, 0 6px 24px rgba(0,0,0,0.2));\r\n    padding: var(--apx-toast-padding, 10px 42px 10px 14px);\r\n    color: #111;\r\n    background: #eee;\r\n    pointer-events: auto;\r\n    position: relative;\r\n    transition: opacity 180ms ease, transform 180ms ease;\r\n}\r\n\r\n.APX-toast--info { background: var(--apx-toast-info-bg, #0dcaf0); color: var(--apx-toast-info-fg, #052c65); }\r\n.APX-toast--success { background: var(--apx-toast-success-bg, #198754); color: var(--apx-toast-success-fg, #ffffff); }\r\n.APX-toast--warning { background: var(--apx-toast-warning-bg, #ffc107); color: var(--apx-toast-warning-fg, #664d03); }\r\n.APX-toast--danger { background: var(--apx-toast-danger-bg, #dc3545); color: var(--apx-toast-danger-fg, #ffffff); }\r\n\r\n.APX-toast__content { line-height: 1.35; }\r\n\r\n.APX-toast__close {\r\n    position: absolute;\r\n    top: 50%; right: 10px;\r\n    width: 24px; height: 24px;\r\n    transform: translateY(-50%);\r\n    display: inline-flex; align-items: center; justify-content: center;\r\n    background: transparent; color: currentColor;\r\n    border: 0; border-radius: 4px; padding: 0; margin: 0;\r\n    cursor: pointer; appearance: none; -webkit-appearance: none;\r\n    opacity: .75; transition: opacity 120ms ease;\r\n}\r\n.APX-toast__close:hover { opacity: 1; }\r\n.APX-toast__close:focus { outline: 2px solid rgba(0,0,0,.2); outline-offset: 2px; }\r\n.APX-toast__close::before {\r\n    content: '×';\r\n    font-size: 16px; line-height: 1; text-align: center;\r\n}\r\n\r\n/* Animations */\r\n.APX-toast--enter { opacity: 0; transform: translateY(8px); }\r\n.APX-toast--enter.APX-toast--enter-active { opacity: 1; transform: translateY(0); }\r\n.APX-toast--exit { opacity: 1; transform: translateY(0); }\r\n.APX-toast--exit.APX-toast--exit-active { opacity: 0; transform: translateY(8px); }\r\n\r\n\r\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./modules/toast/css/toast.css\"],\"names\":[],\"mappings\":\"AAAA;IACI,eAAe;IACf,aAAa;IACb,sBAAsB;IACtB,8BAA8B;IAC9B,wCAAwC;IACxC,oBAAoB;AACxB;;AAEA,qCAAqC,WAAW,EAAE,YAAY,EAAE,qBAAqB,EAAE;AACvF,oCAAoC,UAAU,EAAE,YAAY,EAAE,uBAAuB,EAAE;AACvF,kCAAkC,WAAW,EAAE,SAAS,EAAE,qBAAqB,EAAE;AACjF,iCAAiC,UAAU,EAAE,SAAS,EAAE,uBAAuB,EAAE;;AAEjF;IACI,4CAA4C;IAC5C,4CAA4C;IAC5C,2CAA2C;IAC3C,2CAA2C;IAC3C,+DAA+D;IAC/D,sDAAsD;IACtD,WAAW;IACX,gBAAgB;IAChB,oBAAoB;IACpB,kBAAkB;IAClB,oDAAoD;AACxD;;AAEA,mBAAmB,6CAA6C,EAAE,wCAAwC,EAAE;AAC5G,sBAAsB,gDAAgD,EAAE,2CAA2C,EAAE;AACrH,sBAAsB,gDAAgD,EAAE,2CAA2C,EAAE;AACrH,qBAAqB,+CAA+C,EAAE,0CAA0C,EAAE;;AAElH,sBAAsB,iBAAiB,EAAE;;AAEzC;IACI,kBAAkB;IAClB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,YAAY;IACzB,2BAA2B;IAC3B,oBAAoB,EAAE,mBAAmB,EAAE,uBAAuB;IAClE,uBAAuB,EAAE,mBAAmB;IAC5C,SAAS,EAAE,kBAAkB,EAAE,UAAU,EAAE,SAAS;IACpD,eAAe,EAAE,gBAAgB,EAAE,wBAAwB;IAC3D,YAAY,EAAE,8BAA8B;AAChD;AACA,0BAA0B,UAAU,EAAE;AACtC,0BAA0B,iCAAiC,EAAE,mBAAmB,EAAE;AAClF;IACI,YAAY;IACZ,eAAe,EAAE,cAAc,EAAE,kBAAkB;AACvD;;AAEA,eAAe;AACf,oBAAoB,UAAU,EAAE,0BAA0B,EAAE;AAC5D,4CAA4C,UAAU,EAAE,wBAAwB,EAAE;AAClF,mBAAmB,UAAU,EAAE,wBAAwB,EAAE;AACzD,0CAA0C,UAAU,EAAE,0BAA0B,EAAE\",\"sourcesContent\":[\".APX-toast-container {\\r\\n    position: fixed;\\r\\n    display: flex;\\r\\n    flex-direction: column;\\r\\n    gap: var(--apx-toast-gap, 8px);\\r\\n    z-index: var(--apx-toast-z-index, 11000);\\r\\n    pointer-events: none;\\r\\n}\\r\\n\\r\\n.APX-toast-container--bottom-right { right: 12px; bottom: 12px; align-items: flex-end; }\\r\\n.APX-toast-container--bottom-left { left: 12px; bottom: 12px; align-items: flex-start; }\\r\\n.APX-toast-container--top-right { right: 12px; top: 12px; align-items: flex-end; }\\r\\n.APX-toast-container--top-left { left: 12px; top: 12px; align-items: flex-start; }\\r\\n\\r\\n.APX-toast {\\r\\n    min-width: var(--apx-toast-min-width, 260px);\\r\\n    max-width: var(--apx-toast-max-width, 420px);\\r\\n    font-size: var(--apx-toast-font-size, 14px);\\r\\n    border-radius: var(--apx-toast-radius, 6px);\\r\\n    box-shadow: var(--apx-toast-shadow, 0 6px 24px rgba(0,0,0,0.2));\\r\\n    padding: var(--apx-toast-padding, 10px 42px 10px 14px);\\r\\n    color: #111;\\r\\n    background: #eee;\\r\\n    pointer-events: auto;\\r\\n    position: relative;\\r\\n    transition: opacity 180ms ease, transform 180ms ease;\\r\\n}\\r\\n\\r\\n.APX-toast--info { background: var(--apx-toast-info-bg, #0dcaf0); color: var(--apx-toast-info-fg, #052c65); }\\r\\n.APX-toast--success { background: var(--apx-toast-success-bg, #198754); color: var(--apx-toast-success-fg, #ffffff); }\\r\\n.APX-toast--warning { background: var(--apx-toast-warning-bg, #ffc107); color: var(--apx-toast-warning-fg, #664d03); }\\r\\n.APX-toast--danger { background: var(--apx-toast-danger-bg, #dc3545); color: var(--apx-toast-danger-fg, #ffffff); }\\r\\n\\r\\n.APX-toast__content { line-height: 1.35; }\\r\\n\\r\\n.APX-toast__close {\\r\\n    position: absolute;\\r\\n    top: 50%; right: 10px;\\r\\n    width: 24px; height: 24px;\\r\\n    transform: translateY(-50%);\\r\\n    display: inline-flex; align-items: center; justify-content: center;\\r\\n    background: transparent; color: currentColor;\\r\\n    border: 0; border-radius: 4px; padding: 0; margin: 0;\\r\\n    cursor: pointer; appearance: none; -webkit-appearance: none;\\r\\n    opacity: .75; transition: opacity 120ms ease;\\r\\n}\\r\\n.APX-toast__close:hover { opacity: 1; }\\r\\n.APX-toast__close:focus { outline: 2px solid rgba(0,0,0,.2); outline-offset: 2px; }\\r\\n.APX-toast__close::before {\\r\\n    content: '×';\\r\\n    font-size: 16px; line-height: 1; text-align: center;\\r\\n}\\r\\n\\r\\n/* Animations */\\r\\n.APX-toast--enter { opacity: 0; transform: translateY(8px); }\\r\\n.APX-toast--enter.APX-toast--enter-active { opacity: 1; transform: translateY(0); }\\r\\n.APX-toast--exit { opacity: 1; transform: translateY(0); }\\r\\n.APX-toast--exit.APX-toast--exit-active { opacity: 0; transform: translateY(8px); }\\r\\n\\r\\n\\r\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/api.js\";\nimport ___CSS_LOADER_GET_URL_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/getUrl.js\";\nvar ___CSS_LOADER_URL_IMPORT_0___ = new URL(\"data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A//www.w3.org/2000/svg%27%20width%3D%2732%27%20height%3D%2732%27%3E%3Cpath%20%20fill%3D%22%23cccccc%22%20d%3D%22M25.107%2032.030h-18.214c-3.456%200-6.268-2.81-6.268-6.264v-19.529c0-3.456%202.812-6.268%206.268-6.268h18.214c3.456%200%206.268%202.812%206.268%206.268v19.529c0%203.452-2.812%206.264-6.268%206.264zM6.893%201.85c-2.419%200-4.386%201.967-4.386%204.386v19.529c0%202.417%201.967%204.382%204.386%204.382h18.214c2.419%200%204.386-1.965%204.386-4.382v-19.529c0-2.419-1.967-4.386-4.386-4.386h-18.214z%22%3E%3C/path%3E%3C/svg%3E\", import.meta.url);\nvar ___CSS_LOADER_URL_IMPORT_1___ = new URL(\"data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A//www.w3.org/2000/svg%27%20width%3D%2732%27%20height%3D%2732%27%3E%3Cpath%20fill%3D%22%230654ba%22%20d%3D%22M0.543%205.647c0-3.119%202.531-5.647%205.65-5.647h19.309c3.12%200%205.65%202.511%205.65%205.647v20.705c0%203.119-2.531%205.647-5.65%205.647h-19.309c-3.12%200-5.65-2.511-5.65-5.647v-20.705zM5.313%2017.587l7.039%206.839%2013.831-13.439-2.636-2.561-10.929%2010.62-4.442-4.317-2.862%202.858z%22%3E%3C/path%3E%3C/svg%3E\", import.meta.url);\nvar ___CSS_LOADER_URL_IMPORT_2___ = new URL(\"data:image/svg+xml,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22UTF-8%22%3F%3E%3Csvg%20viewBox%3D%220%200%2032%2032%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22m0.543%205.647c0-3.119%202.531-5.647%205.65-5.647h19.309c3.12%200%205.65%202.511%205.65%205.647v20.705c0%203.119-2.531%205.647-5.65%205.647h-19.309c-3.12%200-5.65-2.511-5.65-5.647v-20.705z%22%20fill%3D%22%23f00%22%2F%3E%3Cpath%20d%3D%22m8%208%2016%2016%22%20stroke%3D%22%23fff%22%20stroke-width%3D%222%22%2F%3E%3Cpath%20d%3D%22M24%208L8%2024%22%20stroke%3D%22%23fff%22%20stroke-width%3D%222%22%2F%3E%3C%2Fsvg%3E\", import.meta.url);\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\nvar ___CSS_LOADER_URL_REPLACEMENT_0___ = ___CSS_LOADER_GET_URL_IMPORT___(___CSS_LOADER_URL_IMPORT_0___);\nvar ___CSS_LOADER_URL_REPLACEMENT_1___ = ___CSS_LOADER_GET_URL_IMPORT___(___CSS_LOADER_URL_IMPORT_1___);\nvar ___CSS_LOADER_URL_REPLACEMENT_2___ = ___CSS_LOADER_GET_URL_IMPORT___(___CSS_LOADER_URL_IMPORT_2___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.apx-tristate {\r\n    display: inline-block;\r\n    vertical-align: middle;\r\n    text-align: center;\r\n    cursor: pointer;\r\n    position: relative;\r\n    min-width:13px;\r\n    min-height:13px;\r\n    background-size: contain;\r\n    background-color: white;\r\n    border-radius:3px;\r\n}\r\n.apx-tristate.unchecked {\r\n    background-image: url(${___CSS_LOADER_URL_REPLACEMENT_0___});\r\n}\r\n.apx-tristate.checked {\r\n    background-image: url(${___CSS_LOADER_URL_REPLACEMENT_1___});\r\n    background-repeat: no-repeat;\r\n    background-position: center;\r\n}\r\n.apx-tristate.crossed {\r\n    background-image: url(${___CSS_LOADER_URL_REPLACEMENT_2___});\r\n    background-repeat: no-repeat;\r\n    background-position: center;\r\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./modules/tristate/css/tristate.css\"],\"names\":[],\"mappings\":\"AAAA;IACI,qBAAqB;IACrB,sBAAsB;IACtB,kBAAkB;IAClB,eAAe;IACf,kBAAkB;IAClB,cAAc;IACd,eAAe;IACf,wBAAwB;IACxB,uBAAuB;IACvB,iBAAiB;AACrB;AACA;IACI,yDAAylB;AAC7lB;AACA;IACI,yDAA6e;IAC7e,4BAA4B;IAC5B,2BAA2B;AAC/B;AACA;IACI,yDAAsnB;IACtnB,4BAA4B;IAC5B,2BAA2B;AAC/B\",\"sourcesContent\":[\".apx-tristate {\\r\\n    display: inline-block;\\r\\n    vertical-align: middle;\\r\\n    text-align: center;\\r\\n    cursor: pointer;\\r\\n    position: relative;\\r\\n    min-width:13px;\\r\\n    min-height:13px;\\r\\n    background-size: contain;\\r\\n    background-color: white;\\r\\n    border-radius:3px;\\r\\n}\\r\\n.apx-tristate.unchecked {\\r\\n    background-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A//www.w3.org/2000/svg%27%20width%3D%2732%27%20height%3D%2732%27%3E%3Cpath%20%20fill%3D%22%23cccccc%22%20d%3D%22M25.107%2032.030h-18.214c-3.456%200-6.268-2.81-6.268-6.264v-19.529c0-3.456%202.812-6.268%206.268-6.268h18.214c3.456%200%206.268%202.812%206.268%206.268v19.529c0%203.452-2.812%206.264-6.268%206.264zM6.893%201.85c-2.419%200-4.386%201.967-4.386%204.386v19.529c0%202.417%201.967%204.382%204.386%204.382h18.214c2.419%200%204.386-1.965%204.386-4.382v-19.529c0-2.419-1.967-4.386-4.386-4.386h-18.214z%22%3E%3C/path%3E%3C/svg%3E');\\r\\n}\\r\\n.apx-tristate.checked {\\r\\n    background-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A//www.w3.org/2000/svg%27%20width%3D%2732%27%20height%3D%2732%27%3E%3Cpath%20fill%3D%22%230654ba%22%20d%3D%22M0.543%205.647c0-3.119%202.531-5.647%205.65-5.647h19.309c3.12%200%205.65%202.511%205.65%205.647v20.705c0%203.119-2.531%205.647-5.65%205.647h-19.309c-3.12%200-5.65-2.511-5.65-5.647v-20.705zM5.313%2017.587l7.039%206.839%2013.831-13.439-2.636-2.561-10.929%2010.62-4.442-4.317-2.862%202.858z%22%3E%3C/path%3E%3C/svg%3E');\\r\\n    background-repeat: no-repeat;\\r\\n    background-position: center;\\r\\n}\\r\\n.apx-tristate.crossed {\\r\\n    background-image: url('data:image/svg+xml,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22UTF-8%22%3F%3E%3Csvg%20viewBox%3D%220%200%2032%2032%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22m0.543%205.647c0-3.119%202.531-5.647%205.65-5.647h19.309c3.12%200%205.65%202.511%205.65%205.647v20.705c0%203.119-2.531%205.647-5.65%205.647h-19.309c-3.12%200-5.65-2.511-5.65-5.647v-20.705z%22%20fill%3D%22%23f00%22%2F%3E%3Cpath%20d%3D%22m8%208%2016%2016%22%20stroke%3D%22%23fff%22%20stroke-width%3D%222%22%2F%3E%3Cpath%20d%3D%22M24%208L8%2024%22%20stroke%3D%22%23fff%22%20stroke-width%3D%222%22%2F%3E%3C%2Fsvg%3E');\\r\\n    background-repeat: no-repeat;\\r\\n    background-position: center;\\r\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","\"use strict\";\n\n/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n*/\nmodule.exports = function (cssWithMappingToString) {\n  var list = [];\n\n  // return the list of modules as css string\n  list.toString = function toString() {\n    return this.map(function (item) {\n      var content = \"\";\n      var needLayer = typeof item[5] !== \"undefined\";\n      if (item[4]) {\n        content += \"@supports (\".concat(item[4], \") {\");\n      }\n      if (item[2]) {\n        content += \"@media \".concat(item[2], \" {\");\n      }\n      if (needLayer) {\n        content += \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\");\n      }\n      content += cssWithMappingToString(item);\n      if (needLayer) {\n        content += \"}\";\n      }\n      if (item[2]) {\n        content += \"}\";\n      }\n      if (item[4]) {\n        content += \"}\";\n      }\n      return content;\n    }).join(\"\");\n  };\n\n  // import a list of modules into the list\n  list.i = function i(modules, media, dedupe, supports, layer) {\n    if (typeof modules === \"string\") {\n      modules = [[null, modules, undefined]];\n    }\n    var alreadyImportedModules = {};\n    if (dedupe) {\n      for (var k = 0; k < this.length; k++) {\n        var id = this[k][0];\n        if (id != null) {\n          alreadyImportedModules[id] = true;\n        }\n      }\n    }\n    for (var _k = 0; _k < modules.length; _k++) {\n      var item = [].concat(modules[_k]);\n      if (dedupe && alreadyImportedModules[item[0]]) {\n        continue;\n      }\n      if (typeof layer !== \"undefined\") {\n        if (typeof item[5] === \"undefined\") {\n          item[5] = layer;\n        } else {\n          item[1] = \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\").concat(item[1], \"}\");\n          item[5] = layer;\n        }\n      }\n      if (media) {\n        if (!item[2]) {\n          item[2] = media;\n        } else {\n          item[1] = \"@media \".concat(item[2], \" {\").concat(item[1], \"}\");\n          item[2] = media;\n        }\n      }\n      if (supports) {\n        if (!item[4]) {\n          item[4] = \"\".concat(supports);\n        } else {\n          item[1] = \"@supports (\".concat(item[4], \") {\").concat(item[1], \"}\");\n          item[4] = supports;\n        }\n      }\n      list.push(item);\n    }\n  };\n  return list;\n};","\"use strict\";\n\nmodule.exports = function (url, options) {\n  if (!options) {\n    options = {};\n  }\n  if (!url) {\n    return url;\n  }\n  url = String(url.__esModule ? url.default : url);\n\n  // If url is already wrapped in quotes, remove them\n  if (/^['\"].*['\"]$/.test(url)) {\n    url = url.slice(1, -1);\n  }\n  if (options.hash) {\n    url += options.hash;\n  }\n\n  // Should url be wrapped?\n  // See https://drafts.csswg.org/css-values-3/#urls\n  if (/[\"'() \\t\\n]|(%20)/.test(url) || options.needQuotes) {\n    return \"\\\"\".concat(url.replace(/\"/g, '\\\\\"').replace(/\\n/g, \"\\\\n\"), \"\\\"\");\n  }\n  return url;\n};","\"use strict\";\n\nmodule.exports = function (item) {\n  var content = item[1];\n  var cssMapping = item[3];\n  if (!cssMapping) {\n    return content;\n  }\n  if (typeof btoa === \"function\") {\n    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));\n    var data = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\".concat(base64);\n    var sourceMapping = \"/*# \".concat(data, \" */\");\n    return [content].concat([sourceMapping]).join(\"\\n\");\n  }\n  return [content].join(\"\\n\");\n};","// Module\nvar code = \"<div class=\\\"APX-dialog\\\">\\r\\n    <div class=\\\"APX-dialog-content\\\">\\r\\n        <span class=\\\"APX-close-dialog\\\">&times;</span>\\r\\n        <h2 class=\\\"APX-dialog-title\\\"></h2>\\r\\n        <div class=\\\"APX-dialog-dynamic-content\\\"></div>\\r\\n        <div class=\\\"APX-dialog-button-container\\\"></div>\\r\\n    </div>\\r\\n</div>\";\n// Exports\nmodule.exports = code;","\n      import API from \"!../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../node_modules/css-loader/dist/cjs.js!./dialog.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../node_modules/css-loader/dist/cjs.js!./dialog.css\";\n       export default content && content.locals ? content.locals : undefined;\n","\n      import API from \"!../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../node_modules/css-loader/dist/cjs.js!./toast.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../node_modules/css-loader/dist/cjs.js!./toast.css\";\n       export default content && content.locals ? content.locals : undefined;\n","\n      import API from \"!../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../node_modules/css-loader/dist/cjs.js!./tristate.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../node_modules/css-loader/dist/cjs.js!./tristate.css\";\n       export default content && content.locals ? content.locals : undefined;\n","\"use strict\";\n\nvar stylesInDOM = [];\nfunction getIndexByIdentifier(identifier) {\n  var result = -1;\n  for (var i = 0; i < stylesInDOM.length; i++) {\n    if (stylesInDOM[i].identifier === identifier) {\n      result = i;\n      break;\n    }\n  }\n  return result;\n}\nfunction modulesToDom(list, options) {\n  var idCountMap = {};\n  var identifiers = [];\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i];\n    var id = options.base ? item[0] + options.base : item[0];\n    var count = idCountMap[id] || 0;\n    var identifier = \"\".concat(id, \" \").concat(count);\n    idCountMap[id] = count + 1;\n    var indexByIdentifier = getIndexByIdentifier(identifier);\n    var obj = {\n      css: item[1],\n      media: item[2],\n      sourceMap: item[3],\n      supports: item[4],\n      layer: item[5]\n    };\n    if (indexByIdentifier !== -1) {\n      stylesInDOM[indexByIdentifier].references++;\n      stylesInDOM[indexByIdentifier].updater(obj);\n    } else {\n      var updater = addElementStyle(obj, options);\n      options.byIndex = i;\n      stylesInDOM.splice(i, 0, {\n        identifier: identifier,\n        updater: updater,\n        references: 1\n      });\n    }\n    identifiers.push(identifier);\n  }\n  return identifiers;\n}\nfunction addElementStyle(obj, options) {\n  var api = options.domAPI(options);\n  api.update(obj);\n  var updater = function updater(newObj) {\n    if (newObj) {\n      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {\n        return;\n      }\n      api.update(obj = newObj);\n    } else {\n      api.remove();\n    }\n  };\n  return updater;\n}\nmodule.exports = function (list, options) {\n  options = options || {};\n  list = list || [];\n  var lastIdentifiers = modulesToDom(list, options);\n  return function update(newList) {\n    newList = newList || [];\n    for (var i = 0; i < lastIdentifiers.length; i++) {\n      var identifier = lastIdentifiers[i];\n      var index = getIndexByIdentifier(identifier);\n      stylesInDOM[index].references--;\n    }\n    var newLastIdentifiers = modulesToDom(newList, options);\n    for (var _i = 0; _i < lastIdentifiers.length; _i++) {\n      var _identifier = lastIdentifiers[_i];\n      var _index = getIndexByIdentifier(_identifier);\n      if (stylesInDOM[_index].references === 0) {\n        stylesInDOM[_index].updater();\n        stylesInDOM.splice(_index, 1);\n      }\n    }\n    lastIdentifiers = newLastIdentifiers;\n  };\n};","\"use strict\";\n\nvar memo = {};\n\n/* istanbul ignore next  */\nfunction getTarget(target) {\n  if (typeof memo[target] === \"undefined\") {\n    var styleTarget = document.querySelector(target);\n\n    // Special case to return head of iframe instead of iframe itself\n    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n      try {\n        // This will throw an exception if access to iframe is blocked\n        // due to cross-origin restrictions\n        styleTarget = styleTarget.contentDocument.head;\n      } catch (e) {\n        // istanbul ignore next\n        styleTarget = null;\n      }\n    }\n    memo[target] = styleTarget;\n  }\n  return memo[target];\n}\n\n/* istanbul ignore next  */\nfunction insertBySelector(insert, style) {\n  var target = getTarget(insert);\n  if (!target) {\n    throw new Error(\"Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.\");\n  }\n  target.appendChild(style);\n}\nmodule.exports = insertBySelector;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction insertStyleElement(options) {\n  var element = document.createElement(\"style\");\n  options.setAttributes(element, options.attributes);\n  options.insert(element, options.options);\n  return element;\n}\nmodule.exports = insertStyleElement;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction setAttributesWithoutAttributes(styleElement) {\n  var nonce = typeof __webpack_nonce__ !== \"undefined\" ? __webpack_nonce__ : null;\n  if (nonce) {\n    styleElement.setAttribute(\"nonce\", nonce);\n  }\n}\nmodule.exports = setAttributesWithoutAttributes;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction apply(styleElement, options, obj) {\n  var css = \"\";\n  if (obj.supports) {\n    css += \"@supports (\".concat(obj.supports, \") {\");\n  }\n  if (obj.media) {\n    css += \"@media \".concat(obj.media, \" {\");\n  }\n  var needLayer = typeof obj.layer !== \"undefined\";\n  if (needLayer) {\n    css += \"@layer\".concat(obj.layer.length > 0 ? \" \".concat(obj.layer) : \"\", \" {\");\n  }\n  css += obj.css;\n  if (needLayer) {\n    css += \"}\";\n  }\n  if (obj.media) {\n    css += \"}\";\n  }\n  if (obj.supports) {\n    css += \"}\";\n  }\n  var sourceMap = obj.sourceMap;\n  if (sourceMap && typeof btoa !== \"undefined\") {\n    css += \"\\n/*# sourceMappingURL=data:application/json;base64,\".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), \" */\");\n  }\n\n  // For old IE\n  /* istanbul ignore if  */\n  options.styleTagTransform(css, styleElement, options.options);\n}\nfunction removeStyleElement(styleElement) {\n  // istanbul ignore if\n  if (styleElement.parentNode === null) {\n    return false;\n  }\n  styleElement.parentNode.removeChild(styleElement);\n}\n\n/* istanbul ignore next  */\nfunction domAPI(options) {\n  if (typeof document === \"undefined\") {\n    return {\n      update: function update() {},\n      remove: function remove() {}\n    };\n  }\n  var styleElement = options.insertStyleElement(options);\n  return {\n    update: function update(obj) {\n      apply(styleElement, options, obj);\n    },\n    remove: function remove() {\n      removeStyleElement(styleElement);\n    }\n  };\n}\nmodule.exports = domAPI;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction styleTagTransform(css, styleElement) {\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css;\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild);\n    }\n    styleElement.appendChild(document.createTextNode(css));\n  }\n}\nmodule.exports = styleTagTransform;","// Function to load the CSS from a given URL\r\nfunction loadCss(url) {\r\n    return fetch(url)\r\n        .then(response => response.text())\r\n        .then(css => {\r\n            const styleSheet = document.createElement(\"style\");\r\n            styleSheet.type = \"text/css\";\r\n            styleSheet.textContent = css;  // Use textContent instead of innerText\r\n            document.head.appendChild(styleSheet);\r\n        })\r\n        .catch(error => {\r\n            console.error(\"Failed to load CSS:\", error);\r\n        });\r\n}\r\n\r\nexport {\r\n    loadCss\r\n}","// Importing the CSS and HTML templates\r\nimport './css/dialog.css';\r\nimport dialogTemplate from './html/dialog.html?raw';\r\n\r\nconst createDialog = (options) => {\r\n    const dialogDefaults = {\r\n        title: '',\r\n        content: '',\r\n        contentURI: '',\r\n        buttons: [],\r\n        size: 'medium',\r\n        showLoadingIndicator: false,\r\n        contentMethod: 'GET',\r\n        contentData: null,\r\n        contentHeaders: undefined\r\n    };\r\n\r\n    const { title, content, contentURI, buttons, size, showLoadingIndicator, contentMethod, contentData, contentHeaders } = { ...dialogDefaults, ...options };\r\n\r\n    const wrapper = document.createElement('div');\r\n    wrapper.innerHTML = dialogTemplate.trim();\r\n    const dialogElement = wrapper.firstChild;\r\n\r\n    // Lifecycle event management\r\n    const lifecycleResolvers = {};\r\n    const lifecycleEvents = {};\r\n\r\n    // Define lifecycle promises as properties\r\n    ['opening', 'opened', 'closing', 'closed', 'contentLoading', 'contentLoaded'].forEach((event) => {\r\n        lifecycleEvents[event] = new Promise((resolve) => {\r\n            lifecycleResolvers[event] = resolve;\r\n        });\r\n    });\r\n\r\n    const triggerEvent = (event) => {\r\n        if (lifecycleResolvers[event]) {\r\n            lifecycleResolvers[event]();\r\n        } else {\r\n            console.warn(`No resolver found for lifecycle event: ${event}`);\r\n        }\r\n    };\r\n\r\n    const dialog = {\r\n        element: dialogElement,\r\n        buttons: {},\r\n        isClosed: false,\r\n        lifecycle: lifecycleEvents, // Lifecycle promises directly exposed here\r\n        disableButton: (key) => {\r\n            const button = dialogElement.querySelector(`.APX-dialog-button[data-key=\"${key}\"]`);\r\n            if (button) {\r\n                button.disabled = true;\r\n                button.classList.add('APX-dialog-button-disabled');\r\n            }\r\n        },\r\n        enableButton: (key) => {\r\n            const button = dialogElement.querySelector(`.APX-dialog-button[data-key=\"${key}\"]`);\r\n            if (button) {\r\n                button.disabled = false;\r\n                button.classList.remove('APX-dialog-button-disabled');\r\n            }\r\n        },\r\n        open: async () => {\r\n            try {\r\n                triggerEvent('opening');\r\n                await dialog.lifecycle.opening;\r\n\r\n                // If loading indicator is enabled and we're fetching content, show dialog first\r\n                if (showLoadingIndicator && contentURI) {\r\n                    // Append dialog to the DOM and display it first\r\n                    document.body.appendChild(dialogElement);\r\n                    dialogElement.style.display = \"flex\";\r\n                    \r\n                    // Show loading indicator\r\n                    dialogElement.querySelector(\".APX-dialog-dynamic-content\").innerHTML = '<div class=\"APX-dialog-loading-indicator\"></div>';\r\n                    \r\n                    // Load content after dialog is visible\r\n                    await fetchAndInsertContent();\r\n                } else {\r\n                    // Default behavior: load content first, then show dialog\r\n                    await fetchAndInsertContent();\r\n                    \r\n                    // Append dialog to the DOM and display it\r\n                    document.body.appendChild(dialogElement);\r\n                    dialogElement.style.display = \"flex\";\r\n                }\r\n\r\n                triggerEvent('opened');\r\n                await dialog.lifecycle.opened;\r\n            } catch (error) {\r\n                console.error('Error opening dialog:', error);\r\n            }\r\n            return dialog; // Return for daisy-chaining\r\n        },\r\n        close: async () => {\r\n            try {\r\n                triggerEvent('closing');\r\n                await dialog.lifecycle.closing;\r\n\r\n                // Cleanup and remove dialog\r\n                closeDialogAndCleanup();\r\n\r\n                triggerEvent('closed');\r\n                await dialog.lifecycle.closed;\r\n            } catch (error) {\r\n                console.error('Error during dialog closing:', error);\r\n            }\r\n            return dialog; // Return for daisy-chaining\r\n        }\r\n    };\r\n\r\n    const closeDialogAndCleanup = () => {\r\n        if (dialog.isClosed) return;\r\n\r\n        dialog.isClosed = true;\r\n        dialogElement.style.display = \"none\";\r\n        if (document.body.contains(dialogElement)) {\r\n            document.body.removeChild(dialogElement);\r\n        }\r\n    };\r\n\r\n    const setDialogSize = () => {\r\n        const dialogContent = dialogElement.querySelector(\".APX-dialog-content\");\r\n        const sizes = {\r\n            small: { width: '300px', height: '200px' },\r\n            medium: { width: '500px', height: '400px' },\r\n            large: { width: '800px', height: '600px' }\r\n        };\r\n\r\n        if (size === 'auto') return;\r\n\r\n        const selectedSize = sizes[size] || (typeof size === 'object' && size);\r\n        if (selectedSize) {\r\n            dialogContent.style.minWidth = selectedSize.width || '500px';\r\n            dialogContent.style.minHeight = selectedSize.height || '400px';\r\n        }\r\n    };\r\n\r\n    const addButtons = () => {\r\n        const buttonContainer = dialogElement.querySelector(\".APX-dialog-button-container\");\r\n\r\n        buttons.forEach(({ key, label, order = 0, align = 'flex-end', closeOnClick = true }) => {\r\n            const button = document.createElement('button');\r\n            button.classList.add('APX-dialog-button');\r\n            button.textContent = label;\r\n            button.style.order = order;\r\n            button.setAttribute('data-key', key);\r\n\r\n            // Create button context with disable/enable methods\r\n            const buttonContext = {\r\n                disable: () => {\r\n                    button.disabled = true;\r\n                    button.classList.add('APX-dialog-button-disabled');\r\n                },\r\n                enable: () => {\r\n                    button.disabled = false;\r\n                    button.classList.remove('APX-dialog-button-disabled');\r\n                },\r\n                key,\r\n                element: button\r\n            };\r\n\r\n            if (closeOnClick) {\r\n                // Handle as a one-time Promise\r\n                let firstClickResolved = false;\r\n\r\n                const firstClickPromise = new Promise((resolve) => {\r\n                    button.onclick = () => {\r\n                        if (!firstClickResolved && !button.disabled) {\r\n                            firstClickResolved = true;\r\n                            resolve({ dialog, button: buttonContext }); // Pass both dialog and button context\r\n                            dialog.close(); // Close the dialog\r\n                        }\r\n                    };\r\n                });\r\n\r\n                // Assign the promise for chaining with `.then`\r\n                dialog.buttons[key] = firstClickPromise;\r\n            } else {\r\n                // Handle as a repeated event handler\r\n                let handlers = []; // Store handlers for `.then()`\r\n\r\n                const clickPromise = {\r\n                    then: (callback) => {\r\n                        if (typeof callback === 'function') {\r\n                            handlers.push(callback); // Add to handlers\r\n                        }\r\n                        return clickPromise; // Allow chaining\r\n                    },\r\n                };\r\n\r\n                button.onclick = () => {\r\n                    if (!button.disabled) {\r\n                        handlers.forEach((handler) => handler({ dialog, button: buttonContext })); // Pass both dialog and button context\r\n                    }\r\n                };\r\n\r\n                dialog.buttons[key] = clickPromise; // Assign the \"fake\" promise\r\n            }\r\n\r\n            buttonContainer.appendChild(button);\r\n            buttonContainer.style.justifyContent = align;\r\n        });\r\n    };\r\n\r\n    const fetchAndInsertContent = async () => {\r\n        const originalCursor = document.body.style.cursor;\r\n        document.body.style.cursor = 'wait';\r\n        const dynamicContent = dialogElement.querySelector(\".APX-dialog-dynamic-content\");\r\n        \r\n        try {\r\n            triggerEvent('contentLoading');\r\n            await dialog.lifecycle.contentLoading;\r\n\r\n            const contentHtml = contentURI\r\n                ? await fetchContent(contentURI)\r\n                : content;\r\n\r\n            dynamicContent.innerHTML = contentHtml;\r\n\r\n            triggerEvent('contentLoaded');\r\n            await dialog.lifecycle.contentLoaded;\r\n        } catch (error) {\r\n            console.error('Error loading content:', error);\r\n        } finally {\r\n            document.body.style.cursor = originalCursor;\r\n        }\r\n    };\r\n\r\n    const fetchContent = async (uri) => {\r\n        const method = (contentMethod || 'GET').toUpperCase();\r\n\r\n        // Always allow custom headers; we only add Content-Type when we can infer it\r\n        const headers = { ...(contentHeaders || {}) };\r\n        const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === 'content-type');\r\n\r\n        /**\r\n         * Build RequestInit depending on method and contentData type.\r\n         * We avoid setting Content-Type for FormData and raw string/Blob payloads,\r\n         * unless the caller explicitly provided it via contentHeaders.\r\n         */\r\n        const init = { method };\r\n\r\n        if (method === 'POST') {\r\n            let body = undefined;\r\n\r\n            const isFormData = typeof FormData !== 'undefined' && contentData instanceof FormData;\r\n            const isURLSearchParams = typeof URLSearchParams !== 'undefined' && contentData instanceof URLSearchParams;\r\n            const isBlob = typeof Blob !== 'undefined' && contentData instanceof Blob;\r\n            const isString = typeof contentData === 'string';\r\n            const isPlainObject = contentData && typeof contentData === 'object' && !isFormData && !isURLSearchParams && !isBlob;\r\n\r\n            if (isFormData) {\r\n                body = contentData;\r\n                // Do not set Content-Type for FormData; browser will set the boundary\r\n            } else if (isURLSearchParams) {\r\n                body = contentData;\r\n                if (!hasContentType) headers['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8';\r\n            } else if (isPlainObject) {\r\n                body = JSON.stringify(contentData);\r\n                if (!hasContentType) headers['Content-Type'] = 'application/json';\r\n            } else if (isString || isBlob) {\r\n                body = contentData;\r\n                // Content-Type left to caller if needed\r\n            } else if (contentData != null) {\r\n                // Fallback: try send as-is\r\n                body = contentData;\r\n            }\r\n\r\n            if (body !== undefined) {\r\n                init.body = body;\r\n            }\r\n        }\r\n\r\n        if (Object.keys(headers).length > 0) {\r\n            init.headers = headers;\r\n        }\r\n\r\n        const response = await fetch(uri, init);\r\n        if (!response.ok) throw new Error(`Failed to fetch content: ${response.statusText}`);\r\n        return response.text();\r\n    };\r\n\r\n    // Initialize dialog\r\n    setDialogSize();\r\n    addButtons();\r\n\r\n    // Set title and close button handler\r\n    dialogElement.querySelector(\".APX-dialog-title\").textContent = title;\r\n    dialogElement.querySelector('.APX-close-dialog').onclick = dialog.close;\r\n\r\n    return dialog;\r\n};\r\n\r\nexport default createDialog;\r\n","let counter = 0;\r\nconst doCallbacks = {};\r\nconst timeouts = {};\r\n\r\n/**\r\n * This function adds an event listener to the elements and returns an object with a do method to add callback functions.\r\n * @param {Object} apx - The apx object to augment with the listen function.\r\n * @returns {Object} - The augmented apx object.\r\n */\r\nexport default function (apx) {\r\n    let elements = apx.elements;\r\n\r\n    /**\r\n     * Adds an event listener to the elements and returns an object with a do method to add callback functions.\r\n     * @param {string} eventType - The type of event to listen for (e.g. 'click', 'keydown', etc.).\r\n     * @param {string} [selector] - The CSS selector to use for event delegation (optional).\r\n     * @returns {Object} - An object with a do method to add callback functions.\r\n     * @example\r\n     * apx.listen('click', '.my-button').do((event) => {\r\n     *   console.log('Button clicked!', event.target);\r\n     * });\r\n     */\r\n    apx.listen = function (eventTypes, secondArgument, thirdArgument) {\r\n        let selector;\r\n        let options = {};\r\n        // Determine if the second argument is a selector or options\r\n        if (typeof secondArgument === 'string') {\r\n            selector = secondArgument;\r\n            options = thirdArgument || {};\r\n        } else {\r\n            options = secondArgument || {};\r\n        }\r\n\r\n        const uniqueId = generateUniqueId();\r\n        const timeoutDuration = options.timeout || 0;\r\n        \r\n        if (!Array.isArray(eventTypes)) {\r\n            eventTypes = [eventTypes]; // Ensure eventTypes is an array\r\n        }\r\n        \r\n        eventTypes.forEach((eventType) => {\r\n            elements.forEach((element) => {\r\n                element.addEventListener(eventType, (event) => {\r\n                    executeCallbacks(event, uniqueId, timeoutDuration, selector, element);\r\n                });\r\n            });\r\n        });\r\n\r\n        return {\r\n            /**\r\n             * Adds a callback function to the doCallbacks object for the current event listener.\r\n             * @param {Function} doCallback - The callback function to execute when the event is triggered.\r\n             * @returns {Object} - Returns the current object to allow for chained calls.\r\n             * @example\r\n             * apx.listen('click', '.my-button').do((event) => {\r\n             *   console.log('Button clicked!', event.target);\r\n             * }).do((event) => {\r\n             *   console.log('Another callback function!');\r\n             * });\r\n             */\r\n            do: function (doCallback) {\r\n                if (!doCallbacks[uniqueId]) {\r\n                    doCallbacks[uniqueId] = [];\r\n                }\r\n                doCallbacks[uniqueId].push(doCallback);\r\n                return this; // Return the object to allow for chained calls\r\n            },\r\n        };\r\n    };\r\n\r\n    /**\r\n     * Manually triggers the registered callbacks for a given event type on all elements or creates a new event if a string is provided.\r\n     * @param {string|Event} event - The event to trigger. This can be an event type string (like 'click') or an actual Event object.\r\n     */\r\n    apx.trigger = function (event) {\r\n        let eventType;\r\n        if (typeof event === 'string') {\r\n            eventType = event;\r\n            event = new Event(event, { bubbles: true, cancelable: true });\r\n        } else if (event instanceof Event) {\r\n            eventType = event.type;\r\n        } else {\r\n            console.error('Invalid event type provided to apx.trigger. It must be either a string or Event object.');\r\n            return;\r\n        }\r\n\r\n        apx.elements.forEach((element) => {\r\n            element.dispatchEvent(event);  // This will allow the event to bubble up naturally.\r\n        });\r\n\r\n        // Handle event delegation manually by executing callbacks if the target matches the selector\r\n        Object.keys(doCallbacks).forEach((uniqueId) => {\r\n            const callbackDetails = doCallbacks[uniqueId];\r\n            if (callbackDetails && callbackDetails.eventType === eventType) {\r\n                // Check if the event target matches the selector used during listener registration\r\n                const { selector } = callbackDetails;\r\n                if (!selector || event.target.matches(selector)) {\r\n                    executeCallbacks(event, uniqueId, 0, selector, event.target);  // Immediate execution, no timeout\r\n                }\r\n            }\r\n        });\r\n    };\r\n    \r\n    return apx;\r\n};\r\n\r\n\r\nfunction executeCallbacks(event, uniqueId, timeoutDuration, selector = '', element) {\r\n    const matchedElement = selector ? closest(event.target, selector) : element;\r\n    if (!matchedElement) {\r\n        return;\r\n    }\r\n\r\n    // Clear any previous timeout for this uniqueId to prevent unintended behavior\r\n    clearTimeout(timeouts[uniqueId]);\r\n\r\n    // Function to handle the execution of callbacks\r\n    function handleCallbackExecution() {\r\n        if (doCallbacks[uniqueId]) {\r\n            doCallbacks[uniqueId].reduce((prevPromise, doCallback) => {\r\n                return prevPromise.then(() => {\r\n                    return new Promise((resolve, reject) => {\r\n                        try {\r\n                            const result = doCallback.bind(matchedElement)(event);\r\n                            if (result instanceof Promise) {\r\n                                result.then(resolve).catch(reject);\r\n                            } else {\r\n                                resolve(result);\r\n                            }\r\n                        } catch (error) {\r\n                            reject(error);\r\n                        }\r\n                    });\r\n                });\r\n            }, Promise.resolve()).catch(error => {\r\n                console.error('Error in callback chain:', error);\r\n            });\r\n        }\r\n    }\r\n\r\n    // Check if timeoutDuration is zero to decide whether to delay the callback execution or not\r\n    if (timeoutDuration === 0) {\r\n        handleCallbackExecution();\r\n    } else {\r\n        timeouts[uniqueId] = setTimeout(handleCallbackExecution, timeoutDuration);\r\n    }\r\n}\r\n\r\n\r\nfunction generateUniqueId() {\r\n    const randomPart = Math.random().toString(36).substr(2, 9); // More randomness\r\n    const uniqueId = `${Date.now()}_${randomPart}_${counter}`;\r\n    counter = (counter + 1) % 1000; // Reset counter to avoid overflow\r\n\r\n    return uniqueId;\r\n}\r\n\r\nfunction closest(element, selector) {\r\n    while (element && element.nodeType === 1) {\r\n        if (element.matches(selector)) {\r\n            return element;\r\n        }\r\n        element = element.parentNode;\r\n    }\r\n    return null;\r\n}\r\n","// Minimal, framework-agnostic ToastManager for APX\r\n// ESM-first, no side effects on import. DOM only when used.\r\nimport './css/toast.css';\r\n\r\n/**\r\n * @typedef {Object} ToastConfig\r\n * @property {'bottom-right'|'bottom-left'|'top-right'|'top-left'} [position]\r\n * @property {number} [maxToasts]\r\n * @property {number} [defaultDurationMs]\r\n * @property {number} [zIndex]\r\n * @property {'polite'|'assertive'|'off'} [ariaLive]\r\n * @property {number} [gap]\r\n * @property {boolean} [dedupe]\r\n * @property {string} [containerClass]\r\n * @property {number} [offset]\r\n */\r\n\r\n/**\r\n * @typedef {Object} ToastOptions\r\n * @property {string|Node} message\r\n * @property {'info'|'success'|'warning'|'danger'} [type]\r\n * @property {number} [durationMs]\r\n * @property {boolean} [dismissible]\r\n * @property {string} [id]\r\n * @property {(ref: ToastRef, ev: MouseEvent) => void} [onClick]\r\n * @property {(ref: ToastRef, reason: 'timeout'|'close'|'api'|'overflow') => void} [onClose]\r\n * @property {string} [className]\r\n */\r\n\r\n/**\r\n * @typedef {Object} ToastRef\r\n * @property {string} id\r\n * @property {HTMLElement} el\r\n * @property {(reason?: 'api'|'close') => void} close\r\n * @property {(partial: Partial<ToastOptions>) => void} update\r\n * @property {() => Promise<void>} whenClosed\r\n * @property {(event: 'close'|'click', handler: Function) => () => void} on\r\n * @property {(event: 'close'|'click', handler: Function) => void} off\r\n */\r\n\r\nconst isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';\r\n\r\nconst DEFAULT_CONFIG = {\r\n    position: 'bottom-right',\r\n    maxToasts: 5,\r\n    defaultDurationMs: 5000,\r\n    zIndex: 11000,\r\n    ariaLive: 'polite',\r\n    gap: 8,\r\n    dedupe: false,\r\n    containerClass: '',\r\n    offset: 0\r\n};\r\n\r\n/**\r\n * Create an element with classes\r\n */\r\nfunction createEl(tag, classNames) {\r\n    const el = document.createElement(tag);\r\n    if (classNames) {\r\n        classNames.split(' ').filter(Boolean).forEach(c => el.classList.add(c));\r\n    }\r\n    return el;\r\n}\r\n\r\n/**\r\n * ToastManager class\r\n */\r\nclass ToastManager {\r\n    /** @param {Partial<ToastConfig>=} config */\r\n    constructor(config) {\r\n        /** @type {ToastConfig} */\r\n        this.config = { ...DEFAULT_CONFIG, ...(config || {}) };\r\n        /** @type {HTMLElement|null} */\r\n        this.container = null;\r\n        /** @type {Map<string, ToastRef>} */\r\n        this.idToRef = new Map();\r\n        /** @type {ToastRef[]} */\r\n        this.open = [];\r\n    }\r\n\r\n    /** @param {Partial<ToastConfig>} config */\r\n    configure(config) {\r\n        this.config = { ...this.config, ...(config || {}) };\r\n        if (this.container) this.applyContainerConfig();\r\n    }\r\n\r\n    /** @param {'polite'|'assertive'|'off'} mode */\r\n    setAriaLive(mode) { this.configure({ ariaLive: mode }); }\r\n\r\n    /** @returns {ToastRef[]} */\r\n    getOpenToasts() { return this.open.slice(); }\r\n\r\n    /** @param {ToastOptions} opts */\r\n    show(opts) {\r\n        if (!isBrowser) return /** @type {any} */(null);\r\n        const options = this.normalizeOptions(opts);\r\n\r\n        if (this.config.dedupe && options.id && this.idToRef.has(options.id)) {\r\n            const ref = this.idToRef.get(options.id);\r\n            ref.update(options);\r\n            return ref;\r\n        }\r\n\r\n        this.ensureContainer();\r\n\r\n        const toastEl = createEl('div', `APX-toast APX-toast--${options.type}`);\r\n        toastEl.setAttribute('role', 'status');\r\n        const toastId = options.id || `t_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;\r\n        toastEl.dataset.toastId = toastId;\r\n        if (options.className) toastEl.className += ` ${options.className}`;\r\n\r\n        const contentEl = createEl('div', 'APX-toast__content');\r\n        if (typeof options.message === 'string') {\r\n            contentEl.textContent = options.message;\r\n        } else if (options.message) {\r\n            contentEl.appendChild(options.message);\r\n        }\r\n        toastEl.appendChild(contentEl);\r\n\r\n        let closeBtn = null;\r\n        if (options.dismissible !== false) {\r\n            closeBtn = createEl('button', 'APX-toast__close');\r\n            closeBtn.setAttribute('aria-label', 'Close');\r\n            closeBtn.type = 'button';\r\n            toastEl.appendChild(closeBtn);\r\n        }\r\n\r\n        this.container.appendChild(toastEl);\r\n\r\n        // Enter animation\r\n        toastEl.classList.add('APX-toast--enter');\r\n        requestAnimationFrame(() => {\r\n            toastEl.classList.add('APX-toast--enter-active');\r\n        });\r\n\r\n        // Event handling and timers\r\n        let remaining = options.durationMs;\r\n        let timerId = null;\r\n        let startTs = null;\r\n        const handlers = { click: new Set(), close: new Set() };\r\n\r\n        const startTimer = () => {\r\n            if (!remaining || remaining <= 0) return; // sticky\r\n            startTs = Date.now();\r\n            timerId = window.setTimeout(() => ref.close('timeout'), remaining);\r\n        };\r\n        const pauseTimer = () => {\r\n            if (timerId != null) {\r\n                window.clearTimeout(timerId);\r\n                timerId = null;\r\n                if (startTs != null) remaining -= (Date.now() - startTs);\r\n            }\r\n        };\r\n\r\n        /** @type {ToastRef} */\r\n        const ref = {\r\n            id: toastId,\r\n            el: toastEl,\r\n            close: (reason) => {\r\n                cleanup(reason || 'api');\r\n            },\r\n            update: (partial) => {\r\n                const merged = this.normalizeOptions({ ...options, ...partial });\r\n                // update content\r\n                if (typeof merged.message === 'string') {\r\n                    contentEl.textContent = merged.message;\r\n                } else if (merged.message) {\r\n                    contentEl.innerHTML = '';\r\n                    contentEl.appendChild(merged.message);\r\n                }\r\n                // update type class\r\n                ['info','success','warning','danger'].forEach(t => toastEl.classList.remove(`APX-toast--${t}`));\r\n                toastEl.classList.add(`APX-toast--${merged.type}`);\r\n                // update classes\r\n                if (options.className !== merged.className) {\r\n                    if (options.className) toastEl.classList.remove(...options.className.split(' ').filter(Boolean));\r\n                    if (merged.className) toastEl.classList.add(...merged.className.split(' ').filter(Boolean));\r\n                }\r\n                // update duration logic\r\n                options.durationMs = merged.durationMs;\r\n                remaining = merged.durationMs;\r\n                pauseTimer();\r\n                startTimer();\r\n            },\r\n            whenClosed: () => closedPromise,\r\n            on: (event, handler) => { handlers[event].add(handler); return () => ref.off(event, handler); },\r\n            off: (event, handler) => { handlers[event].delete(handler); }\r\n        };\r\n\r\n        const notify = (event, arg) => handlers[event].forEach(fn => { try { fn(arg); } catch (_) {} });\r\n\r\n        const closedPromise = new Promise(resolve => {\r\n            const finish = (reason) => {\r\n                notify('close', reason);\r\n                if (typeof options.onClose === 'function') {\r\n                    try { options.onClose(ref, reason); } catch(_){}\r\n                }\r\n                resolve();\r\n            };\r\n\r\n            const cleanup = (reason) => {\r\n                if (!toastEl) return;\r\n                pauseTimer();\r\n                // If overflow, remove immediately to enforce hard cap\r\n                if (reason === 'overflow') {\r\n                    if (toastEl.parentElement) toastEl.parentElement.removeChild(toastEl);\r\n                    const idx = this.open.indexOf(ref);\r\n                    if (idx >= 0) this.open.splice(idx, 1);\r\n                    this.idToRef.delete(toastId);\r\n                    finish(reason);\r\n                    return;\r\n                }\r\n\r\n                // Otherwise, animate out\r\n                toastEl.classList.add('APX-toast--exit');\r\n                requestAnimationFrame(() => toastEl.classList.add('APX-toast--exit-active'));\r\n\r\n                const removeEl = () => {\r\n                    toastEl.removeEventListener('transitionend', removeEl);\r\n                    if (toastEl.parentElement) toastEl.parentElement.removeChild(toastEl);\r\n                    const idx = this.open.indexOf(ref);\r\n                    if (idx >= 0) this.open.splice(idx, 1);\r\n                    this.idToRef.delete(toastId);\r\n                    finish(reason);\r\n                };\r\n                toastEl.addEventListener('transitionend', removeEl);\r\n            };\r\n\r\n            // attach close behavior\r\n            ref.close = (reason) => cleanup(reason || 'api');\r\n        });\r\n\r\n        // Click handling\r\n        toastEl.addEventListener('click', (ev) => {\r\n            notify('click', ev);\r\n            if (typeof options.onClick === 'function') {\r\n                try { options.onClick(ref, ev); } catch(_){}\r\n            }\r\n        });\r\n\r\n        // Hover pause\r\n        toastEl.addEventListener('mouseenter', pauseTimer);\r\n        toastEl.addEventListener('mouseleave', () => startTimer());\r\n\r\n        if (closeBtn) closeBtn.addEventListener('click', (ev) => { ev.stopPropagation(); ref.close('close'); });\r\n\r\n        // Track\r\n        this.open.push(ref);\r\n        this.idToRef.set(toastId, ref);\r\n\r\n        // Overflow policy\r\n        if (this.open.length > this.config.maxToasts) {\r\n            const oldest = this.open[0];\r\n            oldest.close('overflow');\r\n        }\r\n\r\n        startTimer();\r\n        return ref;\r\n    }\r\n\r\n    /**\r\n     * Convenience helpers\r\n     */\r\n    info(message, opts) { return this.show({ ...(opts||{}), message, type: 'info' }); }\r\n    success(message, opts) { return this.show({ ...(opts||{}), message, type: 'success' }); }\r\n    warning(message, opts) { return this.show({ ...(opts||{}), message, type: 'warning' }); }\r\n    danger(message, opts) { return this.show({ ...(opts||{}), message, type: 'danger' }); }\r\n\r\n    /** @param {'api'|'overflow'} [reason] */\r\n    closeAll(reason) {\r\n        // copy to avoid mutation during iteration\r\n        const all = this.open.slice();\r\n        all.forEach(r => r.close(reason || 'api'));\r\n    }\r\n\r\n    /** @param {ToastOptions} opts */\r\n    normalizeOptions(opts) {\r\n        const o = { ...opts };\r\n        if (!o.type) o.type = 'info';\r\n        if (typeof o.dismissible !== 'boolean') o.dismissible = true;\r\n        if (typeof o.durationMs !== 'number') o.durationMs = this.config.defaultDurationMs;\r\n        return o;\r\n    }\r\n\r\n    ensureContainer() {\r\n        if (this.container || !isBrowser) return;\r\n        const c = createEl('div', 'APX-toast-container');\r\n        const pos = this.config.position || 'bottom-right';\r\n        c.classList.add(`APX-toast-container--${pos}`);\r\n        if (this.config.containerClass) c.classList.add(this.config.containerClass);\r\n        c.style.zIndex = String(this.config.zIndex);\r\n        c.style.gap = `${this.config.gap}px`;\r\n        if (this.config.offset) {\r\n            const offset = `${this.config.offset}px`;\r\n            if (pos.includes('bottom')) c.style.bottom = offset; else c.style.top = offset;\r\n            if (pos.includes('right')) c.style.right = offset; else c.style.left = offset;\r\n        }\r\n        c.setAttribute('aria-live', String(this.config.ariaLive));\r\n        document.body.appendChild(c);\r\n        this.container = c;\r\n        this.applyContainerConfig();\r\n    }\r\n\r\n    applyContainerConfig() {\r\n        if (!this.container) return;\r\n        this.container.style.zIndex = String(this.config.zIndex);\r\n        this.container.style.gap = `${this.config.gap}px`;\r\n        this.container.setAttribute('aria-live', String(this.config.ariaLive));\r\n        // Update position class\r\n        const posClasses = ['bottom-right','bottom-left','top-right','top-left'].map(p => `APX-toast-container--${p}`);\r\n        this.container.classList.remove(...posClasses);\r\n        this.container.classList.add(`APX-toast-container--${this.config.position}`);\r\n    }\r\n}\r\n\r\n/**\r\n * @param {Partial<ToastConfig>=} config\r\n * @returns {ToastManager}\r\n */\r\nfunction createToastManager(config) {\r\n    return new ToastManager(config);\r\n}\r\n\r\n// High-level APX.toast API (default & named managers)\r\nlet _defaultManager = null;\r\nconst _getDefault = () => {\r\n    if (!_defaultManager) _defaultManager = createToastManager();\r\n    return _defaultManager;\r\n};\r\n\r\n/**\r\n * Toast API surface to be attached as APX.toast.\r\n * Callable form proxies to defaultManager.show(opts): APX.toast({...})\r\n */\r\nfunction toast(opts) {\r\n    return _getDefault().show(opts);\r\n}\r\n\r\nObject.assign(toast, {\r\n    /**\r\n     * Create a manager. If first arg is string, register as named under toast.custom[name]\r\n     * @param {string|Partial<ToastConfig>} nameOrConfig\r\n     * @param {Partial<ToastConfig>=} maybeConfig\r\n     * @returns {ToastManager}\r\n     */\r\n    create: (nameOrConfig, maybeConfig) => {\r\n        if (typeof nameOrConfig === 'string') {\r\n            const name = nameOrConfig;\r\n            const manager = new ToastManager({ ...(maybeConfig || {}) });\r\n            if (!toast.custom) toast.custom = {};\r\n            toast.custom[name] = manager;\r\n            return manager;\r\n        }\r\n        return new ToastManager({ ...(nameOrConfig || {}) });\r\n    },\r\n    /** @type {Record<string, ToastManager>} */\r\n    custom: {},\r\n    /** @param {string} name */\r\n    use: (name) => (toast.custom && toast.custom[name]) || null,\r\n    Manager: ToastManager,\r\n    show: (opts) => _getDefault().show(opts),\r\n    info: (message, opts) => _getDefault().info(message, opts),\r\n    success: (message, opts) => _getDefault().success(message, opts),\r\n    warning: (message, opts) => _getDefault().warning(message, opts),\r\n    danger: (message, opts) => _getDefault().danger(message, opts),\r\n    configure: (config) => _getDefault().configure(config),\r\n    setAriaLive: (mode) => _getDefault().setAriaLive(mode),\r\n    closeAll: (reason) => _getDefault().closeAll(reason),\r\n    getOpenToasts: () => _getDefault().getOpenToasts()\r\n});\r\n\r\nexport default toast;\r\nexport { ToastManager, createToastManager, toast };\r\n","import './css/tristate.css';\r\n\r\n/**\r\n * Creates a tri-state checkbox for each checkbox element in the apx.elements array.\r\n * @param {Array<HTMLElement>} apx - An array of HTMLElements which is returned by APX()\r\n * @example\r\n * // Call the tristate function on an array of checkbox elements\r\n * apx.tristate();\r\n */\r\nexport default function (apx) {\r\n    apx.tristate = function (options = {}){\r\n        apx.elements.forEach((element) => {\r\n            if (element.type === 'checkbox') {\r\n                const [originalCheckbox, tristateDom, hiddenInput] = createTriStateCheckbox(element,options);\r\n                //If there is a \"options.callbacks.after\" callback in options call it\r\n                if(options.callbacks && options.callbacks.after && typeof options.callbacks.after === 'function') {\r\n                    options.callbacks.after(originalCheckbox, tristateDom, hiddenInput);\r\n                }               \r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nfunction toggleTriStateCheckboxState(customCheckbox, actualCheckbox, hiddenInput) {\r\n    if (customCheckbox.classList.contains('checked')) {\r\n        customCheckbox.classList.remove('checked');\r\n        customCheckbox.classList.add('crossed');\r\n        actualCheckbox.checked = false;\r\n        hiddenInput.value = 'false';\r\n    } else if (customCheckbox.classList.contains('crossed')) {\r\n        customCheckbox.classList.remove('crossed');\r\n        customCheckbox.classList.add('unchecked');\r\n        hiddenInput.removeAttribute('name'); // Ensure the hidden input doesn't post any value\r\n        hiddenInput.removeAttribute('value'); // Ensure the hidden input doesn't post any value\r\n    } else {\r\n        customCheckbox.classList.remove('unchecked');\r\n        customCheckbox.classList.add('checked');\r\n        actualCheckbox.checked = true;\r\n        hiddenInput.value = 'true';\r\n        hiddenInput.setAttribute('name', actualCheckbox.dataset.name); // Restore the name for posting\r\n    }\r\n}\r\n\r\nfunction createTriStateCheckbox(checkboxElement, options) {\r\n    \r\n    //get the checkbox margins including browser default\r\n    const checkboxStyle = window.getComputedStyle(checkboxElement);\r\n    // Hide the original checkbox\r\n    checkboxElement.style.display = 'none';\r\n\r\n    // Create the custom checkbox div and set its initial state\r\n    const tristateDom = document.createElement('div');\r\n    tristateDom.classList.add('apx-tristate');\r\n    if (options.size) {\r\n        if (options.size.width) {\r\n            tristateDom.style.width = options.size.width + 'px';\r\n        }\r\n        if (options.size.height) {\r\n            tristateDom.style.height = options.size.height + 'px';\r\n        }\r\n    }\r\n    if(options.classes) tristateDom.classList.add(...computeClasses(options.classes));\r\n\r\n    tristateDom.style.margin = checkboxStyle.margin;\r\n\r\n    if (checkboxElement.checked) {\r\n        tristateDom.classList.add('checked');\r\n    } else {\r\n        tristateDom.classList.add('unchecked');\r\n    }\r\n\r\n    // Create the hidden input field\r\n    const hiddenInput = document.createElement('input');\r\n    hiddenInput.type = 'hidden';\r\n    hiddenInput.name = checkboxElement.name; // Copy the name from the original checkbox\r\n    checkboxElement.dataset.name = checkboxElement.name; // Store the name in a data attribute for later use\r\n    checkboxElement.removeAttribute('name'); // Remove the name from the original checkbox to avoid double posting\r\n\r\n    if (options.defaultState) setDefaultState(options, tristateDom, hiddenInput);\r\n    else{\r\n        // Set the initial value for the hidden input based on the checkbox's state\r\n        if (checkboxElement.checked) {\r\n            hiddenInput.value = 'true';\r\n        } else {\r\n            hiddenInput.name = ''; // Ensure the hidden input doesn't post any value\r\n            hiddenInput.value = '';\r\n        }\r\n    }\r\n\r\n    //handle accessibility, set the tabindex to the same as the checkbox\r\n    tristateDom.tabIndex = checkboxElement.tabIndex;\r\n\r\n    // Insert the hidden input inside the custom checkbox div\r\n    tristateDom.appendChild(hiddenInput);\r\n\r\n    // Insert it next to the actual checkbox\r\n    checkboxElement.parentNode.insertBefore(tristateDom, checkboxElement.nextSibling);\r\n\r\n    // Add event listener\r\n    tristateDom.addEventListener('click', function (e) {\r\n        toggleTriStateCheckboxState(tristateDom, checkboxElement, hiddenInput);\r\n        bubbleEventsToOriginalCheckbox(options, checkboxElement, tristateDom, hiddenInput, e);\r\n    });\r\n    tristateDom.addEventListener('keyup', onkeyup.bind(null, checkboxElement));\r\n\r\n    return [checkboxElement, tristateDom, hiddenInput];\r\n}\r\n\r\nfunction setDefaultState(options, tristateDom, hiddenInput) {\r\n    //for all values possible for defaultState, set the initial state of the checkbox\r\n    if (options.defaultState === 'checked') {\r\n        tristateDom.classList.remove('unchecked');\r\n        tristateDom.classList.add('checked');\r\n        hiddenInput.value = 'true';\r\n    }\r\n    else if (options.defaultState === 'unchecked') {\r\n        tristateDom.classList.remove('checked');\r\n        tristateDom.classList.add('unchecked');\r\n        hiddenInput.removeAttribute('name'); // Ensure the hidden input doesn't post any value\r\n        hiddenInput.removeAttribute('value'); // Ensure the hidden input doesn't post any value\r\n    }\r\n    else if (options.defaultState === 'crossed') {\r\n        tristateDom.classList.remove('checked');\r\n        tristateDom.classList.add('crossed');\r\n        hiddenInput.value = 'false';\r\n    }\r\n}\r\n\r\nfunction computeClasses(classes) {\r\n    let computedClasses = [];\r\n    if(typeof classes === 'string') {\r\n        //replace multiple white spaces with a single space\r\n        classes = classes.replace(/\\s\\s+/g, ' ');\r\n        if(classes.indexOf(' ') > -1)\r\n            computedClasses = classes.split(' ');\r\n        else if(classes.indexOf(',') > -1)\r\n            computedClasses = classes.split(',');\r\n        else\r\n            computedClasses = [classes];\r\n    }\r\n    else if(Array.isArray(classes)) {\r\n        computedClasses = classes;\r\n    }\r\n    return computedClasses;\r\n}\r\n\r\nfunction bubbleEventsToOriginalCheckbox(options, checkboxElement, tristateDom, hiddenInput, event) {\r\n    //if options.callbacks.change is set, call it\r\n    if(options.callbacks && options.callbacks.change && typeof options.callbacks.change === 'function') {\r\n        options.callbacks.change(checkboxElement, tristateDom, hiddenInput);\r\n    }\r\n\r\n    if(!options.bubbleEvents) return;\r\n\r\n    if(event.type === 'click') {\r\n        checkboxElement.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));\r\n    }\r\n    else if(event.type === 'keyup') {\r\n        checkboxElement.dispatchEvent(new KeyboardEvent('keyup', { key: ' ', bubbles: true, cancelable: true }));\r\n    }\r\n    else if(event.type === 'change') {\r\n        checkboxElement.dispatchEvent(new Event('change', { bubbles: true, cancelable: true }));\r\n    }\r\n}\r\n\r\nfunction onkeyup(checkboxElement, event) {\r\n    if (event.keyCode === 32) {\r\n        bubbleEventsToOriginalCheckbox(checkboxElement, event);\r\n        event.preventDefault();\r\n        event.target.click();\r\n    }\r\n}","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.b = document.baseURI || self.location.href;\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t\"main\": 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// no jsonp function","__webpack_require__.nc = undefined;","import augmentWithListen from './modules/listen/listen.mjs';\r\nimport augmentWithTristate from './modules/tristate/tristate.mjs';\r\nimport dialog from './modules/dialog/dialog.mjs';\r\nimport toast from './modules/toast/toast.mjs';\r\nimport { loadCss } from './modules/common.mjs';\r\n\r\n/**\r\n * Creates an APX object that wraps one or more HTML elements.\r\n * @param {string|HTMLElement|NodeList|HTMLCollection|Array<HTMLElement>|jQuery|Function} input - The input to create the APX object from.\r\n * @returns {Object} The APX object.\r\n * @throws {Error} If the input type is invalid.\r\n * @example\r\n * // XPath\r\n * const apx1 = APX('//div[@class=\"example\"]');\r\n *\r\n * // CSS selector\r\n * const apx2 = APX('.example');\r\n *\r\n * // Single element\r\n * const element = document.querySelector('.example');\r\n * const apx3 = APX(element);\r\n *\r\n * // NodeList or HTMLCollection\r\n * const nodeList = document.querySelectorAll('.example');\r\n * const apx4 = APX(nodeList);\r\n *\r\n * // Array of elements\r\n * const elements = [document.querySelector('.example1'), document.querySelector('.example2')];\r\n * const apx5 = APX(elements);\r\n *\r\n * // jQuery object\r\n * const $example = $('.example');\r\n * const apx6 = APX($example);\r\n *\r\n * // Function returning an APX object\r\n * const apx7 = APX(() => APX('.example'));\r\n */\r\nconst APX = function (input, context = document) {\r\n    let elements;\r\n\r\n    // Validate context\r\n    if (typeof context === 'string') {\r\n        context = document.querySelector(context);\r\n    }\r\n    else if (APX.isAPXObject(context)) {\r\n        context = context.first();\r\n    } else if (!(context instanceof HTMLElement || context instanceof Document)) {\r\n        throw new Error('Invalid context for APX');\r\n    }\r\n\r\n    if (typeof input === 'string' && input.startsWith('//')) {\r\n        // XPath with context\r\n        elements = document.evaluate(input, context, null, XPathResult.ANY_TYPE, null);\r\n        let nodes = [];\r\n        let node = elements.iterateNext();\r\n        while (node) {\r\n            nodes.push(node);\r\n            node = elements.iterateNext();\r\n        }\r\n        elements = nodes;\r\n    } else if (typeof input === 'string') {\r\n        // CSS selector with context\r\n        elements = context.querySelectorAll(input);\r\n    } else if (input instanceof HTMLElement) {\r\n        // Single element within context\r\n        elements = context.contains(input) ? [input] : [];\r\n    } else if (input instanceof NodeList || input instanceof HTMLCollection) {\r\n        // NodeList or HTMLCollection within context\r\n        elements = Array.from(input).filter(el => context.contains(el));\r\n    } else if (Array.isArray(input) && input.every(el => el instanceof HTMLElement)) {\r\n        // Array of elements within context\r\n        elements = input.filter(el => context.contains(el));\r\n    } else if (typeof jQuery != 'undefined' && input instanceof jQuery) {\r\n        // jQuery object within context\r\n        elements = Array.from(input.get()).filter(el => context.contains(el));\r\n    } else if (typeof input === 'function') {\r\n        // Function returning an APX object with context\r\n        elements = APX(input(), context);\r\n    } else {\r\n        throw new Error('Invalid input type for APX');\r\n    }\r\n\r\n    var apx = {\r\n        elements: elements,\r\n        _isAPXObject: true\r\n    };\r\n    apx.length = elements.length;\r\n    apx.each = function (callback) {\r\n        if (this.elements instanceof Array) this.elements.forEach(callback);\r\n        if (this.elements instanceof NodeList) Array.from(this.elements).forEach(callback);\r\n        return this;\r\n    };\r\n    apx.get = function (index) {\r\n        return this.elements[index];\r\n    };\r\n    apx.all = function () {\r\n        if (this.elements instanceof Array) return this.elements;\r\n        if (this.elements instanceof NodeList) return Array.from(this.elements);\r\n        return this;\r\n    };\r\n    apx.first = function () {\r\n        return this.get(0);\r\n    };\r\n    augmentWithListen(apx);\r\n    augmentWithTristate(apx);\r\n    return apx;\r\n};\r\n\r\nAPX.loadCss = loadCss;\r\nAPX.dialog = dialog;\r\nAPX.toast = toast;\r\nAPX.isAPXObject = function (obj) {\r\n    return obj && obj._isAPXObject === true;\r\n}\r\nAPX.is_numeric = (n) => {\r\n    return !isNaN(n - parseFloat(n));\r\n}\r\n\r\nexport default APX;"],"names":[],"sourceRoot":""}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"APX.dev.mjs","mappings":";;;;;;;;;;;;;;;;AAAA;AACgH;AACjB;AAC/F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,WAAW;AACX;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,OAAO,uGAAuG,MAAM,UAAU,UAAU,UAAU,UAAU,UAAU,UAAU,UAAU,UAAU,YAAY,aAAa,OAAO,KAAK,YAAY,WAAW,UAAU,UAAU,YAAY,WAAW,UAAU,YAAY,aAAa,aAAa,OAAO,KAAK,UAAU,OAAO,KAAK,UAAU,UAAU,UAAU,YAAY,aAAa,aAAa,OAAO,MAAM,UAAU,YAAY,WAAW,OAAO,YAAY,SAAS,UAAU,UAAU,YAAY,aAAa,aAAa,aAAa,WAAW,YAAY,aAAa,OAAO,QAAQ,YAAY,aAAa,WAAW,OAAO,YAAY,MAAM,YAAY,aAAa,WAAW,UAAU,YAAY,aAAa,WAAW,UAAU,YAAY,aAAa,OAAO,KAAK,YAAY,aAAa,aAAa,OAAO,KAAK,UAAU,UAAU,UAAU,YAAY,OAAO,YAAY,MAAM,UAAU,YAAY,aAAa,WAAW,UAAU,MAAM,KAAK,UAAU,UAAU,UAAU,YAAY,aAAa,aAAa,aAAa,OAAO,KAAK,sBAAsB,uBAAuB,MAAM,KAAK,UAAU,YAAY,yBAAyB,aAAa,aAAa,aAAa,OAAO,KAAK,wBAAwB,aAAa,OAAO,YAAY,MAAM,UAAU,YAAY,WAAW,UAAU,UAAU,UAAU,YAAY,aAAa,+DAA+D,sBAAsB,wBAAwB,sBAAsB,gBAAgB,eAAe,oBAAoB,qBAAqB,uBAAuB,6CAA6C,wDAAwD,6BAA6B,kCAAkC,sBAAsB,qBAAqB,oBAAoB,yBAAyB,uBAAuB,qBAAqB,2BAA2B,oDAAoD,yDAAyD,KAAK,4BAA4B,qBAAqB,KAAK,2BAA2B,oBAAoB,qBAAqB,wBAAwB,0BAA0B,4DAA4D,KAAK,6DAA6D,oBAAoB,iEAAiE,KAAK,mOAAmO,oBAAoB,sBAAsB,4BAA4B,+BAA+B,2BAA2B,yDAAyD,wBAAwB,+BAA+B,sCAAsC,KAAK,6NAA6N,8BAA8B,mDAAmD,KAAK,2EAA2E,2BAA2B,kCAAkC,uBAAuB,qBAAqB,2BAA2B,2BAA2B,wBAAwB,wBAAwB,kCAAkC,iDAAiD,KAAK,mDAAmD,kCAAkC,oCAAoC,kDAAkD,KAAK,sCAAsC,sBAAsB,kBAAkB,uBAAuB,0CAA0C,kEAAkE,sBAAsB,gCAAgC,4BAA4B,sBAAsB,oBAAoB,KAAK,+CAA+C,oBAAoB,oBAAoB,qBAAqB,kCAAkC,sCAAsC,2BAA2B,sDAAsD,KAAK,oCAAoC,aAAa,0BAA0B,eAAe,4BAA4B,KAAK,iCAAiC,qBAAqB,uCAAuC,8CAA8C,0DAA0D,kCAAkC,mCAAmC,KAAK,2CAA2C,8CAA8C,2DAA2D,KAAK,uFAAuF,oBAAoB,2BAA2B,iBAAiB,gBAAgB,oBAAoB,oBAAoB,6CAA6C,iCAAiC,KAAK,mBAAmB;AAC3qK;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;ACzJvC;AACgH;AACjB;AAC/F,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,aAAa,cAAc;AAChE,oCAAoC,YAAY,cAAc;AAC9D,kCAAkC,aAAa,WAAW;AAC1D,iCAAiC,YAAY,WAAW;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,+CAA+C;AAClE,sBAAsB,kDAAkD;AACxE,sBAAsB,kDAAkD;AACxE,qBAAqB,iDAAiD;AACtE;AACA,sBAAsB;AACtB;AACA;AACA;AACA,cAAc;AACd,iBAAiB;AACjB;AACA,0BAA0B,qBAAqB;AAC/C,6BAA6B;AAC7B,eAAe,oBAAoB,YAAY;AAC/C,qBAAqB,kBAAkB;AACvC,kBAAkB;AAClB;AACA,0BAA0B;AAC1B,0BAA0B,mCAAmC;AAC7D;AACA;AACA,qBAAqB,gBAAgB;AACrC;AACA;AACA;AACA,oBAAoB,YAAY;AAChC,4CAA4C,YAAY;AACxD,mBAAmB,YAAY;AAC/B,0CAA0C,YAAY;AACtD;AACA;AACA,OAAO,8FAA8F,UAAU,UAAU,YAAY,aAAa,aAAa,aAAa,OAAO,4CAA4C,6CAA6C,6CAA6C,8CAA8C,MAAM,YAAY,aAAa,aAAa,aAAa,aAAa,aAAa,WAAW,YAAY,aAAa,aAAa,aAAa,OAAO,oCAAoC,qCAAqC,qCAAqC,sCAAsC,0BAA0B,MAAM,YAAY,qBAAqB,qBAAqB,aAAa,qCAAqC,yBAAyB,2CAA2C,mCAAmC,uBAAuB,MAAM,sBAAsB,qCAAqC,MAAM,UAAU,gCAAgC,OAAO,UAAU,kCAAkC,mCAAmC,mCAAmC,6EAA6E,wBAAwB,sBAAsB,+BAA+B,uCAAuC,iDAAiD,6BAA6B,KAAK,6CAA6C,aAAa,cAAc,wBAAwB,wCAAwC,YAAY,cAAc,0BAA0B,sCAAsC,aAAa,WAAW,wBAAwB,qCAAqC,YAAY,WAAW,0BAA0B,oBAAoB,qDAAqD,qDAAqD,oDAAoD,oDAAoD,wEAAwE,+DAA+D,oBAAoB,yBAAyB,6BAA6B,2BAA2B,6DAA6D,KAAK,2BAA2B,+CAA+C,2CAA2C,0BAA0B,kDAAkD,8CAA8C,0BAA0B,kDAAkD,8CAA8C,yBAAyB,iDAAiD,6CAA6C,8BAA8B,oBAAoB,2BAA2B,2BAA2B,kBAAkB,YAAY,qBAAqB,aAAa,oCAAoC,8BAA8B,qBAAqB,wBAAwB,iCAAiC,oBAAoB,mBAAmB,oBAAoB,YAAY,UAAU,yBAAyB,kBAAkB,yBAAyB,sBAAsB,+BAA+B,KAAK,8BAA8B,aAAa,8BAA8B,mCAAmC,sBAAsB,+BAA+B,qBAAqB,yBAAyB,gBAAgB,mBAAmB,KAAK,gDAAgD,YAAY,6BAA6B,gDAAgD,YAAY,2BAA2B,uBAAuB,YAAY,2BAA2B,8CAA8C,YAAY,6BAA6B,+BAA+B;AACr1H;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;;;;;;;;;;;ACnEvC;AACgH;AACjB;AACO;AACtG,4CAA4C,ysCAAmlB;AAC/nB,4CAA4C,i/BAAue;AACnhB,4CAA4C,mwCAAgnB;AAC5pB,8BAA8B,mFAA2B,CAAC,4FAAqC;AAC/F,yCAAyC,sFAA+B;AACxE,yCAAyC,sFAA+B;AACxE,yCAAyC,sFAA+B;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,mCAAmC;AAC/D;AACA;AACA,4BAA4B,mCAAmC;AAC/D;AACA;AACA;AACA;AACA,4BAA4B,mCAAmC;AAC/D;AACA;AACA,CAAC,OAAO,oGAAoG,YAAY,aAAa,aAAa,WAAW,YAAY,WAAW,UAAU,YAAY,aAAa,aAAa,MAAM,KAAK,aAAa,OAAO,KAAK,YAAY,aAAa,aAAa,MAAM,KAAK,aAAa,cAAc,aAAa,yCAAyC,8BAA8B,+BAA+B,2BAA2B,wBAAwB,2BAA2B,uBAAuB,wBAAwB,iCAAiC,gCAAgC,0BAA0B,KAAK,6BAA6B,kmBAAkmB,KAAK,2BAA2B,sfAAsf,qCAAqC,oCAAoC,KAAK,2BAA2B,+nBAA+nB,qCAAqC,oCAAoC,KAAK,mBAAmB;AACloF;AACA,iEAAe,uBAAuB,EAAC;;;;;;;;;;;ACtC1B;;AAEb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA,gDAAgD;AAChD;AACA;AACA,qFAAqF;AACrF;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,iBAAiB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,qBAAqB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,sFAAsF,qBAAqB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,iDAAiD,qBAAqB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,sDAAsD,qBAAqB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACpFa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACzBa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,cAAc;AACrE;AACA;AACA;AACA;AACA;;;;;;;;;;ACfA;AACA,oIAAoI;AACpI;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACFA,MAAqG;AACrG,MAA2F;AAC3F,MAAkG;AAClG,MAAqH;AACrH,MAA8G;AAC9G,MAA8G;AAC9G,MAA0G;AAC1G;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,uFAAO;;;;AAIoD;AAC5E,OAAO,iEAAe,uFAAO,IAAI,uFAAO,UAAU,uFAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAqG;AACrG,MAA2F;AAC3F,MAAkG;AAClG,MAAqH;AACrH,MAA8G;AAC9G,MAA8G;AAC9G,MAAyG;AACzG;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,sFAAO;;;;AAImD;AAC3E,OAAO,iEAAe,sFAAO,IAAI,sFAAO,UAAU,sFAAO,mBAAmB,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzB7E,MAAqG;AACrG,MAA2F;AAC3F,MAAkG;AAClG,MAAqH;AACrH,MAA8G;AAC9G,MAA8G;AAC9G,MAA4G;AAC5G;AACA;;AAEA;;AAEA,4BAA4B,qGAAmB;AAC/C,wBAAwB,kHAAa;;AAErC,uBAAuB,uGAAa;AACpC;AACA,iBAAiB,+FAAM;AACvB,6BAA6B,sGAAkB;;AAE/C,aAAa,0GAAG,CAAC,yFAAO;;;;AAIsD;AAC9E,OAAO,iEAAe,yFAAO,IAAI,yFAAO,UAAU,yFAAO,mBAAmB,EAAC;;;;;;;;;;;AC1BhE;;AAEb;AACA;AACA;AACA,kBAAkB,wBAAwB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,iBAAiB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,4BAA4B;AAChD;AACA;AACA;AACA;AACA;AACA,qBAAqB,6BAA6B;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACnFa;;AAEb;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACjCa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACTa;;AAEb;AACA;AACA,cAAc,KAAwC,GAAG,sBAAiB,GAAG,CAAI;AACjF;AACA;AACA;AACA;AACA;;;;;;;;;;ACTa;;AAEb;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA,iFAAiF;AACjF;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,yDAAyD;AACzD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AC5Da;;AAEb;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;;;;;;;;;;;;;;;;;ACdA;AAC0B;AAC0B;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,8GAA8G,IAAI;AAC9H;AACA;AACA,wBAAwB,uDAAmB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA,UAAU;AACV,mEAAmE,MAAM;AACzE;AACA;AACA;AACA;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA,uFAAuF,IAAI;AAC3F;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,uFAAuF,IAAI;AAC3F;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,2BAA2B;AAC3B,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,iCAAiC;AACtD,sBAAsB,iCAAiC;AACvD,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,gEAAgE;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,+BAA+B,GAAG;AACxE,4CAA4C;AAC5C;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,cAAc;AACd;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA,6CAA6C;AAC7C,qBAAqB;AACrB;AACA;AACA;AACA;AACA,gEAAgE,+BAA+B,IAAI;AACnG;AACA;AACA;AACA,oDAAoD;AACpD;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC,0BAA0B,wBAAwB;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD,cAAc;AACd;AACA,kGAAkG;AAClG,cAAc;AACd;AACA;AACA,cAAc;AACd;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,oBAAoB;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAe,YAAY,EAAC;;;;;;;;;;;;;;;ACrS5B;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA,6BAAe,oCAAU;AACzB;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB,eAAe,QAAQ;AACvB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA,uBAAuB,UAAU;AACjC,yBAAyB,QAAQ;AACjC;AACA;AACA;AACA,gBAAgB;AAChB;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,eAAe,cAAc;AAC7B;AACA;AACA;AACA;AACA;AACA,uCAAuC,iCAAiC;AACxE,UAAU;AACV;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,WAAW;AACnC;AACA,mFAAmF;AACnF;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA,0BAA0B;AAC1B;AACA;AACA,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE;AAChE,wBAAwB,WAAW,GAAG,WAAW,GAAG,QAAQ;AAC5D,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;ACrKA;AACA;AACyB;AACzB;AACA;AACA,aAAa,QAAQ;AACrB,cAAc,gCAAgC;AAC9C,cAAc,QAAQ;AACtB,cAAc,QAAQ;AACtB,cAAc,aAAa;AAC3B,cAAc,gEAAgE;AAC9E,cAAc,QAAQ;AACtB,cAAc,SAAS;AACvB;AACA;AACA;AACA,aAAa,uBAAuB;AACpC;AACA;AACA;AACA,aAAa,QAAQ;AACrB,cAAc,UAAU;AACxB,cAAc,oBAAoB;AAClC,cAAc,QAAQ;AACtB,cAAc,QAAQ;AACtB,cAAc,QAAQ;AACtB,cAAc,4BAA4B;AAC1C,cAAc,QAAQ;AACtB,cAAc,SAAS;AACvB,cAAc,QAAQ;AACtB,cAAc,QAAQ;AACtB,cAAc,QAAQ;AACtB;AACA;AACA;AACA,aAAa,QAAQ;AACrB,cAAc,aAAa;AAC3B,cAAc,qCAAqC;AACnD,cAAc,QAAQ;AACtB,cAAc,SAAS;AACvB,cAAc,QAAQ;AACtB,cAAc,yCAAyC;AACvD,cAAc,qEAAqE;AACnF,cAAc,QAAQ;AACtB,cAAc,UAAU;AACxB,cAAc,oBAAoB;AAClC;AACA;AACA;AACA,aAAa,QAAQ;AACrB,cAAc,QAAQ;AACtB,cAAc,aAAa;AAC3B,cAAc,kCAAkC;AAChD,cAAc,0CAA0C;AACxD,cAAc,qBAAqB;AACnC,cAAc,2DAA2D;AACzE,cAAc,qDAAqD;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,aAAa;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,aAAa;AACxB,aAAa;AACb;AACA;AACA;AACA,mBAAmB,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,YAAY;AACpF;AACA,oBAAoB,gBAAgB;AACpC;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa;AACb;AACA;AACA;AACA,oBAAoB,SAAS;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,KAAK;AACvC;AACA;AACA,sDAAsD,WAAW;AACjE,sDAAsD,WAAW;AACjE;AACA;AACA;AACA;AACA;AACA,mCAAmC,8BAA8B;AACjE,6BAA6B,UAAU;AACvC;AACA;AACA;AACA;AACA;AACA,4BAA4B,WAAW;AACvC;AACA,wDAAwD,aAAa;AACrE;AACA;AACA,oBAAoB,gBAAgB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,uBAAuB;AACvC;AACA,mBAAmB,aAAa;AAChC,wBAAwB,mCAAmC;AAC3D,mBAAmB,kBAAkB;AACrC;AACA,mBAAmB,uBAAuB;AAC1C;AACA,mBAAmB,YAAY;AAC/B;AACA;AACA;AACA,gBAAgB,sBAAsB;AACtC;AACA,wBAAwB,gCAAgC;AACxD;AACA;AACA;AACA,gBAAgB,4BAA4B;AAC5C,wBAAwB,iBAAiB,gBAAgB;AACzD;AACA,kBAAkB,YAAY;AAC9B,sBAAsB;AACtB;AACA,gBAAgB,cAAc;AAC9B;AACA,0CAA0C,KAAK;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,aAAa;AAC7E;AACA;AACA,2CAA2C,WAAW,GAAG,uCAAuC;AAChG;AACA,wDAAwD,kBAAkB;AAC1E;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0FAA0F,YAAY;AACtG;AACA;AACA;AACA;AACA;AACA,mDAAmD,gBAAgB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,IAAI;AAClF;AACA;AACA;AACA,2EAA2E,IAAI;AAC/E;AACA;AACA;AACA,6EAA6E,IAAI;AACjF;AACA;AACA;AACA,4EAA4E,IAAI;AAChF;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE,eAAe;AACxF,yEAAyE,eAAe;AACxF;AACA;AACA;AACA,6EAA6E,eAAe;AAC5F,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,sDAAsD,gCAAgC;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA,sDAAsD;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,uDAAuD,wBAAwB;AAC/E;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA,0GAA0G,EAAE;AAC5G,oDAAoD,YAAY;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,sCAAsC,8BAA8B,uCAAuC;AAC3G,uCAAuC;AACvC;AACA;AACA,uEAAuE,MAAM,WAAW,cAAc;AACtG;AACA;AACA;AACA;AACA;AACA,0BAA0B,gCAAgC;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,sBAAsB,4BAA4B;AAClD;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,mEAAmE,sBAAsB,qBAAqB;AAC9G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,mBAAmB,YAAY,0BAA0B;AACnF,6BAA6B,mBAAmB,YAAY,6BAA6B;AACzF,6BAA6B,mBAAmB,YAAY,6BAA6B;AACzF,4BAA4B,mBAAmB,YAAY,4BAA4B;AACvF;AACA,gBAAgB,kBAAkB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,cAAc;AAC9B;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAU;AACzB,eAAe,aAAa;AAC5B,eAAe,SAAS;AACxB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,YAAY;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,SAAS;AAC7D;AACA;AACA,6BAA6B,gBAAgB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,gBAAgB;AACtD;AACA;AACA;AACA;AACA,sHAAsH,EAAE;AACxH;AACA,iEAAiE,IAAI;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,kCAAkC,mBAAmB;AACrD;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAU;AACzB,eAAe,aAAa;AAC5B,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,oBAAoB;AACjD,4BAA4B,mBAAmB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,sCAAsC;AACjF,yCAAyC,UAAU;AACnD;AACA;AACA;AACA,wCAAwC,oBAAoB;AAC5D,yCAAyC,UAAU;AACnD;AACA;AACA;AACA,0CAA0C,sCAAsC;AAChF,wCAAwC,SAAS;AACjD;AACA;AACA;AACA,yCAAyC,mBAAmB;AAC5D,wCAAwC,SAAS;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,uBAAuB;AAClC,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,IAAI;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,6BAA6B;AAC5C,eAAe,uBAAuB;AACtC,iBAAiB;AACjB;AACA;AACA;AACA;AACA,+CAA+C,qBAAqB,GAAG;AACvE;AACA;AACA;AACA;AACA,kCAAkC,sBAAsB,GAAG;AAC3D,KAAK;AACL,eAAe,8BAA8B;AAC7C,cAAc;AACd,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA,iEAAe,KAAK,EAAC;AAC8B;;;;;;;;;;;;;;;;;;;AChgCnD;AAC4D;AACE;AAC9D;AACA;AAC2B;AAC3B;AACA;AAC0B;AAC1B;AACA;AACO;AACP,oBAAoB,uEAAc;AAClC;AACA;AACA;;;;;;;;;;;;;;;;ACfkD;AAClD;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA,6BAAe,oCAAU;AACzB;AACA;AACA,iBAAiB,QAAQ;AACzB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,+DAAc;AAC7B;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC7BA;AACA;AACA,WAAW,iBAAiB;AAC5B,aAAa,QAAQ;AACrB,YAAY,WAAW;AACvB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA,iCAAiC,KAAK,GAAG,UAAU;AACnD;AACA;AACA,0BAA0B,KAAK,GAAG,WAAW;AAC7C;AACA;AACA,0BAA0B,KAAK;AAC/B;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,QAAQ;AACzB,kBAAkB,SAAS;AAC3B,kBAAkB,SAAS;AAC3B,kBAAkB,SAAS;AAC3B,kBAAkB,QAAQ;AAC1B;AACA;AACA,iCAAiC;AACjC,mCAAmC,kBAAkB,wCAAwC;AAC7F;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB,eAAe,SAAS;AACxB,eAAe,SAAS;AACxB,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,YAAY;AACtC;AACA;AACA;AACA;AACA;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,YAAY,GAAG,UAAU;AACxE,cAAc;AACd,iCAAiC,YAAY,GAAG,WAAW;AAC3D,cAAc;AACd,iCAAiC,YAAY;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sBAAsB;AAC9C;AACA;AACA;AACA;AACA;AACA,4CAA4C;AAC5C;AACA,gEAAgE;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,UAAU;AACrD;AACA,+CAA+C,UAAU,wCAAwC,6BAA6B;AAC9H,oCAAoC,KAAK,uDAAuD,UAAU;AAC1G;AACA,+CAA+C,UAAU;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA,0BAA0B,kBAAkB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,GAAG;AAClB,eAAe,aAAa;AAC5B,eAAe,aAAa;AAC5B,eAAe,SAAS;AACxB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,GAAG;AAClB,eAAe,aAAa;AAC5B,eAAe,aAAa;AAC5B,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,GAAG;AAClB,eAAe,QAAQ;AACvB,eAAe,GAAG;AAClB,eAAe,QAAQ;AACvB,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,UAAU;AACV;AACA,oBAAoB,QAAQ;AAC5B;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA,kBAAkB;AAClB;AACA,kBAAkB;AAClB;AACA;AACA,cAAc;AACd;AACA;AACA,kBAAkB;AAClB;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,GAAG;AAClB,eAAe,QAAQ;AACvB,eAAe,aAAa;AAC5B,eAAe,QAAQ;AACvB,eAAe,QAAQ;AACvB,eAAe,OAAO;AACtB,eAAe,QAAQ;AACvB,eAAe,QAAQ;AACvB,iBAAiB,GAAG;AACpB;AACA;AACA;AACA;AACA,oBAAoB,QAAQ;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,IAAI,qBAAqB,YAAY,wBAAwB,yBAAyB,SAAS,iCAAiC;AAChK;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,IAAI,qBAAqB,YAAY,wBAAwB,yBAAyB,SAAS,iCAAiC;AAChK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA,4BAA4B,IAAI,qBAAqB,YAAY,wBAAwB,6BAA6B,SAAS,qCAAqC;AACpK;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,IAAI,qBAAqB,YAAY,wBAAwB,6BAA6B,SAAS,qCAAqC;AAChK;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B;AACA;AACA;AACA,wBAAwB,gCAAgC;AACxD;AACA;AACA;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,4BAA4B,kEAAkE;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO,2CAA2C,GAAG;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,4BAA4B;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA,iCAAiC,yBAAyB;AAC1D;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,iCAAiC,0DAA0D;AAC3F,kBAAkB;AAClB;AACA,iCAAiC,mCAAmC;AACpE;AACA;AACA,iBAAiB;AACjB,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,4BAA4B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa;AACb;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACpiB4B;AAC5B;AACA;AACA;AACA,WAAW,oBAAoB;AAC/B;AACA;AACA;AACA;AACA,6BAAe,oCAAU;AACzB,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,6CAA6C;AAC7C,8CAA8C;AAC9C,MAAM;AACN;AACA;AACA;AACA;AACA,uEAAuE;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C,yDAAyD;AACzD,6CAA6C;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C,8CAA8C;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,iCAAiC;AACjG;AACA;AACA,mEAAmE,2CAA2C;AAC9G;AACA;AACA,4DAA4D,iCAAiC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;SC3KA;SACA;;SAEA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;;SAEA;SACA;;SAEA;SACA;SACA;;SAEA;SACA;;;;;UCzBA;UACA;UACA;UACA;UACA;UACA,iCAAiC,WAAW;UAC5C;UACA;;;;;UCPA;UACA;UACA;UACA;UACA,yCAAyC,wCAAwC;UACjF;UACA;UACA;;;;;UCPA;;;;;UCAA;UACA;UACA;UACA,uDAAuD,iBAAiB;UACxE;UACA,gDAAgD,aAAa;UAC7D;;;;;UCNA;;UAEA;UACA;UACA;UACA;UACA;UACA;;UAEA;;UAEA;;UAEA;;UAEA;;UAEA;;UAEA;;UAEA;;;;;UCrBA;;;;;;;;;;;;;;;;;;;;ACA4D;AACM;AACjB;AACH;AACC;AACsB;;AAErE;AACA;AACA,WAAW,+EAA+E;AAC1F,aAAa,QAAQ;AACrB,YAAY,OAAO;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,sEAAiB;AACrB,IAAI,0EAAmB;AACvB,IAAI,2EAAe;AACnB;AACA;;AAEA,cAAc,wDAAO;AACrB,aAAa,kEAAM;AACnB,YAAY,gEAAK;AACjB,YAAY,6DAAK;AACjB;AACA;AACA;AACA;AACA;AACA;;AAEA,iEAAe,GAAG,E","sources":["webpack://@appius-fr/apx/./modules/dialog/css/dialog.css","webpack://@appius-fr/apx/./modules/toast/css/toast.css","webpack://@appius-fr/apx/./modules/tristate/css/tristate.css","webpack://@appius-fr/apx/./node_modules/css-loader/dist/runtime/api.js","webpack://@appius-fr/apx/./node_modules/css-loader/dist/runtime/getUrl.js","webpack://@appius-fr/apx/./node_modules/css-loader/dist/runtime/sourceMaps.js","webpack://@appius-fr/apx/./modules/dialog/html/dialog.html","webpack://@appius-fr/apx/./modules/dialog/css/dialog.css?a567","webpack://@appius-fr/apx/./modules/toast/css/toast.css?8a48","webpack://@appius-fr/apx/./modules/tristate/css/tristate.css?a094","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/insertBySelector.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/insertStyleElement.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/styleDomAPI.js","webpack://@appius-fr/apx/./node_modules/style-loader/dist/runtime/styleTagTransform.js","webpack://@appius-fr/apx/./modules/common.mjs","webpack://@appius-fr/apx/./modules/dialog/dialog.mjs","webpack://@appius-fr/apx/./modules/listen/listen.mjs","webpack://@appius-fr/apx/./modules/toast/toast.mjs","webpack://@appius-fr/apx/./modules/tools/exports.mjs","webpack://@appius-fr/apx/./modules/tools/form-packer/augment-apx.mjs","webpack://@appius-fr/apx/./modules/tools/form-packer/packToJson.mjs","webpack://@appius-fr/apx/./modules/tristate/tristate.mjs","webpack://@appius-fr/apx/webpack/bootstrap","webpack://@appius-fr/apx/webpack/runtime/compat get default export","webpack://@appius-fr/apx/webpack/runtime/define property getters","webpack://@appius-fr/apx/webpack/runtime/hasOwnProperty shorthand","webpack://@appius-fr/apx/webpack/runtime/make namespace object","webpack://@appius-fr/apx/webpack/runtime/jsonp chunk loading","webpack://@appius-fr/apx/webpack/runtime/nonce","webpack://@appius-fr/apx/./APX.mjs"],"sourcesContent":["// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `/* Dialog styling */\r\n.APX-dialog {\r\n    display: none;\r\n    position: fixed;\r\n    z-index: 1002;\r\n    left: 0;\r\n    top: 0;\r\n    width: 100%;\r\n    height: 100%;\r\n    overflow: auto;\r\n    background-color: rgba(0, 0, 0, 0.4);\r\n    /* Dimmed background for focus on dialog */\r\n}\r\n\r\n.APX-dialog-content {\r\n    background-color: #fefefe;\r\n    padding: 40px;\r\n    border: none;\r\n    width: auto;\r\n    min-width: 300px;\r\n    max-width: 80%;\r\n    margin: auto;\r\n    border-radius: 8px;\r\n    box-shadow: 0px 6px 20px rgba(0, 0, 0, 0.1);\r\n    font-family: 'Helvetica Neue', Arial, sans-serif;\r\n}\r\n\r\nh2.APX-dialog-title{\r\n    margin-top:0;\r\n}\r\n\r\n.APX-close-dialog {\r\n    color: #aaa;\r\n    float: right;\r\n    font-size: 24px;\r\n    margin-top: -10px;\r\n    /* Adjust positioning */\r\n    margin-right: -10px;\r\n}\r\n\r\n.APX-close-dialog:hover,\r\n.APX-close-dialog:focus {\r\n    color: #333;\r\n    /* Darker color on hover/focus */\r\n    cursor: pointer;\r\n}\r\n\r\n/* Input fields styling */\r\n.APX-dialog-content input[type=\"text\"],\r\n.APX-dialog-content input[type=\"number\"],\r\n.APX-dialog-content input[type=\"date\"],\r\n.APX-dialog-content input[type=\"datetime-local\"] {\r\n    width: 100%;\r\n    padding: 10px;\r\n    margin-bottom: 20px;\r\n    border: 1px solid #ccc;\r\n    border-radius: 4px;\r\n    font-family: 'Helvetica Neue', Arial, sans-serif;\r\n    font-size: 16px;\r\n    box-sizing: border-box;\r\n    transition: border-color 0.3s;\r\n}\r\n\r\n.APX-dialog-content input[type=\"text\"]:focus,\r\n.APX-dialog-content input[type=\"number\"]:focus,\r\n.APX-dialog-content input[type=\"date\"]:focus,\r\n.APX-dialog-content input[type=\"datetime-local\"]:focus {\r\n    border-color: #2C3E50;\r\n    /* Deep Blue Color */\r\n    outline: none;\r\n}\r\n\r\n/* Button in the dialog */\r\n.APX-dialog-button-container button {\r\n    position: relative;\r\n    background-color: #2C3E50;\r\n    color: #ECF0F1;\r\n    border: none;\r\n    padding: 10px 20px;\r\n    border-radius: 5px;\r\n    font-size: 16px;\r\n    cursor: pointer;\r\n    transition: all 0.3s ease;\r\n    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);\r\n}\r\n\r\n.APX-dialog-button-container button:hover {\r\n    background-color: #34495E;\r\n    transform: translateY(-1px);\r\n    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);\r\n}\r\n\r\n.APX-dialog-button-container {\r\n    display: flex;\r\n    gap: 10px;\r\n    margin-top:1em;\r\n    /* spacing between buttons */\r\n}\r\n\r\n/* Loading indicator */\r\n.APX-dialog-loading-indicator {\r\n    display: flex;\r\n    justify-content: center;\r\n    align-items: center;\r\n    height: 100px;\r\n    width: 100%;\r\n}\r\n\r\n.APX-dialog-loading-indicator::before {\r\n    content: '';\r\n    width: 40px;\r\n    height: 40px;\r\n    border: 4px solid #f3f3f3;\r\n    border-top: 4px solid #2C3E50;\r\n    border-radius: 50%;\r\n    animation: APX-dialog-spin 1s linear infinite;\r\n}\r\n\r\n@keyframes APX-dialog-spin {\r\n    0% { transform: rotate(0deg); }\r\n    100% { transform: rotate(360deg); }\r\n}\r\n.APX-dialog-button-disabled {\r\n    opacity: 0.5;\r\n    cursor: not-allowed !important;\r\n    background-color: #95a5a6 !important; /* Grayed out color */\r\n    box-shadow: none !important;\r\n    transition: all 0.2s ease;\r\n    transform: none !important;\r\n}\r\n\r\n.APX-dialog-button-disabled:hover {\r\n    background-color: #95a5a6 !important; /* Keep gray on hover */\r\n    transform: none !important;\r\n}\r\n\r\n/* Add a subtle strikethrough effect */\r\n.APX-dialog-button-disabled::after {\r\n    content: '';\r\n    position: absolute;\r\n    top: 50%;\r\n    left: 0;\r\n    width: 100%;\r\n    height: 1px;\r\n    background-color: rgba(0, 0, 0, 0.2);\r\n    transform: rotate(-5deg);\r\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./modules/dialog/css/dialog.css\"],\"names\":[],\"mappings\":\"AAAA,mBAAmB;AACnB;IACI,aAAa;IACb,eAAe;IACf,aAAa;IACb,OAAO;IACP,MAAM;IACN,WAAW;IACX,YAAY;IACZ,cAAc;IACd,oCAAoC;IACpC,0CAA0C;AAC9C;;AAEA;IACI,yBAAyB;IACzB,aAAa;IACb,YAAY;IACZ,WAAW;IACX,gBAAgB;IAChB,cAAc;IACd,YAAY;IACZ,kBAAkB;IAClB,2CAA2C;IAC3C,gDAAgD;AACpD;;AAEA;IACI,YAAY;AAChB;;AAEA;IACI,WAAW;IACX,YAAY;IACZ,eAAe;IACf,iBAAiB;IACjB,uBAAuB;IACvB,mBAAmB;AACvB;;AAEA;;IAEI,WAAW;IACX,gCAAgC;IAChC,eAAe;AACnB;;AAEA,yBAAyB;AACzB;;;;IAII,WAAW;IACX,aAAa;IACb,mBAAmB;IACnB,sBAAsB;IACtB,kBAAkB;IAClB,gDAAgD;IAChD,eAAe;IACf,sBAAsB;IACtB,6BAA6B;AACjC;;AAEA;;;;IAII,qBAAqB;IACrB,oBAAoB;IACpB,aAAa;AACjB;;AAEA,yBAAyB;AACzB;IACI,kBAAkB;IAClB,yBAAyB;IACzB,cAAc;IACd,YAAY;IACZ,kBAAkB;IAClB,kBAAkB;IAClB,eAAe;IACf,eAAe;IACf,yBAAyB;IACzB,wCAAwC;AAC5C;;AAEA;IACI,yBAAyB;IACzB,2BAA2B;IAC3B,yCAAyC;AAC7C;;AAEA;IACI,aAAa;IACb,SAAS;IACT,cAAc;IACd,4BAA4B;AAChC;;AAEA,sBAAsB;AACtB;IACI,aAAa;IACb,uBAAuB;IACvB,mBAAmB;IACnB,aAAa;IACb,WAAW;AACf;;AAEA;IACI,WAAW;IACX,WAAW;IACX,YAAY;IACZ,yBAAyB;IACzB,6BAA6B;IAC7B,kBAAkB;IAClB,6CAA6C;AACjD;;AAEA;IACI,KAAK,uBAAuB,EAAE;IAC9B,OAAO,yBAAyB,EAAE;AACtC;AACA;IACI,YAAY;IACZ,8BAA8B;IAC9B,oCAAoC,EAAE,qBAAqB;IAC3D,2BAA2B;IAC3B,yBAAyB;IACzB,0BAA0B;AAC9B;;AAEA;IACI,oCAAoC,EAAE,uBAAuB;IAC7D,0BAA0B;AAC9B;;AAEA,sCAAsC;AACtC;IACI,WAAW;IACX,kBAAkB;IAClB,QAAQ;IACR,OAAO;IACP,WAAW;IACX,WAAW;IACX,oCAAoC;IACpC,wBAAwB;AAC5B\",\"sourcesContent\":[\"/* Dialog styling */\\r\\n.APX-dialog {\\r\\n    display: none;\\r\\n    position: fixed;\\r\\n    z-index: 1002;\\r\\n    left: 0;\\r\\n    top: 0;\\r\\n    width: 100%;\\r\\n    height: 100%;\\r\\n    overflow: auto;\\r\\n    background-color: rgba(0, 0, 0, 0.4);\\r\\n    /* Dimmed background for focus on dialog */\\r\\n}\\r\\n\\r\\n.APX-dialog-content {\\r\\n    background-color: #fefefe;\\r\\n    padding: 40px;\\r\\n    border: none;\\r\\n    width: auto;\\r\\n    min-width: 300px;\\r\\n    max-width: 80%;\\r\\n    margin: auto;\\r\\n    border-radius: 8px;\\r\\n    box-shadow: 0px 6px 20px rgba(0, 0, 0, 0.1);\\r\\n    font-family: 'Helvetica Neue', Arial, sans-serif;\\r\\n}\\r\\n\\r\\nh2.APX-dialog-title{\\r\\n    margin-top:0;\\r\\n}\\r\\n\\r\\n.APX-close-dialog {\\r\\n    color: #aaa;\\r\\n    float: right;\\r\\n    font-size: 24px;\\r\\n    margin-top: -10px;\\r\\n    /* Adjust positioning */\\r\\n    margin-right: -10px;\\r\\n}\\r\\n\\r\\n.APX-close-dialog:hover,\\r\\n.APX-close-dialog:focus {\\r\\n    color: #333;\\r\\n    /* Darker color on hover/focus */\\r\\n    cursor: pointer;\\r\\n}\\r\\n\\r\\n/* Input fields styling */\\r\\n.APX-dialog-content input[type=\\\"text\\\"],\\r\\n.APX-dialog-content input[type=\\\"number\\\"],\\r\\n.APX-dialog-content input[type=\\\"date\\\"],\\r\\n.APX-dialog-content input[type=\\\"datetime-local\\\"] {\\r\\n    width: 100%;\\r\\n    padding: 10px;\\r\\n    margin-bottom: 20px;\\r\\n    border: 1px solid #ccc;\\r\\n    border-radius: 4px;\\r\\n    font-family: 'Helvetica Neue', Arial, sans-serif;\\r\\n    font-size: 16px;\\r\\n    box-sizing: border-box;\\r\\n    transition: border-color 0.3s;\\r\\n}\\r\\n\\r\\n.APX-dialog-content input[type=\\\"text\\\"]:focus,\\r\\n.APX-dialog-content input[type=\\\"number\\\"]:focus,\\r\\n.APX-dialog-content input[type=\\\"date\\\"]:focus,\\r\\n.APX-dialog-content input[type=\\\"datetime-local\\\"]:focus {\\r\\n    border-color: #2C3E50;\\r\\n    /* Deep Blue Color */\\r\\n    outline: none;\\r\\n}\\r\\n\\r\\n/* Button in the dialog */\\r\\n.APX-dialog-button-container button {\\r\\n    position: relative;\\r\\n    background-color: #2C3E50;\\r\\n    color: #ECF0F1;\\r\\n    border: none;\\r\\n    padding: 10px 20px;\\r\\n    border-radius: 5px;\\r\\n    font-size: 16px;\\r\\n    cursor: pointer;\\r\\n    transition: all 0.3s ease;\\r\\n    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);\\r\\n}\\r\\n\\r\\n.APX-dialog-button-container button:hover {\\r\\n    background-color: #34495E;\\r\\n    transform: translateY(-1px);\\r\\n    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);\\r\\n}\\r\\n\\r\\n.APX-dialog-button-container {\\r\\n    display: flex;\\r\\n    gap: 10px;\\r\\n    margin-top:1em;\\r\\n    /* spacing between buttons */\\r\\n}\\r\\n\\r\\n/* Loading indicator */\\r\\n.APX-dialog-loading-indicator {\\r\\n    display: flex;\\r\\n    justify-content: center;\\r\\n    align-items: center;\\r\\n    height: 100px;\\r\\n    width: 100%;\\r\\n}\\r\\n\\r\\n.APX-dialog-loading-indicator::before {\\r\\n    content: '';\\r\\n    width: 40px;\\r\\n    height: 40px;\\r\\n    border: 4px solid #f3f3f3;\\r\\n    border-top: 4px solid #2C3E50;\\r\\n    border-radius: 50%;\\r\\n    animation: APX-dialog-spin 1s linear infinite;\\r\\n}\\r\\n\\r\\n@keyframes APX-dialog-spin {\\r\\n    0% { transform: rotate(0deg); }\\r\\n    100% { transform: rotate(360deg); }\\r\\n}\\r\\n.APX-dialog-button-disabled {\\r\\n    opacity: 0.5;\\r\\n    cursor: not-allowed !important;\\r\\n    background-color: #95a5a6 !important; /* Grayed out color */\\r\\n    box-shadow: none !important;\\r\\n    transition: all 0.2s ease;\\r\\n    transform: none !important;\\r\\n}\\r\\n\\r\\n.APX-dialog-button-disabled:hover {\\r\\n    background-color: #95a5a6 !important; /* Keep gray on hover */\\r\\n    transform: none !important;\\r\\n}\\r\\n\\r\\n/* Add a subtle strikethrough effect */\\r\\n.APX-dialog-button-disabled::after {\\r\\n    content: '';\\r\\n    position: absolute;\\r\\n    top: 50%;\\r\\n    left: 0;\\r\\n    width: 100%;\\r\\n    height: 1px;\\r\\n    background-color: rgba(0, 0, 0, 0.2);\\r\\n    transform: rotate(-5deg);\\r\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.APX-toast-container {\r\n    position: fixed;\r\n    display: flex;\r\n    flex-direction: column;\r\n    gap: var(--apx-toast-gap, 8px);\r\n    z-index: var(--apx-toast-z-index, 11000);\r\n    pointer-events: none;\r\n}\r\n\r\n.APX-toast-container--bottom-right { right: 12px; bottom: 12px; align-items: flex-end; }\r\n.APX-toast-container--bottom-left { left: 12px; bottom: 12px; align-items: flex-start; }\r\n.APX-toast-container--top-right { right: 12px; top: 12px; align-items: flex-end; }\r\n.APX-toast-container--top-left { left: 12px; top: 12px; align-items: flex-start; }\r\n\r\n.APX-toast {\r\n    min-width: var(--apx-toast-min-width, 260px);\r\n    max-width: var(--apx-toast-max-width, 420px);\r\n    font-size: var(--apx-toast-font-size, 14px);\r\n    border-radius: var(--apx-toast-radius, 6px);\r\n    box-shadow: var(--apx-toast-shadow, 0 6px 24px rgba(0,0,0,0.2));\r\n    padding: var(--apx-toast-padding, 10px 42px 10px 14px);\r\n    color: #111;\r\n    background: #eee;\r\n    pointer-events: auto;\r\n    position: relative;\r\n    transition: opacity 180ms ease, transform 180ms ease;\r\n}\r\n\r\n.APX-toast--info { background: var(--apx-toast-info-bg, #0dcaf0); color: var(--apx-toast-info-fg, #052c65); }\r\n.APX-toast--success { background: var(--apx-toast-success-bg, #198754); color: var(--apx-toast-success-fg, #ffffff); }\r\n.APX-toast--warning { background: var(--apx-toast-warning-bg, #ffc107); color: var(--apx-toast-warning-fg, #664d03); }\r\n.APX-toast--danger { background: var(--apx-toast-danger-bg, #dc3545); color: var(--apx-toast-danger-fg, #ffffff); }\r\n\r\n.APX-toast__content { line-height: 1.35; }\r\n\r\n.APX-toast__close {\r\n    position: absolute;\r\n    top: 50%; right: 10px;\r\n    width: 24px; height: 24px;\r\n    transform: translateY(-50%);\r\n    display: inline-flex; align-items: center; justify-content: center;\r\n    background: transparent; color: currentColor;\r\n    border: 0; border-radius: 4px; padding: 0; margin: 0;\r\n    cursor: pointer; appearance: none; -webkit-appearance: none;\r\n    opacity: .75; transition: opacity 120ms ease;\r\n}\r\n.APX-toast__close:hover { opacity: 1; }\r\n.APX-toast__close:focus { outline: 2px solid rgba(0,0,0,.2); outline-offset: 2px; }\r\n.APX-toast__close::before {\r\n    content: '×';\r\n    font-size: 16px; line-height: 1; text-align: center;\r\n}\r\n\r\n/* Animations */\r\n.APX-toast--enter { opacity: 0; transform: translateY(8px); }\r\n.APX-toast--enter.APX-toast--enter-active { opacity: 1; transform: translateY(0); }\r\n.APX-toast--exit { opacity: 1; transform: translateY(0); }\r\n.APX-toast--exit.APX-toast--exit-active { opacity: 0; transform: translateY(8px); }\r\n\r\n\r\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./modules/toast/css/toast.css\"],\"names\":[],\"mappings\":\"AAAA;IACI,eAAe;IACf,aAAa;IACb,sBAAsB;IACtB,8BAA8B;IAC9B,wCAAwC;IACxC,oBAAoB;AACxB;;AAEA,qCAAqC,WAAW,EAAE,YAAY,EAAE,qBAAqB,EAAE;AACvF,oCAAoC,UAAU,EAAE,YAAY,EAAE,uBAAuB,EAAE;AACvF,kCAAkC,WAAW,EAAE,SAAS,EAAE,qBAAqB,EAAE;AACjF,iCAAiC,UAAU,EAAE,SAAS,EAAE,uBAAuB,EAAE;;AAEjF;IACI,4CAA4C;IAC5C,4CAA4C;IAC5C,2CAA2C;IAC3C,2CAA2C;IAC3C,+DAA+D;IAC/D,sDAAsD;IACtD,WAAW;IACX,gBAAgB;IAChB,oBAAoB;IACpB,kBAAkB;IAClB,oDAAoD;AACxD;;AAEA,mBAAmB,6CAA6C,EAAE,wCAAwC,EAAE;AAC5G,sBAAsB,gDAAgD,EAAE,2CAA2C,EAAE;AACrH,sBAAsB,gDAAgD,EAAE,2CAA2C,EAAE;AACrH,qBAAqB,+CAA+C,EAAE,0CAA0C,EAAE;;AAElH,sBAAsB,iBAAiB,EAAE;;AAEzC;IACI,kBAAkB;IAClB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,YAAY;IACzB,2BAA2B;IAC3B,oBAAoB,EAAE,mBAAmB,EAAE,uBAAuB;IAClE,uBAAuB,EAAE,mBAAmB;IAC5C,SAAS,EAAE,kBAAkB,EAAE,UAAU,EAAE,SAAS;IACpD,eAAe,EAAE,gBAAgB,EAAE,wBAAwB;IAC3D,YAAY,EAAE,8BAA8B;AAChD;AACA,0BAA0B,UAAU,EAAE;AACtC,0BAA0B,iCAAiC,EAAE,mBAAmB,EAAE;AAClF;IACI,YAAY;IACZ,eAAe,EAAE,cAAc,EAAE,kBAAkB;AACvD;;AAEA,eAAe;AACf,oBAAoB,UAAU,EAAE,0BAA0B,EAAE;AAC5D,4CAA4C,UAAU,EAAE,wBAAwB,EAAE;AAClF,mBAAmB,UAAU,EAAE,wBAAwB,EAAE;AACzD,0CAA0C,UAAU,EAAE,0BAA0B,EAAE\",\"sourcesContent\":[\".APX-toast-container {\\r\\n    position: fixed;\\r\\n    display: flex;\\r\\n    flex-direction: column;\\r\\n    gap: var(--apx-toast-gap, 8px);\\r\\n    z-index: var(--apx-toast-z-index, 11000);\\r\\n    pointer-events: none;\\r\\n}\\r\\n\\r\\n.APX-toast-container--bottom-right { right: 12px; bottom: 12px; align-items: flex-end; }\\r\\n.APX-toast-container--bottom-left { left: 12px; bottom: 12px; align-items: flex-start; }\\r\\n.APX-toast-container--top-right { right: 12px; top: 12px; align-items: flex-end; }\\r\\n.APX-toast-container--top-left { left: 12px; top: 12px; align-items: flex-start; }\\r\\n\\r\\n.APX-toast {\\r\\n    min-width: var(--apx-toast-min-width, 260px);\\r\\n    max-width: var(--apx-toast-max-width, 420px);\\r\\n    font-size: var(--apx-toast-font-size, 14px);\\r\\n    border-radius: var(--apx-toast-radius, 6px);\\r\\n    box-shadow: var(--apx-toast-shadow, 0 6px 24px rgba(0,0,0,0.2));\\r\\n    padding: var(--apx-toast-padding, 10px 42px 10px 14px);\\r\\n    color: #111;\\r\\n    background: #eee;\\r\\n    pointer-events: auto;\\r\\n    position: relative;\\r\\n    transition: opacity 180ms ease, transform 180ms ease;\\r\\n}\\r\\n\\r\\n.APX-toast--info { background: var(--apx-toast-info-bg, #0dcaf0); color: var(--apx-toast-info-fg, #052c65); }\\r\\n.APX-toast--success { background: var(--apx-toast-success-bg, #198754); color: var(--apx-toast-success-fg, #ffffff); }\\r\\n.APX-toast--warning { background: var(--apx-toast-warning-bg, #ffc107); color: var(--apx-toast-warning-fg, #664d03); }\\r\\n.APX-toast--danger { background: var(--apx-toast-danger-bg, #dc3545); color: var(--apx-toast-danger-fg, #ffffff); }\\r\\n\\r\\n.APX-toast__content { line-height: 1.35; }\\r\\n\\r\\n.APX-toast__close {\\r\\n    position: absolute;\\r\\n    top: 50%; right: 10px;\\r\\n    width: 24px; height: 24px;\\r\\n    transform: translateY(-50%);\\r\\n    display: inline-flex; align-items: center; justify-content: center;\\r\\n    background: transparent; color: currentColor;\\r\\n    border: 0; border-radius: 4px; padding: 0; margin: 0;\\r\\n    cursor: pointer; appearance: none; -webkit-appearance: none;\\r\\n    opacity: .75; transition: opacity 120ms ease;\\r\\n}\\r\\n.APX-toast__close:hover { opacity: 1; }\\r\\n.APX-toast__close:focus { outline: 2px solid rgba(0,0,0,.2); outline-offset: 2px; }\\r\\n.APX-toast__close::before {\\r\\n    content: '×';\\r\\n    font-size: 16px; line-height: 1; text-align: center;\\r\\n}\\r\\n\\r\\n/* Animations */\\r\\n.APX-toast--enter { opacity: 0; transform: translateY(8px); }\\r\\n.APX-toast--enter.APX-toast--enter-active { opacity: 1; transform: translateY(0); }\\r\\n.APX-toast--exit { opacity: 1; transform: translateY(0); }\\r\\n.APX-toast--exit.APX-toast--exit-active { opacity: 0; transform: translateY(8px); }\\r\\n\\r\\n\\r\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/api.js\";\nimport ___CSS_LOADER_GET_URL_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/getUrl.js\";\nvar ___CSS_LOADER_URL_IMPORT_0___ = new URL(\"data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A//www.w3.org/2000/svg%27%20width%3D%2732%27%20height%3D%2732%27%3E%3Cpath%20%20fill%3D%22%23cccccc%22%20d%3D%22M25.107%2032.030h-18.214c-3.456%200-6.268-2.81-6.268-6.264v-19.529c0-3.456%202.812-6.268%206.268-6.268h18.214c3.456%200%206.268%202.812%206.268%206.268v19.529c0%203.452-2.812%206.264-6.268%206.264zM6.893%201.85c-2.419%200-4.386%201.967-4.386%204.386v19.529c0%202.417%201.967%204.382%204.386%204.382h18.214c2.419%200%204.386-1.965%204.386-4.382v-19.529c0-2.419-1.967-4.386-4.386-4.386h-18.214z%22%3E%3C/path%3E%3C/svg%3E\", import.meta.url);\nvar ___CSS_LOADER_URL_IMPORT_1___ = new URL(\"data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A//www.w3.org/2000/svg%27%20width%3D%2732%27%20height%3D%2732%27%3E%3Cpath%20fill%3D%22%230654ba%22%20d%3D%22M0.543%205.647c0-3.119%202.531-5.647%205.65-5.647h19.309c3.12%200%205.65%202.511%205.65%205.647v20.705c0%203.119-2.531%205.647-5.65%205.647h-19.309c-3.12%200-5.65-2.511-5.65-5.647v-20.705zM5.313%2017.587l7.039%206.839%2013.831-13.439-2.636-2.561-10.929%2010.62-4.442-4.317-2.862%202.858z%22%3E%3C/path%3E%3C/svg%3E\", import.meta.url);\nvar ___CSS_LOADER_URL_IMPORT_2___ = new URL(\"data:image/svg+xml,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22UTF-8%22%3F%3E%3Csvg%20viewBox%3D%220%200%2032%2032%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22m0.543%205.647c0-3.119%202.531-5.647%205.65-5.647h19.309c3.12%200%205.65%202.511%205.65%205.647v20.705c0%203.119-2.531%205.647-5.65%205.647h-19.309c-3.12%200-5.65-2.511-5.65-5.647v-20.705z%22%20fill%3D%22%23f00%22%2F%3E%3Cpath%20d%3D%22m8%208%2016%2016%22%20stroke%3D%22%23fff%22%20stroke-width%3D%222%22%2F%3E%3Cpath%20d%3D%22M24%208L8%2024%22%20stroke%3D%22%23fff%22%20stroke-width%3D%222%22%2F%3E%3C%2Fsvg%3E\", import.meta.url);\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\nvar ___CSS_LOADER_URL_REPLACEMENT_0___ = ___CSS_LOADER_GET_URL_IMPORT___(___CSS_LOADER_URL_IMPORT_0___);\nvar ___CSS_LOADER_URL_REPLACEMENT_1___ = ___CSS_LOADER_GET_URL_IMPORT___(___CSS_LOADER_URL_IMPORT_1___);\nvar ___CSS_LOADER_URL_REPLACEMENT_2___ = ___CSS_LOADER_GET_URL_IMPORT___(___CSS_LOADER_URL_IMPORT_2___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.apx-tristate {\r\n    display: inline-block;\r\n    vertical-align: middle;\r\n    text-align: center;\r\n    cursor: pointer;\r\n    position: relative;\r\n    min-width:13px;\r\n    min-height:13px;\r\n    background-size: contain;\r\n    background-color: white;\r\n    border-radius:3px;\r\n}\r\n.apx-tristate.unchecked {\r\n    background-image: url(${___CSS_LOADER_URL_REPLACEMENT_0___});\r\n}\r\n.apx-tristate.checked {\r\n    background-image: url(${___CSS_LOADER_URL_REPLACEMENT_1___});\r\n    background-repeat: no-repeat;\r\n    background-position: center;\r\n}\r\n.apx-tristate.crossed {\r\n    background-image: url(${___CSS_LOADER_URL_REPLACEMENT_2___});\r\n    background-repeat: no-repeat;\r\n    background-position: center;\r\n}`, \"\",{\"version\":3,\"sources\":[\"webpack://./modules/tristate/css/tristate.css\"],\"names\":[],\"mappings\":\"AAAA;IACI,qBAAqB;IACrB,sBAAsB;IACtB,kBAAkB;IAClB,eAAe;IACf,kBAAkB;IAClB,cAAc;IACd,eAAe;IACf,wBAAwB;IACxB,uBAAuB;IACvB,iBAAiB;AACrB;AACA;IACI,yDAAylB;AAC7lB;AACA;IACI,yDAA6e;IAC7e,4BAA4B;IAC5B,2BAA2B;AAC/B;AACA;IACI,yDAAsnB;IACtnB,4BAA4B;IAC5B,2BAA2B;AAC/B\",\"sourcesContent\":[\".apx-tristate {\\r\\n    display: inline-block;\\r\\n    vertical-align: middle;\\r\\n    text-align: center;\\r\\n    cursor: pointer;\\r\\n    position: relative;\\r\\n    min-width:13px;\\r\\n    min-height:13px;\\r\\n    background-size: contain;\\r\\n    background-color: white;\\r\\n    border-radius:3px;\\r\\n}\\r\\n.apx-tristate.unchecked {\\r\\n    background-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A//www.w3.org/2000/svg%27%20width%3D%2732%27%20height%3D%2732%27%3E%3Cpath%20%20fill%3D%22%23cccccc%22%20d%3D%22M25.107%2032.030h-18.214c-3.456%200-6.268-2.81-6.268-6.264v-19.529c0-3.456%202.812-6.268%206.268-6.268h18.214c3.456%200%206.268%202.812%206.268%206.268v19.529c0%203.452-2.812%206.264-6.268%206.264zM6.893%201.85c-2.419%200-4.386%201.967-4.386%204.386v19.529c0%202.417%201.967%204.382%204.386%204.382h18.214c2.419%200%204.386-1.965%204.386-4.382v-19.529c0-2.419-1.967-4.386-4.386-4.386h-18.214z%22%3E%3C/path%3E%3C/svg%3E');\\r\\n}\\r\\n.apx-tristate.checked {\\r\\n    background-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A//www.w3.org/2000/svg%27%20width%3D%2732%27%20height%3D%2732%27%3E%3Cpath%20fill%3D%22%230654ba%22%20d%3D%22M0.543%205.647c0-3.119%202.531-5.647%205.65-5.647h19.309c3.12%200%205.65%202.511%205.65%205.647v20.705c0%203.119-2.531%205.647-5.65%205.647h-19.309c-3.12%200-5.65-2.511-5.65-5.647v-20.705zM5.313%2017.587l7.039%206.839%2013.831-13.439-2.636-2.561-10.929%2010.62-4.442-4.317-2.862%202.858z%22%3E%3C/path%3E%3C/svg%3E');\\r\\n    background-repeat: no-repeat;\\r\\n    background-position: center;\\r\\n}\\r\\n.apx-tristate.crossed {\\r\\n    background-image: url('data:image/svg+xml,%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22UTF-8%22%3F%3E%3Csvg%20viewBox%3D%220%200%2032%2032%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22m0.543%205.647c0-3.119%202.531-5.647%205.65-5.647h19.309c3.12%200%205.65%202.511%205.65%205.647v20.705c0%203.119-2.531%205.647-5.65%205.647h-19.309c-3.12%200-5.65-2.511-5.65-5.647v-20.705z%22%20fill%3D%22%23f00%22%2F%3E%3Cpath%20d%3D%22m8%208%2016%2016%22%20stroke%3D%22%23fff%22%20stroke-width%3D%222%22%2F%3E%3Cpath%20d%3D%22M24%208L8%2024%22%20stroke%3D%22%23fff%22%20stroke-width%3D%222%22%2F%3E%3C%2Fsvg%3E');\\r\\n    background-repeat: no-repeat;\\r\\n    background-position: center;\\r\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","\"use strict\";\n\n/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n*/\nmodule.exports = function (cssWithMappingToString) {\n  var list = [];\n\n  // return the list of modules as css string\n  list.toString = function toString() {\n    return this.map(function (item) {\n      var content = \"\";\n      var needLayer = typeof item[5] !== \"undefined\";\n      if (item[4]) {\n        content += \"@supports (\".concat(item[4], \") {\");\n      }\n      if (item[2]) {\n        content += \"@media \".concat(item[2], \" {\");\n      }\n      if (needLayer) {\n        content += \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\");\n      }\n      content += cssWithMappingToString(item);\n      if (needLayer) {\n        content += \"}\";\n      }\n      if (item[2]) {\n        content += \"}\";\n      }\n      if (item[4]) {\n        content += \"}\";\n      }\n      return content;\n    }).join(\"\");\n  };\n\n  // import a list of modules into the list\n  list.i = function i(modules, media, dedupe, supports, layer) {\n    if (typeof modules === \"string\") {\n      modules = [[null, modules, undefined]];\n    }\n    var alreadyImportedModules = {};\n    if (dedupe) {\n      for (var k = 0; k < this.length; k++) {\n        var id = this[k][0];\n        if (id != null) {\n          alreadyImportedModules[id] = true;\n        }\n      }\n    }\n    for (var _k = 0; _k < modules.length; _k++) {\n      var item = [].concat(modules[_k]);\n      if (dedupe && alreadyImportedModules[item[0]]) {\n        continue;\n      }\n      if (typeof layer !== \"undefined\") {\n        if (typeof item[5] === \"undefined\") {\n          item[5] = layer;\n        } else {\n          item[1] = \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\").concat(item[1], \"}\");\n          item[5] = layer;\n        }\n      }\n      if (media) {\n        if (!item[2]) {\n          item[2] = media;\n        } else {\n          item[1] = \"@media \".concat(item[2], \" {\").concat(item[1], \"}\");\n          item[2] = media;\n        }\n      }\n      if (supports) {\n        if (!item[4]) {\n          item[4] = \"\".concat(supports);\n        } else {\n          item[1] = \"@supports (\".concat(item[4], \") {\").concat(item[1], \"}\");\n          item[4] = supports;\n        }\n      }\n      list.push(item);\n    }\n  };\n  return list;\n};","\"use strict\";\n\nmodule.exports = function (url, options) {\n  if (!options) {\n    options = {};\n  }\n  if (!url) {\n    return url;\n  }\n  url = String(url.__esModule ? url.default : url);\n\n  // If url is already wrapped in quotes, remove them\n  if (/^['\"].*['\"]$/.test(url)) {\n    url = url.slice(1, -1);\n  }\n  if (options.hash) {\n    url += options.hash;\n  }\n\n  // Should url be wrapped?\n  // See https://drafts.csswg.org/css-values-3/#urls\n  if (/[\"'() \\t\\n]|(%20)/.test(url) || options.needQuotes) {\n    return \"\\\"\".concat(url.replace(/\"/g, '\\\\\"').replace(/\\n/g, \"\\\\n\"), \"\\\"\");\n  }\n  return url;\n};","\"use strict\";\n\nmodule.exports = function (item) {\n  var content = item[1];\n  var cssMapping = item[3];\n  if (!cssMapping) {\n    return content;\n  }\n  if (typeof btoa === \"function\") {\n    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));\n    var data = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\".concat(base64);\n    var sourceMapping = \"/*# \".concat(data, \" */\");\n    return [content].concat([sourceMapping]).join(\"\\n\");\n  }\n  return [content].join(\"\\n\");\n};","// Module\nvar code = \"<div class=\\\"APX-dialog\\\">\\r\\n    <div class=\\\"APX-dialog-content\\\">\\r\\n        <span class=\\\"APX-close-dialog\\\">&times;</span>\\r\\n        <h2 class=\\\"APX-dialog-title\\\"></h2>\\r\\n        <div class=\\\"APX-dialog-dynamic-content\\\"></div>\\r\\n        <div class=\\\"APX-dialog-button-container\\\"></div>\\r\\n    </div>\\r\\n</div>\";\n// Exports\nmodule.exports = code;","\n      import API from \"!../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../node_modules/css-loader/dist/cjs.js!./dialog.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../node_modules/css-loader/dist/cjs.js!./dialog.css\";\n       export default content && content.locals ? content.locals : undefined;\n","\n      import API from \"!../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../node_modules/css-loader/dist/cjs.js!./toast.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../node_modules/css-loader/dist/cjs.js!./toast.css\";\n       export default content && content.locals ? content.locals : undefined;\n","\n      import API from \"!../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../node_modules/css-loader/dist/cjs.js!./tristate.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../node_modules/css-loader/dist/cjs.js!./tristate.css\";\n       export default content && content.locals ? content.locals : undefined;\n","\"use strict\";\n\nvar stylesInDOM = [];\nfunction getIndexByIdentifier(identifier) {\n  var result = -1;\n  for (var i = 0; i < stylesInDOM.length; i++) {\n    if (stylesInDOM[i].identifier === identifier) {\n      result = i;\n      break;\n    }\n  }\n  return result;\n}\nfunction modulesToDom(list, options) {\n  var idCountMap = {};\n  var identifiers = [];\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i];\n    var id = options.base ? item[0] + options.base : item[0];\n    var count = idCountMap[id] || 0;\n    var identifier = \"\".concat(id, \" \").concat(count);\n    idCountMap[id] = count + 1;\n    var indexByIdentifier = getIndexByIdentifier(identifier);\n    var obj = {\n      css: item[1],\n      media: item[2],\n      sourceMap: item[3],\n      supports: item[4],\n      layer: item[5]\n    };\n    if (indexByIdentifier !== -1) {\n      stylesInDOM[indexByIdentifier].references++;\n      stylesInDOM[indexByIdentifier].updater(obj);\n    } else {\n      var updater = addElementStyle(obj, options);\n      options.byIndex = i;\n      stylesInDOM.splice(i, 0, {\n        identifier: identifier,\n        updater: updater,\n        references: 1\n      });\n    }\n    identifiers.push(identifier);\n  }\n  return identifiers;\n}\nfunction addElementStyle(obj, options) {\n  var api = options.domAPI(options);\n  api.update(obj);\n  var updater = function updater(newObj) {\n    if (newObj) {\n      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {\n        return;\n      }\n      api.update(obj = newObj);\n    } else {\n      api.remove();\n    }\n  };\n  return updater;\n}\nmodule.exports = function (list, options) {\n  options = options || {};\n  list = list || [];\n  var lastIdentifiers = modulesToDom(list, options);\n  return function update(newList) {\n    newList = newList || [];\n    for (var i = 0; i < lastIdentifiers.length; i++) {\n      var identifier = lastIdentifiers[i];\n      var index = getIndexByIdentifier(identifier);\n      stylesInDOM[index].references--;\n    }\n    var newLastIdentifiers = modulesToDom(newList, options);\n    for (var _i = 0; _i < lastIdentifiers.length; _i++) {\n      var _identifier = lastIdentifiers[_i];\n      var _index = getIndexByIdentifier(_identifier);\n      if (stylesInDOM[_index].references === 0) {\n        stylesInDOM[_index].updater();\n        stylesInDOM.splice(_index, 1);\n      }\n    }\n    lastIdentifiers = newLastIdentifiers;\n  };\n};","\"use strict\";\n\nvar memo = {};\n\n/* istanbul ignore next  */\nfunction getTarget(target) {\n  if (typeof memo[target] === \"undefined\") {\n    var styleTarget = document.querySelector(target);\n\n    // Special case to return head of iframe instead of iframe itself\n    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n      try {\n        // This will throw an exception if access to iframe is blocked\n        // due to cross-origin restrictions\n        styleTarget = styleTarget.contentDocument.head;\n      } catch (e) {\n        // istanbul ignore next\n        styleTarget = null;\n      }\n    }\n    memo[target] = styleTarget;\n  }\n  return memo[target];\n}\n\n/* istanbul ignore next  */\nfunction insertBySelector(insert, style) {\n  var target = getTarget(insert);\n  if (!target) {\n    throw new Error(\"Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.\");\n  }\n  target.appendChild(style);\n}\nmodule.exports = insertBySelector;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction insertStyleElement(options) {\n  var element = document.createElement(\"style\");\n  options.setAttributes(element, options.attributes);\n  options.insert(element, options.options);\n  return element;\n}\nmodule.exports = insertStyleElement;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction setAttributesWithoutAttributes(styleElement) {\n  var nonce = typeof __webpack_nonce__ !== \"undefined\" ? __webpack_nonce__ : null;\n  if (nonce) {\n    styleElement.setAttribute(\"nonce\", nonce);\n  }\n}\nmodule.exports = setAttributesWithoutAttributes;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction apply(styleElement, options, obj) {\n  var css = \"\";\n  if (obj.supports) {\n    css += \"@supports (\".concat(obj.supports, \") {\");\n  }\n  if (obj.media) {\n    css += \"@media \".concat(obj.media, \" {\");\n  }\n  var needLayer = typeof obj.layer !== \"undefined\";\n  if (needLayer) {\n    css += \"@layer\".concat(obj.layer.length > 0 ? \" \".concat(obj.layer) : \"\", \" {\");\n  }\n  css += obj.css;\n  if (needLayer) {\n    css += \"}\";\n  }\n  if (obj.media) {\n    css += \"}\";\n  }\n  if (obj.supports) {\n    css += \"}\";\n  }\n  var sourceMap = obj.sourceMap;\n  if (sourceMap && typeof btoa !== \"undefined\") {\n    css += \"\\n/*# sourceMappingURL=data:application/json;base64,\".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), \" */\");\n  }\n\n  // For old IE\n  /* istanbul ignore if  */\n  options.styleTagTransform(css, styleElement, options.options);\n}\nfunction removeStyleElement(styleElement) {\n  // istanbul ignore if\n  if (styleElement.parentNode === null) {\n    return false;\n  }\n  styleElement.parentNode.removeChild(styleElement);\n}\n\n/* istanbul ignore next  */\nfunction domAPI(options) {\n  if (typeof document === \"undefined\") {\n    return {\n      update: function update() {},\n      remove: function remove() {}\n    };\n  }\n  var styleElement = options.insertStyleElement(options);\n  return {\n    update: function update(obj) {\n      apply(styleElement, options, obj);\n    },\n    remove: function remove() {\n      removeStyleElement(styleElement);\n    }\n  };\n}\nmodule.exports = domAPI;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction styleTagTransform(css, styleElement) {\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css;\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild);\n    }\n    styleElement.appendChild(document.createTextNode(css));\n  }\n}\nmodule.exports = styleTagTransform;","// Function to load the CSS from a given URL\r\nfunction loadCss(url) {\r\n    return fetch(url)\r\n        .then(response => response.text())\r\n        .then(css => {\r\n            const styleSheet = document.createElement(\"style\");\r\n            styleSheet.type = \"text/css\";\r\n            styleSheet.textContent = css;  // Use textContent instead of innerText\r\n            document.head.appendChild(styleSheet);\r\n        })\r\n        .catch(error => {\r\n            console.error(\"Failed to load CSS:\", error);\r\n        });\r\n}\r\n\r\nexport {\r\n    loadCss\r\n}","// Importing the CSS and HTML templates\r\nimport './css/dialog.css';\r\nimport dialogTemplate from './html/dialog.html?raw';\r\n\r\nconst createDialog = (options) => {\r\n    const dialogDefaults = {\r\n        title: '',\r\n        content: '',\r\n        contentURI: '',\r\n        buttons: [],\r\n        size: 'medium',\r\n        showLoadingIndicator: false,\r\n        contentMethod: 'GET',\r\n        contentData: null,\r\n        contentHeaders: undefined\r\n    };\r\n\r\n    const { title, content, contentURI, buttons, size, showLoadingIndicator, contentMethod, contentData, contentHeaders } = { ...dialogDefaults, ...options };\r\n\r\n    const wrapper = document.createElement('div');\r\n    wrapper.innerHTML = dialogTemplate.trim();\r\n    const dialogElement = wrapper.firstChild;\r\n\r\n    // Lifecycle event management\r\n    const lifecycleResolvers = {};\r\n    const lifecycleEvents = {};\r\n\r\n    // Define lifecycle promises as properties\r\n    ['opening', 'opened', 'closing', 'closed', 'contentLoading', 'contentLoaded'].forEach((event) => {\r\n        lifecycleEvents[event] = new Promise((resolve) => {\r\n            lifecycleResolvers[event] = resolve;\r\n        });\r\n    });\r\n\r\n    const triggerEvent = (event) => {\r\n        if (lifecycleResolvers[event]) {\r\n            lifecycleResolvers[event]();\r\n        } else {\r\n            console.warn(`No resolver found for lifecycle event: ${event}`);\r\n        }\r\n    };\r\n\r\n    const dialog = {\r\n        element: dialogElement,\r\n        buttons: {},\r\n        isClosed: false,\r\n        lifecycle: lifecycleEvents, // Lifecycle promises directly exposed here\r\n        disableButton: (key) => {\r\n            const button = dialogElement.querySelector(`.APX-dialog-button[data-key=\"${key}\"]`);\r\n            if (button) {\r\n                button.disabled = true;\r\n                button.classList.add('APX-dialog-button-disabled');\r\n            }\r\n        },\r\n        enableButton: (key) => {\r\n            const button = dialogElement.querySelector(`.APX-dialog-button[data-key=\"${key}\"]`);\r\n            if (button) {\r\n                button.disabled = false;\r\n                button.classList.remove('APX-dialog-button-disabled');\r\n            }\r\n        },\r\n        open: async () => {\r\n            try {\r\n                triggerEvent('opening');\r\n                await dialog.lifecycle.opening;\r\n\r\n                // If loading indicator is enabled and we're fetching content, show dialog first\r\n                if (showLoadingIndicator && contentURI) {\r\n                    // Append dialog to the DOM and display it first\r\n                    document.body.appendChild(dialogElement);\r\n                    dialogElement.style.display = \"flex\";\r\n                    \r\n                    // Show loading indicator\r\n                    dialogElement.querySelector(\".APX-dialog-dynamic-content\").innerHTML = '<div class=\"APX-dialog-loading-indicator\"></div>';\r\n                    \r\n                    // Load content after dialog is visible\r\n                    await fetchAndInsertContent();\r\n                } else {\r\n                    // Default behavior: load content first, then show dialog\r\n                    await fetchAndInsertContent();\r\n                    \r\n                    // Append dialog to the DOM and display it\r\n                    document.body.appendChild(dialogElement);\r\n                    dialogElement.style.display = \"flex\";\r\n                }\r\n\r\n                triggerEvent('opened');\r\n                await dialog.lifecycle.opened;\r\n            } catch (error) {\r\n                console.error('Error opening dialog:', error);\r\n            }\r\n            return dialog; // Return for daisy-chaining\r\n        },\r\n        close: async () => {\r\n            try {\r\n                triggerEvent('closing');\r\n                await dialog.lifecycle.closing;\r\n\r\n                // Cleanup and remove dialog\r\n                closeDialogAndCleanup();\r\n\r\n                triggerEvent('closed');\r\n                await dialog.lifecycle.closed;\r\n            } catch (error) {\r\n                console.error('Error during dialog closing:', error);\r\n            }\r\n            return dialog; // Return for daisy-chaining\r\n        }\r\n    };\r\n\r\n    const closeDialogAndCleanup = () => {\r\n        if (dialog.isClosed) return;\r\n\r\n        dialog.isClosed = true;\r\n        dialogElement.style.display = \"none\";\r\n        if (document.body.contains(dialogElement)) {\r\n            document.body.removeChild(dialogElement);\r\n        }\r\n    };\r\n\r\n    const setDialogSize = () => {\r\n        const dialogContent = dialogElement.querySelector(\".APX-dialog-content\");\r\n        const sizes = {\r\n            small: { width: '300px', height: '200px' },\r\n            medium: { width: '500px', height: '400px' },\r\n            large: { width: '800px', height: '600px' }\r\n        };\r\n\r\n        if (size === 'auto') return;\r\n\r\n        const selectedSize = sizes[size] || (typeof size === 'object' && size);\r\n        if (selectedSize) {\r\n            dialogContent.style.minWidth = selectedSize.width || '500px';\r\n            dialogContent.style.minHeight = selectedSize.height || '400px';\r\n        }\r\n    };\r\n\r\n    const addButtons = () => {\r\n        const buttonContainer = dialogElement.querySelector(\".APX-dialog-button-container\");\r\n\r\n        buttons.forEach(({ key, label, order = 0, align = 'flex-end', closeOnClick = true }) => {\r\n            const button = document.createElement('button');\r\n            button.classList.add('APX-dialog-button');\r\n            button.textContent = label;\r\n            button.style.order = order;\r\n            button.setAttribute('data-key', key);\r\n\r\n            // Create button context with disable/enable methods\r\n            const buttonContext = {\r\n                disable: () => {\r\n                    button.disabled = true;\r\n                    button.classList.add('APX-dialog-button-disabled');\r\n                },\r\n                enable: () => {\r\n                    button.disabled = false;\r\n                    button.classList.remove('APX-dialog-button-disabled');\r\n                },\r\n                key,\r\n                element: button\r\n            };\r\n\r\n            if (closeOnClick) {\r\n                // Handle as a one-time Promise\r\n                let firstClickResolved = false;\r\n\r\n                const firstClickPromise = new Promise((resolve) => {\r\n                    button.onclick = () => {\r\n                        if (!firstClickResolved && !button.disabled) {\r\n                            firstClickResolved = true;\r\n                            resolve({ dialog, button: buttonContext }); // Pass both dialog and button context\r\n                            dialog.close(); // Close the dialog\r\n                        }\r\n                    };\r\n                });\r\n\r\n                // Assign the promise for chaining with `.then`\r\n                dialog.buttons[key] = firstClickPromise;\r\n            } else {\r\n                // Handle as a repeated event handler\r\n                let handlers = []; // Store handlers for `.then()`\r\n\r\n                const clickPromise = {\r\n                    then: (callback) => {\r\n                        if (typeof callback === 'function') {\r\n                            handlers.push(callback); // Add to handlers\r\n                        }\r\n                        return clickPromise; // Allow chaining\r\n                    },\r\n                };\r\n\r\n                button.onclick = () => {\r\n                    if (!button.disabled) {\r\n                        handlers.forEach((handler) => handler({ dialog, button: buttonContext })); // Pass both dialog and button context\r\n                    }\r\n                };\r\n\r\n                dialog.buttons[key] = clickPromise; // Assign the \"fake\" promise\r\n            }\r\n\r\n            buttonContainer.appendChild(button);\r\n            buttonContainer.style.justifyContent = align;\r\n        });\r\n    };\r\n\r\n    const fetchAndInsertContent = async () => {\r\n        const originalCursor = document.body.style.cursor;\r\n        document.body.style.cursor = 'wait';\r\n        const dynamicContent = dialogElement.querySelector(\".APX-dialog-dynamic-content\");\r\n        \r\n        try {\r\n            triggerEvent('contentLoading');\r\n            await dialog.lifecycle.contentLoading;\r\n\r\n            const contentHtml = contentURI\r\n                ? await fetchContent(contentURI)\r\n                : content;\r\n\r\n            dynamicContent.innerHTML = contentHtml;\r\n\r\n            triggerEvent('contentLoaded');\r\n            await dialog.lifecycle.contentLoaded;\r\n        } catch (error) {\r\n            console.error('Error loading content:', error);\r\n        } finally {\r\n            document.body.style.cursor = originalCursor;\r\n        }\r\n    };\r\n\r\n    const fetchContent = async (uri) => {\r\n        const method = (contentMethod || 'GET').toUpperCase();\r\n\r\n        // Always allow custom headers; we only add Content-Type when we can infer it\r\n        const headers = { ...(contentHeaders || {}) };\r\n        const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === 'content-type');\r\n\r\n        /**\r\n         * Build RequestInit depending on method and contentData type.\r\n         * We avoid setting Content-Type for FormData and raw string/Blob payloads,\r\n         * unless the caller explicitly provided it via contentHeaders.\r\n         */\r\n        const init = { method };\r\n\r\n        if (method === 'POST') {\r\n            let body = undefined;\r\n\r\n            const isFormData = typeof FormData !== 'undefined' && contentData instanceof FormData;\r\n            const isURLSearchParams = typeof URLSearchParams !== 'undefined' && contentData instanceof URLSearchParams;\r\n            const isBlob = typeof Blob !== 'undefined' && contentData instanceof Blob;\r\n            const isString = typeof contentData === 'string';\r\n            const isPlainObject = contentData && typeof contentData === 'object' && !isFormData && !isURLSearchParams && !isBlob;\r\n\r\n            if (isFormData) {\r\n                body = contentData;\r\n                // Do not set Content-Type for FormData; browser will set the boundary\r\n            } else if (isURLSearchParams) {\r\n                body = contentData;\r\n                if (!hasContentType) headers['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8';\r\n            } else if (isPlainObject) {\r\n                body = JSON.stringify(contentData);\r\n                if (!hasContentType) headers['Content-Type'] = 'application/json';\r\n            } else if (isString || isBlob) {\r\n                body = contentData;\r\n                // Content-Type left to caller if needed\r\n            } else if (contentData != null) {\r\n                // Fallback: try send as-is\r\n                body = contentData;\r\n            }\r\n\r\n            if (body !== undefined) {\r\n                init.body = body;\r\n            }\r\n        }\r\n\r\n        if (Object.keys(headers).length > 0) {\r\n            init.headers = headers;\r\n        }\r\n\r\n        const response = await fetch(uri, init);\r\n        if (!response.ok) throw new Error(`Failed to fetch content: ${response.statusText}`);\r\n        return response.text();\r\n    };\r\n\r\n    // Initialize dialog\r\n    setDialogSize();\r\n    addButtons();\r\n\r\n    // Set title and close button handler\r\n    dialogElement.querySelector(\".APX-dialog-title\").textContent = title;\r\n    dialogElement.querySelector('.APX-close-dialog').onclick = dialog.close;\r\n\r\n    return dialog;\r\n};\r\n\r\nexport default createDialog;\r\n","let counter = 0;\r\nconst doCallbacks = {};\r\nconst timeouts = {};\r\n\r\n/**\r\n * This function adds an event listener to the elements and returns an object with a do method to add callback functions.\r\n * @param {Object} apx - The apx object to augment with the listen function.\r\n * @returns {Object} - The augmented apx object.\r\n */\r\nexport default function (apx) {\r\n    let elements = apx.elements;\r\n\r\n    /**\r\n     * Adds an event listener to the elements and returns an object with a do method to add callback functions.\r\n     * @param {string} eventType - The type of event to listen for (e.g. 'click', 'keydown', etc.).\r\n     * @param {string} [selector] - The CSS selector to use for event delegation (optional).\r\n     * @returns {Object} - An object with a do method to add callback functions.\r\n     * @example\r\n     * apx.listen('click', '.my-button').do((event) => {\r\n     *   console.log('Button clicked!', event.target);\r\n     * });\r\n     */\r\n    apx.listen = function (eventTypes, secondArgument, thirdArgument) {\r\n        let selector;\r\n        let options = {};\r\n        // Determine if the second argument is a selector or options\r\n        if (typeof secondArgument === 'string') {\r\n            selector = secondArgument;\r\n            options = thirdArgument || {};\r\n        } else {\r\n            options = secondArgument || {};\r\n        }\r\n\r\n        const uniqueId = generateUniqueId();\r\n        const timeoutDuration = options.timeout || 0;\r\n        \r\n        if (!Array.isArray(eventTypes)) {\r\n            eventTypes = [eventTypes]; // Ensure eventTypes is an array\r\n        }\r\n        \r\n        eventTypes.forEach((eventType) => {\r\n            elements.forEach((element) => {\r\n                element.addEventListener(eventType, (event) => {\r\n                    executeCallbacks(event, uniqueId, timeoutDuration, selector, element);\r\n                });\r\n            });\r\n        });\r\n\r\n        return {\r\n            /**\r\n             * Adds a callback function to the doCallbacks object for the current event listener.\r\n             * @param {Function} doCallback - The callback function to execute when the event is triggered.\r\n             * @returns {Object} - Returns the current object to allow for chained calls.\r\n             * @example\r\n             * apx.listen('click', '.my-button').do((event) => {\r\n             *   console.log('Button clicked!', event.target);\r\n             * }).do((event) => {\r\n             *   console.log('Another callback function!');\r\n             * });\r\n             */\r\n            do: function (doCallback) {\r\n                if (!doCallbacks[uniqueId]) {\r\n                    doCallbacks[uniqueId] = [];\r\n                }\r\n                doCallbacks[uniqueId].push(doCallback);\r\n                return this; // Return the object to allow for chained calls\r\n            },\r\n        };\r\n    };\r\n\r\n    /**\r\n     * Manually triggers the registered callbacks for a given event type on all elements or creates a new event if a string is provided.\r\n     * @param {string|Event} event - The event to trigger. This can be an event type string (like 'click') or an actual Event object.\r\n     */\r\n    apx.trigger = function (event) {\r\n        let eventType;\r\n        if (typeof event === 'string') {\r\n            eventType = event;\r\n            event = new Event(event, { bubbles: true, cancelable: true });\r\n        } else if (event instanceof Event) {\r\n            eventType = event.type;\r\n        } else {\r\n            console.error('Invalid event type provided to apx.trigger. It must be either a string or Event object.');\r\n            return;\r\n        }\r\n\r\n        apx.elements.forEach((element) => {\r\n            element.dispatchEvent(event);  // This will allow the event to bubble up naturally.\r\n        });\r\n\r\n        // Handle event delegation manually by executing callbacks if the target matches the selector\r\n        Object.keys(doCallbacks).forEach((uniqueId) => {\r\n            const callbackDetails = doCallbacks[uniqueId];\r\n            if (callbackDetails && callbackDetails.eventType === eventType) {\r\n                // Check if the event target matches the selector used during listener registration\r\n                const { selector } = callbackDetails;\r\n                if (!selector || event.target.matches(selector)) {\r\n                    executeCallbacks(event, uniqueId, 0, selector, event.target);  // Immediate execution, no timeout\r\n                }\r\n            }\r\n        });\r\n    };\r\n    \r\n    return apx;\r\n};\r\n\r\n\r\nfunction executeCallbacks(event, uniqueId, timeoutDuration, selector = '', element) {\r\n    const matchedElement = selector ? closest(event.target, selector) : element;\r\n    if (!matchedElement) {\r\n        return;\r\n    }\r\n\r\n    // Clear any previous timeout for this uniqueId to prevent unintended behavior\r\n    clearTimeout(timeouts[uniqueId]);\r\n\r\n    // Function to handle the execution of callbacks\r\n    function handleCallbackExecution() {\r\n        if (doCallbacks[uniqueId]) {\r\n            doCallbacks[uniqueId].reduce((prevPromise, doCallback) => {\r\n                return prevPromise.then(() => {\r\n                    return new Promise((resolve, reject) => {\r\n                        try {\r\n                            const result = doCallback.bind(matchedElement)(event);\r\n                            if (result instanceof Promise) {\r\n                                result.then(resolve).catch(reject);\r\n                            } else {\r\n                                resolve(result);\r\n                            }\r\n                        } catch (error) {\r\n                            reject(error);\r\n                        }\r\n                    });\r\n                });\r\n            }, Promise.resolve()).catch(error => {\r\n                console.error('Error in callback chain:', error);\r\n            });\r\n        }\r\n    }\r\n\r\n    // Check if timeoutDuration is zero to decide whether to delay the callback execution or not\r\n    if (timeoutDuration === 0) {\r\n        handleCallbackExecution();\r\n    } else {\r\n        timeouts[uniqueId] = setTimeout(handleCallbackExecution, timeoutDuration);\r\n    }\r\n}\r\n\r\n\r\nfunction generateUniqueId() {\r\n    const randomPart = Math.random().toString(36).substr(2, 9); // More randomness\r\n    const uniqueId = `${Date.now()}_${randomPart}_${counter}`;\r\n    counter = (counter + 1) % 1000; // Reset counter to avoid overflow\r\n\r\n    return uniqueId;\r\n}\r\n\r\nfunction closest(element, selector) {\r\n    while (element && element.nodeType === 1) {\r\n        if (element.matches(selector)) {\r\n            return element;\r\n        }\r\n        element = element.parentNode;\r\n    }\r\n    return null;\r\n}\r\n","// Minimal, framework-agnostic ToastManager for APX\r\n// ESM-first, no side effects on import. DOM only when used.\r\nimport './css/toast.css';\r\n\r\n/**\r\n * @typedef {Object} PositionObject\r\n * @property {'sticky'|'relative'|'anchored'} [type]\r\n * @property {string} [x]\r\n * @property {string} [y]\r\n * @property {HTMLElement} [element]\r\n * @property {'top'|'right'|'bottom'|'left'|'above'|'below'|'before'|'after'} [placement]\r\n * @property {string} [gap]\r\n * @property {boolean} [useNativeCSS]\r\n */\r\n\r\n/**\r\n * @typedef {string|PositionObject} Position\r\n */\r\n\r\n/**\r\n * @typedef {Object} ToastConfig\r\n * @property {Position} [position]\r\n * @property {'up'|'down'|'auto'} [flow] Flow direction for stacking toasts. 'auto' determines based on position. Default: 'auto'\r\n * @property {number} [maxToasts]\r\n * @property {number} [defaultDurationMs]\r\n * @property {number} [zIndex]\r\n * @property {'polite'|'assertive'|'off'} [ariaLive]\r\n * @property {number} [gap]\r\n * @property {boolean} [dedupe]\r\n * @property {string} [containerClass]\r\n * @property {number} [offset]\r\n * @property {string} [id]\r\n */\r\n\r\n/**\r\n * @typedef {Object} ToastOptions\r\n * @property {string|Node} message\r\n * @property {'info'|'success'|'warning'|'danger'} [type]\r\n * @property {number} [durationMs]\r\n * @property {boolean} [dismissible]\r\n * @property {string} [id]\r\n * @property {(ref: ToastRef, ev: MouseEvent) => void} [onClick]\r\n * @property {(ref: ToastRef, reason: 'timeout'|'close'|'api'|'overflow') => void} [onClose]\r\n * @property {string} [className]\r\n * @property {Position} [position]\r\n * @property {'up'|'down'|'auto'} [flow] Flow direction for stacking toasts. 'auto' determines based on position. Default: 'auto'\r\n */\r\n\r\n/**\r\n * @typedef {Object} ToastRef\r\n * @property {string} id\r\n * @property {HTMLElement} el\r\n * @property {(reason?: 'api'|'close') => void} close\r\n * @property {(partial: Partial<ToastOptions>) => void} update\r\n * @property {() => Promise<void>} whenClosed\r\n * @property {(event: 'close'|'click', handler: Function) => () => void} on\r\n * @property {(event: 'close'|'click', handler: Function) => void} off\r\n */\r\n\r\nconst isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';\r\n\r\n// Shared container cache: Map<position, HTMLElement>\r\n// Containers are shared between managers with the same position\r\nconst _containerCache = new Map();\r\n\r\n// Garbage collection: cleanup empty unmanaged containers after a delay\r\nconst GC_DELAY_MS = 20000; // 20 seconds\r\nlet _gcTimeoutId = null;\r\n\r\n// Wrapper for all toast containers (keeps DOM clean)\r\nlet _toastWrapper = null;\r\n\r\n/**\r\n * Get or create the toast containers wrapper\r\n * @returns {HTMLElement|null}\r\n */\r\nfunction getToastWrapper() {\r\n    if (!isBrowser) return null;\r\n    \r\n    if (!_toastWrapper) {\r\n        _toastWrapper = document.querySelector('.APX-toast-wrapper');\r\n        if (!_toastWrapper) {\r\n            _toastWrapper = createEl('div', 'APX-toast-wrapper');\r\n            _toastWrapper.style.position = 'fixed';\r\n            _toastWrapper.style.top = '0';\r\n            _toastWrapper.style.left = '0';\r\n            _toastWrapper.style.width = '0';\r\n            _toastWrapper.style.height = '0';\r\n            _toastWrapper.style.pointerEvents = 'none';\r\n            _toastWrapper.style.zIndex = '10000'; // Below containers but above most content\r\n            document.body.appendChild(_toastWrapper);\r\n        }\r\n    }\r\n    \r\n    return _toastWrapper;\r\n}\r\n\r\nconst DEFAULT_CONFIG = {\r\n    position: 'bottom-right',\r\n    maxToasts: 5,\r\n    defaultDurationMs: 5000,\r\n    zIndex: 11000,\r\n    ariaLive: 'polite',\r\n    gap: 8,\r\n    dedupe: false,\r\n    containerClass: '',\r\n    offset: 0\r\n};\r\n\r\n/**\r\n * Create an element with classes\r\n */\r\nfunction createEl(tag, classNames) {\r\n    const el = document.createElement(tag);\r\n    if (classNames) {\r\n        classNames.split(' ').filter(Boolean).forEach(c => el.classList.add(c));\r\n    }\r\n    return el;\r\n}\r\n\r\n/**\r\n * Normalize placement synonyms to CSS values\r\n * @param {string} placement\r\n * @returns {'top'|'right'|'bottom'|'left'}\r\n */\r\nfunction normalizePlacement(placement) {\r\n    const synonyms = {\r\n        'above': 'top',\r\n        'below': 'bottom',\r\n        'before': 'left',\r\n        'after': 'right'\r\n    };\r\n    return synonyms[placement] || placement;\r\n}\r\n\r\n/**\r\n * Determine flow direction based on position\r\n * @param {Position} position\r\n * @returns {'up'|'down'}\r\n */\r\nfunction determineFlow(position) {\r\n    if (typeof position === 'string') {\r\n        // String positions: top = up, bottom = down\r\n        if (position.includes('top')) return 'up';\r\n        if (position.includes('bottom')) return 'down';\r\n        return 'down'; // default\r\n    }\r\n    \r\n    if (typeof position === 'object' && position !== null) {\r\n        const type = position.type || (position.x || position.y ? 'sticky' : null);\r\n        \r\n        if (type === 'sticky' || (!type && (position.x || position.y))) {\r\n            // Sticky: determine based on y coordinate\r\n            if (position.y !== undefined) {\r\n                // If y starts with '-' or is a small value, likely top (up)\r\n                // If y is a large value or percentage, likely bottom (down)\r\n                if (position.y.startsWith('-')) {\r\n                    // Negative = from bottom, so flow down\r\n                    return 'down';\r\n                }\r\n                const num = parseFloat(position.y);\r\n                if (!isNaN(num)) {\r\n                    // If y < 50% of viewport height, likely top (up)\r\n                    // Otherwise likely bottom (down)\r\n                    if (position.y.includes('%')) {\r\n                        return num < 50 ? 'up' : 'down';\r\n                    }\r\n                    // For px values, assume < 400px is top (up)\r\n                    return num < 400 ? 'up' : 'down';\r\n                }\r\n            }\r\n            return 'down'; // default\r\n        }\r\n        \r\n        if (type === 'anchored' && position.placement) {\r\n            // Anchored: placement determines flow\r\n            const placement = normalizePlacement(position.placement);\r\n            if (placement === 'top' || placement === 'above') return 'up';\r\n            if (placement === 'bottom' || placement === 'below') return 'down';\r\n            // For left/right, default to down\r\n            return 'down';\r\n        }\r\n        \r\n        if (type === 'relative') {\r\n            // Relative: determine based on y offset\r\n            if (position.y !== undefined) {\r\n                const num = parseFloat(position.y);\r\n                if (!isNaN(num)) {\r\n                    // Negative y = above element = flow up\r\n                    // Positive y = below element = flow down\r\n                    return num < 0 ? 'up' : 'down';\r\n                }\r\n            }\r\n            return 'down'; // default\r\n        }\r\n    }\r\n    \r\n    return 'down'; // default\r\n}\r\n\r\n/**\r\n * Garbage collection: remove empty unmanaged containers\r\n */\r\nfunction cleanupEmptyContainers() {\r\n    if (!isBrowser) return;\r\n    \r\n    const containers = document.querySelectorAll('.APX-toast-container:not([data-apx-toast-managed=\"true\"])');\r\n    containers.forEach(container => {\r\n        // Check if container is empty (no toasts)\r\n        if (container.children.length === 0) {\r\n            const positionKey = container.getAttribute('data-apx-toast-position');\r\n            if (positionKey) {\r\n                _containerCache.delete(positionKey);\r\n            }\r\n            container.remove();\r\n        }\r\n    });\r\n    \r\n    // Clean up wrapper if it's empty (all containers removed)\r\n    if (_toastWrapper && _toastWrapper.children.length === 0) {\r\n        _toastWrapper.remove();\r\n        _toastWrapper = null;\r\n    }\r\n    \r\n    _gcTimeoutId = null;\r\n}\r\n\r\n/**\r\n * Schedule garbage collection for empty unmanaged containers\r\n */\r\nfunction scheduleGarbageCollection() {\r\n    if (_gcTimeoutId) {\r\n        clearTimeout(_gcTimeoutId);\r\n    }\r\n    _gcTimeoutId = setTimeout(cleanupEmptyContainers, GC_DELAY_MS);\r\n}\r\n\r\n/**\r\n * Find all scrollable parent elements\r\n * @param {HTMLElement} element\r\n * @returns {HTMLElement[]}\r\n */\r\nfunction findScrollableParents(element) {\r\n    const scrollables = [];\r\n    let current = element.parentElement;\r\n    \r\n    while (current && current !== document.body && current !== document.documentElement) {\r\n        const style = window.getComputedStyle(current);\r\n        const overflow = style.overflow + style.overflowY + style.overflowX;\r\n        \r\n        if (overflow.includes('scroll') || overflow.includes('auto')) {\r\n            scrollables.push(current);\r\n        }\r\n        \r\n        current = current.parentElement;\r\n    }\r\n    \r\n    return scrollables;\r\n}\r\n\r\n/**\r\n * Hash an element to create a unique identifier\r\n * @param {HTMLElement} el\r\n * @returns {string}\r\n */\r\nfunction hashElement(el) {\r\n    const rect = el.getBoundingClientRect();\r\n    const str = `${el.tagName}_${rect.left}_${rect.top}_${rect.width}_${rect.height}`;\r\n    let hash = 0;\r\n    for (let i = 0; i < str.length; i++) {\r\n        const char = str.charCodeAt(i);\r\n        hash = ((hash << 5) - hash) + char;\r\n        hash = hash & hash; // Convert to 32bit integer\r\n    }\r\n    return Math.abs(hash).toString(36);\r\n}\r\n\r\n/**\r\n * Serialize position options into a unique key\r\n * @param {Position} position\r\n * @returns {string}\r\n */\r\nfunction serializePosition(position) {\r\n    if (typeof position === 'string') {\r\n        return `s:${position}`;\r\n    }\r\n    \r\n    if (typeof position === 'object' && position !== null) {\r\n        const parts = [];\r\n        \r\n        // Type (default: sticky if x/y provided)\r\n        const type = position.type || (position.x || position.y ? 'sticky' : null);\r\n        if (type) parts.push(`t:${type}`);\r\n        \r\n        // Coordinates\r\n        if (position.x !== undefined) parts.push(`x:${position.x}`);\r\n        if (position.y !== undefined) parts.push(`y:${position.y}`);\r\n        \r\n        // For relative/anchored: use element ID or hash\r\n        if (position.element) {\r\n            const elementId = position.element.id || \r\n                             position.element.dataset?.apxToastAnchorId ||\r\n                             `el_${hashElement(position.element)}`;\r\n            parts.push(`el:${elementId}`);\r\n        }\r\n        \r\n        if (position.placement) {\r\n            // Normalize placement for serialization (use CSS values)\r\n            const normalized = normalizePlacement(position.placement);\r\n            parts.push(`p:${normalized}`);\r\n        }\r\n        if (position.gap !== undefined) parts.push(`g:${position.gap}`);\r\n        if (position.useNativeCSS) parts.push(`native:true`);\r\n        \r\n        return `o:${parts.join('|')}`;\r\n    }\r\n    \r\n    return 's:bottom-right';\r\n}\r\n\r\n/**\r\n * ToastManager class\r\n */\r\nclass ToastManager {\r\n    /** @param {Partial<ToastConfig>=} config */\r\n    constructor(config) {\r\n        /** @type {ToastConfig} */\r\n        this.config = { ...DEFAULT_CONFIG, ...(config || {}) };\r\n        /** @type {HTMLElement|null} */\r\n        this.container = null;\r\n        /** @type {Map<string, ToastRef>} */\r\n        this.idToRef = new Map();\r\n        /** @type {ToastRef[]} */\r\n        this.open = [];\r\n    }\r\n\r\n    /** @param {Partial<ToastConfig>} config */\r\n    configure(config) {\r\n        this.config = { ...this.config, ...(config || {}) };\r\n        if (this.container) this.applyContainerConfig();\r\n    }\r\n\r\n    /** @param {'polite'|'assertive'|'off'} mode */\r\n    setAriaLive(mode) { this.configure({ ariaLive: mode }); }\r\n\r\n    /** @returns {ToastRef[]} */\r\n    getOpenToasts() { return this.open.slice(); }\r\n\r\n    /** @param {ToastOptions} opts */\r\n    show(opts) {\r\n        if (!isBrowser) return /** @type {any} */(null);\r\n        const options = this.normalizeOptions(opts);\r\n\r\n        if (this.config.dedupe && options.id && this.idToRef.has(options.id)) {\r\n            const ref = this.idToRef.get(options.id);\r\n            ref.update(options);\r\n            return ref;\r\n        }\r\n\r\n        // Determine position and flow for this toast (options take precedence over config)\r\n        const position = options.position || this.config.position || 'bottom-right';\r\n        const flow = options.flow !== undefined ? options.flow : (this.config.flow !== undefined ? this.config.flow : 'auto');\r\n        const finalFlow = flow === 'auto' ? determineFlow(position) : flow;\r\n        \r\n        // Ensure default container is set (for backward compatibility)\r\n        this.ensureContainer();\r\n\r\n        const toastEl = createEl('div', `APX-toast APX-toast--${options.type}`);\r\n        toastEl.setAttribute('role', 'status');\r\n        // Priority: options.id > config.id > auto-generated\r\n        const toastId = options.id || `t_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;\r\n        toastEl.dataset.toastId = toastId;\r\n        if (options.className) toastEl.className += ` ${options.className}`;\r\n\r\n        const contentEl = createEl('div', 'APX-toast__content');\r\n        if (typeof options.message === 'string') {\r\n            contentEl.textContent = options.message;\r\n        } else if (options.message) {\r\n            contentEl.appendChild(options.message);\r\n        }\r\n        toastEl.appendChild(contentEl);\r\n\r\n        let closeBtn = null;\r\n        if (options.dismissible !== false) {\r\n            closeBtn = createEl('button', 'APX-toast__close');\r\n            closeBtn.setAttribute('aria-label', 'Close');\r\n            closeBtn.type = 'button';\r\n            toastEl.appendChild(closeBtn);\r\n        }\r\n\r\n        // Get or create container for this specific position\r\n        let container = null;\r\n        let positionUpdateFn = null;\r\n        let positionCleanup = null;\r\n        let originalElementStyle = null;\r\n        \r\n        if (position && typeof position === 'object' && position !== null) {\r\n            const type = position.type || (position.x || position.y ? 'sticky' : null);\r\n            \r\n            if (position.useNativeCSS && (type === 'relative' || type === 'anchored') && position.element) {\r\n                // useNativeCSS: true - create container in target element using native CSS\r\n                const targetEl = position.element;\r\n                originalElementStyle = targetEl.style.position;\r\n                targetEl.style.position = 'relative';\r\n                \r\n                // Create a container for stacking toasts (reuse if exists)\r\n                const positionKey = serializePosition(position);\r\n                let nativeContainer = targetEl.querySelector(`[data-apx-toast-position=\"${positionKey}\"]`);\r\n                if (!nativeContainer) {\r\n                    nativeContainer = createEl('div', 'APX-toast-container APX-toast-container-native');\r\n                    nativeContainer.setAttribute('data-apx-toast-position', positionKey);\r\n                    nativeContainer.style.position = 'absolute';\r\n                    nativeContainer.style.zIndex = String(this.config.zIndex);\r\n                    nativeContainer.style.gap = `${this.config.gap}px`;\r\n                    nativeContainer.setAttribute('aria-live', String(this.config.ariaLive));\r\n                    nativeContainer.style.flexDirection = finalFlow === 'up' ? 'column-reverse' : 'column';\r\n                    \r\n                    // Apply positioning to container\r\n                    if (type === 'relative') {\r\n                        // Relative: use x/y directly\r\n                        if (position.x !== undefined) {\r\n                            if (position.x.startsWith('-')) {\r\n                                nativeContainer.style.right = position.x.substring(1);\r\n                            } else {\r\n                                nativeContainer.style.left = position.x;\r\n                            }\r\n                        }\r\n                        if (position.y !== undefined) {\r\n                            if (position.y.startsWith('-')) {\r\n                                nativeContainer.style.bottom = position.y.substring(1);\r\n                            } else {\r\n                                nativeContainer.style.top = position.y;\r\n                            }\r\n                        }\r\n                    } else if (type === 'anchored') {\r\n                        // Anchored: position outside the element using 100% (element size) + gap\r\n                        const placement = normalizePlacement(position.placement);\r\n                        const gap = position.gap || '1em';\r\n                        \r\n                        switch (placement) {\r\n                            case 'top':\r\n                                nativeContainer.style.bottom = `calc(100% + ${gap})`;\r\n                                nativeContainer.style.left = '0';\r\n                                break;\r\n                            case 'bottom':\r\n                                nativeContainer.style.top = `calc(100% + ${gap})`;\r\n                                nativeContainer.style.left = '0';\r\n                                break;\r\n                            case 'left':\r\n                                nativeContainer.style.right = `calc(100% + ${gap})`;\r\n                                nativeContainer.style.top = '0';\r\n                                break;\r\n                            case 'right':\r\n                                nativeContainer.style.left = `calc(100% + ${gap})`;\r\n                                nativeContainer.style.top = '0';\r\n                                break;\r\n                        }\r\n                    }\r\n                    \r\n                    targetEl.appendChild(nativeContainer);\r\n                } else {\r\n                    // Update flow direction if container exists\r\n                    nativeContainer.style.flexDirection = finalFlow === 'up' ? 'column-reverse' : 'column';\r\n                }\r\n                \r\n                container = nativeContainer;\r\n                \r\n                positionCleanup = () => {\r\n                    if (targetEl && targetEl.parentElement) {\r\n                        targetEl.style.position = originalElementStyle || '';\r\n                        // Remove native container if empty\r\n                        if (nativeContainer && nativeContainer.children.length === 0) {\r\n                            const positionKey = nativeContainer.getAttribute('data-apx-toast-position');\r\n                            if (positionKey) {\r\n                                _containerCache.delete(positionKey);\r\n                            }\r\n                            nativeContainer.remove();\r\n                        }\r\n                    }\r\n                };\r\n            } else {\r\n                // Default: get or create container for this position\r\n                container = this.getContainerForPosition(position, finalFlow);\r\n                \r\n                const updateContainerPosition = () => {\r\n                    const styles = this.calculatePosition(position, container);\r\n                    Object.assign(container.style, styles);\r\n                };\r\n                \r\n                updateContainerPosition();\r\n                \r\n                // For relative/anchored, listen to scroll/resize\r\n                if ((type === 'relative' || type === 'anchored') && position.element) {\r\n                    let rafId = null;\r\n                    let lastUpdate = 0;\r\n                    const throttleMs = 16; // ~60fps\r\n                    \r\n                    const throttledUpdate = () => {\r\n                        const now = Date.now();\r\n                        if (now - lastUpdate < throttleMs) {\r\n                            if (rafId) cancelAnimationFrame(rafId);\r\n                            rafId = requestAnimationFrame(() => {\r\n                                updateContainerPosition();\r\n                                lastUpdate = Date.now();\r\n                            });\r\n                        } else {\r\n                            updateContainerPosition();\r\n                            lastUpdate = now;\r\n                        }\r\n                    };\r\n                    \r\n                    // Find all scrollable parents\r\n                    const scrollableParents = findScrollableParents(position.element);\r\n                    \r\n                    // Listen to scroll on window and all scrollable parents\r\n                    window.addEventListener('scroll', throttledUpdate, { passive: true });\r\n                    window.addEventListener('resize', throttledUpdate, { passive: true });\r\n                    \r\n                    // Listen to scroll on all scrollable parent elements\r\n                    scrollableParents.forEach(parent => {\r\n                        parent.addEventListener('scroll', throttledUpdate, { passive: true });\r\n                    });\r\n                    \r\n                    // Watch for element removal\r\n                    const observer = new MutationObserver(() => {\r\n                        if (!position.element.parentElement) {\r\n                            ref.close('api');\r\n                        }\r\n                    });\r\n                    observer.observe(document.body, { childList: true, subtree: true });\r\n                    \r\n                    positionUpdateFn = updateContainerPosition;\r\n                    positionCleanup = () => {\r\n                        window.removeEventListener('scroll', throttledUpdate);\r\n                        window.removeEventListener('resize', throttledUpdate);\r\n                        scrollableParents.forEach(parent => {\r\n                            parent.removeEventListener('scroll', throttledUpdate);\r\n                        });\r\n                        observer.disconnect();\r\n                        if (rafId) cancelAnimationFrame(rafId);\r\n                    };\r\n                }\r\n            }\r\n        } else {\r\n            // String position - get or create container for this position\r\n            container = this.getContainerForPosition(position, finalFlow);\r\n        }\r\n        \r\n        // Append toast to the appropriate container\r\n        if (container) {\r\n            container.appendChild(toastEl);\r\n        } else {\r\n            // Fallback to default container\r\n            this.container.appendChild(toastEl);\r\n        }\r\n\r\n        // Enter animation\r\n        toastEl.classList.add('APX-toast--enter');\r\n        requestAnimationFrame(() => {\r\n            toastEl.classList.add('APX-toast--enter-active');\r\n        });\r\n\r\n        // Event handling and timers\r\n        let remaining = options.durationMs;\r\n        let timerId = null;\r\n        let startTs = null;\r\n        const handlers = { click: new Set(), close: new Set() };\r\n\r\n        const startTimer = () => {\r\n            if (!remaining || remaining <= 0) return; // sticky\r\n            startTs = Date.now();\r\n            timerId = window.setTimeout(() => ref.close('timeout'), remaining);\r\n        };\r\n        const pauseTimer = () => {\r\n            if (timerId != null) {\r\n                window.clearTimeout(timerId);\r\n                timerId = null;\r\n                if (startTs != null) remaining -= (Date.now() - startTs);\r\n            }\r\n        };\r\n\r\n        /** @type {ToastRef} */\r\n        const ref = {\r\n            id: toastId,\r\n            el: toastEl,\r\n            close: (reason) => {\r\n                cleanup(reason || 'api');\r\n            },\r\n            update: (partial) => {\r\n                const merged = this.normalizeOptions({ ...options, ...partial });\r\n                // update content\r\n                if (typeof merged.message === 'string') {\r\n                    contentEl.textContent = merged.message;\r\n                } else if (merged.message) {\r\n                    contentEl.innerHTML = '';\r\n                    contentEl.appendChild(merged.message);\r\n                }\r\n                // update type class\r\n                ['info','success','warning','danger'].forEach(t => toastEl.classList.remove(`APX-toast--${t}`));\r\n                toastEl.classList.add(`APX-toast--${merged.type}`);\r\n                // update classes\r\n                if (options.className !== merged.className) {\r\n                    if (options.className) toastEl.classList.remove(...options.className.split(' ').filter(Boolean));\r\n                    if (merged.className) toastEl.classList.add(...merged.className.split(' ').filter(Boolean));\r\n                }\r\n                // update duration logic\r\n                options.durationMs = merged.durationMs;\r\n                remaining = merged.durationMs;\r\n                pauseTimer();\r\n                startTimer();\r\n            },\r\n            whenClosed: () => closedPromise,\r\n            on: (event, handler) => { handlers[event].add(handler); return () => ref.off(event, handler); },\r\n            off: (event, handler) => { handlers[event].delete(handler); }\r\n        };\r\n\r\n        const notify = (event, arg) => handlers[event].forEach(fn => { try { fn(arg); } catch (_) {} });\r\n\r\n        const closedPromise = new Promise(resolve => {\r\n            const finish = (reason) => {\r\n                notify('close', reason);\r\n                if (typeof options.onClose === 'function') {\r\n                    try { options.onClose(ref, reason); } catch(_){}\r\n                }\r\n                resolve();\r\n            };\r\n\r\n            const cleanup = (reason) => {\r\n                if (!toastEl) return;\r\n                pauseTimer();\r\n                \r\n                // Cleanup position listeners and restore styles\r\n                if (positionCleanup) {\r\n                    positionCleanup();\r\n                    positionCleanup = null;\r\n                }\r\n                \r\n                // If overflow, remove immediately to enforce hard cap\r\n                if (reason === 'overflow') {\r\n                    if (toastEl.parentElement) toastEl.parentElement.removeChild(toastEl);\r\n                    const idx = this.open.indexOf(ref);\r\n                    if (idx >= 0) this.open.splice(idx, 1);\r\n                    this.idToRef.delete(toastId);\r\n                    finish(reason);\r\n                    return;\r\n                }\r\n\r\n                // Otherwise, animate out\r\n                toastEl.classList.add('APX-toast--exit');\r\n                requestAnimationFrame(() => toastEl.classList.add('APX-toast--exit-active'));\r\n\r\n                const removeEl = () => {\r\n                    toastEl.removeEventListener('transitionend', removeEl);\r\n                    if (toastEl.parentElement) toastEl.parentElement.removeChild(toastEl);\r\n                    const idx = this.open.indexOf(ref);\r\n                    if (idx >= 0) this.open.splice(idx, 1);\r\n                    this.idToRef.delete(toastId);\r\n                    \r\n                    // Schedule garbage collection for unmanaged containers\r\n                    scheduleGarbageCollection();\r\n                    \r\n                    finish(reason);\r\n                };\r\n                toastEl.addEventListener('transitionend', removeEl);\r\n            };\r\n\r\n            // attach close behavior\r\n            ref.close = (reason) => cleanup(reason || 'api');\r\n        });\r\n\r\n        // Click handling\r\n        toastEl.addEventListener('click', (ev) => {\r\n            notify('click', ev);\r\n            if (typeof options.onClick === 'function') {\r\n                try { options.onClick(ref, ev); } catch(_){}\r\n            }\r\n        });\r\n\r\n        // Hover pause\r\n        toastEl.addEventListener('mouseenter', pauseTimer);\r\n        toastEl.addEventListener('mouseleave', () => startTimer());\r\n\r\n        if (closeBtn) closeBtn.addEventListener('click', (ev) => { ev.stopPropagation(); ref.close('close'); });\r\n\r\n        // Track\r\n        this.open.push(ref);\r\n        this.idToRef.set(toastId, ref);\r\n\r\n        // Overflow policy\r\n        if (this.open.length > this.config.maxToasts) {\r\n            const oldest = this.open[0];\r\n            oldest.close('overflow');\r\n        }\r\n\r\n        startTimer();\r\n        return ref;\r\n    }\r\n\r\n    /**\r\n     * Convenience helpers\r\n     */\r\n    info(message, opts) { return this.show({ ...(opts||{}), message, type: 'info' }); }\r\n    success(message, opts) { return this.show({ ...(opts||{}), message, type: 'success' }); }\r\n    warning(message, opts) { return this.show({ ...(opts||{}), message, type: 'warning' }); }\r\n    danger(message, opts) { return this.show({ ...(opts||{}), message, type: 'danger' }); }\r\n\r\n    /** @param {'api'|'overflow'} [reason] */\r\n    closeAll(reason) {\r\n        // copy to avoid mutation during iteration\r\n        const all = this.open.slice();\r\n        all.forEach(r => r.close(reason || 'api'));\r\n    }\r\n\r\n    /** @param {ToastOptions} opts */\r\n    normalizeOptions(opts) {\r\n        const o = { ...opts };\r\n        if (!o.type) o.type = 'info';\r\n        if (typeof o.dismissible !== 'boolean') o.dismissible = true;\r\n        if (typeof o.durationMs !== 'number') o.durationMs = this.config.defaultDurationMs;\r\n        // Use id from options if provided, otherwise use id from config, otherwise undefined (will be auto-generated)\r\n        if (!o.id && this.config.id) o.id = this.config.id;\r\n        return o;\r\n    }\r\n\r\n    /**\r\n     * Find or create a container for a specific position\r\n     * @param {Position} position\r\n     * @param {'up'|'down'} [flow] Flow direction (already determined, not 'auto')\r\n     * @param {boolean} [managed] Whether this container is managed by a manager (default: false)\r\n     * @returns {HTMLElement|null}\r\n     */\r\n    getContainerForPosition(position, flow, managed = false) {\r\n        if (!isBrowser) return null;\r\n        \r\n        const positionKey = serializePosition(position);\r\n        \r\n        // Flow should already be determined ('up' or 'down'), but fallback to auto if needed\r\n        const finalFlow = flow && flow !== 'auto' ? flow : determineFlow(position);\r\n        \r\n        // 1. Check memory cache\r\n        let c = _containerCache.get(positionKey);\r\n        \r\n        // 2. If not in cache, search in DOM by data attribute\r\n        if (!c && isBrowser) {\r\n            c = document.querySelector(`[data-apx-toast-position=\"${positionKey}\"]`);\r\n            if (c) {\r\n                _containerCache.set(positionKey, c);\r\n            }\r\n        }\r\n        \r\n        // 3. If still not found, create new container\r\n        if (!c) {\r\n            c = createEl('div', 'APX-toast-container');\r\n            c.setAttribute('data-apx-toast-position', positionKey);\r\n            \r\n            // Mark as managed if created by a manager\r\n            if (managed) {\r\n                c.setAttribute('data-apx-toast-managed', 'true');\r\n            }\r\n            \r\n            // Determine position class (for CSS)\r\n            const posClass = typeof position === 'string' \r\n                ? position \r\n                : (position.type || 'bottom-right');\r\n            c.classList.add(`APX-toast-container--${posClass}`);\r\n            c.setAttribute('aria-live', String(this.config.ariaLive));\r\n            c.style.zIndex = String(this.config.zIndex);\r\n            c.style.gap = `${this.config.gap}px`;\r\n            \r\n            // Apply flow direction\r\n            c.style.flexDirection = finalFlow === 'up' ? 'column-reverse' : 'column';\r\n            \r\n            // Apply position styles if object position\r\n            if (typeof position === 'object' && position !== null) {\r\n                c.style.position = 'fixed';\r\n                const styles = this.calculatePosition(position, c);\r\n                Object.assign(c.style, styles);\r\n            }\r\n            \r\n            // Append to wrapper for clean DOM organization\r\n            const wrapper = getToastWrapper();\r\n            if (wrapper) {\r\n                wrapper.appendChild(c);\r\n            } else {\r\n                document.body.appendChild(c);\r\n            }\r\n            _containerCache.set(positionKey, c);\r\n        } else {\r\n            // Update flow direction if container exists (may be shared)\r\n            c.style.flexDirection = finalFlow === 'up' ? 'column-reverse' : 'column';\r\n            \r\n            // If container exists and is now managed, mark it\r\n            if (managed && !c.hasAttribute('data-apx-toast-managed')) {\r\n                c.setAttribute('data-apx-toast-managed', 'true');\r\n            }\r\n        }\r\n        \r\n        return c;\r\n    }\r\n\r\n    ensureContainer() {\r\n        if (this.container || !isBrowser) return;\r\n        \r\n        const position = this.config.position || 'bottom-right';\r\n        const flow = this.config.flow !== undefined ? this.config.flow : 'auto';\r\n        // Containers created by ensureContainer are managed\r\n        this.container = this.getContainerForPosition(position, flow, true);\r\n        this.applyContainerConfig();\r\n    }\r\n\r\n    applyContainerConfig() {\r\n        if (!this.container) return;\r\n        const position = this.config.position || 'bottom-right';\r\n        const pos = typeof position === 'string' ? position : (position.type || 'bottom-right');\r\n        \r\n        // Apply styles (these may be overridden by other managers sharing the container)\r\n        this.container.style.zIndex = String(this.config.zIndex);\r\n        this.container.style.gap = `${this.config.gap}px`;\r\n        this.container.setAttribute('aria-live', String(this.config.ariaLive));\r\n        \r\n        // Update position class (only for string positions)\r\n        if (typeof position === 'string') {\r\n            const posClasses = ['bottom-right','bottom-left','top-right','top-left'].map(p => `APX-toast-container--${p}`);\r\n            this.container.classList.remove(...posClasses);\r\n            this.container.classList.add(`APX-toast-container--${pos}`);\r\n        }\r\n        \r\n        // Apply container class if specified\r\n        if (this.config.containerClass) {\r\n            this.config.containerClass.split(' ').filter(Boolean).forEach(cls => {\r\n                this.container.classList.add(cls);\r\n            });\r\n        }\r\n        \r\n        // Apply offset (only for string positions)\r\n        if (typeof position === 'string') {\r\n            if (this.config.offset) {\r\n                const offset = `${this.config.offset}px`;\r\n                if (pos.includes('bottom')) this.container.style.bottom = offset;\r\n                else this.container.style.top = offset;\r\n                if (pos.includes('right')) this.container.style.right = offset;\r\n                else this.container.style.left = offset;\r\n            } else {\r\n                // Reset offset if not specified\r\n                if (pos.includes('bottom')) this.container.style.bottom = '';\r\n                else this.container.style.top = '';\r\n                if (pos.includes('right')) this.container.style.right = '';\r\n                else this.container.style.left = '';\r\n            }\r\n        } else if (typeof position === 'object' && position !== null) {\r\n            // For object positions, ensure container has position: fixed\r\n            this.container.style.position = 'fixed';\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Calculate position for a container based on position config\r\n     * @param {Position} position\r\n     * @param {HTMLElement} containerEl\r\n     * @returns {{left?: string, top?: string, right?: string, bottom?: string}}\r\n     */\r\n    calculatePosition(position, containerEl) {\r\n        if (typeof position === 'string') {\r\n            // String positions are handled by container CSS\r\n            return {};\r\n        }\r\n        \r\n        if (typeof position === 'object' && position !== null) {\r\n            const type = position.type || (position.x || position.y ? 'sticky' : null);\r\n            \r\n            if (type === 'sticky' || (!type && (position.x || position.y))) {\r\n                // Sticky: fixed position relative to viewport\r\n                const styles = {};\r\n                if (position.x !== undefined) {\r\n                    if (position.x.startsWith('-')) {\r\n                        styles.right = position.x.substring(1);\r\n                    } else {\r\n                        styles.left = position.x;\r\n                    }\r\n                }\r\n                if (position.y !== undefined) {\r\n                    if (position.y.startsWith('-')) {\r\n                        styles.bottom = position.y.substring(1);\r\n                    } else {\r\n                        styles.top = position.y;\r\n                    }\r\n                }\r\n                return styles;\r\n            }\r\n            \r\n            if (type === 'relative' && position.element) {\r\n                // Relative: position relative to element with x/y offset\r\n                // Use fixed positioning, so getBoundingClientRect() is relative to viewport\r\n                const rect = position.element.getBoundingClientRect();\r\n                \r\n                // Parse x/y offsets (can be px, em, etc.)\r\n                const parseOffset = (val) => {\r\n                    if (!val) return 0;\r\n                    const num = parseFloat(val);\r\n                    if (val.includes('em')) {\r\n                        // Convert em to px (approximate: 1em = 16px)\r\n                        return num * 16;\r\n                    }\r\n                    return num;\r\n                };\r\n                \r\n                const offsetX = parseOffset(position.x || '0');\r\n                const offsetY = parseOffset(position.y || '0');\r\n                \r\n                const styles = {\r\n                    left: `${rect.left + offsetX}px`,\r\n                    top: `${rect.top + offsetY}px`\r\n                };\r\n                return styles;\r\n            }\r\n            \r\n            if (type === 'anchored' && position.element) {\r\n                // Anchored: position relative to element with placement\r\n                const rect = position.element.getBoundingClientRect();\r\n                const gap = position.gap || '1em';\r\n                \r\n                // Parse gap (can be px, em, etc.)\r\n                const parseGap = (val) => {\r\n                    const num = parseFloat(val);\r\n                    if (val.includes('em')) {\r\n                        return num * 16; // Approximate: 1em = 16px\r\n                    }\r\n                    return num;\r\n                };\r\n                \r\n                const gapPx = parseGap(gap);\r\n                const styles = {};\r\n                \r\n                // Normalize placement synonyms (above/below/before/after) to CSS values\r\n                const placement = normalizePlacement(position.placement);\r\n                \r\n                switch (placement) {\r\n                    case 'top':\r\n                        // Toast above element: bottom of toast = top of element - gap\r\n                        // bottom = viewport height - (element top - gap) = viewport height - element top + gap\r\n                        styles.bottom = `${window.innerHeight - rect.top + gapPx}px`;\r\n                        styles.left = `${rect.left}px`;\r\n                        break;\r\n                    case 'bottom':\r\n                        // Toast below element: top of toast = bottom of element + gap\r\n                        styles.top = `${rect.bottom + gapPx}px`;\r\n                        styles.left = `${rect.left}px`;\r\n                        break;\r\n                    case 'left':\r\n                        // Toast to the left: right of toast = left of element - gap\r\n                        styles.right = `${window.innerWidth - rect.left + gapPx}px`;\r\n                        styles.top = `${rect.top}px`;\r\n                        break;\r\n                    case 'right':\r\n                        // Toast to the right: left of toast = right of element + gap\r\n                        styles.left = `${rect.right + gapPx}px`;\r\n                        styles.top = `${rect.top}px`;\r\n                        break;\r\n                }\r\n                return styles;\r\n            }\r\n        }\r\n        \r\n        return {};\r\n    }\r\n}\r\n\r\n/**\r\n * @param {Partial<ToastConfig>=} config\r\n * @returns {ToastManager}\r\n */\r\nfunction createToastManager(config) {\r\n    return new ToastManager(config);\r\n}\r\n\r\n// High-level APX.toast API (default & named managers)\r\nlet _defaultManager = null;\r\nconst _getDefault = () => {\r\n    if (!_defaultManager) _defaultManager = createToastManager();\r\n    return _defaultManager;\r\n};\r\n\r\n/**\r\n * Toast API surface to be attached as APX.toast.\r\n * Callable form proxies to defaultManager.show(opts): APX.toast({...})\r\n */\r\nfunction toast(opts) {\r\n    return _getDefault().show(opts);\r\n}\r\n\r\nObject.assign(toast, {\r\n    /**\r\n     * Create a manager. If first arg is string, register as named under toast.custom[name]\r\n     * @param {string|Partial<ToastConfig>} nameOrConfig\r\n     * @param {Partial<ToastConfig>=} maybeConfig\r\n     * @returns {ToastManager}\r\n     */\r\n    create: (nameOrConfig, maybeConfig) => {\r\n        if (typeof nameOrConfig === 'string') {\r\n            const name = nameOrConfig;\r\n            const manager = new ToastManager({ ...(maybeConfig || {}) });\r\n            if (!toast.custom) toast.custom = {};\r\n            toast.custom[name] = manager;\r\n            return manager;\r\n        }\r\n        return new ToastManager({ ...(nameOrConfig || {}) });\r\n    },\r\n    /** @type {Record<string, ToastManager>} */\r\n    custom: {},\r\n    /** @param {string} name */\r\n    use: (name) => (toast.custom && toast.custom[name]) || null,\r\n    Manager: ToastManager,\r\n    show: (opts) => _getDefault().show(opts),\r\n    info: (message, opts) => _getDefault().info(message, opts),\r\n    success: (message, opts) => _getDefault().success(message, opts),\r\n    warning: (message, opts) => _getDefault().warning(message, opts),\r\n    danger: (message, opts) => _getDefault().danger(message, opts),\r\n    configure: (config) => _getDefault().configure(config),\r\n    setAriaLive: (mode) => _getDefault().setAriaLive(mode),\r\n    closeAll: (reason) => _getDefault().closeAll(reason),\r\n    getOpenToasts: () => _getDefault().getOpenToasts()\r\n});\r\n\r\nexport default toast;\r\nexport { ToastManager, createToastManager, toast };\r\n","// Import des fonctions et modules des sous-modules\r\nimport augmentWithPack from './form-packer/augment-apx.mjs';\r\nimport { packFormToJSON } from './form-packer/packToJson.mjs';\r\n\r\n// Export de la fonction d'augmentation\r\nexport { augmentWithPack };\r\n\r\n// Export des fonctions utilitaires\r\nexport { packFormToJSON };\r\n\r\n// Export d'un objet tools pour faciliter l'utilisation\r\nexport const tools = {\r\n    packFormToJSON: packFormToJSON\r\n};\r\n\r\n\r\n","import { packFormToJSON } from './packToJson.mjs';\r\n\r\n/**\r\n * Ajoute la méthode pack() aux objets APX pour convertir les formulaires en JSON\r\n * @param {Object} apx - L'objet APX à augmenter\r\n * @returns {Object} L'objet APX augmenté\r\n */\r\nexport default function (apx) {\r\n    /**\r\n     * Convertit le premier formulaire sélectionné en objet JSON\r\n     * @returns {Object} L'objet JSON résultant\r\n     * @throws {Error} Si aucun formulaire n'est trouvé ou si le premier élément n'est pas un formulaire\r\n     * @example\r\n     * const data = APX('form.myformclass').pack();\r\n     */\r\n    apx.pack = function () {\r\n        const firstElement = this.first();\r\n        if (!firstElement) {\r\n            throw new Error('No element found');\r\n        }\r\n        if (firstElement.tagName !== 'FORM') {\r\n            throw new Error('Element is not a form');\r\n        }\r\n        return packFormToJSON(firstElement);\r\n    };\r\n    \r\n    return apx;\r\n}\r\n\r\n\r\n","/**\r\n * Convertit un formulaire HTML en objet JSON\r\n * @param {HTMLFormElement} form - Le formulaire à convertir\r\n * @returns {Object} L'objet JSON résultant\r\n * @throws {TypeError} Si form n'est pas un HTMLFormElement\r\n */\r\nexport const packFormToJSON = (form) => {\r\n    // Validation de l'entrée\r\n    if (!form || !(form instanceof HTMLFormElement)) {\r\n        throw new TypeError('packFormToJSON expects an HTMLFormElement');\r\n    }\r\n\r\n    const formData = new FormData(form);\r\n    const jsonData = {};\r\n    \r\n    /**\r\n     * Construit une représentation string du chemin pour les messages d'erreur\r\n     * @param {Array} parts - Les parties du chemin\r\n     * @returns {string} Le chemin formaté\r\n     */\r\n    const buildPathString = (parts) => {\r\n        return parts.reduce((path, part) => {\r\n            if (part.type === 'key') {\r\n                return path ? `${path}[${part.name}]` : part.name;\r\n            }\r\n            if (part.type === 'numeric') {\r\n                return `${path}[${part.index}]`;\r\n            }\r\n            if (part.type === 'array') {\r\n                return `${path}[]`;\r\n            }\r\n            return path;\r\n        }, '');\r\n    };\r\n    \r\n    // ============================================================================\r\n    // PHASE 1 : ANALYSE ET DÉTECTION DES CONFLITS\r\n    // ============================================================================\r\n    \r\n    /**\r\n     * Structure pour stocker l'utilisation d'un chemin\r\n     * @typedef {Object} PathUsage\r\n     * @property {boolean} isFinal - Le chemin est utilisé comme valeur finale\r\n     * @property {boolean} isIntermediate - Le chemin est utilisé comme chemin intermédiaire\r\n     * @property {boolean} hasArraySuffix - Le chemin se termine par [] (crée des valeurs primitives)\r\n     * @property {string} key - La clé du formulaire qui utilise ce chemin\r\n     */\r\n    \r\n    const pathUsage = new Map(); // Map<pathString, PathUsage>\r\n    const keyAnalysis = new Map(); // Map<basePath, {hasNumeric: boolean, hasString: boolean}>\r\n    const allEntries = [];\r\n    \r\n    /**\r\n     * Enregistre l'utilisation d'un chemin dans pathUsage\r\n     * @param {string} currentPath - Le chemin à enregistrer\r\n     * @param {boolean} isFinal - Si c'est une valeur finale\r\n     * @param {boolean} isArraySuffix - Si le chemin se termine par []\r\n     * @param {string} key - La clé du formulaire\r\n     */\r\n    const recordPathUsage = (currentPath, isFinal, isArraySuffix, key) => {\r\n        const usage = pathUsage.get(currentPath) ?? {\r\n            isFinal: false,\r\n            isIntermediate: false,\r\n            hasArraySuffix: false,\r\n            key\r\n        };\r\n        \r\n        if (!pathUsage.has(currentPath)) {\r\n            pathUsage.set(currentPath, usage);\r\n        }\r\n        \r\n        if (isFinal) {\r\n            usage.isFinal = true;\r\n            usage.key = key;\r\n            if (isArraySuffix) {\r\n                usage.hasArraySuffix = true;\r\n            }\r\n        } else {\r\n            usage.isIntermediate = true;\r\n            usage.key ??= key;\r\n        }\r\n    };\r\n    \r\n    // Première passe : analyser toutes les clés et enregistrer les chemins\r\n    for (const [key, value] of formData.entries()) {\r\n        if (!key) continue;\r\n        \r\n        allEntries.push({ key, value });\r\n        const parts = parseKey(key);\r\n        \r\n        // Construire tous les chemins intermédiaires et le chemin final\r\n        let currentPath = '';\r\n        \r\n        for (let i = 0; i < parts.length; i++) {\r\n            const part = parts[i];\r\n            const isLast = i === parts.length - 1;\r\n            const isArraySuffix = part.type === 'array';\r\n            \r\n            // Construire le chemin jusqu'à ce niveau\r\n            if (part.type === 'key') {\r\n                currentPath = currentPath ? `${currentPath}[${part.name}]` : part.name;\r\n            } else if (part.type === 'numeric') {\r\n                currentPath = `${currentPath}[${part.index}]`;\r\n            } else if (part.type === 'array') {\r\n                currentPath = `${currentPath}[]`;\r\n            }\r\n            \r\n            // Enregistrer l'utilisation du chemin\r\n            recordPathUsage(currentPath, isLast, isArraySuffix && isLast, key);\r\n        }\r\n        \r\n        // Analyser chaque niveau de la hiérarchie pour détecter les conflits (indices numériques vs clés de chaîne)\r\n        for (let i = 0; i < parts.length - 1; i++) {\r\n            const part = parts[i];\r\n            const nextPart = parts[i + 1];\r\n            \r\n            // Analyser seulement les clés (pas les indices numériques)\r\n            if (part.type === 'key') {\r\n                const basePath = part.name; // Le nom de la première clé dans le chemin\r\n                \r\n                const analysis = keyAnalysis.get(basePath) ?? { hasNumeric: false, hasString: false };\r\n                if (!keyAnalysis.has(basePath)) {\r\n                    keyAnalysis.set(basePath, analysis);\r\n                }\r\n                \r\n                if (nextPart) {\r\n                    if (nextPart.type === 'numeric') {\r\n                        analysis.hasNumeric = true;\r\n                    } else if (nextPart.type === 'key' || nextPart.type === 'array') {\r\n                        analysis.hasString = true;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    \r\n    /**\r\n     * Détecte et lève une exception pour tous les conflits de chemins\r\n     * \r\n     * Principe simple : pour chaque chemin final (valeur primitive), vérifier si un chemin\r\n     * intermédiaire commence par ce chemin suivi de '['. Si c'est le cas, c'est un conflit.\r\n     * \r\n     * Cette approche unifiée couvre tous les cas :\r\n     * - items[] (final) vs items[0][name] (intermédiaire)\r\n     * - array[3] (final) vs array[3][nested] (intermédiaire)\r\n     * - data[key] (final) vs data[key][sub] (intermédiaire)\r\n     */\r\n    const detectPathConflicts = () => {\r\n        // 1. Collecter tous les chemins finaux (valeurs primitives)\r\n        const finalPaths = new Set();\r\n        const finalPathKeys = new Map(); // Pour les messages d'erreur\r\n        \r\n        for (const [path, usage] of pathUsage.entries()) {\r\n            if (usage.isFinal) {\r\n                finalPaths.add(path);\r\n                finalPathKeys.set(path, usage.key);\r\n            }\r\n        }\r\n        \r\n        // 2. Pour chaque chemin intermédiaire, vérifier s'il commence par un chemin final\r\n        for (const [path, usage] of pathUsage.entries()) {\r\n            if (usage.isIntermediate) {\r\n                for (const finalPath of finalPaths) {\r\n                    // Vérifier si ce chemin intermédiaire commence par un chemin final suivi de '['\r\n                    // Exemple: finalPath = \"array[3]\", path = \"array[3][nested]\" → conflit\r\n                    if (path.startsWith(`${finalPath}[`)) {\r\n                        throw new Error(\r\n                            `Path conflict: \"${finalPath}\" is used as a final value (in field \"${finalPathKeys.get(finalPath)}\"), ` +\r\n                            `but \"${path}\" tries to use it as an intermediate path (in field \"${usage.key}\"). ` +\r\n                            `This creates incompatible data structures. ` +\r\n                            `You cannot use \"${finalPath}\" as a primitive value and then access it as an object.`\r\n                        );\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    };\r\n    \r\n    // Exécuter la détection des conflits\r\n    detectPathConflicts();\r\n\r\n    /**\r\n     * Vérifie si un chemin de base a un conflit (indices numériques ET clés de chaîne)\r\n     * @param {string} basePath - Le chemin de base à vérifier\r\n     * @returns {boolean}\r\n     */\r\n    const hasConflict = (basePath) => {\r\n        if (!basePath) return false;\r\n        const analysis = keyAnalysis.get(basePath);\r\n        return analysis?.hasNumeric && analysis?.hasString;\r\n    };\r\n\r\n    /**\r\n     * Convertit un tableau en objet en préservant les indices numériques comme propriétés\r\n     * @param {Array} arr - Le tableau à convertir\r\n     * @returns {Object} L'objet résultant\r\n     */\r\n    const arrayToObject = (arr) => {\r\n        const obj = {};\r\n        // Copier les indices numériques\r\n        for (let idx = 0; idx < arr.length; idx++) {\r\n            obj[idx] = arr[idx];\r\n        }\r\n        // Copier les propriétés non-numériques\r\n        for (const [k, v] of Object.entries(arr)) {\r\n            const numKey = Number.parseInt(k, 10);\r\n            if (Number.isNaN(numKey) || k !== String(numKey)) {\r\n                obj[k] = v;\r\n            }\r\n        }\r\n        return obj;\r\n    };\r\n\r\n    /**\r\n     * Convertit un objet en tableau en préservant les indices numériques\r\n     * @param {Object} obj - L'objet à convertir\r\n     * @returns {Array} Le tableau résultant\r\n     */\r\n    const objectToArray = (obj) => {\r\n        if (Array.isArray(obj)) return obj;\r\n        const arr = [];\r\n        if (typeof obj === 'object' && obj !== null) {\r\n            for (const [k, v] of Object.entries(obj)) {\r\n                const numKey = Number.parseInt(k, 10);\r\n                if (!Number.isNaN(numKey)) {\r\n                    arr[numKey] = v;\r\n                }\r\n            }\r\n        }\r\n        return arr;\r\n    };\r\n\r\n    /**\r\n     * Assure qu'un conteneur est un objet, en convertissant si nécessaire\r\n     * @param {*} container - Le conteneur à vérifier\r\n     * @param {string|null} key - La clé dans le conteneur parent\r\n     * @param {Object|null} parent - Le conteneur parent\r\n     * @param {boolean} forceObject - Forcer la conversion en objet même s'il n'y a pas de conflit\r\n     * @returns {Object} Le conteneur (converti en objet si nécessaire)\r\n     */\r\n    const ensureObject = (container, key, parent, forceObject = false) => {\r\n        if (Array.isArray(container)) {\r\n            const obj = arrayToObject(container);\r\n            if (parent && key !== null) {\r\n                parent[key] = obj;\r\n            }\r\n            return obj;\r\n        }\r\n        if (typeof container !== 'object' || container === null) {\r\n            const obj = {};\r\n            if (parent && key !== null) {\r\n                parent[key] = obj;\r\n            }\r\n            return obj;\r\n        }\r\n        return container;\r\n    };\r\n\r\n    /**\r\n     * Assure qu'un conteneur est un tableau, en convertissant si nécessaire\r\n     * @param {*} container - Le conteneur à vérifier\r\n     * @param {string|null} key - La clé dans le conteneur parent\r\n     * @param {Object|null} parent - Le conteneur parent\r\n     * @returns {Array} Le conteneur (converti en tableau si nécessaire)\r\n     */\r\n    const ensureArray = (container, key, parent) => {\r\n        if (!Array.isArray(container)) {\r\n            const arr = objectToArray(container);\r\n            if (parent && key !== null) {\r\n                parent[key] = arr;\r\n            }\r\n            return arr;\r\n        }\r\n        return container;\r\n    };\r\n\r\n    // ============================================================================\r\n    // PHASE 2 : TRAITEMENT DES VALEURS\r\n    // ============================================================================\r\n    \r\n    /**\r\n     * Traite une valeur finale (dernière partie du chemin)\r\n     * @param {*} container - Le conteneur actuel\r\n     * @param {Object} part - La partie à traiter\r\n     * @param {*} value - La valeur à assigner\r\n     * @param {Object} parent - Le conteneur parent\r\n     * @param {string} basePath - Le chemin de base pour la détection de conflit\r\n     */\r\n    const processFinalValue = (container, part, value, parent, basePath) => {\r\n        if (part.type === 'array') {\r\n            // Tableau explicite avec []\r\n            container[part.name] ??= [];\r\n            if (Array.isArray(container[part.name])) {\r\n                container[part.name].push(value);\r\n            } else {\r\n                container[part.name] = [container[part.name], value];\r\n            }\r\n        } else if (part.type === 'numeric') {\r\n            // Indice numérique final\r\n            const { index } = part;\r\n            container = ensureArray(container, parent.key, parent.container);\r\n            while (container.length <= index) {\r\n                container.push(undefined);\r\n            }\r\n            container[index] = value;\r\n        } else {\r\n            // Clé simple finale\r\n            const conflict = hasConflict(basePath);\r\n            \r\n            if (conflict) {\r\n                container = ensureObject(container, parent.key, parent.container, true);\r\n                if (Array.isArray(container[part.name])) {\r\n                    container[part.name] = arrayToObject(container[part.name]);\r\n                }\r\n                if (container[part.name] !== undefined && \r\n                    (typeof container[part.name] !== 'object' || container[part.name] === null)) {\r\n                    container[part.name] = value;\r\n                } else if (container[part.name] === undefined) {\r\n                    container[part.name] = value;\r\n                } else if (Array.isArray(container[part.name])) {\r\n                    container[part.name].push(value);\r\n                } else {\r\n                    container[part.name] = [container[part.name], value];\r\n                }\r\n            } else {\r\n                if (container[part.name] === undefined) {\r\n                    container[part.name] = value;\r\n                } else if (Array.isArray(container[part.name])) {\r\n                    container[part.name].push(value);\r\n                } else {\r\n                    container[part.name] = [container[part.name], value];\r\n                }\r\n            }\r\n        }\r\n    };\r\n    \r\n    /**\r\n     * Traite une partie intermédiaire (crée la structure)\r\n     * @param {*} container - Le conteneur actuel\r\n     * @param {Object} part - La partie à traiter\r\n     * @param {Object|null} nextPart - La partie suivante (peut être null)\r\n     * @param {Object} parent - Le conteneur parent\r\n     * @param {string} basePath - Le chemin de base pour la détection de conflit\r\n     * @param {Array} parts - Toutes les parties du chemin (pour construire le chemin complet dans les erreurs)\r\n     * @param {number} i - L'index de la partie actuelle (pour construire le chemin complet dans les erreurs)\r\n     * @param {string} key - La clé du formulaire (pour les messages d'erreur)\r\n     * @returns {*} Le nouveau conteneur après traitement\r\n     */\r\n    const processIntermediatePart = (container, part, nextPart, parent, basePath, parts, i, key) => {\r\n        if (part.type === 'numeric') {\r\n            // Indice numérique : le container doit être un tableau ou un objet (selon conflit)\r\n            const { index } = part;\r\n            const conflict = hasConflict(basePath);\r\n            \r\n            if (conflict) {\r\n                // Conflit : utiliser un objet (les indices seront des propriétés)\r\n                container = ensureObject(container, parent.key, parent.container, true);\r\n                container[index] ??= {};\r\n                if (typeof container[index] !== 'object' || container[index] === null) {\r\n                    // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement\r\n                    const pathParts = parts.slice(0, i + 1);\r\n                    const currentPath = buildPathString(pathParts);\r\n                    throw new Error(\r\n                        `Cannot access property on primitive value. ` +\r\n                        `Key \"${key}\" tries to access \"${currentPath}\" but it is already a ${typeof container[index]} value: ${JSON.stringify(container[index])}. ` +\r\n                        `This should have been detected during conflict detection phase.`\r\n                    );\r\n                }\r\n            } else {\r\n                // Pas de conflit : utiliser un tableau\r\n                container = ensureArray(container, parent.key, parent.container);\r\n                while (container.length <= index) {\r\n                    container.push(undefined);\r\n                }\r\n                container[index] ??= {};\r\n                if (typeof container[index] !== 'object' || container[index] === null) {\r\n                    // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement\r\n                    const pathParts = parts.slice(0, i + 1);\r\n                    const currentPath = buildPathString(pathParts);\r\n                    throw new Error(\r\n                        `Cannot access property on primitive value. ` +\r\n                        `Key \"${key}\" tries to access \"${currentPath}\" but it is already a ${typeof container[index]} value: ${JSON.stringify(container[index])}. ` +\r\n                        `This should have been detected during conflict detection phase.`\r\n                    );\r\n                }\r\n            }\r\n            return container[index];\r\n        }\r\n        \r\n        // Clé normale : créer objet ou tableau selon la partie suivante\r\n        const nextIsNumeric = nextPart?.type === 'numeric';\r\n        const conflict = hasConflict(basePath);\r\n        \r\n        if (conflict) {\r\n            // Conflit : toujours utiliser un objet\r\n            container = ensureObject(container, parent.key, parent.container, true);\r\n            container[part.name] ??= {};\r\n            if (Array.isArray(container[part.name])) {\r\n                container[part.name] = arrayToObject(container[part.name]);\r\n            } else if (typeof container[part.name] !== 'object' || container[part.name] === null) {\r\n                // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement\r\n                const pathParts = parts.slice(0, i + 1);\r\n                const currentPath = buildPathString(pathParts);\r\n                throw new Error(\r\n                    `Cannot access property on primitive value. ` +\r\n                    `Key \"${key}\" tries to access \"${currentPath}\" but it is already a ${typeof container[part.name]} value: ${JSON.stringify(container[part.name])}. ` +\r\n                    `This should have been detected during conflict detection phase.`\r\n                );\r\n            }\r\n        } else if (container[part.name] === undefined) {\r\n            // Pas de conflit, créer selon la partie suivante\r\n            container[part.name] = nextIsNumeric ? [] : {};\r\n        } else if (nextIsNumeric && !Array.isArray(container[part.name])) {\r\n            // On a besoin d'un tableau mais c'est un objet\r\n            const hasStringKeys = Object.keys(container[part.name]).some(k => {\r\n                const numKey = Number.parseInt(k, 10);\r\n                return Number.isNaN(numKey) || k !== String(numKey);\r\n            });\r\n            if (!hasStringKeys) {\r\n                container[part.name] = objectToArray(container[part.name]);\r\n            }\r\n        } else if (!nextIsNumeric && !isPlainObject(container[part.name])) {\r\n            // On a besoin d'un objet mais c'est un tableau\r\n            if (Array.isArray(container[part.name])) {\r\n                container[part.name] = arrayToObject(container[part.name]);\r\n            } else {\r\n                container[part.name] = {};\r\n            }\r\n        }\r\n        \r\n        // S'assurer que container[part.name] est bien un objet après toutes les conversions\r\n        if (container[part.name] !== undefined && \r\n            (typeof container[part.name] !== 'object' || container[part.name] === null)) {\r\n            // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement\r\n            const pathParts = parts.slice(0, i + 1);\r\n            const currentPath = buildPathString(pathParts);\r\n            throw new Error(\r\n                `Cannot access property on primitive value. ` +\r\n                `Key \"${key}\" tries to access \"${currentPath}\" but it is already a ${typeof container[part.name]} value: ${JSON.stringify(container[part.name])}. ` +\r\n                `This should have been detected during conflict detection phase.`\r\n            );\r\n        }\r\n        return container[part.name];\r\n    };\r\n    \r\n    // Traiter toutes les entrées\r\n    for (const { value, key } of allEntries) {\r\n        if (!key) continue;\r\n\r\n        const parts = parseKey(key);\r\n        const path = [{ container: jsonData, key: null }];\r\n        let container = jsonData;\r\n        const basePath = parts[0]?.type === 'key' ? parts[0].name : '';\r\n\r\n        for (let i = 0; i < parts.length; i++) {\r\n            const part = parts[i];\r\n            const isLast = i === parts.length - 1;\r\n            const nextPart = i + 1 < parts.length ? parts[i + 1] : null;\r\n            const parent = path[path.length - 1];\r\n\r\n            if (isLast) {\r\n                // Dernière partie : assigner la valeur\r\n                processFinalValue(container, part, value, parent, basePath);\r\n            } else {\r\n                // Partie intermédiaire : créer la structure\r\n                const newContainer = processIntermediatePart(container, part, nextPart, parent, basePath, parts, i, key);\r\n                path.push({ container, key: part.type === 'numeric' ? part.index : part.name });\r\n                container = newContainer;\r\n            }\r\n        }\r\n    }\r\n\r\n    return jsonData;\r\n};\r\n\r\n/**\r\n * Parse une clé de formulaire pour extraire les parties (nom, indices, etc.)\r\n * @param {string} key - La clé à parser (ex: \"user[email]\", \"tags[]\", \"items[0][name]\")\r\n * @returns {Array<{name: string, type: string, index?: number}>} Tableau des parties parsées\r\n * @private\r\n */\r\nconst parseKey = (key) => {\r\n    const parts = [];\r\n    let current = '';\r\n    let i = 0;\r\n    const len = key.length;\r\n\r\n    while (i < len) {\r\n        const char = key[i];\r\n        \r\n        if (char === '[') {\r\n            // Sauvegarder la partie précédente si elle existe\r\n            if (current) {\r\n                parts.push({ name: current, type: 'key' });\r\n                current = '';\r\n            }\r\n            \r\n            // Trouver la fin du crochet\r\n            i++;\r\n            let bracketContent = '';\r\n            while (i < len && key[i] !== ']') {\r\n                bracketContent += key[i];\r\n                i++;\r\n            }\r\n            \r\n            if (bracketContent === '') {\r\n                // [] vide = tableau\r\n                const lastPart = parts[parts.length - 1];\r\n                if (lastPart) {\r\n                    lastPart.type = 'array';\r\n                } else {\r\n                    // [] au début, créer une partie spéciale\r\n                    parts.push({ name: '', type: 'array' });\r\n                }\r\n            } else {\r\n                // Contenu dans les crochets\r\n                const numIndex = Number.parseInt(bracketContent, 10);\r\n                if (!Number.isNaN(numIndex) && bracketContent === String(numIndex)) {\r\n                    // Indice numérique\r\n                    parts.push({ name: String(numIndex), type: 'numeric', index: numIndex });\r\n                } else {\r\n                    // Nom de propriété\r\n                    parts.push({ name: bracketContent, type: 'key' });\r\n                }\r\n            }\r\n            i++; // Passer le ']'\r\n        } else {\r\n            current += char;\r\n            i++;\r\n        }\r\n    }\r\n    \r\n    // Ajouter la dernière partie si elle existe\r\n    if (current) {\r\n        parts.push({ name: current, type: 'key' });\r\n    }\r\n    \r\n    return parts;\r\n};\r\n\r\n/**\r\n * Vérifie si une valeur est un objet simple (pas un tableau, pas null)\r\n * @param {*} obj - La valeur à vérifier\r\n * @returns {boolean}\r\n * @private\r\n */\r\nconst isPlainObject = (obj) => {\r\n    return typeof obj === 'object' && obj !== null && !Array.isArray(obj);\r\n};\r\n","import './css/tristate.css';\r\n\r\n/**\r\n * Creates a tri-state checkbox for each checkbox element in the apx.elements array.\r\n * @param {Array<HTMLElement>} apx - An array of HTMLElements which is returned by APX()\r\n * @example\r\n * // Call the tristate function on an array of checkbox elements\r\n * apx.tristate();\r\n */\r\nexport default function (apx) {\r\n    apx.tristate = function (options = {}){\r\n        apx.elements.forEach((element) => {\r\n            if (element.type === 'checkbox') {\r\n                const [originalCheckbox, tristateDom, hiddenInput] = createTriStateCheckbox(element,options);\r\n                //If there is a \"options.callbacks.after\" callback in options call it\r\n                if(options.callbacks && options.callbacks.after && typeof options.callbacks.after === 'function') {\r\n                    options.callbacks.after(originalCheckbox, tristateDom, hiddenInput);\r\n                }               \r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nfunction toggleTriStateCheckboxState(customCheckbox, actualCheckbox, hiddenInput) {\r\n    if (customCheckbox.classList.contains('checked')) {\r\n        customCheckbox.classList.remove('checked');\r\n        customCheckbox.classList.add('crossed');\r\n        actualCheckbox.checked = false;\r\n        hiddenInput.value = 'false';\r\n    } else if (customCheckbox.classList.contains('crossed')) {\r\n        customCheckbox.classList.remove('crossed');\r\n        customCheckbox.classList.add('unchecked');\r\n        hiddenInput.removeAttribute('name'); // Ensure the hidden input doesn't post any value\r\n        hiddenInput.removeAttribute('value'); // Ensure the hidden input doesn't post any value\r\n    } else {\r\n        customCheckbox.classList.remove('unchecked');\r\n        customCheckbox.classList.add('checked');\r\n        actualCheckbox.checked = true;\r\n        hiddenInput.value = 'true';\r\n        hiddenInput.setAttribute('name', actualCheckbox.dataset.name); // Restore the name for posting\r\n    }\r\n}\r\n\r\nfunction createTriStateCheckbox(checkboxElement, options) {\r\n    \r\n    //get the checkbox margins including browser default\r\n    const checkboxStyle = window.getComputedStyle(checkboxElement);\r\n    // Hide the original checkbox\r\n    checkboxElement.style.display = 'none';\r\n\r\n    // Create the custom checkbox div and set its initial state\r\n    const tristateDom = document.createElement('div');\r\n    tristateDom.classList.add('apx-tristate');\r\n    if (options.size) {\r\n        if (options.size.width) {\r\n            tristateDom.style.width = options.size.width + 'px';\r\n        }\r\n        if (options.size.height) {\r\n            tristateDom.style.height = options.size.height + 'px';\r\n        }\r\n    }\r\n    if(options.classes) tristateDom.classList.add(...computeClasses(options.classes));\r\n\r\n    tristateDom.style.margin = checkboxStyle.margin;\r\n\r\n    if (checkboxElement.checked) {\r\n        tristateDom.classList.add('checked');\r\n    } else {\r\n        tristateDom.classList.add('unchecked');\r\n    }\r\n\r\n    // Create the hidden input field\r\n    const hiddenInput = document.createElement('input');\r\n    hiddenInput.type = 'hidden';\r\n    hiddenInput.name = checkboxElement.name; // Copy the name from the original checkbox\r\n    checkboxElement.dataset.name = checkboxElement.name; // Store the name in a data attribute for later use\r\n    checkboxElement.removeAttribute('name'); // Remove the name from the original checkbox to avoid double posting\r\n\r\n    if (options.defaultState) setDefaultState(options, tristateDom, hiddenInput);\r\n    else{\r\n        // Set the initial value for the hidden input based on the checkbox's state\r\n        if (checkboxElement.checked) {\r\n            hiddenInput.value = 'true';\r\n        } else {\r\n            hiddenInput.name = ''; // Ensure the hidden input doesn't post any value\r\n            hiddenInput.value = '';\r\n        }\r\n    }\r\n\r\n    //handle accessibility, set the tabindex to the same as the checkbox\r\n    tristateDom.tabIndex = checkboxElement.tabIndex;\r\n\r\n    // Insert the hidden input inside the custom checkbox div\r\n    tristateDom.appendChild(hiddenInput);\r\n\r\n    // Insert it next to the actual checkbox\r\n    checkboxElement.parentNode.insertBefore(tristateDom, checkboxElement.nextSibling);\r\n\r\n    // Add event listener\r\n    tristateDom.addEventListener('click', function (e) {\r\n        toggleTriStateCheckboxState(tristateDom, checkboxElement, hiddenInput);\r\n        bubbleEventsToOriginalCheckbox(options, checkboxElement, tristateDom, hiddenInput, e);\r\n    });\r\n    tristateDom.addEventListener('keyup', onkeyup.bind(null, checkboxElement));\r\n\r\n    return [checkboxElement, tristateDom, hiddenInput];\r\n}\r\n\r\nfunction setDefaultState(options, tristateDom, hiddenInput) {\r\n    //for all values possible for defaultState, set the initial state of the checkbox\r\n    if (options.defaultState === 'checked') {\r\n        tristateDom.classList.remove('unchecked');\r\n        tristateDom.classList.add('checked');\r\n        hiddenInput.value = 'true';\r\n    }\r\n    else if (options.defaultState === 'unchecked') {\r\n        tristateDom.classList.remove('checked');\r\n        tristateDom.classList.add('unchecked');\r\n        hiddenInput.removeAttribute('name'); // Ensure the hidden input doesn't post any value\r\n        hiddenInput.removeAttribute('value'); // Ensure the hidden input doesn't post any value\r\n    }\r\n    else if (options.defaultState === 'crossed') {\r\n        tristateDom.classList.remove('checked');\r\n        tristateDom.classList.add('crossed');\r\n        hiddenInput.value = 'false';\r\n    }\r\n}\r\n\r\nfunction computeClasses(classes) {\r\n    let computedClasses = [];\r\n    if(typeof classes === 'string') {\r\n        //replace multiple white spaces with a single space\r\n        classes = classes.replace(/\\s\\s+/g, ' ');\r\n        if(classes.indexOf(' ') > -1)\r\n            computedClasses = classes.split(' ');\r\n        else if(classes.indexOf(',') > -1)\r\n            computedClasses = classes.split(',');\r\n        else\r\n            computedClasses = [classes];\r\n    }\r\n    else if(Array.isArray(classes)) {\r\n        computedClasses = classes;\r\n    }\r\n    return computedClasses;\r\n}\r\n\r\nfunction bubbleEventsToOriginalCheckbox(options, checkboxElement, tristateDom, hiddenInput, event) {\r\n    //if options.callbacks.change is set, call it\r\n    if(options.callbacks && options.callbacks.change && typeof options.callbacks.change === 'function') {\r\n        options.callbacks.change(checkboxElement, tristateDom, hiddenInput);\r\n    }\r\n\r\n    if(!options.bubbleEvents) return;\r\n\r\n    if(event.type === 'click') {\r\n        checkboxElement.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));\r\n    }\r\n    else if(event.type === 'keyup') {\r\n        checkboxElement.dispatchEvent(new KeyboardEvent('keyup', { key: ' ', bubbles: true, cancelable: true }));\r\n    }\r\n    else if(event.type === 'change') {\r\n        checkboxElement.dispatchEvent(new Event('change', { bubbles: true, cancelable: true }));\r\n    }\r\n}\r\n\r\nfunction onkeyup(checkboxElement, event) {\r\n    if (event.keyCode === 32) {\r\n        bubbleEventsToOriginalCheckbox(checkboxElement, event);\r\n        event.preventDefault();\r\n        event.target.click();\r\n    }\r\n}","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.b = document.baseURI || self.location.href;\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t\"main\": 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// no jsonp function","__webpack_require__.nc = undefined;","import augmentWithListen from './modules/listen/listen.mjs';\nimport augmentWithTristate from './modules/tristate/tristate.mjs';\nimport dialog from './modules/dialog/dialog.mjs';\nimport toast from './modules/toast/toast.mjs';\nimport { loadCss } from './modules/common.mjs';\nimport { augmentWithPack, tools } from './modules/tools/exports.mjs';\n\n/**\n * Creates an APX object that wraps one or more HTML elements.\n * @param {string|HTMLElement|NodeList|HTMLCollection|Array<HTMLElement>|jQuery|Function} input - The input to create the APX object from.\n * @returns {Object} The APX object.\n * @throws {Error} If the input type is invalid.\n * @example\n * // XPath\n * const apx1 = APX('//div[@class=\"example\"]');\n *\n * // CSS selector\n * const apx2 = APX('.example');\n *\n * // Single element\n * const element = document.querySelector('.example');\n * const apx3 = APX(element);\n *\n * // NodeList or HTMLCollection\n * const nodeList = document.querySelectorAll('.example');\n * const apx4 = APX(nodeList);\n *\n * // Array of elements\n * const elements = [document.querySelector('.example1'), document.querySelector('.example2')];\n * const apx5 = APX(elements);\n *\n * // jQuery object\n * const $example = $('.example');\n * const apx6 = APX($example);\n *\n * // Function returning an APX object\n * const apx7 = APX(() => APX('.example'));\n */\nconst APX = function (input, context = document) {\n    let elements;\n\n    // Validate context\n    if (typeof context === 'string') {\n        context = document.querySelector(context);\n    }\n    else if (APX.isAPXObject(context)) {\n        context = context.first();\n    } else if (!(context instanceof HTMLElement || context instanceof Document)) {\n        throw new Error('Invalid context for APX');\n    }\n\n    if (typeof input === 'string' && input.startsWith('//')) {\n        // XPath with context\n        elements = document.evaluate(input, context, null, XPathResult.ANY_TYPE, null);\n        let nodes = [];\n        let node = elements.iterateNext();\n        while (node) {\n            nodes.push(node);\n            node = elements.iterateNext();\n        }\n        elements = nodes;\n    } else if (typeof input === 'string') {\n        // CSS selector with context\n        elements = context.querySelectorAll(input);\n    } else if (input instanceof HTMLElement) {\n        // Single element within context\n        elements = context.contains(input) ? [input] : [];\n    } else if (input instanceof NodeList || input instanceof HTMLCollection) {\n        // NodeList or HTMLCollection within context\n        elements = Array.from(input).filter(el => context.contains(el));\n    } else if (Array.isArray(input) && input.every(el => el instanceof HTMLElement)) {\n        // Array of elements within context\n        elements = input.filter(el => context.contains(el));\n    } else if (typeof jQuery != 'undefined' && input instanceof jQuery) {\n        // jQuery object within context\n        elements = Array.from(input.get()).filter(el => context.contains(el));\n    } else if (typeof input === 'function') {\n        // Function returning an APX object with context\n        elements = APX(input(), context);\n    } else {\n        throw new Error('Invalid input type for APX');\n    }\n\n    var apx = {\n        elements: elements,\n        _isAPXObject: true\n    };\n    apx.length = elements.length;\n    apx.each = function (callback) {\n        if (this.elements instanceof Array) this.elements.forEach(callback);\n        if (this.elements instanceof NodeList) Array.from(this.elements).forEach(callback);\n        return this;\n    };\n    apx.get = function (index) {\n        return this.elements[index];\n    };\n    apx.all = function () {\n        if (this.elements instanceof Array) return this.elements;\n        if (this.elements instanceof NodeList) return Array.from(this.elements);\n        return this;\n    };\n    apx.first = function () {\n        return this.get(0);\n    };\n    augmentWithListen(apx);\n    augmentWithTristate(apx);\n    augmentWithPack(apx);\n    return apx;\n};\n\nAPX.loadCss = loadCss;\nAPX.dialog = dialog;\nAPX.toast = toast;\nAPX.tools = tools;\nAPX.isAPXObject = function (obj) {\n    return obj && obj._isAPXObject === true;\n}\nAPX.is_numeric = (n) => {\n    return !isNaN(n - parseFloat(n));\n}\n\nexport default APX;"],"names":[],"sourceRoot":""}