@esri/calcite-components 1.7.0-next.16 → 1.7.0-next.17

package/hydrate/index.js

@@ -1,7 +1,7 @@
 /*!
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
  * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
- * v1.7.0-next.16
+ * v1.7.0-next.17
  */
 'use strict';
 
@@ -7018,11 +7018,11 @@ function isBefore(a, b) {
   return children.indexOf(a) < children.indexOf(b);
 }
 
-const SLOTS$y = {
+const SLOTS$z = {
   actionsStart: "actions-start",
   actionsEnd: "actions-end",
 };
-const CSS$18 = {
+const CSS$1b = {
   icon: "icon",
   header: "header",
   headerContent: "header-content",
@@ -7086,28 +7086,28 @@ class AccordionItem {
   // --------------------------------------------------------------------------
   renderActionsStart() {
     const { el } = this;
-    return getSlotted(el, SLOTS$y.actionsStart) ? (hAsync("div", { class: CSS$18.actionsStart }, hAsync("slot", { name: SLOTS$y.actionsStart }))) : null;
+    return getSlotted(el, SLOTS$z.actionsStart) ? (hAsync("div", { class: CSS$1b.actionsStart }, hAsync("slot", { name: SLOTS$z.actionsStart }))) : null;
   }
   renderActionsEnd() {
     const { el } = this;
-    return getSlotted(el, SLOTS$y.actionsEnd) ? (hAsync("div", { class: CSS$18.actionsEnd }, hAsync("slot", { name: SLOTS$y.actionsEnd }))) : null;
+    return getSlotted(el, SLOTS$z.actionsEnd) ? (hAsync("div", { class: CSS$1b.actionsEnd }, hAsync("slot", { name: SLOTS$z.actionsEnd }))) : null;
   }
   render() {
     const { iconFlipRtl } = this;
     const dir = getElementDir(this.el);
-    const iconStartEl = this.iconStart ? (hAsync("calcite-icon", { class: CSS$18.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$18.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$1b.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$1b.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$18.header]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.renderActionsStart(), hAsync("div", { "aria-expanded": toAriaBoolean(this.expanded), class: CSS$18.headerContent, onClick: this.itemHeaderClickHandler, role: "button", tabindex: "0" }, hAsync("div", { class: CSS$18.headerContainer }, iconStartEl, hAsync("div", { class: CSS$18.headerText }, hAsync("span", { class: CSS$18.heading }, this.heading), description ? hAsync("span", { class: CSS$18.description }, description) : null), iconEndEl), hAsync("calcite-icon", { class: CSS$18.expandIcon, icon: this.iconType === "chevron"
+      } }, hAsync("div", { class: { [CSS$1b.header]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.renderActionsStart(), hAsync("div", { "aria-expanded": toAriaBoolean(this.expanded), class: CSS$1b.headerContent, onClick: this.itemHeaderClickHandler, role: "button", tabindex: "0" }, hAsync("div", { class: CSS$1b.headerContainer }, iconStartEl, hAsync("div", { class: CSS$1b.headerText }, hAsync("span", { class: CSS$1b.heading }, this.heading), description ? hAsync("span", { class: CSS$1b.description }, description) : null), iconEndEl), hAsync("calcite-icon", { class: CSS$1b.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$18.content }, hAsync("slot", null)))));
+            : "plus", scale: this.scale === "l" ? "m" : "s" })), this.renderActionsEnd()), hAsync("div", { class: CSS$1b.content }, hAsync("slot", null)))));
   }
   //--------------------------------------------------------------------------
   //
@@ -8027,7 +8027,7 @@ function defaultOnMessagesChange() {
   mergeMessages(this);
 }
 
-const CSS$17 = {
+const CSS$1a = {
   button: "button",
   buttonTextVisible: "button--text-visible",
   buttonCompact: "button--compact",
@@ -8038,7 +8038,7 @@ const CSS$17 = {
   textContainer: "text-container",
   textContainerVisible: "text-container--visible",
 };
-const SLOTS$x = {
+const SLOTS$y = {
   tooltip: "tooltip",
 };
 
@@ -8138,14 +8138,14 @@ class Action {
   renderTextContainer() {
     const { text, textEnabled } = this;
     const textContainerClasses = {
-      [CSS$17.textContainer]: true,
-      [CSS$17.textContainerVisible]: textEnabled,
+      [CSS$1a.textContainer]: true,
+      [CSS$1a.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$17.indicatorText, id: indicatorId, role: "region" }, indicator ? messages.indicator : null));
+    return (hAsync("div", { "aria-labelledby": buttonId, "aria-live": "polite", class: CSS$1a.indicatorText, id: indicatorId, role: "region" }, indicator ? messages.indicator : null));
   }
   renderIconContainer() {
     const { loading, icon, scale, el, iconFlipRtl } = this;
@@ -8156,22 +8156,22 @@ class Action {
     const iconNode = calciteLoaderNode || calciteIconNode;
     const hasIconToDisplay = iconNode || el.children?.length;
     const slotContainerNode = (hAsync("div", { class: {
-        [CSS$17.slotContainer]: true,
-        [CSS$17.slotContainerHidden]: loading,
+        [CSS$1a.slotContainer]: true,
+        [CSS$1a.slotContainerHidden]: loading,
       } }, hAsync("slot", null)));
-    return hasIconToDisplay ? (hAsync("div", { "aria-hidden": "true", class: CSS$17.iconContainer, key: "icon-container" }, iconNode, slotContainerNode)) : null;
+    return hasIconToDisplay ? (hAsync("div", { "aria-hidden": "true", class: CSS$1a.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$17.button]: true,
-      [CSS$17.buttonTextVisible]: textEnabled,
-      [CSS$17.buttonCompact]: compact,
+      [CSS$1a.button]: true,
+      [CSS$1a.buttonTextVisible]: textEnabled,
+      [CSS$1a.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 -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: (buttonEl) => (this.buttonEl = buttonEl) }, this.renderIconContainer(), this.renderTextContainer()), hAsync("slot", { name: SLOTS$x.tooltip, onSlotchange: this.handleTooltipSlotChange }), this.renderIndicatorText()));
+      ref: (buttonEl) => (this.buttonEl = buttonEl) }, this.renderIconContainer(), this.renderTextContainer()), hAsync("slot", { name: SLOTS$y.tooltip, onSlotchange: this.handleTooltipSlotChange }), this.renderIndicatorText()));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -9472,22 +9472,22 @@ function throttle$1(func, wait, options) {
   });
 }
 
-const SLOTS$w = {
+const SLOTS$x = {
   menuActions: "menu-actions",
   menuTooltip: "menu-tooltip",
 };
 const ICONS$j = {
   menu: "ellipsis",
 };
-const CSS$16 = {
+const CSS$19 = {
   container: "container",
 };
 
-const CSS$15 = {
+const CSS$18 = {
   menu: "menu",
   defaultTrigger: "default-trigger",
 };
-const SLOTS$v = {
+const SLOTS$w = {
   tooltip: "tooltip",
   trigger: "trigger",
 };
@@ -9514,7 +9514,7 @@ const getOverflowCount = ({ layout, actionCount, actionWidth, width, actionHeigh
   return Math.max(actionCount - getMaxActionCount({ width, actionWidth, layout, height, actionHeight, groupCount }), 0);
 };
 const queryActions = (el) => {
-  return Array.from(el.querySelectorAll("calcite-action")).filter((action) => action.closest("calcite-action-menu") ? action.slot === SLOTS$v.trigger : true);
+  return Array.from(el.querySelectorAll("calcite-action")).filter((action) => action.closest("calcite-action-menu") ? action.slot === SLOTS$w.trigger : true);
 };
 const overflowActions = ({ actionGroups, expanded, overflowCount, }) => {
   let needToSlotCount = overflowCount;
@@ -9522,7 +9522,7 @@ const overflowActions = ({ actionGroups, expanded, overflowCount, }) => {
     let slottedWithinGroupCount = 0;
     const groupActions = queryActions(group).reverse();
     groupActions.forEach((groupAction) => {
-      if (groupAction.slot === SLOTS$w.menuActions) {
+      if (groupAction.slot === SLOTS$x.menuActions) {
         groupAction.removeAttribute("slot");
         groupAction.textEnabled = expanded;
       }
@@ -9532,7 +9532,7 @@ const overflowActions = ({ actionGroups, expanded, overflowCount, }) => {
         const unslottedActions = groupActions.filter((action) => !action.slot);
         if (unslottedActions.length > 1 && groupActions.length > 2 && !groupAction.closest("calcite-action-menu")) {
           groupAction.textEnabled = true;
-          groupAction.setAttribute("slot", SLOTS$w.menuActions);
+          groupAction.setAttribute("slot", SLOTS$x.menuActions);
           slottedWithinGroupCount++;
           if (slottedWithinGroupCount > 1) {
             needToSlotCount--;
@@ -9554,7 +9554,7 @@ function getCalcitePosition(position, el) {
 }
 function toggleChildActionText({ el, expanded, }) {
   queryActions(el)
-    .filter((el) => el.slot !== SLOTS$w.menuActions)
+    .filter((el) => el.slot !== SLOTS$x.menuActions)
     .forEach((action) => (action.textEnabled = expanded));
   el.querySelectorAll("calcite-action-group, calcite-action-menu").forEach((el) => (el.expanded = expanded));
 }
@@ -9583,10 +9583,10 @@ const ExpandToggle = ({ expanded, expandText, collapseText, toggle, el, position
   return actionNode;
 };
 
-const CSS$14 = {
+const CSS$17 = {
   actionGroupEnd: "action-group--end",
 };
-const SLOTS$u = {
+const SLOTS$v = {
   actionsEnd: "actions-end",
   bottomActions: "bottom-actions",
   expandTooltip: "expand-tooltip",
@@ -9786,7 +9786,7 @@ class ActionBar {
     const expandToggleNode = !expandDisabled ? (hAsync(ExpandToggle, { collapseText: messages.collapse, el: el, expandText: messages.expand, expanded: expanded, position: position, scale: scale, toggle: toggleExpand, tooltip: this.expandTooltip,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setExpandToggleRef })) : null;
-    return (hAsync("calcite-action-group", { class: CSS$14.actionGroupEnd, label: actionsEndGroupLabel, hidden: this.expandDisabled && !(this.hasActionsEnd || this.hasBottomActions), layout: layout, scale: scale }, hAsync("slot", { name: SLOTS$u.actionsEnd, onSlotchange: this.handleActionsEndSlotChange }), hAsync("slot", { name: SLOTS$u.bottomActions, onSlotchange: this.handleBottomActionsSlotChange }), hAsync("slot", { name: SLOTS$u.expandTooltip, onSlotchange: this.handleTooltipSlotChange }), expandToggleNode));
+    return (hAsync("calcite-action-group", { class: CSS$17.actionGroupEnd, label: actionsEndGroupLabel, hidden: this.expandDisabled && !(this.hasActionsEnd || this.hasBottomActions), layout: layout, scale: scale }, hAsync("slot", { name: SLOTS$v.actionsEnd, onSlotchange: this.handleActionsEndSlotChange }), hAsync("slot", { name: SLOTS$v.bottomActions, onSlotchange: this.handleBottomActionsSlotChange }), hAsync("slot", { name: SLOTS$v.expandTooltip, onSlotchange: this.handleTooltipSlotChange }), expandToggleNode));
   }
   render() {
     return (hAsync(Host, { onCalciteActionMenuOpen: this.actionMenuOpenHandler }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }), this.renderBottomActionGroup()));
@@ -9911,10 +9911,10 @@ class ActionGroup {
   // --------------------------------------------------------------------------
   renderMenu() {
     const { expanded, menuOpen, scale, layout, messages, overlayPositioning, hasMenuActions } = this;
-    return (hAsync("calcite-action-menu", { expanded: expanded, flipPlacements: ["left", "right"], hidden: !hasMenuActions, label: messages.more, onCalciteActionMenuOpen: this.setMenuOpen, open: menuOpen, overlayPositioning: overlayPositioning, placement: layout === "horizontal" ? "bottom-start" : "leading-start", scale: scale }, hAsync("calcite-action", { icon: ICONS$j.menu, scale: scale, slot: SLOTS$v.trigger, text: messages.more, textEnabled: expanded }), hAsync("slot", { name: SLOTS$w.menuActions, onSlotchange: this.handleMenuActionsSlotChange }), hAsync("slot", { name: SLOTS$w.menuTooltip, slot: SLOTS$v.tooltip })));
+    return (hAsync("calcite-action-menu", { expanded: expanded, flipPlacements: ["left", "right"], hidden: !hasMenuActions, label: messages.more, onCalciteActionMenuOpen: this.setMenuOpen, open: menuOpen, overlayPositioning: overlayPositioning, placement: layout === "horizontal" ? "bottom-start" : "leading-start", scale: scale }, hAsync("calcite-action", { icon: ICONS$j.menu, scale: scale, slot: SLOTS$w.trigger, text: messages.more, textEnabled: expanded }), hAsync("slot", { name: SLOTS$x.menuActions, onSlotchange: this.handleMenuActionsSlotChange }), hAsync("slot", { name: SLOTS$x.menuTooltip, slot: SLOTS$w.tooltip })));
   }
   render() {
-    return (hAsync("div", { "aria-label": this.label, class: CSS$16.container, role: "group" }, hAsync("slot", null), this.renderMenu()));
+    return (hAsync("div", { "aria-label": this.label, class: CSS$19.container, role: "group" }, hAsync("slot", null), this.renderMenu()));
   }
   static get delegatesFocus() { return true; }
   static get assetsDirs() { return ["assets"]; }
@@ -10198,7 +10198,7 @@ class ActionMenu {
   }
   renderMenuButton() {
     const { label, scale, expanded } = this;
-    const menuButtonSlot = (hAsync("slot", { name: SLOTS$v.trigger, onSlotchange: this.setMenuButtonEl }, hAsync("calcite-action", { class: CSS$15.defaultTrigger, icon: ICONS$i.menu, scale: scale, text: label, textEnabled: expanded,
+    const menuButtonSlot = (hAsync("slot", { name: SLOTS$w.trigger, onSlotchange: this.setMenuButtonEl }, hAsync("calcite-action", { class: CSS$18.defaultTrigger, icon: ICONS$i.menu, scale: scale, text: label, textEnabled: expanded,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setDefaultMenuButtonEl })));
     return menuButtonSlot;
@@ -10207,10 +10207,10 @@ 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$15.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$18.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$v.tooltip, onSlotchange: this.updateTooltip })));
+    return (hAsync(Fragment, null, this.renderMenuButton(), this.renderMenuItems(), hAsync("slot", { name: SLOTS$w.tooltip, onSlotchange: this.updateTooltip })));
   }
   isValidKey(key, supportedKeys) {
     return !!supportedKeys.find((k) => k === key);
@@ -10243,11 +10243,11 @@ class ActionMenu {
   }; }
 }
 
-const CSS$13 = {
+const CSS$16 = {
   actionGroupEnd: "action-group--end",
   container: "container",
 };
-const SLOTS$t = {
+const SLOTS$u = {
   expandTooltip: "expand-tooltip",
 };
 
@@ -10368,10 +10368,10 @@ class ActionPad {
     const expandToggleNode = !expandDisabled ? (hAsync(ExpandToggle, { collapseText: messages.collapse, el: el, expandText: messages.expand, expanded: expanded, position: position, scale: scale, toggle: toggleExpand, tooltip: this.expandTooltip,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setExpandToggleRef })) : null;
-    return expandToggleNode ? (hAsync("calcite-action-group", { class: CSS$13.actionGroupEnd, label: actionsEndGroupLabel, layout: layout, scale: scale }, hAsync("slot", { name: SLOTS$t.expandTooltip, onSlotchange: this.handleTooltipSlotChange }), expandToggleNode)) : null;
+    return expandToggleNode ? (hAsync("calcite-action-group", { class: CSS$16.actionGroupEnd, label: actionsEndGroupLabel, layout: layout, scale: scale }, hAsync("slot", { name: SLOTS$u.expandTooltip, onSlotchange: this.handleTooltipSlotChange }), expandToggleNode)) : null;
   }
   render() {
-    return (hAsync(Host, { onCalciteActionMenuOpen: this.actionMenuOpenHandler }, hAsync("div", { class: CSS$13.container }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }), this.renderBottomActionGroup())));
+    return (hAsync(Host, { onCalciteActionMenuOpen: this.actionMenuOpenHandler }, hAsync("div", { class: CSS$16.container }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }), this.renderBottomActionGroup())));
   }
   static get delegatesFocus() { return true; }
   static get assetsDirs() { return ["assets"]; }
@@ -10494,13 +10494,13 @@ const DURATIONS = {
   medium: 10000,
   fast: 6000,
 };
-const SLOTS$s = {
+const SLOTS$t = {
   actionsEnd: "actions-end",
   title: "title",
   message: "message",
   link: "link",
 };
-const CSS$12 = {
+const CSS$15 = {
   actionsEnd: "actions-end",
   container: "container",
   close: "alert-close",
@@ -10655,15 +10655,15 @@ class Alert {
     const { open, autoClose, label, placement, queued, requestedIcon, iconFlipRtl } = this;
     const role = autoClose ? "alert" : "alertdialog";
     const hidden = !open;
-    const slotNode = (hAsync("slot", { key: "actionsEndSlot", name: SLOTS$s.actionsEnd, onSlotchange: this.actionsEndSlotChangeHandler }));
+    const slotNode = (hAsync("slot", { key: "actionsEndSlot", name: SLOTS$t.actionsEnd, onSlotchange: this.actionsEndSlotChangeHandler }));
     return (hAsync(Host, { "aria-hidden": toAriaBoolean(hidden), "aria-label": label, "calcite-hydrated-hidden": hidden, role: role }, hAsync("div", { class: {
         container: true,
         queued,
         [placement]: true,
-        [CSS$12.slottedInShell]: this.slottedInShell,
+        [CSS$15.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      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$s.title }), hAsync("slot", { name: SLOTS$s.message }), hAsync("slot", { name: SLOTS$s.link })), hAsync("div", { class: CSS$12.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$t.title }), hAsync("slot", { name: SLOTS$t.message }), hAsync("slot", { name: SLOTS$t.link })), hAsync("div", { class: CSS$15.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) {
@@ -11132,7 +11132,7 @@ const Heading = (props, children) => {
   return hAsync(HeadingTag, { ...props }, children);
 };
 
-const CSS$11 = {
+const CSS$14 = {
   container: "container",
   content: "content",
   headerContainer: "header-container",
@@ -11150,7 +11150,7 @@ const CSS$11 = {
   valid: "valid",
   invalid: "invalid",
 };
-const SLOTS$r = {
+const SLOTS$s = {
   icon: "icon",
   control: "control",
   headerMenuActions: "header-menu-actions",
@@ -11256,31 +11256,31 @@ class Block {
   }
   renderIcon() {
     const { loading, messages, status } = this;
-    const hasSlottedIcon = !!getSlotted(this.el, SLOTS$r.icon);
-    return loading ? (hAsync("div", { class: CSS$11.icon, key: "loader" }, hAsync("calcite-loader", { inline: true, label: messages.loading }))) : !!status ? (hAsync("div", { class: CSS$11.icon, key: "status-icon" }, hAsync("calcite-icon", { class: {
-        [CSS$11.statusIcon]: true,
-        [CSS$11.valid]: status == "valid",
-        [CSS$11.invalid]: status == "invalid",
-      }, icon: ICONS$g[status], scale: "s" }))) : hasSlottedIcon ? (hAsync("div", { class: CSS$11.icon, key: "icon-slot" }, hAsync("slot", { key: "icon-slot", name: SLOTS$r.icon }))) : null;
+    const hasSlottedIcon = !!getSlotted(this.el, SLOTS$s.icon);
+    return loading ? (hAsync("div", { class: CSS$14.icon, key: "loader" }, hAsync("calcite-loader", { inline: true, label: messages.loading }))) : !!status ? (hAsync("div", { class: CSS$14.icon, key: "status-icon" }, hAsync("calcite-icon", { class: {
+        [CSS$14.statusIcon]: true,
+        [CSS$14.valid]: status == "valid",
+        [CSS$14.invalid]: status == "invalid",
+      }, icon: ICONS$g[status], scale: "s" }))) : hasSlottedIcon ? (hAsync("div", { class: CSS$14.icon, key: "icon-slot" }, hAsync("slot", { key: "icon-slot", name: SLOTS$s.icon }))) : null;
   }
   renderTitle() {
     const { heading, headingLevel, description } = this;
-    return heading || description ? (hAsync("div", { class: CSS$11.title }, hAsync(Heading, { class: CSS$11.heading, level: headingLevel }, heading), description ? hAsync("div", { class: CSS$11.description }, description) : null)) : null;
+    return heading || description ? (hAsync("div", { class: CSS$14.title }, hAsync(Heading, { class: CSS$14.heading, level: headingLevel }, heading), description ? hAsync("div", { class: CSS$14.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$11.header }, this.renderIcon(), this.renderTitle()));
-    const hasControl = !!getSlotted(el, SLOTS$r.control);
-    const hasMenuActions = !!getSlotted(el, SLOTS$r.headerMenuActions);
+    const headerContent = (hAsync("header", { class: CSS$14.header }, this.renderIcon(), this.renderTitle()));
+    const hasControl = !!getSlotted(el, SLOTS$s.control);
+    const hasMenuActions = !!getSlotted(el, SLOTS$s.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$11.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$11.toggle, id: buttonId, onClick: this.onHeaderClick, title: toggleLabel }, headerContent, !hasControl && !hasMenuActions ? (hAsync("calcite-icon", { "aria-hidden": "true", class: CSS$11.toggleIcon, icon: collapseIcon, scale: "s" })) : null)) : (headerContent), hasControl ? (hAsync("div", { class: CSS$11.controlContainer }, hAsync("slot", { name: SLOTS$r.control }))) : null, hasMenuActions ? (hAsync("calcite-action-menu", { label: messages.options }, hAsync("slot", { name: SLOTS$r.headerMenuActions }))) : null));
+    const headerNode = (hAsync("div", { class: CSS$14.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$14.toggle, id: buttonId, onClick: this.onHeaderClick, title: toggleLabel }, headerContent, !hasControl && !hasMenuActions ? (hAsync("calcite-icon", { "aria-hidden": "true", class: CSS$14.toggleIcon, icon: collapseIcon, scale: "s" })) : null)) : (headerContent), hasControl ? (hAsync("div", { class: CSS$14.controlContainer }, hAsync("slot", { name: SLOTS$s.control }))) : null, hasMenuActions ? (hAsync("calcite-action-menu", { label: messages.options }, hAsync("slot", { name: SLOTS$s.headerMenuActions }))) : null));
     return (hAsync(Host, null, hAsync("article", { "aria-busy": toAriaBoolean(loading), class: {
-        [CSS$11.container]: true,
-      } }, headerNode, hAsync("section", { "aria-expanded": toAriaBoolean(open), "aria-labelledby": buttonId, class: CSS$11.content, hidden: !open, id: regionId }, this.renderScrim()))));
+        [CSS$14.container]: true,
+      } }, headerNode, hAsync("section", { "aria-expanded": toAriaBoolean(open), "aria-labelledby": buttonId, class: CSS$14.content, hidden: !open, id: regionId }, this.renderScrim()))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -11314,7 +11314,7 @@ class Block {
   }; }
 }
 
-const CSS$10 = {
+const CSS$13 = {
   content: "content",
   invalid: "invalid",
   toggle: "toggle",
@@ -11417,9 +11417,9 @@ class BlockSection {
     const { status } = this;
     const statusIcon = ICONS$f[status] ?? false;
     const statusIconClasses = {
-      [CSS$10.statusIcon]: true,
-      [CSS$10.valid]: status == "valid",
-      [CSS$10.invalid]: status == "invalid",
+      [CSS$13.statusIcon]: true,
+      [CSS$13.valid]: status == "valid",
+      [CSS$13.invalid]: status == "invalid",
     };
     return !!statusIcon ? (hAsync("calcite-icon", { class: statusIconClasses, icon: statusIcon, scale: "s" })) : null;
   }
@@ -11436,13 +11436,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$10.toggle]: true,
-        [CSS$10.toggleSwitch]: true,
-      }, id: buttonId, onClick: this.toggleSection, onKeyDown: this.handleHeaderKeyDown, tabIndex: 0, title: toggleLabel }, hAsync("div", { class: CSS$10.toggleSwitchContent }, hAsync("span", { class: CSS$10.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$10.sectionHeader]: true,
-        [CSS$10.toggle]: true,
-      }, id: buttonId, name: toggleLabel, onClick: this.toggleSection }, hAsync("calcite-icon", { icon: arrowIcon, scale: "s" }), hAsync("span", { class: CSS$10.sectionHeaderText }, text), this.renderStatusIcon()));
-    return (hAsync(Host, null, headerNode, hAsync("section", { "aria-expanded": toAriaBoolean(open), "aria-labelledby": buttonId, class: CSS$10.content, hidden: !open, id: regionId }, hAsync("slot", null))));
+        [CSS$13.toggle]: true,
+        [CSS$13.toggleSwitch]: true,
+      }, id: buttonId, onClick: this.toggleSection, onKeyDown: this.handleHeaderKeyDown, tabIndex: 0, title: toggleLabel }, hAsync("div", { class: CSS$13.toggleSwitchContent }, hAsync("span", { class: CSS$13.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$13.sectionHeader]: true,
+        [CSS$13.toggle]: true,
+      }, id: buttonId, name: toggleLabel, onClick: this.toggleSection }, hAsync("calcite-icon", { icon: arrowIcon, scale: "s" }), hAsync("span", { class: CSS$13.sectionHeaderText }, text), this.renderStatusIcon()));
+    return (hAsync(Host, null, headerNode, hAsync("section", { "aria-expanded": toAriaBoolean(open), "aria-labelledby": buttonId, class: CSS$13.content, hidden: !open, id: regionId }, hAsync("slot", null))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -11872,7 +11872,7 @@ function onLabelDisconnected() {
   document.addEventListener(labelConnectedEvent, boundOnLabelConnected);
 }
 
-const CSS$$ = {
+const CSS$12 = {
   buttonLoader: "calcite-button--loader",
   content: "content",
   contentSlotted: "content--slotted",
@@ -12000,17 +12000,17 @@ class Button {
   render() {
     const childElType = this.href ? "a" : "button";
     const Tag = childElType;
-    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 loaderNode = this.hasLoader ? (hAsync("div", { class: CSS$12.buttonLoader }, hAsync("calcite-loader", { class: this.loading ? CSS$12.loadingIn : CSS$12.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$$.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)));
+    const iconStartEl = (hAsync("calcite-icon", { class: { [CSS$12.icon]: true, [CSS$12.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$12.icon]: true, [CSS$12.iconEnd]: true }, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, scale: this.scale === "l" ? "m" : "s" }));
+    const contentEl = (hAsync("span", { class: CSS$12.content, ref: (el) => (this.contentEl = el) }, hAsync("slot", null)));
     return (hAsync(Tag, { "aria-label": !this.loading ? getLabelText(this) : this.messages.loading, "aria-live": "polite", class: {
-        [CSS$$.buttonPadding]: noStartEndIcons,
-        [CSS$$.buttonPaddingShrunk]: !noStartEndIcons,
-        [CSS$$.contentSlotted]: this.hasContent,
-        [CSS$$.iconStartEmpty]: !this.iconStart,
-        [CSS$$.iconEndEmpty]: !this.iconEnd,
+        [CSS$12.buttonPadding]: noStartEndIcons,
+        [CSS$12.buttonPaddingShrunk]: !noStartEndIcons,
+        [CSS$12.contentSlotted]: this.hasContent,
+        [CSS$12.iconStartEmpty]: !this.iconStart,
+        [CSS$12.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));
   }
   //--------------------------------------------------------------------------
@@ -12325,7 +12325,7 @@ class CalciteMenu {
   }; }
 }
 
-const CSS$_ = {
+const CSS$11 = {
   container: "container",
   content: "content",
   dropdownVertical: "dropdown--vertical",
@@ -12529,54 +12529,54 @@ class CalciteMenuItem {
   //
   //--------------------------------------------------------------------------
   renderIconStart() {
-    return (hAsync("calcite-icon", { class: `${CSS$_.icon} ${CSS$_.iconStart}`, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, key: CSS$_.iconStart, scale: "s" }));
+    return (hAsync("calcite-icon", { class: `${CSS$11.icon} ${CSS$11.iconStart}`, flipRtl: this.iconFlipRtl === "start" || this.iconFlipRtl === "both", icon: this.iconStart, key: CSS$11.iconStart, scale: "s" }));
   }
   renderIconEnd() {
-    return (hAsync("calcite-icon", { class: `${CSS$_.icon} ${CSS$_.iconEnd}`, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, key: CSS$_.iconEnd, scale: "s" }));
+    return (hAsync("calcite-icon", { class: `${CSS$11.icon} ${CSS$11.iconEnd}`, flipRtl: this.iconFlipRtl === "end" || this.iconFlipRtl === "both", icon: this.iconEnd, key: CSS$11.iconEnd, scale: "s" }));
   }
   renderBreadcrumbIcon(dir) {
-    return (hAsync("calcite-icon", { class: `${CSS$_.icon} ${CSS$_.iconBreadcrumb}`, icon: dir === "rtl" ? "chevron-left" : "chevron-right", key: CSS$_.iconBreadcrumb, scale: "s" }));
+    return (hAsync("calcite-icon", { class: `${CSS$11.icon} ${CSS$11.iconBreadcrumb}`, icon: dir === "rtl" ? "chevron-left" : "chevron-right", key: CSS$11.iconBreadcrumb, scale: "s" }));
   }
   renderDropdownIcon(dir) {
     const dirChevron = dir === "rtl" ? "chevron-left" : "chevron-right";
-    return (hAsync("calcite-icon", { class: `${CSS$_.icon} ${CSS$_.iconDropdown}`, icon: this.topLevelMenuLayout === "vertical" || this.isTopLevelItem
+    return (hAsync("calcite-icon", { class: `${CSS$11.icon} ${CSS$11.iconDropdown}`, icon: this.topLevelMenuLayout === "vertical" || this.isTopLevelItem
         ? this.open
           ? "chevron-up"
           : "chevron-down"
-        : dirChevron, key: CSS$_.iconDropdown, scale: "s" }));
+        : dirChevron, key: CSS$11.iconDropdown, scale: "s" }));
   }
   renderDropdownAction(dir) {
     const dirChevron = dir === "rtl" ? "chevron-left" : "chevron-right";
-    return (hAsync("calcite-action", { class: CSS$_.dropdownAction, icon: this.topLevelMenuLayout === "vertical" || this.isTopLevelItem
+    return (hAsync("calcite-action", { class: CSS$11.dropdownAction, icon: this.topLevelMenuLayout === "vertical" || this.isTopLevelItem
         ? this.open
           ? "chevron-up"
           : "chevron-down"
-        : dirChevron, key: CSS$_.dropdownAction, onClick: this.clickHandler, onKeyDown: this.keyDownHandler, text: this.messages.open,
+        : dirChevron, key: CSS$11.dropdownAction, onClick: this.clickHandler, onKeyDown: this.keyDownHandler, text: this.messages.open,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.dropdownActionEl = el) }));
   }
   renderSubmenuItems(dir) {
     return (hAsync("calcite-menu", { class: {
-        [CSS$_.dropdownMenuItems]: true,
-        [CSS$_.open]: this.open,
-        [CSS$_.nested]: !this.isTopLevelItem,
+        [CSS$11.dropdownMenuItems]: true,
+        [CSS$11.open]: this.open,
+        [CSS$11.nested]: !this.isTopLevelItem,
         [CSS_UTILITY.rtl]: dir === "rtl",
-        [CSS$_.dropdownVertical]: this.topLevelMenuLayout === "vertical",
+        [CSS$11.dropdownVertical]: this.topLevelMenuLayout === "vertical",
       }, label: this.messages.submenu, layout: "vertical", role: "menu" }, hAsync("slot", { name: "submenu-item", onSlotchange: this.handleMenuItemSlotChange })));
   }
   renderHrefIcon(dir) {
-    return (hAsync("calcite-icon", { class: CSS$_.hoverHrefIcon, icon: dir === "rtl" ? "arrow-left" : "arrow-right", key: CSS$_.hoverHrefIcon, scale: "s" }));
+    return (hAsync("calcite-icon", { class: CSS$11.hoverHrefIcon, icon: dir === "rtl" ? "arrow-left" : "arrow-right", key: CSS$11.hoverHrefIcon, scale: "s" }));
   }
   renderItemContent(dir) {
     const hasHref = this.href && (this.topLevelMenuLayout === "vertical" || !this.isTopLevelItem);
-    return (hAsync(Fragment, null, this.iconStart && this.renderIconStart(), hAsync("div", { class: CSS$_.textContainer }, hAsync("span", null, this.text)), hasHref && this.renderHrefIcon(dir), this.iconEnd && this.renderIconEnd(), this.breadcrumb ? this.renderBreadcrumbIcon(dir) : null, !this.href && this.hasSubmenu ? this.renderDropdownIcon(dir) : null));
+    return (hAsync(Fragment, null, this.iconStart && this.renderIconStart(), hAsync("div", { class: CSS$11.textContainer }, hAsync("span", null, this.text)), hasHref && this.renderHrefIcon(dir), this.iconEnd && this.renderIconEnd(), this.breadcrumb ? this.renderBreadcrumbIcon(dir) : null, !this.href && this.hasSubmenu ? this.renderDropdownIcon(dir) : null));
   }
   render() {
     const dir = getElementDir(this.el);
     return (hAsync(Host, { onBlur: this.blurHandler, onFocus: this.focusHandler }, hAsync("li", { class: {
-        [CSS$_.container]: true,
-        [CSS$_.isParentVertical]: this.topLevelMenuLayout === "vertical",
-      }, role: "none" }, hAsync("div", { class: CSS$_.itemContent }, hAsync("a", { "aria-current": this.isFocused ? "page" : false, "aria-expanded": this.open, "aria-haspopup": this.hasSubmenu, "aria-label": this.label, class: { [CSS$_.layoutVertical]: this.layout === "vertical", [CSS$_.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$11.container]: true,
+        [CSS$11.isParentVertical]: this.topLevelMenuLayout === "vertical",
+      }, role: "none" }, hAsync("div", { class: CSS$11.itemContent }, hAsync("a", { "aria-current": this.isFocused ? "page" : false, "aria-expanded": this.open, "aria-haspopup": this.hasSubmenu, "aria-label": this.label, class: { [CSS$11.layoutVertical]: this.layout === "vertical", [CSS$11.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.anchorEl = el) }, this.renderItemContent(dir)), this.href && this.hasSubmenu ? this.renderDropdownAction(dir) : null), this.renderSubmenuItems(dir))));
   }
@@ -12619,7 +12619,7 @@ class CalciteMenuItem {
   }; }
 }
 
-const CSS$Z = {
+const CSS$10 = {
   container: "container",
   containerContent: "container-content",
   hasProgress: "progress-bar",
@@ -12628,7 +12628,7 @@ const CSS$Z = {
   secondary: "secondary",
   tertiary: "tertiary",
 };
-const SLOTS$q = {
+const SLOTS$r = {
   logo: "logo",
   user: "user",
   progress: "progress",
@@ -12746,7 +12746,7 @@ class CalciteNavigation {
     setComponentLoaded(this);
   }
   isPrimaryLevel() {
-    return this.el.slot !== SLOTS$q.navSecondary && this.el.slot !== SLOTS$q.navTertiary;
+    return this.el.slot !== SLOTS$r.navSecondary && this.el.slot !== SLOTS$r.navTertiary;
   }
   //--------------------------------------------------------------------------
   //
@@ -12754,7 +12754,7 @@ class CalciteNavigation {
   //
   //--------------------------------------------------------------------------
   renderMenuAction() {
-    return (hAsync("slot", { name: SLOTS$q.navigationAction, onSlotchange: this.handleMenuActionSlotChange }, this.navigationAction && (hAsync("calcite-action", { icon: ICONS$e.hamburger, onClick: this.actionClickHandler, text: this.label,
+    return (hAsync("slot", { name: SLOTS$r.navigationAction, onSlotchange: this.handleMenuActionSlotChange }, this.navigationAction && (hAsync("calcite-action", { icon: ICONS$e.hamburger, onClick: this.actionClickHandler, text: this.label,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.navigationActionEl = el) }))));
   }
@@ -12768,11 +12768,11 @@ class CalciteNavigation {
       this.navigationAction;
     const slotName = this.el.slot;
     return (hAsync(Host, null, hAsync("div", { class: {
-        [CSS$Z.container]: true,
-        [CSS$Z.secondary]: slotName === SLOTS$q.navSecondary,
-        [CSS$Z.tertiary]: slotName === SLOTS$q.navTertiary,
-        [CSS$Z.primary]: primaryLevelHasElements,
-      } }, hAsync("div", { class: { [CSS$Z.hide]: !this.progressSlotHasElement, [SLOTS$q.progress]: true } }, hAsync("slot", { name: SLOTS$q.progress, onSlotchange: this.handleProgressSlotChange })), hAsync("div", { class: { [CSS$Z.containerContent]: true, [CSS$Z.hasProgress]: this.progressSlotHasElement } }, this.renderMenuAction(), hAsync("div", { class: { [CSS$Z.hide]: !this.logoSlotHasElements, [SLOTS$q.logo]: true } }, hAsync("slot", { name: SLOTS$q.logo, onSlotchange: this.handleLogoSlotChange })), hAsync("slot", { name: SLOTS$q.contentStart, onSlotchange: this.handleContentStartSlotChange }), hAsync("slot", { name: SLOTS$q.contentCenter, onSlotchange: this.handleContentCenterSlotChange }), hAsync("slot", { name: SLOTS$q.contentEnd, onSlotchange: this.handleContentEndSlotChange }), hAsync("div", { class: { [CSS$Z.hide]: !this.userSlotHasElements, [SLOTS$q.user]: true } }, hAsync("slot", { name: SLOTS$q.user, onSlotchange: this.handleUserSlotChange })))), hAsync(Fragment, null, hAsync("slot", { name: SLOTS$q.navSecondary, onSlotchange: this.handleSecondarySlotChange }), hAsync("slot", { name: SLOTS$q.navTertiary, onSlotchange: this.handleTertiarySlotChange }))));
+        [CSS$10.container]: true,
+        [CSS$10.secondary]: slotName === SLOTS$r.navSecondary,
+        [CSS$10.tertiary]: slotName === SLOTS$r.navTertiary,
+        [CSS$10.primary]: primaryLevelHasElements,
+      } }, hAsync("div", { class: { [CSS$10.hide]: !this.progressSlotHasElement, [SLOTS$r.progress]: true } }, hAsync("slot", { name: SLOTS$r.progress, onSlotchange: this.handleProgressSlotChange })), hAsync("div", { class: { [CSS$10.containerContent]: true, [CSS$10.hasProgress]: this.progressSlotHasElement } }, this.renderMenuAction(), hAsync("div", { class: { [CSS$10.hide]: !this.logoSlotHasElements, [SLOTS$r.logo]: true } }, hAsync("slot", { name: SLOTS$r.logo, onSlotchange: this.handleLogoSlotChange })), hAsync("slot", { name: SLOTS$r.contentStart, onSlotchange: this.handleContentStartSlotChange }), hAsync("slot", { name: SLOTS$r.contentCenter, onSlotchange: this.handleContentCenterSlotChange }), hAsync("slot", { name: SLOTS$r.contentEnd, onSlotchange: this.handleContentEndSlotChange }), hAsync("div", { class: { [CSS$10.hide]: !this.userSlotHasElements, [SLOTS$r.user]: true } }, hAsync("slot", { name: SLOTS$r.user, onSlotchange: this.handleUserSlotChange })))), hAsync(Fragment, null, hAsync("slot", { name: SLOTS$r.navSecondary, onSlotchange: this.handleSecondarySlotChange }), hAsync("slot", { name: SLOTS$r.navTertiary, onSlotchange: this.handleTertiarySlotChange }))));
   }
   get el() { return getElement(this); }
   static get style() { return navigationCss; }
@@ -12799,7 +12799,7 @@ class CalciteNavigation {
   }; }
 }
 
-const CSS$Y = {
+const CSS$$ = {
   container: "container",
   heading: "heading",
   description: "description",
@@ -12852,10 +12852,10 @@ class CalciteNavigationLogo {
   // --------------------------------------------------------------------------
   render() {
     const { heading, description, thumbnail } = this;
-    return (hAsync(Host, null, hAsync("a", { class: CSS$Y.anchor, href: this.href, rel: this.rel, target: this.target }, thumbnail && hAsync("img", { alt: this.label || "", class: CSS$Y.image, src: thumbnail }), (heading || description) && (hAsync("div", { class: CSS$Y.container }, heading && (hAsync("span", { "aria-label": this.heading, class: {
-        [CSS$Y.heading]: true,
-        [CSS$Y.standalone]: !this.description,
-      }, key: CSS$Y.heading }, heading)), description && (hAsync("span", { "aria-label": this.description, class: CSS$Y.description, key: CSS$Y.description }, description)))))));
+    return (hAsync(Host, null, hAsync("a", { class: CSS$$.anchor, href: this.href, rel: this.rel, target: this.target }, thumbnail && hAsync("img", { alt: this.label || "", class: CSS$$.image, src: thumbnail }), (heading || description) && (hAsync("div", { class: CSS$$.container }, heading && (hAsync("span", { "aria-label": this.heading, class: {
+        [CSS$$.heading]: true,
+        [CSS$$.standalone]: !this.description,
+      }, key: CSS$$.heading }, heading)), description && (hAsync("span", { "aria-label": this.description, class: CSS$$.description, key: CSS$$.description }, description)))))));
   }
   static get delegatesFocus() { return true; }
   get el() { return getElement(this); }
@@ -12880,7 +12880,7 @@ class CalciteNavigationLogo {
   }; }
 }
 
-const CSS$X = {
+const CSS$_ = {
   textContainer: "text-container",
   fullName: "full-name",
   username: "username",
@@ -12927,7 +12927,7 @@ class CalciteNavigationUser {
   //
   // --------------------------------------------------------------------------
   render() {
-    return (hAsync(Host, null, hAsync("button", { "aria-label": this.label, class: CSS$X.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$X.textContainer }, this.fullName && (hAsync("span", { class: CSS$X.fullName, key: CSS$X.fullName }, this.fullName)), this.username && (hAsync("span", { class: CSS$X.username, key: CSS$X.username }, this.username)))))));
+    return (hAsync(Host, null, hAsync("button", { "aria-label": this.label, class: CSS$_.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$_.textContainer }, this.fullName && (hAsync("span", { class: CSS$_.fullName, key: CSS$_.fullName }, this.fullName)), this.username && (hAsync("span", { class: CSS$_.username, key: CSS$_.username }, this.username)))))));
   }
   static get delegatesFocus() { return true; }
   get el() { return getElement(this); }
@@ -12951,7 +12951,7 @@ class CalciteNavigationUser {
   }; }
 }
 
-const CSS$W = {
+const CSS$Z = {
   container: "container",
   header: "header",
   footer: "footer",
@@ -12960,7 +12960,7 @@ const CSS$W = {
   checkboxWrapper: "checkbox-wrapper",
   thumbnailWrapper: "thumbnail-wrapper",
 };
-const SLOTS$p = {
+const SLOTS$q = {
   thumbnail: "thumbnail",
   title: "title",
   subtitle: "subtitle",
@@ -13036,7 +13036,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", { "aria-live": "polite", 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$W.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", { "aria-live": "polite", 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$Z.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);
@@ -13046,24 +13046,24 @@ class Card {
     this.calciteCardSelect.emit();
   }
   renderThumbnail() {
-    return getSlotted(this.el, SLOTS$p.thumbnail) ? (hAsync("section", { class: CSS$W.thumbnailWrapper }, hAsync("slot", { name: SLOTS$p.thumbnail }))) : null;
+    return getSlotted(this.el, SLOTS$q.thumbnail) ? (hAsync("section", { class: CSS$Z.thumbnailWrapper }, hAsync("slot", { name: SLOTS$q.thumbnail }))) : null;
   }
   renderCheckbox() {
-    return (hAsync("calcite-label", { class: CSS$W.checkboxWrapper, onClick: this.cardSelectClick, onKeyDown: this.cardSelectKeyDown }, hAsync("calcite-checkbox", { checked: this.selected, label: this.messages.select })));
+    return (hAsync("calcite-label", { class: CSS$Z.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$p.title);
-    const subtitle = getSlotted(el, SLOTS$p.subtitle);
+    const title = getSlotted(el, SLOTS$q.title);
+    const subtitle = getSlotted(el, SLOTS$q.subtitle);
     const hasHeader = title || subtitle;
-    return hasHeader ? (hAsync("header", { class: CSS$W.header }, hAsync("slot", { name: SLOTS$p.title }), hAsync("slot", { name: SLOTS$p.subtitle }))) : null;
+    return hasHeader ? (hAsync("header", { class: CSS$Z.header }, hAsync("slot", { name: SLOTS$q.title }), hAsync("slot", { name: SLOTS$q.subtitle }))) : null;
   }
   renderFooter() {
     const { el } = this;
-    const startFooter = getSlotted(el, SLOTS$p.footerStart);
-    const endFooter = getSlotted(el, SLOTS$p.footerEnd);
+    const startFooter = getSlotted(el, SLOTS$q.footerStart);
+    const endFooter = getSlotted(el, SLOTS$q.footerEnd);
     const hasFooter = startFooter || endFooter;
-    return hasFooter ? (hAsync("footer", { class: CSS$W.footer }, hAsync("slot", { name: SLOTS$p.footerStart }), hAsync("slot", { name: SLOTS$p.footerEnd }))) : null;
+    return hasFooter ? (hAsync("footer", { class: CSS$Z.footer }, hAsync("slot", { name: SLOTS$q.footerStart }), hAsync("slot", { name: SLOTS$q.footerEnd }))) : null;
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -13226,7 +13226,7 @@ class Checkbox {
   }; }
 }
 
-const CSS$V = {
+const CSS$Y = {
   title: "title",
   close: "close",
   imageContainer: "image-container",
@@ -13242,7 +13242,7 @@ const CSS$V = {
   nonInteractive: "non-interactive",
   isCircle: "is-circle",
 };
-const SLOTS$o = {
+const SLOTS$p = {
   image: "image",
 };
 const ICONS$d = {
@@ -13395,7 +13395,7 @@ class Chip {
   //
   //--------------------------------------------------------------------------
   renderChipImage() {
-    return (hAsync("div", { class: CSS$V.imageContainer }, hAsync("slot", { name: SLOTS$o.image, onSlotchange: this.handleSlotImageChange })));
+    return (hAsync("div", { class: CSS$Y.imageContainer }, hAsync("slot", { name: SLOTS$p.image, onSlotchange: this.handleSlotImageChange })));
   }
   renderSelectionIcon() {
     const icon = this.selectionMode === "multiple" && this.selected
@@ -13406,17 +13406,17 @@ class Chip {
           ? ICONS$d.checkedSingle
           : undefined;
     return (hAsync("div", { class: {
-        [CSS$V.selectIcon]: true,
-        [CSS$V.selectIconActive]: this.selectionMode === "multiple" || this.selected,
+        [CSS$Y.selectIcon]: true,
+        [CSS$Y.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$V.close, onClick: this.close, onKeyDown: this.closeButtonKeyDownHandler, tabIndex: this.disabled ? -1 : 0,
+    return (hAsync("button", { "aria-label": this.messages.dismissLabel, class: CSS$Y.close, onClick: this.close, onKeyDown: this.closeButtonKeyDownHandler, tabIndex: this.disabled ? -1 : 0,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       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$V.chipIcon, flipRtl: this.iconFlipRtl, icon: this.icon, scale: this.scale === "l" ? "m" : "s" }));
+    return (hAsync("calcite-icon", { class: CSS$Y.chipIcon, flipRtl: this.iconFlipRtl, icon: this.icon, scale: this.scale === "l" ? "m" : "s" }));
   }
   render() {
     const disableInteraction = this.disabled || (!this.disabled && !this.interactive);
@@ -13430,21 +13430,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$V.container]: true,
-        [CSS$V.textSlotted]: this.hasText,
-        [CSS$V.imageSlotted]: this.hasImage,
-        [CSS$V.selectable]: this.selectionMode !== "none",
-        [CSS$V.multiple]: this.selectionMode === "multiple",
-        [CSS$V.closable]: this.closable,
-        [CSS$V.nonInteractive]: !this.interactive,
-        [CSS$V.isCircle]: !this.closable &&
+        [CSS$Y.container]: true,
+        [CSS$Y.textSlotted]: this.hasText,
+        [CSS$Y.imageSlotted]: this.hasImage,
+        [CSS$Y.selectable]: this.selectionMode !== "none",
+        [CSS$Y.multiple]: this.selectionMode === "multiple",
+        [CSS$Y.closable]: this.closable,
+        [CSS$Y.nonInteractive]: !this.interactive,
+        [CSS$Y.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: (el) => (this.containerEl = el) }, this.selectionMode !== "none" && this.renderSelectionIcon(), this.renderChipImage(), this.icon && this.renderIcon(), hAsync("span", { class: CSS$V.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$Y.title }, hAsync("slot", null)), this.closable && this.renderCloseButton())));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -15766,7 +15766,7 @@ function zeroArray(array, length) {
 
 var color = Color;
 
-const CSS$U = {
+const CSS$X = {
   channel: "channel",
   channels: "channels",
   colorField: "color-field",
@@ -16115,7 +16115,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$U.colorMode, "data-color-mode": channelMode, key: channelMode, onCalciteTabsActivate: this.handleTabActivate, selected: selected }, label));
+      return (hAsync("calcite-tab-title", { class: CSS$X.colorMode, "data-color-mode": channelMode, key: channelMode, onCalciteTabsActivate: this.handleTabActivate, selected: selected }, label));
     };
     this.renderChannelsTab = (channelMode) => {
       const { allowEmpty, channelMode: activeChannelMode, channels, messages, alphaChannel } = this;
@@ -16126,7 +16126,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$U.control, key: channelMode, selected: selected }, hAsync("div", { class: CSS$U.channels, dir: "ltr" }, channelsToRender.map((channelValue, index) => {
+      return (hAsync("calcite-tab", { class: CSS$X.control, key: channelMode, selected: selected }, hAsync("div", { class: CSS$X.channels, dir: "ltr" }, channelsToRender.map((channelValue, index) => {
         const isAlphaChannel = index === 3;
         if (isAlphaChannel) {
           channelValue =
@@ -16137,7 +16137,7 @@ class ColorPicker {
       }))));
     };
     this.renderChannel = (value, index, ariaLabel, direction, suffix) => {
-      return (hAsync("calcite-input-number", { class: CSS$U.channel, "data-channel-index": index, dir: direction, key: index, label: ariaLabel, lang: this.effectiveLocale, numberButtonType: "none", numberingSystem: this.numberingSystem, onCalciteInputNumberChange: this.handleChannelChange, onCalciteInputNumberInput: this.handleChannelInput, onKeyDown: this.handleKeyDown, scale: this.scale === "l" ? "m" : "s",
+      return (hAsync("calcite-input-number", { class: CSS$X.channel, "data-channel-index": index, dir: direction, key: index, label: ariaLabel, lang: this.effectiveLocale, numberButtonType: "none", numberingSystem: this.numberingSystem, onCalciteInputNumberChange: this.handleChannelChange, onCalciteInputNumberInput: 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
@@ -16327,7 +16327,7 @@ class ColorPicker {
     this.shiftKeyChannelAdjustment = 0;
     const { key } = event;
     if ((key !== "ArrowUp" && key !== "ArrowDown") ||
-      !event.composedPath().some((node) => node.classList?.contains(CSS$U.channel))) {
+      !event.composedPath().some((node) => node.classList?.contains(CSS$X.channel))) {
       return;
     }
     const { shiftKey } = event;
@@ -16419,35 +16419,35 @@ class ColorPicker {
     const [adjustedColorFieldScopeLeft, adjustedColorFieldScopeTop] = this.getAdjustedScopePosition(colorFieldScopeLeft, colorFieldScopeTop);
     const [adjustedHueScopeLeft, adjustedHueScopeTop] = this.getAdjustedScopePosition(hueLeft, hueTop);
     const [adjustedOpacityScopeLeft, adjustedOpacityScopeTop] = this.getAdjustedScopePosition(opacityLeft, opacityTop);
-    return (hAsync("div", { class: CSS$U.container }, hAsync("div", { class: CSS$U.controlAndScope }, hAsync("canvas", { class: CSS$U.colorField, onPointerDown: this.handleColorFieldPointerDown,
+    return (hAsync("div", { class: CSS$X.container }, hAsync("div", { class: CSS$X.controlAndScope }, hAsync("canvas", { class: CSS$X.colorField, onPointerDown: this.handleColorFieldPointerDown,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      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$U.scope]: true, [CSS$U.colorFieldScope]: true }, onKeyDown: this.handleColorFieldScopeKeyDown, role: "slider", style: {
+      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$X.scope]: true, [CSS$X.colorFieldScope]: true }, onKeyDown: this.handleColorFieldScopeKeyDown, role: "slider", style: {
         top: `${adjustedColorFieldScopeTop || 0}px`,
         left: `${adjustedColorFieldScopeLeft || 0}px`,
       }, tabindex: "0",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: this.storeColorFieldScope })), hAsync("div", { class: CSS$U.previewAndSliders }, hAsync("calcite-color-picker-swatch", { class: CSS$U.preview, color: selectedColorInHex, scale: "l" }), hAsync("div", { class: CSS$U.sliders }, hAsync("div", { class: CSS$U.controlAndScope }, hAsync("canvas", { class: { [CSS$U.slider]: true, [CSS$U.hueSlider]: true }, onPointerDown: this.handleHueSliderPointerDown,
+      ref: this.storeColorFieldScope })), hAsync("div", { class: CSS$X.previewAndSliders }, hAsync("calcite-color-picker-swatch", { class: CSS$X.preview, color: selectedColorInHex, scale: "l" }), hAsync("div", { class: CSS$X.sliders }, hAsync("div", { class: CSS$X.controlAndScope }, hAsync("canvas", { class: { [CSS$X.slider]: true, [CSS$X.hueSlider]: true }, onPointerDown: this.handleHueSliderPointerDown,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      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$U.scope]: true, [CSS$U.hueScope]: true }, onKeyDown: this.handleHueScopeKeyDown, role: "slider", style: {
+      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$X.scope]: true, [CSS$X.hueScope]: true }, onKeyDown: this.handleHueScopeKeyDown, role: "slider", style: {
         top: `${adjustedHueScopeTop}px`,
         left: `${adjustedHueScopeLeft}px`,
       }, tabindex: "0",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: this.storeHueScope })), alphaChannel ? (hAsync("div", { class: CSS$U.controlAndScope }, hAsync("canvas", { class: { [CSS$U.slider]: true, [CSS$U.opacitySlider]: true }, onPointerDown: this.handleOpacitySliderPointerDown,
+      ref: this.storeHueScope })), alphaChannel ? (hAsync("div", { class: CSS$X.controlAndScope }, hAsync("canvas", { class: { [CSS$X.slider]: true, [CSS$X.opacitySlider]: true }, onPointerDown: this.handleOpacitySliderPointerDown,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      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$U.scope]: true, [CSS$U.opacityScope]: true }, onKeyDown: this.handleOpacityScopeKeyDown, role: "slider", style: {
+      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$X.scope]: true, [CSS$X.opacityScope]: true }, onKeyDown: this.handleOpacityScopeKeyDown, role: "slider", style: {
         top: `${adjustedOpacityScopeTop}px`,
         left: `${adjustedOpacityScopeLeft}px`,
       }, tabindex: "0",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.storeOpacityScope }))) : null)), noHex && noChannels ? null : (hAsync("div", { class: {
-        [CSS$U.controlSection]: true,
-        [CSS$U.section]: true,
-      } }, hAsync("div", { class: CSS$U.hexAndChannelsGroup }, noHex ? null : (hAsync("div", { class: CSS$U.hexOptions }, hAsync("calcite-color-picker-hex-input", { allowEmpty: allowEmpty, alphaChannel: alphaChannel, class: CSS$U.control, messages: messages, numberingSystem: this.numberingSystem, onCalciteColorPickerHexInputChange: this.handleHexInputChange, scale: scale, value: selectedColorInHex }))), noChannels ? null : (hAsync("calcite-tabs", { class: {
-        [CSS$U.colorModeContainer]: true,
-        [CSS$U.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$U.savedColorsSection]: true, [CSS$U.section]: true } }, hAsync("div", { class: CSS$U.header }, hAsync("label", null, messages.saved), hAsync("div", { class: CSS$U.savedColorsButtons }, hAsync("calcite-button", { appearance: "transparent", class: CSS$U.deleteColor, disabled: noColor, iconStart: "minus", kind: "neutral", label: messages.deleteColor, onClick: this.deleteColor, scale: scale, type: "button" }), hAsync("calcite-button", { appearance: "transparent", class: CSS$U.saveColor, disabled: noColor, iconStart: "plus", kind: "neutral", label: messages.saveColor, onClick: this.saveColor, scale: scale, type: "button" }))), savedColors.length > 0 ? (hAsync("div", { class: CSS$U.savedColors }, [
-      ...savedColors.map((color) => (hAsync("calcite-color-picker-swatch", { class: CSS$U.savedColor, color: color, key: color, onClick: this.handleSavedColorSelect, onKeyDown: this.handleSavedColorKeyDown, scale: scale, tabIndex: 0 }))),
+        [CSS$X.controlSection]: true,
+        [CSS$X.section]: true,
+      } }, hAsync("div", { class: CSS$X.hexAndChannelsGroup }, noHex ? null : (hAsync("div", { class: CSS$X.hexOptions }, hAsync("calcite-color-picker-hex-input", { allowEmpty: allowEmpty, alphaChannel: alphaChannel, class: CSS$X.control, messages: messages, numberingSystem: this.numberingSystem, onCalciteColorPickerHexInputChange: this.handleHexInputChange, scale: scale, value: selectedColorInHex }))), noChannels ? null : (hAsync("calcite-tabs", { class: {
+        [CSS$X.colorModeContainer]: true,
+        [CSS$X.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$X.savedColorsSection]: true, [CSS$X.section]: true } }, hAsync("div", { class: CSS$X.header }, hAsync("label", null, messages.saved), hAsync("div", { class: CSS$X.savedColorsButtons }, hAsync("calcite-button", { appearance: "transparent", class: CSS$X.deleteColor, disabled: noColor, iconStart: "minus", kind: "neutral", label: messages.deleteColor, onClick: this.deleteColor, scale: scale, type: "button" }), hAsync("calcite-button", { appearance: "transparent", class: CSS$X.saveColor, disabled: noColor, iconStart: "plus", kind: "neutral", label: messages.saveColor, onClick: this.saveColor, scale: scale, type: "button" }))), savedColors.length > 0 ? (hAsync("div", { class: CSS$X.savedColors }, [
+      ...savedColors.map((color) => (hAsync("calcite-color-picker-swatch", { class: CSS$X.savedColor, color: color, key: color, onClick: this.handleSavedColorSelect, onKeyDown: this.handleSavedColorKeyDown, scale: scale, tabIndex: 0 }))),
     ])) : null))));
   }
   // --------------------------------------------------------------------------
@@ -16818,7 +16818,7 @@ class ColorPicker {
   }; }
 }
 
-const CSS$T = {
+const CSS$W = {
   container: "container",
   hexInput: "hex-input",
   opacityInput: "opacity-input",
@@ -16986,9 +16986,9 @@ class ColorPickerHexInput {
     const hexInputValue = this.formatHexForInternalInput(value);
     const opacityInputValue = this.formatOpacityForInternalInput(internalColor);
     const inputScale = scale === "l" ? "m" : "s";
-    return (hAsync("div", { class: CSS$T.container }, hAsync("calcite-input-text", { class: CSS$T.hexInput, label: messages?.hex || hexLabel, maxLength: 6, onCalciteInputTextChange: this.onHexInputChange, onCalciteInternalInputTextBlur: this.onHexInputBlur, onKeyDown: this.onInputKeyDown, onPaste: this.onHexInputPaste, prefixText: "#", scale: inputScale, value: hexInputValue,
+    return (hAsync("div", { class: CSS$W.container }, hAsync("calcite-input-text", { class: CSS$W.hexInput, label: messages?.hex || hexLabel, maxLength: 6, onCalciteInputTextChange: this.onHexInputChange, onCalciteInternalInputTextBlur: this.onHexInputBlur, onKeyDown: this.onInputKeyDown, onPaste: this.onHexInputPaste, prefixText: "#", scale: inputScale, value: hexInputValue,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: this.storeHexInputRef }), alphaChannel ? (hAsync("calcite-input-number", { class: CSS$T.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$W.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.storeOpacityInputRef })) : null));
   }
@@ -17084,7 +17084,7 @@ class ColorPickerHexInput {
   }; }
 }
 
-const CSS$S = {
+const CSS$V = {
   swatch: "swatch",
   noColorSwatch: "swatch--no-color",
   checker: "checker",
@@ -17122,8 +17122,8 @@ class ColorPickerSwatch {
   render() {
     const isEmpty = !this.internalColor;
     const classes = {
-      [CSS$S.swatch]: true,
-      [CSS$S.noColorSwatch]: isEmpty,
+      [CSS$V.swatch]: true,
+      [CSS$V.noColorSwatch]: isEmpty,
     };
     return (hAsync("svg", { class: classes, xmlns: "http://www.w3.org/2000/svg" }, this.renderSwatch()));
   }
@@ -17149,7 +17149,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$S.checker, height: CHECKER_DIMENSIONS.squareSize, width: CHECKER_DIMENSIONS.squareSize, x: "0", y: "0" }), hAsync("rect", { class: CSS$S.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$V.checker, height: CHECKER_DIMENSIONS.squareSize, width: CHECKER_DIMENSIONS.squareSize, x: "0", y: "0" }), hAsync("rect", { class: CSS$V.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));
   }
@@ -18878,7 +18878,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$R = {
+const CSS$U = {
   listContainer: "list-container",
 };
 
@@ -18906,11 +18906,11 @@ function isSingleLike(selectionMode) {
   return selectionMode.includes("single");
 }
 
-const CSS$Q = {
+const CSS$T = {
   button: "x-button",
 };
 function XButton({ disabled, key, label, onClick, ref, scale, }) {
-  return (hAsync("button", { "aria-label": label, class: CSS$Q.button, disabled: disabled, key: key, onClick: onClick, tabIndex: -1, type: "button", 
+  return (hAsync("button", { "aria-label": label, class: CSS$T.button, disabled: disabled, key: key, onClick: onClick, tabIndex: -1, type: "button", 
     // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
     ref: ref },
     hAsync("calcite-icon", { icon: "x", scale: scale === "l" ? "m" : "s" })));
@@ -19108,7 +19108,7 @@ class Combobox {
         event.preventDefault();
         return;
       }
-      if (composedPath.some((node) => node.classList?.contains(CSS$Q.button))) {
+      if (composedPath.some((node) => node.classList?.contains(CSS$T.button))) {
         this.clearValue();
         event.preventDefault();
         return;
@@ -19723,7 +19723,7 @@ class Combobox {
   renderFloatingUIContainer() {
     const { setFloatingEl, setContainerEl, open } = this;
     const classes = {
-      [CSS$R.listContainer]: true,
+      [CSS$U.listContainer]: true,
       [FloatingCSS.animation]: true,
       [FloatingCSS.animationActive]: open,
     };
@@ -19822,7 +19822,7 @@ class Combobox {
   }; }
 }
 
-const CSS$P = {
+const CSS$S = {
   icon: "icon",
   iconActive: "icon--active",
   iconIndent: "icon--indent",
@@ -19901,20 +19901,20 @@ class ComboboxItem {
   // --------------------------------------------------------------------------
   renderIcon(iconPath) {
     return this.icon ? (hAsync("calcite-icon", { class: {
-        [CSS$P.custom]: !!this.icon,
-        [CSS$P.iconActive]: this.icon && this.selected,
-        [CSS$P.iconIndent]: true,
+        [CSS$S.custom]: !!this.icon,
+        [CSS$S.iconActive]: this.icon && this.selected,
+        [CSS$S.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$P.icon]: true,
-        [CSS$P.dot]: true,
-        [CSS$P.iconIndent]: true,
+        [CSS$S.icon]: true,
+        [CSS$S.dot]: true,
+        [CSS$S.iconIndent]: true,
       } })) : (hAsync("calcite-icon", { class: {
-        [CSS$P.icon]: true,
-        [CSS$P.iconActive]: this.selected,
-        [CSS$P.iconIndent]: true,
+        [CSS$S.icon]: true,
+        [CSS$S.iconActive]: this.selected,
+        [CSS$S.iconIndent]: true,
       }, flipRtl: this.iconFlipRtl, icon: iconPath, key: "indicator", scale: this.scale === "l" ? "m" : "s" }));
   }
   renderChildren() {
@@ -19929,10 +19929,10 @@ class ComboboxItem {
     const defaultIcon = isSingleSelect ? "dot" : "check";
     const iconPath = this.disabled ? "circle-disallowed" : defaultIcon;
     const classes = {
-      [CSS$P.label]: true,
-      [CSS$P.selected]: this.selected,
-      [CSS$P.active]: this.active,
-      [CSS$P.single]: isSingleSelect,
+      [CSS$S.label]: true,
+      [CSS$S.selected]: this.selected,
+      [CSS$S.active]: this.active,
+      [CSS$S.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())));
@@ -19965,7 +19965,7 @@ class ComboboxItem {
   }; }
 }
 
-const CSS$O = {
+const CSS$R = {
   list: "list",
   label: "label",
   title: "title",
@@ -20001,7 +20001,7 @@ class ComboboxItemGroup {
   render() {
     const { el, scale } = this;
     const depth = getDepth$1();
-    return (hAsync("ul", { "aria-labelledby": this.guid, class: { [CSS$O.list]: true, [`scale--${scale}`]: true }, role: "group" }, hAsync("li", { class: { [CSS$O.label]: true }, id: this.guid, role: "presentation", style: { "--calcite-combobox-item-spacing-indent-multiplier": `${depth}` } }, hAsync("span", { class: CSS$O.title }, this.label)), hAsync("slot", null)));
+    return (hAsync("ul", { "aria-labelledby": this.guid, class: { [CSS$R.list]: true, [`scale--${scale}`]: true }, role: "group" }, hAsync("li", { class: { [CSS$R.label]: true }, id: this.guid, role: "presentation", style: { "--calcite-combobox-item-spacing-indent-multiplier": `${depth}` } }, hAsync("span", { class: CSS$R.title }, this.label)), hAsync("slot", null)));
   }
   get el() { return getElement(this); }
   static get style() { return comboboxItemGroupCss; }
@@ -21188,7 +21188,7 @@ class DatePickerMonth {
   }; }
 }
 
-const CSS$N = {
+const CSS$Q = {
   header: "header",
   month: "month",
   chevron: "chevron",
@@ -21288,7 +21288,7 @@ class DatePickerMonthHeader {
     this.setNextPrevMonthDates();
   }
   render() {
-    return hAsync("div", { class: CSS$N.header }, this.renderContent());
+    return hAsync("div", { class: CSS$Q.header }, this.renderContent());
   }
   renderContent() {
     const { messages, localeData, activeDate } = this;
@@ -21311,12 +21311,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$N.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$N.textReverse]: reverse } }, hAsync(Heading, { class: CSS$N.month, level: this.headingLevel }, localizedMonth), hAsync("span", { class: CSS$N.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$Q.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$Q.textReverse]: reverse } }, hAsync(Heading, { class: CSS$Q.month, level: this.headingLevel }, localizedMonth), hAsync("span", { class: CSS$Q.yearWrap }, hAsync("input", { "aria-label": messages.year, class: {
         year: true,
-        [CSS$N.yearSuffix]: !!suffix,
+        [CSS$Q.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: (el) => (this.yearInput = el) }), suffix && hAsync("span", { class: CSS$N.suffix }, suffix))), hAsync("a", { "aria-disabled": `${this.nextMonthDate.getMonth() === activeMonth}`, "aria-label": messages.nextMonth, class: CSS$N.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$Q.suffix }, suffix))), hAsync("a", { "aria-disabled": `${this.nextMonthDate.getMonth() === activeMonth}`, "aria-label": messages.nextMonth, class: CSS$Q.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) {
@@ -21392,7 +21392,7 @@ class DatePickerMonthHeader {
   }; }
 }
 
-const SLOTS$n = {
+const SLOTS$o = {
   dropdownTrigger: "trigger",
 };
 
@@ -21630,7 +21630,7 @@ class Dropdown {
     const { open, guid } = this;
     return (hAsync(Host, null, hAsync("div", { class: "calcite-trigger-container", id: `${guid}-menubutton`, onClick: this.openCalciteDropdown, onKeyDown: this.keyDownHandler,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: this.setReferenceEl }, hAsync("slot", { "aria-controls": `${guid}-menu`, "aria-expanded": toAriaBoolean(open), "aria-haspopup": "menu", name: SLOTS$n.dropdownTrigger, onSlotchange: this.updateTriggers })), hAsync("div", { "aria-hidden": toAriaBoolean(!open), class: "calcite-dropdown-wrapper",
+      ref: this.setReferenceEl }, hAsync("slot", { "aria-controls": `${guid}-menu`, "aria-expanded": toAriaBoolean(open), "aria-haspopup": "menu", name: SLOTS$o.dropdownTrigger, onSlotchange: this.updateTriggers })), hAsync("div", { "aria-hidden": toAriaBoolean(!open), class: "calcite-dropdown-wrapper",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setFloatingEl }, hAsync("div", { "aria-labelledby": `${guid}-menubutton`, class: {
         ["calcite-dropdown-content"]: true,
@@ -21819,7 +21819,7 @@ class Dropdown {
   }; }
 }
 
-const CSS$M = {
+const CSS$P = {
   container: "container",
   containerLink: "container--link",
   containerMulti: "container--multi-selection",
@@ -21867,8 +21867,8 @@ class DropdownGroup {
     const groupTitle = this.groupTitle ? (hAsync("span", { "aria-hidden": "true", class: "dropdown-title" }, this.groupTitle)) : null;
     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: {
-        [CSS$M.container]: true,
-        [`${CSS$M.container}--${this.scale}`]: true,
+        [CSS$P.container]: true,
+        [`${CSS$P.container}--${this.scale}`]: true,
       } }, dropdownSeparator, groupTitle, hAsync("slot", null))));
   }
   //--------------------------------------------------------------------------
@@ -21962,9 +21962,9 @@ class DropdownItem {
   }
   render() {
     const { href, selectionMode, label, iconFlipRtl, scale } = this;
-    const iconStartEl = (hAsync("calcite-icon", { class: CSS$M.iconStart, flipRtl: iconFlipRtl === "start" || iconFlipRtl === "both", icon: this.iconStart, scale: scale === "l" ? "m" : "s" }));
-    const contentNode = (hAsync("span", { class: CSS$M.itemContent }, hAsync("slot", null)));
-    const iconEndEl = (hAsync("calcite-icon", { class: CSS$M.iconEnd, flipRtl: iconFlipRtl === "end" || iconFlipRtl === "both", icon: this.iconEnd, scale: scale === "l" ? "m" : "s" }));
+    const iconStartEl = (hAsync("calcite-icon", { class: CSS$P.iconStart, flipRtl: iconFlipRtl === "start" || iconFlipRtl === "both", icon: this.iconStart, scale: scale === "l" ? "m" : "s" }));
+    const contentNode = (hAsync("span", { class: CSS$P.itemContent }, hAsync("slot", null)));
+    const iconEndEl = (hAsync("calcite-icon", { class: CSS$P.iconEnd, flipRtl: iconFlipRtl === "end" || iconFlipRtl === "both", icon: this.iconEnd, scale: scale === "l" ? "m" : "s" }));
     const slottedContent = this.iconStart && this.iconEnd
       ? [iconStartEl, contentNode, iconEndEl]
       : this.iconStart
@@ -21972,7 +21972,7 @@ class DropdownItem {
         : this.iconEnd
           ? [contentNode, iconEndEl]
           : contentNode;
-    const contentEl = !href ? (slottedContent) : (hAsync("a", { "aria-label": label, class: CSS$M.link, href: href, rel: this.rel, tabIndex: -1, target: this.target,
+    const contentEl = !href ? (slottedContent) : (hAsync("a", { "aria-label": label, class: CSS$P.link, href: href, rel: this.rel, tabIndex: -1, target: this.target,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.childLink = el) }, slottedContent));
     const itemRole = href
@@ -21984,13 +21984,13 @@ class DropdownItem {
           : "menuitem";
     const itemAria = selectionMode !== "none" ? toAriaBoolean(this.selected) : null;
     return (hAsync(Host, { "aria-checked": itemAria, "aria-label": !href ? label : "", role: itemRole, tabindex: "0" }, hAsync("div", { class: {
-        [CSS$M.container]: true,
-        [CSS$M.containerLink]: !!href,
-        [`${CSS$M.container}--${scale}`]: true,
-        [CSS$M.containerMulti]: selectionMode === "multiple",
-        [CSS$M.containerSingle]: selectionMode === "single",
-        [CSS$M.containerNone]: selectionMode === "none",
-      } }, selectionMode !== "none" ? (hAsync("calcite-icon", { class: CSS$M.icon, icon: selectionMode === "multiple" ? "check" : "bullet-point", scale: scale === "l" ? "m" : "s" })) : null, contentEl)));
+        [CSS$P.container]: true,
+        [CSS$P.containerLink]: !!href,
+        [`${CSS$P.container}--${scale}`]: true,
+        [CSS$P.containerMulti]: selectionMode === "multiple",
+        [CSS$P.containerSingle]: selectionMode === "single",
+        [CSS$P.containerNone]: selectionMode === "none",
+      } }, selectionMode !== "none" ? (hAsync("calcite-icon", { class: CSS$P.icon, icon: selectionMode === "multiple" ? "check" : "bullet-point", scale: scale === "l" ? "m" : "s" })) : null, contentEl)));
   }
   //--------------------------------------------------------------------------
   //
@@ -22097,7 +22097,7 @@ class DropdownItem {
   }; }
 }
 
-const CSS$L = {
+const CSS$O = {
   button: "button",
 };
 const ICONS$c = {
@@ -22158,7 +22158,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$L.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$O.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (buttonEl) => {
         this.buttonEl = buttonEl;
@@ -22188,7 +22188,7 @@ class Fab {
   }; }
 }
 
-const CSS$K = {
+const CSS$N = {
   container: "container",
   searchIcon: "search-icon",
 };
@@ -22317,7 +22317,7 @@ class Filter {
   // --------------------------------------------------------------------------
   render() {
     const { disabled, scale } = this;
-    return (hAsync(Fragment, null, hAsync("div", { class: CSS$K.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$N.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => {
         this.textInput = el;
@@ -22356,7 +22356,7 @@ class Filter {
   }; }
 }
 
-const CSS$J = {
+const CSS$M = {
   frame: "frame",
   frameAdvancing: "frame--advancing",
   frameRetreating: "frame--retreating",
@@ -22477,9 +22477,9 @@ class Flow {
   render() {
     const { flowDirection } = this;
     const frameDirectionClasses = {
-      [CSS$J.frame]: true,
-      [CSS$J.frameAdvancing]: flowDirection === "advancing",
-      [CSS$J.frameRetreating]: flowDirection === "retreating",
+      [CSS$M.frame]: true,
+      [CSS$M.frameAdvancing]: flowDirection === "advancing",
+      [CSS$M.frameRetreating]: flowDirection === "retreating",
     };
     return (hAsync("div", { class: frameDirectionClasses }, hAsync("slot", null)));
   }
@@ -22501,7 +22501,7 @@ class Flow {
   }; }
 }
 
-const CSS$I = {
+const CSS$L = {
   actionBarContainer: "action-bar-container",
   backButton: "back-button",
   container: "container",
@@ -22525,7 +22525,7 @@ const ICONS$a = {
   backLeft: "chevron-left",
   backRight: "chevron-right",
 };
-const SLOTS$m = {
+const SLOTS$n = {
   actionBar: "action-bar",
   headerActionsStart: "header-actions-start",
   headerActionsEnd: "header-actions-end",
@@ -22536,14 +22536,14 @@ const SLOTS$m = {
   footerActions: "footer-actions",
 };
 
-const CSS$H = {
+const CSS$K = {
   backButton: "back-button",
 };
 const ICONS$9 = {
   backLeft: "chevron-left",
   backRight: "chevron-right",
 };
-const SLOTS$l = {
+const SLOTS$m = {
   actionBar: "action-bar",
   headerActionsStart: "header-actions-start",
   headerActionsEnd: "header-actions-end",
@@ -22684,7 +22684,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$H.backButton, icon: icon, key: "flow-back-button", onClick: backButtonClick, scale: "s", slot: "header-actions-start", text: label, title: label,
+    return showBackButton ? (hAsync("calcite-action", { "aria-label": label, class: CSS$K.backButton, icon: icon, key: "flow-back-button", onClick: backButtonClick, scale: "s", slot: "header-actions-start", text: label, title: label,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setBackRef })) : null;
   }
@@ -22692,7 +22692,7 @@ class FlowItem {
     const { closable, closed, description, disabled, heading, headingLevel, loading, menuOpen, messages, } = this;
     return (hAsync(Host, null, hAsync("calcite-panel", { closable: closable, closed: closed, description: description, disabled: disabled, heading: heading, headingLevel: headingLevel, loading: loading, menuOpen: menuOpen, messageOverrides: messages, onCalcitePanelClose: this.handlePanelClose, onCalcitePanelScroll: this.handlePanelScroll,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: this.setContainerRef }, this.renderBackButton(), hAsync("slot", { name: SLOTS$l.actionBar, slot: SLOTS$m.actionBar }), hAsync("slot", { name: SLOTS$l.headerActionsStart, slot: SLOTS$m.headerActionsStart }), hAsync("slot", { name: SLOTS$l.headerActionsEnd, slot: SLOTS$m.headerActionsEnd }), hAsync("slot", { name: SLOTS$l.headerContent, slot: SLOTS$m.headerContent }), hAsync("slot", { name: SLOTS$l.headerMenuActions, slot: SLOTS$m.headerMenuActions }), hAsync("slot", { name: SLOTS$l.fab, slot: SLOTS$m.fab }), hAsync("slot", { name: SLOTS$l.footerActions, slot: SLOTS$m.footerActions }), hAsync("slot", { name: SLOTS$l.footer, slot: SLOTS$m.footer }), hAsync("slot", null))));
+      ref: this.setContainerRef }, this.renderBackButton(), hAsync("slot", { name: SLOTS$m.actionBar, slot: SLOTS$n.actionBar }), hAsync("slot", { name: SLOTS$m.headerActionsStart, slot: SLOTS$n.headerActionsStart }), hAsync("slot", { name: SLOTS$m.headerActionsEnd, slot: SLOTS$n.headerActionsEnd }), hAsync("slot", { name: SLOTS$m.headerContent, slot: SLOTS$n.headerContent }), hAsync("slot", { name: SLOTS$m.headerMenuActions, slot: SLOTS$n.headerMenuActions }), hAsync("slot", { name: SLOTS$m.fab, slot: SLOTS$n.fab }), hAsync("slot", { name: SLOTS$m.footerActions, slot: SLOTS$n.footerActions }), hAsync("slot", { name: SLOTS$m.footer, slot: SLOTS$n.footer }), hAsync("slot", null))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -22948,7 +22948,7 @@ class Graph {
   }; }
 }
 
-const CSS$G = {
+const CSS$J = {
   handle: "handle",
   handleActivated: "handle--activated",
 };
@@ -23071,7 +23071,7 @@ class Handle {
   render() {
     return (
     // Needs to be a span because of https://github.com/SortableJS/Sortable/issues/1486
-    hAsync("span", { "aria-label": this.getAriaText("label"), "aria-pressed": toAriaBoolean(this.activated), class: { [CSS$G.handle]: true, [CSS$G.handleActivated]: this.activated }, onBlur: this.handleBlur, onKeyDown: this.handleKeyDown, role: "button", tabindex: "0", title: this.messages?.dragHandle,
+    hAsync("span", { "aria-label": this.getAriaText("label"), "aria-pressed": toAriaBoolean(this.activated), class: { [CSS$J.handle]: true, [CSS$J.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => {
         this.handleButton = el;
@@ -23110,7 +23110,7 @@ class Handle {
   }; }
 }
 
-const CSS$F = {
+const CSS$I = {
   icon: "icon",
   flipRtl: "flip-rtl",
 };
@@ -23158,7 +23158,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$F.flipRtl]: dir === "rtl" && flipRtl,
+        [CSS$I.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 }))))));
   }
@@ -23204,7 +23204,7 @@ class Icon {
   }; }
 }
 
-const CSS$E = {
+const CSS$H = {
   wrapper: "wrapper",
   confirmChangesButton: "confirm-changes-button",
   cancelEditingButton: "cancel-editing-button",
@@ -23354,16 +23354,16 @@ class InlineEditable {
     updateHostInteraction(this);
   }
   render() {
-    return (hAsync("div", { class: CSS$E.wrapper, onClick: this.enableEditingHandler, onKeyDown: this.escapeKeyHandler }, hAsync("div", { class: CSS$E.inputWrapper }, hAsync("slot", null)), hAsync("div", { class: CSS$E.controlsWrapper }, hAsync("calcite-button", { appearance: "transparent", class: CSS$E.enableEditingButton, disabled: this.disabled, iconStart: "pencil", kind: "neutral", label: this.messages.enableEditing, onClick: this.enableEditingHandler, scale: this.scale, style: {
+    return (hAsync("div", { class: CSS$H.wrapper, onClick: this.enableEditingHandler, onKeyDown: this.escapeKeyHandler }, hAsync("div", { class: CSS$H.inputWrapper }, hAsync("slot", null)), hAsync("div", { class: CSS$H.controlsWrapper }, hAsync("calcite-button", { appearance: "transparent", class: CSS$H.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.enableEditingButton = el) }), this.shouldShowControls && [
-      hAsync("div", { class: CSS$E.cancelEditingButtonWrapper }, hAsync("calcite-button", { appearance: "transparent", class: CSS$E.cancelEditingButton, disabled: this.disabled, iconStart: "x", kind: "neutral", label: this.messages.cancelEditing, onClick: this.cancelEditingHandler, scale: this.scale, type: "button",
+      hAsync("div", { class: CSS$H.cancelEditingButtonWrapper }, hAsync("calcite-button", { appearance: "transparent", class: CSS$H.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
         ref: (el) => (this.cancelEditingButton = el) })),
-      hAsync("calcite-button", { appearance: "solid", class: CSS$E.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$H.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
         ref: (el) => (this.confirmEditingButton = el) }),
     ])));
@@ -23449,7 +23449,7 @@ class InlineEditable {
   }; }
 }
 
-const CSS$D = {
+const CSS$G = {
   loader: "loader",
   clearButton: "clear-button",
   editingEnabled: "editing-enabled",
@@ -23473,7 +23473,7 @@ const INPUT_TYPE_ICONS = {
   time: "clock",
   search: "search",
 };
-const SLOTS$k = {
+const SLOTS$l = {
   action: "action",
 };
 
@@ -24033,38 +24033,38 @@ class Input {
   // --------------------------------------------------------------------------
   render() {
     const dir = getElementDir(this.el);
-    const loader = (hAsync("div", { class: CSS$D.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
-    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$D.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$D.inputIcon, flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }));
+    const loader = (hAsync("div", { class: CSS$G.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
+    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$G.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$G.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$D.numberButtonItem]: true,
-        [CSS$D.buttonItemHorizontal]: isHorizontalNumberButton,
+        [CSS$G.numberButtonItem]: true,
+        [CSS$G.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$D.numberButtonItem]: true,
-        [CSS$D.buttonItemHorizontal]: isHorizontalNumberButton,
+        [CSS$G.numberButtonItem]: true,
+        [CSS$G.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$D.numberButtonWrapper }, numberButtonsHorizontalUp, numberButtonsHorizontalDown));
-    const prefixText = hAsync("div", { class: CSS$D.prefix }, this.prefixText);
-    const suffixText = hAsync("div", { class: CSS$D.suffix }, this.suffixText);
+    const numberButtonsVertical = (hAsync("div", { class: CSS$G.numberButtonWrapper }, numberButtonsHorizontalUp, numberButtonsHorizontalDown));
+    const prefixText = hAsync("div", { class: CSS$G.prefix }, this.prefixText);
+    const suffixText = hAsync("div", { class: CSS$G.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       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$D.editingEnabled]: this.editingEnabled,
-            [CSS$D.inlineChild]: !!this.inlineEditableEl,
+            [CSS$G.editingEnabled]: this.editingEnabled,
+            [CSS$G.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
           ref: this.setChildElRef }),
-        this.isTextarea ? (hAsync("div", { class: CSS$D.resizeIconWrapper }, hAsync("calcite-icon", { icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" }))) : null,
+        this.isTextarea ? (hAsync("div", { class: CSS$G.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$D.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$G.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$D.wrapper }, localeNumberInput, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$D.actionWrapper }, hAsync("slot", { name: SLOTS$k.action })), this.type === "number" && this.numberButtonType === "vertical" && !this.readOnly
+      : null, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$G.wrapper }, localeNumberInput, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$G.actionWrapper }, hAsync("slot", { name: SLOTS$l.action })), this.type === "number" && this.numberButtonType === "vertical" && !this.readOnly
       ? numberButtonsVertical
       : null, this.suffixText ? suffixText : null, this.type === "number" && this.numberButtonType === "horizontal" && !this.readOnly
       ? numberButtonsHorizontalUp
@@ -24139,7 +24139,7 @@ class Input {
   }; }
 }
 
-const CSS$C = {
+const CSS$F = {
   assistiveText: "assistive-text",
   menu: "menu-container",
   menuActive: "menu-container--active",
@@ -25325,12 +25325,12 @@ class InputDatePicker {
       const valueIsArray = Array.isArray(valueAsDate);
       const newStartDate = valueIsArray ? valueAsDate[0] : null;
       let newStartDateISO = valueIsArray ? dateToISO(newStartDate) : "";
-      if (newStartDateISO && isTwoDigitYear(newStartDateISO)) {
+      if (newStartDateISO) {
         newStartDateISO = this.getNormalizedDate(newStartDateISO);
       }
       const newEndDate = valueIsArray ? valueAsDate[1] : null;
       let newEndDateISO = valueIsArray ? dateToISO(newEndDate) : "";
-      if (newEndDateISO && isTwoDigitYear(newEndDateISO)) {
+      if (newEndDateISO) {
         newEndDateISO = this.getNormalizedDate(newEndDateISO);
       }
       const newValue = newStartDateISO || newEndDateISO ? [newStartDateISO, newEndDateISO] : "";
@@ -25359,9 +25359,7 @@ class InputDatePicker {
       }
       const oldValue = this.value;
       let newValue = dateToISO(value);
-      if (isTwoDigitYear(newValue)) {
-        newValue = this.getNormalizedDate(newValue);
-      }
+      newValue = this.getNormalizedDate(newValue);
       if (newValue === oldValue) {
         return;
       }
@@ -25407,7 +25405,6 @@ class InputDatePicker {
     this.max = undefined;
     this.open = false;
     this.name = undefined;
-    this.normalizeYear = false;
     this.numberingSystem = undefined;
     this.scale = "m";
     this.placement = defaultMenuPlacement;
@@ -25437,17 +25434,9 @@ class InputDatePicker {
     if (!this.userChangedValue) {
       let newValueAsDate;
       if (Array.isArray(newValue)) {
-        if (isTwoDigitYear(newValue[0]) || isTwoDigitYear(newValue[1])) {
-          this.value = newValue.map((val) => this.getNormalizedDate(val));
-          return;
-        }
         newValueAsDate = getValueAsDateRange(newValue);
       }
       else if (newValue) {
-        if (isTwoDigitYear(newValue)) {
-          this.value = this.getNormalizedDate(newValue);
-          return;
-        }
         newValueAsDate = dateFromISO(newValue);
       }
       else {
@@ -25549,18 +25538,10 @@ class InputDatePicker {
     const { open } = this;
     open && this.openHandler(open);
     if (Array.isArray(this.value)) {
-      if (isTwoDigitYear(this.value[0]) || isTwoDigitYear(this.value[1])) {
-        this.value = this.value.map((val) => this.getNormalizedDate(val));
-        return;
-      }
       this.valueAsDate = getValueAsDateRange(this.value);
     }
     else if (this.value) {
       try {
-        if (isTwoDigitYear(this.value)) {
-          this.value = this.getNormalizedDate(this.value);
-          return;
-        }
         this.valueAsDate = dateFromISO(this.value);
       }
       catch (error) {
@@ -25625,9 +25606,9 @@ class InputDatePicker {
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setStartWrapper }, hAsync("calcite-input", { "aria-autocomplete": "none", "aria-controls": this.dialogId, "aria-describedby": this.placeholderTextId, "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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: this.setStartInput }), !this.readOnly && this.renderToggleIcon(this.open && this.focusedInput === "start"), hAsync("span", { "aria-hidden": "true", class: CSS$C.assistiveText, id: this.placeholderTextId }, "Date Format: ", this.localeData?.placeholder)), hAsync("div", { "aria-hidden": toAriaBoolean(!this.open), "aria-label": messages.chooseDate, "aria-live": "polite", "aria-modal": "true", class: {
-        [CSS$C.menu]: true,
-        [CSS$C.menuActive]: this.open,
+      ref: this.setStartInput }), !this.readOnly && this.renderToggleIcon(this.open && this.focusedInput === "start"), hAsync("span", { "aria-hidden": "true", class: CSS$F.assistiveText, id: this.placeholderTextId }, "Date Format: ", this.localeData?.placeholder)), hAsync("div", { "aria-hidden": toAriaBoolean(!this.open), "aria-label": messages.chooseDate, "aria-live": "polite", "aria-modal": "true", class: {
+        [CSS$F.menu]: true,
+        [CSS$F.menuActive]: this.open,
       }, id: this.dialogId, role: "dialog",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setFloatingEl }, hAsync("div", { class: {
@@ -25649,7 +25630,7 @@ class InputDatePicker {
       ref: this.setEndInput }), !this.readOnly && this.renderToggleIcon(this.open && this.focusedInput === "end"))))), hAsync(HiddenFormInputSlot, { component: this })));
   }
   renderToggleIcon(open) {
-    return (hAsync("span", { class: CSS$C.toggleIcon }, hAsync("calcite-icon", { icon: open ? "chevron-up" : "chevron-down", scale: "s" })));
+    return (hAsync("span", { class: CSS$F.toggleIcon }, hAsync("calcite-icon", { icon: open ? "chevron-up" : "chevron-down", scale: "s" })));
   }
   setReferenceEl() {
     const { focusedInput, layout, endWrapper, startWrapper } = this;
@@ -25773,7 +25754,7 @@ class InputDatePicker {
     if (!value) {
       return "";
     }
-    if (!this.normalizeYear) {
+    if (!isTwoDigitYear(value)) {
       return value;
     }
     const { day, month, year } = datePartsFromISO(value);
@@ -25820,7 +25801,6 @@ class InputDatePicker {
       "max": [1],
       "open": [1540],
       "name": [513],
-      "normalizeYear": [516, "normalize-year"],
       "numberingSystem": [513, "numbering-system"],
       "scale": [513],
       "placement": [513],
@@ -25839,7 +25819,7 @@ class InputDatePicker {
     },
     "$listeners$": [[0, "calciteDaySelect", "calciteDaySelectHandler"]],
     "$lazyBundleId$": "-",
-    "$attrsToReflect$": [["disabled", "disabled"], ["focusTrapDisabled", "focus-trap-disabled"], ["form", "form"], ["readOnly", "read-only"], ["headingLevel", "heading-level"], ["open", "open"], ["name", "name"], ["normalizeYear", "normalize-year"], ["numberingSystem", "numbering-system"], ["scale", "scale"], ["placement", "placement"], ["range", "range"], ["required", "required"], ["overlayPositioning", "overlay-positioning"], ["layout", "layout"]]
+    "$attrsToReflect$": [["disabled", "disabled"], ["focusTrapDisabled", "focus-trap-disabled"], ["form", "form"], ["readOnly", "read-only"], ["headingLevel", "heading-level"], ["open", "open"], ["name", "name"], ["numberingSystem", "numbering-system"], ["scale", "scale"], ["placement", "placement"], ["range", "range"], ["required", "required"], ["overlayPositioning", "overlay-positioning"], ["layout", "layout"]]
   }; }
 }
 
@@ -25909,7 +25889,7 @@ class InputMessage {
   }; }
 }
 
-const CSS$B = {
+const CSS$E = {
   loader: "loader",
   clearButton: "clear-button",
   editingEnabled: "editing-enabled",
@@ -25925,7 +25905,7 @@ const CSS$B = {
   resizeIconWrapper: "resize-icon-wrapper",
   numberButtonItem: "number-button-item",
 };
-const SLOTS$j = {
+const SLOTS$k = {
   action: "action",
 };
 
@@ -26418,27 +26398,27 @@ class InputNumber {
   // --------------------------------------------------------------------------
   render() {
     const dir = getElementDir(this.el);
-    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 loader = (hAsync("div", { class: CSS$E.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
+    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$E.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$E.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$B.numberButtonItem]: true,
-        [CSS$B.buttonItemHorizontal]: isHorizontalNumberButton,
+        [CSS$E.numberButtonItem]: true,
+        [CSS$E.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$B.numberButtonItem]: true,
-        [CSS$B.buttonItemHorizontal]: isHorizontalNumberButton,
+        [CSS$E.numberButtonItem]: true,
+        [CSS$E.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$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 numberButtonsVertical = (hAsync("div", { class: CSS$E.numberButtonWrapper }, numberButtonsHorizontalUp, numberButtonsHorizontalDown));
+    const prefixText = hAsync("div", { class: CSS$E.prefix }, this.prefixText);
+    const suffixText = hAsync("div", { class: CSS$E.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setChildNumberElRef }));
-    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$B.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$E.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.numberButtonType === "horizontal" && !this.readOnly
       ? numberButtonsHorizontalDown
-      : null, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$B.wrapper }, 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.numberButtonType === "vertical" && !this.readOnly ? numberButtonsVertical : null, this.suffixText ? suffixText : null, this.numberButtonType === "horizontal" && !this.readOnly
+      : null, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$E.wrapper }, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$E.actionWrapper }, hAsync("slot", { name: SLOTS$k.action })), this.numberButtonType === "vertical" && !this.readOnly ? numberButtonsVertical : null, this.suffixText ? suffixText : null, this.numberButtonType === "horizontal" && !this.readOnly
       ? numberButtonsHorizontalUp
       : null, hAsync(HiddenFormInputSlot, { component: this }))));
   }
@@ -26505,7 +26485,7 @@ class InputNumber {
   }; }
 }
 
-const CSS$A = {
+const CSS$D = {
   loader: "loader",
   clearButton: "clear-button",
   editingEnabled: "editing-enabled",
@@ -26518,7 +26498,7 @@ const CSS$A = {
   actionWrapper: "action-wrapper",
   resizeIconWrapper: "resize-icon-wrapper",
 };
-const SLOTS$i = {
+const SLOTS$j = {
   action: "action",
 };
 
@@ -26805,18 +26785,18 @@ class InputText {
   // --------------------------------------------------------------------------
   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.clearInputTextValue, 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 prefixText = hAsync("div", { class: CSS$A.prefix }, this.prefixText);
-    const suffixText = hAsync("div", { class: CSS$A.suffix }, this.suffixText);
+    const loader = (hAsync("div", { class: CSS$D.loader }, hAsync("calcite-progress", { label: this.messages.loading, type: "indeterminate" })));
+    const inputClearButton = (hAsync("button", { "aria-label": this.messages.clear, class: CSS$D.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$D.inputIcon, flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }));
+    const prefixText = hAsync("div", { class: CSS$D.prefix }, this.prefixText);
+    const suffixText = hAsync("div", { class: CSS$D.suffix }, this.suffixText);
     const childEl = (hAsync("input", { "aria-label": getLabelText(this), autocomplete: this.autocomplete, autofocus: this.autofocus ? true : null, class: {
-        [CSS$A.editingEnabled]: this.editingEnabled,
-        [CSS$A.inlineChild]: !!this.inlineEditableEl,
+        [CSS$D.editingEnabled]: this.editingEnabled,
+        [CSS$D.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setChildElRef }));
-    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$A.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$A.wrapper }, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$A.actionWrapper }, hAsync("slot", { name: SLOTS$i.action })), this.suffixText ? suffixText : null, hAsync(HiddenFormInputSlot, { component: this }))));
+    return (hAsync(Host, { onClick: this.clickHandler, onKeyDown: this.keyDownHandler }, hAsync("div", { class: { [CSS$D.inputWrapper]: true, [CSS_UTILITY.rtl]: dir === "rtl" } }, this.prefixText ? prefixText : null, hAsync("div", { class: CSS$D.wrapper }, childEl, this.isClearable ? inputClearButton : null, this.requestedIcon ? iconEl : null, this.loading ? loader : null), hAsync("div", { class: CSS$D.actionWrapper }, hAsync("slot", { name: SLOTS$j.action })), this.suffixText ? suffixText : null, hAsync(HiddenFormInputSlot, { component: this }))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -27132,7 +27112,7 @@ function toISOTimeString(value, includeSeconds = true) {
   return isoTimeString;
 }
 
-const CSS$z = {
+const CSS$C = {
   toggleIcon: "toggle-icon",
 };
 
@@ -28905,7 +28885,7 @@ class InputTimePicker {
       ref: this.setCalciteTimePickerEl })), 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$C.toggleIcon }, hAsync("calcite-icon", { icon: open ? "chevron-up" : "chevron-down", scale: "s" })));
   }
   static get delegatesFocus() { return true; }
   static get assetsDirs() { return ["assets"]; }
@@ -29149,7 +29129,7 @@ class InputTimeZone {
   }; }
 }
 
-const CSS$y = {
+const CSS$B = {
   container: "container",
 };
 
@@ -29189,7 +29169,7 @@ class Label {
     document.dispatchEvent(new CustomEvent(labelDisconnectedEvent));
   }
   render() {
-    return (hAsync(Host, { onClick: this.labelClickHandler }, hAsync("div", { class: CSS$y.container }, hAsync("slot", null))));
+    return (hAsync(Host, { onClick: this.labelClickHandler }, hAsync("div", { class: CSS$B.container }, hAsync("slot", null))));
   }
   get el() { return getElement(this); }
   static get style() { return labelCss; }
@@ -29324,7 +29304,7 @@ class Link {
   }; }
 }
 
-const CSS$x = {
+const CSS$A = {
   container: "container",
   containerBorderSelected: "container--border-selected",
   containerBorderUnselected: "container--border-unselected",
@@ -29345,7 +29325,7 @@ const CSS$x = {
   openContainer: "open-container",
   dragContainer: "drag-container",
 };
-const SLOTS$h = {
+const SLOTS$i = {
   actionsStart: "actions-start",
   contentStart: "content-start",
   content: "content",
@@ -29391,7 +29371,7 @@ function getDepth(element, includeGroup = false) {
   }
 }
 
-const CSS$w = {
+const CSS$z = {
   container: "container",
   table: "table",
   scrim: "scrim",
@@ -29401,7 +29381,7 @@ const CSS$w = {
   assistiveText: "assistive-text",
 };
 const debounceTimeout = 0;
-const SLOTS$g = {
+const SLOTS$h = {
   filterActionsStart: "filter-actions-start",
   filterActionsEnd: "filter-actions-end",
 };
@@ -32502,7 +32482,7 @@ function onSortingEnd(activeComponent) {
   getNestedSortableComponents(activeComponent).forEach((component) => inactiveSortableComponentSet.delete(component));
 }
 
-const CSS$v = {
+const CSS$y = {
   container: "container",
   actionsStart: "actions-start",
   contentStart: "content-start",
@@ -32510,7 +32490,7 @@ const CSS$v = {
   contentEnd: "content-end",
   actionsEnd: "actions-end",
 };
-const SLOTS$f = {
+const SLOTS$g = {
   actionsStart: "actions-start",
   contentStart: "content-start",
   contentEnd: "content-end",
@@ -32825,9 +32805,9 @@ class List$1 {
   // --------------------------------------------------------------------------
   render() {
     const { loading, label, disabled, dataForFilter, filterEnabled, filterPlaceholder, filterText, hasFilterActionsStart, hasFilterActionsEnd, } = this;
-    return (hAsync("div", { class: CSS$w.container }, this.dragEnabled ? (hAsync("span", { "aria-live": "assertive", class: CSS$w.assistiveText }, this.assistiveText)) : null, loading ? hAsync("calcite-scrim", { class: CSS$w.scrim, loading: loading }) : null, hAsync("table", { "aria-busy": toAriaBoolean(loading), "aria-label": label || "", class: CSS$w.table, onKeyDown: this.handleListKeydown, role: "treegrid" }, filterEnabled || hasFilterActionsStart || hasFilterActionsEnd ? (hAsync("thead", null, hAsync("tr", { class: { [CSS$w.sticky]: true } }, hAsync("th", { colSpan: MAX_COLUMNS }, hAsync("calcite-stack", { class: CSS$w.stack }, hAsync("slot", { name: SLOTS$g.filterActionsStart, onSlotchange: this.handleFilterActionsStartSlotChange, slot: SLOTS$f.actionsStart }), hAsync("calcite-filter", { "aria-label": filterPlaceholder, disabled: loading || disabled, items: dataForFilter, onCalciteFilterChange: this.handleFilterChange, placeholder: filterPlaceholder, value: filterText,
+    return (hAsync("div", { class: CSS$z.container }, this.dragEnabled ? (hAsync("span", { "aria-live": "assertive", class: CSS$z.assistiveText }, this.assistiveText)) : null, loading ? hAsync("calcite-scrim", { class: CSS$z.scrim, loading: loading }) : null, hAsync("table", { "aria-busy": toAriaBoolean(loading), "aria-label": label || "", class: CSS$z.table, onKeyDown: this.handleListKeydown, role: "treegrid" }, filterEnabled || hasFilterActionsStart || hasFilterActionsEnd ? (hAsync("thead", null, hAsync("tr", { class: { [CSS$z.sticky]: true } }, hAsync("th", { colSpan: MAX_COLUMNS }, hAsync("calcite-stack", { class: CSS$z.stack }, hAsync("slot", { name: SLOTS$h.filterActionsStart, onSlotchange: this.handleFilterActionsStartSlotChange, slot: SLOTS$g.actionsStart }), hAsync("calcite-filter", { "aria-label": filterPlaceholder, disabled: loading || disabled, items: dataForFilter, onCalciteFilterChange: this.handleFilterChange, placeholder: filterPlaceholder, value: filterText,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: this.setFilterEl }), hAsync("slot", { name: SLOTS$g.filterActionsEnd, onSlotchange: this.handleFilterActionsEndSlotChange, slot: SLOTS$f.actionsEnd })))))) : null, hAsync("tbody", { class: CSS$w.tableContainer }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange })))));
+      ref: this.setFilterEl }), hAsync("slot", { name: SLOTS$h.filterActionsEnd, onSlotchange: this.handleFilterActionsEndSlotChange, slot: SLOTS$g.actionsEnd })))))) : null, hAsync("tbody", { class: CSS$z.tableContainer }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange })))));
   }
   // --------------------------------------------------------------------------
   //
@@ -33242,47 +33222,47 @@ class ListItem {
     if (selectionMode === "none" || selectionAppearance === "border") {
       return null;
     }
-    return (hAsync("td", { class: CSS$x.selectionContainer, key: "selection-container", onClick: this.itemClicked }, hAsync("calcite-icon", { icon: selected
+    return (hAsync("td", { class: CSS$A.selectionContainer, key: "selection-container", onClick: this.itemClicked }, hAsync("calcite-icon", { icon: selected
         ? selectionMode === "multiple"
           ? ICONS$7.selectedMultiple
           : ICONS$7.selectedSingle
         : ICONS$7.unselected, scale: "s" })));
   }
   renderDragHandle() {
-    return this.dragHandle ? (hAsync("td", { class: CSS$x.dragContainer, key: "drag-handle-container" }, hAsync("calcite-handle", { label: this.label, setPosition: this.setPosition, setSize: this.setSize }))) : null;
+    return this.dragHandle ? (hAsync("td", { class: CSS$A.dragContainer, key: "drag-handle-container" }, hAsync("calcite-handle", { label: this.label, setPosition: this.setPosition, setSize: this.setSize }))) : null;
   }
   renderOpen() {
     const { el, open, openable, parentListEl } = this;
     const dir = getElementDir(el);
-    return openable ? (hAsync("td", { class: CSS$x.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$x.openContainer, key: "open-container", onClick: this.itemClicked }, hAsync("calcite-icon", { icon: ICONS$7.blank, scale: "s" }))) : null;
+    return openable ? (hAsync("td", { class: CSS$A.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$A.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$x.actionsStart, hidden: !hasActionsStart, key: "actions-start-container", role: "gridcell",
+    return (hAsync("td", { "aria-label": label, class: CSS$A.actionsStart, hidden: !hasActionsStart, key: "actions-start-container", role: "gridcell",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: (el) => (this.actionsStartEl = el) }, hAsync("slot", { name: SLOTS$h.actionsStart, onSlotchange: this.handleActionsStartSlotChange })));
+      ref: (el) => (this.actionsStartEl = el) }, hAsync("slot", { name: SLOTS$i.actionsStart, onSlotchange: this.handleActionsStartSlotChange })));
   }
   renderActionsEnd() {
     const { label, hasActionsEnd, closable, messages } = this;
-    return (hAsync("td", { "aria-label": label, class: CSS$x.actionsEnd, hidden: !(hasActionsEnd || closable), key: "actions-end-container", role: "gridcell",
+    return (hAsync("td", { "aria-label": label, class: CSS$A.actionsEnd, hidden: !(hasActionsEnd || closable), key: "actions-end-container", role: "gridcell",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: (el) => (this.actionsEndEl = el) }, hAsync("slot", { name: SLOTS$h.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));
+      ref: (el) => (this.actionsEndEl = el) }, hAsync("slot", { name: SLOTS$i.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$x.contentStart, hidden: !hasContentStart }, hAsync("slot", { name: SLOTS$h.contentStart, onSlotchange: this.handleContentStartSlotChange })));
+    return (hAsync("div", { class: CSS$A.contentStart, hidden: !hasContentStart }, hAsync("slot", { name: SLOTS$i.contentStart, onSlotchange: this.handleContentStartSlotChange })));
   }
   renderCustomContent() {
     const { hasCustomContent } = this;
-    return (hAsync("div", { class: CSS$x.customContent, hidden: !hasCustomContent }, hAsync("slot", { name: SLOTS$h.content, onSlotchange: this.handleContentSlotChange })));
+    return (hAsync("div", { class: CSS$A.customContent, hidden: !hasCustomContent }, hAsync("slot", { name: SLOTS$i.content, onSlotchange: this.handleContentSlotChange })));
   }
   renderContentEnd() {
     const { hasContentEnd } = this;
-    return (hAsync("div", { class: CSS$x.contentEnd, hidden: !hasContentEnd }, hAsync("slot", { name: SLOTS$h.contentEnd, onSlotchange: this.handleContentEndSlotChange })));
+    return (hAsync("div", { class: CSS$A.contentEnd, hidden: !hasContentEnd }, hAsync("slot", { name: SLOTS$i.contentEnd, onSlotchange: this.handleContentEndSlotChange })));
   }
   renderContentProperties() {
     const { label, description, hasCustomContent } = this;
-    return !hasCustomContent && (!!label || !!description) ? (hAsync("div", { class: CSS$x.content, key: "content" }, label ? (hAsync("div", { class: CSS$x.label, key: "label" }, label)) : null, description ? (hAsync("div", { class: CSS$x.description, key: "description" }, description)) : null)) : null;
+    return !hasCustomContent && (!!label || !!description) ? (hAsync("div", { class: CSS$A.content, key: "content" }, label ? (hAsync("div", { class: CSS$A.label, key: "label" }, label)) : null, description ? (hAsync("div", { class: CSS$A.description, key: "description" }, description)) : null)) : null;
   }
   renderContentContainer() {
     const { description, label, selectionMode, hasCustomContent } = this;
@@ -33294,9 +33274,9 @@ class ListItem {
       this.renderContentEnd(),
     ];
     return (hAsync("td", { "aria-label": label, class: {
-        [CSS$x.contentContainer]: true,
-        [CSS$x.contentContainerSelectable]: selectionMode !== "none",
-        [CSS$x.contentContainerHasCenterContent]: hasCenterContent,
+        [CSS$A.contentContainer]: true,
+        [CSS$A.contentContainerSelectable]: selectionMode !== "none",
+        [CSS$A.contentContainerHasCenterContent]: hasCenterContent,
       }, key: "content-container", onClick: this.itemClicked, role: "gridcell",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.contentEl = el) }, content));
@@ -33307,14 +33287,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$x.container]: true,
-        [CSS$x.containerBorderSelected]: borderSelected,
-        [CSS$x.containerBorderUnselected]: borderUnselected,
+        [CSS$A.container]: true,
+        [CSS$A.containerBorderSelected]: borderSelected,
+        [CSS$A.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.containerEl = el) }, this.renderDragHandle(), this.renderSelected(), this.renderOpen(), this.renderActionsStart(), this.renderContentContainer(), this.renderActionsEnd()), hAsync("div", { class: {
-        [CSS$x.nestedContainer]: true,
-        [CSS$x.nestedContainerHidden]: openable && !open,
+        [CSS$A.nestedContainer]: true,
+        [CSS$A.nestedContainerHidden]: openable && !open,
       } }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange, ref: (el) => (this.defaultSlotEl = el) }))));
   }
   // --------------------------------------------------------------------------
@@ -33404,7 +33384,7 @@ class ListItem {
   }; }
 }
 
-const CSS$u = {
+const CSS$x = {
   container: "container",
   heading: "heading",
 };
@@ -33453,7 +33433,7 @@ class ListItemGroup {
   // --------------------------------------------------------------------------
   render() {
     const { heading, visualLevel } = this;
-    return (hAsync(Host, null, hAsync("tr", { class: CSS$u.container, style: { "--calcite-list-item-spacing-indent-multiplier": `${visualLevel}` } }, hAsync("td", { class: CSS$u.heading, colSpan: MAX_COLUMNS }, heading)), hAsync("slot", { onSlotchange: this.handleDefaultSlotChange })));
+    return (hAsync(Host, null, hAsync("tr", { class: CSS$x.container, style: { "--calcite-list-item-spacing-indent-multiplier": `${visualLevel}` } }, hAsync("td", { class: CSS$x.heading, colSpan: MAX_COLUMNS }, heading)), hAsync("slot", { onSlotchange: this.handleDefaultSlotChange })));
   }
   get el() { return getElement(this); }
   static get style() { return listItemGroupCss; }
@@ -33553,7 +33533,7 @@ class Loader {
   }; }
 }
 
-const CSS$t = {
+const CSS$w = {
   container: "container",
   fill: "fill",
   stepLine: "step-line",
@@ -33703,16 +33683,16 @@ class Meter {
     const aboveHighest = value >= highest;
     const belowHighest = value < highest;
     if (!value || (!low && belowHighest) || belowLowest) {
-      return CSS$t.success;
+      return CSS$w.success;
     }
     else if (aboveLowest && belowHighest) {
-      return CSS$t.warning;
+      return CSS$w.warning;
     }
     else if (aboveHighest) {
-      return CSS$t.danger;
+      return CSS$w.danger;
     }
     else {
-      return CSS$t.success;
+      return CSS$w.success;
     }
   }
   intersects(el1, el2) {
@@ -33726,7 +33706,7 @@ class Meter {
     const minHighOverlap = this.intersects(minLabelEl, highLabelEl);
     const minLowOverlap = this.intersects(minLabelEl, lowLabelEl);
     const minMaxOverlap = this.intersects(minLabelEl, maxLabelEl);
-    const hiddenClass = CSS$t.labelHidden;
+    const hiddenClass = CSS$w.labelHidden;
     if (lowLabelEl) {
       if (minLowOverlap || lowMaxOverlap || lowHighOverlap) {
         lowLabelEl.classList.add(hiddenClass);
@@ -33775,26 +33755,26 @@ class Meter {
   renderMeterFill() {
     const { currentPercent, fillType } = this;
     const kindClass = this.getMeterKindCssClass();
-    return (hAsync("div", { class: { [CSS$t.fill]: true, [kindClass]: fillType !== "single" }, style: { width: `${currentPercent}%` } }));
+    return (hAsync("div", { class: { [CSS$w.fill]: true, [kindClass]: fillType !== "single" }, style: { width: `${currentPercent}%` } }));
   }
   renderRangeLine(position) {
     const style = { insetInlineStart: `${position}%` };
-    return hAsync("div", { class: CSS$t.stepLine, style: style });
+    return hAsync("div", { class: CSS$w.stepLine, style: style });
   }
   renderValueLabel() {
     const { currentPercent, valueLabelType, unitLabel, value } = this;
     const label = this.formatLabel(valueLabelType === "percent" ? currentPercent / 100 : value || 0, valueLabelType);
-    return (hAsync("div", { class: { [CSS$t.label]: true, [CSS$t.labelValue]: true }, key: "low-label-line",
+    return (hAsync("div", { class: { [CSS$w.label]: true, [CSS$w.labelValue]: true }, key: "low-label-line",
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (el) => (this.valueLabelEl = el) }, label, unitLabel && valueLabelType !== "percent" && (hAsync("span", { class: CSS$t.unitLabel }, "\u00A0", unitLabel))));
+      ref: (el) => (this.valueLabelEl = el) }, label, unitLabel && valueLabelType !== "percent" && (hAsync("span", { class: CSS$w.unitLabel }, "\u00A0", unitLabel))));
   }
   renderMinLabel() {
     const { rangeLabelType, min, minPercent, unitLabel } = this;
     const style = { insetInlineStart: `${minPercent}%` };
     const labelMin = this.formatLabel(rangeLabelType === "percent" ? minPercent : min, rangeLabelType);
-    return (hAsync("div", { class: { [CSS$t.label]: true, [CSS$t.labelRange]: true }, key: "min-label-line", style: style,
+    return (hAsync("div", { class: { [CSS$w.label]: true, [CSS$w.labelRange]: true }, key: "min-label-line", style: style,
       // eslint-disable-next-line react/jsx-sort-props
-      ref: (el) => (this.minLabelEl = el) }, labelMin, unitLabel && rangeLabelType !== "percent" && (hAsync("span", { class: CSS$t.unitLabel }, "\u00A0", unitLabel))));
+      ref: (el) => (this.minLabelEl = el) }, labelMin, unitLabel && rangeLabelType !== "percent" && (hAsync("span", { class: CSS$w.unitLabel }, "\u00A0", unitLabel))));
   }
   renderLowLabel() {
     const { rangeLabelType, low, lowPercent, highPercent, labelFlipProximity } = this;
@@ -33804,7 +33784,7 @@ class Meter {
     const styleDefault = { insetInlineStart: `${lowPercent}%` };
     const styleFlipped = { insetInlineEnd: `${100 - lowPercent}%` };
     const style = (highPercent - lowPercent) / 100 < labelFlipProximity ? styleFlipped : styleDefault;
-    return (hAsync("div", { class: { [CSS$t.label]: true, [CSS$t.labelRange]: true }, key: "low-label-line", style: style,
+    return (hAsync("div", { class: { [CSS$w.label]: true, [CSS$w.labelRange]: true }, key: "low-label-line", style: style,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.lowLabelEl = el) }, label));
   }
@@ -33816,7 +33796,7 @@ class Meter {
     const styleDefault = { insetInlineStart: `${highPercent}%` };
     const styleFlipped = { insetInlineEnd: `${100 - highPercent}%` };
     const style = highPercent / 100 >= labelFlipMax ? styleFlipped : styleDefault;
-    return (hAsync("div", { class: { [CSS$t.label]: true, [CSS$t.labelRange]: true }, key: "high-label-line", style: style,
+    return (hAsync("div", { class: { [CSS$w.label]: true, [CSS$w.labelRange]: true }, key: "high-label-line", style: style,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.highLabelEl = el) }, label));
   }
@@ -33824,7 +33804,7 @@ class Meter {
     const { rangeLabelType, max, maxPercent } = this;
     const style = { insetInlineEnd: `${100 - maxPercent}%` };
     const labelMax = this.formatLabel(rangeLabelType === "percent" ? maxPercent / 100 : max, rangeLabelType);
-    return (hAsync("div", { class: { [CSS$t.label]: true, [CSS$t.labelRange]: true }, key: "max-label-line", style: style,
+    return (hAsync("div", { class: { [CSS$w.label]: true, [CSS$w.labelRange]: true }, key: "max-label-line", style: style,
       // eslint-disable-next-line react/jsx-sort-props
       ref: (el) => (this.maxLabelEl = el) }, labelMax));
   }
@@ -33838,9 +33818,9 @@ class Meter {
         ? textUnitLabel
         : undefined;
     return (hAsync(Host, null, hAsync("div", { "aria-label": label, "aria-valuemax": rangeLabelType === "percent" ? maxPercent : max, "aria-valuemin": rangeLabelType === "percent" ? minPercent : min, "aria-valuenow": valueLabelType === "percent" ? currentPercent : value, "aria-valuetext": valueText, class: {
-        [CSS$t.container]: true,
-        [CSS$t.stepsVisible]: rangeLabels,
-        [CSS$t.valueVisible]: valueLabel,
+        [CSS$w.container]: true,
+        [CSS$w.stepsVisible]: rangeLabels,
+        [CSS$w.valueVisible]: valueLabel,
         [appearance]: appearance !== "outline-fill",
       }, role: "meter",
       // eslint-disable-next-line react/jsx-sort-props
@@ -33896,7 +33876,7 @@ class Meter {
   }; }
 }
 
-const CSS$s = {
+const CSS$v = {
   modal: "modal",
   title: "title",
   header: "header",
@@ -33923,7 +33903,7 @@ const CSS$s = {
 const ICONS$6 = {
   close: "x",
 };
-const SLOTS$e = {
+const SLOTS$f = {
   content: "content",
   contentBottom: "content-bottom",
   contentTop: "content-top",
@@ -34008,7 +33988,7 @@ class Modal {
       this.updateFocusTrapElements();
     };
     this.updateFooterVisibility = () => {
-      this.hasFooter = !!getSlotted(this.el, [SLOTS$e.back, SLOTS$e.primary, SLOTS$e.secondary]);
+      this.hasFooter = !!getSlotted(this.el, [SLOTS$f.back, SLOTS$f.primary, SLOTS$f.secondary]);
     };
     this.updateSizeCssVars = () => {
       this.cssWidth = getComputedStyle(this.el).getPropertyValue("--calcite-modal-width");
@@ -34091,50 +34071,50 @@ class Modal {
   }
   render() {
     return (hAsync(Host, { "aria-describedby": this.contentId, "aria-labelledby": this.titleId, "aria-modal": "true", role: "dialog" }, hAsync("div", { class: {
-        [CSS$s.container]: true,
-        [CSS$s.containerOpen]: this.opened,
-        [CSS$s.slottedInShell]: this.slottedInShell,
-      } }, hAsync("calcite-scrim", { class: CSS$s.scrim, onClick: this.handleOutsideClose }), this.renderStyle(), hAsync("div", { class: {
-        [CSS$s.modal]: true,
+        [CSS$v.container]: true,
+        [CSS$v.containerOpen]: this.opened,
+        [CSS$v.slottedInShell]: this.slottedInShell,
+      } }, hAsync("calcite-scrim", { class: CSS$v.scrim, onClick: this.handleOutsideClose }), this.renderStyle(), hAsync("div", { class: {
+        [CSS$v.modal]: true,
       },
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      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,
+      ref: this.setTransitionEl }, hAsync("div", { class: CSS$v.header }, this.renderCloseButton(), hAsync("header", { class: CSS$v.title }, hAsync("slot", { name: CSS$v.header }))), this.renderContentTop(), hAsync("div", { class: {
+        [CSS$v.content]: true,
+        [CSS$v.contentNoFooter]: !this.hasFooter,
       },
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: (el) => (this.modalContent = el) }, hAsync("slot", { name: SLOTS$e.content })), this.renderContentBottom(), this.renderFooter()))));
+      ref: (el) => (this.modalContent = el) }, hAsync("slot", { name: SLOTS$f.content })), this.renderContentBottom(), this.renderFooter()))));
   }
   renderFooter() {
-    return this.hasFooter ? (hAsync("div", { class: CSS$s.footer, key: "footer" }, hAsync("span", { class: CSS$s.back }, hAsync("slot", { name: SLOTS$e.back })), hAsync("span", { class: CSS$s.secondary }, hAsync("slot", { name: SLOTS$e.secondary })), hAsync("span", { class: CSS$s.primary }, hAsync("slot", { name: SLOTS$e.primary })))) : null;
+    return this.hasFooter ? (hAsync("div", { class: CSS$v.footer, key: "footer" }, hAsync("span", { class: CSS$v.back }, hAsync("slot", { name: SLOTS$f.back })), hAsync("span", { class: CSS$v.secondary }, hAsync("slot", { name: SLOTS$f.secondary })), hAsync("span", { class: CSS$v.primary }, hAsync("slot", { name: SLOTS$f.primary })))) : null;
   }
   renderContentTop() {
-    return (hAsync("div", { class: CSS$s.contentTop, hidden: !this.hasContentTop }, hAsync("slot", { name: SLOTS$e.contentTop, onSlotchange: this.contentTopSlotChangeHandler })));
+    return (hAsync("div", { class: CSS$v.contentTop, hidden: !this.hasContentTop }, hAsync("slot", { name: SLOTS$f.contentTop, onSlotchange: this.contentTopSlotChangeHandler })));
   }
   renderContentBottom() {
-    return (hAsync("div", { class: CSS$s.contentBottom, hidden: !this.hasContentBottom }, hAsync("slot", { name: SLOTS$e.contentBottom, onSlotchange: this.contentBottomSlotChangeHandler })));
+    return (hAsync("div", { class: CSS$v.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$s.close, key: "button", onClick: this.closeModal, title: this.messages.close,
+    return !this.closeButtonDisabled ? (hAsync("button", { "aria-label": this.messages.close, class: CSS$v.close, key: "button", onClick: this.closeModal, title: this.messages.close,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       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$s.container} {
+      return (hAsync("style", null, `.${CSS$v.container} {
               ${this.docked && this.cssWidth ? `align-items: center !important;` : ""}
             }
-            .${CSS$s.modal} {
+            .${CSS$v.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$s.container} {
+              .${CSS$v.container} {
                 ${this.docked ? `align-items: flex-end !important;` : ""}
               }
-              .${CSS$s.modal} {
+              .${CSS$v.modal} {
                 max-block-size: 100% !important;
                 inline-size: 100% !important;
                 max-inline-size: 100% !important;
@@ -34201,20 +34181,20 @@ class Modal {
     }
   }
   onBeforeOpen() {
-    this.transitionEl.classList.add(CSS$s.openingActive);
+    this.transitionEl.classList.add(CSS$v.openingActive);
     this.calciteModalBeforeOpen.emit();
   }
   onOpen() {
-    this.transitionEl.classList.remove(CSS$s.openingIdle, CSS$s.openingActive);
+    this.transitionEl.classList.remove(CSS$v.openingIdle, CSS$v.openingActive);
     this.calciteModalOpen.emit();
     activateFocusTrap(this);
   }
   onBeforeClose() {
-    this.transitionEl.classList.add(CSS$s.closingActive);
+    this.transitionEl.classList.add(CSS$v.closingActive);
     this.calciteModalBeforeClose.emit();
   }
   onClose() {
-    this.transitionEl.classList.remove(CSS$s.closingIdle, CSS$s.closingActive);
+    this.transitionEl.classList.remove(CSS$v.closingIdle, CSS$v.closingActive);
     this.calciteModalClose.emit();
     deactivateFocusTrap(this);
   }
@@ -34224,11 +34204,11 @@ class Modal {
     }
     onToggleOpenCloseComponent(this);
     if (value) {
-      this.transitionEl?.classList.add(CSS$s.openingIdle);
+      this.transitionEl?.classList.add(CSS$v.openingIdle);
       this.openModal();
     }
     else {
-      this.transitionEl?.classList.add(CSS$s.closingIdle);
+      this.transitionEl?.classList.add(CSS$v.closingIdle);
       this.closeModal();
     }
   }
@@ -34241,8 +34221,8 @@ class Modal {
     this.el.addEventListener("calciteModalOpen", this.openEnd);
     this.open = true;
     this.opened = true;
-    const titleEl = getSlotted(this.el, SLOTS$e.header);
-    const contentEl = getSlotted(this.el, SLOTS$e.content);
+    const titleEl = getSlotted(this.el, SLOTS$f.header);
+    const contentEl = getSlotted(this.el, SLOTS$f.content);
     this.titleId = ensureId(titleEl);
     this.contentId = ensureId(contentEl);
     if (!this.slottedInShell) {
@@ -34300,13 +34280,13 @@ class Modal {
   }; }
 }
 
-const SLOTS$d = {
+const SLOTS$e = {
   title: "title",
   message: "message",
   link: "link",
   actionsEnd: "actions-end",
 };
-const CSS$r = {
+const CSS$u = {
   actionsEnd: "actions-end",
   close: "notice-close",
   container: "container",
@@ -34385,11 +34365,11 @@ class Notice {
   }
   render() {
     const { el } = this;
-    const closeButton = (hAsync("button", { "aria-label": this.messages.close, class: CSS$r.close, onClick: this.close,
+    const closeButton = (hAsync("button", { "aria-label": this.messages.close, class: CSS$u.close, onClick: this.close,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.closeButton = el) }, hAsync("calcite-icon", { icon: "x", scale: this.scale === "l" ? "m" : "s" })));
-    const hasActionEnd = getSlotted(el, SLOTS$d.actionsEnd);
-    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$d.title }), hAsync("slot", { name: SLOTS$d.message }), hAsync("slot", { name: SLOTS$d.link })), hasActionEnd ? (hAsync("div", { class: CSS$r.actionsEnd }, hAsync("slot", { name: SLOTS$d.actionsEnd }))) : null, this.closable ? closeButton : null));
+    const hasActionEnd = getSlotted(el, SLOTS$e.actionsEnd);
+    return (hAsync("div", { class: CSS$u.container }, this.requestedIcon ? (hAsync("div", { class: CSS$u.icon }, hAsync("calcite-icon", { flipRtl: this.iconFlipRtl, icon: this.requestedIcon, scale: this.scale === "l" ? "m" : "s" }))) : null, hAsync("div", { class: CSS$u.content }, hAsync("slot", { name: SLOTS$e.title }), hAsync("slot", { name: SLOTS$e.message }), hAsync("slot", { name: SLOTS$e.link })), hasActionEnd ? (hAsync("div", { class: CSS$u.actionsEnd }, hAsync("slot", { name: SLOTS$e.actionsEnd }))) : null, this.closable ? closeButton : null));
   }
   //--------------------------------------------------------------------------
   //
@@ -34568,7 +34548,7 @@ class OptionGroup {
   }; }
 }
 
-const CSS$q = {
+const CSS$t = {
   page: "page",
   selected: "is-selected",
   previous: "previous",
@@ -34726,8 +34706,8 @@ class Pagination {
     const displayedPage = numberStringFormatter.localize(page.toString());
     const selected = start === this.startItem;
     return (hAsync("button", { "aria-current": selected ? "page" : "false", class: {
-        [CSS$q.page]: true,
-        [CSS$q.selected]: selected,
+        [CSS$t.page]: true,
+        [CSS$t.selected]: selected,
       }, onClick: () => {
         this.startItem = start;
         this.emitUpdate();
@@ -34735,12 +34715,12 @@ class Pagination {
   }
   renderLeftEllipsis() {
     if (this.totalItems / this.pageSize > maxPagesDisplayed && this.showLeftEllipsis()) {
-      return hAsync("span", { class: `${CSS$q.ellipsis} ${CSS$q.ellipsisStart}` }, "\u2026");
+      return hAsync("span", { class: `${CSS$t.ellipsis} ${CSS$t.ellipsisStart}` }, "\u2026");
     }
   }
   renderRightEllipsis() {
     if (this.totalItems / this.pageSize > maxPagesDisplayed && this.showRightEllipsis()) {
-      return hAsync("span", { class: `${CSS$q.ellipsis} ${CSS$q.ellipsisEnd}` }, "\u2026");
+      return hAsync("span", { class: `${CSS$t.ellipsis} ${CSS$t.ellipsisEnd}` }, "\u2026");
     }
   }
   render() {
@@ -34748,11 +34728,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$q.previous]: true,
-        [CSS$q.disabled]: prevDisabled,
+        [CSS$t.previous]: true,
+        [CSS$t.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$q.next]: true,
-        [CSS$q.disabled]: nextDisabled,
+        [CSS$t.next]: true,
+        [CSS$t.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; }
@@ -34963,22 +34943,22 @@ class Panel {
   // --------------------------------------------------------------------------
   renderHeaderContent() {
     const { heading, headingLevel, description, hasHeaderContent } = this;
-    const headingNode = heading ? (hAsync(Heading, { class: CSS$I.heading, level: headingLevel }, heading)) : null;
-    const descriptionNode = description ? hAsync("span", { class: CSS$I.description }, description) : null;
-    return !hasHeaderContent && (headingNode || descriptionNode) ? (hAsync("div", { class: CSS$I.headerContent, key: "header-content" }, headingNode, descriptionNode)) : null;
+    const headingNode = heading ? (hAsync(Heading, { class: CSS$L.heading, level: headingLevel }, heading)) : null;
+    const descriptionNode = description ? hAsync("span", { class: CSS$L.description }, description) : null;
+    return !hasHeaderContent && (headingNode || descriptionNode) ? (hAsync("div", { class: CSS$L.headerContent, key: "header-content" }, headingNode, descriptionNode)) : null;
   }
   renderActionBar() {
-    return (hAsync("div", { class: CSS$I.actionBarContainer, hidden: !this.hasActionBar }, hAsync("slot", { name: SLOTS$m.actionBar, onSlotchange: this.handleActionBarSlotChange })));
+    return (hAsync("div", { class: CSS$L.actionBarContainer, hidden: !this.hasActionBar }, hAsync("slot", { name: SLOTS$n.actionBar, onSlotchange: this.handleActionBarSlotChange })));
   }
   /**
    * Allows user to override the entire header-content node.
    */
   renderHeaderSlottedContent() {
-    return (hAsync("div", { class: CSS$I.headerContent, hidden: !this.hasHeaderContent, key: "slotted-header-content" }, hAsync("slot", { name: SLOTS$m.headerContent, onSlotchange: this.handleHeaderContentSlotChange })));
+    return (hAsync("div", { class: CSS$L.headerContent, hidden: !this.hasHeaderContent, key: "slotted-header-content" }, hAsync("slot", { name: SLOTS$n.headerContent, onSlotchange: this.handleHeaderContentSlotChange })));
   }
   renderHeaderStartActions() {
     const { hasStartActions } = this;
-    return (hAsync("div", { class: { [CSS$I.headerActionsStart]: true, [CSS$I.headerActions]: true }, hidden: !hasStartActions, key: "header-actions-start" }, hAsync("slot", { name: SLOTS$m.headerActionsStart, onSlotchange: this.handleHeaderActionsStartSlotChange })));
+    return (hAsync("div", { class: { [CSS$L.headerActionsStart]: true, [CSS$L.headerActions]: true }, hidden: !hasStartActions, key: "header-actions-start" }, hAsync("slot", { name: SLOTS$n.headerActionsStart, onSlotchange: this.handleHeaderActionsStartSlotChange })));
   }
   renderHeaderActionsEnd() {
     const { close, hasEndActions, messages, closable, hasMenuItems } = this;
@@ -34986,13 +34966,13 @@ class Panel {
     const closableNode = closable ? (hAsync("calcite-action", { "aria-label": text, "data-test": "close", icon: ICONS$a.close, onClick: close, text: text, title: text,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setCloseRef })) : null;
-    const slotNode = (hAsync("slot", { name: SLOTS$m.headerActionsEnd, onSlotchange: this.handleHeaderActionsEndSlotChange }));
+    const slotNode = (hAsync("slot", { name: SLOTS$n.headerActionsEnd, onSlotchange: this.handleHeaderActionsEndSlotChange }));
     const showContainer = hasEndActions || closableNode || hasMenuItems;
-    return (hAsync("div", { class: { [CSS$I.headerActionsEnd]: true, [CSS$I.headerActions]: true }, hidden: !showContainer, key: "header-actions-end" }, slotNode, this.renderMenu(), closableNode));
+    return (hAsync("div", { class: { [CSS$L.headerActionsEnd]: true, [CSS$L.headerActions]: true }, hidden: !showContainer, key: "header-actions-end" }, slotNode, this.renderMenu(), closableNode));
   }
   renderMenu() {
     const { hasMenuItems, messages, menuOpen } = this;
-    return (hAsync("calcite-action-menu", { flipPlacements: ["top", "bottom"], hidden: !hasMenuItems, key: "menu", label: messages.options, open: menuOpen, placement: "bottom-end" }, hAsync("calcite-action", { icon: ICONS$a.menu, slot: SLOTS$v.trigger, text: messages.options }), hAsync("slot", { name: SLOTS$m.headerMenuActions, onSlotchange: this.handleHeaderMenuActionsSlotChange })));
+    return (hAsync("calcite-action-menu", { flipPlacements: ["top", "bottom"], hidden: !hasMenuItems, key: "menu", label: messages.options, open: menuOpen, placement: "bottom-end" }, hAsync("calcite-action", { icon: ICONS$a.menu, slot: SLOTS$w.trigger, text: messages.options }), hAsync("slot", { name: SLOTS$n.headerMenuActions, onSlotchange: this.handleHeaderMenuActionsSlotChange })));
   }
   renderHeaderNode() {
     const { hasHeaderContent, hasStartActions, hasEndActions, closable, hasMenuItems, hasActionBar, } = this;
@@ -35004,24 +34984,24 @@ class Panel {
       closable ||
       hasMenuItems;
     this.showHeaderContent = showHeaderContent;
-    return (hAsync("header", { class: CSS$I.header, hidden: !(showHeaderContent || hasActionBar) }, hAsync("div", { class: { [CSS$I.headerContainer]: true, [CSS$I.headerContainerBorderEnd]: hasActionBar }, hidden: !showHeaderContent }, this.renderHeaderStartActions(), this.renderHeaderSlottedContent(), headerContentNode, this.renderHeaderActionsEnd()), this.renderActionBar()));
+    return (hAsync("header", { class: CSS$L.header, hidden: !(showHeaderContent || hasActionBar) }, hAsync("div", { class: { [CSS$L.headerContainer]: true, [CSS$L.headerContainerBorderEnd]: hasActionBar }, hidden: !showHeaderContent }, this.renderHeaderStartActions(), this.renderHeaderSlottedContent(), headerContentNode, this.renderHeaderActionsEnd()), this.renderActionBar()));
   }
   renderFooterNode() {
     const { hasFooterContent, hasFooterActions } = this;
     const showFooter = hasFooterContent || hasFooterActions;
-    return (hAsync("footer", { class: CSS$I.footer, hidden: !showFooter }, hAsync("slot", { key: "footer-slot", name: SLOTS$m.footer, onSlotchange: this.handleFooterSlotChange }), hAsync("slot", { key: "footer-actions-slot", name: SLOTS$m.footerActions, onSlotchange: this.handleFooterActionsSlotChange })));
+    return (hAsync("footer", { class: CSS$L.footer, hidden: !showFooter }, hAsync("slot", { key: "footer-slot", name: SLOTS$n.footer, onSlotchange: this.handleFooterSlotChange }), hAsync("slot", { key: "footer-actions-slot", name: SLOTS$n.footerActions, onSlotchange: this.handleFooterActionsSlotChange })));
   }
   renderContent() {
-    return (hAsync("div", { class: CSS$I.contentWrapper, onScroll: this.panelScrollHandler,
+    return (hAsync("div", { class: CSS$L.contentWrapper, onScroll: this.panelScrollHandler,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setPanelScrollEl }, hAsync("slot", null), this.renderFab()));
   }
   renderFab() {
-    return (hAsync("div", { class: CSS$I.fabContainer, hidden: !this.hasFab }, hAsync("slot", { name: SLOTS$m.fab, onSlotchange: this.handleFabSlotChange })));
+    return (hAsync("div", { class: CSS$L.fabContainer, hidden: !this.hasFab }, hAsync("slot", { name: SLOTS$n.fab, onSlotchange: this.handleFabSlotChange })));
   }
   render() {
     const { loading, panelKeyDownHandler, closed, closable } = this;
-    const panelNode = (hAsync("article", { "aria-busy": toAriaBoolean(loading), class: CSS$I.container, hidden: closed, onKeyDown: panelKeyDownHandler, tabIndex: closable ? 0 : -1,
+    const panelNode = (hAsync("article", { "aria-busy": toAriaBoolean(loading), class: CSS$L.container, hidden: closed, onKeyDown: panelKeyDownHandler, tabIndex: closable ? 0 : -1,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setContainerRef }, this.renderHeaderNode(), this.renderContent(), this.renderFooterNode()));
     return (hAsync(Fragment, null, loading ? hAsync("calcite-scrim", { loading: loading }) : null, panelNode));
@@ -35067,7 +35047,7 @@ class Panel {
   }; }
 }
 
-const CSS$p = {
+const CSS$s = {
   sticky: "sticky-pos",
 };
 var ICON_TYPES$1;
@@ -35076,16 +35056,16 @@ var ICON_TYPES$1;
   ICON_TYPES["square"] = "square";
   ICON_TYPES["grip"] = "grip";
 })(ICON_TYPES$1 || (ICON_TYPES$1 = {}));
-const SLOTS$c = {
+const SLOTS$d = {
   menuActions: "menu-actions",
 };
 
-const CSS$o = {
+const CSS$r = {
   heading: "heading",
   container: "container",
   indented: "container--indented",
 };
-const SLOTS$b = {
+const SLOTS$c = {
   parentItem: "parent-item",
 };
 
@@ -35230,7 +35210,7 @@ function removeItem(event) {
   }
   const item = event.target;
   const selectedValues = this.selectedValues;
-  if (item.parentElement.tagName === "CALCITE-PICK-LIST-GROUP" && item.slot === SLOTS$b.parentItem) {
+  if (item.parentElement.tagName === "CALCITE-PICK-LIST-GROUP" && item.slot === SLOTS$c.parentItem) {
     item.parentElement.remove();
     Array.from(item.parentElement.children).forEach((item) => selectedValues.delete(item.value));
   }
@@ -35406,11 +35386,11 @@ 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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
         ref: storeAssistiveEl })) : null,
-      hAsync("header", { class: { [CSS$p.sticky]: true } },
+      hAsync("header", { class: { [CSS$s.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
           ref: setFilterEl })) : null,
-        hAsync("slot", { name: SLOTS$c.menuActions })),
+        hAsync("slot", { name: SLOTS$d.menuActions })),
       loading ? hAsync("calcite-scrim", { loading: loading }) : null,
       defaultSlot)));
 };
@@ -35595,16 +35575,16 @@ class PickListGroup {
   // --------------------------------------------------------------------------
   render() {
     const { el, groupTitle, headingLevel } = this;
-    const hasParentItem = getSlotted(el, SLOTS$b.parentItem) !== null;
+    const hasParentItem = getSlotted(el, SLOTS$c.parentItem) !== null;
     const sectionClasses = {
-      [CSS$o.container]: true,
-      [CSS$o.indented]: hasParentItem,
+      [CSS$r.container]: true,
+      [CSS$r.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$o.heading, level: level }, title)) : null, hAsync("slot", { name: SLOTS$b.parentItem }), hAsync("section", { class: sectionClasses }, hAsync("slot", null))));
+    return (hAsync(Fragment, null, title ? (hAsync(Heading, { class: CSS$r.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; }
@@ -35621,7 +35601,7 @@ class PickListGroup {
   }; }
 }
 
-const CSS$n = {
+const CSS$q = {
   actions: "actions",
   actionsEnd: "actions--end",
   actionsStart: "actions--start",
@@ -35640,7 +35620,7 @@ const ICONS$5 = {
   checked: "check",
   remove: "x",
 };
-const SLOTS$a = {
+const SLOTS$b = {
   actionsEnd: "actions-end",
   actionsStart: "actions-start",
 };
@@ -35783,28 +35763,28 @@ class PickListItem {
       return null;
     }
     return (hAsync("span", { class: {
-        [CSS$n.icon]: true,
-        [CSS$n.iconDot]: icon === ICON_TYPES$1.circle,
+        [CSS$q.icon]: true,
+        [CSS$q.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$n.remove, icon: ICONS$5.remove, onClick: this.removeClickHandler, slot: SLOTS$a.actionsEnd, text: this.messages.remove })) : null;
+    return this.removable ? (hAsync("calcite-action", { class: CSS$q.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$a.actionsStart);
-    return hasActionsStart ? (hAsync("div", { class: { [CSS$n.actions]: true, [CSS$n.actionsStart]: true } }, hAsync("slot", { name: SLOTS$a.actionsStart }))) : null;
+    const hasActionsStart = getSlotted(el, SLOTS$b.actionsStart);
+    return hasActionsStart ? (hAsync("div", { class: { [CSS$q.actions]: true, [CSS$q.actionsStart]: true } }, hAsync("slot", { name: SLOTS$b.actionsStart }))) : null;
   }
   renderActionsEnd() {
     const { el, removable } = this;
-    const hasActionsEnd = getSlotted(el, SLOTS$a.actionsEnd);
-    return hasActionsEnd || removable ? (hAsync("div", { class: { [CSS$n.actions]: true, [CSS$n.actionsEnd]: true } }, hAsync("slot", { name: SLOTS$a.actionsEnd }), this.renderRemoveAction())) : null;
+    const hasActionsEnd = getSlotted(el, SLOTS$b.actionsEnd);
+    return hasActionsEnd || removable ? (hAsync("div", { class: { [CSS$q.actions]: true, [CSS$q.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$n.label, onClick: this.pickListClickHandler, onKeyDown: this.pickListKeyDownHandler, tabIndex: 0,
+    return (hAsync(Fragment, null, this.renderIcon(), this.renderActionsStart(), hAsync("label", { "aria-label": label, class: CSS$q.label, onClick: this.pickListClickHandler, onKeyDown: this.pickListKeyDownHandler, tabIndex: 0,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      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()));
+      ref: (focusEl) => (this.focusEl = focusEl) }, hAsync("div", { "aria-checked": toAriaBoolean(this.selected), class: CSS$q.textContainer, role: "menuitemcheckbox" }, hAsync("span", { class: CSS$q.title }, label), description ? hAsync("span", { class: CSS$q.description }, description) : null)), this.renderActionsEnd()));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -35847,7 +35827,7 @@ class PickListItem {
   }; }
 }
 
-const CSS$m = {
+const CSS$p = {
   container: "container",
   imageContainer: "image-container",
   closeButtonContainer: "close-button-container",
@@ -35941,7 +35921,7 @@ class PopoverManager {
   }
 }
 
-const CSS$l = {
+const CSS$o = {
   arrow: "calcite-floating-ui-arrow",
   arrowStroke: "calcite-floating-ui-arrow__stroke",
 };
@@ -35971,8 +35951,8 @@ const FloatingArrow = ({ floatingLayout, key, ref, }) => {
     ` L${width - svgX},${height}` +
     ` Q${svgX},${height} ${svgX},${height}` +
     " Z";
-  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 })),
+  return (hAsync("svg", { "aria-hidden": "true", class: CSS$o.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$o.arrowStroke, d: dValue, fill: "none", "stroke-width": strokeWidth + 1 })),
     hAsync("path", { d: dValue, stroke: "none" })));
 };
 
@@ -36224,14 +36204,14 @@ class Popover {
   // --------------------------------------------------------------------------
   renderCloseButton() {
     const { messages, closable } = this;
-    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,
+    return closable ? (hAsync("div", { class: CSS$p.closeButtonContainer, key: CSS$p.closeButtonContainer }, hAsync("calcite-action", { appearance: "transparent", class: CSS$p.closeButton, onClick: this.hide, scale: this.scale, text: messages.close,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       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$m.heading, level: headingLevel }, heading)) : null;
-    return headingNode ? (hAsync("div", { class: CSS$m.header, key: CSS$m.header }, headingNode, this.renderCloseButton())) : null;
+    const headingNode = heading ? (hAsync(Heading, { class: CSS$p.heading, level: headingLevel }, heading)) : null;
+    return headingNode ? (hAsync("div", { class: CSS$p.header, key: CSS$p.header }, headingNode, this.renderCloseButton())) : null;
   }
   render() {
     const { effectiveReferenceElement, heading, label, open, pointerDisabled, floatingLayout } = this;
@@ -36246,9 +36226,9 @@ class Popover {
       },
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setTransitionEl }, arrowNode, hAsync("div", { class: {
-        [CSS$m.hasHeader]: !!heading,
-        [CSS$m.container]: true,
-      } }, this.renderHeader(), hAsync("div", { class: CSS$m.content }, hAsync("slot", null)), !heading ? this.renderCloseButton() : null))));
+        [CSS$p.hasHeader]: !!heading,
+        [CSS$p.container]: true,
+      } }, this.renderHeader(), hAsync("div", { class: CSS$p.content }, hAsync("slot", null)), !heading ? this.renderCloseButton() : null))));
   }
   static get assetsDirs() { return ["assets"]; }
   get el() { return getElement(this); }
@@ -36342,7 +36322,7 @@ class Progress {
   }; }
 }
 
-const CSS$k = {
+const CSS$n = {
   container: "container",
 };
 
@@ -36619,7 +36599,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$k.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$n.container, onBlur: this.onContainerBlur, onFocus: this.onContainerFocus, role: "radio", tabIndex: tabIndex,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setContainerEl }, hAsync("div", { class: "radio" })), hAsync(HiddenFormInputSlot, { component: this })));
   }
@@ -37046,7 +37026,7 @@ class Rating {
   }; }
 }
 
-const CSS$j = {
+const CSS$m = {
   scrim: "scrim",
   content: "content",
 };
@@ -37116,7 +37096,7 @@ class Scrim {
   // --------------------------------------------------------------------------
   render() {
     const { hasContent, loading, messages } = this;
-    return (hAsync("div", { class: CSS$j.scrim }, loading ? (hAsync("calcite-loader", { label: messages.loading, ref: this.storeLoaderEl, scale: this.loaderScale })) : null, hAsync("div", { class: CSS$j.content, hidden: !hasContent }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }))));
+    return (hAsync("div", { class: CSS$m.scrim }, loading ? (hAsync("calcite-loader", { label: messages.loading, ref: this.storeLoaderEl, scale: this.loaderScale })) : null, hAsync("div", { class: CSS$m.content, hidden: !hasContent }, hAsync("slot", { onSlotchange: this.handleDefaultSlotChange }))));
   }
   getScale(size) {
     if (size < BREAKPOINTS.s) {
@@ -37388,10 +37368,10 @@ class SegmentedControl {
   }; }
 }
 
-const SLOTS$9 = {
+const SLOTS$a = {
   input: "input",
 };
-const CSS$i = {
+const CSS$l = {
   segmentedControlItemIcon: "segmented-control-item-icon",
 };
 
@@ -37420,8 +37400,8 @@ class SegmentedControlItem {
   //--------------------------------------------------------------------------
   render() {
     const { appearance, checked, layout, scale, value } = this;
-    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;
+    const iconStartEl = this.iconStart ? (hAsync("calcite-icon", { class: CSS$l.segmentedControlItemIcon, flipRtl: this.iconFlipRtl, icon: this.iconStart, key: "icon-start", scale: "s" })) : null;
+    const iconEndEl = this.iconEnd ? (hAsync("calcite-icon", { class: CSS$l.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",
@@ -37429,7 +37409,7 @@ class SegmentedControlItem {
         "label--horizontal": layout === "horizontal",
         "label--outline": appearance === "outline",
         "label--outline-fill": appearance === "outline-fill",
-      } }, this.iconStart ? iconStartEl : null, hAsync("slot", null, value), hAsync("slot", { name: SLOTS$9.input }), this.iconEnd ? iconEndEl : null)));
+      } }, this.iconStart ? iconStartEl : null, hAsync("slot", null, value), hAsync("slot", { name: SLOTS$a.input }), this.iconEnd ? iconEndEl : null)));
   }
   get el() { return getElement(this); }
   static get watchers() { return {
@@ -37455,7 +37435,7 @@ class SegmentedControlItem {
   }; }
 }
 
-const CSS$h = {
+const CSS$k = {
   icon: "icon",
   iconContainer: "icon-container",
   select: "select",
@@ -37642,10 +37622,10 @@ class Select {
   //
   //--------------------------------------------------------------------------
   renderChevron() {
-    return (hAsync("div", { class: CSS$h.iconContainer }, hAsync("calcite-icon", { class: CSS$h.icon, icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" })));
+    return (hAsync("div", { class: CSS$k.iconContainer }, hAsync("calcite-icon", { class: CSS$k.icon, icon: "chevron-down", scale: this.scale === "l" ? "m" : "s" })));
   }
   render() {
-    return (hAsync(Fragment, null, hAsync("select", { "aria-label": getLabelText(this), class: CSS$h.select, disabled: this.disabled, onChange: this.handleInternalSelectChange,
+    return (hAsync(Fragment, null, hAsync("select", { "aria-label": getLabelText(this), class: CSS$k.select, disabled: this.disabled, onChange: this.handleInternalSelectChange,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.storeSelectRef }, hAsync("slot", null)), this.renderChevron(), hAsync(HiddenFormInputSlot, { component: this })));
   }
@@ -37676,7 +37656,7 @@ class Select {
   }; }
 }
 
-const CSS$g = {
+const CSS$j = {
   scrim: "scrim",
   container: "container",
   containerOpen: "container--open",
@@ -37799,12 +37779,12 @@ class Sheet {
   render() {
     const dir = getElementDir(this.el);
     return (hAsync(Host, { "aria-describedby": this.contentId, "aria-label": this.label, "aria-modal": "true", role: "dialog" }, hAsync("div", { class: {
-        [CSS$g.container]: true,
-        [CSS$g.containerOpen]: this.opened,
-        [CSS$g.containerSlottedInShell]: this.slottedInShell,
+        [CSS$j.container]: true,
+        [CSS$j.containerOpen]: this.opened,
+        [CSS$j.containerSlottedInShell]: this.slottedInShell,
         [CSS_UTILITY.rtl]: dir === "rtl",
-      } }, hAsync("calcite-scrim", { class: CSS$g.scrim, onClick: this.handleOutsideClose }), hAsync("div", { class: {
-        [CSS$g.content]: true,
+      } }, hAsync("calcite-scrim", { class: CSS$j.scrim, onClick: this.handleOutsideClose }), hAsync("div", { class: {
+        [CSS$j.content]: true,
       },
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.setTransitionEl }, hAsync("slot", null)))));
@@ -37909,7 +37889,7 @@ class Sheet {
   }; }
 }
 
-const CSS$f = {
+const CSS$i = {
   main: "main",
   content: "content",
   contentBehind: "content--behind",
@@ -37918,7 +37898,7 @@ const CSS$f = {
   container: "container",
   contentBehindCenterContent: "center-content",
 };
-const SLOTS$8 = {
+const SLOTS$9 = {
   centerRow: "center-row",
   panelStart: "panel-start",
   panelEnd: "panel-end",
@@ -38008,44 +37988,44 @@ class Shell {
   //
   // --------------------------------------------------------------------------
   renderHeader() {
-    return (hAsync("div", { hidden: !this.hasHeader }, hAsync("slot", { key: "header", name: SLOTS$8.header, onSlotchange: this.handleHeaderSlotChange })));
+    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$8.footer, onSlotchange: this.handleFooterSlotChange })));
+    return (hAsync("div", { class: CSS$i.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$8.alerts, onSlotchange: this.handleAlertsSlotChange })));
+    return (hAsync("div", { hidden: !this.hasAlerts }, hAsync("slot", { key: "alerts", name: SLOTS$9.alerts, onSlotchange: this.handleAlertsSlotChange })));
   }
   renderSheets() {
-    return (hAsync("div", { hidden: !this.hasSheets }, hAsync("slot", { key: "sheets", name: SLOTS$8.sheets, onSlotchange: this.handleSheetsSlotChange })));
+    return (hAsync("div", { hidden: !this.hasSheets }, hAsync("slot", { key: "sheets", name: SLOTS$9.sheets, onSlotchange: this.handleSheetsSlotChange })));
   }
   renderModals() {
-    return (hAsync("div", { hidden: !this.hasModals }, hAsync("slot", { key: "modals", name: SLOTS$8.modals, onSlotchange: this.handleModalsSlotChange })));
+    return (hAsync("div", { hidden: !this.hasModals }, hAsync("slot", { key: "modals", name: SLOTS$9.modals, onSlotchange: this.handleModalsSlotChange })));
   }
   renderContent() {
     const defaultSlotNode = hAsync("slot", { key: "default-slot" });
-    const deprecatedCenterRowSlotNode = (hAsync("slot", { key: "center-row-slot", name: SLOTS$8.centerRow }));
-    const panelBottomSlotNode = hAsync("slot", { key: "panel-bottom-slot", name: SLOTS$8.panelBottom });
-    const panelTopSlotNode = hAsync("slot", { key: "panel-top-slot", name: SLOTS$8.panelTop });
+    const deprecatedCenterRowSlotNode = (hAsync("slot", { key: "center-row-slot", name: SLOTS$9.centerRow }));
+    const panelBottomSlotNode = hAsync("slot", { key: "panel-bottom-slot", name: SLOTS$9.panelBottom });
+    const panelTopSlotNode = hAsync("slot", { key: "panel-top-slot", name: SLOTS$9.panelTop });
     const contentContainerKey = "content-container";
     const content = !!this.contentBehind
       ? [
         hAsync("div", { class: {
-            [CSS$f.content]: true,
-            [CSS$f.contentBehind]: true,
+            [CSS$i.content]: true,
+            [CSS$i.contentBehind]: true,
           }, key: contentContainerKey }, defaultSlotNode),
-        hAsync("div", { class: CSS$f.contentBehindCenterContent }, panelTopSlotNode, panelBottomSlotNode, deprecatedCenterRowSlotNode),
+        hAsync("div", { class: CSS$i.contentBehindCenterContent }, panelTopSlotNode, panelBottomSlotNode, deprecatedCenterRowSlotNode),
       ]
       : [
-        hAsync("div", { class: CSS$f.content, key: contentContainerKey }, panelTopSlotNode, defaultSlotNode, panelBottomSlotNode, deprecatedCenterRowSlotNode),
+        hAsync("div", { class: CSS$i.content, key: contentContainerKey }, panelTopSlotNode, defaultSlotNode, panelBottomSlotNode, deprecatedCenterRowSlotNode),
       ];
     return content;
   }
   renderMain() {
-    return (hAsync("div", { class: CSS$f.main }, hAsync("slot", { name: SLOTS$8.panelStart }), this.renderContent(), hAsync("slot", { name: SLOTS$8.panelEnd })));
+    return (hAsync("div", { class: CSS$i.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(), this.renderSheets()));
+    return (hAsync("div", { class: CSS$i.positionedSlotWrapper }, this.renderAlerts(), this.renderModals(), this.renderSheets()));
   }
   render() {
     return (hAsync(Fragment, null, this.renderHeader(), this.renderMain(), this.renderFooter(), this.renderPositionedSlots()));
@@ -38069,11 +38049,11 @@ class Shell {
   }; }
 }
 
-const CSS$e = {
+const CSS$h = {
   actionBarContainer: "action-bar-container",
   content: "content",
 };
-const SLOTS$7 = {
+const SLOTS$8 = {
   actionBar: "action-bar",
 };
 
@@ -38108,9 +38088,9 @@ class ShellCenterRow {
   // --------------------------------------------------------------------------
   render() {
     const { el } = this;
-    const contentNode = (hAsync("div", { class: CSS$e.content }, hAsync("slot", null)));
-    const actionBar = getSlotted(el, SLOTS$7.actionBar);
-    const actionBarNode = actionBar ? (hAsync("div", { class: CSS$e.actionBarContainer, key: "action-bar" }, hAsync("slot", { name: SLOTS$7.actionBar }))) : null;
+    const contentNode = (hAsync("div", { class: CSS$h.content }, hAsync("slot", null)));
+    const actionBar = getSlotted(el, SLOTS$8.actionBar);
+    const actionBarNode = actionBar ? (hAsync("div", { class: CSS$h.actionBarContainer, key: "action-bar" }, hAsync("slot", { name: SLOTS$8.actionBar }))) : null;
     const children = [actionBarNode, contentNode];
     if (actionBar?.position === "end") {
       children.reverse();
@@ -38133,7 +38113,7 @@ class ShellCenterRow {
   }; }
 }
 
-const CSS$d = {
+const CSS$g = {
   container: "container",
   content: "content",
   contentHeader: "content__header",
@@ -38142,7 +38122,7 @@ const CSS$d = {
   contentOverlay: "content--overlay",
   separator: "separator",
 };
-const SLOTS$6 = {
+const SLOTS$7 = {
   actionBar: "action-bar",
   header: "header",
 };
@@ -38396,7 +38376,7 @@ class ShellPanel {
   //
   // --------------------------------------------------------------------------
   renderHeader() {
-    return (hAsync("div", { class: CSS$d.contentHeader, hidden: !this.hasHeader, key: "header" }, hAsync("slot", { name: SLOTS$6.header, onSlotchange: this.handleHeaderSlotChange })));
+    return (hAsync("div", { class: CSS$g.contentHeader, hidden: !this.hasHeader, key: "header" }, hAsync("slot", { name: SLOTS$7.header, onSlotchange: this.handleHeaderSlotChange })));
   }
   render() {
     const { collapsed, position, initialContentWidth, initialContentHeight, contentWidth, contentWidthMax, contentWidthMin, contentHeight, contentHeightMax, contentHeightMin, resizable, layout, displayMode, } = this;
@@ -38413,7 +38393,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$g.separator, key: "separator", onKeyDown: this.separatorKeyDown, role: "separator", tabIndex: 0, "touch-action": "none",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: this.connectSeparator })) : null;
     const getAnimationDir = () => {
@@ -38429,20 +38409,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$g.content]: true,
+        [CSS$g.contentOverlay]: displayMode === "overlay",
+        [CSS$g.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 should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      ref: this.storeContentEl }, this.renderHeader(), hAsync("div", { class: CSS$d.contentBody }, hAsync("slot", null)), separatorNode));
-    const actionBarNode = (hAsync("slot", { key: "action-bar", name: SLOTS$6.actionBar, onSlotchange: this.handleActionBarSlotChange }));
+      ref: this.storeContentEl }, this.renderHeader(), hAsync("div", { class: CSS$g.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$g.container]: true } }, mainNodes);
   }
   // --------------------------------------------------------------------------
   //
@@ -38543,7 +38523,7 @@ class ShellPanel {
   }; }
 }
 
-const CSS$c = {
+const CSS$f = {
   handleLabel: "handle__label",
   handleLabelMinValue: "handle__label--minValue",
   handleLabelValue: "handle__label--value",
@@ -38742,8 +38722,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$f.handleLabel} ${CSS$f.handleLabelMinValue}`;
+    const handleLabelValueClasses = `${CSS$f.handleLabel} ${CSS$f.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,
@@ -38879,8 +38859,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$f.tickMin]: isMinTickLabel,
+        [CSS$f.tickMax]: isMaxTickLabel,
       } }, displayedTickValue));
     if (this.labelTicks && !this.hasHistogram && !valueIsRange) {
       return tickLabel;
@@ -39438,7 +39418,7 @@ class Slider {
   }; }
 }
 
-const CSS$b = {
+const CSS$e = {
   sortItem: "sort-item",
   container: "container",
   containerHorizontal: "container--horizontal",
@@ -39566,9 +39546,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$e.container]: true,
+        [CSS$e.containerVertical]: !horizontal,
+        [CSS$e.containerHorizontal]: horizontal,
       } }, hAsync("slot", null)));
   }
   get el() { return getElement(this); }
@@ -39592,7 +39572,7 @@ class SortableList {
   }; }
 }
 
-const CSS$a = {
+const CSS$d = {
   container: "split-button__container",
   dividerContainer: "split-button__divider-container",
   divider: "split-button__divider",
@@ -39671,13 +39651,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$d.container]: true,
+      [CSS$d.widthAuto]: this.width === "auto",
+      [CSS$d.widthHalf]: this.width === "half",
+      [CSS$d.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$d.dividerContainer }, hAsync("div", { class: CSS$d.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"
@@ -39764,25 +39744,25 @@ class Stack {
   // --------------------------------------------------------------------------
   renderActionsStart() {
     const { hasActionsStart } = this;
-    return (hAsync("div", { class: CSS$v.actionsStart, hidden: !hasActionsStart, key: "actions-start-container" }, hAsync("slot", { name: SLOTS$f.actionsStart, onSlotchange: this.handleActionsStartSlotChange })));
+    return (hAsync("div", { class: CSS$y.actionsStart, hidden: !hasActionsStart, key: "actions-start-container" }, hAsync("slot", { name: SLOTS$g.actionsStart, onSlotchange: this.handleActionsStartSlotChange })));
   }
   renderActionsEnd() {
     const { hasActionsEnd } = this;
-    return (hAsync("div", { class: CSS$v.actionsEnd, hidden: !hasActionsEnd, key: "actions-end-container" }, hAsync("slot", { name: SLOTS$f.actionsEnd, onSlotchange: this.handleActionsEndSlotChange })));
+    return (hAsync("div", { class: CSS$y.actionsEnd, hidden: !hasActionsEnd, key: "actions-end-container" }, hAsync("slot", { name: SLOTS$g.actionsEnd, onSlotchange: this.handleActionsEndSlotChange })));
   }
   renderContentStart() {
     const { hasContentStart } = this;
-    return (hAsync("div", { class: CSS$v.contentStart, hidden: !hasContentStart }, hAsync("slot", { name: SLOTS$f.contentStart, onSlotchange: this.handleContentStartSlotChange })));
+    return (hAsync("div", { class: CSS$y.contentStart, hidden: !hasContentStart }, hAsync("slot", { name: SLOTS$g.contentStart, onSlotchange: this.handleContentStartSlotChange })));
   }
   renderDefaultContent() {
-    return (hAsync("div", { class: CSS$v.content }, hAsync("slot", null)));
+    return (hAsync("div", { class: CSS$y.content }, hAsync("slot", null)));
   }
   renderContentEnd() {
     const { hasContentEnd } = this;
-    return (hAsync("div", { class: CSS$v.contentEnd, hidden: !hasContentEnd }, hAsync("slot", { name: SLOTS$f.contentEnd, onSlotchange: this.handleContentEndSlotChange })));
+    return (hAsync("div", { class: CSS$y.contentEnd, hidden: !hasContentEnd }, hAsync("slot", { name: SLOTS$g.contentEnd, onSlotchange: this.handleContentEndSlotChange })));
   }
   render() {
-    return (hAsync(Host, null, hAsync("div", { class: CSS$v.container }, this.renderActionsStart(), this.renderContentStart(), this.renderDefaultContent(), this.renderContentEnd(), this.renderActionsEnd())));
+    return (hAsync(Host, null, hAsync("div", { class: CSS$y.container }, this.renderActionsStart(), this.renderContentStart(), this.renderDefaultContent(), this.renderContentEnd(), this.renderActionsEnd())));
   }
   static get style() { return stackCss; }
   static get cmpMeta() { return {
@@ -40680,7 +40660,7 @@ class TabNav {
   }; }
 }
 
-const CSS$9 = {
+const CSS$c = {
   closeButton: "close-button",
   container: "container",
   content: "content",
@@ -40800,18 +40780,18 @@ class TabTitle {
   render() {
     const { el, closed } = this;
     const id = el.id || this.guid;
-    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" }));
+    const iconStartEl = (hAsync("calcite-icon", { class: { [CSS$c.titleIcon]: true, [CSS$c.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$c.titleIcon]: true, [CSS$c.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$9.iconPresent]: !!this.iconStart || !!this.iconEnd,
+        [CSS$c.iconPresent]: !!this.iconStart || !!this.iconEnd,
       }, hidden: closed,
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
-      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())));
+      ref: (el) => this.resizeObserver?.observe(el) }, hAsync("div", { class: { [CSS$c.content]: true, [CSS$c.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$9.closeButton, disabled: false, key: CSS$9.closeButton, onClick: this.closeClickHandler, title: messages.close, type: "button",
+    return closable ? (hAsync("button", { "aria-label": messages.close, class: CSS$c.closeButton, disabled: false, key: CSS$c.closeButton, onClick: this.closeClickHandler, title: messages.close, type: "button",
       // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
       ref: (el) => (this.closeButtonEl = el) }, hAsync("calcite-icon", { icon: ICONS$4.close, scale: this.scale === "l" ? "m" : "s" }))) : null;
   }
@@ -40978,6 +40958,883 @@ class TabTitle {
   }; }
 }
 
+const CSS$b = {
+  bordered: "bordered",
+  zebra: "zebra",
+  selectionArea: "selection-area",
+  paginationArea: "pagination-area",
+  container: "container",
+  tableContainer: "table-container",
+  tableFixed: "table--fixed",
+  assistiveText: "assistive-text",
+  selectionActions: "selection-actions",
+};
+const SLOTS$6 = {
+  selectionActions: "selection-actions",
+  tableHeader: "table-header",
+  tableFooter: "table-footer",
+};
+
+const tableCss = "/*!@:host([scale=s])*/[scale=s].sc-calcite-table-h{--calcite-internal-table-cell-padding:0.25rem;--calcite-internal-table-cell-font-size:var(--calcite-font-size--2);--calcite-internal-table-cell-font-size-secondary:var(--calcite-font-size--3)}/*!@:host([scale=m])*/[scale=m].sc-calcite-table-h{--calcite-internal-table-cell-padding:0.5rem;--calcite-internal-table-cell-font-size:var(--calcite-font-size--1);--calcite-internal-table-cell-font-size-secondary:var(--calcite-font-size--2)}/*!@:host([scale=l])*/[scale=l].sc-calcite-table-h{--calcite-internal-table-cell-padding:1rem;--calcite-internal-table-cell-font-size:var(--calcite-font-size-0);--calcite-internal-table-cell-font-size-secondary:var(--calcite-font-size--1)}/*!@:host*/.sc-calcite-table-h{display:table}/*!@.container*/.container.sc-calcite-table{max-inline-size:100vw;inline-size:100%}/*!@.table-container*/.table-container.sc-calcite-table{overflow-x:scroll;white-space:nowrap}/*!@.table-container:not(.bordered)*/.table-container.sc-calcite-table:not(.bordered){border-block-end:1px solid var(--calcite-ui-border-3)}/*!@.assistive-text*/.assistive-text.sc-calcite-table{position:absolute;inline-size:1px;block-size:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border-width:0}/*!@table*/table.sc-calcite-table{inline-size:100%;border-collapse:collapse;overflow-x:scroll;border-block-start:1px solid var(--calcite-ui-border-3);border-inline-start:1px solid var(--calcite-ui-border-3);border-block-end:1px solid var(--calcite-ui-border-3)}/*!@tbody*/tbody.sc-calcite-table{border-block-end:1px solid var(--calcite-ui-border-3)}/*!@.table--fixed*/.table--fixed.sc-calcite-table{table-layout:fixed}/*!@.bordered ::slotted(calcite-table-row)*/.bordered .sc-calcite-table-s>calcite-table-row{--calcite-table-row-border-color:var(--calcite-ui-border-3)}/*!@.zebra ::slotted(calcite-table-row:nth-child(2n+1))*/.zebra .sc-calcite-table-s>calcite-table-row:nth-child(2n+1){--calcite-table-row-background:var(--calcite-ui-foreground-2)}/*!@.selection-actions*/.selection-actions.sc-calcite-table{display:flex;flex-direction:row;margin-inline-start:auto}/*!@.selection-area*/.selection-area.sc-calcite-table{display:flex;flex-direction:row;align-items:center;padding-block:var(--calcite-internal-table-cell-padding)}/*!@.selection-area calcite-chip:last-of-type*/.selection-area.sc-calcite-table calcite-chip.sc-calcite-table:last-of-type{margin-inline-end:0.5rem}/*!@.selection-area calcite-chip:last-of-type:not(:first-of-type)*/.selection-area.sc-calcite-table calcite-chip.sc-calcite-table:last-of-type:not(:first-of-type){margin-inline-start:0.5rem}/*!@.selection-area calcite-button*/.selection-area.sc-calcite-table calcite-button.sc-calcite-table{margin-inline-end:1rem}/*!@.pagination-area*/.pagination-area.sc-calcite-table{display:flex;inline-size:100%;flex-direction:row;justify-content:center;padding-block:var(--calcite-internal-table-cell-padding)}/*!@:host([hidden])*/[hidden].sc-calcite-table-h{display:none}/*!@[hidden]*/[hidden].sc-calcite-table{display:none}";
+
+/**
+ * @slot - A slot for adding `calcite-table-row` or nested `calcite-table` elements.
+ * @slot table-header - A slot for adding `calcite-table-row` containing `calcite-table-header` elements.
+ * @slot table-footer - A slot for adding `calcite-table-row` containing `calcite-table-cell` or `calcite-table-header` elements.
+ * @slot selection-actions - A slot for adding a `calcite-action-bar` or other components to display when `selectionMode` is not `"none"` and one or more `calcite-table-row` is selected.
+ */
+class Table {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.calciteTableSelect = createEvent(this, "calciteTableSelect", 6);
+    this.calciteTablePageChange = createEvent(this, "calciteTablePageChange", 6);
+    this.calciteInternalTableRowFocusChange = createEvent(this, "calciteInternalTableRowFocusChange", 6);
+    // --------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    // --------------------------------------------------------------------------
+    this.getSlottedRows = (el) => {
+      return el
+        ?.assignedElements({ flatten: true })
+        ?.filter((el) => el?.matches("calcite-table-row"));
+    };
+    this.updateRows = () => {
+      const headRows = this.getSlottedRows(this.tableHeadSlotEl) || [];
+      const bodyRows = this.getSlottedRows(this.tableBodySlotEl) || [];
+      const footRows = this.getSlottedRows(this.tableFootSlotEl) || [];
+      const allRows = [...headRows, ...bodyRows, ...footRows];
+      headRows?.forEach((row) => {
+        const position = headRows?.indexOf(row);
+        row.rowType = "head";
+        row.positionSection = position;
+        row.positionSectionLocalized = this.localizeNumber((position + 1).toString());
+      });
+      bodyRows?.forEach((row) => {
+        const position = bodyRows?.indexOf(row);
+        row.rowType = "body";
+        row.positionSection = position;
+        row.positionSectionLocalized = this.localizeNumber((position + 1).toString());
+      });
+      footRows?.forEach((row) => {
+        const position = footRows?.indexOf(row);
+        row.rowType = "foot";
+        row.positionSection = position;
+        row.positionSectionLocalized = this.localizeNumber((position + 1).toString());
+      });
+      allRows?.forEach((row) => {
+        row.selectionMode = this.selectionMode;
+        row.bodyRowCount = bodyRows?.length;
+        row.positionAll = allRows?.indexOf(row);
+        row.numbered = this.numbered;
+        row.scale = this.scale;
+        row.readCellContentsToAT = this.readCellContentsToAT;
+      });
+      const colCount = headRows[0]?.cellCount || headRows[0]?.querySelectorAll("calcite-table-header")?.length;
+      this.colCount = colCount;
+      this.headRows = headRows;
+      this.bodyRows = bodyRows;
+      this.footRows = footRows;
+      this.allRows = allRows;
+      this.updateSelectedItems();
+      this.paginateRows();
+    };
+    this.handlePaginationChange = () => {
+      const requestedItem = this.paginationEl?.startItem;
+      this.pageStartRow = requestedItem || 1;
+      this.calciteTablePageChange.emit();
+      this.updateRows();
+    };
+    this.paginateRows = () => {
+      this.bodyRows?.forEach((row) => {
+        const rowPos = row.positionSection + 1;
+        const inView = rowPos >= this.pageStartRow && rowPos < this.pageStartRow + this.pageSize;
+        row.hidden = this.pageSize > 0 && !inView && !this.footRows.includes(row);
+      });
+    };
+    this.updateSelectedItems = (emit) => {
+      const selectedItems = this.bodyRows?.filter((el) => el.selected);
+      this.selectedItems = selectedItems;
+      this.selectedCount = selectedItems?.length;
+      this.allRows?.forEach((row) => {
+        row.selectedRowCount = this.selectedCount;
+        row.selectedRowCountLocalized = this.localizeNumber(this.selectedCount);
+      });
+      if (emit) {
+        this.calciteTableSelect.emit();
+      }
+    };
+    this.handleDeselectAllRows = () => {
+      this.bodyRows?.forEach((row) => {
+        row.selected = false;
+      });
+      this.updateSelectedItems(true);
+    };
+    this.setSelectedItems = (elToMatch) => {
+      this.bodyRows?.forEach((el) => {
+        if (elToMatch?.rowType === "head") {
+          el.selected = this.selectedCount !== this.bodyRows?.length;
+        }
+        else {
+          el.selected =
+            elToMatch === el ? !el.selected : this.selectionMode === "multiple" ? el.selected : false;
+        }
+      });
+      this.updateSelectedItems(true);
+    };
+    this.localizeNumber = (value) => {
+      numberStringFormatter.numberFormatOptions = {
+        locale: this.effectiveLocale,
+        numberingSystem: this.numberingSystem,
+        useGrouping: this.groupSeparator,
+      };
+      return numberStringFormatter.localize(value.toString());
+    };
+    this.bordered = false;
+    this.caption = undefined;
+    this.groupSeparator = false;
+    this.layout = "auto";
+    this.numbered = false;
+    this.numberingSystem = undefined;
+    this.pageSize = 0;
+    this.scale = "m";
+    this.selectionMode = "none";
+    this.zebra = false;
+    this.selectedItems = [];
+    this.messages = undefined;
+    this.messageOverrides = undefined;
+    this.colCount = 0;
+    this.pageStartRow = 1;
+    this.selectedCount = 0;
+    this.readCellContentsToAT = undefined;
+    this.defaultMessages = undefined;
+    this.effectiveLocale = "";
+  }
+  handleNumberedChange() {
+    this.updateRows();
+  }
+  onMessagesChange() {
+    /* wired up by t9n util */
+  }
+  effectiveLocaleChange() {
+    updateMessages(this);
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  async componentWillLoad() {
+    setUpLoadableComponent(this);
+    await setUpMessages(this);
+    this.readCellContentsToAT = /safari/i.test(getUserAgentString());
+    this.updateRows();
+  }
+  componentDidLoad() {
+    setComponentLoaded(this);
+  }
+  connectedCallback() {
+    connectLocalized(this);
+    connectMessages(this);
+  }
+  disconnectedCallback() {
+    disconnectLocalized(this);
+    disconnectMessages(this);
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Event Listeners
+  //
+  //--------------------------------------------------------------------------
+  calciteChipSelectListener(event) {
+    if (event.composedPath().includes(this.el)) {
+      this.setSelectedItems(event.target);
+    }
+  }
+  calciteInternalTableRowFocusEvent(event) {
+    const cellPosition = event["detail"].cellPosition;
+    const rowPos = event["detail"].rowPosition;
+    const destination = event["detail"].destination;
+    const lastCell = event["detail"].lastCell;
+    const visibleBody = this.bodyRows?.filter((row) => !row.hidden);
+    const visibleAll = this.allRows?.filter((row) => !row.hidden);
+    const lastHeadRow = this.headRows[this.headRows.length - 1]?.positionAll;
+    const firstBodyRow = visibleBody[0]?.positionAll;
+    const lastBodyRow = visibleBody[visibleBody.length - 1]?.positionAll;
+    const firstFootRow = this.footRows[0]?.positionAll;
+    const lastTableRow = visibleAll[visibleAll.length - 1]?.positionAll;
+    const leavingHeader = destination === "next" && rowPos === lastHeadRow;
+    const leavingFooter = destination === "previous" && rowPos === firstFootRow;
+    const enteringHeader = destination === "previous" && rowPos === firstBodyRow;
+    const enteringFooter = destination === "next" && rowPos === lastBodyRow;
+    let rowPosition;
+    switch (destination) {
+      case "first":
+        rowPosition = 0;
+        break;
+      case "last":
+        rowPosition = lastTableRow;
+        break;
+      case "next":
+        rowPosition = leavingHeader ? firstBodyRow : enteringFooter ? firstFootRow : rowPos + 1;
+        break;
+      case "previous":
+        rowPosition = leavingFooter ? lastBodyRow : enteringHeader ? lastHeadRow : rowPos - 1;
+        break;
+    }
+    const destinationCount = this.allRows?.find((row) => row.positionAll === rowPosition)?.cellCount;
+    const adjustedPos = cellPosition > destinationCount ? destinationCount : cellPosition;
+    if (rowPosition !== undefined) {
+      this.calciteInternalTableRowFocusChange.emit({
+        cellPosition: adjustedPos,
+        rowPosition,
+        destination,
+        lastCell,
+      });
+    }
+  }
+  // --------------------------------------------------------------------------
+  //
+  //  Render Methods
+  //
+  // --------------------------------------------------------------------------
+  renderSelectionArea() {
+    const outOfViewCount = this.selectedItems?.filter((el) => el.hidden)?.length;
+    const localizedOutOfView = this.localizeNumber(outOfViewCount?.toString());
+    const localizedSelectedCount = this.localizeNumber(this.selectedCount?.toString());
+    const selectionText = `${localizedSelectedCount} ${this.messages.selected}`;
+    const outOfView = `${localizedOutOfView} ${this.messages.hiddenSelected}`;
+    return (hAsync("div", { class: CSS$b.selectionArea }, hAsync("calcite-chip", { kind: this.selectedCount > 0 ? "brand" : "neutral", scale: this.scale, value: selectionText }, selectionText), outOfViewCount > 0 && (hAsync("calcite-chip", { icon: "hide-empty", scale: this.scale, title: outOfView, value: outOfView }, localizedOutOfView)), this.selectedCount > 0 && (hAsync("calcite-button", { "icon-start": "x", kind: "neutral", onClick: this.handleDeselectAllRows, round: true, scale: this.scale, title: `${this.messages.clear} ${selectionText} ${this.messages.row}` }, this.messages.clear)), hAsync("div", { class: CSS$b.selectionActions }, hAsync("slot", { name: SLOTS$6.selectionActions }))));
+  }
+  renderPaginationArea() {
+    return (hAsync("div", { class: CSS$b.paginationArea }, hAsync("calcite-pagination", { groupSeparator: this.groupSeparator, numberingSystem: this.numberingSystem, onCalcitePaginationChange: this.handlePaginationChange, pageSize: this.pageSize, scale: this.scale, startItem: 1, totalItems: this.bodyRows?.length,
+      // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+      ref: (el) => (this.paginationEl = el) })));
+  }
+  renderTHead() {
+    return (hAsync("thead", null, hAsync("slot", { name: SLOTS$6.tableHeader, onSlotchange: this.updateRows, ref: (el) => (this.tableHeadSlotEl = el) })));
+  }
+  renderTBody() {
+    return (hAsync("tbody", null, hAsync("slot", { onSlotchange: this.updateRows, ref: (el) => (this.tableBodySlotEl = el) })));
+  }
+  renderTFoot() {
+    return (hAsync("tfoot", null, hAsync("slot", { name: SLOTS$6.tableFooter, onSlotchange: this.updateRows, ref: (el) => (this.tableFootSlotEl = el) })));
+  }
+  render() {
+    return (hAsync(Host, null, hAsync("div", { class: CSS$b.container }, this.selectionMode !== "none" && this.renderSelectionArea(), hAsync("div", { class: {
+        [CSS$b.bordered]: this.bordered,
+        [CSS$b.zebra]: this.zebra,
+        [CSS$b.tableContainer]: true,
+      } }, hAsync("table", { "aria-colcount": this.colCount, "aria-multiselectable": this.selectionMode === "multiple", "aria-readonly": true, "aria-rowcount": this.allRows?.length, class: { [CSS$b.tableFixed]: this.layout === "fixed" }, role: "grid" }, hAsync("caption", { class: CSS$b.assistiveText }, this.caption), this.renderTHead(), this.renderTBody(), this.renderTFoot())), this.pageSize > 0 && this.renderPaginationArea())));
+  }
+  static get assetsDirs() { return ["assets"]; }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "groupSeparator": ["handleNumberedChange"],
+    "numbered": ["handleNumberedChange"],
+    "numberingSystem": ["handleNumberedChange"],
+    "pageSize": ["handleNumberedChange"],
+    "scale": ["handleNumberedChange"],
+    "selectionMode": ["handleNumberedChange"],
+    "messageOverrides": ["onMessagesChange"],
+    "effectiveLocale": ["effectiveLocaleChange"]
+  }; }
+  static get style() { return tableCss; }
+  static get cmpMeta() { return {
+    "$flags$": 9,
+    "$tagName$": "calcite-table",
+    "$members$": {
+      "bordered": [516],
+      "caption": [1],
+      "groupSeparator": [516, "group-separator"],
+      "layout": [513],
+      "numbered": [516],
+      "numberingSystem": [513, "numbering-system"],
+      "pageSize": [514, "page-size"],
+      "scale": [513],
+      "selectionMode": [513, "selection-mode"],
+      "zebra": [516],
+      "selectedItems": [1040],
+      "messages": [1040],
+      "messageOverrides": [1040],
+      "colCount": [32],
+      "pageStartRow": [32],
+      "selectedCount": [32],
+      "readCellContentsToAT": [32],
+      "defaultMessages": [32],
+      "effectiveLocale": [32]
+    },
+    "$listeners$": [[0, "calciteTableRowSelect", "calciteChipSelectListener"], [0, "calciteInternalTableRowFocusRequest", "calciteInternalTableRowFocusEvent"]],
+    "$lazyBundleId$": "-",
+    "$attrsToReflect$": [["bordered", "bordered"], ["groupSeparator", "group-separator"], ["layout", "layout"], ["numbered", "numbered"], ["numberingSystem", "numbering-system"], ["pageSize", "page-size"], ["scale", "scale"], ["selectionMode", "selection-mode"], ["zebra", "zebra"]]
+  }; }
+}
+
+const CSS$a = {
+  numberCell: "number-cell",
+  footerCell: "footer-cell",
+  selectionCell: "selection-cell",
+  selectedCell: "selected-cell",
+  assistiveText: "assistive-text",
+};
+
+const tableCellCss = "/*!@:host*/.sc-calcite-table-cell-h{--calcite-internal-table-cell-background-internal:var(--calcite-table-cell-background, transparent);--calcite-internal-table-cell-border-color-internal:var(--calcite-table-cell-border-color, transparent);display:contents}/*!@:host([alignment=center]) td*/[alignment=center].sc-calcite-table-cell-h td.sc-calcite-table-cell{text-align:center}/*!@:host([alignment=end]) td*/[alignment=end].sc-calcite-table-cell-h td.sc-calcite-table-cell{text-align:end}/*!@.assistive-text*/.assistive-text.sc-calcite-table-cell{position:absolute;inline-size:1px;block-size:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border-width:0}/*!@td*/td.sc-calcite-table-cell{text-align:start;vertical-align:middle;color:var(--calcite-ui-text-1);outline-color:transparent;background:var(--calcite-internal-table-cell-background);border-inline-end:1px solid var(--calcite-ui-border-3);font-size:var(--calcite-internal-table-cell-font-size);padding:var(--calcite-internal-table-cell-padding)}/*!@td:focus*/td.sc-calcite-table-cell:focus{outline:2px solid var(--calcite-ui-focus-color, var(--calcite-ui-brand));outline-offset:calc(\n            -2px *\n            calc(\n              1 -\n              2 * clamp(\n                0,\n                var(--calcite-ui-focus-offset-invert),\n                1\n              )\n            )\n          )}/*!@.number-cell*/.number-cell.sc-calcite-table-cell{background-color:var(--calcite-ui-foreground-2)}/*!@.footer-cell*/.footer-cell.sc-calcite-table-cell{background-color:var(--calcite-ui-background);font-weight:var(--calcite-font-weight-medium);color:var(--calcite-ui-text-1);border-block-start:1px solid var(--calcite-ui-border-3)}/*!@.number-cell,\n.selection-cell*/.number-cell.sc-calcite-table-cell,.selection-cell.sc-calcite-table-cell{border-inline-end:1px solid var(--calcite-ui-border-3);inline-size:2rem;min-inline-size:2rem}/*!@.selection-cell*/.selection-cell.sc-calcite-table-cell{cursor:pointer;color:var(--calcite-ui-text-3);inset-inline-start:2rem}/*!@.selected-cell:not(.number-cell):not(.footer-cell)*/.selected-cell.sc-calcite-table-cell:not(.number-cell):not(.footer-cell){--calcite-table-cell-background:var(--calcite-ui-foreground-current);background:var(--calcite-ui-foreground-current)}/*!@.selection-cell.selected-cell*/.selection-cell.selected-cell.sc-calcite-table-cell{box-shadow:inset 0.25rem 0 0 0 var(--calcite-ui-brand);color:var(--calcite-ui-brand)}/*!@.selection-cell.selected-cell calcite-icon*/.selection-cell.selected-cell.sc-calcite-table-cell calcite-icon.sc-calcite-table-cell{color:var(--calcite-ui-brand)}/*!@.selection-cell*/.selection-cell.sc-calcite-table-cell{vertical-align:middle}/*!@.selection-cell ::slotted(calcite-icon)*/.selection-cell .sc-calcite-table-cell-s>calcite-icon{pointer-events:none;margin-block-start:0.25rem}";
+
+/**
+ * @slot - A slot for adding content, usually text content.
+ */
+class TableCell {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.updateScreenReaderContentsText = () => {
+      this.contentsText = this.el.textContent;
+    };
+    this.onContainerBlur = () => {
+      this.focused = false;
+    };
+    this.onContainerFocus = () => {
+      this.focused = true;
+    };
+    this.alignment = "start";
+    this.colSpan = undefined;
+    this.rowSpan = undefined;
+    this.disabled = undefined;
+    this.numberCell = undefined;
+    this.parentRowIsSelected = undefined;
+    this.parentRowPositionLocalized = undefined;
+    this.parentRowType = undefined;
+    this.positionInRow = undefined;
+    this.readCellContentsToAT = undefined;
+    this.scale = "m";
+    this.selectionCell = undefined;
+    this.messages = undefined;
+    this.messageOverrides = undefined;
+    this.contentsText = "";
+    this.defaultMessages = undefined;
+    this.focused = false;
+    this.selectionText = "";
+    this.effectiveLocale = "";
+  }
+  onSelectedChange() {
+    this.updateScreenReaderSelectionText();
+  }
+  onMessagesChange() {
+    /* wired up by t9n util */
+  }
+  effectiveLocaleChange() {
+    updateMessages(this);
+  }
+  // --------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  // --------------------------------------------------------------------------
+  async componentWillLoad() {
+    setUpLoadableComponent(this);
+    await setUpMessages(this);
+    this.updateScreenReaderContentsText();
+    this.updateScreenReaderSelectionText();
+  }
+  componentDidLoad() {
+    setComponentLoaded(this);
+  }
+  connectedCallback() {
+    connectLocalized(this);
+    connectMessages(this);
+    connectInteractive(this);
+  }
+  componentDidRender() {
+    updateHostInteraction(this);
+  }
+  disconnectedCallback() {
+    disconnectLocalized(this);
+    disconnectMessages(this);
+    disconnectInteractive(this);
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Public Methods
+  //
+  // --------------------------------------------------------------------------
+  /** Sets focus on the component. */
+  async setFocus() {
+    await componentFocusable(this);
+    this.containerEl.focus();
+  }
+  // --------------------------------------------------------------------------
+  //
+  //  Private Methods
+  //
+  // --------------------------------------------------------------------------
+  updateScreenReaderSelectionText() {
+    const selectedText = `${this.messages?.row} ${this.parentRowPositionLocalized} ${this.messages?.selected} ${this.messages?.keyboardDeselect}`;
+    const unselectedText = `${this.messages?.row} ${this.parentRowPositionLocalized} ${this.messages?.unselected} ${this.messages?.keyboardSelect}`;
+    this.selectionText = this.parentRowIsSelected ? selectedText : unselectedText;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Render Methods
+  //
+  //--------------------------------------------------------------------------
+  render() {
+    return (hAsync(Host, null, hAsync("td", { "aria-disabled": this.disabled, class: {
+        [CSS$a.footerCell]: this.parentRowType === "foot",
+        [CSS$a.numberCell]: this.numberCell,
+        [CSS$a.selectionCell]: this.selectionCell,
+        [CSS$a.selectedCell]: this.parentRowIsSelected,
+      }, colSpan: this.colSpan, onBlur: this.onContainerBlur, onFocus: this.onContainerFocus, role: "gridcell", rowSpan: this.rowSpan, tabIndex: this.disabled ? -1 : 0,
+      // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+      ref: (el) => (this.containerEl = el) }, (this.selectionCell || this.readCellContentsToAT) && this.focused && (hAsync("span", { "aria-hidden": true, "aria-live": "polite", class: CSS$a.assistiveText }, this.selectionCell && this.selectionText, this.readCellContentsToAT && !this.selectionCell && this.contentsText)), hAsync("slot", { onSlotchange: this.updateScreenReaderContentsText }))));
+  }
+  static get assetsDirs() { return ["assets"]; }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "parentRowIsSelected": ["onSelectedChange"],
+    "messageOverrides": ["onMessagesChange"],
+    "effectiveLocale": ["effectiveLocaleChange"]
+  }; }
+  static get style() { return tableCellCss; }
+  static get cmpMeta() { return {
+    "$flags$": 9,
+    "$tagName$": "calcite-table-cell",
+    "$members$": {
+      "alignment": [513],
+      "colSpan": [514, "col-span"],
+      "rowSpan": [514, "row-span"],
+      "disabled": [4],
+      "numberCell": [4, "number-cell"],
+      "parentRowIsSelected": [4, "parent-row-is-selected"],
+      "parentRowPositionLocalized": [1, "parent-row-position-localized"],
+      "parentRowType": [1, "parent-row-type"],
+      "positionInRow": [2, "position-in-row"],
+      "readCellContentsToAT": [4, "read-cell-contents-to-a-t"],
+      "scale": [1],
+      "selectionCell": [4, "selection-cell"],
+      "messages": [1040],
+      "messageOverrides": [1040],
+      "contentsText": [32],
+      "defaultMessages": [32],
+      "focused": [32],
+      "selectionText": [32],
+      "effectiveLocale": [32],
+      "setFocus": [64]
+    },
+    "$listeners$": undefined,
+    "$lazyBundleId$": "-",
+    "$attrsToReflect$": [["alignment", "alignment"], ["colSpan", "col-span"], ["rowSpan", "row-span"]]
+  }; }
+}
+
+const CSS$9 = {
+  numberCell: "number-cell",
+  selectionCell: "selection-cell",
+  bodyRow: "body-row",
+  footerRow: "footer-row",
+  heading: "heading",
+  description: "description",
+  multipleSelectionCell: "cell--multiple-selection",
+  assistiveText: "assistive-text",
+  active: "active",
+};
+
+const tableHeaderCss = "/*!@:host*/.sc-calcite-table-header-h{--calcite-internal-table-header-background:var(--calcite-table-header-background, var(--calcite-ui-foreground-2));--calcite-internal-table-header-border-color:var(--calcite-table-border-color, var(--calcite-ui-border-3));display:contents}/*!@:host([alignment=center]) th*/[alignment=center].sc-calcite-table-header-h th.sc-calcite-table-header{text-align:center}/*!@:host([alignment=end]) th*/[alignment=end].sc-calcite-table-header-h th.sc-calcite-table-header{text-align:end}/*!@.assistive-text*/.assistive-text.sc-calcite-table-header{position:absolute;inline-size:1px;block-size:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;border-width:0}/*!@th*/th.sc-calcite-table-header{text-align:start;vertical-align:top;font-weight:var(--calcite-font-weight-medium);color:var(--calcite-ui-text-1);outline-color:transparent;font-size:var(--calcite-internal-table-cell-font-size);border-inline-end:1px solid var(--calcite-internal-table-header-border-color);border-block-end:1px solid var(--calcite-internal-table-header-border-color);padding-block:calc(var(--calcite-internal-table-cell-padding) * 1.5);padding-inline:var(--calcite-internal-table-cell-padding);background-color:var(--calcite-internal-table-header-background)}/*!@th:focus-within*/th.sc-calcite-table-header:focus-within{outline:2px solid var(--calcite-ui-focus-color, var(--calcite-ui-brand));outline-offset:calc(\n            -2px *\n            calc(\n              1 -\n              2 * clamp(\n                0,\n                var(--calcite-ui-focus-offset-invert),\n                1\n              )\n            )\n          )}/*!@th.body-row,\nth.footer-row*/th.body-row.sc-calcite-table-header,th.footer-row.sc-calcite-table-header{vertical-align:middle;border-block-end:0}/*!@th.footer-row*/th.footer-row.sc-calcite-table-header{border-block-start:1px solid var(--calcite-internal-table-header-border-color)}/*!@.cell--multiple-selection*/.cell--multiple-selection.sc-calcite-table-header{cursor:pointer;vertical-align:middle;color:var(--calcite-ui-text-3)}/*!@.number-cell,\n.selection-cell*/.number-cell.sc-calcite-table-header,.selection-cell.sc-calcite-table-header{color:var(--calcite-ui-text-2);inline-size:2rem;min-inline-size:2rem}/*!@.selection-cell calcite-icon.active*/.selection-cell.sc-calcite-table-header calcite-icon.active.sc-calcite-table-header{color:var(--calcite-ui-brand)}/*!@.number-cell calcite-icon,\n.selection-cell calcite-icon*/.number-cell.sc-calcite-table-header calcite-icon.sc-calcite-table-header,.selection-cell.sc-calcite-table-header calcite-icon.sc-calcite-table-header{margin-inline-start:auto;margin-inline-end:auto;vertical-align:middle}/*!@.heading*/.heading.sc-calcite-table-header{color:var(--calcite-ui-text-1)}/*!@.description*/.description.sc-calcite-table-header{color:var(--calcite-ui-text-3);font-size:var(--calcite-internal-table-cell-font-size-secondary)}";
+
+class TableHeader {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.alignment = "start";
+    this.colSpan = undefined;
+    this.description = undefined;
+    this.heading = undefined;
+    this.rowSpan = undefined;
+    this.numberCell = false;
+    this.parentRowPosition = undefined;
+    this.parentRowType = undefined;
+    this.positionInRow = undefined;
+    this.scale = undefined;
+    this.selectedRowCount = undefined;
+    this.selectedRowCountLocalized = undefined;
+    this.selectionCell = false;
+    this.selectionMode = undefined;
+    this.bodyRowCount = undefined;
+    this.messages = undefined;
+    this.messageOverrides = undefined;
+    this.defaultMessages = undefined;
+    this.screenReaderText = "";
+    this.effectiveLocale = "";
+  }
+  onSelectedChange() {
+    this.updateScreenReaderText();
+  }
+  onMessagesChange() {
+    /* wired up by t9n util */
+  }
+  // --------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  // --------------------------------------------------------------------------
+  async componentWillLoad() {
+    setUpLoadableComponent(this);
+    await setUpMessages(this);
+    this.updateScreenReaderText();
+  }
+  componentDidLoad() {
+    setComponentLoaded(this);
+  }
+  connectedCallback() {
+    connectLocalized(this);
+    connectMessages(this);
+  }
+  disconnectedCallback() {
+    disconnectLocalized(this);
+    disconnectMessages(this);
+  }
+  effectiveLocaleChange() {
+    updateMessages(this);
+  }
+  // --------------------------------------------------------------------------
+  //
+  //  Public Methods
+  //
+  // --------------------------------------------------------------------------
+  /** Sets focus on the component. */
+  async setFocus() {
+    await componentFocusable(this);
+    this.containerEl.focus();
+  }
+  // --------------------------------------------------------------------------
+  //
+  //  Private Methods
+  //
+  // --------------------------------------------------------------------------
+  updateScreenReaderText() {
+    let text = "";
+    const sharedText = `${this.selectedRowCountLocalized} ${this.messages?.selected}`;
+    if (this.numberCell) {
+      text = this.messages?.rowNumber;
+    }
+    else if (this.selectionMode === "single") {
+      text = `${this.messages?.selectionColumn}. ${sharedText}`;
+    }
+    else if (this.bodyRowCount === this.selectedRowCount) {
+      text = `${this.messages?.selectionColumn}. ${this.messages?.all} ${sharedText} ${this.messages?.keyboardDeselectAll}`;
+    }
+    else {
+      text = `${this.messages?.selectionColumn}. ${sharedText} ${this.messages?.keyboardSelectAll}`;
+    }
+    this.screenReaderText = text;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Render Methods
+  //
+  //--------------------------------------------------------------------------
+  render() {
+    const scope = this.rowSpan
+      ? "rowgroup"
+      : this.colSpan
+        ? "colgroup"
+        : this.parentRowType === "body"
+          ? "row"
+          : "col";
+    const allSelected = this.selectedRowCount === this.bodyRowCount;
+    const selectionIcon = allSelected ? "check-square-f" : "check-square";
+    return (hAsync(Host, null, hAsync("th", { "aria-colindex": this.parentRowType !== "body" ? this.positionInRow : "", class: {
+        [CSS$9.bodyRow]: this.parentRowType === "body",
+        [CSS$9.footerRow]: this.parentRowType === "foot",
+        [CSS$9.numberCell]: this.numberCell,
+        [CSS$9.selectionCell]: this.selectionCell,
+        [CSS$9.multipleSelectionCell]: this.selectionMode === "multiple",
+      }, colSpan: this.colSpan, role: "columnheader", rowSpan: this.rowSpan, scope: scope, tabIndex: 0,
+      // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+      ref: (el) => (this.containerEl = el) }, this.heading && hAsync("div", { class: CSS$9.heading }, this.heading), this.description && hAsync("div", { class: CSS$9.description }, this.description), this.selectionCell && this.selectionMode === "multiple" && (hAsync("calcite-icon", { class: { [CSS$9.active]: allSelected }, icon: selectionIcon, scale: this.scale === "l" ? "m" : "s" })), (this.selectionCell || this.numberCell) && (hAsync("span", { "aria-hidden": true, "aria-live": "polite", class: CSS$9.assistiveText }, this.screenReaderText)))));
+  }
+  static get assetsDirs() { return ["assets"]; }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "selectedRowCount": ["onSelectedChange"],
+    "selectedRowCountLocalized": ["onSelectedChange"],
+    "messageOverrides": ["onMessagesChange"],
+    "effectiveLocale": ["effectiveLocaleChange"]
+  }; }
+  static get style() { return tableHeaderCss; }
+  static get cmpMeta() { return {
+    "$flags$": 9,
+    "$tagName$": "calcite-table-header",
+    "$members$": {
+      "alignment": [513],
+      "colSpan": [514, "col-span"],
+      "description": [513],
+      "heading": [513],
+      "rowSpan": [514, "row-span"],
+      "numberCell": [4, "number-cell"],
+      "parentRowPosition": [2, "parent-row-position"],
+      "parentRowType": [1, "parent-row-type"],
+      "positionInRow": [2, "position-in-row"],
+      "scale": [1],
+      "selectedRowCount": [2, "selected-row-count"],
+      "selectedRowCountLocalized": [1, "selected-row-count-localized"],
+      "selectionCell": [4, "selection-cell"],
+      "selectionMode": [1, "selection-mode"],
+      "bodyRowCount": [2, "body-row-count"],
+      "messages": [1040],
+      "messageOverrides": [1040],
+      "defaultMessages": [32],
+      "screenReaderText": [32],
+      "effectiveLocale": [32],
+      "setFocus": [64]
+    },
+    "$listeners$": undefined,
+    "$lazyBundleId$": "-",
+    "$attrsToReflect$": [["alignment", "alignment"], ["colSpan", "col-span"], ["description", "description"], ["heading", "heading"], ["rowSpan", "row-span"]]
+  }; }
+}
+
+const tableRowCss = "/*!@:host([disabled])*/[disabled].sc-calcite-table-row-h{cursor:default;-webkit-user-select:none;user-select:none;opacity:var(--calcite-ui-opacity-disabled)}/*!@:host([disabled]) *,\n:host([disabled]) ::slotted(*)*/[disabled].sc-calcite-table-row-h *.sc-calcite-table-row,.sc-calcite-table-row-h[disabled] .sc-calcite-table-row-s>*{pointer-events:none}/*!@:host*/.sc-calcite-table-row-h{--calcite-internal-table-row-background:var(--calcite-table-row-background, var(--calcite-ui-foreground-1));--calcite-internal-table-row-border-color:var(--calcite-table-row-border-color, transparent);display:contents}/*!@:host([hidden])*/[hidden].sc-calcite-table-row-h{display:none}/*!@[hidden]*/[hidden].sc-calcite-table-row{display:none}/*!@:host([disabled]) tr*/[disabled].sc-calcite-table-row-h tr.sc-calcite-table-row{pointer-events:none;opacity:var(--calcite-ui-opacity-disabled)}/*!@:host([disabled]) ::slotted([calcite-hydrated][disabled]),\n:host([disabled]) [calcite-hydrated][disabled]*/.sc-calcite-table-row-h[disabled] .sc-calcite-table-row-s>[calcite-hydrated][disabled],[disabled].sc-calcite-table-row-h [calcite-hydrated][disabled].sc-calcite-table-row{opacity:1}/*!@tr*/tr.sc-calcite-table-row{border-block-end:1px solid var(--calcite-internal-table-row-border-color);background-color:var(--calcite-internal-table-row-background)}";
+
+/**
+ * @slot - A slot for adding `calcite-table-cell` or `calcite-table-header` elements.
+ */
+class TableRow {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.calciteTableRowSelect = createEvent(this, "calciteTableRowSelect", 6);
+    this.calciteInternalTableRowFocusRequest = createEvent(this, "calciteInternalTableRowFocusRequest", 6);
+    this.rowCells = [];
+    this.emitTableRowFocusRequest = (cellPosition, rowPosition, destination, lastCell) => {
+      this.calciteInternalTableRowFocusRequest.emit({
+        cellPosition,
+        rowPosition,
+        destination,
+        lastCell,
+      });
+    };
+    this.updateCells = () => {
+      const slottedCells = this.tableRowSlotEl
+        ?.assignedElements({ flatten: true })
+        ?.filter((el) => el.matches("calcite-table-cell") || el.matches("calcite-table-header"));
+      const renderedCells = Array.from(this.tableRowEl?.querySelectorAll("calcite-table-header, calcite-table-cell"))?.filter((el) => el.numberCell || el.selectionCell);
+      const cells = renderedCells ? renderedCells.concat(slottedCells) : slottedCells;
+      if (cells.length > 0) {
+        cells?.forEach((cell, index) => {
+          cell.positionInRow = index + 1;
+          cell.parentRowType = this.rowType;
+          cell.scale = this.scale;
+          if (cell.nodeName === "CALCITE-TABLE-CELL") {
+            cell.readCellContentsToAT = this.readCellContentsToAT;
+            cell.disabled = this.disabled;
+            cell.parentRowIsSelected = this.selected;
+          }
+        });
+      }
+      this.rowCells =
+        cells || [];
+      this.cellCount = cells?.length;
+    };
+    this.handleSelectionOfRow = () => {
+      this.calciteTableRowSelect.emit();
+    };
+    this.handleKeyboardSelection = (event) => {
+      if (isActivationKey(event.key)) {
+        if (event.key === " ") {
+          event.preventDefault();
+        }
+        this.handleSelectionOfRow();
+      }
+    };
+    this.disabled = false;
+    this.selected = false;
+    this.cellCount = undefined;
+    this.rowType = undefined;
+    this.numbered = false;
+    this.positionSection = undefined;
+    this.positionSectionLocalized = undefined;
+    this.positionAll = undefined;
+    this.readCellContentsToAT = undefined;
+    this.scale = undefined;
+    this.selectionMode = "none";
+    this.selectedRowCount = undefined;
+    this.selectedRowCountLocalized = undefined;
+    this.bodyRowCount = undefined;
+    this.effectiveLocale = "";
+  }
+  handleCellChanges() {
+    if (this.tableRowEl && this.rowCells.length > 0) {
+      this.updateCells();
+    }
+  }
+  handleDelayedCellChanges() {
+    if (this.tableRowEl && this.rowCells.length > 0) {
+      requestAnimationFrame(() => this.updateCells());
+    }
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  componentDidLoad() {
+    if (this.tableRowEl && this.rowCells.length > 0) {
+      this.updateCells();
+    }
+  }
+  connectedCallback() {
+    connectInteractive(this);
+  }
+  componentDidRender() {
+    updateHostInteraction(this);
+  }
+  disconnectedCallback() {
+    disconnectInteractive(this);
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Event Listeners
+  //
+  //--------------------------------------------------------------------------
+  calciteInternalTableRowFocusChangeHandler(event) {
+    if (event.target.contains(this.el)) {
+      const position = event.detail.cellPosition;
+      const rowPosition = event.detail.rowPosition;
+      const destination = event.detail.destination;
+      const lastCell = event.detail.lastCell;
+      if (rowPosition === this.positionAll) {
+        if (this.disabled) {
+          const deflectDirection = destination === "last" ? "previous" : destination === "first" ? "next" : destination;
+          this.emitTableRowFocusRequest(position, this.positionAll, deflectDirection);
+          return;
+        }
+        const cellPosition = lastCell
+          ? this.rowCells[this.rowCells.length - 1]
+          : this.rowCells?.find((_, index) => index + 1 === position);
+        if (cellPosition) {
+          cellPosition.setFocus();
+        }
+      }
+    }
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Private Methods
+  //
+  //--------------------------------------------------------------------------
+  keyDownHandler(event) {
+    const el = event.target;
+    const key = event.key;
+    const isControl = event.ctrlKey;
+    const cells = this.rowCells;
+    if (el.matches("calcite-table-cell") || el.matches("calcite-table-header")) {
+      switch (key) {
+        case "ArrowUp":
+          this.emitTableRowFocusRequest(el.positionInRow, this.positionAll, "previous");
+          event.preventDefault();
+          break;
+        case "ArrowDown":
+          this.emitTableRowFocusRequest(el.positionInRow, this.positionAll, "next");
+          event.preventDefault();
+          break;
+        case "PageUp":
+          this.emitTableRowFocusRequest(el.positionInRow, this.positionAll, "first");
+          event.preventDefault();
+          break;
+        case "PageDown":
+          this.emitTableRowFocusRequest(el.positionInRow, this.positionAll, "last");
+          event.preventDefault();
+          break;
+        case "ArrowLeft":
+          focusElementInGroup(cells, el, "previous", false);
+          event.preventDefault();
+          break;
+        case "ArrowRight":
+          focusElementInGroup(cells, el, "next", false);
+          event.preventDefault();
+          break;
+        case "Home":
+          if (isControl) {
+            this.emitTableRowFocusRequest(1, this.positionAll, "first");
+            event.preventDefault();
+          }
+          else {
+            focusElementInGroup(cells, el, "first", false);
+            event.preventDefault();
+          }
+          break;
+        case "End":
+          if (isControl) {
+            this.emitTableRowFocusRequest(this.rowCells?.length, this.positionAll, "last", true);
+            event.preventDefault();
+          }
+          else {
+            focusElementInGroup(cells, el, "last", false);
+            event.preventDefault();
+          }
+          break;
+      }
+    }
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Render Methods
+  //
+  //--------------------------------------------------------------------------
+  renderSelectionIcon() {
+    const icon = this.selectionMode === "multiple" && this.selected
+      ? "check-square-f"
+      : this.selectionMode === "multiple"
+        ? "square"
+        : this.selected
+          ? "circle-f"
+          : "circle";
+    return hAsync("calcite-icon", { icon: icon, scale: this.scale === "l" ? "m" : "s" });
+  }
+  renderSelectableCell() {
+    return this.rowType === "head" ? (hAsync("calcite-table-header", { alignment: "center", bodyRowCount: this.bodyRowCount, key: "selection-head", onClick: this.selectionMode === "multiple" && this.handleSelectionOfRow, onKeyDown: this.selectionMode === "multiple" && this.handleKeyboardSelection, selectedRowCount: this.selectedRowCount, selectedRowCountLocalized: this.selectedRowCountLocalized, selectionCell: true, selectionMode: this.selectionMode })) : this.rowType === "body" ? (hAsync("calcite-table-cell", { alignment: "center", key: "selection-body", onClick: this.handleSelectionOfRow, onKeyDown: this.handleKeyboardSelection, parentRowIsSelected: this.selected, parentRowPositionLocalized: this.positionSectionLocalized, selectionCell: true }, this.renderSelectionIcon())) : (hAsync("calcite-table-cell", { alignment: "center", key: "selection-foot", selectionCell: true }));
+  }
+  renderNumberedCell() {
+    return this.rowType === "head" ? (hAsync("calcite-table-header", { alignment: "center", key: "numbered-head", numberCell: true })) : this.rowType === "body" ? (hAsync("calcite-table-cell", { alignment: "center", key: "numbered-body", numberCell: true }, this.positionSectionLocalized)) : (hAsync("calcite-table-cell", { alignment: "center", key: "numbered-foot", numberCell: true }));
+  }
+  render() {
+    return (hAsync(Host, null, hAsync("tr", { "aria-disabled": this.disabled, "aria-rowindex": this.positionAll + 1, "aria-selected": this.selected, onKeyDown: (event) => this.keyDownHandler(event),
+      // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+      ref: (el) => (this.tableRowEl = el) }, this.numbered && this.renderNumberedCell(), this.selectionMode !== "none" && this.renderSelectableCell(), hAsync("slot", { onSlotchange: this.updateCells, ref: (el) => (this.tableRowSlotEl = el) }))));
+  }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "bodyRowCount": ["handleCellChanges"],
+    "scale": ["handleCellChanges"],
+    "selected": ["handleCellChanges"],
+    "selectedRowCount": ["handleCellChanges"],
+    "numbered": ["handleDelayedCellChanges"],
+    "selectionMode": ["handleDelayedCellChanges"]
+  }; }
+  static get style() { return tableRowCss; }
+  static get cmpMeta() { return {
+    "$flags$": 9,
+    "$tagName$": "calcite-table-row",
+    "$members$": {
+      "disabled": [516],
+      "selected": [516],
+      "cellCount": [1026, "cell-count"],
+      "rowType": [1, "row-type"],
+      "numbered": [4],
+      "positionSection": [2, "position-section"],
+      "positionSectionLocalized": [1, "position-section-localized"],
+      "positionAll": [2, "position-all"],
+      "readCellContentsToAT": [4, "read-cell-contents-to-a-t"],
+      "scale": [1],
+      "selectionMode": [1, "selection-mode"],
+      "selectedRowCount": [2, "selected-row-count"],
+      "selectedRowCountLocalized": [1, "selected-row-count-localized"],
+      "bodyRowCount": [2, "body-row-count"],
+      "effectiveLocale": [32]
+    },
+    "$listeners$": [[4, "calciteInternalTableRowFocusChange", "calciteInternalTableRowFocusChangeHandler"]],
+    "$lazyBundleId$": "-",
+    "$attrsToReflect$": [["disabled", "disabled"], ["selected", "selected"]]
+  }; }
+}
+
 const SLOTS$5 = {
   titleGroup: "title-group",
 };
@@ -44373,19 +45230,19 @@ class ValueListItem {
   renderActionsEnd() {
     const { el } = this;
     const hasActionsEnd = getSlotted(el, SLOTS.actionsEnd);
-    return hasActionsEnd ? (hAsync("slot", { name: SLOTS.actionsEnd, slot: SLOTS$a.actionsEnd })) : null;
+    return hasActionsEnd ? (hAsync("slot", { name: SLOTS.actionsEnd, slot: SLOTS$b.actionsEnd })) : null;
   }
   renderActionsStart() {
     const { el } = this;
     const hasActionsStart = getSlotted(el, SLOTS.actionsStart);
-    return hasActionsStart ? (hAsync("slot", { name: SLOTS.actionsStart, slot: SLOTS$a.actionsStart })) : null;
+    return hasActionsStart ? (hAsync("slot", { name: SLOTS.actionsStart, slot: SLOTS$b.actionsStart })) : null;
   }
   renderHandle() {
     const { icon, iconFlipRtl } = this;
     if (icon === ICON_TYPES$1.grip) {
       return (hAsync("span", { class: {
-          [CSS$n.handle]: true,
-          [CSS$n.handleActivated]: this.handleActivated,
+          [CSS$q.handle]: true,
+          [CSS$q.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" })));
     }
   }
@@ -44510,6 +45367,10 @@ registerComponents([
   Tab,
   TabNav,
   TabTitle,
+  Table,
+  TableCell,
+  TableHeader,
+  TableRow,
   Tabs,
   TextArea,
   Tile,