@ionic/core 8.8.19-dev.11787007863.1976a30e → 8.8.19-dev.11787083540.1511caf2

package/dist/esm/ion-accordion_2.entry.js

@@ -1,10 +1,11 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { r as registerInstance, g as getElement, e as config, h, d as Host, c as createEvent, f as printIonWarning } from './index-ChhhtsGZ.js';
-import { f as addEventListener, m as removeEventListener, r as raf, g as getElementRoot, t as transitionEndAsync } from './helpers-DexiPLIC.js';
-import { b as chevronDown } from './index-BvabGprD.js';
-import { b as getIonMode } from './ionic-global-BVB7BrLT.js';
+import { r as registerInstance, e as config, h, d as Host, g as getElement, c as createEvent, f as printIonWarning } from './index-tcQvqkiX.js';
+import { g as getElementRoot, r as raf, f as addEventListener, m as removeEventListener, t as transitionEndAsync } from './helpers-DkCLSLI9.js';
+import { l as chevronDown } from './index-DV3sJJW8.js';
+import { b as getIonMode } from './ionic-global-Cp_eT4sZ.js';
+import './dir-o8OKV5aD.js';
 
 const accordionIosCss = () => `:host{display:block;position:relative;width:100%;background-color:var(--ion-background-color, #ffffff);overflow:hidden;z-index:0}:host(.accordion-expanding) ::slotted(ion-item[slot=header]),:host(.accordion-expanded) ::slotted(ion-item[slot=header]){--border-width:0px}:host(.accordion-animated){-webkit-transition:all 300ms cubic-bezier(0.25, 0.8, 0.5, 1);transition:all 300ms cubic-bezier(0.25, 0.8, 0.5, 1)}:host(.accordion-animated) #content{-webkit-transition:max-height 300ms cubic-bezier(0.25, 0.8, 0.5, 1);transition:max-height 300ms cubic-bezier(0.25, 0.8, 0.5, 1)}#content{overflow:hidden;will-change:max-height}:host(.accordion-collapsing) #content{max-height:0 !important}:host(.accordion-collapsed) #content{display:none}:host(.accordion-expanding) #content{max-height:0}:host(.accordion-expanding) #content-wrapper{overflow:auto}:host(.accordion-disabled) #header,:host(.accordion-readonly) #header,:host(.accordion-disabled) #content,:host(.accordion-readonly) #content{pointer-events:none}:host(.accordion-disabled) #header,:host(.accordion-disabled) #content{opacity:0.4}@media (prefers-reduced-motion: reduce){:host,#content{-webkit-transition:none !important;transition:none !important}}:host(.accordion-next) ::slotted(ion-item[slot=header]){--border-width:0.55px 0px 0.55px 0px}`;
 
@@ -13,94 +14,329 @@ const accordionMdCss = () => `:host{display:block;position:relative;width:100%;b
 const Accordion = class {
     constructor(hostRef) {
         registerInstance(this, hostRef);
-    }
-    accordionGroupEl;
-    accordionGroupUpdateHandler = () => {
+        this.accordionGroupUpdateHandler = () => {
+            /**
+             * Determine if this update will cause an actual state change.
+             * We only want to mark as "interacted" if the state is changing.
+             */
+            const accordionGroup = this.accordionGroupEl;
+            if (accordionGroup) {
+                const value = accordionGroup.value;
+                const accordionValue = this.value;
+                const shouldExpand = Array.isArray(value) ? value.includes(accordionValue) : value === accordionValue;
+                const isExpanded = this.state === 4 /* AccordionState.Expanded */ || this.state === 8 /* AccordionState.Expanding */;
+                const stateWillChange = shouldExpand !== isExpanded;
+                /**
+                 * Only mark as interacted if:
+                 * 1. This is not the first update we've received with a defined value
+                 * 2. The state is actually changing (prevents redundant updates from enabling animations)
+                 */
+                if (this.hasReceivedFirstUpdate && stateWillChange) {
+                    this.hasInteracted = true;
+                }
+                /**
+                 * Only count this as the first update if the group value is defined.
+                 * This prevents the initial undefined value from the group's componentDidLoad
+                 * from being treated as the first real update.
+                 */
+                if (value !== undefined) {
+                    this.hasReceivedFirstUpdate = true;
+                }
+            }
+            this.updateState();
+        };
+        this.state = 1 /* AccordionState.Collapsed */;
+        this.isNext = false;
+        this.isPrevious = false;
         /**
-         * Determine if this update will cause an actual state change.
-         * We only want to mark as "interacted" if the state is changing.
+         * Tracks whether a user-initiated interaction has occurred.
+         * Animations are disabled until the first interaction happens.
+         * This prevents the accordion from animating when it's programmatically
+         * set to an expanded or collapsed state on initial load.
          */
-        const accordionGroup = this.accordionGroupEl;
-        if (accordionGroup) {
-            const value = accordionGroup.value;
-            const accordionValue = this.value;
-            const shouldExpand = Array.isArray(value) ? value.includes(accordionValue) : value === accordionValue;
-            const isExpanded = this.state === 4 /* AccordionState.Expanded */ || this.state === 8 /* AccordionState.Expanding */;
-            const stateWillChange = shouldExpand !== isExpanded;
+        this.hasInteracted = false;
+        /**
+         * Tracks if this accordion has ever been expanded.
+         * Used to prevent the first expansion from animating.
+         */
+        this.hasEverBeenExpanded = false;
+        /**
+         * Tracks if this accordion has received its first update from the group.
+         * Used to distinguish initial programmatic sets from user interactions.
+         */
+        this.hasReceivedFirstUpdate = false;
+        /**
+         * The value of the accordion. Defaults to an autogenerated
+         * value.
+         */
+        this.value = `ion-accordion-${accordionIds++}`;
+        /**
+         * If `true`, the accordion cannot be interacted with.
+         */
+        this.disabled = false;
+        /**
+         * If `true`, the accordion cannot be interacted with,
+         * but does not alter the opacity.
+         */
+        this.readonly = false;
+        /**
+         * The toggle icon to use. This icon will be
+         * rotated when the accordion is expanded
+         * or collapsed.
+         */
+        this.toggleIcon = chevronDown;
+        /**
+         * The slot inside of `ion-item` to
+         * place the toggle icon. Defaults to `"end"`.
+         */
+        this.toggleIconSlot = 'end';
+        this.setItemDefaults = () => {
+            const ionItem = this.getSlottedHeaderIonItem();
+            if (!ionItem) {
+                return;
+            }
+            /**
+             * For a11y purposes, we make
+             * the ion-item a button so users
+             * can tab to it and use keyboard
+             * navigation to get around.
+             */
+            ionItem.button = true;
+            ionItem.detail = false;
             /**
-             * Only mark as interacted if:
-             * 1. This is not the first update we've received with a defined value
-             * 2. The state is actually changing (prevents redundant updates from enabling animations)
+             * By default, the lines in an
+             * item should be full here, but
+             * only do that if a user has
+             * not explicitly overridden them
              */
-            if (this.hasReceivedFirstUpdate && stateWillChange) {
-                this.hasInteracted = true;
+            if (ionItem.lines === undefined) {
+                ionItem.lines = 'full';
+            }
+        };
+        this.getSlottedHeaderIonItem = () => {
+            const { headerEl } = this;
+            if (!headerEl) {
+                return;
             }
             /**
-             * Only count this as the first update if the group value is defined.
-             * This prevents the initial undefined value from the group's componentDidLoad
-             * from being treated as the first real update.
+             * Get the first ion-item
+             * slotted in the header slot
              */
-            if (value !== undefined) {
-                this.hasReceivedFirstUpdate = true;
+            const slot = headerEl.querySelector('slot');
+            if (!slot) {
+                return;
             }
-        }
-        this.updateState();
-    };
-    contentEl;
-    contentElWrapper;
-    headerEl;
-    currentRaf;
-    get el() { return getElement(this); }
-    state = 1 /* AccordionState.Collapsed */;
-    isNext = false;
-    isPrevious = false;
-    /**
-     * Tracks whether a user-initiated interaction has occurred.
-     * Animations are disabled until the first interaction happens.
-     * This prevents the accordion from animating when it's programmatically
-     * set to an expanded or collapsed state on initial load.
-     */
-    hasInteracted = false;
-    /**
-     * Tracks if this accordion has ever been expanded.
-     * Used to prevent the first expansion from animating.
-     */
-    hasEverBeenExpanded = false;
-    /**
-     * Tracks if this accordion has received its first update from the group.
-     * Used to distinguish initial programmatic sets from user interactions.
-     */
-    hasReceivedFirstUpdate = false;
-    /**
-     * The value of the accordion. Defaults to an autogenerated
-     * value.
-     */
-    value = `ion-accordion-${accordionIds++}`;
+            // This is not defined in unit tests
+            if (slot.assignedElements === undefined)
+                return;
+            return slot.assignedElements().find((el) => el.tagName === 'ION-ITEM');
+        };
+        this.setAria = (expanded = false) => {
+            const ionItem = this.getSlottedHeaderIonItem();
+            if (!ionItem) {
+                return;
+            }
+            /**
+             * Get the native <button> element inside of
+             * ion-item because that is what will be focused
+             */
+            const root = getElementRoot(ionItem);
+            const button = root.querySelector('button');
+            if (!button) {
+                return;
+            }
+            button.setAttribute('aria-expanded', `${expanded}`);
+        };
+        this.slotToggleIcon = () => {
+            const ionItem = this.getSlottedHeaderIonItem();
+            if (!ionItem) {
+                return;
+            }
+            const { toggleIconSlot, toggleIcon } = this;
+            /**
+             * Check if there already is a toggle icon.
+             * If so, do not add another one.
+             */
+            const existingToggleIcon = ionItem.querySelector('.ion-accordion-toggle-icon');
+            if (existingToggleIcon) {
+                return;
+            }
+            const iconEl = document.createElement('ion-icon');
+            iconEl.slot = toggleIconSlot;
+            iconEl.lazy = false;
+            iconEl.classList.add('ion-accordion-toggle-icon');
+            iconEl.icon = toggleIcon;
+            iconEl.setAttribute('aria-hidden', 'true');
+            ionItem.appendChild(iconEl);
+        };
+        this.expandAccordion = () => {
+            const { contentEl, contentElWrapper } = this;
+            /**
+             * If the content elements aren't available yet, just set the state.
+             * This happens on initial render before the DOM is ready.
+             */
+            if (contentEl === undefined || contentElWrapper === undefined) {
+                this.state = 4 /* AccordionState.Expanded */;
+                this.hasEverBeenExpanded = true;
+                return;
+            }
+            if (this.state === 4 /* AccordionState.Expanded */) {
+                return;
+            }
+            if (this.currentRaf !== undefined) {
+                cancelAnimationFrame(this.currentRaf);
+            }
+            /**
+             * Mark that this accordion has been expanded at least once.
+             * This allows subsequent expansions to animate.
+             */
+            this.hasEverBeenExpanded = true;
+            if (this.shouldAnimate()) {
+                raf(() => {
+                    this.state = 8 /* AccordionState.Expanding */;
+                    this.currentRaf = raf(async () => {
+                        const contentHeight = contentElWrapper.offsetHeight;
+                        const waitForTransition = transitionEndAsync(contentEl, 2000);
+                        contentEl.style.setProperty('max-height', `${contentHeight}px`);
+                        await waitForTransition;
+                        this.state = 4 /* AccordionState.Expanded */;
+                        contentEl.style.removeProperty('max-height');
+                    });
+                });
+            }
+            else {
+                this.state = 4 /* AccordionState.Expanded */;
+            }
+        };
+        this.collapseAccordion = () => {
+            const { contentEl } = this;
+            /**
+             * If the content element isn't available yet, just set the state.
+             * This happens on initial render before the DOM is ready.
+             */
+            if (contentEl === undefined) {
+                this.state = 1 /* AccordionState.Collapsed */;
+                return;
+            }
+            if (this.state === 1 /* AccordionState.Collapsed */) {
+                return;
+            }
+            if (this.currentRaf !== undefined) {
+                cancelAnimationFrame(this.currentRaf);
+            }
+            if (this.shouldAnimate()) {
+                this.currentRaf = raf(async () => {
+                    const contentHeight = contentEl.offsetHeight;
+                    contentEl.style.setProperty('max-height', `${contentHeight}px`);
+                    raf(async () => {
+                        const waitForTransition = transitionEndAsync(contentEl, 2000);
+                        this.state = 2 /* AccordionState.Collapsing */;
+                        await waitForTransition;
+                        this.state = 1 /* AccordionState.Collapsed */;
+                        contentEl.style.removeProperty('max-height');
+                    });
+                });
+            }
+            else {
+                this.state = 1 /* AccordionState.Collapsed */;
+            }
+        };
+        /**
+         * Helper function to determine if
+         * something should animate.
+         * If prefers-reduced-motion is set
+         * then we should not animate, regardless
+         * of what is set in the config.
+         */
+        this.shouldAnimate = () => {
+            /**
+             * Don't animate until after the first user interaction.
+             * This prevents animations on initial load when accordions
+             * start in an expanded or collapsed state programmatically.
+             *
+             * Additionally, don't animate the very first expansion even if
+             * hasInteracted is true. This handles edge cases like React StrictMode
+             * where effects run twice and might incorrectly mark as interacted.
+             */
+            if (!this.hasInteracted || !this.hasEverBeenExpanded) {
+                return false;
+            }
+            if (typeof window === 'undefined') {
+                return false;
+            }
+            const prefersReducedMotion = matchMedia('(prefers-reduced-motion: reduce)').matches;
+            if (prefersReducedMotion) {
+                return false;
+            }
+            const animated = config.get('animated', true);
+            if (!animated) {
+                return false;
+            }
+            if (this.accordionGroupEl && !this.accordionGroupEl.animated) {
+                return false;
+            }
+            return true;
+        };
+        this.updateState = async () => {
+            const accordionGroup = this.accordionGroupEl;
+            const accordionValue = this.value;
+            if (!accordionGroup) {
+                return;
+            }
+            const value = accordionGroup.value;
+            const shouldExpand = Array.isArray(value) ? value.includes(accordionValue) : value === accordionValue;
+            if (shouldExpand) {
+                this.expandAccordion();
+                this.isNext = this.isPrevious = false;
+            }
+            else {
+                this.collapseAccordion();
+                /**
+                 * When using popout or inset,
+                 * the collapsed accordion items
+                 * may need additional border radius
+                 * applied. Check to see if the
+                 * next or previous accordion is selected.
+                 */
+                const nextAccordion = this.getNextSibling();
+                const nextAccordionValue = nextAccordion === null || nextAccordion === void 0 ? void 0 : nextAccordion.value;
+                if (nextAccordionValue !== undefined) {
+                    this.isPrevious = Array.isArray(value) ? value.includes(nextAccordionValue) : value === nextAccordionValue;
+                }
+                const previousAccordion = this.getPreviousSibling();
+                const previousAccordionValue = previousAccordion === null || previousAccordion === void 0 ? void 0 : previousAccordion.value;
+                if (previousAccordionValue !== undefined) {
+                    this.isNext = Array.isArray(value) ? value.includes(previousAccordionValue) : value === previousAccordionValue;
+                }
+            }
+        };
+        this.getNextSibling = () => {
+            if (!this.el) {
+                return;
+            }
+            const nextSibling = this.el.nextElementSibling;
+            if ((nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.tagName) !== 'ION-ACCORDION') {
+                return;
+            }
+            return nextSibling;
+        };
+        this.getPreviousSibling = () => {
+            if (!this.el) {
+                return;
+            }
+            const previousSibling = this.el.previousElementSibling;
+            if ((previousSibling === null || previousSibling === void 0 ? void 0 : previousSibling.tagName) !== 'ION-ACCORDION') {
+                return;
+            }
+            return previousSibling;
+        };
+    }
     valueChanged() {
         this.updateState();
     }
-    /**
-     * If `true`, the accordion cannot be interacted with.
-     */
-    disabled = false;
-    /**
-     * If `true`, the accordion cannot be interacted with,
-     * but does not alter the opacity.
-     */
-    readonly = false;
-    /**
-     * The toggle icon to use. This icon will be
-     * rotated when the accordion is expanded
-     * or collapsed.
-     */
-    toggleIcon = chevronDown;
-    /**
-     * The slot inside of `ion-item` to
-     * place the toggle icon. Defaults to `"end"`.
-     */
-    toggleIconSlot = 'end';
     connectedCallback() {
-        const accordionGroupEl = (this.accordionGroupEl = this.el?.closest('ion-accordion-group'));
+        var _a;
+        const accordionGroupEl = (this.accordionGroupEl = (_a = this.el) === null || _a === void 0 ? void 0 : _a.closest('ion-accordion-group'));
         if (accordionGroupEl) {
             this.updateState();
             addEventListener(accordionGroupEl, 'ionValueChange', this.accordionGroupUpdateHandler);
@@ -129,246 +365,6 @@ const Accordion = class {
             this.setAria(expanded);
         });
     }
-    setItemDefaults = () => {
-        const ionItem = this.getSlottedHeaderIonItem();
-        if (!ionItem) {
-            return;
-        }
-        /**
-         * For a11y purposes, we make
-         * the ion-item a button so users
-         * can tab to it and use keyboard
-         * navigation to get around.
-         */
-        ionItem.button = true;
-        ionItem.detail = false;
-        /**
-         * By default, the lines in an
-         * item should be full here, but
-         * only do that if a user has
-         * not explicitly overridden them
-         */
-        if (ionItem.lines === undefined) {
-            ionItem.lines = 'full';
-        }
-    };
-    getSlottedHeaderIonItem = () => {
-        const { headerEl } = this;
-        if (!headerEl) {
-            return;
-        }
-        /**
-         * Get the first ion-item
-         * slotted in the header slot
-         */
-        const slot = headerEl.querySelector('slot');
-        if (!slot) {
-            return;
-        }
-        // This is not defined in unit tests
-        if (slot.assignedElements === undefined)
-            return;
-        return slot.assignedElements().find((el) => el.tagName === 'ION-ITEM');
-    };
-    setAria = (expanded = false) => {
-        const ionItem = this.getSlottedHeaderIonItem();
-        if (!ionItem) {
-            return;
-        }
-        /**
-         * Get the native <button> element inside of
-         * ion-item because that is what will be focused
-         */
-        const root = getElementRoot(ionItem);
-        const button = root.querySelector('button');
-        if (!button) {
-            return;
-        }
-        button.setAttribute('aria-expanded', `${expanded}`);
-    };
-    slotToggleIcon = () => {
-        const ionItem = this.getSlottedHeaderIonItem();
-        if (!ionItem) {
-            return;
-        }
-        const { toggleIconSlot, toggleIcon } = this;
-        /**
-         * Check if there already is a toggle icon.
-         * If so, do not add another one.
-         */
-        const existingToggleIcon = ionItem.querySelector('.ion-accordion-toggle-icon');
-        if (existingToggleIcon) {
-            return;
-        }
-        const iconEl = document.createElement('ion-icon');
-        iconEl.slot = toggleIconSlot;
-        iconEl.lazy = false;
-        iconEl.classList.add('ion-accordion-toggle-icon');
-        iconEl.icon = toggleIcon;
-        iconEl.setAttribute('aria-hidden', 'true');
-        ionItem.appendChild(iconEl);
-    };
-    expandAccordion = () => {
-        const { contentEl, contentElWrapper } = this;
-        /**
-         * If the content elements aren't available yet, just set the state.
-         * This happens on initial render before the DOM is ready.
-         */
-        if (contentEl === undefined || contentElWrapper === undefined) {
-            this.state = 4 /* AccordionState.Expanded */;
-            this.hasEverBeenExpanded = true;
-            return;
-        }
-        if (this.state === 4 /* AccordionState.Expanded */) {
-            return;
-        }
-        if (this.currentRaf !== undefined) {
-            cancelAnimationFrame(this.currentRaf);
-        }
-        /**
-         * Mark that this accordion has been expanded at least once.
-         * This allows subsequent expansions to animate.
-         */
-        this.hasEverBeenExpanded = true;
-        if (this.shouldAnimate()) {
-            raf(() => {
-                this.state = 8 /* AccordionState.Expanding */;
-                this.currentRaf = raf(async () => {
-                    const contentHeight = contentElWrapper.offsetHeight;
-                    const waitForTransition = transitionEndAsync(contentEl, 2000);
-                    contentEl.style.setProperty('max-height', `${contentHeight}px`);
-                    await waitForTransition;
-                    this.state = 4 /* AccordionState.Expanded */;
-                    contentEl.style.removeProperty('max-height');
-                });
-            });
-        }
-        else {
-            this.state = 4 /* AccordionState.Expanded */;
-        }
-    };
-    collapseAccordion = () => {
-        const { contentEl } = this;
-        /**
-         * If the content element isn't available yet, just set the state.
-         * This happens on initial render before the DOM is ready.
-         */
-        if (contentEl === undefined) {
-            this.state = 1 /* AccordionState.Collapsed */;
-            return;
-        }
-        if (this.state === 1 /* AccordionState.Collapsed */) {
-            return;
-        }
-        if (this.currentRaf !== undefined) {
-            cancelAnimationFrame(this.currentRaf);
-        }
-        if (this.shouldAnimate()) {
-            this.currentRaf = raf(async () => {
-                const contentHeight = contentEl.offsetHeight;
-                contentEl.style.setProperty('max-height', `${contentHeight}px`);
-                raf(async () => {
-                    const waitForTransition = transitionEndAsync(contentEl, 2000);
-                    this.state = 2 /* AccordionState.Collapsing */;
-                    await waitForTransition;
-                    this.state = 1 /* AccordionState.Collapsed */;
-                    contentEl.style.removeProperty('max-height');
-                });
-            });
-        }
-        else {
-            this.state = 1 /* AccordionState.Collapsed */;
-        }
-    };
-    /**
-     * Helper function to determine if
-     * something should animate.
-     * If prefers-reduced-motion is set
-     * then we should not animate, regardless
-     * of what is set in the config.
-     */
-    shouldAnimate = () => {
-        /**
-         * Don't animate until after the first user interaction.
-         * This prevents animations on initial load when accordions
-         * start in an expanded or collapsed state programmatically.
-         *
-         * Additionally, don't animate the very first expansion even if
-         * hasInteracted is true. This handles edge cases like React StrictMode
-         * where effects run twice and might incorrectly mark as interacted.
-         */
-        if (!this.hasInteracted || !this.hasEverBeenExpanded) {
-            return false;
-        }
-        if (typeof window === 'undefined') {
-            return false;
-        }
-        const prefersReducedMotion = matchMedia('(prefers-reduced-motion: reduce)').matches;
-        if (prefersReducedMotion) {
-            return false;
-        }
-        const animated = config.get('animated', true);
-        if (!animated) {
-            return false;
-        }
-        if (this.accordionGroupEl && !this.accordionGroupEl.animated) {
-            return false;
-        }
-        return true;
-    };
-    updateState = async () => {
-        const accordionGroup = this.accordionGroupEl;
-        const accordionValue = this.value;
-        if (!accordionGroup) {
-            return;
-        }
-        const value = accordionGroup.value;
-        const shouldExpand = Array.isArray(value) ? value.includes(accordionValue) : value === accordionValue;
-        if (shouldExpand) {
-            this.expandAccordion();
-            this.isNext = this.isPrevious = false;
-        }
-        else {
-            this.collapseAccordion();
-            /**
-             * When using popout or inset,
-             * the collapsed accordion items
-             * may need additional border radius
-             * applied. Check to see if the
-             * next or previous accordion is selected.
-             */
-            const nextAccordion = this.getNextSibling();
-            const nextAccordionValue = nextAccordion?.value;
-            if (nextAccordionValue !== undefined) {
-                this.isPrevious = Array.isArray(value) ? value.includes(nextAccordionValue) : value === nextAccordionValue;
-            }
-            const previousAccordion = this.getPreviousSibling();
-            const previousAccordionValue = previousAccordion?.value;
-            if (previousAccordionValue !== undefined) {
-                this.isNext = Array.isArray(value) ? value.includes(previousAccordionValue) : value === previousAccordionValue;
-            }
-        }
-    };
-    getNextSibling = () => {
-        if (!this.el) {
-            return;
-        }
-        const nextSibling = this.el.nextElementSibling;
-        if (nextSibling?.tagName !== 'ION-ACCORDION') {
-            return;
-        }
-        return nextSibling;
-    };
-    getPreviousSibling = () => {
-        if (!this.el) {
-            return;
-        }
-        const previousSibling = this.el.previousElementSibling;
-        if (previousSibling?.tagName !== 'ION-ACCORDION') {
-            return;
-        }
-        return previousSibling;
-    };
     toggleExpanded() {
         const { accordionGroupEl, disabled, readonly, value, state } = this;
         if (disabled || readonly)
@@ -412,6 +408,7 @@ const Accordion = class {
             }, tabindex: disabled ? '-1' : undefined }, h("div", { key: 'f76bc02347639b41c9a5be8a9488a8be8559cba7', onClick: () => this.toggleExpanded(), id: "header", part: headerPart, "aria-controls": "content", ref: (headerEl) => (this.headerEl = headerEl) }, h("slot", { key: 'e01744bf0af3200239e82c60c632ed36295db2da', name: "header" })), h("div", { key: 'c613345a7e244ee361f76ff4ebed139d2a1b9572', id: "content", part: contentPart, role: "region", "aria-labelledby": "header", ref: (contentEl) => (this.contentEl = contentEl) }, h("div", { key: '943b65d9a129759b4c213974ae5ed777b5f6166e', id: "content-wrapper", ref: (contentElWrapper) => (this.contentElWrapper = contentElWrapper) }, h("slot", { key: 'b0df520dad9d5557df63a35f8206ada4a765d238', name: "content" })))));
     }
     static get delegatesFocus() { return true; }
+    get el() { return getElement(this); }
     static get watchers() { return {
         "value": [{
                 "valueChanged": 0
@@ -433,53 +430,28 @@ const AccordionGroup = class {
         registerInstance(this, hostRef);
         this.ionChange = createEvent(this, "ionChange", 7);
         this.ionValueChange = createEvent(this, "ionValueChange", 7);
+        /**
+         * If `true`, all accordions inside of the
+         * accordion group will animate when expanding
+         * or collapsing.
+         */
+        this.animated = true;
+        /**
+         * If `true`, the accordion group cannot be interacted with.
+         */
+        this.disabled = false;
+        /**
+         * If `true`, the accordion group cannot be interacted with,
+         * but does not alter the opacity.
+         */
+        this.readonly = false;
+        /**
+         * Describes the expansion behavior for each accordion.
+         * Possible values are `"compact"` and `"inset"`.
+         * Defaults to `"compact"`.
+         */
+        this.expand = 'compact';
     }
-    get el() { return getElement(this); }
-    /**
-     * If `true`, all accordions inside of the
-     * accordion group will animate when expanding
-     * or collapsing.
-     */
-    animated = true;
-    /**
-     * If `true`, the accordion group can have multiple
-     * accordion components expanded at the same time.
-     */
-    multiple;
-    /**
-     * The value of the accordion group. This controls which
-     * accordions are expanded.
-     * This should be an array of strings only when `multiple="true"`
-     */
-    value;
-    /**
-     * If `true`, the accordion group cannot be interacted with.
-     */
-    disabled = false;
-    /**
-     * If `true`, the accordion group cannot be interacted with,
-     * but does not alter the opacity.
-     */
-    readonly = false;
-    /**
-     * Describes the expansion behavior for each accordion.
-     * Possible values are `"compact"` and `"inset"`.
-     * Defaults to `"compact"`.
-     */
-    expand = 'compact';
-    /**
-     * Emitted when the value property has changed as a result of a user action such as a click.
-     *
-     * This event will not emit when programmatically setting the `value` property.
-     */
-    ionChange;
-    /**
-     * Emitted when the value property has changed.
-     * This is used to ensure that ion-accordion can respond
-     * to any value property changes.
-     * @internal
-     */
-    ionValueChange;
     valueChanged() {
         const { value, multiple } = this;
         if (!multiple && Array.isArray(value)) {
@@ -612,7 +584,7 @@ const AccordionGroup = class {
              * to the array.
              */
             if (multiple) {
-                const groupValue = value ?? [];
+                const groupValue = value !== null && value !== void 0 ? value : [];
                 const processedValue = Array.isArray(groupValue) ? groupValue : [groupValue];
                 const valueExists = processedValue.find((v) => v === accordionValue);
                 if (valueExists === undefined && accordionValue !== undefined) {
@@ -629,7 +601,7 @@ const AccordionGroup = class {
              * out of the values array or unset the value.
              */
             if (multiple) {
-                const groupValue = value ?? [];
+                const groupValue = value !== null && value !== void 0 ? value : [];
                 const processedValue = Array.isArray(groupValue) ? groupValue : [groupValue];
                 this.setValue(processedValue.filter((v) => v !== accordionValue));
             }
@@ -668,6 +640,7 @@ const AccordionGroup = class {
                 [`accordion-group-expand-${expand}`]: true,
             }, role: "presentation" }, h("slot", { key: 'e6b8954b686d1fbb4fc92adb07fddc97a24b0a31' })));
     }
+    get el() { return getElement(this); }
     static get watchers() { return {
         "value": [{
                 "valueChanged": 0