@esri/calcite-components 1.4.1 → 1.4.2

package/hydrate/index.js

@@ -1,7 +1,7 @@
 /*!
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
  * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
- * v1.4.1
+ * v1.4.2
  */
 'use strict';
 
@@ -6919,7 +6919,7 @@ const SLOTS$x = {
   actionsStart: "actions-start",
   actionsEnd: "actions-end"
 };
-const CSS$15 = {
+const CSS$16 = {
   icon: "icon",
   header: "header",
   headerContent: "header-content",
@@ -6990,28 +6990,28 @@ class AccordionItem {
   // --------------------------------------------------------------------------
   renderActionsStart() {
     const { el } = this;
-    return getSlotted(el, SLOTS$x.actionsStart) ? (hAsync("div", { class: CSS$15.actionsStart }, hAsync("slot", { name: SLOTS$x.actionsStart }))) : null;
+    return getSlotted(el, SLOTS$x.actionsStart) ? (hAsync("div", { class: CSS$16.actionsStart }, hAsync("slot", { name: SLOTS$x.actionsStart }))) : null;
   }
   renderActionsEnd() {
     const { el } = this;
-    return getSlotted(el, SLOTS$x.actionsEnd) ? (hAsync("div", { class: CSS$15.actionsEnd }, hAsync("slot", { name: SLOTS$x.actionsEnd }))) : null;
+    return getSlotted(el, SLOTS$x.actionsEnd) ? (hAsync("div", { class: CSS$16.actionsEnd }, hAsync("slot", { name: SLOTS$x.actionsEnd }))) : null;
   }
   render() {
     const { iconFlipRtl } = this;
     const dir = getElementDir(this.el);
-    const iconStartEl = this.iconStart ? (hAsync("calcite-icon", { class: CSS$15.iconStart, flipRtl: iconFlipRtl === "both" || iconFlipRtl === "start", icon: this.iconStart, key: "icon-start", scale: this.scale === "l" ? "m" : "s" })) : null;
-    const iconEndEl = this.iconEnd ? (hAsync("calcite-icon", { class: CSS$15.iconEnd, flipRtl: iconFlipRtl === "both" || iconFlipRtl === "end", icon: this.iconEnd, key: "icon-end", scale: this.scale === "l" ? "m" : "s" })) : null;
+    const iconStartEl = this.iconStart ? (hAsync("calcite-icon", { class: CSS$16.iconStart, flipRtl: iconFlipRtl === "both" || iconFlipRtl === "start", icon: this.iconStart, key: "icon-start", scale: this.scale === "l" ? "m" : "s" })) : null;
+    const iconEndEl = this.iconEnd ? (hAsync("calcite-icon", { class: CSS$16.iconEnd, flipRtl: iconFlipRtl === "both" || iconFlipRtl === "end", icon: this.iconEnd, key: "icon-end", scale: this.scale === "l" ? "m" : "s" })) : null;
     const { description } = this;
     return (hAsync(Host, null, hAsync("div", { class: {
         [`icon-position--${this.iconPosition}`]: true,
         [`icon-type--${this.iconType}`]: true
-      } }, hAsync("div", { class: { [CSS$15.header]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.renderActionsStart(), hAsync("div", { "aria-expanded": toAriaBoolean(this.expanded), class: CSS$15.headerContent, onClick: this.itemHeaderClickHandler, role: "button", tabindex: "0" }, hAsync("div", { class: CSS$15.headerContainer }, iconStartEl, hAsync("div", { class: CSS$15.headerText }, hAsync("span", { class: CSS$15.heading }, this.heading), description ? hAsync("span", { class: CSS$15.description }, description) : null), iconEndEl), hAsync("calcite-icon", { class: CSS$15.expandIcon, icon: this.iconType === "chevron"
+      } }, hAsync("div", { class: { [CSS$16.header]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.renderActionsStart(), hAsync("div", { "aria-expanded": toAriaBoolean(this.expanded), class: CSS$16.headerContent, onClick: this.itemHeaderClickHandler, role: "button", tabindex: "0" }, hAsync("div", { class: CSS$16.headerContainer }, iconStartEl, hAsync("div", { class: CSS$16.headerText }, hAsync("span", { class: CSS$16.heading }, this.heading), description ? hAsync("span", { class: CSS$16.description }, description) : null), iconEndEl), hAsync("calcite-icon", { class: CSS$16.expandIcon, icon: this.iconType === "chevron"
         ? "chevronDown"
         : this.iconType === "caret"
           ? "caretDown"
           : this.expanded
             ? "minus"
-            : "plus", scale: this.scale === "l" ? "m" : "s" })), this.renderActionsEnd()), hAsync("div", { class: CSS$15.content }, hAsync("slot", null)))));
+            : "plus", scale: this.scale === "l" ? "m" : "s" })), this.renderActionsEnd()), hAsync("div", { class: CSS$16.content }, hAsync("slot", null)))));
   }
   //--------------------------------------------------------------------------
   //
@@ -7784,7 +7784,7 @@ function defaultOnMessagesChange() {
   mergeMessages(this);
 }
 
-const CSS$14 = {
+const CSS$15 = {
   button: "button",
   buttonTextVisible: "button--text-visible",
   buttonCompact: "button--compact",
@@ -7893,14 +7893,14 @@ class Action {
   renderTextContainer() {
     const { text, textEnabled } = this;
     const textContainerClasses = {
-      [CSS$14.textContainer]: true,
-      [CSS$14.textContainerVisible]: textEnabled
+      [CSS$15.textContainer]: true,
+      [CSS$15.textContainerVisible]: textEnabled
     };
     return text ? (hAsync("div", { class: textContainerClasses, key: "text-container" }, text)) : null;
   }
   renderIndicatorText() {
     const { indicator, messages, indicatorId, buttonId } = this;
-    return (hAsync("div", { "aria-labelledby": buttonId, "aria-live": "polite", class: CSS$14.indicatorText, id: indicatorId, role: "region" }, indicator ? messages.indicator : null));
+    return (hAsync("div", { "aria-labelledby": buttonId, "aria-live": "polite", class: CSS$15.indicatorText, id: indicatorId, role: "region" }, indicator ? messages.indicator : null));
   }
   renderIconContainer() {
     const { loading, icon, scale, el, iconFlipRtl } = this;
@@ -7911,18 +7911,18 @@ class Action {
     const iconNode = calciteLoaderNode || calciteIconNode;
     const hasIconToDisplay = iconNode || el.children?.length;
     const slotContainerNode = (hAsync("div", { class: {
-        [CSS$14.slotContainer]: true,
-        [CSS$14.slotContainerHidden]: loading
+        [CSS$15.slotContainer]: true,
+        [CSS$15.slotContainerHidden]: loading
       } }, hAsync("slot", null)));
-    return hasIconToDisplay ? (hAsync("div", { "aria-hidden": "true", class: CSS$14.iconContainer, key: "icon-container" }, iconNode, slotContainerNode)) : null;
+    return hasIconToDisplay ? (hAsync("div", { "aria-hidden": "true", class: CSS$15.iconContainer, key: "icon-container" }, iconNode, slotContainerNode)) : null;
   }
   render() {
     const { active, compact, disabled, loading, textEnabled, label, text, indicator, indicatorId, buttonId, messages } = this;
     const ariaLabel = `${label || text}${indicator ? ` (${messages.indicator})` : ""}`;
     const buttonClasses = {
-      [CSS$14.button]: true,
-      [CSS$14.buttonTextVisible]: textEnabled,
-      [CSS$14.buttonCompact]: compact
+      [CSS$15.button]: true,
+      [CSS$15.buttonTextVisible]: textEnabled,
+      [CSS$15.buttonCompact]: compact
     };
     return (hAsync(Host, null, hAsync("button", { "aria-busy": toAriaBoolean(loading), "aria-controls": indicator ? indicatorId : null, "aria-disabled": toAriaBoolean(disabled), "aria-label": ariaLabel, "aria-pressed": toAriaBoolean(active), class: buttonClasses, disabled: disabled, id: buttonId,
       // eslint-disable-next-line react/jsx-sort-props
@@ -9235,7 +9235,7 @@ const ICONS$j = {
   menu: "ellipsis"
 };
 
-const CSS$13 = {
+const CSS$14 = {
   menu: "menu",
   defaultTrigger: "default-trigger"
 };
@@ -9337,7 +9337,7 @@ const ExpandToggle = ({ expanded, intlExpand, intlCollapse, toggle, el, position
   return actionNode;
 };
 
-const CSS$12 = {
+const CSS$13 = {
   actionGroupBottom: "action-group--bottom"
 };
 const SLOTS$t = {
@@ -9525,7 +9525,7 @@ class ActionBar {
     const expandToggleNode = !expandDisabled ? (hAsync(ExpandToggle, { el: el, expanded: expanded, intlCollapse: messages.collapse, intlExpand: messages.expand, position: position, scale: scale, toggle: toggleExpand, tooltip: tooltip,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setExpandToggleRef })) : null;
-    return getSlotted(el, SLOTS$t.bottomActions) || expandToggleNode ? (hAsync("calcite-action-group", { class: CSS$12.actionGroupBottom, layout: layout, scale: scale }, hAsync("slot", { name: SLOTS$t.bottomActions }), hAsync("slot", { name: SLOTS$t.expandTooltip }), expandToggleNode)) : null;
+    return getSlotted(el, SLOTS$t.bottomActions) || expandToggleNode ? (hAsync("calcite-action-group", { class: CSS$13.actionGroupBottom, layout: layout, scale: scale }, hAsync("slot", { name: SLOTS$t.bottomActions }), hAsync("slot", { name: SLOTS$t.expandTooltip }), expandToggleNode)) : null;
   }
   render() {
     return (hAsync(Host, { onCalciteActionMenuOpen: this.actionMenuOpenHandler }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }), this.renderBottomActionGroup()));
@@ -9931,7 +9931,7 @@ class ActionMenu {
   }
   renderMenuButton() {
     const { label, scale, expanded } = this;
-    const menuButtonSlot = (hAsync("slot", { name: SLOTS$u.trigger, onSlotchange: this.setMenuButtonEl }, hAsync("calcite-action", { class: CSS$13.defaultTrigger, icon: ICONS$i.menu, scale: scale, text: label, textEnabled: expanded,
+    const menuButtonSlot = (hAsync("slot", { name: SLOTS$u.trigger, onSlotchange: this.setMenuButtonEl }, hAsync("calcite-action", { class: CSS$14.defaultTrigger, icon: ICONS$i.menu, scale: scale, text: label, textEnabled: expanded,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setDefaultMenuButtonEl })));
     return menuButtonSlot;
@@ -9940,7 +9940,7 @@ class ActionMenu {
     const { actionElements, activeMenuItemIndex, open, menuId, menuButtonEl, label, placement, overlayPositioning, flipPlacements } = this;
     const activeAction = actionElements[activeMenuItemIndex];
     const activeDescendantId = activeAction?.id || null;
-    return (hAsync("calcite-popover", { flipPlacements: flipPlacements, focusTrapDisabled: true, label: label, offsetDistance: 0, open: open, overlayPositioning: overlayPositioning, placement: placement, pointerDisabled: true, referenceElement: menuButtonEl }, hAsync("div", { "aria-activedescendant": activeDescendantId, "aria-labelledby": menuButtonEl?.id, class: CSS$13.menu, id: menuId, onClick: this.handleCalciteActionClick, role: "menu", tabIndex: -1 }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }))));
+    return (hAsync("calcite-popover", { flipPlacements: flipPlacements, focusTrapDisabled: true, label: label, offsetDistance: 0, open: open, overlayPositioning: overlayPositioning, placement: placement, pointerDisabled: true, referenceElement: menuButtonEl }, hAsync("div", { "aria-activedescendant": activeDescendantId, "aria-labelledby": menuButtonEl?.id, class: CSS$14.menu, id: menuId, onClick: this.handleCalciteActionClick, role: "menu", tabIndex: -1 }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }))));
   }
   render() {
     return (hAsync(Fragment, null, this.renderMenuButton(), this.renderMenuItems(), hAsync("slot", { name: SLOTS$u.tooltip, onSlotchange: this.updateTooltip })));
@@ -9976,7 +9976,7 @@ class ActionMenu {
   }; }
 }
 
-const CSS$11 = {
+const CSS$12 = {
   actionGroupBottom: "action-group--bottom",
   container: "container"
 };
@@ -10096,10 +10096,10 @@ class ActionPad {
     const expandToggleNode = !expandDisabled ? (hAsync(ExpandToggle, { el: el, expanded: expanded, intlCollapse: messages.collapse, intlExpand: messages.expand, position: position, scale: scale, toggle: toggleExpand, tooltip: tooltip,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setExpandToggleRef })) : null;
-    return expandToggleNode ? (hAsync("calcite-action-group", { class: CSS$11.actionGroupBottom, layout: layout, scale: scale }, hAsync("slot", { name: SLOTS$s.expandTooltip }), expandToggleNode)) : null;
+    return expandToggleNode ? (hAsync("calcite-action-group", { class: CSS$12.actionGroupBottom, layout: layout, scale: scale }, hAsync("slot", { name: SLOTS$s.expandTooltip }), expandToggleNode)) : null;
   }
   render() {
-    return (hAsync(Host, { onCalciteActionMenuOpen: this.actionMenuOpenHandler }, hAsync("div", { class: CSS$11.container }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }), this.renderBottomActionGroup())));
+    return (hAsync(Host, { onCalciteActionMenuOpen: this.actionMenuOpenHandler }, hAsync("div", { class: CSS$12.container }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }), this.renderBottomActionGroup())));
   }
   static get delegatesFocus() { return true; }
   static get assetsDirs() { return ["assets"]; }
@@ -10235,7 +10235,7 @@ const SLOTS$r = {
   message: "message",
   link: "link"
 };
-const CSS$10 = {
+const CSS$11 = {
   actionsEnd: "actions-end",
   container: "container",
   close: "alert-close",
@@ -10393,10 +10393,10 @@ class Alert {
         container: true,
         queued,
         [placement]: true,
-        [CSS$10.slottedInShell]: this.slottedInShell
+        [CSS$11.slottedInShell]: this.slottedInShell
       }, onPointerEnter: this.autoClose && this.autoCloseTimeoutId ? this.handleMouseOver : null, onPointerLeave: this.autoClose && this.autoCloseTimeoutId ? this.handleMouseLeave : null,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.setTransitionEl }, requestedIcon ? (hAsync("div", { class: "alert-icon" }, hAsync("calcite-icon", { flipRtl: iconFlipRtl, icon: requestedIcon, scale: this.scale === "l" ? "m" : "s" }))) : null, hAsync("div", { class: "alert-content" }, hAsync("slot", { name: SLOTS$r.title }), hAsync("slot", { name: SLOTS$r.message }), hAsync("slot", { name: SLOTS$r.link })), hAsync("div", { class: CSS$10.actionsEnd, hidden: !hasEndActions }, slotNode), this.queueLength > 1 ? queueCount : null, closeButton, open && !queued && autoClose ? hAsync("div", { class: "alert-dismiss-progress" }) : null)));
+      ref: this.setTransitionEl }, requestedIcon ? (hAsync("div", { class: "alert-icon" }, hAsync("calcite-icon", { flipRtl: iconFlipRtl, icon: requestedIcon, scale: this.scale === "l" ? "m" : "s" }))) : null, hAsync("div", { class: "alert-content" }, hAsync("slot", { name: SLOTS$r.title }), hAsync("slot", { name: SLOTS$r.message }), hAsync("slot", { name: SLOTS$r.link })), hAsync("div", { class: CSS$11.actionsEnd, hidden: !hasEndActions }, slotNode), this.queueLength > 1 ? queueCount : null, closeButton, open && !queued && autoClose ? hAsync("div", { class: "alert-dismiss-progress" }) : null)));
   }
   // when an alert is opened or closed, update queue and determine active alert
   alertSync(event) {
@@ -10854,7 +10854,7 @@ const Heading = (props, children) => {
   return hAsync(HeadingTag, { ...props }, children);
 };
 
-const CSS$$ = {
+const CSS$10 = {
   container: "container",
   content: "content",
   headerContainer: "header-container",
@@ -10965,31 +10965,31 @@ class Block {
     const statusIcon = showingLoadingStatus ? ICONS$g.refresh : ICONS$g[status];
     const hasIcon = getSlotted(el, SLOTS$q.icon) || statusIcon;
     const iconEl = !statusIcon ? (hAsync("slot", { key: "icon-slot", name: SLOTS$q.icon })) : (hAsync("calcite-icon", { class: {
-        [CSS$$.statusIcon]: true,
-        [CSS$$.valid]: status == "valid",
-        [CSS$$.invalid]: status == "invalid",
-        [CSS$$.loading]: showingLoadingStatus
+        [CSS$10.statusIcon]: true,
+        [CSS$10.valid]: status == "valid",
+        [CSS$10.invalid]: status == "invalid",
+        [CSS$10.loading]: showingLoadingStatus
       }, icon: statusIcon, scale: "m" }));
-    return hasIcon ? hAsync("div", { class: CSS$$.icon }, iconEl) : null;
+    return hasIcon ? hAsync("div", { class: CSS$10.icon }, iconEl) : null;
   }
   renderTitle() {
     const { heading, headingLevel, description } = this;
-    return heading || description ? (hAsync("div", { class: CSS$$.title }, hAsync(Heading, { class: CSS$$.heading, level: headingLevel }, heading), description ? hAsync("div", { class: CSS$$.description }, description) : null)) : null;
+    return heading || description ? (hAsync("div", { class: CSS$10.title }, hAsync(Heading, { class: CSS$10.heading, level: headingLevel }, heading), description ? hAsync("div", { class: CSS$10.description }, description) : null)) : null;
   }
   render() {
     const { collapsible, el, loading, open, messages } = this;
     const toggleLabel = open ? messages.collapse : messages.expand;
-    const headerContent = (hAsync("header", { class: CSS$$.header }, this.renderIcon(), this.renderTitle()));
+    const headerContent = (hAsync("header", { class: CSS$10.header }, this.renderIcon(), this.renderTitle()));
     const hasControl = !!getSlotted(el, SLOTS$q.control);
     const hasMenuActions = !!getSlotted(el, SLOTS$q.headerMenuActions);
     const collapseIcon = open ? ICONS$g.opened : ICONS$g.closed;
     const { guid } = this;
     const regionId = `${guid}-region`;
     const buttonId = `${guid}-button`;
-    const headerNode = (hAsync("div", { class: CSS$$.headerContainer }, this.dragHandle ? hAsync("calcite-handle", null) : null, collapsible ? (hAsync("button", { "aria-controls": regionId, "aria-expanded": collapsible ? toAriaBoolean(open) : null, "aria-label": toggleLabel, class: CSS$$.toggle, id: buttonId, onClick: this.onHeaderClick, title: toggleLabel }, headerContent, !hasControl && !hasMenuActions ? (hAsync("calcite-icon", { "aria-hidden": "true", class: CSS$$.toggleIcon, icon: collapseIcon, scale: "s" })) : null)) : (headerContent), loading ? (hAsync("calcite-loader", { inline: true, label: messages.loading })) : hasControl ? (hAsync("div", { class: CSS$$.controlContainer }, hAsync("slot", { name: SLOTS$q.control }))) : null, hasMenuActions ? (hAsync("calcite-action-menu", { label: messages.options }, hAsync("slot", { name: SLOTS$q.headerMenuActions }))) : null));
+    const headerNode = (hAsync("div", { class: CSS$10.headerContainer }, this.dragHandle ? hAsync("calcite-handle", null) : null, collapsible ? (hAsync("button", { "aria-controls": regionId, "aria-expanded": collapsible ? toAriaBoolean(open) : null, "aria-label": toggleLabel, class: CSS$10.toggle, id: buttonId, onClick: this.onHeaderClick, title: toggleLabel }, headerContent, !hasControl && !hasMenuActions ? (hAsync("calcite-icon", { "aria-hidden": "true", class: CSS$10.toggleIcon, icon: collapseIcon, scale: "s" })) : null)) : (headerContent), loading ? (hAsync("calcite-loader", { inline: true, label: messages.loading })) : hasControl ? (hAsync("div", { class: CSS$10.controlContainer }, hAsync("slot", { name: SLOTS$q.control }))) : null, hasMenuActions ? (hAsync("calcite-action-menu", { label: messages.options }, hAsync("slot", { name: SLOTS$q.headerMenuActions }))) : null));
     return (hAsync(Host, null, hAsync("article", { "aria-busy": toAriaBoolean(loading), class: {
-        [CSS$$.container]: true
-      } }, headerNode, hAsync("section", { "aria-expanded": toAriaBoolean(open), "aria-labelledby": buttonId, class: CSS$$.content, hidden: !open, id: regionId }, this.renderScrim()))));
+        [CSS$10.container]: true
+      } }, headerNode, hAsync("section", { "aria-expanded": toAriaBoolean(open), "aria-labelledby": buttonId, class: CSS$10.content, hidden: !open, id: regionId }, this.renderScrim()))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -11022,7 +11022,7 @@ class Block {
   }; }
 }
 
-const CSS$_ = {
+const CSS$$ = {
   content: "content",
   invalid: "invalid",
   toggle: "toggle",
@@ -11108,9 +11108,9 @@ class BlockSection {
     const { status } = this;
     const statusIcon = ICONS$f[status] ?? false;
     const statusIconClasses = {
-      [CSS$_.statusIcon]: true,
-      [CSS$_.valid]: status == "valid",
-      [CSS$_.invalid]: status == "invalid"
+      [CSS$$.statusIcon]: true,
+      [CSS$$.valid]: status == "valid",
+      [CSS$$.invalid]: status == "invalid"
     };
     return !!statusIcon ? (hAsync("calcite-icon", { class: statusIconClasses, icon: statusIcon, scale: "s" })) : null;
   }
@@ -11127,13 +11127,13 @@ class BlockSection {
     const regionId = `${guid}-region`;
     const buttonId = `${guid}-button`;
     const headerNode = toggleDisplay === "switch" ? (hAsync("div", { "aria-controls": regionId, "aria-label": toggleLabel, class: {
-        [CSS$_.toggle]: true,
-        [CSS$_.toggleSwitch]: true
-      }, id: buttonId, onClick: this.toggleSection, onKeyDown: this.handleHeaderKeyDown, tabIndex: 0, title: toggleLabel }, hAsync("div", { class: CSS$_.toggleSwitchContent }, hAsync("span", { class: CSS$_.toggleSwitchText }, text)), hAsync("calcite-switch", { checked: open, label: toggleLabel, scale: "s", tabIndex: -1 }), this.renderStatusIcon())) : (hAsync("button", { "aria-controls": regionId, "aria-label": toggleLabel, class: {
-        [CSS$_.sectionHeader]: true,
-        [CSS$_.toggle]: true
-      }, id: buttonId, name: toggleLabel, onClick: this.toggleSection }, hAsync("calcite-icon", { icon: arrowIcon, scale: "s" }), hAsync("span", { class: CSS$_.sectionHeaderText }, text), this.renderStatusIcon()));
-    return (hAsync(Host, null, headerNode, hAsync("section", { "aria-expanded": toAriaBoolean(open), "aria-labelledby": buttonId, class: CSS$_.content, hidden: !open, id: regionId }, hAsync("slot", null))));
+        [CSS$$.toggle]: true,
+        [CSS$$.toggleSwitch]: true
+      }, id: buttonId, onClick: this.toggleSection, onKeyDown: this.handleHeaderKeyDown, tabIndex: 0, title: toggleLabel }, hAsync("div", { class: CSS$$.toggleSwitchContent }, hAsync("span", { class: CSS$$.toggleSwitchText }, text)), hAsync("calcite-switch", { checked: open, label: toggleLabel, scale: "s", tabIndex: -1 }), this.renderStatusIcon())) : (hAsync("button", { "aria-controls": regionId, "aria-label": toggleLabel, class: {
+        [CSS$$.sectionHeader]: true,
+        [CSS$$.toggle]: true
+      }, id: buttonId, name: toggleLabel, onClick: this.toggleSection }, hAsync("calcite-icon", { icon: arrowIcon, scale: "s" }), hAsync("span", { class: CSS$$.sectionHeaderText }, text), this.renderStatusIcon()));
+    return (hAsync(Host, null, headerNode, hAsync("section", { "aria-expanded": toAriaBoolean(open), "aria-labelledby": buttonId, class: CSS$$.content, hidden: !open, id: regionId }, hAsync("slot", null))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -11544,7 +11544,7 @@ function onLabelDisconnected() {
   document.addEventListener(labelConnectedEvent, boundOnLabelConnected);
 }
 
-const CSS$Z = {
+const CSS$_ = {
   buttonLoader: "calcite-button--loader",
   content: "content",
   contentSlotted: "content--slotted",
@@ -11670,17 +11670,17 @@ class Button {
   render() {
     const childElType = this.href ? "a" : "button";
     const Tag = childElType;
-    const loaderNode = this.hasLoader ? (hAsync("div", { class: CSS$Z.buttonLoader }, hAsync("calcite-loader", { class: this.loading ? CSS$Z.loadingIn : CSS$Z.loadingOut, inline: true, label: this.messages.loading, scale: this.scale === "l" ? "m" : "s" }))) : null;
+    const loaderNode = this.hasLoader ? (hAsync("div", { class: CSS$_.buttonLoader }, hAsync("calcite-loader", { class: this.loading ? CSS$_.loadingIn : CSS$_.loadingOut, inline: true, label: this.messages.loading, scale: this.scale === "l" ? "m" : "s" }))) : null;
     const noStartEndIcons = !this.iconStart && !this.iconEnd;
-    const iconStartEl = (hAsync("calcite-icon", { class: { [CSS$Z.icon]: true, [CSS$Z.iconStart]: true }, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, scale: this.scale === "l" ? "m" : "s" }));
-    const iconEndEl = (hAsync("calcite-icon", { class: { [CSS$Z.icon]: true, [CSS$Z.iconEnd]: true }, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, scale: this.scale === "l" ? "m" : "s" }));
-    const contentEl = (hAsync("span", { class: CSS$Z.content, ref: (el) => (this.contentEl = el) }, hAsync("slot", null)));
+    const iconStartEl = (hAsync("calcite-icon", { class: { [CSS$_.icon]: true, [CSS$_.iconStart]: true }, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, scale: this.scale === "l" ? "m" : "s" }));
+    const iconEndEl = (hAsync("calcite-icon", { class: { [CSS$_.icon]: true, [CSS$_.iconEnd]: true }, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, scale: this.scale === "l" ? "m" : "s" }));
+    const contentEl = (hAsync("span", { class: CSS$_.content, ref: (el) => (this.contentEl = el) }, hAsync("slot", null)));
     return (hAsync(Tag, { "aria-label": getLabelText(this), class: {
-        [CSS$Z.buttonPadding]: noStartEndIcons,
-        [CSS$Z.buttonPaddingShrunk]: !noStartEndIcons,
-        [CSS$Z.contentSlotted]: this.hasContent,
-        [CSS$Z.iconStartEmpty]: !this.iconStart,
-        [CSS$Z.iconEndEmpty]: !this.iconEnd
+        [CSS$_.buttonPadding]: noStartEndIcons,
+        [CSS$_.buttonPaddingShrunk]: !noStartEndIcons,
+        [CSS$_.contentSlotted]: this.hasContent,
+        [CSS$_.iconStartEmpty]: !this.iconStart,
+        [CSS$_.iconEndEmpty]: !this.iconEnd
       }, disabled: this.disabled || this.loading, href: childElType === "a" && this.href, name: childElType === "button" && this.name, onClick: this.handleClick, ref: this.setChildEl, rel: childElType === "a" && this.rel, tabIndex: this.disabled || this.loading ? -1 : null, target: childElType === "a" && this.target, title: this.tooltipText, type: childElType === "button" && this.type }, loaderNode, this.iconStart ? iconStartEl : null, this.hasContent ? contentEl : null, this.iconEnd ? iconEndEl : null));
   }
   //--------------------------------------------------------------------------
@@ -11995,7 +11995,7 @@ class CalciteMenu {
   }; }
 }
 
-const CSS$Y = {
+const CSS$Z = {
   container: "container",
   content: "content",
   dropdownVertical: "dropdown--vertical",
@@ -12199,52 +12199,52 @@ class CalciteMenuItem {
   //
   //--------------------------------------------------------------------------
   renderIconStart() {
-    return (hAsync("calcite-icon", { class: `${CSS$Y.icon} ${CSS$Y.iconStart}`, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, key: CSS$Y.iconStart, scale: "s" }));
+    return (hAsync("calcite-icon", { class: `${CSS$Z.icon} ${CSS$Z.iconStart}`, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, key: CSS$Z.iconStart, scale: "s" }));
   }
   renderIconEnd() {
-    return (hAsync("calcite-icon", { class: `${CSS$Y.icon} ${CSS$Y.iconEnd}`, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, key: CSS$Y.iconEnd, scale: "s" }));
+    return (hAsync("calcite-icon", { class: `${CSS$Z.icon} ${CSS$Z.iconEnd}`, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, key: CSS$Z.iconEnd, scale: "s" }));
   }
   renderBreadcrumbIcon(dir) {
-    return (hAsync("calcite-icon", { class: `${CSS$Y.icon} ${CSS$Y.iconBreadcrumb}`, icon: dir === "rtl" ? "chevron-left" : "chevron-right", key: CSS$Y.iconBreadcrumb, scale: "s" }));
+    return (hAsync("calcite-icon", { class: `${CSS$Z.icon} ${CSS$Z.iconBreadcrumb}`, icon: dir === "rtl" ? "chevron-left" : "chevron-right", key: CSS$Z.iconBreadcrumb, scale: "s" }));
   }
   renderDropdownIcon(dir) {
     const dirChevron = dir === "rtl" ? "chevron-left" : "chevron-right";
-    return (hAsync("calcite-icon", { class: `${CSS$Y.icon} ${CSS$Y.iconDropdown}`, icon: this.topLevelMenuLayout === "vertical" || this.isTopLevelItem
+    return (hAsync("calcite-icon", { class: `${CSS$Z.icon} ${CSS$Z.iconDropdown}`, icon: this.topLevelMenuLayout === "vertical" || this.isTopLevelItem
         ? this.open
           ? "chevron-up"
           : "chevron-down"
-        : dirChevron, key: CSS$Y.iconDropdown, scale: "s" }));
+        : dirChevron, key: CSS$Z.iconDropdown, scale: "s" }));
   }
   renderDropdownAction(dir) {
     const dirChevron = dir === "rtl" ? "chevron-left" : "chevron-right";
-    return (hAsync("calcite-action", { class: CSS$Y.dropdownAction, icon: this.topLevelMenuLayout === "vertical" || this.isTopLevelItem
+    return (hAsync("calcite-action", { class: CSS$Z.dropdownAction, icon: this.topLevelMenuLayout === "vertical" || this.isTopLevelItem
         ? this.open
           ? "chevron-up"
           : "chevron-down"
-        : dirChevron, key: CSS$Y.dropdownAction, onClick: this.clickHandler, onKeyDown: this.keyDownHandler, text: this.messages.open,
+        : dirChevron, key: CSS$Z.dropdownAction, onClick: this.clickHandler, onKeyDown: this.keyDownHandler, text: this.messages.open,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.dropdownActionEl = el) }));
   }
   renderSubmenuItems(dir) {
     return (hAsync("calcite-menu", { class: {
-        [CSS$Y.dropdownMenuItems]: true,
-        [CSS$Y.open]: this.open,
-        [CSS$Y.nested]: !this.isTopLevelItem,
+        [CSS$Z.dropdownMenuItems]: true,
+        [CSS$Z.open]: this.open,
+        [CSS$Z.nested]: !this.isTopLevelItem,
         [CSS_UTILITY.rtl]: dir === "rtl",
-        [CSS$Y.dropdownVertical]: this.topLevelMenuLayout === "vertical"
+        [CSS$Z.dropdownVertical]: this.topLevelMenuLayout === "vertical"
       }, label: this.messages.submenu, layout: "vertical", role: "menu" }, hAsync("slot", { name: "submenu-item", onSlotchange: this.handleMenuItemSlotChange })));
   }
   renderItemContent(dir) {
-    return (hAsync(Fragment, null, this.iconStart && this.renderIconStart(), hAsync("div", { class: CSS$Y.textContainer }, hAsync("span", null, this.text)), !this.href && this.hasSubmenu ? this.renderDropdownIcon(dir) : null, this.breadcrumb ? this.renderBreadcrumbIcon(dir) : null, this.iconEnd && this.renderIconEnd()));
+    return (hAsync(Fragment, null, this.iconStart && this.renderIconStart(), hAsync("div", { class: CSS$Z.textContainer }, hAsync("span", null, this.text)), !this.href && this.hasSubmenu ? this.renderDropdownIcon(dir) : null, this.breadcrumb ? this.renderBreadcrumbIcon(dir) : null, this.iconEnd && this.renderIconEnd()));
   }
   render() {
     const dir = getElementDir(this.el);
     return (hAsync(Host, { onBlur: this.blurHandler, onFocus: this.focusHandler }, hAsync("li", { class: {
-        [CSS$Y.container]: true,
-        [CSS$Y.isParentVertical]: this.topLevelMenuLayout === "vertical"
-      }, role: "none" }, hAsync("div", { class: CSS$Y.itemContent }, hAsync("a", { "aria-current": this.isFocused ? "page" : false, "aria-expanded": this.open, "aria-haspopup": this.hasSubmenu, "aria-label": this.label, class: { [CSS$Y.layoutVertical]: this.layout === "vertical", [CSS$Y.content]: true }, href: this.href, onClick: this.clickHandler, onKeyDown: this.keyDownHandler, rel: this.rel, role: "menuitem", tabIndex: this.isTopLevelItem ? 0 : -1, target: this.target,
+        [CSS$Z.container]: true,
+        [CSS$Z.isParentVertical]: this.topLevelMenuLayout === "vertical"
+      }, role: "none" }, hAsync("div", { class: CSS$Z.itemContent }, hAsync("a", { "aria-current": this.isFocused ? "page" : false, "aria-expanded": this.open, "aria-haspopup": this.hasSubmenu, "aria-label": this.label, class: { [CSS$Z.layoutVertical]: this.layout === "vertical", [CSS$Z.content]: true }, href: this.href, onClick: this.clickHandler, onKeyDown: this.keyDownHandler, rel: this.rel, role: "menuitem", tabIndex: this.isTopLevelItem ? 0 : -1, target: this.target,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (el) => (this.anchorEl = el) }, this.renderItemContent(dir), this.href && (this.topLevelMenuLayout === "vertical" || !this.isTopLevelItem) ? (hAsync("calcite-icon", { class: CSS$Y.hoverHrefIcon, icon: dir === "rtl" ? "arrow-left" : "arrow-right", scale: "s" })) : null), this.href && this.hasSubmenu ? this.renderDropdownAction(dir) : null), this.renderSubmenuItems(dir))));
+      ref: (el) => (this.anchorEl = el) }, this.renderItemContent(dir), this.href && (this.topLevelMenuLayout === "vertical" || !this.isTopLevelItem) ? (hAsync("calcite-icon", { class: CSS$Z.hoverHrefIcon, icon: dir === "rtl" ? "arrow-left" : "arrow-right", scale: "s" })) : null), this.href && this.hasSubmenu ? this.renderDropdownAction(dir) : null), this.renderSubmenuItems(dir))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -12285,7 +12285,7 @@ class CalciteMenuItem {
   }; }
 }
 
-const CSS$X = {
+const CSS$Y = {
   container: "container",
   containerContent: "container-content",
   hasProgress: "progress-bar",
@@ -12434,11 +12434,11 @@ class CalciteNavigation {
       this.navigationAction;
     const slotName = this.el.slot;
     return (hAsync(Host, null, hAsync("div", { class: {
-        [CSS$X.container]: true,
-        [CSS$X.secondary]: slotName === SLOTS$p.navSecondary,
-        [CSS$X.tertiary]: slotName === SLOTS$p.navTertiary,
-        [CSS$X.primary]: primaryLevelHasElements
-      } }, hAsync("div", { class: { [CSS$X.hide]: !this.progressSlotHasElement, [SLOTS$p.progress]: true } }, hAsync("slot", { name: SLOTS$p.progress, onSlotchange: this.handleProgressSlotChange })), hAsync("div", { class: { [CSS$X.containerContent]: true, [CSS$X.hasProgress]: this.progressSlotHasElement } }, this.renderMenuAction(), hAsync("div", { class: { [CSS$X.hide]: !this.logoSlotHasElements, [SLOTS$p.logo]: true } }, hAsync("slot", { name: SLOTS$p.logo, onSlotchange: this.handleLogoSlotChange })), hAsync("slot", { name: SLOTS$p.contentStart, onSlotchange: this.handleContentStartSlotChange }), hAsync("slot", { name: SLOTS$p.contentCenter, onSlotchange: this.handleContentCenterSlotChange }), hAsync("slot", { name: SLOTS$p.contentEnd, onSlotchange: this.handleContentEndSlotChange }), hAsync("div", { class: { [CSS$X.hide]: !this.userSlotHasElements, [SLOTS$p.user]: true } }, hAsync("slot", { name: SLOTS$p.user, onSlotchange: this.handleUserSlotChange })))), hAsync(Fragment, null, hAsync("slot", { name: SLOTS$p.navSecondary, onSlotchange: this.handleSecondarySlotChange }), hAsync("slot", { name: SLOTS$p.navTertiary, onSlotchange: this.handleTertiarySlotChange }))));
+        [CSS$Y.container]: true,
+        [CSS$Y.secondary]: slotName === SLOTS$p.navSecondary,
+        [CSS$Y.tertiary]: slotName === SLOTS$p.navTertiary,
+        [CSS$Y.primary]: primaryLevelHasElements
+      } }, hAsync("div", { class: { [CSS$Y.hide]: !this.progressSlotHasElement, [SLOTS$p.progress]: true } }, hAsync("slot", { name: SLOTS$p.progress, onSlotchange: this.handleProgressSlotChange })), hAsync("div", { class: { [CSS$Y.containerContent]: true, [CSS$Y.hasProgress]: this.progressSlotHasElement } }, this.renderMenuAction(), hAsync("div", { class: { [CSS$Y.hide]: !this.logoSlotHasElements, [SLOTS$p.logo]: true } }, hAsync("slot", { name: SLOTS$p.logo, onSlotchange: this.handleLogoSlotChange })), hAsync("slot", { name: SLOTS$p.contentStart, onSlotchange: this.handleContentStartSlotChange }), hAsync("slot", { name: SLOTS$p.contentCenter, onSlotchange: this.handleContentCenterSlotChange }), hAsync("slot", { name: SLOTS$p.contentEnd, onSlotchange: this.handleContentEndSlotChange }), hAsync("div", { class: { [CSS$Y.hide]: !this.userSlotHasElements, [SLOTS$p.user]: true } }, hAsync("slot", { name: SLOTS$p.user, onSlotchange: this.handleUserSlotChange })))), hAsync(Fragment, null, hAsync("slot", { name: SLOTS$p.navSecondary, onSlotchange: this.handleSecondarySlotChange }), hAsync("slot", { name: SLOTS$p.navTertiary, onSlotchange: this.handleTertiarySlotChange }))));
   }
   get el() { return getElement(this); }
   static get style() { return navigationCss; }
@@ -12465,7 +12465,7 @@ class CalciteNavigation {
   }; }
 }
 
-const CSS$W = {
+const CSS$X = {
   container: "container",
   heading: "heading",
   description: "description",
@@ -12517,7 +12517,7 @@ class CalciteNavigationLogo {
   // --------------------------------------------------------------------------
   render() {
     const { heading, description, thumbnail } = this;
-    return (hAsync(Host, null, hAsync("a", { class: CSS$W.anchor, href: this.href, rel: this.rel, target: this.target }, thumbnail && hAsync("img", { alt: this.label || "", class: CSS$W.image, src: thumbnail }), (heading || description) && (hAsync("div", { class: CSS$W.container }, heading && (hAsync("span", { "aria-label": this.heading, class: CSS$W.heading, key: CSS$W.heading }, heading)), description && (hAsync("span", { "aria-label": this.description, class: CSS$W.description, key: CSS$W.description }, description)))))));
+    return (hAsync(Host, null, hAsync("a", { class: CSS$X.anchor, href: this.href, rel: this.rel, target: this.target }, thumbnail && hAsync("img", { alt: this.label || "", class: CSS$X.image, src: thumbnail }), (heading || description) && (hAsync("div", { class: CSS$X.container }, heading && (hAsync("span", { "aria-label": this.heading, class: CSS$X.heading, key: CSS$X.heading }, heading)), description && (hAsync("span", { "aria-label": this.description, class: CSS$X.description, key: CSS$X.description }, description)))))));
   }
   static get delegatesFocus() { return true; }
   get el() { return getElement(this); }
@@ -12542,7 +12542,7 @@ class CalciteNavigationLogo {
   }; }
 }
 
-const CSS$V = {
+const CSS$W = {
   textContainer: "text-container",
   fullName: "full-name",
   username: "username",
@@ -12589,7 +12589,7 @@ class CalciteNavigationUser {
   //
   // --------------------------------------------------------------------------
   render() {
-    return (hAsync(Host, null, hAsync("button", { "aria-label": this.label, class: CSS$V.button }, hAsync("calcite-avatar", { "full-name": this.fullName, label: this.label, thumbnail: this.thumbnail, "user-id": this.userId, username: this.username }), (this.fullName || this.username) && !this.textDisabled && (hAsync("div", { class: CSS$V.textContainer }, this.fullName && (hAsync("span", { class: CSS$V.fullName, key: CSS$V.fullName }, this.fullName)), this.username && (hAsync("span", { class: CSS$V.username, key: CSS$V.username }, this.username)))))));
+    return (hAsync(Host, null, hAsync("button", { "aria-label": this.label, class: CSS$W.button }, hAsync("calcite-avatar", { "full-name": this.fullName, label: this.label, thumbnail: this.thumbnail, "user-id": this.userId, username: this.username }), (this.fullName || this.username) && !this.textDisabled && (hAsync("div", { class: CSS$W.textContainer }, this.fullName && (hAsync("span", { class: CSS$W.fullName, key: CSS$W.fullName }, this.fullName)), this.username && (hAsync("span", { class: CSS$W.username, key: CSS$W.username }, this.username)))))));
   }
   static get delegatesFocus() { return true; }
   get el() { return getElement(this); }
@@ -12613,7 +12613,7 @@ class CalciteNavigationUser {
   }; }
 }
 
-const CSS$U = {
+const CSS$V = {
   container: "container",
   header: "header",
   footer: "footer",
@@ -12698,7 +12698,7 @@ class Card {
   render() {
     const thumbnailInline = this.thumbnailPosition.startsWith("inline");
     const thumbnailStart = this.thumbnailPosition.endsWith("start");
-    return (hAsync("div", { class: { "calcite-card-container": true, inline: thumbnailInline } }, this.loading ? (hAsync("div", { class: "calcite-card-loader-container" }, hAsync("calcite-loader", { label: this.messages.loading }))) : null, thumbnailStart && this.renderThumbnail(), hAsync("section", { "aria-busy": toAriaBoolean(this.loading), class: { [CSS$U.container]: true } }, this.selectable ? this.renderCheckbox() : null, this.renderHeader(), hAsync("div", { class: "card-content" }, hAsync("slot", null)), this.renderFooter()), !thumbnailStart && this.renderThumbnail()));
+    return (hAsync("div", { class: { "calcite-card-container": true, inline: thumbnailInline } }, this.loading ? (hAsync("div", { class: "calcite-card-loader-container" }, hAsync("calcite-loader", { label: this.messages.loading }))) : null, thumbnailStart && this.renderThumbnail(), hAsync("section", { "aria-busy": toAriaBoolean(this.loading), class: { [CSS$V.container]: true } }, this.selectable ? this.renderCheckbox() : null, this.renderHeader(), hAsync("div", { class: "card-content" }, hAsync("slot", null)), this.renderFooter()), !thumbnailStart && this.renderThumbnail()));
   }
   effectiveLocaleChange() {
     updateMessages(this);
@@ -12708,24 +12708,24 @@ class Card {
     this.calciteCardSelect.emit();
   }
   renderThumbnail() {
-    return getSlotted(this.el, SLOTS$o.thumbnail) ? (hAsync("section", { class: CSS$U.thumbnailWrapper }, hAsync("slot", { name: SLOTS$o.thumbnail }))) : null;
+    return getSlotted(this.el, SLOTS$o.thumbnail) ? (hAsync("section", { class: CSS$V.thumbnailWrapper }, hAsync("slot", { name: SLOTS$o.thumbnail }))) : null;
   }
   renderCheckbox() {
-    return (hAsync("calcite-label", { class: CSS$U.checkboxWrapper, onClick: this.cardSelectClick, onKeyDown: this.cardSelectKeyDown }, hAsync("calcite-checkbox", { checked: this.selected, label: this.messages.select })));
+    return (hAsync("calcite-label", { class: CSS$V.checkboxWrapper, onClick: this.cardSelectClick, onKeyDown: this.cardSelectKeyDown }, hAsync("calcite-checkbox", { checked: this.selected, label: this.messages.select })));
   }
   renderHeader() {
     const { el } = this;
     const title = getSlotted(el, SLOTS$o.title);
     const subtitle = getSlotted(el, SLOTS$o.subtitle);
     const hasHeader = title || subtitle;
-    return hasHeader ? (hAsync("header", { class: CSS$U.header }, hAsync("slot", { name: SLOTS$o.title }), hAsync("slot", { name: SLOTS$o.subtitle }))) : null;
+    return hasHeader ? (hAsync("header", { class: CSS$V.header }, hAsync("slot", { name: SLOTS$o.title }), hAsync("slot", { name: SLOTS$o.subtitle }))) : null;
   }
   renderFooter() {
     const { el } = this;
     const startFooter = getSlotted(el, SLOTS$o.footerStart);
     const endFooter = getSlotted(el, SLOTS$o.footerEnd);
     const hasFooter = startFooter || endFooter;
-    return hasFooter ? (hAsync("footer", { class: CSS$U.footer }, hAsync("slot", { name: SLOTS$o.footerStart }), hAsync("slot", { name: SLOTS$o.footerEnd }))) : null;
+    return hasFooter ? (hAsync("footer", { class: CSS$V.footer }, hAsync("slot", { name: SLOTS$o.footerStart }), hAsync("slot", { name: SLOTS$o.footerEnd }))) : null;
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -12891,7 +12891,7 @@ class Checkbox {
   }; }
 }
 
-const CSS$T = {
+const CSS$U = {
   title: "title",
   close: "close",
   imageContainer: "image-container",
@@ -13060,7 +13060,7 @@ class Chip {
   //
   //--------------------------------------------------------------------------
   renderChipImage() {
-    return (hAsync("div", { class: CSS$T.imageContainer }, hAsync("slot", { name: SLOTS$n.image, onSlotchange: this.handleSlotImageChange })));
+    return (hAsync("div", { class: CSS$U.imageContainer }, hAsync("slot", { name: SLOTS$n.image, onSlotchange: this.handleSlotImageChange })));
   }
   renderSelectionIcon() {
     const icon = this.selectionMode === "multiple" && this.selected
@@ -13071,17 +13071,17 @@ class Chip {
           ? ICONS$d.checkedSingle
           : undefined;
     return (hAsync("div", { class: {
-        [CSS$T.selectIcon]: true,
-        [CSS$T.selectIconActive]: this.selectionMode === "multiple" || this.selected
+        [CSS$U.selectIcon]: true,
+        [CSS$U.selectIconActive]: this.selectionMode === "multiple" || this.selected
       } }, hAsync("calcite-icon", { icon: icon, scale: this.scale === "l" ? "m" : "s" })));
   }
   renderCloseButton() {
-    return (hAsync("button", { "aria-label": this.messages.dismissLabel, class: CSS$T.close, onClick: this.close, onKeyDown: this.closeButtonKeyDownHandler, tabIndex: this.disabled ? -1 : 0,
+    return (hAsync("button", { "aria-label": this.messages.dismissLabel, class: CSS$U.close, onClick: this.close, onKeyDown: this.closeButtonKeyDownHandler, tabIndex: this.disabled ? -1 : 0,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.closeButtonEl = el) }, hAsync("calcite-icon", { icon: ICONS$d.close, scale: this.scale === "l" ? "m" : "s" })));
   }
   renderIcon() {
-    return (hAsync("calcite-icon", { class: CSS$T.chipIcon, flipRtl: this.iconFlipRtl, icon: this.icon, scale: this.scale === "l" ? "m" : "s" }));
+    return (hAsync("calcite-icon", { class: CSS$U.chipIcon, flipRtl: this.iconFlipRtl, icon: this.icon, scale: this.scale === "l" ? "m" : "s" }));
   }
   render() {
     const disableInteraction = this.disabled || (!this.disabled && !this.interactive);
@@ -13095,21 +13095,21 @@ class Chip {
     return (hAsync(Host, null, hAsync("div", { "aria-checked": this.selectionMode !== "none" && this.interactive
         ? toAriaBoolean(this.selected)
         : undefined, "aria-disabled": disableInteraction ? toAriaBoolean(this.disabled) : undefined, "aria-label": this.label, class: {
-        [CSS$T.container]: true,
-        [CSS$T.textSlotted]: this.hasText,
-        [CSS$T.imageSlotted]: this.hasImage,
-        [CSS$T.selectable]: this.selectionMode !== "none",
-        [CSS$T.multiple]: this.selectionMode === "multiple",
-        [CSS$T.closable]: this.closable,
-        [CSS$T.nonInteractive]: !this.interactive,
-        [CSS$T.isCircle]: !this.closable &&
+        [CSS$U.container]: true,
+        [CSS$U.textSlotted]: this.hasText,
+        [CSS$U.imageSlotted]: this.hasImage,
+        [CSS$U.selectable]: this.selectionMode !== "none",
+        [CSS$U.multiple]: this.selectionMode === "multiple",
+        [CSS$U.closable]: this.closable,
+        [CSS$U.nonInteractive]: !this.interactive,
+        [CSS$U.isCircle]: !this.closable &&
           !this.hasText &&
           (!this.icon || !this.hasImage) &&
           (this.selectionMode === "none" ||
             (!!this.selectionMode && this.selectionMode !== "multiple" && !this.selected))
       }, onClick: this.handleEmittingEvent, role: role, tabIndex: disableInteraction ? -1 : 0,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (el) => (this.containerEl = el) }, this.selectionMode !== "none" && this.renderSelectionIcon(), this.renderChipImage(), this.icon && this.renderIcon(), hAsync("span", { class: CSS$T.title }, hAsync("slot", null)), this.closable && this.renderCloseButton())));
+      ref: (el) => (this.containerEl = el) }, this.selectionMode !== "none" && this.renderSelectionIcon(), this.renderChipImage(), this.icon && this.renderIcon(), hAsync("span", { class: CSS$U.title }, hAsync("slot", null)), this.closable && this.renderCloseButton())));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -15434,7 +15434,7 @@ function zeroArray(array, length) {
 
 var color = Color;
 
-const CSS$S = {
+const CSS$T = {
   channel: "channel",
   channels: "channels",
   colorField: "color-field",
@@ -15754,7 +15754,7 @@ class ColorPicker {
       const { channelMode: activeChannelMode, messages } = this;
       const selected = channelMode === activeChannelMode;
       const label = channelMode === "rgb" ? messages.rgb : messages.hsv;
-      return (hAsync("calcite-tab-title", { class: CSS$S.colorMode, "data-color-mode": channelMode, key: channelMode, onCalciteTabsActivate: this.handleTabActivate, selected: selected }, label));
+      return (hAsync("calcite-tab-title", { class: CSS$T.colorMode, "data-color-mode": channelMode, key: channelMode, onCalciteTabsActivate: this.handleTabActivate, selected: selected }, label));
     };
     this.renderChannelsTab = (channelMode) => {
       const { allowEmpty, channelMode: activeChannelMode, channels, messages, alphaChannel } = this;
@@ -15765,7 +15765,7 @@ class ColorPicker {
         : [messages.hue, messages.saturation, messages.value];
       const direction = getElementDir(this.el);
       const channelsToRender = alphaChannel ? channels : channels.slice(0, 3);
-      return (hAsync("calcite-tab", { class: CSS$S.control, key: channelMode, selected: selected }, hAsync("div", { class: CSS$S.channels, dir: "ltr" }, channelsToRender.map((channelValue, index) => {
+      return (hAsync("calcite-tab", { class: CSS$T.control, key: channelMode, selected: selected }, hAsync("div", { class: CSS$T.channels, dir: "ltr" }, channelsToRender.map((channelValue, index) => {
         const isAlphaChannel = index === 3;
         if (isAlphaChannel) {
           channelValue =
@@ -15776,7 +15776,7 @@ class ColorPicker {
       }))));
     };
     this.renderChannel = (value, index, ariaLabel, direction, suffix) => {
-      return (hAsync("calcite-input", { class: CSS$S.channel, "data-channel-index": index, dir: direction, key: index, label: ariaLabel, lang: this.effectiveLocale, numberButtonType: "none", numberingSystem: this.numberingSystem, onCalciteInputChange: this.handleChannelChange, onCalciteInputInput: this.handleChannelInput, onKeyDown: this.handleKeyDown, scale: this.scale === "l" ? "m" : "s",
+      return (hAsync("calcite-input", { class: CSS$T.channel, "data-channel-index": index, dir: direction, key: index, label: ariaLabel, lang: this.effectiveLocale, numberButtonType: "none", numberingSystem: this.numberingSystem, onCalciteInputChange: this.handleChannelChange, onCalciteInputInput: this.handleChannelInput, onKeyDown: this.handleKeyDown, scale: this.scale === "l" ? "m" : "s",
         // workaround to ensure input borders overlap as desired
         // this is because the build transforms margin-left to its
         // logical-prop, which is undesired as channels are always ltr
@@ -15961,7 +15961,7 @@ class ColorPicker {
     this.shiftKeyChannelAdjustment = 0;
     const { key } = event;
     if ((key !== "ArrowUp" && key !== "ArrowDown") ||
-      !event.composedPath().some((node) => node.classList?.contains(CSS$S.channel))) {
+      !event.composedPath().some((node) => node.classList?.contains(CSS$T.channel))) {
       return;
     }
     const { shiftKey } = event;
@@ -16048,26 +16048,26 @@ class ColorPicker {
     const noHex = hexDisabled || hideHex;
     const noChannels = channelsDisabled || hideChannels;
     const noSaved = savedDisabled || hideSaved;
-    return (hAsync("div", { class: CSS$S.container }, hAsync("div", { class: CSS$S.controlAndScope }, hAsync("canvas", { class: CSS$S.colorField, onPointerDown: this.handleColorFieldPointerDown,
+    return (hAsync("div", { class: CSS$T.container }, hAsync("div", { class: CSS$T.controlAndScope }, hAsync("canvas", { class: CSS$T.colorField, onPointerDown: this.handleColorFieldPointerDown,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.initColorField }), hAsync("div", { "aria-label": vertical ? messages.value : messages.saturation, "aria-valuemax": vertical ? HSV_LIMITS.v : HSV_LIMITS.s, "aria-valuemin": "0", "aria-valuenow": (vertical ? color?.saturationv() : color?.value()) || "0", class: { [CSS$S.scope]: true, [CSS$S.colorFieldScope]: true }, onKeyDown: this.handleColorFieldScopeKeyDown, role: "slider", style: { top: `${colorFieldScopeTop || 0}px`, left: `${colorFieldScopeLeft || 0}px` }, tabindex: "0",
+      ref: this.initColorField }), hAsync("div", { "aria-label": vertical ? messages.value : messages.saturation, "aria-valuemax": vertical ? HSV_LIMITS.v : HSV_LIMITS.s, "aria-valuemin": "0", "aria-valuenow": (vertical ? color?.saturationv() : color?.value()) || "0", class: { [CSS$T.scope]: true, [CSS$T.colorFieldScope]: true }, onKeyDown: this.handleColorFieldScopeKeyDown, role: "slider", style: { top: `${colorFieldScopeTop || 0}px`, left: `${colorFieldScopeLeft || 0}px` }, tabindex: "0",
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.storeColorFieldScope })), hAsync("div", { class: CSS$S.previewAndSliders }, hAsync("calcite-color-picker-swatch", { class: CSS$S.preview, color: selectedColorInHex, scale: "l" }), hAsync("div", { class: CSS$S.sliders }, hAsync("div", { class: CSS$S.controlAndScope }, hAsync("canvas", { class: { [CSS$S.slider]: true, [CSS$S.hueSlider]: true }, onPointerDown: this.handleHueSliderPointerDown,
+      ref: this.storeColorFieldScope })), hAsync("div", { class: CSS$T.previewAndSliders }, hAsync("calcite-color-picker-swatch", { class: CSS$T.preview, color: selectedColorInHex, scale: "l" }), hAsync("div", { class: CSS$T.sliders }, hAsync("div", { class: CSS$T.controlAndScope }, hAsync("canvas", { class: { [CSS$T.slider]: true, [CSS$T.hueSlider]: true }, onPointerDown: this.handleHueSliderPointerDown,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.initHueSlider }), hAsync("div", { "aria-label": messages.hue, "aria-valuemax": HSV_LIMITS.h, "aria-valuemin": "0", "aria-valuenow": color?.round().hue() || DEFAULT_COLOR$1.round().hue(), class: { [CSS$S.scope]: true, [CSS$S.hueScope]: true }, onKeyDown: this.handleHueScopeKeyDown, role: "slider", style: { top: `${hueTop}px`, left: `${hueLeft}px` }, tabindex: "0",
+      ref: this.initHueSlider }), hAsync("div", { "aria-label": messages.hue, "aria-valuemax": HSV_LIMITS.h, "aria-valuemin": "0", "aria-valuenow": color?.round().hue() || DEFAULT_COLOR$1.round().hue(), class: { [CSS$T.scope]: true, [CSS$T.hueScope]: true }, onKeyDown: this.handleHueScopeKeyDown, role: "slider", style: { top: `${hueTop}px`, left: `${hueLeft}px` }, tabindex: "0",
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.storeHueScope })), alphaChannel ? (hAsync("div", { class: CSS$S.controlAndScope }, hAsync("canvas", { class: { [CSS$S.slider]: true, [CSS$S.opacitySlider]: true }, onPointerDown: this.handleOpacitySliderPointerDown,
+      ref: this.storeHueScope })), alphaChannel ? (hAsync("div", { class: CSS$T.controlAndScope }, hAsync("canvas", { class: { [CSS$T.slider]: true, [CSS$T.opacitySlider]: true }, onPointerDown: this.handleOpacitySliderPointerDown,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.initOpacitySlider }), hAsync("div", { "aria-label": messages.opacity, "aria-valuemax": OPACITY_LIMITS.max, "aria-valuemin": OPACITY_LIMITS.min, "aria-valuenow": (color || DEFAULT_COLOR$1).round().alpha(), class: { [CSS$S.scope]: true, [CSS$S.opacityScope]: true }, onKeyDown: this.handleOpacityScopeKeyDown, role: "slider", style: { top: `${opacityTop}px`, left: `${opacityLeft}px` }, tabindex: "0",
+      ref: this.initOpacitySlider }), hAsync("div", { "aria-label": messages.opacity, "aria-valuemax": OPACITY_LIMITS.max, "aria-valuemin": OPACITY_LIMITS.min, "aria-valuenow": (color || DEFAULT_COLOR$1).round().alpha(), class: { [CSS$T.scope]: true, [CSS$T.opacityScope]: true }, onKeyDown: this.handleOpacityScopeKeyDown, role: "slider", style: { top: `${opacityTop}px`, left: `${opacityLeft}px` }, tabindex: "0",
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.storeOpacityScope }))) : null)), noHex && noChannels ? null : (hAsync("div", { class: {
-        [CSS$S.controlSection]: true,
-        [CSS$S.section]: true
-      } }, hAsync("div", { class: CSS$S.hexAndChannelsGroup }, noHex ? null : (hAsync("div", { class: CSS$S.hexOptions }, hAsync("calcite-color-picker-hex-input", { allowEmpty: allowEmpty, alphaChannel: alphaChannel, class: CSS$S.control, messages: messages, numberingSystem: this.numberingSystem, onCalciteColorPickerHexInputChange: this.handleHexInputChange, scale: scale, value: selectedColorInHex }))), noChannels ? null : (hAsync("calcite-tabs", { class: {
-        [CSS$S.colorModeContainer]: true,
-        [CSS$S.splitSection]: true
-      }, scale: scale === "l" ? "m" : "s" }, hAsync("calcite-tab-nav", { slot: "title-group" }, this.renderChannelsTabTitle("rgb"), this.renderChannelsTabTitle("hsv")), this.renderChannelsTab("rgb"), this.renderChannelsTab("hsv")))))), noSaved ? null : (hAsync("div", { class: { [CSS$S.savedColorsSection]: true, [CSS$S.section]: true } }, hAsync("div", { class: CSS$S.header }, hAsync("label", null, messages.saved), hAsync("div", { class: CSS$S.savedColorsButtons }, hAsync("calcite-button", { appearance: "transparent", class: CSS$S.deleteColor, disabled: noColor, iconStart: "minus", kind: "neutral", label: messages.deleteColor, onClick: this.deleteColor, scale: scale, type: "button" }), hAsync("calcite-button", { appearance: "transparent", class: CSS$S.saveColor, disabled: noColor, iconStart: "plus", kind: "neutral", label: messages.saveColor, onClick: this.saveColor, scale: scale, type: "button" }))), savedColors.length > 0 ? (hAsync("div", { class: CSS$S.savedColors }, [
-      ...savedColors.map((color) => (hAsync("calcite-color-picker-swatch", { class: CSS$S.savedColor, color: color, key: color, onClick: this.handleSavedColorSelect, onKeyDown: this.handleSavedColorKeyDown, scale: scale, tabIndex: 0 })))
+        [CSS$T.controlSection]: true,
+        [CSS$T.section]: true
+      } }, hAsync("div", { class: CSS$T.hexAndChannelsGroup }, noHex ? null : (hAsync("div", { class: CSS$T.hexOptions }, hAsync("calcite-color-picker-hex-input", { allowEmpty: allowEmpty, alphaChannel: alphaChannel, class: CSS$T.control, messages: messages, numberingSystem: this.numberingSystem, onCalciteColorPickerHexInputChange: this.handleHexInputChange, scale: scale, value: selectedColorInHex }))), noChannels ? null : (hAsync("calcite-tabs", { class: {
+        [CSS$T.colorModeContainer]: true,
+        [CSS$T.splitSection]: true
+      }, scale: scale === "l" ? "m" : "s" }, hAsync("calcite-tab-nav", { slot: "title-group" }, this.renderChannelsTabTitle("rgb"), this.renderChannelsTabTitle("hsv")), this.renderChannelsTab("rgb"), this.renderChannelsTab("hsv")))))), noSaved ? null : (hAsync("div", { class: { [CSS$T.savedColorsSection]: true, [CSS$T.section]: true } }, hAsync("div", { class: CSS$T.header }, hAsync("label", null, messages.saved), hAsync("div", { class: CSS$T.savedColorsButtons }, hAsync("calcite-button", { appearance: "transparent", class: CSS$T.deleteColor, disabled: noColor, iconStart: "minus", kind: "neutral", label: messages.deleteColor, onClick: this.deleteColor, scale: scale, type: "button" }), hAsync("calcite-button", { appearance: "transparent", class: CSS$T.saveColor, disabled: noColor, iconStart: "plus", kind: "neutral", label: messages.saveColor, onClick: this.saveColor, scale: scale, type: "button" }))), savedColors.length > 0 ? (hAsync("div", { class: CSS$T.savedColors }, [
+      ...savedColors.map((color) => (hAsync("calcite-color-picker-swatch", { class: CSS$T.savedColor, color: color, key: color, onClick: this.handleSavedColorSelect, onKeyDown: this.handleSavedColorKeyDown, scale: scale, tabIndex: 0 })))
     ])) : null))));
   }
   // --------------------------------------------------------------------------
@@ -16418,7 +16418,7 @@ class ColorPicker {
   }; }
 }
 
-const CSS$R = {
+const CSS$S = {
   container: "container",
   hexInput: "hex-input",
   opacityInput: "opacity-input"
@@ -16587,9 +16587,9 @@ class ColorPickerHexInput {
     const hexInputValue = this.formatHexForInternalInput(value);
     const opacityInputValue = this.formatOpacityForInternalInput(internalColor);
     const inputScale = scale === "l" ? "m" : "s";
-    return (hAsync("div", { class: CSS$R.container }, hAsync("calcite-input", { class: CSS$R.hexInput, label: messages?.hex || hexLabel, maxLength: 6, numberingSystem: this.numberingSystem, onCalciteInputChange: this.onHexInputChange, onCalciteInternalInputBlur: this.onHexInputBlur, onKeyDown: this.onInputKeyDown, onPaste: this.onHexInputPaste, prefixText: "#", scale: inputScale, value: hexInputValue,
+    return (hAsync("div", { class: CSS$S.container }, hAsync("calcite-input", { class: CSS$S.hexInput, label: messages?.hex || hexLabel, maxLength: 6, numberingSystem: this.numberingSystem, onCalciteInputChange: this.onHexInputChange, onCalciteInternalInputBlur: this.onHexInputBlur, onKeyDown: this.onInputKeyDown, onPaste: this.onHexInputPaste, prefixText: "#", scale: inputScale, value: hexInputValue,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.storeHexInputRef }), alphaChannel ? (hAsync("calcite-input-number", { class: CSS$R.opacityInput, key: "opacity-input", label: messages?.opacity, max: OPACITY_LIMITS.max, maxLength: 3, min: OPACITY_LIMITS.min, numberButtonType: "none", numberingSystem: this.numberingSystem, onCalciteInputNumberChange: this.onOpacityInputChange, onCalciteInternalInputNumberBlur: this.onOpacityInputBlur, onKeyDown: this.onInputKeyDown, scale: inputScale, suffixText: "%", value: opacityInputValue,
+      ref: this.storeHexInputRef }), alphaChannel ? (hAsync("calcite-input-number", { class: CSS$S.opacityInput, key: "opacity-input", label: messages?.opacity, max: OPACITY_LIMITS.max, maxLength: 3, min: OPACITY_LIMITS.min, numberButtonType: "none", numberingSystem: this.numberingSystem, onCalciteInputNumberChange: this.onOpacityInputChange, onCalciteInternalInputNumberBlur: this.onOpacityInputBlur, onKeyDown: this.onInputKeyDown, scale: inputScale, suffixText: "%", value: opacityInputValue,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.storeOpacityInputRef })) : null));
   }
@@ -16685,7 +16685,7 @@ class ColorPickerHexInput {
   }; }
 }
 
-const CSS$Q = {
+const CSS$R = {
   swatch: "swatch",
   noColorSwatch: "swatch--no-color",
   checker: "checker"
@@ -16723,8 +16723,8 @@ class ColorPickerSwatch {
   render() {
     const isEmpty = !this.internalColor;
     const classes = {
-      [CSS$Q.swatch]: true,
-      [CSS$Q.noColorSwatch]: isEmpty
+      [CSS$R.swatch]: true,
+      [CSS$R.noColorSwatch]: isEmpty
     };
     return (hAsync("svg", { class: classes, xmlns: "http://www.w3.org/2000/svg" }, this.renderSwatch()));
   }
@@ -16750,7 +16750,7 @@ class ColorPickerSwatch {
     const alpha = internalColor.alpha();
     const hex = hexify(internalColor);
     const hexa = hexify(internalColor, alpha < 1);
-    return (hAsync(Fragment, null, hAsync("title", null, hexa), hAsync("defs", null, hAsync("pattern", { height: CHECKER_DIMENSIONS.size, id: "checker", patternUnits: "userSpaceOnUse", width: CHECKER_DIMENSIONS.size, x: "0", y: "0" }, hAsync("rect", { class: CSS$Q.checker, height: CHECKER_DIMENSIONS.squareSize, width: CHECKER_DIMENSIONS.squareSize, x: "0", y: "0" }), hAsync("rect", { class: CSS$Q.checker, height: CHECKER_DIMENSIONS.squareSize, width: CHECKER_DIMENSIONS.squareSize, x: CHECKER_DIMENSIONS.squareSize, y: CHECKER_DIMENSIONS.squareSize }))), hAsync("rect", { fill: "url(#checker)", height: "100%", rx: borderRadius, width: "100%" }), hAsync("rect", { fill: hex, style: {
+    return (hAsync(Fragment, null, hAsync("title", null, hexa), hAsync("defs", null, hAsync("pattern", { height: CHECKER_DIMENSIONS.size, id: "checker", patternUnits: "userSpaceOnUse", width: CHECKER_DIMENSIONS.size, x: "0", y: "0" }, hAsync("rect", { class: CSS$R.checker, height: CHECKER_DIMENSIONS.squareSize, width: CHECKER_DIMENSIONS.squareSize, x: "0", y: "0" }), hAsync("rect", { class: CSS$R.checker, height: CHECKER_DIMENSIONS.squareSize, width: CHECKER_DIMENSIONS.squareSize, x: CHECKER_DIMENSIONS.squareSize, y: CHECKER_DIMENSIONS.squareSize }))), hAsync("rect", { fill: "url(#checker)", height: "100%", rx: borderRadius, width: "100%" }), hAsync("rect", { fill: hex, style: {
         "clip-path": alpha < 1 ? "polygon(100% 0, 0 0, 0 100%)" : `inset(0 round ${borderRadius})`
       }, ...commonSwatchProps }), alpha < 1 ? (hAsync("rect", { fill: hexa, key: "opacity-fill", style: { "clip-path": "polygon(100% 0, 100% 100%, 0 100%)" }, ...commonSwatchProps })) : null));
   }
@@ -17660,19 +17660,6 @@ function getNodeName(node) {
   return isNode(node) ? (node.nodeName || '').toLowerCase() : '';
 }
 
-let uaString;
-function getUAString() {
-  if (uaString) {
-    return uaString;
-  }
-  const uaData = navigator.userAgentData;
-  if (uaData && Array.isArray(uaData.brands)) {
-    uaString = uaData.brands.map(item => item.brand + "/" + item.version).join(' ');
-    return uaString;
-  }
-  return navigator.userAgent;
-}
-
 function isHTMLElement(value) {
   return value instanceof getWindow(value).HTMLElement;
 }
@@ -17700,36 +17687,15 @@ function isTableElement(element) {
   return ['table', 'td', 'th'].includes(getNodeName(element));
 }
 function isContainingBlock(element) {
-  // TODO: Try to use feature detection here instead.
-  const isFirefox = /firefox/i.test(getUAString());
+  const safari = isSafari();
   const css = getComputedStyle$1(element);
-  const backdropFilter = css.backdropFilter || css.WebkitBackdropFilter;
 
-  // This is non-exhaustive but covers the most common CSS properties that
-  // create a containing block.
   // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  return css.transform !== 'none' || css.perspective !== 'none' || (backdropFilter ? backdropFilter !== 'none' : false) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective'].some(value => css.willChange.includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => {
-    // Add type check for old browsers.
-    const contain = css.contain;
-    return contain != null ? contain.includes(value) : false;
-  });
+  return css.transform !== 'none' || css.perspective !== 'none' || !safari && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !safari && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
 }
-
-/**
- * Determines whether or not `.getBoundingClientRect()` is affected by visual
- * viewport offsets. In Safari, the `x`/`y` offsets are values relative to the
- * visual viewport, while in other engines, they are values relative to the
- * layout viewport.
- */
-function isClientRectVisualViewportBased() {
-  // TODO: Try to use feature detection here instead. Feature detection for
-  // this can fail in various ways, making the userAgent check the most
-  // reliable:
-  // • Always-visible scrollbar or not
-  // • Width of <html>
-
-  // Is Safari.
-  return /^((?!chrome|android).)*safari/i.test(getUAString());
+function isSafari() {
+  if (typeof CSS === 'undefined' || !CSS.supports) return false;
+  return CSS.supports('-webkit-backdrop-filter', 'none');
 }
 function isLastTraversableNode(node) {
   return ['html', 'body', '#document'].includes(getNodeName(node));
@@ -17741,8 +17707,10 @@ const round = Math.round;
 
 function getCssDimensions(element) {
   const css = getComputedStyle$1(element);
-  let width = parseFloat(css.width);
-  let height = parseFloat(css.height);
+  // In testing environments, the `width` and `height` properties are empty
+  // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
   const hasOffset = isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
@@ -17794,8 +17762,29 @@ function getScale(element) {
   };
 }
 
-function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+const noOffsets = {
+  x: 0,
+  y: 0
+};
+function getVisualOffsets(element, isFixed, floatingOffsetParent) {
   var _win$visualViewport, _win$visualViewport2;
+  if (isFixed === void 0) {
+    isFixed = true;
+  }
+  if (!isSafari()) {
+    return noOffsets;
+  }
+  const win = element ? getWindow(element) : window;
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== win) {
+    return noOffsets;
+  }
+  return {
+    x: ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0,
+    y: ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0
+  };
+}
+
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
   if (includeScale === void 0) {
     includeScale = false;
   }
@@ -17814,10 +17803,9 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       scale = getScale(element);
     }
   }
-  const win = domElement ? getWindow(domElement) : window;
-  const addVisualOffsets = isClientRectVisualViewportBased() && isFixedStrategy;
-  let x = (clientRect.left + (addVisualOffsets ? ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0 : 0)) / scale.x;
-  let y = (clientRect.top + (addVisualOffsets ? ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0 : 0)) / scale.y;
+  const visualOffsets = getVisualOffsets(domElement, isFixedStrategy, offsetParent);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
   let width = clientRect.width / scale.x;
   let height = clientRect.height / scale.y;
   if (domElement) {
@@ -17987,7 +17975,7 @@ function getViewportRect(element, strategy) {
   if (visualViewport) {
     width = visualViewport.width;
     height = visualViewport.height;
-    const visualViewportBased = isClientRectVisualViewportBased();
+    const visualViewportBased = isSafari();
     if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
       x = visualViewport.offsetLeft;
       y = visualViewport.offsetTop;
@@ -18030,16 +18018,12 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
   } else if (isElement(clippingAncestor)) {
     rect = getInnerBoundingClientRect(clippingAncestor, strategy);
   } else {
-    const mutableRect = {
-      ...clippingAncestor
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      ...clippingAncestor,
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y
     };
-    if (isClientRectVisualViewportBased()) {
-      var _win$visualViewport, _win$visualViewport2;
-      const win = getWindow(element);
-      mutableRect.x -= ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0;
-      mutableRect.y -= ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0;
-    }
-    rect = mutableRect;
   }
   return rectToClientRect(rect);
 }
@@ -18158,7 +18142,8 @@ function getOffsetParent(element, polyfill) {
 function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
   const isOffsetParentAnElement = isHTMLElement(offsetParent);
   const documentElement = getDocumentElement(offsetParent);
-  const rect = getBoundingClientRect(element, true, strategy === 'fixed', offsetParent);
+  const isFixed = strategy === 'fixed';
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
   let scroll = {
     scrollLeft: 0,
     scrollTop: 0
@@ -18167,12 +18152,12 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
     x: 0,
     y: 0
   };
-  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
     if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
       scroll = getNodeScroll(offsetParent);
     }
     if (isHTMLElement(offsetParent)) {
-      const offsetRect = getBoundingClientRect(offsetParent, true);
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
       offsets.x = offsetRect.x + offsetParent.clientLeft;
       offsets.y = offsetRect.y + offsetParent.clientTop;
     } else if (documentElement) {
@@ -18505,7 +18490,7 @@ const defaultOffsetDistance = Math.ceil(Math.hypot(visiblePointerSize, visiblePo
 const ComboboxItem$1 = "CALCITE-COMBOBOX-ITEM";
 const ComboboxItemGroup$1 = "CALCITE-COMBOBOX-ITEM-GROUP";
 const ComboboxChildSelector = `${ComboboxItem$1}, ${ComboboxItemGroup$1}`;
-const CSS$P = {
+const CSS$Q = {
   listContainer: "list-container"
 };
 
@@ -18530,11 +18515,11 @@ function getDepth$1(element) {
   }
 }
 
-const CSS$O = {
+const CSS$P = {
   button: "x-button"
 };
 function XButton({ disabled, key, label, onClick, ref, scale }) {
-  return (hAsync("button", { "aria-label": label, class: CSS$O.button, disabled: disabled, key: key, onClick: onClick, tabIndex: -1, type: "button", 
+  return (hAsync("button", { "aria-label": label, class: CSS$P.button, disabled: disabled, key: key, onClick: onClick, tabIndex: -1, type: "button", 
     // eslint-disable-next-line react/jsx-sort-props
     ref: ref },
     hAsync("calcite-icon", { icon: "x", scale: scale === "l" ? "m" : "s" })));
@@ -18735,7 +18720,7 @@ class Combobox {
         event.preventDefault();
         return;
       }
-      if (composedPath.some((node) => node.classList?.contains(CSS$O.button))) {
+      if (composedPath.some((node) => node.classList?.contains(CSS$P.button))) {
         this.clearValue();
         event.preventDefault();
         return;
@@ -19331,7 +19316,7 @@ class Combobox {
   renderFloatingUIContainer() {
     const { setFloatingEl, setContainerEl, open } = this;
     const classes = {
-      [CSS$P.listContainer]: true,
+      [CSS$Q.listContainer]: true,
       [FloatingCSS.animation]: true,
       [FloatingCSS.animationActive]: open
     };
@@ -19428,7 +19413,7 @@ class Combobox {
   }; }
 }
 
-const CSS$N = {
+const CSS$O = {
   icon: "icon",
   iconActive: "icon--active",
   iconIndent: "icon--indent",
@@ -19505,20 +19490,20 @@ class ComboboxItem {
   // --------------------------------------------------------------------------
   renderIcon(iconPath) {
     return this.icon ? (hAsync("calcite-icon", { class: {
-        [CSS$N.custom]: !!this.icon,
-        [CSS$N.iconActive]: this.icon && this.selected,
-        [CSS$N.iconIndent]: true
+        [CSS$O.custom]: !!this.icon,
+        [CSS$O.iconActive]: this.icon && this.selected,
+        [CSS$O.iconIndent]: true
       }, flipRtl: this.iconFlipRtl, icon: this.icon || iconPath, key: "icon", scale: this.scale === "l" ? "m" : "s" })) : null;
   }
   renderSelectIndicator(showDot, iconPath) {
     return showDot ? (hAsync("span", { class: {
-        [CSS$N.icon]: true,
-        [CSS$N.dot]: true,
-        [CSS$N.iconIndent]: true
+        [CSS$O.icon]: true,
+        [CSS$O.dot]: true,
+        [CSS$O.iconIndent]: true
       } })) : (hAsync("calcite-icon", { class: {
-        [CSS$N.icon]: true,
-        [CSS$N.iconActive]: this.selected,
-        [CSS$N.iconIndent]: true
+        [CSS$O.icon]: true,
+        [CSS$O.iconActive]: this.selected,
+        [CSS$O.iconIndent]: true
       }, flipRtl: this.iconFlipRtl, icon: iconPath, key: "indicator", scale: this.scale === "l" ? "m" : "s" }));
   }
   renderChildren() {
@@ -19533,10 +19518,10 @@ class ComboboxItem {
     const defaultIcon = isSingleSelect ? "dot" : "check";
     const iconPath = this.disabled ? "circle-disallowed" : defaultIcon;
     const classes = {
-      [CSS$N.label]: true,
-      [CSS$N.selected]: this.selected,
-      [CSS$N.active]: this.active,
-      [CSS$N.single]: isSingleSelect
+      [CSS$O.label]: true,
+      [CSS$O.selected]: this.selected,
+      [CSS$O.active]: this.active,
+      [CSS$O.single]: isSingleSelect
     };
     const depth = getDepth$1();
     return (hAsync(Host, { "aria-hidden": "true" }, hAsync("div", { class: `container scale--${this.scale}`, style: { "--calcite-combobox-item-spacing-indent-multiplier": `${depth}` } }, hAsync("li", { class: classes, id: this.guid, onClick: this.itemClickHandler }, this.renderSelectIndicator(showDot, iconPath), this.renderIcon(iconPath), hAsync("span", { class: "title" }, this.textLabel)), this.renderChildren())));
@@ -19567,7 +19552,7 @@ class ComboboxItem {
   }; }
 }
 
-const CSS$M = {
+const CSS$N = {
   list: "list",
   label: "label",
   title: "title"
@@ -19603,7 +19588,7 @@ class ComboboxItemGroup {
   render() {
     const { el, scale } = this;
     const depth = getDepth$1();
-    return (hAsync("ul", { "aria-labelledby": this.guid, class: { [CSS$M.list]: true, [`scale--${scale}`]: true }, role: "group" }, hAsync("li", { class: { [CSS$M.label]: true }, id: this.guid, role: "presentation", style: { "--calcite-combobox-item-spacing-indent-multiplier": `${depth}` } }, hAsync("span", { class: CSS$M.title }, this.label)), hAsync("slot", null)));
+    return (hAsync("ul", { "aria-labelledby": this.guid, class: { [CSS$N.list]: true, [`scale--${scale}`]: true }, role: "group" }, hAsync("li", { class: { [CSS$N.label]: true }, id: this.guid, role: "presentation", style: { "--calcite-combobox-item-spacing-indent-multiplier": `${depth}` } }, hAsync("span", { class: CSS$N.title }, this.label)), hAsync("slot", null)));
   }
   get el() { return getElement(this); }
   static get style() { return comboboxItemGroupCss; }
@@ -20770,7 +20755,7 @@ class DatePickerMonth {
   }; }
 }
 
-const CSS$L = {
+const CSS$M = {
   header: "header",
   month: "month",
   chevron: "chevron",
@@ -20870,7 +20855,7 @@ class DatePickerMonthHeader {
     this.setNextPrevMonthDates();
   }
   render() {
-    return hAsync("div", { class: CSS$L.header }, this.renderContent());
+    return hAsync("div", { class: CSS$M.header }, this.renderContent());
   }
   renderContent() {
     const { messages, localeData, activeDate } = this;
@@ -20893,12 +20878,12 @@ class DatePickerMonthHeader {
     const order = getOrder(unitOrder);
     const reverse = order.indexOf("y") < order.indexOf("m");
     const suffix = localeData.year?.suffix;
-    return (hAsync(Fragment, null, hAsync("a", { "aria-disabled": `${this.prevMonthDate.getMonth() === activeMonth}`, "aria-label": messages.prevMonth, class: CSS$L.chevron, href: "#", onClick: this.prevMonthClick, onKeyDown: this.prevMonthKeydown, role: "button", tabindex: this.prevMonthDate.getMonth() === activeMonth ? -1 : 0 }, hAsync("calcite-icon", { "flip-rtl": true, icon: ICON.chevronLeft, scale: iconScale })), hAsync("div", { class: { text: true, [CSS$L.textReverse]: reverse } }, hAsync(Heading, { class: CSS$L.month, level: this.headingLevel }, localizedMonth), hAsync("span", { class: CSS$L.yearWrap }, hAsync("input", { "aria-label": messages.year, class: {
+    return (hAsync(Fragment, null, hAsync("a", { "aria-disabled": `${this.prevMonthDate.getMonth() === activeMonth}`, "aria-label": messages.prevMonth, class: CSS$M.chevron, href: "#", onClick: this.prevMonthClick, onKeyDown: this.prevMonthKeydown, role: "button", tabindex: this.prevMonthDate.getMonth() === activeMonth ? -1 : 0 }, hAsync("calcite-icon", { "flip-rtl": true, icon: ICON.chevronLeft, scale: iconScale })), hAsync("div", { class: { text: true, [CSS$M.textReverse]: reverse } }, hAsync(Heading, { class: CSS$M.month, level: this.headingLevel }, localizedMonth), hAsync("span", { class: CSS$M.yearWrap }, hAsync("input", { "aria-label": messages.year, class: {
         year: true,
-        [CSS$L.yearSuffix]: !!suffix
+        [CSS$M.yearSuffix]: !!suffix
       }, inputmode: "numeric", maxlength: "4", minlength: "1", onChange: this.onYearChange, onInput: this.onYearInput, onKeyDown: this.onYearKey, pattern: "\\d*", type: "text", value: localizedYear,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (el) => (this.yearInput = el) }), suffix && hAsync("span", { class: CSS$L.suffix }, suffix))), hAsync("a", { "aria-disabled": `${this.nextMonthDate.getMonth() === activeMonth}`, "aria-label": messages.nextMonth, class: CSS$L.chevron, href: "#", onClick: this.nextMonthClick, onKeyDown: this.nextMonthKeydown, role: "button", tabindex: this.nextMonthDate.getMonth() === activeMonth ? -1 : 0 }, hAsync("calcite-icon", { "flip-rtl": true, icon: ICON.chevronRight, scale: iconScale }))));
+      ref: (el) => (this.yearInput = el) }), suffix && hAsync("span", { class: CSS$M.suffix }, suffix))), hAsync("a", { "aria-disabled": `${this.nextMonthDate.getMonth() === activeMonth}`, "aria-label": messages.nextMonth, class: CSS$M.chevron, href: "#", onClick: this.nextMonthClick, onKeyDown: this.nextMonthKeydown, role: "button", tabindex: this.nextMonthDate.getMonth() === activeMonth ? -1 : 0 }, hAsync("calcite-icon", { "flip-rtl": true, icon: ICON.chevronRight, scale: iconScale }))));
   }
   setNextPrevMonthDates() {
     if (!this.activeDate) {
@@ -21393,7 +21378,7 @@ class Dropdown {
   }; }
 }
 
-const CSS$K = {
+const CSS$L = {
   containerSmall: "container--s",
   containerMedium: "container--m",
   containerLarge: "container--l"
@@ -21426,9 +21411,9 @@ class DropdownGroup {
     const dropdownSeparator = this.groupPosition > 0 ? hAsync("div", { class: "dropdown-separator", role: "separator" }) : null;
     return (hAsync(Host, { "aria-label": this.groupTitle, role: "group" }, hAsync("div", { class: {
         container: true,
-        [CSS$K.containerSmall]: scale === "s",
-        [CSS$K.containerMedium]: scale === "m",
-        [CSS$K.containerLarge]: scale === "l"
+        [CSS$L.containerSmall]: scale === "s",
+        [CSS$L.containerMedium]: scale === "m",
+        [CSS$L.containerLarge]: scale === "l"
       }, title: this.groupTitle }, dropdownSeparator, groupTitle, hAsync("slot", null))));
   }
   //--------------------------------------------------------------------------
@@ -21469,7 +21454,7 @@ class DropdownGroup {
   }; }
 }
 
-const CSS$J = {
+const CSS$K = {
   containerLink: "container--link",
   containerSmall: "container--s",
   containerMedium: "container--m",
@@ -21534,9 +21519,9 @@ class DropdownItem {
   }
   render() {
     const scale = getElementProp(this.el, "scale", this.scale);
-    const iconStartEl = (hAsync("calcite-icon", { class: CSS$J.iconStart, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, scale: scale === "l" ? "m" : "s" }));
-    const contentNode = (hAsync("span", { class: CSS$J.itemContent }, hAsync("slot", null)));
-    const iconEndEl = (hAsync("calcite-icon", { class: CSS$J.iconEnd, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, scale: scale === "l" ? "m" : "s" }));
+    const iconStartEl = (hAsync("calcite-icon", { class: CSS$K.iconStart, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, scale: scale === "l" ? "m" : "s" }));
+    const contentNode = (hAsync("span", { class: CSS$K.itemContent }, hAsync("slot", null)));
+    const iconEndEl = (hAsync("calcite-icon", { class: CSS$K.iconEnd, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, scale: scale === "l" ? "m" : "s" }));
     const slottedContent = this.iconStart && this.iconEnd
       ? [iconStartEl, contentNode, iconEndEl]
       : this.iconStart
@@ -21544,7 +21529,7 @@ class DropdownItem {
         : this.iconEnd
           ? [contentNode, iconEndEl]
           : contentNode;
-    const contentEl = !this.href ? (slottedContent) : (hAsync("a", { "aria-label": this.label, class: CSS$J.link, href: this.href, rel: this.rel, tabIndex: -1, target: this.target,
+    const contentEl = !this.href ? (slottedContent) : (hAsync("a", { "aria-label": this.label, class: CSS$K.link, href: this.href, rel: this.rel, tabIndex: -1, target: this.target,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.childLink = el) }, slottedContent));
     const itemRole = this.href
@@ -21557,14 +21542,14 @@ class DropdownItem {
     const itemAria = this.selectionMode !== "none" ? toAriaBoolean(this.selected) : null;
     return (hAsync(Host, { "aria-checked": itemAria, role: itemRole, tabindex: "0" }, hAsync("div", { class: {
         container: true,
-        [CSS$J.containerLink]: !!this.href,
-        [CSS$J.containerSmall]: scale === "s",
-        [CSS$J.containerMedium]: scale === "m",
-        [CSS$J.containerLarge]: scale === "l",
-        [CSS$J.containerMulti]: this.selectionMode === "multiple",
-        [CSS$J.containerSingle]: this.selectionMode === "single",
-        [CSS$J.containerNone]: this.selectionMode === "none"
-      } }, this.selectionMode !== "none" ? (hAsync("calcite-icon", { class: CSS$J.icon, icon: this.selectionMode === "multiple" ? "check" : "bullet-point", scale: scale === "l" ? "m" : "s" })) : null, contentEl)));
+        [CSS$K.containerLink]: !!this.href,
+        [CSS$K.containerSmall]: scale === "s",
+        [CSS$K.containerMedium]: scale === "m",
+        [CSS$K.containerLarge]: scale === "l",
+        [CSS$K.containerMulti]: this.selectionMode === "multiple",
+        [CSS$K.containerSingle]: this.selectionMode === "single",
+        [CSS$K.containerNone]: this.selectionMode === "none"
+      } }, this.selectionMode !== "none" ? (hAsync("calcite-icon", { class: CSS$K.icon, icon: this.selectionMode === "multiple" ? "check" : "bullet-point", scale: scale === "l" ? "m" : "s" })) : null, contentEl)));
   }
   //--------------------------------------------------------------------------
   //
@@ -21670,7 +21655,7 @@ class DropdownItem {
   }; }
 }
 
-const CSS$I = {
+const CSS$J = {
   button: "button"
 };
 const ICONS$c = {
@@ -21725,7 +21710,7 @@ class Fab {
   render() {
     const { appearance, kind, disabled, loading, scale, textEnabled, icon, label, text, iconFlipRtl } = this;
     const title = !textEnabled ? label || text || null : null;
-    return (hAsync("calcite-button", { appearance: appearance === "solid" ? "solid" : "outline-fill", class: CSS$I.button, disabled: disabled, iconFlipRtl: iconFlipRtl ? "start" : null, iconStart: icon, kind: kind, label: label, loading: loading, round: true, scale: scale, title: title, type: "button", width: "auto",
+    return (hAsync("calcite-button", { appearance: appearance === "solid" ? "solid" : "outline-fill", class: CSS$J.button, disabled: disabled, iconFlipRtl: iconFlipRtl ? "start" : null, iconStart: icon, kind: kind, label: label, loading: loading, round: true, scale: scale, title: title, type: "button", width: "auto",
       // eslint-disable-next-line react/jsx-sort-props
       ref: (buttonEl) => {
         this.buttonEl = buttonEl;
@@ -21755,7 +21740,7 @@ class Fab {
   }; }
 }
 
-const CSS$H = {
+const CSS$I = {
   container: "container",
   searchIcon: "search-icon"
 };
@@ -21867,7 +21852,7 @@ class Filter {
   // --------------------------------------------------------------------------
   render() {
     const { disabled, scale } = this;
-    return (hAsync(Fragment, null, hAsync("div", { class: CSS$H.container }, hAsync("label", null, hAsync("calcite-input", { "aria-label": this.messages.label, clearable: true, disabled: disabled, icon: ICONS$b.search, messageOverrides: { clear: this.messages.clear }, onCalciteInputInput: this.inputHandler, onKeyDown: this.keyDownHandler, placeholder: this.placeholder, scale: scale, type: "text", value: this.value,
+    return (hAsync(Fragment, null, hAsync("div", { class: CSS$I.container }, hAsync("label", null, hAsync("calcite-input", { "aria-label": this.messages.label, clearable: true, disabled: disabled, icon: ICONS$b.search, messageOverrides: { clear: this.messages.clear }, onCalciteInputInput: this.inputHandler, onKeyDown: this.keyDownHandler, placeholder: this.placeholder, scale: scale, type: "text", value: this.value,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => {
         this.textInput = el;
@@ -21905,7 +21890,7 @@ class Filter {
   }; }
 }
 
-const CSS$G = {
+const CSS$H = {
   frame: "frame",
   frameAdvancing: "frame--advancing",
   frameRetreating: "frame--retreating"
@@ -22005,9 +21990,9 @@ class Flow {
   render() {
     const { flowDirection } = this;
     const frameDirectionClasses = {
-      [CSS$G.frame]: true,
-      [CSS$G.frameAdvancing]: flowDirection === "advancing",
-      [CSS$G.frameRetreating]: flowDirection === "retreating"
+      [CSS$H.frame]: true,
+      [CSS$H.frameAdvancing]: flowDirection === "advancing",
+      [CSS$H.frameRetreating]: flowDirection === "retreating"
     };
     return (hAsync("div", { class: frameDirectionClasses }, hAsync("slot", null)));
   }
@@ -22028,7 +22013,7 @@ class Flow {
   }; }
 }
 
-const CSS$F = {
+const CSS$G = {
   actionBarContainer: "action-bar-container",
   backButton: "back-button",
   container: "container",
@@ -22063,7 +22048,7 @@ const SLOTS$l = {
   footerActions: "footer-actions"
 };
 
-const CSS$E = {
+const CSS$F = {
   backButton: "back-button"
 };
 const ICONS$9 = {
@@ -22209,7 +22194,7 @@ class FlowItem {
     const { showBackButton, backButtonClick, messages } = this;
     const label = messages.back;
     const icon = rtl ? ICONS$9.backRight : ICONS$9.backLeft;
-    return showBackButton ? (hAsync("calcite-action", { "aria-label": label, class: CSS$E.backButton, icon: icon, key: "flow-back-button", onClick: backButtonClick, scale: "s", slot: "header-actions-start", text: label,
+    return showBackButton ? (hAsync("calcite-action", { "aria-label": label, class: CSS$F.backButton, icon: icon, key: "flow-back-button", onClick: backButtonClick, scale: "s", slot: "header-actions-start", text: label,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setBackRef })) : null;
   }
@@ -22480,7 +22465,7 @@ class Graph {
   }; }
 }
 
-const CSS$D = {
+const CSS$E = {
   handle: "handle",
   handleActivated: "handle--activated"
 };
@@ -22575,7 +22560,7 @@ class Handle {
   render() {
     return (
     // Needs to be a span because of https://github.com/SortableJS/Sortable/issues/1486
-    hAsync("span", { "aria-pressed": toAriaBoolean(this.activated), class: { [CSS$D.handle]: true, [CSS$D.handleActivated]: this.activated }, onBlur: this.handleBlur, onKeyDown: this.handleKeyDown, role: "button", tabindex: "0", title: this.messages.dragHandle,
+    hAsync("span", { "aria-pressed": toAriaBoolean(this.activated), class: { [CSS$E.handle]: true, [CSS$E.handleActivated]: this.activated }, onBlur: this.handleBlur, onKeyDown: this.handleKeyDown, role: "button", tabindex: "0", title: this.messages.dragHandle,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => {
         this.handleButton = el;
@@ -22606,7 +22591,7 @@ class Handle {
   }; }
 }
 
-const CSS$C = {
+const CSS$D = {
   icon: "icon",
   flipRtl: "flip-rtl"
 };
@@ -22654,7 +22639,7 @@ class Icon {
     const semantic = !!textLabel;
     const paths = [].concat(pathData || "");
     return (hAsync(Host, { "aria-hidden": toAriaBoolean(!semantic), "aria-label": semantic ? textLabel : null, role: semantic ? "img" : null }, hAsync("svg", { "aria-hidden": "true", class: {
-        [CSS$C.flipRtl]: dir === "rtl" && flipRtl,
+        [CSS$D.flipRtl]: dir === "rtl" && flipRtl,
         svg: true
       }, fill: "currentColor", height: "100%", viewBox: `0 0 ${size} ${size}`, width: "100%", xmlns: "http://www.w3.org/2000/svg" }, paths.map((path) => typeof path === "string" ? (hAsync("path", { d: path })) : (hAsync("path", { d: path.d, opacity: "opacity" in path ? path.opacity : 1 }))))));
   }
@@ -22700,7 +22685,7 @@ class Icon {
   }; }
 }
 
-const CSS$B = {
+const CSS$C = {
   wrapper: "wrapper",
   confirmChangesButton: "confirm-changes-button",
   cancelEditingButton: "cancel-editing-button",
@@ -22848,16 +22833,16 @@ class InlineEditable {
     updateHostInteraction(this);
   }
   render() {
-    return (hAsync("div", { class: CSS$B.wrapper, onClick: this.enableEditingHandler, onKeyDown: this.escapeKeyHandler }, hAsync("div", { class: CSS$B.inputWrapper }, hAsync("slot", null)), hAsync("div", { class: CSS$B.controlsWrapper }, hAsync("calcite-button", { appearance: "transparent", class: CSS$B.enableEditingButton, disabled: this.disabled, iconStart: "pencil", kind: "neutral", label: this.messages.enableEditing, onClick: this.enableEditingHandler, scale: this.scale, style: {
+    return (hAsync("div", { class: CSS$C.wrapper, onClick: this.enableEditingHandler, onKeyDown: this.escapeKeyHandler }, hAsync("div", { class: CSS$C.inputWrapper }, hAsync("slot", null)), hAsync("div", { class: CSS$C.controlsWrapper }, hAsync("calcite-button", { appearance: "transparent", class: CSS$C.enableEditingButton, disabled: this.disabled, iconStart: "pencil", kind: "neutral", label: this.messages.enableEditing, onClick: this.enableEditingHandler, scale: this.scale, style: {
         opacity: this.editingEnabled ? "0" : "1",
         width: this.editingEnabled ? "0" : "inherit"
       }, type: "button",
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.enableEditingButton = el) }), this.shouldShowControls && [
-      hAsync("div", { class: CSS$B.cancelEditingButtonWrapper }, hAsync("calcite-button", { appearance: "transparent", class: CSS$B.cancelEditingButton, disabled: this.disabled, iconStart: "x", kind: "neutral", label: this.messages.cancelEditing, onClick: this.cancelEditingHandler, scale: this.scale, type: "button",
+      hAsync("div", { class: CSS$C.cancelEditingButtonWrapper }, hAsync("calcite-button", { appearance: "transparent", class: CSS$C.cancelEditingButton, disabled: this.disabled, iconStart: "x", kind: "neutral", label: this.messages.cancelEditing, onClick: this.cancelEditingHandler, scale: this.scale, type: "button",
         // eslint-disable-next-line react/jsx-sort-props
         ref: (el) => (this.cancelEditingButton = el) })),
-      hAsync("calcite-button", { appearance: "solid", class: CSS$B.confirmChangesButton, disabled: this.disabled, iconStart: "check", kind: "brand", label: this.messages.confirmChanges, loading: this.loading, onClick: this.confirmChangesHandler, scale: this.scale, type: "button",
+      hAsync("calcite-button", { appearance: "solid", class: CSS$C.confirmChangesButton, disabled: this.disabled, iconStart: "check", kind: "brand", label: this.messages.confirmChanges, loading: this.loading, onClick: this.confirmChangesHandler, scale: this.scale, type: "button",
         // eslint-disable-next-line react/jsx-sort-props
         ref: (el) => (this.confirmEditingButton = el) })
     ])));
@@ -22943,7 +22928,7 @@ class InlineEditable {
   }; }
 }
 
-const CSS$A = {
+const CSS$B = {
   loader: "loader",
   clearButton: "clear-button",
   editingEnabled: "editing-enabled",
@@ -23532,38 +23517,38 @@ class Input {
   // --------------------------------------------------------------------------
   render() {
     const dir = getElementDir(this.el);
-    const loader = (hAsync("div", { class: CSS$A.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
-    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$A.clearButton, disabled: this.disabled || this.readOnly, onClick: this.clearInputValue, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : "s" })));
-    const iconEl = (hAsync("calcite-icon", { class: CSS$A.inputIcon, flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }));
+    const loader = (hAsync("div", { class: CSS$B.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
+    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$B.clearButton, disabled: this.disabled || this.readOnly, onClick: this.clearInputValue, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : "s" })));
+    const iconEl = (hAsync("calcite-icon", { class: CSS$B.inputIcon, flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }));
     const isHorizontalNumberButton = this.numberButtonType === "horizontal";
     const numberButtonsHorizontalUp = (hAsync("button", { "aria-hidden": "true", class: {
-        [CSS$A.numberButtonItem]: true,
-        [CSS$A.buttonItemHorizontal]: isHorizontalNumberButton
+        [CSS$B.numberButtonItem]: true,
+        [CSS$B.buttonItemHorizontal]: isHorizontalNumberButton
       }, "data-adjustment": "up", disabled: this.disabled || this.readOnly, onPointerDown: this.numberButtonPointerDownHandler, onPointerOut: this.numberButtonPointerUpAndOutHandler, onPointerUp: this.numberButtonPointerUpAndOutHandler, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "chevron-up", scale: this.scale === "l" ? "m" : "s" })));
     const numberButtonsHorizontalDown = (hAsync("button", { "aria-hidden": "true", class: {
-        [CSS$A.numberButtonItem]: true,
-        [CSS$A.buttonItemHorizontal]: isHorizontalNumberButton
+        [CSS$B.numberButtonItem]: true,
+        [CSS$B.buttonItemHorizontal]: isHorizontalNumberButton
       }, "data-adjustment": "down", disabled: this.disabled || this.readOnly, onPointerDown: this.numberButtonPointerDownHandler, onPointerOut: this.numberButtonPointerUpAndOutHandler, onPointerUp: this.numberButtonPointerUpAndOutHandler, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" })));
-    const numberButtonsVertical = (hAsync("div", { class: CSS$A.numberButtonWrapper }, numberButtonsHorizontalUp, numberButtonsHorizontalDown));
-    const prefixText = hAsync("div", { class: CSS$A.prefix }, this.prefixText);
-    const suffixText = hAsync("div", { class: CSS$A.suffix }, this.suffixText);
+    const numberButtonsVertical = (hAsync("div", { class: CSS$B.numberButtonWrapper }, numberButtonsHorizontalUp, numberButtonsHorizontalDown));
+    const prefixText = hAsync("div", { class: CSS$B.prefix }, this.prefixText);
+    const suffixText = hAsync("div", { class: CSS$B.suffix }, this.suffixText);
     const localeNumberInput = this.type === "number" ? (hAsync("input", { accept: this.accept, "aria-label": getLabelText(this), autocomplete: this.autocomplete, autofocus: this.autofocus ? true : null, defaultValue: this.defaultValue, disabled: this.disabled ? true : null, enterKeyHint: this.enterKeyHint, inputMode: this.inputMode, key: "localized-input", maxLength: this.maxLength, minLength: this.minLength, multiple: this.multiple, name: undefined, onBlur: this.inputBlurHandler, onFocus: this.inputFocusHandler, onInput: this.inputNumberInputHandler, onKeyDown: this.inputNumberKeyDownHandler, onKeyUp: this.inputKeyUpHandler, pattern: this.pattern, placeholder: this.placeholder || "", readOnly: this.readOnly, type: "text", value: this.localizedValue,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setChildNumberElRef })) : null;
     const childEl = this.type !== "number"
       ? [
         hAsync(this.childElType, { accept: this.accept, "aria-label": getLabelText(this), autocomplete: this.autocomplete, autofocus: this.autofocus ? true : null, class: {
-            [CSS$A.editingEnabled]: this.editingEnabled,
-            [CSS$A.inlineChild]: !!this.inlineEditableEl
+            [CSS$B.editingEnabled]: this.editingEnabled,
+            [CSS$B.inlineChild]: !!this.inlineEditableEl
           }, defaultValue: this.defaultValue, disabled: this.disabled ? true : null, enterKeyHint: this.enterKeyHint, inputMode: this.inputMode, max: this.maxString, maxLength: this.maxLength, min: this.minString, minLength: this.minLength, multiple: this.multiple, name: this.name, onBlur: this.inputBlurHandler, onChange: this.inputChangeHandler, onFocus: this.inputFocusHandler, onInput: this.inputInputHandler, onKeyDown: this.inputKeyDownHandler, onKeyUp: this.inputKeyUpHandler, pattern: this.pattern, placeholder: this.placeholder || "", readOnly: this.readOnly, required: this.required ? true : null, step: this.step, tabIndex: this.disabled || (this.inlineEditableEl && !this.editingEnabled) ? -1 : null, type: this.type, value: this.value,
           // eslint-disable-next-line react/jsx-sort-props
           ref: this.setChildElRef }),
-        this.isTextarea ? (hAsync("div", { class: CSS$A.resizeIconWrapper }, hAsync("calcite-icon", { icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" }))) : null
+        this.isTextarea ? (hAsync("div", { class: CSS$B.resizeIconWrapper }, hAsync("calcite-icon", { icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" }))) : null
       ]
       : null;
-    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$A.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.type === "number" && this.numberButtonType === "horizontal" && !this.readOnly
+    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$B.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.type === "number" && this.numberButtonType === "horizontal" && !this.readOnly
       ? numberButtonsHorizontalDown
-      : null, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$A.wrapper }, localeNumberInput, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$A.actionWrapper }, hAsync("slot", { name: SLOTS$j.action })), this.type === "number" && this.numberButtonType === "vertical" && !this.readOnly
+      : null, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$B.wrapper }, localeNumberInput, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$B.actionWrapper }, hAsync("slot", { name: SLOTS$j.action })), this.type === "number" && this.numberButtonType === "vertical" && !this.readOnly
       ? numberButtonsVertical
       : null, this.suffixText ? suffixText : null, this.type === "number" && this.numberButtonType === "horizontal" && !this.readOnly
       ? numberButtonsHorizontalUp
@@ -23639,7 +23624,7 @@ class Input {
   }; }
 }
 
-const CSS$z = {
+const CSS$A = {
   menu: "menu-container",
   menuActive: "menu-container--active",
   toggleIcon: "toggle-icon"
@@ -24875,8 +24860,8 @@ class InputDatePicker {
       ref: this.setStartWrapper }, hAsync("calcite-input", { "aria-autocomplete": "none", "aria-controls": this.dialogId, "aria-expanded": toAriaBoolean(this.open), "aria-haspopup": "dialog", class: `input ${this.layout === "vertical" && this.range ? `no-bottom-border` : ``}`, disabled: disabled, icon: "calendar", "number-button-type": "none", numberingSystem: numberingSystem, onCalciteInputInput: this.calciteInternalInputInputHandler, onCalciteInternalInputBlur: this.calciteInternalInputBlurHandler, onCalciteInternalInputFocus: this.startInputFocus, onFocus: this.startEndInputFocus, placeholder: this.localeData?.placeholder, readOnly: readOnly, role: "combobox", scale: this.scale, type: "text",
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setStartInput }), this.renderToggleIcon(this.open && this.focusedInput === "start")), hAsync("div", { "aria-hidden": toAriaBoolean(!this.open), "aria-label": messages.chooseDate, "aria-live": "polite", "aria-modal": "true", class: {
-        [CSS$z.menu]: true,
-        [CSS$z.menuActive]: this.open
+        [CSS$A.menu]: true,
+        [CSS$A.menuActive]: this.open
       }, id: this.dialogId, role: "dialog",
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setFloatingEl }, hAsync("div", { class: {
@@ -24898,7 +24883,7 @@ class InputDatePicker {
       ref: this.setEndInput }), this.renderToggleIcon(this.open && this.focusedInput === "end"))))), hAsync(HiddenFormInputSlot, { component: this })));
   }
   renderToggleIcon(open) {
-    return (hAsync("span", { class: CSS$z.toggleIcon }, hAsync("calcite-icon", { icon: open ? "chevron-up" : "chevron-down", scale: "s" })));
+    return (hAsync("span", { class: CSS$A.toggleIcon }, hAsync("calcite-icon", { icon: open ? "chevron-up" : "chevron-down", scale: "s" })));
   }
   setReferenceEl() {
     const { focusedInput, layout, endWrapper, startWrapper } = this;
@@ -25145,7 +25130,7 @@ class InputMessage {
   }; }
 }
 
-const CSS$y = {
+const CSS$z = {
   loader: "loader",
   clearButton: "clear-button",
   editingEnabled: "editing-enabled",
@@ -25647,27 +25632,27 @@ class InputNumber {
   // --------------------------------------------------------------------------
   render() {
     const dir = getElementDir(this.el);
-    const loader = (hAsync("div", { class: CSS$y.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
-    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$y.clearButton, disabled: this.disabled || this.readOnly, onClick: this.clearInputValue, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : "s" })));
-    const iconEl = (hAsync("calcite-icon", { class: CSS$y.inputIcon, flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }));
+    const loader = (hAsync("div", { class: CSS$z.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
+    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$z.clearButton, disabled: this.disabled || this.readOnly, onClick: this.clearInputValue, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : "s" })));
+    const iconEl = (hAsync("calcite-icon", { class: CSS$z.inputIcon, flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }));
     const isHorizontalNumberButton = this.numberButtonType === "horizontal";
     const numberButtonsHorizontalUp = (hAsync("button", { "aria-hidden": "true", class: {
-        [CSS$y.numberButtonItem]: true,
-        [CSS$y.buttonItemHorizontal]: isHorizontalNumberButton
+        [CSS$z.numberButtonItem]: true,
+        [CSS$z.buttonItemHorizontal]: isHorizontalNumberButton
       }, "data-adjustment": "up", disabled: this.disabled || this.readOnly, onPointerDown: this.nudgeButtonPointerDownHandler, onPointerOut: this.nudgeButtonPointerUpAndOutHandler, onPointerUp: this.nudgeButtonPointerUpAndOutHandler, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "chevron-up", scale: this.scale === "l" ? "m" : "s" })));
     const numberButtonsHorizontalDown = (hAsync("button", { "aria-hidden": "true", class: {
-        [CSS$y.numberButtonItem]: true,
-        [CSS$y.buttonItemHorizontal]: isHorizontalNumberButton
+        [CSS$z.numberButtonItem]: true,
+        [CSS$z.buttonItemHorizontal]: isHorizontalNumberButton
       }, "data-adjustment": "down", disabled: this.disabled || this.readOnly, onPointerDown: this.nudgeButtonPointerDownHandler, onPointerOut: this.nudgeButtonPointerUpAndOutHandler, onPointerUp: this.nudgeButtonPointerUpAndOutHandler, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" })));
-    const numberButtonsVertical = (hAsync("div", { class: CSS$y.numberButtonWrapper }, numberButtonsHorizontalUp, numberButtonsHorizontalDown));
-    const prefixText = hAsync("div", { class: CSS$y.prefix }, this.prefixText);
-    const suffixText = hAsync("div", { class: CSS$y.suffix }, this.suffixText);
+    const numberButtonsVertical = (hAsync("div", { class: CSS$z.numberButtonWrapper }, numberButtonsHorizontalUp, numberButtonsHorizontalDown));
+    const prefixText = hAsync("div", { class: CSS$z.prefix }, this.prefixText);
+    const suffixText = hAsync("div", { class: CSS$z.suffix }, this.suffixText);
     const childEl = (hAsync("input", { "aria-label": getLabelText(this), autocomplete: this.autocomplete, autofocus: this.autofocus ? true : null, defaultValue: this.defaultValue, disabled: this.disabled ? true : null, enterKeyHint: this.enterKeyHint, inputMode: this.inputMode, key: "localized-input", maxLength: this.maxLength, minLength: this.minLength, name: undefined, onBlur: this.inputNumberBlurHandler, onFocus: this.inputNumberFocusHandler, onInput: this.inputNumberInputHandler, onKeyDown: this.inputNumberKeyDownHandler, onKeyUp: this.inputNumberKeyUpHandler, placeholder: this.placeholder || "", readOnly: this.readOnly, type: "text", value: this.localizedValue,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setChildNumberElRef }));
-    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$y.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.numberButtonType === "horizontal" && !this.readOnly
+    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$z.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.numberButtonType === "horizontal" && !this.readOnly
       ? numberButtonsHorizontalDown
-      : null, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$y.wrapper }, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$y.actionWrapper }, hAsync("slot", { name: SLOTS$i.action })), this.numberButtonType === "vertical" && !this.readOnly ? numberButtonsVertical : null, this.suffixText ? suffixText : null, this.numberButtonType === "horizontal" && !this.readOnly
+      : null, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$z.wrapper }, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$z.actionWrapper }, hAsync("slot", { name: SLOTS$i.action })), this.numberButtonType === "vertical" && !this.readOnly ? numberButtonsVertical : null, this.suffixText ? suffixText : null, this.numberButtonType === "horizontal" && !this.readOnly
       ? numberButtonsHorizontalUp
       : null, hAsync(HiddenFormInputSlot, { component: this }))));
   }
@@ -25734,7 +25719,7 @@ class InputNumber {
   }; }
 }
 
-const CSS$x = {
+const CSS$y = {
   loader: "loader",
   clearButton: "clear-button",
   editingEnabled: "editing-enabled",
@@ -26032,18 +26017,18 @@ class InputText {
   // --------------------------------------------------------------------------
   render() {
     const dir = getElementDir(this.el);
-    const loader = (hAsync("div", { class: CSS$x.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
-    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$x.clearButton, disabled: this.disabled || this.readOnly, onClick: this.clearInputTextValue, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : "s" })));
-    const iconEl = (hAsync("calcite-icon", { class: CSS$x.inputIcon, flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }));
-    const prefixText = hAsync("div", { class: CSS$x.prefix }, this.prefixText);
-    const suffixText = hAsync("div", { class: CSS$x.suffix }, this.suffixText);
+    const loader = (hAsync("div", { class: CSS$y.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
+    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$y.clearButton, disabled: this.disabled || this.readOnly, onClick: this.clearInputTextValue, tabIndex: -1, type: "button" }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : "s" })));
+    const iconEl = (hAsync("calcite-icon", { class: CSS$y.inputIcon, flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }));
+    const prefixText = hAsync("div", { class: CSS$y.prefix }, this.prefixText);
+    const suffixText = hAsync("div", { class: CSS$y.suffix }, this.suffixText);
     const childEl = (hAsync("input", { "aria-label": getLabelText(this), autocomplete: this.autocomplete, autofocus: this.autofocus ? true : null, class: {
-        [CSS$x.editingEnabled]: this.editingEnabled,
-        [CSS$x.inlineChild]: !!this.inlineEditableEl
+        [CSS$y.editingEnabled]: this.editingEnabled,
+        [CSS$y.inlineChild]: !!this.inlineEditableEl
       }, defaultValue: this.defaultValue, disabled: this.disabled ? true : null, enterKeyHint: this.enterKeyHint, inputMode: this.inputMode, maxLength: this.maxLength, minLength: this.minLength, name: this.name, onBlur: this.inputTextBlurHandler, onFocus: this.inputTextFocusHandler, onInput: this.inputTextInputHandler, onKeyDown: this.inputTextKeyDownHandler, pattern: this.pattern, placeholder: this.placeholder || "", readOnly: this.readOnly, required: this.required ? true : null, tabIndex: this.disabled || (this.inlineEditableEl && !this.editingEnabled) ? -1 : null, type: "text", value: this.value,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setChildElRef }));
-    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$x.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$x.wrapper }, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$x.actionWrapper }, hAsync("slot", { name: SLOTS$h.action })), this.suffixText ? suffixText : null, hAsync(HiddenFormInputSlot, { component: this }))));
+    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$y.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$y.wrapper }, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$y.actionWrapper }, hAsync("slot", { name: SLOTS$h.action })), this.suffixText ? suffixText : null, hAsync(HiddenFormInputSlot, { component: this }))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -26281,7 +26266,7 @@ function toISOTimeString(value, includeSeconds = true) {
   return isoTimeString;
 }
 
-const CSS$w = {
+const CSS$x = {
   toggleIcon: "toggle-icon"
 };
 
@@ -27857,7 +27842,7 @@ class InputTimePicker {
       ref: this.setCalciteTimePickerEl })), hAsync(HiddenFormInputSlot, { component: this })));
   }
   renderToggleIcon(open) {
-    return (hAsync("span", { class: CSS$w.toggleIcon }, hAsync("calcite-icon", { icon: open ? "chevron-up" : "chevron-down", scale: "s" })));
+    return (hAsync("span", { class: CSS$x.toggleIcon }, hAsync("calcite-icon", { icon: open ? "chevron-up" : "chevron-down", scale: "s" })));
   }
   static get delegatesFocus() { return true; }
   static get assetsDirs() { return ["assets"]; }
@@ -27904,7 +27889,7 @@ class InputTimePicker {
   }; }
 }
 
-const CSS$v = {
+const CSS$w = {
   container: "container"
 };
 
@@ -27944,7 +27929,7 @@ class Label {
     document.dispatchEvent(new CustomEvent(labelDisconnectedEvent));
   }
   render() {
-    return (hAsync(Host, { onClick: this.labelClickHandler }, hAsync("div", { class: CSS$v.container }, hAsync("slot", null))));
+    return (hAsync(Host, { onClick: this.labelClickHandler }, hAsync("div", { class: CSS$w.container }, hAsync("slot", null))));
   }
   get el() { return getElement(this); }
   static get style() { return labelCss; }
@@ -28073,7 +28058,7 @@ class Link {
   }; }
 }
 
-const CSS$u = {
+const CSS$v = {
   container: "container",
   containerBorderSelected: "container--border-selected",
   containerBorderUnselected: "container--border-unselected",
@@ -28134,7 +28119,7 @@ function getDepth(element, includeGroup = false) {
   }
 }
 
-const CSS$t = {
+const CSS$u = {
   container: "container",
   table: "table",
   scrim: "scrim",
@@ -28378,9 +28363,9 @@ class List$1 {
   // --------------------------------------------------------------------------
   render() {
     const { loading, label, disabled, dataForFilter, filterEnabled, filterPlaceholder, filterText } = this;
-    return (hAsync("div", { class: CSS$t.container }, loading ? hAsync("calcite-scrim", { class: CSS$t.scrim, loading: loading }) : null, hAsync("table", { "aria-busy": toAriaBoolean(loading), "aria-label": label || "", class: CSS$t.table, onKeyDown: this.handleListKeydown, role: "treegrid" }, filterEnabled ? (hAsync("thead", null, hAsync("tr", { class: { [CSS$t.sticky]: true } }, hAsync("th", { colSpan: MAX_COLUMNS }, hAsync("calcite-filter", { "aria-label": filterPlaceholder, disabled: loading || disabled, items: dataForFilter, onCalciteFilterChange: this.handleFilter, placeholder: filterPlaceholder, value: filterText,
+    return (hAsync("div", { class: CSS$u.container }, loading ? hAsync("calcite-scrim", { class: CSS$u.scrim, loading: loading }) : null, hAsync("table", { "aria-busy": toAriaBoolean(loading), "aria-label": label || "", class: CSS$u.table, onKeyDown: this.handleListKeydown, role: "treegrid" }, filterEnabled ? (hAsync("thead", null, hAsync("tr", { class: { [CSS$u.sticky]: true } }, hAsync("th", { colSpan: MAX_COLUMNS }, hAsync("calcite-filter", { "aria-label": filterPlaceholder, disabled: loading || disabled, items: dataForFilter, onCalciteFilterChange: this.handleFilter, placeholder: filterPlaceholder, value: filterText,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (el) => (this.filterEl = el) }))))) : null, hAsync("tbody", { class: CSS$t.tableContainer }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange })))));
+      ref: (el) => (this.filterEl = el) }))))) : null, hAsync("tbody", { class: CSS$u.tableContainer }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange })))));
   }
   filterElements({ el, filteredItems, visibleParents }) {
     const hidden = !visibleParents.has(el) && !filteredItems.includes(el);
@@ -28499,7 +28484,7 @@ class ListItem {
     };
     this.toggleSelected = () => {
       const { selectionMode, selected } = this;
-      if (this.disabled || selectionMode === "none" || !selectionMode) {
+      if (this.disabled) {
         return;
       }
       if (selectionMode === "multiple" || selectionMode === "single") {
@@ -28516,10 +28501,10 @@ class ListItem {
       }
       const { key } = event;
       const composedPath = event.composedPath();
-      const { containerEl, contentEl, actionsStartEl, actionsEndEl, open, openable, selectionMode } = this;
+      const { containerEl, contentEl, actionsStartEl, actionsEndEl, open, openable } = this;
       const cells = [actionsStartEl, contentEl, actionsEndEl].filter(Boolean);
       const currentIndex = cells.findIndex((cell) => composedPath.includes(cell));
-      if (key === "Enter" && selectionMode && selectionMode !== "none") {
+      if (key === "Enter") {
         event.preventDefault();
         this.toggleSelected();
       }
@@ -28679,7 +28664,7 @@ class ListItem {
     if (selectionMode === "none" || selectionAppearance === "border") {
       return null;
     }
-    return (hAsync("td", { class: CSS$u.selectionContainer, key: "selection-container", onClick: this.itemClicked }, hAsync("calcite-icon", { icon: selected
+    return (hAsync("td", { class: CSS$v.selectionContainer, key: "selection-container", onClick: this.itemClicked }, hAsync("calcite-icon", { icon: selected
         ? selectionMode === "multiple"
           ? ICONS$7.selectedMultiple
           : ICONS$7.selectedSingle
@@ -28688,35 +28673,35 @@ class ListItem {
   renderOpen() {
     const { el, open, openable, parentListEl } = this;
     const dir = getElementDir(el);
-    return openable ? (hAsync("td", { class: CSS$u.openContainer, key: "open-container", onClick: this.toggleOpen }, hAsync("calcite-icon", { icon: open ? ICONS$7.open : dir === "rtl" ? ICONS$7.closedRTL : ICONS$7.closedLTR, scale: "s" }))) : parentListEl?.openable ? (hAsync("td", { class: CSS$u.openContainer, key: "open-container", onClick: this.itemClicked }, hAsync("calcite-icon", { icon: ICONS$7.blank, scale: "s" }))) : null;
+    return openable ? (hAsync("td", { class: CSS$v.openContainer, key: "open-container", onClick: this.toggleOpen }, hAsync("calcite-icon", { icon: open ? ICONS$7.open : dir === "rtl" ? ICONS$7.closedRTL : ICONS$7.closedLTR, scale: "s" }))) : parentListEl?.openable ? (hAsync("td", { class: CSS$v.openContainer, key: "open-container", onClick: this.itemClicked }, hAsync("calcite-icon", { icon: ICONS$7.blank, scale: "s" }))) : null;
   }
   renderActionsStart() {
     const { label, hasActionsStart } = this;
-    return (hAsync("td", { "aria-label": label, class: CSS$u.actionsStart, hidden: !hasActionsStart, key: "actions-start-container", role: "gridcell",
+    return (hAsync("td", { "aria-label": label, class: CSS$v.actionsStart, hidden: !hasActionsStart, key: "actions-start-container", role: "gridcell",
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.actionsStartEl = el) }, hAsync("slot", { name: SLOTS$g.actionsStart, onSlotchange: this.handleActionsStartSlotChange })));
   }
   renderActionsEnd() {
     const { label, hasActionsEnd, closable, messages } = this;
-    return (hAsync("td", { "aria-label": label, class: CSS$u.actionsEnd, hidden: !(hasActionsEnd || closable), key: "actions-end-container", role: "gridcell",
+    return (hAsync("td", { "aria-label": label, class: CSS$v.actionsEnd, hidden: !(hasActionsEnd || closable), key: "actions-end-container", role: "gridcell",
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.actionsEndEl = el) }, hAsync("slot", { name: SLOTS$g.actionsEnd, onSlotchange: this.handleActionsEndSlotChange }), closable ? (hAsync("calcite-action", { appearance: "transparent", icon: ICONS$7.close, key: "close-action", label: messages.close, onClick: this.closeClickHandler, text: messages.close })) : null));
   }
   renderContentStart() {
     const { hasContentStart } = this;
-    return (hAsync("div", { class: CSS$u.contentStart, hidden: !hasContentStart }, hAsync("slot", { name: SLOTS$g.contentStart, onSlotchange: this.handleContentStartSlotChange })));
+    return (hAsync("div", { class: CSS$v.contentStart, hidden: !hasContentStart }, hAsync("slot", { name: SLOTS$g.contentStart, onSlotchange: this.handleContentStartSlotChange })));
   }
   renderCustomContent() {
     const { hasCustomContent } = this;
-    return (hAsync("div", { class: CSS$u.customContent, hidden: !hasCustomContent }, hAsync("slot", { name: SLOTS$g.content, onSlotchange: this.handleContentSlotChange })));
+    return (hAsync("div", { class: CSS$v.customContent, hidden: !hasCustomContent }, hAsync("slot", { name: SLOTS$g.content, onSlotchange: this.handleContentSlotChange })));
   }
   renderContentEnd() {
     const { hasContentEnd } = this;
-    return (hAsync("div", { class: CSS$u.contentEnd, hidden: !hasContentEnd }, hAsync("slot", { name: SLOTS$g.contentEnd, onSlotchange: this.handleContentEndSlotChange })));
+    return (hAsync("div", { class: CSS$v.contentEnd, hidden: !hasContentEnd }, hAsync("slot", { name: SLOTS$g.contentEnd, onSlotchange: this.handleContentEndSlotChange })));
   }
   renderContentProperties() {
     const { label, description, hasCustomContent } = this;
-    return !hasCustomContent && (!!label || !!description) ? (hAsync("div", { class: CSS$u.content, key: "content" }, label ? (hAsync("div", { class: CSS$u.label, key: "label" }, label)) : null, description ? (hAsync("div", { class: CSS$u.description, key: "description" }, description)) : null)) : null;
+    return !hasCustomContent && (!!label || !!description) ? (hAsync("div", { class: CSS$v.content, key: "content" }, label ? (hAsync("div", { class: CSS$v.label, key: "label" }, label)) : null, description ? (hAsync("div", { class: CSS$v.description, key: "description" }, description)) : null)) : null;
   }
   renderContentContainer() {
     const { description, label, selectionMode, hasCustomContent } = this;
@@ -28728,9 +28713,9 @@ class ListItem {
       this.renderContentEnd()
     ];
     return (hAsync("td", { "aria-label": label, class: {
-        [CSS$u.contentContainer]: true,
-        [CSS$u.contentContainerSelectable]: selectionMode !== "none",
-        [CSS$u.contentContainerHasCenterContent]: hasCenterContent
+        [CSS$v.contentContainer]: true,
+        [CSS$v.contentContainerSelectable]: selectionMode !== "none",
+        [CSS$v.contentContainerHasCenterContent]: hasCenterContent
       }, key: "content-container", onClick: this.itemClicked, role: "gridcell",
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.contentEl = el) }, content));
@@ -28741,14 +28726,14 @@ class ListItem {
     const borderSelected = showBorder && selected;
     const borderUnselected = showBorder && !selected;
     return (hAsync(Host, null, hAsync("tr", { "aria-expanded": openable ? toAriaBoolean(open) : null, "aria-label": label, "aria-level": level, "aria-posinset": setPosition, "aria-selected": toAriaBoolean(selected), "aria-setsize": setSize, class: {
-        [CSS$u.container]: true,
-        [CSS$u.containerBorderSelected]: borderSelected,
-        [CSS$u.containerBorderUnselected]: borderUnselected
+        [CSS$v.container]: true,
+        [CSS$v.containerBorderSelected]: borderSelected,
+        [CSS$v.containerBorderUnselected]: borderUnselected
       }, hidden: closed, onFocus: this.focusCellNull, onKeyDown: this.handleItemKeyDown, role: "row", style: { "--calcite-list-item-spacing-indent-multiplier": `${this.visualLevel}` }, tabIndex: active ? 0 : -1,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.containerEl = el) }, this.renderSelected(), this.renderOpen(), this.renderActionsStart(), this.renderContentContainer(), this.renderActionsEnd()), hAsync("div", { class: {
-        [CSS$u.nestedContainer]: true,
-        [CSS$u.nestedContainerHidden]: openable && !open
+        [CSS$v.nestedContainer]: true,
+        [CSS$v.nestedContainerHidden]: openable && !open
       } }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }))));
   }
   setSelectionDefaults() {
@@ -28811,7 +28796,7 @@ class ListItem {
   }; }
 }
 
-const CSS$s = {
+const CSS$t = {
   container: "container",
   heading: "heading"
 };
@@ -28847,7 +28832,7 @@ class ListItemGroup {
   // --------------------------------------------------------------------------
   render() {
     const { heading, visualLevel } = this;
-    return (hAsync(Host, null, hAsync("tr", { class: CSS$s.container, style: { "--calcite-list-item-spacing-indent-multiplier": `${visualLevel}` } }, hAsync("td", { class: CSS$s.heading, colSpan: MAX_COLUMNS }, heading)), hAsync("slot", null)));
+    return (hAsync(Host, null, hAsync("tr", { class: CSS$t.container, style: { "--calcite-list-item-spacing-indent-multiplier": `${visualLevel}` } }, hAsync("td", { class: CSS$t.heading, colSpan: MAX_COLUMNS }, heading)), hAsync("slot", null)));
   }
   get el() { return getElement(this); }
   static get style() { return listItemGroupCss; }
@@ -28947,7 +28932,7 @@ class Loader {
   }; }
 }
 
-const CSS$r = {
+const CSS$s = {
   modal: "modal",
   title: "title",
   header: "header",
@@ -29120,50 +29105,50 @@ class Modal {
   }
   render() {
     return (hAsync(Host, { "aria-describedby": this.contentId, "aria-labelledby": this.titleId, "aria-modal": "true", role: "dialog" }, hAsync("div", { class: {
-        [CSS$r.container]: true,
-        [CSS$r.containerOpen]: this.isOpen,
-        [CSS$r.slottedInShell]: this.slottedInShell
-      } }, hAsync("calcite-scrim", { class: CSS$r.scrim, onClick: this.handleOutsideClose }), this.renderStyle(), hAsync("div", { class: {
-        [CSS$r.modal]: true
+        [CSS$s.container]: true,
+        [CSS$s.containerOpen]: this.isOpen,
+        [CSS$s.slottedInShell]: this.slottedInShell
+      } }, hAsync("calcite-scrim", { class: CSS$s.scrim, onClick: this.handleOutsideClose }), this.renderStyle(), hAsync("div", { class: {
+        [CSS$s.modal]: true
       },
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.setTransitionEl }, hAsync("div", { class: CSS$r.header }, this.renderCloseButton(), hAsync("header", { class: CSS$r.title }, hAsync("slot", { name: CSS$r.header }))), this.renderContentTop(), hAsync("div", { class: {
-        [CSS$r.content]: true,
-        [CSS$r.contentNoFooter]: !this.hasFooter
+      ref: this.setTransitionEl }, hAsync("div", { class: CSS$s.header }, this.renderCloseButton(), hAsync("header", { class: CSS$s.title }, hAsync("slot", { name: CSS$s.header }))), this.renderContentTop(), hAsync("div", { class: {
+        [CSS$s.content]: true,
+        [CSS$s.contentNoFooter]: !this.hasFooter
       },
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.modalContent = el) }, hAsync("slot", { name: SLOTS$f.content })), this.renderContentBottom(), this.renderFooter()))));
   }
   renderFooter() {
-    return this.hasFooter ? (hAsync("div", { class: CSS$r.footer, key: "footer" }, hAsync("span", { class: CSS$r.back }, hAsync("slot", { name: SLOTS$f.back })), hAsync("span", { class: CSS$r.secondary }, hAsync("slot", { name: SLOTS$f.secondary })), hAsync("span", { class: CSS$r.primary }, hAsync("slot", { name: SLOTS$f.primary })))) : null;
+    return this.hasFooter ? (hAsync("div", { class: CSS$s.footer, key: "footer" }, hAsync("span", { class: CSS$s.back }, hAsync("slot", { name: SLOTS$f.back })), hAsync("span", { class: CSS$s.secondary }, hAsync("slot", { name: SLOTS$f.secondary })), hAsync("span", { class: CSS$s.primary }, hAsync("slot", { name: SLOTS$f.primary })))) : null;
   }
   renderContentTop() {
-    return (hAsync("div", { class: CSS$r.contentTop, hidden: !this.hasContentTop }, hAsync("slot", { name: SLOTS$f.contentTop, onSlotchange: this.contentTopSlotChangeHandler })));
+    return (hAsync("div", { class: CSS$s.contentTop, hidden: !this.hasContentTop }, hAsync("slot", { name: SLOTS$f.contentTop, onSlotchange: this.contentTopSlotChangeHandler })));
   }
   renderContentBottom() {
-    return (hAsync("div", { class: CSS$r.contentBottom, hidden: !this.hasContentBottom }, hAsync("slot", { name: SLOTS$f.contentBottom, onSlotchange: this.contentBottomSlotChangeHandler })));
+    return (hAsync("div", { class: CSS$s.contentBottom, hidden: !this.hasContentBottom }, hAsync("slot", { name: SLOTS$f.contentBottom, onSlotchange: this.contentBottomSlotChangeHandler })));
   }
   renderCloseButton() {
-    return !this.closeButtonDisabled ? (hAsync("button", { "aria-label": this.messages.close, class: CSS$r.close, key: "button", onClick: this.close, title: this.messages.close,
+    return !this.closeButtonDisabled ? (hAsync("button", { "aria-label": this.messages.close, class: CSS$s.close, key: "button", onClick: this.close, title: this.messages.close,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.closeButtonEl = el) }, hAsync("calcite-icon", { icon: ICONS$6.close, scale: this.scale === "s" ? "s" : this.scale === "m" ? "m" : this.scale === "l" ? "l" : null }))) : null;
   }
   renderStyle() {
     if (!this.fullscreen && (this.cssWidth || this.cssHeight)) {
-      return (hAsync("style", null, `.${CSS$r.container} {
+      return (hAsync("style", null, `.${CSS$s.container} {
               ${this.docked && this.cssWidth ? `align-items: center !important;` : ""}
             }
-            .${CSS$r.modal} {
+            .${CSS$s.modal} {
               block-size: ${this.cssHeight ? this.cssHeight : "auto"} !important;
               ${this.cssWidth ? `inline-size: ${this.cssWidth} !important;` : ""}
               ${this.cssWidth ? `max-inline-size: ${this.cssWidth} !important;` : ""}
               ${this.docked ? `border-radius: var(--calcite-border-radius) !important;` : ""}
             }
             @media screen and (max-width: ${this.cssWidth}) {
-              .${CSS$r.container} {
+              .${CSS$s.container} {
                 ${this.docked ? `align-items: flex-end !important;` : ""}
               }
-              .${CSS$r.modal} {
+              .${CSS$s.modal} {
                 max-block-size: 100% !important;
                 inline-size: 100% !important;
                 max-inline-size: 100% !important;
@@ -29230,31 +29215,31 @@ class Modal {
     }
   }
   onBeforeOpen() {
-    this.transitionEl.classList.add(CSS$r.openingActive);
+    this.transitionEl.classList.add(CSS$s.openingActive);
     this.calciteModalBeforeOpen.emit();
   }
   onOpen() {
-    this.transitionEl.classList.remove(CSS$r.openingIdle, CSS$r.openingActive);
+    this.transitionEl.classList.remove(CSS$s.openingIdle, CSS$s.openingActive);
     this.calciteModalOpen.emit();
     activateFocusTrap(this);
   }
   onBeforeClose() {
-    this.transitionEl.classList.add(CSS$r.closingActive);
+    this.transitionEl.classList.add(CSS$s.closingActive);
     this.calciteModalBeforeClose.emit();
   }
   onClose() {
-    this.transitionEl.classList.remove(CSS$r.closingIdle, CSS$r.closingActive);
+    this.transitionEl.classList.remove(CSS$s.closingIdle, CSS$s.closingActive);
     this.calciteModalClose.emit();
     deactivateFocusTrap(this);
   }
   async toggleModal(value) {
     onToggleOpenCloseComponent(this);
     if (value) {
-      this.transitionEl?.classList.add(CSS$r.openingIdle);
+      this.transitionEl?.classList.add(CSS$s.openingIdle);
       this.openModal();
     }
     else {
-      this.transitionEl?.classList.add(CSS$r.closingIdle);
+      this.transitionEl?.classList.add(CSS$s.closingIdle);
       this.close();
     }
   }
@@ -29268,11 +29253,11 @@ class Modal {
     this.titleId = ensureId(titleEl);
     this.contentId = ensureId(contentEl);
     if (!this.slottedInShell) {
-      document.documentElement.classList.add(CSS$r.overflowHidden);
+      document.documentElement.classList.add(CSS$s.overflowHidden);
     }
   }
   removeOverflowHiddenClass() {
-    document.documentElement.classList.remove(CSS$r.overflowHidden);
+    document.documentElement.classList.remove(CSS$s.overflowHidden);
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -29325,7 +29310,7 @@ const SLOTS$e = {
   link: "link",
   actionsEnd: "actions-end"
 };
-const CSS$q = {
+const CSS$r = {
   actionsEnd: "actions-end",
   close: "notice-close",
   container: "container",
@@ -29404,11 +29389,11 @@ class Notice {
   }
   render() {
     const { el } = this;
-    const closeButton = (hAsync("button", { "aria-label": this.messages.close, class: CSS$q.close, onClick: this.close,
+    const closeButton = (hAsync("button", { "aria-label": this.messages.close, class: CSS$r.close, onClick: this.close,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.closeButton = el) }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : "s" })));
     const hasActionEnd = getSlotted(el, SLOTS$e.actionsEnd);
-    return (hAsync("div", { class: CSS$q.container }, this.requestedIcon ? (hAsync("div", { class: CSS$q.icon }, hAsync("calcite-icon", { flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }))) : null, hAsync("div", { class: CSS$q.content }, hAsync("slot", { name: SLOTS$e.title }), hAsync("slot", { name: SLOTS$e.message }), hAsync("slot", { name: SLOTS$e.link })), hasActionEnd ? (hAsync("div", { class: CSS$q.actionsEnd }, hAsync("slot", { name: SLOTS$e.actionsEnd }))) : null, this.closable ? closeButton : null));
+    return (hAsync("div", { class: CSS$r.container }, this.requestedIcon ? (hAsync("div", { class: CSS$r.icon }, hAsync("calcite-icon", { flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }))) : null, hAsync("div", { class: CSS$r.content }, hAsync("slot", { name: SLOTS$e.title }), hAsync("slot", { name: SLOTS$e.message }), hAsync("slot", { name: SLOTS$e.link })), hasActionEnd ? (hAsync("div", { class: CSS$r.actionsEnd }, hAsync("slot", { name: SLOTS$e.actionsEnd }))) : null, this.closable ? closeButton : null));
   }
   //--------------------------------------------------------------------------
   //
@@ -29587,7 +29572,7 @@ class OptionGroup {
   }; }
 }
 
-const CSS$p = {
+const CSS$q = {
   page: "page",
   selected: "is-selected",
   previous: "previous",
@@ -29745,8 +29730,8 @@ class Pagination {
     const displayedPage = numberStringFormatter.localize(page.toString());
     const selected = start === this.startItem;
     return (hAsync("button", { "aria-current": selected ? "page" : "false", class: {
-        [CSS$p.page]: true,
-        [CSS$p.selected]: selected
+        [CSS$q.page]: true,
+        [CSS$q.selected]: selected
       }, onClick: () => {
         this.startItem = start;
         this.emitUpdate();
@@ -29754,12 +29739,12 @@ class Pagination {
   }
   renderLeftEllipsis() {
     if (this.totalItems / this.pageSize > maxPagesDisplayed && this.showLeftEllipsis()) {
-      return hAsync("span", { class: `${CSS$p.ellipsis} ${CSS$p.ellipsisStart}` }, "\u2026");
+      return hAsync("span", { class: `${CSS$q.ellipsis} ${CSS$q.ellipsisStart}` }, "\u2026");
     }
   }
   renderRightEllipsis() {
     if (this.totalItems / this.pageSize > maxPagesDisplayed && this.showRightEllipsis()) {
-      return hAsync("span", { class: `${CSS$p.ellipsis} ${CSS$p.ellipsisEnd}` }, "\u2026");
+      return hAsync("span", { class: `${CSS$q.ellipsis} ${CSS$q.ellipsisEnd}` }, "\u2026");
     }
   }
   render() {
@@ -29767,11 +29752,11 @@ class Pagination {
     const prevDisabled = pageSize === 1 ? startItem <= pageSize : startItem < pageSize;
     const nextDisabled = pageSize === 1 ? startItem + pageSize > totalItems : startItem + pageSize > totalItems;
     return (hAsync(Fragment, null, hAsync("button", { "aria-label": this.messages.previous, class: {
-        [CSS$p.previous]: true,
-        [CSS$p.disabled]: prevDisabled
+        [CSS$q.previous]: true,
+        [CSS$q.disabled]: prevDisabled
       }, disabled: prevDisabled, onClick: this.previousClicked }, hAsync("calcite-icon", { flipRtl: true, icon: "chevronLeft", scale: this.scale === "l" ? "m" : "s" })), totalItems > pageSize ? this.renderPage(1) : null, this.renderLeftEllipsis(), this.renderPages(), this.renderRightEllipsis(), this.renderPage(this.getLastStart()), hAsync("button", { "aria-label": this.messages.next, class: {
-        [CSS$p.next]: true,
-        [CSS$p.disabled]: nextDisabled
+        [CSS$q.next]: true,
+        [CSS$q.disabled]: nextDisabled
       }, disabled: nextDisabled, onClick: this.nextClicked }, hAsync("calcite-icon", { flipRtl: true, icon: "chevronRight", scale: this.scale === "l" ? "m" : "s" }))));
   }
   static get delegatesFocus() { return true; }
@@ -30000,22 +29985,22 @@ class Panel {
   // --------------------------------------------------------------------------
   renderHeaderContent() {
     const { heading, headingLevel, description, hasHeaderContent } = this;
-    const headingNode = heading ? (hAsync(Heading, { class: CSS$F.heading, level: headingLevel }, heading)) : null;
-    const descriptionNode = description ? hAsync("span", { class: CSS$F.description }, description) : null;
-    return !hasHeaderContent && (headingNode || descriptionNode) ? (hAsync("div", { class: CSS$F.headerContent, key: "header-content" }, headingNode, descriptionNode)) : null;
+    const headingNode = heading ? (hAsync(Heading, { class: CSS$G.heading, level: headingLevel }, heading)) : null;
+    const descriptionNode = description ? hAsync("span", { class: CSS$G.description }, description) : null;
+    return !hasHeaderContent && (headingNode || descriptionNode) ? (hAsync("div", { class: CSS$G.headerContent, key: "header-content" }, headingNode, descriptionNode)) : null;
   }
   renderActionBar() {
-    return (hAsync("div", { class: CSS$F.actionBarContainer, hidden: !this.hasActionBar }, hAsync("slot", { name: SLOTS$l.actionBar, onSlotchange: this.handleActionBarSlotChange })));
+    return (hAsync("div", { class: CSS$G.actionBarContainer, hidden: !this.hasActionBar }, hAsync("slot", { name: SLOTS$l.actionBar, onSlotchange: this.handleActionBarSlotChange })));
   }
   /**
    * Allows user to override the entire header-content node.
    */
   renderHeaderSlottedContent() {
-    return (hAsync("div", { class: CSS$F.headerContent, hidden: !this.hasHeaderContent, key: "slotted-header-content" }, hAsync("slot", { name: SLOTS$l.headerContent, onSlotchange: this.handleHeaderContentSlotChange })));
+    return (hAsync("div", { class: CSS$G.headerContent, hidden: !this.hasHeaderContent, key: "slotted-header-content" }, hAsync("slot", { name: SLOTS$l.headerContent, onSlotchange: this.handleHeaderContentSlotChange })));
   }
   renderHeaderStartActions() {
     const { hasStartActions } = this;
-    return (hAsync("div", { class: { [CSS$F.headerActionsStart]: true, [CSS$F.headerActions]: true }, hidden: !hasStartActions, key: "header-actions-start" }, hAsync("slot", { name: SLOTS$l.headerActionsStart, onSlotchange: this.handleHeaderActionsStartSlotChange })));
+    return (hAsync("div", { class: { [CSS$G.headerActionsStart]: true, [CSS$G.headerActions]: true }, hidden: !hasStartActions, key: "header-actions-start" }, hAsync("slot", { name: SLOTS$l.headerActionsStart, onSlotchange: this.handleHeaderActionsStartSlotChange })));
   }
   renderHeaderActionsEnd() {
     const { close, hasEndActions, messages, closable, hasMenuItems } = this;
@@ -30025,7 +30010,7 @@ class Panel {
       ref: this.setCloseRef })) : null;
     const slotNode = (hAsync("slot", { name: SLOTS$l.headerActionsEnd, onSlotchange: this.handleHeaderActionsEndSlotChange }));
     const showContainer = hasEndActions || closableNode || hasMenuItems;
-    return (hAsync("div", { class: { [CSS$F.headerActionsEnd]: true, [CSS$F.headerActions]: true }, hidden: !showContainer, key: "header-actions-end" }, slotNode, this.renderMenu(), closableNode));
+    return (hAsync("div", { class: { [CSS$G.headerActionsEnd]: true, [CSS$G.headerActions]: true }, hidden: !showContainer, key: "header-actions-end" }, slotNode, this.renderMenu(), closableNode));
   }
   renderMenu() {
     const { hasMenuItems, messages, menuOpen } = this;
@@ -30040,31 +30025,31 @@ class Panel {
       hasEndActions ||
       closable ||
       hasMenuItems;
-    return (hAsync("header", { class: CSS$F.header, hidden: !showHeader }, this.renderHeaderStartActions(), this.renderHeaderSlottedContent(), headerContentNode, this.renderHeaderActionsEnd()));
+    return (hAsync("header", { class: CSS$G.header, hidden: !showHeader }, this.renderHeaderStartActions(), this.renderHeaderSlottedContent(), headerContentNode, this.renderHeaderActionsEnd()));
   }
   renderFooterNode() {
     const { hasFooterContent, hasFooterActions } = this;
     const showFooter = hasFooterContent || hasFooterActions;
-    return (hAsync("footer", { class: CSS$F.footer, hidden: !showFooter }, hAsync("slot", { key: "footer-slot", name: SLOTS$l.footer, onSlotchange: this.handleFooterSlotChange }), hAsync("slot", { key: "footer-actions-slot", name: SLOTS$l.footerActions, onSlotchange: this.handleFooterActionsSlotChange })));
+    return (hAsync("footer", { class: CSS$G.footer, hidden: !showFooter }, hAsync("slot", { key: "footer-slot", name: SLOTS$l.footer, onSlotchange: this.handleFooterSlotChange }), hAsync("slot", { key: "footer-actions-slot", name: SLOTS$l.footerActions, onSlotchange: this.handleFooterActionsSlotChange })));
   }
   renderContent() {
     const { hasFab } = this;
     const defaultSlotNode = hAsync("slot", { key: "default-slot" });
-    const containerNode = hasFab ? (hAsync("section", { class: CSS$F.contentContainer }, defaultSlotNode)) : (defaultSlotNode);
+    const containerNode = hasFab ? (hAsync("section", { class: CSS$G.contentContainer }, defaultSlotNode)) : (defaultSlotNode);
     return (hAsync("div", { class: {
-        [CSS$F.contentWrapper]: true,
-        [CSS$F.contentContainer]: !hasFab,
-        [CSS$F.contentHeight]: hasFab
+        [CSS$G.contentWrapper]: true,
+        [CSS$G.contentContainer]: !hasFab,
+        [CSS$G.contentHeight]: hasFab
       }, onScroll: this.panelScrollHandler,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setPanelScrollEl }, containerNode, this.renderFab()));
   }
   renderFab() {
-    return (hAsync("div", { class: CSS$F.fabContainer, hidden: !this.hasFab }, hAsync("slot", { name: SLOTS$l.fab, onSlotchange: this.handleFabSlotChange })));
+    return (hAsync("div", { class: CSS$G.fabContainer, hidden: !this.hasFab }, hAsync("slot", { name: SLOTS$l.fab, onSlotchange: this.handleFabSlotChange })));
   }
   render() {
     const { loading, panelKeyDownHandler, closed, closable } = this;
-    const panelNode = (hAsync("article", { "aria-busy": toAriaBoolean(loading), class: CSS$F.container, hidden: closed, onKeyDown: panelKeyDownHandler, tabIndex: closable ? 0 : -1,
+    const panelNode = (hAsync("article", { "aria-busy": toAriaBoolean(loading), class: CSS$G.container, hidden: closed, onKeyDown: panelKeyDownHandler, tabIndex: closable ? 0 : -1,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setContainerRef }, this.renderHeaderNode(), this.renderActionBar(), this.renderContent(), this.renderFooterNode()));
     return (hAsync(Fragment, null, loading ? hAsync("calcite-scrim", { loading: loading }) : null, panelNode));
@@ -30109,7 +30094,7 @@ class Panel {
   }; }
 }
 
-const CSS$o = {
+const CSS$p = {
   sticky: "sticky-pos"
 };
 var ICON_TYPES$1;
@@ -30122,7 +30107,7 @@ const SLOTS$d = {
   menuActions: "menu-actions"
 };
 
-const CSS$n = {
+const CSS$o = {
   heading: "heading",
   container: "container",
   indented: "container--indented"
@@ -30448,7 +30433,7 @@ const List = ({ props: { disabled, loading, filterEnabled, dataForFilter, handle
       dragEnabled ? (hAsync("span", { "aria-live": "assertive", class: "assistive-text", 
         // eslint-disable-next-line react/jsx-sort-props
         ref: storeAssistiveEl })) : null,
-      hAsync("header", { class: { [CSS$o.sticky]: true } },
+      hAsync("header", { class: { [CSS$p.sticky]: true } },
         filterEnabled ? (hAsync("calcite-filter", { "aria-label": filterPlaceholder, disabled: loading || disabled, items: dataForFilter, onCalciteFilterChange: handleFilterEvent, placeholder: filterPlaceholder, value: filterText, 
           // eslint-disable-next-line react/jsx-sort-props
           ref: setFilterEl })) : null,
@@ -30637,14 +30622,14 @@ class PickListGroup {
     const { el, groupTitle, headingLevel } = this;
     const hasParentItem = getSlotted(el, SLOTS$c.parentItem) !== null;
     const sectionClasses = {
-      [CSS$n.container]: true,
-      [CSS$n.indented]: hasParentItem
+      [CSS$o.container]: true,
+      [CSS$o.indented]: hasParentItem
     };
     const title = groupTitle;
     const parentLevel = el.closest("calcite-pick-list")?.headingLevel;
     const relativeLevel = parentLevel ? constrainHeadingLevel(parentLevel + 1) : null;
     const level = headingLevel || relativeLevel;
-    return (hAsync(Fragment, null, title ? (hAsync(Heading, { class: CSS$n.heading, level: level }, title)) : null, hAsync("slot", { name: SLOTS$c.parentItem }), hAsync("section", { class: sectionClasses }, hAsync("slot", null))));
+    return (hAsync(Fragment, null, title ? (hAsync(Heading, { class: CSS$o.heading, level: level }, title)) : null, hAsync("slot", { name: SLOTS$c.parentItem }), hAsync("section", { class: sectionClasses }, hAsync("slot", null))));
   }
   get el() { return getElement(this); }
   static get style() { return pickListGroupCss; }
@@ -30661,7 +30646,7 @@ class PickListGroup {
   }; }
 }
 
-const CSS$m = {
+const CSS$n = {
   actions: "actions",
   actionsEnd: "actions--end",
   actionsStart: "actions--start",
@@ -30821,28 +30806,28 @@ class PickListItem {
       return null;
     }
     return (hAsync("span", { class: {
-        [CSS$m.icon]: true,
-        [CSS$m.iconDot]: icon === ICON_TYPES$1.circle
+        [CSS$n.icon]: true,
+        [CSS$n.iconDot]: icon === ICON_TYPES$1.circle
       }, onClick: this.pickListClickHandler }, icon === ICON_TYPES$1.square ? (hAsync("calcite-icon", { flipRtl: iconFlipRtl, icon: ICONS$5.checked, scale: "s" })) : null));
   }
   renderRemoveAction() {
-    return this.removable ? (hAsync("calcite-action", { class: CSS$m.remove, icon: ICONS$5.remove, onClick: this.removeClickHandler, slot: SLOTS$b.actionsEnd, text: this.messages.remove })) : null;
+    return this.removable ? (hAsync("calcite-action", { class: CSS$n.remove, icon: ICONS$5.remove, onClick: this.removeClickHandler, slot: SLOTS$b.actionsEnd, text: this.messages.remove })) : null;
   }
   renderActionsStart() {
     const { el } = this;
     const hasActionsStart = getSlotted(el, SLOTS$b.actionsStart);
-    return hasActionsStart ? (hAsync("div", { class: { [CSS$m.actions]: true, [CSS$m.actionsStart]: true } }, hAsync("slot", { name: SLOTS$b.actionsStart }))) : null;
+    return hasActionsStart ? (hAsync("div", { class: { [CSS$n.actions]: true, [CSS$n.actionsStart]: true } }, hAsync("slot", { name: SLOTS$b.actionsStart }))) : null;
   }
   renderActionsEnd() {
     const { el, removable } = this;
     const hasActionsEnd = getSlotted(el, SLOTS$b.actionsEnd);
-    return hasActionsEnd || removable ? (hAsync("div", { class: { [CSS$m.actions]: true, [CSS$m.actionsEnd]: true } }, hAsync("slot", { name: SLOTS$b.actionsEnd }), this.renderRemoveAction())) : null;
+    return hasActionsEnd || removable ? (hAsync("div", { class: { [CSS$n.actions]: true, [CSS$n.actionsEnd]: true } }, hAsync("slot", { name: SLOTS$b.actionsEnd }), this.renderRemoveAction())) : null;
   }
   render() {
     const { description, label } = this;
-    return (hAsync(Fragment, null, this.renderIcon(), this.renderActionsStart(), hAsync("label", { "aria-label": label, class: CSS$m.label, onClick: this.pickListClickHandler, onKeyDown: this.pickListKeyDownHandler, tabIndex: 0,
+    return (hAsync(Fragment, null, this.renderIcon(), this.renderActionsStart(), hAsync("label", { "aria-label": label, class: CSS$n.label, onClick: this.pickListClickHandler, onKeyDown: this.pickListKeyDownHandler, tabIndex: 0,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (focusEl) => (this.focusEl = focusEl) }, hAsync("div", { "aria-checked": toAriaBoolean(this.selected), class: CSS$m.textContainer, role: "menuitemcheckbox" }, hAsync("span", { class: CSS$m.title }, label), description ? hAsync("span", { class: CSS$m.description }, description) : null)), this.renderActionsEnd()));
+      ref: (focusEl) => (this.focusEl = focusEl) }, hAsync("div", { "aria-checked": toAriaBoolean(this.selected), class: CSS$n.textContainer, role: "menuitemcheckbox" }, hAsync("span", { class: CSS$n.title }, label), description ? hAsync("span", { class: CSS$n.description }, description) : null)), this.renderActionsEnd()));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -30885,7 +30870,7 @@ class PickListItem {
   }; }
 }
 
-const CSS$l = {
+const CSS$m = {
   container: "container",
   imageContainer: "image-container",
   closeButtonContainer: "close-button-container",
@@ -30979,7 +30964,7 @@ class PopoverManager {
   }
 }
 
-const CSS$k = {
+const CSS$l = {
   arrow: "calcite-floating-ui-arrow",
   arrowStroke: "calcite-floating-ui-arrow__stroke"
 };
@@ -31009,8 +30994,8 @@ const FloatingArrow = ({ floatingLayout, key, ref }) => {
     ` L${width - svgX},${height}` +
     ` Q${svgX},${height} ${svgX},${height}` +
     " Z";
-  return (hAsync("svg", { "aria-hidden": "true", class: CSS$k.arrow, height: width, key: key, ref: ref, viewBox: `0 0 ${width} ${width + (!isVertical ? strokeWidth : 0)}`, width: width + (isVertical ? strokeWidth : 0) },
-    strokeWidth > 0 && (hAsync("path", { class: CSS$k.arrowStroke, d: dValue, fill: "none", "stroke-width": strokeWidth + 1 })),
+  return (hAsync("svg", { "aria-hidden": "true", class: CSS$l.arrow, height: width, key: key, ref: ref, viewBox: `0 0 ${width} ${width + (!isVertical ? strokeWidth : 0)}`, width: width + (isVertical ? strokeWidth : 0) },
+    strokeWidth > 0 && (hAsync("path", { class: CSS$l.arrowStroke, d: dValue, fill: "none", "stroke-width": strokeWidth + 1 })),
     hAsync("path", { d: dValue, stroke: "none" })));
 };
 
@@ -31266,14 +31251,14 @@ class Popover {
   // --------------------------------------------------------------------------
   renderCloseButton() {
     const { messages, closable } = this;
-    return closable ? (hAsync("div", { class: CSS$l.closeButtonContainer, key: CSS$l.closeButtonContainer }, hAsync("calcite-action", { appearance: "transparent", class: CSS$l.closeButton, onClick: this.hide, scale: this.scale, text: messages.close,
+    return closable ? (hAsync("div", { class: CSS$m.closeButtonContainer, key: CSS$m.closeButtonContainer }, hAsync("calcite-action", { appearance: "transparent", class: CSS$m.closeButton, onClick: this.hide, scale: this.scale, text: messages.close,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (closeButtonEl) => (this.closeButtonEl = closeButtonEl) }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : this.scale })))) : null;
   }
   renderHeader() {
     const { heading, headingLevel } = this;
-    const headingNode = heading ? (hAsync(Heading, { class: CSS$l.heading, level: headingLevel }, heading)) : null;
-    return headingNode ? (hAsync("div", { class: CSS$l.header, key: CSS$l.header }, headingNode, this.renderCloseButton())) : null;
+    const headingNode = heading ? (hAsync(Heading, { class: CSS$m.heading, level: headingLevel }, heading)) : null;
+    return headingNode ? (hAsync("div", { class: CSS$m.header, key: CSS$m.header }, headingNode, this.renderCloseButton())) : null;
   }
   render() {
     const { effectiveReferenceElement, heading, label, open, pointerDisabled, floatingLayout } = this;
@@ -31288,9 +31273,9 @@ class Popover {
       },
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setTransitionEl }, arrowNode, hAsync("div", { class: {
-        [CSS$l.hasHeader]: !!heading,
-        [CSS$l.container]: true
-      } }, this.renderHeader(), hAsync("div", { class: CSS$l.content }, hAsync("slot", null)), !heading ? this.renderCloseButton() : null))));
+        [CSS$m.hasHeader]: !!heading,
+        [CSS$m.container]: true
+      } }, this.renderHeader(), hAsync("div", { class: CSS$m.content }, hAsync("slot", null)), !heading ? this.renderCloseButton() : null))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -31382,7 +31367,7 @@ class Progress {
   }; }
 }
 
-const CSS$j = {
+const CSS$k = {
   container: "container"
 };
 
@@ -31632,7 +31617,7 @@ class RadioButton {
   // --------------------------------------------------------------------------
   render() {
     const tabIndex = this.getTabIndex();
-    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.handleKeyDown }, hAsync("div", { "aria-checked": toAriaBoolean(this.checked), "aria-label": getLabelText(this), class: CSS$j.container, onBlur: this.onContainerBlur, onFocus: this.onContainerFocus, role: "radio", tabIndex: tabIndex,
+    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.handleKeyDown }, hAsync("div", { "aria-checked": toAriaBoolean(this.checked), "aria-label": getLabelText(this), class: CSS$k.container, onBlur: this.onContainerBlur, onFocus: this.onContainerFocus, role: "radio", tabIndex: tabIndex,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setContainerEl }, hAsync("div", { class: "radio" })), hAsync(HiddenFormInputSlot, { component: this })));
   }
@@ -32042,7 +32027,7 @@ class Rating {
   }; }
 }
 
-const CSS$i = {
+const CSS$j = {
   scrim: "scrim",
   content: "content"
 };
@@ -32092,8 +32077,8 @@ class Scrim {
     const { el, loading, messages } = this;
     const hasContent = el.innerHTML.trim().length > 0;
     const loaderNode = loading ? hAsync("calcite-loader", { label: messages.loading }) : null;
-    const contentNode = hasContent ? (hAsync("div", { class: CSS$i.content }, hAsync("slot", null))) : null;
-    return (hAsync("div", { class: CSS$i.scrim }, loaderNode, contentNode));
+    const contentNode = hasContent ? (hAsync("div", { class: CSS$j.content }, hAsync("slot", null))) : null;
+    return (hAsync("div", { class: CSS$j.scrim }, loaderNode, contentNode));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -32325,7 +32310,7 @@ class SegmentedControl {
 const SLOTS$a = {
   input: "input"
 };
-const CSS$h = {
+const CSS$i = {
   segmentedControlItemIcon: "segmented-control-item-icon"
 };
 
@@ -32349,8 +32334,8 @@ class SegmentedControlItem {
     const scale = getElementProp(this.el, "scale", "m");
     const appearance = getElementProp(this.el, "appearance", "solid");
     const layout = getElementProp(this.el, "layout", "horizontal");
-    const iconStartEl = this.iconStart ? (hAsync("calcite-icon", { class: CSS$h.segmentedControlItemIcon, flipRtl: this.iconFlipRtl, icon: this.iconStart, key: "icon-start", scale: "s" })) : null;
-    const iconEndEl = this.iconEnd ? (hAsync("calcite-icon", { class: CSS$h.segmentedControlItemIcon, flipRtl: this.iconFlipRtl, icon: this.iconEnd, key: "icon-end", scale: "s" })) : null;
+    const iconStartEl = this.iconStart ? (hAsync("calcite-icon", { class: CSS$i.segmentedControlItemIcon, flipRtl: this.iconFlipRtl, icon: this.iconStart, key: "icon-start", scale: "s" })) : null;
+    const iconEndEl = this.iconEnd ? (hAsync("calcite-icon", { class: CSS$i.segmentedControlItemIcon, flipRtl: this.iconFlipRtl, icon: this.iconEnd, key: "icon-end", scale: "s" })) : null;
     return (hAsync(Host, { "aria-checked": toAriaBoolean(checked), "aria-label": value, role: "radio" }, hAsync("label", { class: {
         "label--scale-s": scale === "s",
         "label--scale-m": scale === "m",
@@ -32381,7 +32366,7 @@ class SegmentedControlItem {
   }; }
 }
 
-const CSS$g = {
+const CSS$h = {
   icon: "icon",
   iconContainer: "icon-container",
   select: "select"
@@ -32566,10 +32551,10 @@ class Select {
   //
   //--------------------------------------------------------------------------
   renderChevron() {
-    return (hAsync("div", { class: CSS$g.iconContainer }, hAsync("calcite-icon", { class: CSS$g.icon, icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" })));
+    return (hAsync("div", { class: CSS$h.iconContainer }, hAsync("calcite-icon", { class: CSS$h.icon, icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" })));
   }
   render() {
-    return (hAsync(Fragment, null, hAsync("select", { "aria-label": getLabelText(this), class: CSS$g.select, disabled: this.disabled, onChange: this.handleInternalSelectChange,
+    return (hAsync(Fragment, null, hAsync("select", { "aria-label": getLabelText(this), class: CSS$h.select, disabled: this.disabled, onChange: this.handleInternalSelectChange,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.storeSelectRef }, hAsync("slot", null)), this.renderChevron(), hAsync(HiddenFormInputSlot, { component: this })));
   }
@@ -32600,7 +32585,7 @@ class Select {
   }; }
 }
 
-const CSS$f = {
+const CSS$g = {
   main: "main",
   content: "content",
   contentBehind: "content--behind",
@@ -32691,7 +32676,7 @@ class Shell {
     return (hAsync("div", { hidden: !this.hasHeader }, hAsync("slot", { key: "header", name: SLOTS$9.header, onSlotchange: this.handleHeaderSlotChange })));
   }
   renderFooter() {
-    return (hAsync("div", { class: CSS$f.footer, hidden: !this.hasFooter, key: "footer" }, hAsync("slot", { name: SLOTS$9.footer, onSlotchange: this.handleFooterSlotChange })));
+    return (hAsync("div", { class: CSS$g.footer, hidden: !this.hasFooter, key: "footer" }, hAsync("slot", { name: SLOTS$9.footer, onSlotchange: this.handleFooterSlotChange })));
   }
   renderAlerts() {
     return (hAsync("div", { hidden: !this.hasAlerts }, hAsync("slot", { key: "alerts", name: SLOTS$9.alerts, onSlotchange: this.handleAlertsSlotChange })));
@@ -32708,21 +32693,21 @@ class Shell {
     const content = !!this.contentBehind
       ? [
         hAsync("div", { class: {
-            [CSS$f.content]: true,
-            [CSS$f.contentBehind]: true
+            [CSS$g.content]: true,
+            [CSS$g.contentBehind]: true
           }, key: contentContainerKey }, defaultSlotNode),
-        hAsync("div", { class: CSS$f.contentBehindCenterContent }, panelTopSlotNode, panelBottomSlotNode, deprecatedCenterRowSlotNode)
+        hAsync("div", { class: CSS$g.contentBehindCenterContent }, panelTopSlotNode, panelBottomSlotNode, deprecatedCenterRowSlotNode)
       ]
       : [
-        hAsync("div", { class: CSS$f.content, key: contentContainerKey }, panelTopSlotNode, defaultSlotNode, panelBottomSlotNode, deprecatedCenterRowSlotNode)
+        hAsync("div", { class: CSS$g.content, key: contentContainerKey }, panelTopSlotNode, defaultSlotNode, panelBottomSlotNode, deprecatedCenterRowSlotNode)
       ];
     return content;
   }
   renderMain() {
-    return (hAsync("div", { class: CSS$f.main }, hAsync("slot", { name: SLOTS$9.panelStart }), this.renderContent(), hAsync("slot", { name: SLOTS$9.panelEnd })));
+    return (hAsync("div", { class: CSS$g.main }, hAsync("slot", { name: SLOTS$9.panelStart }), this.renderContent(), hAsync("slot", { name: SLOTS$9.panelEnd })));
   }
   renderPositionedSlots() {
-    return (hAsync("div", { class: CSS$f.positionedSlotWrapper }, this.renderAlerts(), this.renderModals()));
+    return (hAsync("div", { class: CSS$g.positionedSlotWrapper }, this.renderAlerts(), this.renderModals()));
   }
   render() {
     return (hAsync(Fragment, null, this.renderHeader(), this.renderMain(), this.renderFooter(), this.renderPositionedSlots()));
@@ -32745,7 +32730,7 @@ class Shell {
   }; }
 }
 
-const CSS$e = {
+const CSS$f = {
   actionBarContainer: "action-bar-container",
   content: "content"
 };
@@ -32784,9 +32769,9 @@ class ShellCenterRow {
   // --------------------------------------------------------------------------
   render() {
     const { el } = this;
-    const contentNode = (hAsync("div", { class: CSS$e.content }, hAsync("slot", null)));
+    const contentNode = (hAsync("div", { class: CSS$f.content }, hAsync("slot", null)));
     const actionBar = getSlotted(el, SLOTS$8.actionBar);
-    const actionBarNode = actionBar ? (hAsync("div", { class: CSS$e.actionBarContainer, key: "action-bar" }, hAsync("slot", { name: SLOTS$8.actionBar }))) : null;
+    const actionBarNode = actionBar ? (hAsync("div", { class: CSS$f.actionBarContainer, key: "action-bar" }, hAsync("slot", { name: SLOTS$8.actionBar }))) : null;
     const children = [actionBarNode, contentNode];
     if (actionBar?.position === "end") {
       children.reverse();
@@ -32809,7 +32794,7 @@ class ShellCenterRow {
   }; }
 }
 
-const CSS$d = {
+const CSS$e = {
   container: "container",
   content: "content",
   contentHeader: "content__header",
@@ -33070,7 +33055,7 @@ class ShellPanel {
   renderHeader() {
     const { el } = this;
     const hasHeader = getSlotted(el, SLOTS$7.header);
-    return hasHeader ? (hAsync("div", { class: CSS$d.contentHeader, key: "header" }, hAsync("slot", { name: SLOTS$7.header }))) : null;
+    return hasHeader ? (hAsync("div", { class: CSS$e.contentHeader, key: "header" }, hAsync("slot", { name: SLOTS$7.header }))) : null;
   }
   render() {
     const { collapsed, position, initialContentWidth, initialContentHeight, contentWidth, contentWidthMax, contentWidthMin, contentHeight, contentHeightMax, contentHeightMin, resizable, layout, displayMode } = this;
@@ -33087,7 +33072,7 @@ class ShellPanel {
       : null;
     const separatorNode = !collapsed && allowResizing ? (hAsync("div", { "aria-label": this.messages.resize, "aria-orientation": layout === "horizontal" ? "vertical" : "horizontal", "aria-valuemax": layout == "horizontal" ? contentHeightMax : contentWidthMax, "aria-valuemin": layout == "horizontal" ? contentHeightMin : contentWidthMin, "aria-valuenow": layout == "horizontal"
         ? contentHeight ?? initialContentHeight
-        : contentWidth ?? initialContentWidth, class: CSS$d.separator, key: "separator", onKeyDown: this.separatorKeyDown, role: "separator", tabIndex: 0, "touch-action": "none",
+        : contentWidth ?? initialContentWidth, class: CSS$e.separator, key: "separator", onKeyDown: this.separatorKeyDown, role: "separator", tabIndex: 0, "touch-action": "none",
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.connectSeparator })) : null;
     const getAnimationDir = () => {
@@ -33103,20 +33088,20 @@ class ShellPanel {
     };
     const contentNode = (hAsync("div", { class: {
         [CSS_UTILITY.rtl]: dir === "rtl",
-        [CSS$d.content]: true,
-        [CSS$d.contentOverlay]: displayMode === "overlay",
-        [CSS$d.contentFloat]: displayMode === "float",
+        [CSS$e.content]: true,
+        [CSS$e.contentOverlay]: displayMode === "overlay",
+        [CSS$e.contentFloat]: displayMode === "float",
         [CSS_UTILITY.calciteAnimate]: displayMode === "overlay",
         [getAnimationDir()]: displayMode === "overlay"
       }, hidden: collapsed, key: "content", style: style,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.storeContentEl }, this.renderHeader(), hAsync("div", { class: CSS$d.contentBody }, hAsync("slot", null)), separatorNode));
+      ref: this.storeContentEl }, this.renderHeader(), hAsync("div", { class: CSS$e.contentBody }, hAsync("slot", null)), separatorNode));
     const actionBarNode = (hAsync("slot", { key: "action-bar", name: SLOTS$7.actionBar, onSlotchange: this.handleActionBarSlotChange }));
     const mainNodes = [actionBarNode, contentNode];
     if (position === "end") {
       mainNodes.reverse();
     }
-    return hAsync("div", { class: { [CSS$d.container]: true } }, mainNodes);
+    return hAsync("div", { class: { [CSS$e.container]: true } }, mainNodes);
   }
   // --------------------------------------------------------------------------
   //
@@ -33216,7 +33201,7 @@ class ShellPanel {
   }; }
 }
 
-const CSS$c = {
+const CSS$d = {
   handleLabel: "handle__label",
   handleLabelMinValue: "handle__label--minValue",
   handleLabelValue: "handle__label--value",
@@ -33414,8 +33399,8 @@ class Slider {
     const leftThumbOffset = `${mirror ? 100 - minInterval : minInterval}%`;
     const rightThumbOffset = `${mirror ? maxInterval : 100 - maxInterval}%`;
     const valueIsRange = isRange(this.value);
-    const handleLabelMinValueClasses = `${CSS$c.handleLabel} ${CSS$c.handleLabelMinValue}`;
-    const handleLabelValueClasses = `${CSS$c.handleLabel} ${CSS$c.handleLabelValue}`;
+    const handleLabelMinValueClasses = `${CSS$d.handleLabel} ${CSS$d.handleLabelMinValue}`;
+    const handleLabelValueClasses = `${CSS$d.handleLabel} ${CSS$d.handleLabelValue}`;
     const handle = (hAsync("div", { "aria-disabled": this.disabled, "aria-label": valueIsRange ? this.maxLabel : this.minLabel, "aria-orientation": "horizontal", "aria-valuemax": this.max, "aria-valuemin": this.min, "aria-valuenow": value, class: {
         thumb: true,
         "thumb--value": true,
@@ -33551,8 +33536,8 @@ class Slider {
     const displayedTickValue = this.determineGroupSeparator(tick);
     const tickLabel = (hAsync("span", { class: {
         tick__label: true,
-        [CSS$c.tickMin]: isMinTickLabel,
-        [CSS$c.tickMax]: isMaxTickLabel
+        [CSS$d.tickMin]: isMinTickLabel,
+        [CSS$d.tickMax]: isMaxTickLabel
       } }, displayedTickValue));
     if (this.labelTicks && !this.hasHistogram && !valueIsRange) {
       return tickLabel;
@@ -34096,7 +34081,7 @@ class Slider {
   }; }
 }
 
-const CSS$b = {
+const CSS$c = {
   sortItem: "sort-item",
   container: "container",
   containerHorizontal: "container--horizontal",
@@ -37299,9 +37284,9 @@ class SortableList {
     const { layout } = this;
     const horizontal = layout === "horizontal" || false;
     return (hAsync("div", { class: {
-        [CSS$b.container]: true,
-        [CSS$b.containerVertical]: !horizontal,
-        [CSS$b.containerHorizontal]: horizontal
+        [CSS$c.container]: true,
+        [CSS$c.containerVertical]: !horizontal,
+        [CSS$c.containerHorizontal]: horizontal
       } }, hAsync("slot", null)));
   }
   get el() { return getElement(this); }
@@ -37323,7 +37308,7 @@ class SortableList {
   }; }
 }
 
-const CSS$a = {
+const CSS$b = {
   container: "split-button__container",
   dividerContainer: "split-button__divider-container",
   divider: "split-button__divider",
@@ -37396,13 +37381,13 @@ class SplitButton {
   }
   render() {
     const widthClasses = {
-      [CSS$a.container]: true,
-      [CSS$a.widthAuto]: this.width === "auto",
-      [CSS$a.widthHalf]: this.width === "half",
-      [CSS$a.widthFull]: this.width === "full"
+      [CSS$b.container]: true,
+      [CSS$b.widthAuto]: this.width === "auto",
+      [CSS$b.widthHalf]: this.width === "half",
+      [CSS$b.widthFull]: this.width === "full"
     };
     const buttonWidth = this.width === "auto" ? "auto" : "full";
-    return (hAsync("div", { class: widthClasses }, hAsync("calcite-button", { appearance: this.appearance, disabled: this.disabled, "icon-end": this.primaryIconEnd ? this.primaryIconEnd : null, "icon-start": this.primaryIconStart ? this.primaryIconStart : null, iconFlipRtl: this.primaryIconFlipRtl ? this.primaryIconFlipRtl : null, kind: this.kind, label: this.primaryLabel, loading: this.loading, onClick: this.calciteSplitButtonPrimaryClickHandler, scale: this.scale, splitChild: "primary", type: "button", width: buttonWidth }, this.primaryText), hAsync("div", { class: CSS$a.dividerContainer }, hAsync("div", { class: CSS$a.divider })), hAsync("calcite-dropdown", { disabled: this.disabled, onClick: this.calciteSplitButtonSecondaryClickHandler, open: this.active, overlayPositioning: this.overlayPositioning, placement: "bottom-end", scale: this.scale, width: this.scale }, hAsync("calcite-button", { appearance: this.appearance, disabled: this.disabled, "icon-start": this.dropdownIcon, kind: this.kind, label: this.dropdownLabel, scale: this.scale, slot: "trigger", splitChild: "secondary", type: "button" }), hAsync("slot", null))));
+    return (hAsync("div", { class: widthClasses }, hAsync("calcite-button", { appearance: this.appearance, disabled: this.disabled, "icon-end": this.primaryIconEnd ? this.primaryIconEnd : null, "icon-start": this.primaryIconStart ? this.primaryIconStart : null, iconFlipRtl: this.primaryIconFlipRtl ? this.primaryIconFlipRtl : null, kind: this.kind, label: this.primaryLabel, loading: this.loading, onClick: this.calciteSplitButtonPrimaryClickHandler, scale: this.scale, splitChild: "primary", type: "button", width: buttonWidth }, this.primaryText), hAsync("div", { class: CSS$b.dividerContainer }, hAsync("div", { class: CSS$b.divider })), hAsync("calcite-dropdown", { disabled: this.disabled, onClick: this.calciteSplitButtonSecondaryClickHandler, open: this.active, overlayPositioning: this.overlayPositioning, placement: "bottom-end", scale: this.scale, width: this.scale }, hAsync("calcite-button", { appearance: this.appearance, disabled: this.disabled, "icon-start": this.dropdownIcon, kind: this.kind, label: this.dropdownLabel, scale: this.scale, slot: "trigger", splitChild: "secondary", type: "button" }), hAsync("slot", null))));
   }
   get dropdownIcon() {
     return this.dropdownIconType === "chevron"
@@ -37447,7 +37432,7 @@ class SplitButton {
   }; }
 }
 
-const CSS$9 = {
+const CSS$a = {
   container: "container",
   actionsStart: "actions-start",
   contentStart: "content-start",
@@ -37504,25 +37489,25 @@ class Stack {
   // --------------------------------------------------------------------------
   renderActionsStart() {
     const { hasActionsStart } = this;
-    return (hAsync("div", { class: CSS$9.actionsStart, hidden: !hasActionsStart, key: "actions-start-container" }, hAsync("slot", { name: SLOTS$6.actionsStart, onSlotchange: this.handleActionsStartSlotChange })));
+    return (hAsync("div", { class: CSS$a.actionsStart, hidden: !hasActionsStart, key: "actions-start-container" }, hAsync("slot", { name: SLOTS$6.actionsStart, onSlotchange: this.handleActionsStartSlotChange })));
   }
   renderActionsEnd() {
     const { hasActionsEnd } = this;
-    return (hAsync("div", { class: CSS$9.actionsEnd, hidden: !hasActionsEnd, key: "actions-end-container" }, hAsync("slot", { name: SLOTS$6.actionsEnd, onSlotchange: this.handleActionsEndSlotChange })));
+    return (hAsync("div", { class: CSS$a.actionsEnd, hidden: !hasActionsEnd, key: "actions-end-container" }, hAsync("slot", { name: SLOTS$6.actionsEnd, onSlotchange: this.handleActionsEndSlotChange })));
   }
   renderContentStart() {
     const { hasContentStart } = this;
-    return (hAsync("div", { class: CSS$9.contentStart, hidden: !hasContentStart }, hAsync("slot", { name: SLOTS$6.contentStart, onSlotchange: this.handleContentStartSlotChange })));
+    return (hAsync("div", { class: CSS$a.contentStart, hidden: !hasContentStart }, hAsync("slot", { name: SLOTS$6.contentStart, onSlotchange: this.handleContentStartSlotChange })));
   }
   renderDefaultContent() {
-    return (hAsync("div", { class: CSS$9.content }, hAsync("slot", null)));
+    return (hAsync("div", { class: CSS$a.content }, hAsync("slot", null)));
   }
   renderContentEnd() {
     const { hasContentEnd } = this;
-    return (hAsync("div", { class: CSS$9.contentEnd, hidden: !hasContentEnd }, hAsync("slot", { name: SLOTS$6.contentEnd, onSlotchange: this.handleContentEndSlotChange })));
+    return (hAsync("div", { class: CSS$a.contentEnd, hidden: !hasContentEnd }, hAsync("slot", { name: SLOTS$6.contentEnd, onSlotchange: this.handleContentEndSlotChange })));
   }
   render() {
-    return (hAsync(Host, null, hAsync("div", { class: CSS$9.container }, this.renderActionsStart(), this.renderContentStart(), this.renderDefaultContent(), this.renderContentEnd(), this.renderActionsEnd())));
+    return (hAsync(Host, null, hAsync("div", { class: CSS$a.container }, this.renderActionsStart(), this.renderContentStart(), this.renderDefaultContent(), this.renderContentEnd(), this.renderActionsEnd())));
   }
   static get style() { return stackCss; }
   static get cmpMeta() { return {
@@ -38421,7 +38406,7 @@ class TabNav {
   }; }
 }
 
-const CSS$8 = {
+const CSS$9 = {
   closeButton: "close-button",
   container: "container",
   content: "content",
@@ -38544,18 +38529,18 @@ class TabTitle {
   render() {
     const { el, closed } = this;
     const id = el.id || this.guid;
-    const iconStartEl = (hAsync("calcite-icon", { class: { [CSS$8.titleIcon]: true, [CSS$8.iconStart]: true }, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, scale: this.scale === "l" ? "m" : "s" }));
-    const iconEndEl = (hAsync("calcite-icon", { class: { [CSS$8.titleIcon]: true, [CSS$8.iconEnd]: true }, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, scale: this.scale === "l" ? "m" : "s" }));
+    const iconStartEl = (hAsync("calcite-icon", { class: { [CSS$9.titleIcon]: true, [CSS$9.iconStart]: true }, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, scale: this.scale === "l" ? "m" : "s" }));
+    const iconEndEl = (hAsync("calcite-icon", { class: { [CSS$9.titleIcon]: true, [CSS$9.iconEnd]: true }, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, scale: this.scale === "l" ? "m" : "s" }));
     return (hAsync(Host, { "aria-controls": this.controls, "aria-selected": toAriaBoolean(this.selected), id: id, role: "tab", tabIndex: this.selected ? 0 : -1 }, hAsync("div", { class: {
         container: true,
-        [CSS$8.iconPresent]: !!this.iconStart || !!this.iconEnd
+        [CSS$9.iconPresent]: !!this.iconStart || !!this.iconEnd
       }, hidden: closed,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (el) => this.resizeObserver?.observe(el) }, hAsync("div", { class: { [CSS$8.content]: true, [CSS$8.contentHasText]: this.hasText } }, this.iconStart ? iconStartEl : null, hAsync("slot", null), this.iconEnd ? iconEndEl : null), this.renderCloseButton())));
+      ref: (el) => this.resizeObserver?.observe(el) }, hAsync("div", { class: { [CSS$9.content]: true, [CSS$9.contentHasText]: this.hasText } }, this.iconStart ? iconStartEl : null, hAsync("slot", null), this.iconEnd ? iconEndEl : null), this.renderCloseButton())));
   }
   renderCloseButton() {
     const { closable, messages } = this;
-    return closable ? (hAsync("button", { "aria-label": messages.close, class: CSS$8.closeButton, disabled: false, key: CSS$8.closeButton, onClick: this.closeClickHandler, title: messages.close, type: "button",
+    return closable ? (hAsync("button", { "aria-label": messages.close, class: CSS$9.closeButton, disabled: false, key: CSS$9.closeButton, onClick: this.closeClickHandler, title: messages.close, type: "button",
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.closeButtonEl = el) }, hAsync("calcite-icon", { icon: ICONS$4.close, scale: this.scale === "l" ? "m" : "s" }))) : null;
   }
@@ -38856,7 +38841,7 @@ class Tabs {
   }; }
 }
 
-const CSS$7 = {
+const CSS$8 = {
   characterLimit: "character-limit",
   content: "content",
   container: "container",
@@ -38909,7 +38894,7 @@ class TextArea {
       }
     };
     this.renderCharacterLimit = () => {
-      return this.maxLength ? (hAsync("span", { class: CSS$7.characterLimit }, hAsync("span", { class: { [CSS$7.characterOverLimit]: this.value?.length > this.maxLength } }, this.getLocalizedCharacterLength()), "/", numberStringFormatter.localize(this.maxLength.toString()))) : null;
+      return this.maxLength ? (hAsync("span", { class: CSS$8.characterLimit }, hAsync("span", { class: { [CSS$8.characterOverLimit]: this.value?.length > this.maxLength } }, this.getLocalizedCharacterLength()), "/", numberStringFormatter.localize(this.maxLength.toString()))) : null;
     };
     this.resizeObserver = createObserver();
     // height and width are set to auto here to avoid overlapping on to neighboring elements in the layout when user starts resizing.
@@ -38985,20 +38970,20 @@ class TextArea {
   render() {
     const hasFooter = this.startSlotHasElements || this.endSlotHasElements || !!this.maxLength;
     return (hAsync(Host, null, hAsync("textarea", { "aria-invalid": toAriaBoolean(this.value?.length > this.maxLength), "aria-label": getLabelText(this), autofocus: this.autofocus, class: {
-        [CSS$7.readOnly]: this.readOnly,
-        [CSS$7.textAreaInvalid]: this.value?.length > this.maxLength,
-        [CSS$7.footerSlotted]: this.endSlotHasElements && this.startSlotHasElements,
-        [CSS$7.blockSizeFull]: !hasFooter,
-        [CSS$7.borderColor]: !hasFooter
+        [CSS$8.readOnly]: this.readOnly,
+        [CSS$8.textAreaInvalid]: this.value?.length > this.maxLength,
+        [CSS$8.footerSlotted]: this.endSlotHasElements && this.startSlotHasElements,
+        [CSS$8.blockSizeFull]: !hasFooter,
+        [CSS$8.borderColor]: !hasFooter
       }, cols: this.columns, disabled: this.disabled, name: this.name, onChange: this.handleChange, onInput: this.handleInput, placeholder: this.placeholder, readonly: this.readOnly, required: this.required, rows: this.rows, value: this.value, wrap: this.wrap,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.setTextAreaEl }), hAsync("span", { class: { [CSS$7.content]: true } }, hAsync("slot", { onSlotchange: this.contentSlotChangeHandler })), hAsync("footer", { class: {
-        [CSS$7.footer]: true,
-        [CSS$7.readOnly]: this.readOnly,
-        [CSS$7.hide]: !hasFooter
+      ref: this.setTextAreaEl }), hAsync("span", { class: { [CSS$8.content]: true } }, hAsync("slot", { onSlotchange: this.contentSlotChangeHandler })), hAsync("footer", { class: {
+        [CSS$8.footer]: true,
+        [CSS$8.readOnly]: this.readOnly,
+        [CSS$8.hide]: !hasFooter
       }, ref: (el) => (this.footerEl = el) }, hAsync("div", { class: {
-        [CSS$7.container]: true,
-        [CSS$7.footerEndSlotOnly]: !this.startSlotHasElements && this.endSlotHasElements
+        [CSS$8.container]: true,
+        [CSS$8.footerEndSlotOnly]: !this.startSlotHasElements && this.endSlotHasElements
       } }, hAsync("slot", { name: SLOTS$4.footerStart, onSlotchange: (event) => (this.startSlotHasElements = slotChangeHasAssignedElement(event)) }), hAsync("slot", { name: SLOTS$4.footerEnd, onSlotchange: (event) => (this.endSlotHasElements = slotChangeHasAssignedElement(event)) })), this.renderCharacterLimit()), hAsync(HiddenFormInputSlot, { component: this })));
   }
   //--------------------------------------------------------------------------
@@ -39188,7 +39173,7 @@ class Tile {
   }; }
 }
 
-const CSS$6 = {
+const CSS$7 = {
   checked: "checked",
   description: "description",
   descriptionOnly: "description-only",
@@ -39361,20 +39346,20 @@ class TileSelect {
     return (hAsync("div", { class: {
         checked,
         container: true,
-        [CSS$6.description]: Boolean(description),
-        [CSS$6.descriptionOnly]: Boolean(!heading && !icon && description),
+        [CSS$7.description]: Boolean(description),
+        [CSS$7.descriptionOnly]: Boolean(!heading && !icon && description),
         disabled,
         focused,
-        [CSS$6.heading]: Boolean(heading),
-        [CSS$6.headingOnly]: heading && !icon && !description,
-        [CSS$6.icon]: Boolean(icon),
-        [CSS$6.iconOnly]: !heading && icon && !description,
-        [CSS$6.inputAlignmentEnd]: inputAlignment === "end",
-        [CSS$6.inputAlignmentStart]: inputAlignment === "start",
-        [CSS$6.inputEnabled]: inputEnabled,
-        [CSS$6.largeVisual]: heading && icon && !description,
-        [CSS$6.widthAuto]: width === "auto",
-        [CSS$6.widthFull]: width === "full"
+        [CSS$7.heading]: Boolean(heading),
+        [CSS$7.headingOnly]: heading && !icon && !description,
+        [CSS$7.icon]: Boolean(icon),
+        [CSS$7.iconOnly]: !heading && icon && !description,
+        [CSS$7.inputAlignmentEnd]: inputAlignment === "end",
+        [CSS$7.inputAlignmentStart]: inputAlignment === "start",
+        [CSS$7.inputEnabled]: inputEnabled,
+        [CSS$7.largeVisual]: heading && icon && !description,
+        [CSS$7.widthAuto]: width === "auto",
+        [CSS$7.widthFull]: width === "full"
       } }, hAsync("calcite-tile", { active: checked, description: description, embed: true, heading: heading, icon: icon, iconFlipRtl: iconFlipRtl }), hAsync("slot", null)));
   }
   get el() { return getElement(this); }
@@ -39446,7 +39431,7 @@ class TileSelectGroup {
   }; }
 }
 
-const CSS$5 = {
+const CSS$6 = {
   button: "button",
   buttonBottomLeft: "button--bottom-left",
   buttonBottomRight: "button--bottom-right",
@@ -40018,61 +40003,61 @@ class TimePicker {
     const secondIsNumber = isValidNumber(this.second);
     const showMeridiem = this.hourCycle === "12";
     return (hAsync("div", { class: {
-        [CSS$5.timePicker]: true,
-        [CSS$5.showMeridiem]: showMeridiem,
-        [CSS$5.showSecond]: this.showSecond,
-        [CSS$5[`scale-${this.scale}`]]: true
-      }, dir: "ltr" }, hAsync("div", { class: CSS$5.column, role: "group" }, hAsync("span", { "aria-label": this.messages.hourUp, class: {
-        [CSS$5.button]: true,
-        [CSS$5.buttonHourUp]: true,
-        [CSS$5.buttonTopLeft]: true
+        [CSS$6.timePicker]: true,
+        [CSS$6.showMeridiem]: showMeridiem,
+        [CSS$6.showSecond]: this.showSecond,
+        [CSS$6[`scale-${this.scale}`]]: true
+      }, dir: "ltr" }, hAsync("div", { class: CSS$6.column, role: "group" }, hAsync("span", { "aria-label": this.messages.hourUp, class: {
+        [CSS$6.button]: true,
+        [CSS$6.buttonHourUp]: true,
+        [CSS$6.buttonTopLeft]: true
       }, onClick: this.incrementHour, onKeyDown: this.hourUpButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-up", scale: iconScale })), hAsync("span", { "aria-label": this.messages.hour, "aria-valuemax": "23", "aria-valuemin": "1", "aria-valuenow": (hourIsNumber && parseInt(this.hour)) || "0", "aria-valuetext": this.hour, class: {
-        [CSS$5.input]: true,
-        [CSS$5.hour]: true
+        [CSS$6.input]: true,
+        [CSS$6.hour]: true
       }, onFocus: this.focusHandler, onKeyDown: this.hourKeyDownHandler, role: "spinbutton", tabIndex: 0,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setHourEl }, this.localizedHour || "--"), hAsync("span", { "aria-label": this.messages.hourDown, class: {
-        [CSS$5.button]: true,
-        [CSS$5.buttonHourDown]: true,
-        [CSS$5.buttonBottomLeft]: true
-      }, onClick: this.decrementHour, onKeyDown: this.hourDownButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: iconScale }))), hAsync("span", { class: CSS$5.delimiter }, this.localizedHourSuffix), hAsync("div", { class: CSS$5.column, role: "group" }, hAsync("span", { "aria-label": this.messages.minuteUp, class: {
-        [CSS$5.button]: true,
-        [CSS$5.buttonMinuteUp]: true
+        [CSS$6.button]: true,
+        [CSS$6.buttonHourDown]: true,
+        [CSS$6.buttonBottomLeft]: true
+      }, onClick: this.decrementHour, onKeyDown: this.hourDownButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: iconScale }))), hAsync("span", { class: CSS$6.delimiter }, this.localizedHourSuffix), hAsync("div", { class: CSS$6.column, role: "group" }, hAsync("span", { "aria-label": this.messages.minuteUp, class: {
+        [CSS$6.button]: true,
+        [CSS$6.buttonMinuteUp]: true
       }, onClick: this.incrementMinute, onKeyDown: this.minuteUpButtonKeyDownHandler, role: "button", tabIndex: -1 }, hAsync("calcite-icon", { icon: "chevron-up", scale: iconScale })), hAsync("span", { "aria-label": this.messages.minute, "aria-valuemax": "12", "aria-valuemin": "1", "aria-valuenow": (minuteIsNumber && parseInt(this.minute)) || "0", "aria-valuetext": this.minute, class: {
-        [CSS$5.input]: true,
-        [CSS$5.minute]: true
+        [CSS$6.input]: true,
+        [CSS$6.minute]: true
       }, onFocus: this.focusHandler, onKeyDown: this.minuteKeyDownHandler, role: "spinbutton", tabIndex: 0,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setMinuteEl }, this.localizedMinute || "--"), hAsync("span", { "aria-label": this.messages.minuteDown, class: {
-        [CSS$5.button]: true,
-        [CSS$5.buttonMinuteDown]: true
-      }, onClick: this.decrementMinute, onKeyDown: this.minuteDownButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: iconScale }))), this.showSecond && hAsync("span", { class: CSS$5.delimiter }, this.localizedMinuteSuffix), this.showSecond && (hAsync("div", { class: CSS$5.column, role: "group" }, hAsync("span", { "aria-label": this.messages.secondUp, class: {
-        [CSS$5.button]: true,
-        [CSS$5.buttonSecondUp]: true
+        [CSS$6.button]: true,
+        [CSS$6.buttonMinuteDown]: true
+      }, onClick: this.decrementMinute, onKeyDown: this.minuteDownButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: iconScale }))), this.showSecond && hAsync("span", { class: CSS$6.delimiter }, this.localizedMinuteSuffix), this.showSecond && (hAsync("div", { class: CSS$6.column, role: "group" }, hAsync("span", { "aria-label": this.messages.secondUp, class: {
+        [CSS$6.button]: true,
+        [CSS$6.buttonSecondUp]: true
       }, onClick: this.incrementSecond, onKeyDown: this.secondUpButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-up", scale: iconScale })), hAsync("span", { "aria-label": this.messages.second, "aria-valuemax": "59", "aria-valuemin": "0", "aria-valuenow": (secondIsNumber && parseInt(this.second)) || "0", "aria-valuetext": this.second, class: {
-        [CSS$5.input]: true,
-        [CSS$5.second]: true
+        [CSS$6.input]: true,
+        [CSS$6.second]: true
       }, onFocus: this.focusHandler, onKeyDown: this.secondKeyDownHandler, role: "spinbutton", tabIndex: 0,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setSecondEl }, this.localizedSecond || "--"), hAsync("span", { "aria-label": this.messages.secondDown, class: {
-        [CSS$5.button]: true,
-        [CSS$5.buttonSecondDown]: true
-      }, onClick: this.decrementSecond, onKeyDown: this.secondDownButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: iconScale })))), this.localizedSecondSuffix && (hAsync("span", { class: CSS$5.delimiter }, this.localizedSecondSuffix)), showMeridiem && (hAsync("div", { class: {
-        [CSS$5.column]: true,
-        [CSS$5.meridiemStart]: this.meridiemOrder === 0
+        [CSS$6.button]: true,
+        [CSS$6.buttonSecondDown]: true
+      }, onClick: this.decrementSecond, onKeyDown: this.secondDownButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: iconScale })))), this.localizedSecondSuffix && (hAsync("span", { class: CSS$6.delimiter }, this.localizedSecondSuffix)), showMeridiem && (hAsync("div", { class: {
+        [CSS$6.column]: true,
+        [CSS$6.meridiemStart]: this.meridiemOrder === 0
       }, role: "group" }, hAsync("span", { "aria-label": this.messages.meridiemUp, class: {
-        [CSS$5.button]: true,
-        [CSS$5.buttonMeridiemUp]: true,
-        [CSS$5.buttonTopRight]: true
+        [CSS$6.button]: true,
+        [CSS$6.buttonMeridiemUp]: true,
+        [CSS$6.buttonTopRight]: true
       }, onClick: this.incrementMeridiem, onKeyDown: this.meridiemUpButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-up", scale: iconScale })), hAsync("span", { "aria-label": this.messages.meridiem, "aria-valuemax": "2", "aria-valuemin": "1", "aria-valuenow": (this.meridiem === "PM" && "2") || "1", "aria-valuetext": this.meridiem, class: {
-        [CSS$5.input]: true,
-        [CSS$5.meridiem]: true
+        [CSS$6.input]: true,
+        [CSS$6.meridiem]: true
       }, onFocus: this.focusHandler, onKeyDown: this.meridiemKeyDownHandler, role: "spinbutton", tabIndex: 0,
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setMeridiemEl }, this.localizedMeridiem || "--"), hAsync("span", { "aria-label": this.messages.meridiemDown, class: {
-        [CSS$5.button]: true,
-        [CSS$5.buttonMeridiemDown]: true,
-        [CSS$5.buttonBottomRight]: true
+        [CSS$6.button]: true,
+        [CSS$6.buttonMeridiemDown]: true,
+        [CSS$6.buttonBottomRight]: true
       }, onClick: this.decrementMeridiem, onKeyDown: this.meridiemDownButtonKeyDownHandler, role: "button" }, hAsync("calcite-icon", { icon: "chevron-down", scale: iconScale }))))));
   }
   static get delegatesFocus() { return true; }
@@ -40118,7 +40103,7 @@ class TimePicker {
   }; }
 }
 
-const CSS$4 = {
+const CSS$5 = {
   container: "container",
   header: "header",
   heading: "heading",
@@ -40197,24 +40182,24 @@ class Tip {
     const parentLevel = el.closest("calcite-tip-manager")?.headingLevel;
     const relativeLevel = parentLevel ? constrainHeadingLevel(parentLevel + 1) : null;
     const level = headingLevel || relativeLevel;
-    return heading ? (hAsync("header", { class: CSS$4.header }, hAsync(Heading, { class: CSS$4.heading, level: level }, heading))) : null;
+    return heading ? (hAsync("header", { class: CSS$5.header }, hAsync(Heading, { class: CSS$5.heading, level: level }, heading))) : null;
   }
   renderDismissButton() {
     const { closeDisabled, hideTip } = this;
-    return !closeDisabled ? (hAsync("calcite-action", { class: CSS$4.close, icon: ICONS$3.close, onClick: hideTip, scale: "l", text: this.messages.close })) : null;
+    return !closeDisabled ? (hAsync("calcite-action", { class: CSS$5.close, icon: ICONS$3.close, onClick: hideTip, scale: "l", text: this.messages.close })) : null;
   }
   renderImageFrame() {
     const { el } = this;
-    return getSlotted(el, SLOTS$2.thumbnail) ? (hAsync("div", { class: CSS$4.imageFrame, key: "thumbnail" }, hAsync("slot", { name: SLOTS$2.thumbnail }))) : null;
+    return getSlotted(el, SLOTS$2.thumbnail) ? (hAsync("div", { class: CSS$5.imageFrame, key: "thumbnail" }, hAsync("slot", { name: SLOTS$2.thumbnail }))) : null;
   }
   renderInfoNode() {
-    return (hAsync("div", { class: CSS$4.info }, hAsync("slot", null)));
+    return (hAsync("div", { class: CSS$5.info }, hAsync("slot", null)));
   }
   renderContent() {
-    return (hAsync("div", { class: CSS$4.content }, this.renderImageFrame(), this.renderInfoNode()));
+    return (hAsync("div", { class: CSS$5.content }, this.renderImageFrame(), this.renderInfoNode()));
   }
   render() {
-    return (hAsync(Fragment, null, hAsync("article", { class: CSS$4.container }, this.renderHeader(), this.renderContent()), this.renderDismissButton()));
+    return (hAsync(Fragment, null, hAsync("article", { class: CSS$5.container }, this.renderHeader(), this.renderContent()), this.renderDismissButton()));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -40269,7 +40254,7 @@ class TipGroup {
   }; }
 }
 
-const CSS$3 = {
+const CSS$4 = {
   header: "header",
   heading: "heading",
   close: "close",
@@ -40441,7 +40426,7 @@ class TipManager {
     const nextLabel = messages.next;
     const previousLabel = messages.previous;
     const paginationLabel = messages.defaultPaginationLabel;
-    return tips.length > 1 ? (hAsync("footer", { class: CSS$3.pagination }, hAsync("calcite-action", { class: CSS$3.pagePrevious, icon: dir === "ltr" ? ICONS$2.chevronLeft : ICONS$2.chevronRight, onClick: this.previousClicked, scale: "m", text: previousLabel }), hAsync("span", { class: CSS$3.pagePosition }, `${paginationLabel} ${selectedIndex + 1}/${total}`), hAsync("calcite-action", { class: CSS$3.pageNext, icon: dir === "ltr" ? ICONS$2.chevronRight : ICONS$2.chevronLeft, onClick: this.nextClicked, scale: "m", text: nextLabel }))) : null;
+    return tips.length > 1 ? (hAsync("footer", { class: CSS$4.pagination }, hAsync("calcite-action", { class: CSS$4.pagePrevious, icon: dir === "ltr" ? ICONS$2.chevronLeft : ICONS$2.chevronRight, onClick: this.previousClicked, scale: "m", text: previousLabel }), hAsync("span", { class: CSS$4.pagePosition }, `${paginationLabel} ${selectedIndex + 1}/${total}`), hAsync("calcite-action", { class: CSS$4.pageNext, icon: dir === "ltr" ? ICONS$2.chevronRight : ICONS$2.chevronLeft, onClick: this.nextClicked, scale: "m", text: nextLabel }))) : null;
   }
   render() {
     const { closed, direction, headingLevel, groupTitle, selectedIndex, messages, total } = this;
@@ -40449,12 +40434,12 @@ class TipManager {
     if (total === 0) {
       return null;
     }
-    return (hAsync("section", { "aria-hidden": toAriaBoolean(closed), class: CSS$3.container, hidden: closed, onKeyDown: this.tipManagerKeyDownHandler, tabIndex: 0,
+    return (hAsync("section", { "aria-hidden": toAriaBoolean(closed), class: CSS$4.container, hidden: closed, onKeyDown: this.tipManagerKeyDownHandler, tabIndex: 0,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: this.storeContainerRef }, hAsync("header", { class: CSS$3.header }, hAsync(Heading, { class: CSS$3.heading, level: headingLevel }, groupTitle), hAsync("calcite-action", { class: CSS$3.close, onClick: this.hideTipManager, scale: "m", text: closeLabel }, hAsync("calcite-icon", { icon: ICONS$2.close, scale: "m" }))), hAsync("div", { class: {
-        [CSS$3.tipContainer]: true,
-        [CSS$3.tipContainerAdvancing]: !closed && direction === "advancing",
-        [CSS$3.tipContainerRetreating]: !closed && direction === "retreating"
+      ref: this.storeContainerRef }, hAsync("header", { class: CSS$4.header }, hAsync(Heading, { class: CSS$4.heading, level: headingLevel }, groupTitle), hAsync("calcite-action", { class: CSS$4.close, onClick: this.hideTipManager, scale: "m", text: closeLabel }, hAsync("calcite-icon", { icon: ICONS$2.close, scale: "m" }))), hAsync("div", { class: {
+        [CSS$4.tipContainer]: true,
+        [CSS$4.tipContainerAdvancing]: !closed && direction === "advancing",
+        [CSS$4.tipContainerRetreating]: !closed && direction === "retreating"
       }, key: selectedIndex, tabIndex: 0 }, hAsync("slot", null)), this.renderPagination()));
   }
   static get assetsDirs() { return ["assets"]; }
@@ -40490,7 +40475,7 @@ class TipManager {
   }; }
 }
 
-const CSS$2 = {
+const CSS$3 = {
   container: "container"
 };
 const TOOLTIP_DELAY_MS = 500;
@@ -40858,7 +40843,7 @@ class Tooltip {
       // eslint-disable-next-line react/jsx-sort-props
       ref: this.setTransitionEl }, hAsync(FloatingArrow, { floatingLayout: floatingLayout,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (arrowEl) => (this.arrowEl = arrowEl) }), hAsync("div", { class: CSS$2.container }, hAsync("slot", null)))));
+      ref: (arrowEl) => (this.arrowEl = arrowEl) }), hAsync("div", { class: CSS$3.container }, hAsync("slot", null)))));
   }
   get el() { return getElement(this); }
   static get watchers() { return {
@@ -41186,7 +41171,7 @@ class Tree {
   }; }
 }
 
-const CSS$1 = {
+const CSS$2 = {
   actionsEnd: "actions-end",
   checkboxLabel: "checkbox-label",
   checkbox: "checkbox",
@@ -41341,11 +41326,11 @@ class TreeItem {
     const showCheckmark = this.selectionMode === "multiple" || this.selectionMode === "multichildren";
     const showBlank = this.selectionMode === "none" && !this.hasChildren;
     const chevron = this.hasChildren ? (hAsync("calcite-icon", { class: {
-        [CSS$1.chevron]: true,
+        [CSS$2.chevron]: true,
         [CSS_UTILITY.rtl]: rtl
       }, "data-test-id": "icon", icon: ICONS$1.chevronRight, onClick: this.iconClickHandler, scale: this.scale === "l" ? "m" : "s" })) : null;
     const defaultSlotNode = hAsync("slot", { key: "default-slot" });
-    const checkbox = this.selectionMode === "ancestors" ? (hAsync("label", { class: CSS$1.checkboxLabel, key: "checkbox-label" }, hAsync("calcite-checkbox", { checked: this.selected, class: CSS$1.checkbox, "data-test-id": "checkbox", indeterminate: this.hasChildren && this.indeterminate, scale: this.scale, tabIndex: -1 }), defaultSlotNode)) : null;
+    const checkbox = this.selectionMode === "ancestors" ? (hAsync("label", { class: CSS$2.checkboxLabel, key: "checkbox-label" }, hAsync("calcite-checkbox", { checked: this.selected, class: CSS$2.checkbox, "data-test-id": "checkbox", indeterminate: this.hasChildren && this.indeterminate, scale: this.scale, tabIndex: -1 }), defaultSlotNode)) : null;
     const selectedIcon = showBulletPoint
       ? ICONS$1.bulletPoint
       : showCheckmark
@@ -41354,22 +41339,22 @@ class TreeItem {
           ? ICONS$1.blank
           : null;
     const itemIndicator = selectedIcon ? (hAsync("calcite-icon", { class: {
-        [CSS$1.bulletPointIcon]: selectedIcon === ICONS$1.bulletPoint,
-        [CSS$1.checkmarkIcon]: selectedIcon === ICONS$1.checkmark,
+        [CSS$2.bulletPointIcon]: selectedIcon === ICONS$1.bulletPoint,
+        [CSS$2.checkmarkIcon]: selectedIcon === ICONS$1.checkmark,
         [CSS_UTILITY.rtl]: rtl
       }, icon: selectedIcon, scale: this.scale === "l" ? "m" : "s" })) : null;
     const hidden = !(this.parentExpanded || this.depth === 1);
     const isExpanded = this.updateAfterInitialRender && this.expanded;
     const { hasEndActions } = this;
     const slotNode = (hAsync("slot", { key: "actionsEndSlot", name: SLOTS$1.actionsEnd, onSlotchange: this.actionsEndSlotChangeHandler }));
-    const iconStartEl = (hAsync("calcite-icon", { class: CSS$1.iconStart, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, scale: this.scale === "l" ? "m" : "s" }));
-    return (hAsync(Host, { "aria-expanded": this.hasChildren ? toAriaBoolean(isExpanded) : undefined, "aria-hidden": toAriaBoolean(hidden), "aria-selected": this.selected ? "true" : showCheckmark ? "false" : undefined, "calcite-hydrated-hidden": hidden, role: "treeitem" }, hAsync("div", { class: { [CSS$1.itemExpanded]: isExpanded } }, hAsync("div", { class: CSS$1.nodeAndActionsContainer }, hAsync("div", { class: {
-        [CSS$1.nodeContainer]: true,
+    const iconStartEl = (hAsync("calcite-icon", { class: CSS$2.iconStart, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, scale: this.scale === "l" ? "m" : "s" }));
+    return (hAsync(Host, { "aria-expanded": this.hasChildren ? toAriaBoolean(isExpanded) : undefined, "aria-hidden": toAriaBoolean(hidden), "aria-selected": this.selected ? "true" : showCheckmark ? "false" : undefined, "calcite-hydrated-hidden": hidden, role: "treeitem" }, hAsync("div", { class: { [CSS$2.itemExpanded]: isExpanded } }, hAsync("div", { class: CSS$2.nodeAndActionsContainer }, hAsync("div", { class: {
+        [CSS$2.nodeContainer]: true,
         [CSS_UTILITY.rtl]: rtl
       }, "data-selection-mode": this.selectionMode,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (el) => (this.defaultSlotWrapper = el) }, chevron, itemIndicator, this.iconStart ? iconStartEl : null, checkbox ? checkbox : defaultSlotNode), hAsync("div", { class: CSS$1.actionsEnd, hidden: !hasEndActions, ref: (el) => (this.actionSlotWrapper = el) }, slotNode)), hAsync("div", { class: {
-        [CSS$1.childrenContainer]: true,
+      ref: (el) => (this.defaultSlotWrapper = el) }, chevron, itemIndicator, this.iconStart ? iconStartEl : null, checkbox ? checkbox : defaultSlotNode), hAsync("div", { class: CSS$2.actionsEnd, hidden: !hasEndActions, ref: (el) => (this.actionSlotWrapper = el) }, slotNode)), hAsync("div", { class: {
+        [CSS$2.childrenContainer]: true,
         [CSS_UTILITY.rtl]: rtl
       }, "data-test-id": "calcite-tree-children", onClick: this.childrenClickHandler, role: this.hasChildren ? "group" : undefined,
       // eslint-disable-next-line react/jsx-sort-props
@@ -41518,7 +41503,7 @@ class TreeItem {
   }; }
 }
 
-const CSS = {
+const CSS$1 = {
   container: "container",
   handle: "handle"
 };
@@ -41724,7 +41709,7 @@ class ValueList {
     connectSortableComponent(this, {
       dataIdAttr: "id",
       group,
-      handle: `.${CSS.handle}`,
+      handle: `.${CSS$1.handle}`,
       draggable: "calcite-value-list-item",
       onStart: () => {
         cleanUpObserver.call(this);
@@ -41945,8 +41930,8 @@ class ValueListItem {
     const { icon, iconFlipRtl } = this;
     if (icon === ICON_TYPES$1.grip) {
       return (hAsync("span", { class: {
-          [CSS$m.handle]: true,
-          [CSS$m.handleActivated]: this.handleActivated
+          [CSS$n.handle]: true,
+          [CSS$n.handleActivated]: this.handleActivated
         }, "data-js-handle": true, onBlur: this.handleBlur, onKeyDown: this.handleKeyDown, ref: (el) => (this.handleEl = el), role: "button", tabindex: "0" }, hAsync("calcite-icon", { flipRtl: iconFlipRtl, icon: ICONS.drag, scale: "s" })));
     }
   }