voyager-ionic-core 8.8.12 → 9.0.1

package/dist/cjs/{overlays-TbKsuC-K.js → overlays-BR21NUIG.js}

@@ -4,12 +4,12 @@
 'use strict';
 
 var index$1 = require('./index-DkNv4J_i.js');
-var helpers = require('./helpers-Cv23MFHM.js');
-var hardwareBackButton = require('./hardware-back-button-iUuF_76h.js');
-var index = require('./index-Ct7gcRif.js');
-var ionicGlobal = require('./ionic-global-B-cA6LkY.js');
-var frameworkDelegate = require('./framework-delegate-BtICZDHr.js');
-var gestureController = require('./gesture-controller-dtqlP_q4.js');
+var helpers = require('./helpers-7wzdhdeg.js');
+var hardwareBackButton = require('./hardware-back-button-Bu4Dzw8l.js');
+var index = require('./index-DXoo08JC.js');
+var ionicGlobal = require('./ionic-global-CYJNT-2P.js');
+var frameworkDelegate = require('./framework-delegate-d-fWfeI6.js');
+var gestureController = require('./gesture-controller-CeJslptU.js');
 
 /**
  * This query string selects elements that
@@ -36,7 +36,7 @@ const focusableQueryString = '[tabindex]:not([tabindex^="-"]):not([hidden]):not(
  */
 const focusFirstDescendant = (ref, fallbackElement) => {
     const firstInput = ref.querySelector(focusableQueryString);
-    focusElementInContext(firstInput, fallbackElement !== null && fallbackElement !== void 0 ? fallbackElement : ref);
+    focusElementInContext(firstInput, fallbackElement ?? ref);
 };
 /**
  * Focuses the last descendant in a context
@@ -51,7 +51,7 @@ const focusFirstDescendant = (ref, fallbackElement) => {
 const focusLastDescendant = (ref, fallbackElement) => {
     const inputs = Array.from(ref.querySelectorAll(focusableQueryString));
     const lastInput = inputs.length > 0 ? inputs[inputs.length - 1] : null;
-    focusElementInContext(lastInput, fallbackElement !== null && fallbackElement !== void 0 ? fallbackElement : ref);
+    focusElementInContext(lastInput, fallbackElement ?? ref);
 };
 /**
  * Focuses a particular element in a context. If the element
@@ -72,7 +72,7 @@ const focusLastDescendant = (ref, fallbackElement) => {
  */
 const focusElementInContext = (hostToFocus, fallbackElement) => {
     let elementToFocus = hostToFocus;
-    const shadowRoot = hostToFocus === null || hostToFocus === void 0 ? void 0 : hostToFocus.shadowRoot;
+    const shadowRoot = hostToFocus?.shadowRoot;
     if (shadowRoot) {
         // If there are no inner focusable elements, just focus the host element.
         elementToFocus = shadowRoot.querySelector(focusableQueryString) || hostToFocus;
@@ -100,8 +100,16 @@ const activeAnimations = new WeakMap();
  * Returns false if showBackdrop=false or backdropBreakpoint > 0.
  */
 const isBackdropAlwaysBlocking = (el) => {
-    var _a;
-    return el.showBackdrop !== false && !(((_a = el.backdropBreakpoint) !== null && _a !== void 0 ? _a : 0) > 0);
+    return el.showBackdrop !== false && !((el.backdropBreakpoint ?? 0) > 0);
+};
+/**
+ * Whether the overlay takes the app root out of the accessibility tree and
+ * blocks body scroll while presented. Toasts never do, modal and popover can
+ * opt out with `focusTrap={false}`, and a backdrop that does not block
+ * (`showBackdrop={false}`, or a `backdropBreakpoint` above 0) is excluded.
+ */
+const locksAppRoot = (el) => {
+    return el.tagName !== 'ION-TOAST' && el.focusTrap !== false && isBackdropAlwaysBlocking(el);
 };
 const createController = (tagName) => {
     return {
@@ -120,10 +128,6 @@ const alertController = /*@__PURE__*/ createController('ion-alert');
 const actionSheetController = /*@__PURE__*/ createController('ion-action-sheet');
 const loadingController = /*@__PURE__*/ createController('ion-loading');
 const modalController = /*@__PURE__*/ createController('ion-modal');
-/**
- * @deprecated Use the inline ion-picker component instead.
- */
-const pickerController = /*@__PURE__*/ createController('ion-picker-legacy');
 const popoverController = /*@__PURE__*/ createController('ion-popover');
 const toastController = /*@__PURE__*/ createController('ion-toast');
 /**
@@ -163,7 +167,6 @@ const setOverlayId = (el) => {
     return el.id;
 };
 const createOverlay = (tagName, opts) => {
-    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
     if (typeof window !== 'undefined' && typeof window.customElements !== 'undefined') {
         return window.customElements.whenDefined(tagName).then(() => {
             const element = document.createElement(tagName);
@@ -172,7 +175,7 @@ const createOverlay = (tagName, opts) => {
              * Convert the passed in overlay options into props
              * that get passed down into the new overlay.
              */
-            Object.assign(element, Object.assign(Object.assign({}, opts), { hasController: true }));
+            Object.assign(element, { ...opts, hasController: true });
             // append the overlay element to the document body
             getAppRoot(document).appendChild(element);
             return new Promise((resolve) => helpers.componentOnReady(element, resolve));
@@ -196,7 +199,7 @@ const isOverlayHidden = (overlay) => overlay.classList.contains('overlay-hidden'
  */
 const focusElementInOverlay = (hostToFocus, overlay) => {
     let elementToFocus = hostToFocus;
-    const shadowRoot = hostToFocus === null || hostToFocus === void 0 ? void 0 : hostToFocus.shadowRoot;
+    const shadowRoot = hostToFocus?.shadowRoot;
     if (shadowRoot) {
         // If there are no inner focusable elements, just focus the host element.
         elementToFocus = shadowRoot.querySelector(focusableQueryString) || hostToFocus;
@@ -217,7 +220,7 @@ const focusElementInOverlay = (hostToFocus, overlay) => {
  * Should NOT include: Toast
  */
 const trapKeyboardFocus = (ev, doc) => {
-    const lastOverlay = getPresentedOverlay(doc, 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker-legacy,ion-popover');
+    const lastOverlay = getPresentedOverlay(doc, 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-popover');
     const target = ev.target;
     /**
      * If no active overlay, ignore this event.
@@ -403,7 +406,7 @@ const connectListeners = (doc) => {
         // handle back-button click
         doc.addEventListener('ionBackButton', (ev) => {
             const lastOverlay = getPresentedOverlay(doc);
-            if (lastOverlay === null || lastOverlay === void 0 ? void 0 : lastOverlay.backdropDismiss) {
+            if (lastOverlay?.backdropDismiss) {
                 ev.detail.register(hardwareBackButton.OVERLAY_BACK_BUTTON_PRIORITY, () => {
                     /**
                      * Do not return this promise otherwise
@@ -431,7 +434,7 @@ const connectListeners = (doc) => {
             doc.addEventListener('keydown', (ev) => {
                 if (ev.key === 'Escape') {
                     const lastOverlay = getPresentedOverlay(doc);
-                    if (lastOverlay === null || lastOverlay === void 0 ? void 0 : lastOverlay.backdropDismiss) {
+                    if (lastOverlay?.backdropDismiss) {
                         lastOverlay.dismiss(undefined, BACKDROP);
                     }
                 }
@@ -451,7 +454,7 @@ const dismissOverlay = (doc, data, role, overlayTag, id) => {
  */
 const getOverlays = (doc, selector) => {
     if (selector === undefined) {
-        selector = 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker-legacy,ion-popover,ion-toast';
+        selector = 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-popover,ion-toast';
     }
     return Array.from(doc.querySelectorAll(selector)).filter((c) => c.overlayIndex > 0);
 };
@@ -478,6 +481,13 @@ const getPresentedOverlay = (doc, overlayTag, id) => {
     // Otherwise, return the last overlay with the given id
     return (id === undefined ? overlays : overlays.filter((o) => o.id === id)).slice(-1)[0];
 };
+/**
+ * The element an app nests its views under. Overlays hide this rather than the
+ * whole root, so the overlay itself (a sibling) stays reachable.
+ */
+const getViewContainer = () => {
+    return getAppRoot(document).querySelector('ion-router-outlet, #ion-view-container-root');
+};
 /**
  * When an overlay is presented, the main
  * focus is the overlay not the page content.
@@ -501,8 +511,7 @@ const getPresentedOverlay = (doc, overlayTag, id) => {
  * for main content.
  */
 const setRootAriaHidden = (hidden = false) => {
-    const root = getAppRoot(document);
-    const viewContainer = root.querySelector('ion-router-outlet, #ion-view-container-root');
+    const viewContainer = getViewContainer();
     if (!viewContainer) {
         return;
     }
@@ -513,8 +522,57 @@ const setRootAriaHidden = (hidden = false) => {
         viewContainer.removeAttribute('aria-hidden');
     }
 };
+/**
+ * Cleans up root `aria-hidden` and `backdrop-no-scroll` when
+ * an overlay is removed from the DOM without going through
+ * the `dismiss()` flow (e.g., when a framework unmounts the
+ * overlay during a route change).
+ *
+ * Should be called from an overlay's `disconnectedCallback`
+ * when the overlay was still presented at the time of removal.
+ */
+const cleanupRootFocusTrapAccessibility = () => {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    const remainingOverlays = getPresentedOverlays(document);
+    const hasRemainingLocking = remainingOverlays.some((o) => locksAppRoot(o));
+    if (!hasRemainingLocking) {
+        setRootAriaHidden(false);
+        document.body.classList.remove(gestureController.BACKDROP_NO_SCROLL);
+    }
+};
+/**
+ * Applies the root lock itself: `aria-hidden` on the view container, and
+ * `backdrop-no-scroll` on the body. Shared by `present()` and the restore
+ * below, which have to stay in lockstep.
+ */
+const applyRootLock = (el) => {
+    // Hiding the container the overlay now sits in would hide the overlay too.
+    if (!getViewContainer()?.contains(el)) {
+        setRootAriaHidden(true);
+    }
+    document.body.classList.add(gestureController.BACKDROP_NO_SCROLL);
+};
+/**
+ * Re-applies the root lock that `cleanupRootFocusTrapAccessibility()` released.
+ * Call from `connectedCallback` when the overlay is still presented.
+ *
+ * A synchronous move keeps the overlay connected, so the lock survives. A
+ * detach with a re-insert in a later task releases it, which is the shape a
+ * framework produces when it takes a subtree out and puts it back.
+ */
+const restoreRootFocusTrapAccessibility = (overlayEl) => {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    const el = overlayEl;
+    if (!locksAppRoot(el)) {
+        return;
+    }
+    applyRootLock(el);
+};
 const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts) => {
-    var _a, _b;
     if (overlay.presented) {
         return;
     }
@@ -530,15 +588,7 @@ const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts)
         restoreElementFocus(overlay.el);
     }
     /**
-     * Due to accessibility guidelines, toasts do not have
-     * focus traps.
-     *
-     * All other overlays should have focus traps to prevent
-     * the keyboard focus from leaving the overlay unless
-     * developers explicitly opt out (for example, sheet
-     * modals that should permit background interaction).
-     *
-     * Note: Some apps move inline overlays to a specific container
+     * Some apps move inline overlays to a specific container
      * during the willPresent lifecycle (e.g., React portals via
      * onWillPresent). Defer applying aria-hidden/inert to the app
      * root until after willPresent so we can detect where the
@@ -547,20 +597,13 @@ const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts)
      * to avoid disabling the overlay.
      */
     const overlayEl = overlay.el;
-    const shouldTrapFocus = overlayEl.tagName !== 'ION-TOAST' && overlayEl.focusTrap !== false;
-    const shouldLockRoot = shouldTrapFocus && isBackdropAlwaysBlocking(overlayEl);
+    const shouldLockRoot = locksAppRoot(overlayEl);
     overlay.presented = true;
     overlay.willPresent.emit();
     if (shouldLockRoot) {
-        const root = getAppRoot(document);
-        const viewContainer = root.querySelector('ion-router-outlet, #ion-view-container-root');
-        const overlayInsideViewContainer = viewContainer ? viewContainer.contains(overlayEl) : false;
-        if (!overlayInsideViewContainer) {
-            setRootAriaHidden(true);
-        }
-        document.body.classList.add(gestureController.BACKDROP_NO_SCROLL);
+        applyRootLock(overlayEl);
     }
-    (_a = overlay.willPresentShorthand) === null || _a === void 0 ? void 0 : _a.emit();
+    overlay.willPresentShorthand?.emit();
     const mode = ionicGlobal.getIonMode(overlay);
     // get the user's animation fn if one was provided
     const animationBuilder = overlay.enterAnimation
@@ -569,7 +612,7 @@ const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts)
     const completed = await overlayAnimation(overlay, animationBuilder, overlay.el, opts);
     if (completed) {
         overlay.didPresent.emit();
-        (_b = overlay.didPresentShorthand) === null || _b === void 0 ? void 0 : _b.emit();
+        overlay.didPresentShorthand?.emit();
     }
     /**
      * If the focused element is already
@@ -578,7 +621,30 @@ const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts)
      * to the overlay container.
      */
     if (overlay.keyboardClose && (document.activeElement === null || !overlay.el.contains(document.activeElement))) {
-        overlay.el.focus();
+        /**
+         * Some overlays (e.g. modal) put the dialog role and accessible label
+         * on the `.ion-overlay-wrapper` instead of the host. Screen readers
+         * need focus on the element with `role="dialog"` to properly announce
+         * and navigate the dialog.
+         *
+         * We only target wrappers with `tabindex`, since `role="dialog"` alone
+         * does not make an element focusable. If no focusable dialog wrapper
+         * exists (e.g. picker-legacy), we fall back to the host.
+         */
+        const overlayWrapper = helpers.getElementRoot(overlay.el).querySelector('[role="dialog"][tabindex]');
+        const focusTarget = overlayWrapper ?? overlay.el;
+        /**
+         * `preventScroll` keeps this a pure focus move so the viewport does not
+         * jump when the wrapper is partially off-screen (e.g. a sheet modal).
+         * Guard the options call so an older engine that mishandles it can never
+         * reject present(); we fall back to a plain focus() in that case.
+         */
+        try {
+            focusTarget.focus({ preventScroll: true });
+        }
+        catch {
+            focusTarget.focus();
+        }
     }
     /**
      * If this overlay was previously dismissed without being
@@ -612,7 +678,7 @@ const restoreElementFocus = async (overlayEl) => {
     }
     // Ensure active element is blurred to prevent a11y warning issues
     previousElement.blur();
-    const shadowRoot = previousElement === null || previousElement === void 0 ? void 0 : previousElement.shadowRoot;
+    const shadowRoot = previousElement?.shadowRoot;
     if (shadowRoot) {
         // If there are no inner focusable elements, just focus the host element.
         previousElement = shadowRoot.querySelector(focusableQueryString) || previousElement;
@@ -647,7 +713,6 @@ const restoreElementFocus = async (overlayEl) => {
     }
 };
 const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnimation, opts) => {
-    var _a, _b;
     if (!overlay.presented) {
         return false;
     }
@@ -662,12 +727,9 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
      * from the root element when the last focus-trapping overlay
      * is dismissed.
      */
-    const overlaysLockingRoot = presentedOverlays.filter((o) => {
-        const el = o;
-        return el.tagName !== 'ION-TOAST' && el.focusTrap !== false && isBackdropAlwaysBlocking(el);
-    });
+    const overlaysLockingRoot = presentedOverlays.filter((o) => locksAppRoot(o));
     const overlayEl = overlay.el;
-    const locksRoot = overlayEl.tagName !== 'ION-TOAST' && overlayEl.focusTrap !== false && isBackdropAlwaysBlocking(overlayEl);
+    const locksRoot = locksAppRoot(overlayEl);
     /**
      * If this is the last visible overlay that is trapping focus
      * then we want to re-add the root to the accessibility tree.
@@ -682,7 +744,7 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
         // Overlay contents should not be clickable during dismiss
         overlay.el.style.setProperty('pointer-events', 'none');
         overlay.willDismiss.emit({ data, role });
-        (_a = overlay.willDismissShorthand) === null || _a === void 0 ? void 0 : _a.emit({ data, role });
+        overlay.willDismissShorthand?.emit({ data, role });
         const mode = ionicGlobal.getIonMode(overlay);
         const animationBuilder = overlay.leaveAnimation
             ? overlay.leaveAnimation
@@ -692,7 +754,7 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
             await overlayAnimation(overlay, animationBuilder, overlay.el, opts);
         }
         overlay.didDismiss.emit({ data, role });
-        (_b = overlay.didDismissShorthand) === null || _b === void 0 ? void 0 : _b.emit({ data, role });
+        overlay.didDismissShorthand?.emit({ data, role });
         // Get a reference to all animations currently assigned to this overlay
         // Then tear them down to return the overlay to its initial visual state
         const animations = activeAnimations.get(overlay) || [];
@@ -733,7 +795,7 @@ const overlayAnimation = async (overlay, animationBuilder, baseEl, opts) => {
     if (overlay.keyboardClose) {
         animation.beforeAddWrite(() => {
             const activeElement = baseEl.ownerDocument.activeElement;
-            if (activeElement === null || activeElement === void 0 ? void 0 : activeElement.matches('input,ion-input, ion-textarea')) {
+            if (activeElement?.matches('input,ion-input, ion-textarea')) {
                 activeElement.blur();
             }
         });
@@ -920,6 +982,7 @@ exports.GESTURE = GESTURE;
 exports.OVERLAY_GESTURE_PRIORITY = OVERLAY_GESTURE_PRIORITY;
 exports.actionSheetController = actionSheetController;
 exports.alertController = alertController;
+exports.cleanupRootFocusTrapAccessibility = cleanupRootFocusTrapAccessibility;
 exports.createDelegateController = createDelegateController;
 exports.createTriggerController = createTriggerController;
 exports.dismiss = dismiss;
@@ -930,10 +993,10 @@ exports.getPresentedOverlay = getPresentedOverlay;
 exports.isCancel = isCancel;
 exports.loadingController = loadingController;
 exports.modalController = modalController;
-exports.pickerController = pickerController;
 exports.popoverController = popoverController;
 exports.prepareOverlay = prepareOverlay;
 exports.present = present;
+exports.restoreRootFocusTrapAccessibility = restoreRootFocusTrapAccessibility;
 exports.safeCall = safeCall;
 exports.setOverlayId = setOverlayId;
 exports.toastController = toastController;

package/dist/cjs/select-option-render-CrbLc-1j.js

@@ -0,0 +1,123 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+'use strict';
+
+var index = require('./index-DXoo08JC.js');
+var index$1 = require('./index-BbqUBe2T.js');
+
+/**
+ * Converts a DOM node into a Stencil VNode (or text string) so the
+ * resulting tree is rendered through the component's normal render
+ * path. Rendering through Stencil ensures that scoped CSS classes
+ * (e.g. `sc-ion-action-sheet-ionic`) are applied to every element.
+ *
+ * Highly recommended to pre-sanitize the source DOM (see
+ * `getOptionContent` in select.tsx). This function performs pure
+ * structural conversion — no security filtering.
+ *
+ * Preserves attributes only — properties set imperatively on the source
+ * element (e.g. `input.value` after a user types) won't carry through.
+ * In practice this isn't a concern: interactive controls shouldn't
+ * appear in select-option rich content since they'd nest inside the
+ * overlay's button/radio/checkbox wrapper, which is invalid HTML and
+ * an accessibility issue.
+ *
+ * @param node - The DOM node to convert. Text nodes become strings,
+ * element nodes become VNodes, and any other node types are skipped.
+ * @param keyPrefix - String prefix used to build a stable VNode key,
+ * so Stencil's diff can preserve elements across re-renders.
+ * @param index - Position of this node among its siblings. Combined
+ * with `keyPrefix` to form the final unique key.
+ * @returns The converted VNode, a text string, or `null` if the node
+ * type isn't supported.
+ *
+ * @internal Exported only so it can be unit tested; not part of the
+ * public API.
+ */
+const cloneToVNode = (node, keyPrefix, index$1) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+        return node.textContent ?? '';
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) {
+        return null;
+    }
+    const el = node;
+    const tag = el.tagName.toLowerCase();
+    const key = `${keyPrefix}-${index$1}`;
+    const attrs = { key };
+    for (let i = 0; i < el.attributes.length; i++) {
+        const attr = el.attributes.item(i);
+        attrs[attr.name] = attr.value;
+    }
+    const children = Array.from(el.childNodes)
+        .map((child, i) => cloneToVNode(child, key, i))
+        .filter((c) => c !== null);
+    return index.h(tag, attrs, children);
+};
+/**
+ * Renders cloned DOM content as Stencil JSX. Walking the source DOM
+ * into VNodes (rather than injecting it via innerHTML) keeps the
+ * content inside Stencil's render path, so scoped CSS classes are
+ * applied automatically and component attributes like `size` or
+ * `color` survive intact.
+ *
+ * Span elements should be used when this content renders within buttons,
+ * depending on the select interface. Buttons can only have phrasing
+ * content to prevent accessibility issues.
+ *
+ * @param id - Unique identifier for generating stable virtual DOM keys.
+ * @param content - The HTMLElement container whose child nodes will be cloned.
+ * @param className - CSS class applied to the wrapper element.
+ * @param useSpan - Whether to use a span element instead of a div for the wrapper.
+ */
+const renderClonedContent = (id, content, className, useSpan = false) => {
+    const Tag = useSpan ? 'span' : 'div';
+    const keyPrefix = `${className}-${id}`;
+    /**
+     * Do not remove. This is the only sanitization pass for callers that pass
+     * an `HTMLElement` straight to `renderOptionLabel` (e.g. vanilla JS)
+     * without going through `getOptionContent`, which sanitizes upstream.
+     * `cloneToVNode` does pure structural conversion and no security
+     * filtering, so dropping this call would reopen an XSS hole on the
+     * direct `HTMLElement` path.
+     */
+    index$1.sanitizeDOMTree(content);
+    return (index.h(Tag, { class: className, key: keyPrefix }, Array.from(content.childNodes).map((child, i) => cloneToVNode(child, keyPrefix, i))));
+};
+/**
+ * Renders the label content for a select option within an overlay
+ * interface based on the presence of rich content.
+ *
+ * Span elements should be used when this content renders within buttons,
+ * depending on the select interface. Buttons can only have phrasing
+ * content to prevent accessibility issues.
+ *
+ * @param option - The content option data containing label, slots,
+ * and description.
+ * @param className - The base CSS class for the label element.
+ * @param useSpan - Whether to use a span element instead of a div for the label.
+ */
+const renderOptionLabel = (option, className, useSpan = false) => {
+    const { id, label, startContent, endContent, description } = option;
+    const hasRichContent = !!startContent || !!endContent || !!description;
+    const Tag = useSpan ? 'span' : 'div';
+    // Render simple string label if there is no rich content to display
+    if (!hasRichContent && (typeof label === 'string' || !label)) {
+        return (index.h(Tag, { class: className, key: `${className}-${id}` }, label));
+    }
+    // Render the main label
+    const labelEl = typeof label === 'string' || !label ? (
+    // Label is a simple string or undefined
+    index.h(Tag, { key: `${className}-label-${id}` }, label)) : (
+    // Label is an HTMLElement with potential rich content
+    renderClonedContent(id, label, `${className}-text`, useSpan));
+    // No rich content, render just the label
+    if (!hasRichContent) {
+        return (index.h(Tag, { class: className, key: `${className}-${id}` }, labelEl));
+    }
+    // Render label with rich content (start, end, description)
+    return (index.h(Tag, { class: `${className} ${className}-has-rich-content`, key: `${className}-${id}` }, startContent && renderClonedContent(id, startContent, 'select-option-start', useSpan), index.h(Tag, { class: "select-option-content", key: `${className}-content-${id}` }, labelEl, description && (index.h(Tag, { class: "select-option-description", key: `${className}-desc-${id}` }, description))), endContent && renderClonedContent(id, endContent, 'select-option-end', useSpan)));
+};
+
+exports.renderOptionLabel = renderOptionLabel;