@esri/solutions-components 0.8.5 → 0.8.6-6.2

package/dist/esm/calcite-combobox_3.entry.js

@@ -0,0 +1,2202 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { h, r as registerInstance, c as createEvent, H as Host, g as getElement, f as forceUpdate } from './index-e3f04fa1.js';
+import { d as calciteSize48 } from './core-6a3c13ac.js';
+import { f as filter } from './filter-d09ea2a2.js';
+import { A as getElementWidth, B as getTextWidth, t as toAriaBoolean, i as isPrimaryPointerButton, u as intersects } from './dom-d675fe65.js';
+import { d as defaultMenuPlacement, f as filterComputedPlacements, c as connectFloatingUI, r as reposition, a as disconnectFloatingUI, F as FloatingCSS } from './floating-ui-3e149d85.js';
+import { s as submitForm, c as connectForm, a as afterConnectDefaultValueSet, d as disconnectForm, H as HiddenFormInputSlot } from './form-8b2f6210.js';
+import { g as guid } from './guid-f05d01d5.js';
+import { c as connectInteractive, u as updateHostInteraction, d as disconnectInteractive, I as InteractiveContainer } from './interactive-2e2d102f.js';
+import { c as connectLabel, d as disconnectLabel, g as getLabelText } from './label-5692de01.js';
+import { b as componentLoaded, c as componentFocusable, s as setUpLoadableComponent, a as setComponentLoaded } from './loadable-01033497.js';
+import { c as connectLocalized, d as disconnectLocalized, n as numberStringFormatter } from './locale-60861d67.js';
+import { c as createObserver } from './observers-fdb7a374.js';
+import { o as onToggleOpenCloseComponent } from './openCloseComponent-1fbfcd2f.js';
+import { c as connectMessages, s as setUpMessages, d as disconnectMessages, u as updateMessages } from './t9n-5800da82.js';
+import { g as getIconScale } from './component-960ddabf.js';
+import { V as Validation } from './Validation-cc8dc911.js';
+import { i as isSingleLike, h as hasActiveChildren, C as CSS$2, b as ComboboxChildSelector, c as getItemAncestors, d as getItemChildren, e as ComboboxItem, f as ComboboxItemGroup } from './utils-e4ed10d3.js';
+import { d as debounce } from './debounce-6e9ade8c.js';
+import { i as isActivationKey } from './key-092b6260.js';
+import { d as decimalPlaces, c as clamp } from './math-81650811.js';
+import './resources-1febf4c6.js';
+import './browser-7fe78178.js';
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v2.8.2
+ */
+const CSS$1 = {
+    button: "x-button",
+};
+function XButton({ disabled, key, label, onClick, ref, scale, }) {
+    return (h("button", { "aria-label": label, class: CSS$1.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 }, h("calcite-icon", { icon: "x", scale: getIconScale(scale) })));
+}
+
+const comboboxCss = ":host([disabled]){cursor:default;-webkit-user-select:none;-moz-user-select:none;user-select:none;opacity:var(--calcite-opacity-disabled)}:host([disabled]) *,:host([disabled]) ::slotted(*){pointer-events:none}:host{position:relative;display:block}:host([disabled]) ::slotted([calcite-hydrated][disabled]),:host([disabled]) [calcite-hydrated][disabled]{opacity:1}.interaction-container{display:contents}:host([scale=s]) .x-button{inline-size:1rem;block-size:1rem}:host([scale=m]) .x-button{inline-size:1.5rem;block-size:1.5rem}:host([scale=l]) .x-button{inline-size:2rem;block-size:2rem}.x-button{margin:0px;display:flex;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;align-content:center;align-items:center;justify-content:center;align-self:center;border-width:2px;background-color:transparent;color:var(--calcite-color-text-3);outline-color:transparent;transition:background-color, block-size, border-color, box-shadow, color, inset-block-end, inset-block-start, inset-inline-end, inset-inline-start inset-size, opacity, outline-color, transform var(--calcite-animation-timing) ease-in-out 0s, outline 0s, outline-offset 0s;border-radius:50%;border-color:transparent;background-color:var(--calcite-color-foreground-2)}.x-button:active,.x-button:hover{color:var(--calcite-color-text-1);background-color:var(--calcite-color-foreground-3)}.x-button:active{border-style:solid;border-color:var(--calcite-color-brand)}.x-button calcite-icon{color:inherit}:host([scale=s]){font-size:var(--calcite-font-size--2);--calcite-combobox-item-spacing-unit-l:0.5rem;--calcite-combobox-item-spacing-unit-s:0.25rem;--calcite-combobox-input-height:1rem;--calcite-internal-combobox-input-margin-block:calc(0.25rem - 1px)}:host([scale=s]) .x-button{margin-inline:0.5rem}:host([scale=m]){font-size:var(--calcite-font-size--1);--calcite-combobox-item-spacing-unit-l:0.75rem;--calcite-combobox-item-spacing-unit-s:0.5rem;--calcite-combobox-input-height:1rem;--calcite-internal-combobox-input-margin-block:calc(0.5rem - 1px)}:host([scale=m]) .x-button{margin-inline-end:0.75rem}:host([scale=l]){font-size:var(--calcite-font-size-0);--calcite-combobox-item-spacing-unit-l:1rem;--calcite-combobox-item-spacing-unit-s:0.75rem;--calcite-combobox-input-height:1.5rem;--calcite-internal-combobox-input-margin-block:calc(0.625rem - 1px)}:host([scale=l]) .x-button{margin-inline-end:1rem}.wrapper{display:flex;border-width:1px;border-style:solid;border-color:var(--calcite-color-border-input);background-color:var(--calcite-color-foreground-1);color:var(--calcite-color-text-1);outline-color:transparent;padding-block:calc(var(--calcite-combobox-item-spacing-unit-s) / 4);padding-inline:var(--calcite-combobox-item-spacing-unit-l)}.wrapper:hover .icon{color:var(--calcite-color-text-1)}:host(:focus-within) .wrapper,.wrapper--active{outline:2px solid var(--calcite-ui-focus-color, var(--calcite-color-brand));outline-offset:calc(\n            -2px *\n            calc(\n              1 -\n              2 * clamp(\n                0,\n                var(--calcite-offset-invert-focus),\n                1\n              )\n            )\n          )}:host([read-only]) .wrapper{background-color:var(--calcite-color-background)}:host([read-only]) .label{font-weight:var(--calcite-font-weight-medium)}:host([status=invalid]) .wrapper{border-color:var(--calcite-color-status-danger)}:host([status=invalid]:focus-within) .wrapper{outline:2px solid var(--calcite-color-status-danger);outline-offset:calc(\n            -2px *\n            calc(\n              1 -\n              2 * clamp(\n                0,\n                var(--calcite-offset-invert-focus),\n                1\n              )\n            )\n          )}.wrapper--single{padding-block:0;padding-inline:var(--calcite-combobox-item-spacing-unit-l);cursor:pointer;flex-wrap:nowrap}.grid-input{position:relative;display:flex;flex-grow:1;flex-wrap:wrap;align-items:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;padding:0px;gap:var(--calcite-combobox-item-spacing-unit-s);margin-inline-end:var(--calcite-combobox-item-spacing-unit-s)}.grid-input.selection-display-fit,.grid-input.selection-display-single{flex-wrap:nowrap;overflow:hidden}.input{flex-grow:1;-webkit-appearance:none;-moz-appearance:none;appearance:none;overflow:hidden;text-overflow:ellipsis;border-style:none;background-color:transparent;padding:0px;font-family:inherit;color:var(--calcite-color-text-1);font-size:inherit;block-size:var(--calcite-combobox-input-height);line-height:var(--calcite-combobox-input-height);inline-size:100%;margin-block-end:var(--calcite-combobox-item-spacing-unit-s);min-inline-size:4.8125rem}.input:focus{outline:2px solid transparent;outline-offset:2px}.input:-moz-placeholder-shown{text-overflow:ellipsis}.input:placeholder-shown{text-overflow:ellipsis}.input--transparent{opacity:0}.input--single{padding:0px;margin-block:var(--calcite-internal-combobox-input-margin-block)}.wrapper--active .input-single{cursor:text}.input--hidden{pointer-events:none;inline-size:0px;min-inline-size:0px;opacity:0}.input--icon{padding-block:0;padding-inline:var(--calcite-combobox-item-spacing-unit-l)}.input-wrap{display:flex;flex-grow:1;align-items:center}.input-wrap--single{flex:1 1 0%;overflow:hidden}.label{pointer-events:none;max-inline-size:100%;flex:1 1 auto;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;padding:0px;font-weight:var(--calcite-font-weight-normal);block-size:var(--calcite-combobox-input-height);line-height:var(--calcite-combobox-input-height)}.label--icon{padding-inline:var(--calcite-combobox-item-spacing-unit-l)}.icon-end,.icon-start{display:flex;cursor:pointer;align-items:center}.icon-end{flex:none}.icon-end .icon{color:var(--calcite-color-text-3)}.floating-ui-container{--calcite-floating-ui-z-index:var(--calcite-z-index-dropdown);display:block;position:absolute;z-index:var(--calcite-floating-ui-z-index);visibility:hidden}.floating-ui-container .calcite-floating-ui-anim{position:relative;transition:var(--calcite-floating-ui-transition);transition-property:transform, visibility, opacity;opacity:0;box-shadow:0 0 16px 0 rgba(0, 0, 0, 0.16);z-index:var(--calcite-z-index);border-radius:0.25rem}.floating-ui-container[data-placement^=bottom] .calcite-floating-ui-anim{transform:translateY(-5px)}.floating-ui-container[data-placement^=top] .calcite-floating-ui-anim{transform:translateY(5px)}.floating-ui-container[data-placement^=left] .calcite-floating-ui-anim{transform:translateX(5px)}.floating-ui-container[data-placement^=right] .calcite-floating-ui-anim{transform:translateX(-5px)}.floating-ui-container[data-placement] .calcite-floating-ui-anim--active{opacity:1;transform:translate(0)}.floating-ui-container--active{visibility:visible}@media (forced-colors: active){.wrapper,.floating-ui-container--active{border:1px solid canvasText}}.screen-readers-only{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}.list-container{max-block-size:45vh;overflow-y:auto;background-color:var(--calcite-color-foreground-1);inline-size:var(--calcite-dropdown-width)}.list{margin:0px;display:block;padding:0px}.list--hide{block-size:0px;overflow:hidden}calcite-chip{--calcite-animation-timing:0}.chip{margin-block:calc(var(--calcite-combobox-item-spacing-unit-s) / 4);max-inline-size:100%}.chip--active{background-color:var(--calcite-color-foreground-3)}.chip--invisible{visibility:hidden;position:absolute}.item{display:block}.validation-container{display:flex;flex-direction:column;align-items:flex-start;align-self:stretch}:host([scale=m]) .validation-container,:host([scale=l]) .validation-container{padding-block-start:0.5rem}:host([scale=s]) .validation-container{padding-block-start:0.25rem}::slotted(input[slot=hidden-form-input]){margin:0 !important;opacity:0 !important;outline:none !important;padding:0 !important;position:absolute !important;inset:0 !important;transform:none !important;-webkit-appearance:none !important;z-index:-1 !important}:host([hidden]){display:none}[hidden]{display:none}::slotted(calcite-combobox-item-group:not(:first-child)){padding-block-start:var(--calcite-combobox-item-spacing-unit-l)}";
+const CalciteComboboxStyle0 = comboboxCss;
+
+const isGroup = (el) => el.tagName === ComboboxItemGroup;
+const itemUidPrefix = "combobox-item-";
+const chipUidPrefix = "combobox-chip-";
+const labelUidPrefix = "combobox-label-";
+const listboxUidPrefix = "combobox-listbox-";
+const inputUidPrefix = "combobox-input-";
+const Combobox = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.calciteComboboxChange = createEvent(this, "calciteComboboxChange", 6);
+        this.calciteComboboxFilterChange = createEvent(this, "calciteComboboxFilterChange", 6);
+        this.calciteComboboxChipClose = createEvent(this, "calciteComboboxChipClose", 6);
+        this.calciteComboboxBeforeClose = createEvent(this, "calciteComboboxBeforeClose", 6);
+        this.calciteComboboxClose = createEvent(this, "calciteComboboxClose", 6);
+        this.calciteComboboxBeforeOpen = createEvent(this, "calciteComboboxBeforeOpen", 6);
+        this.calciteComboboxOpen = createEvent(this, "calciteComboboxOpen", 6);
+        this.placement = defaultMenuPlacement;
+        this.internalValueChangeFlag = false;
+        this.textInput = null;
+        this.mutationObserver = createObserver("mutation", () => this.updateItems());
+        this.resizeObserver = createObserver("resize", () => {
+            this.setMaxScrollerHeight();
+            this.refreshSelectionDisplay();
+        });
+        this.guid = guid();
+        this.inputHeight = 0;
+        this.ignoreSelectedEventsFlag = false;
+        this.openTransitionProp = "opacity";
+        this.setFilteredPlacements = () => {
+            const { el, flipPlacements } = this;
+            this.filteredFlipPlacements = flipPlacements
+                ? filterComputedPlacements(flipPlacements, el)
+                : null;
+        };
+        this.getValue = () => {
+            const items = this.selectedItems.map((item) => { var _a; return (_a = item === null || item === void 0 ? void 0 : item.value) === null || _a === void 0 ? void 0 : _a.toString(); });
+            return (items === null || items === void 0 ? void 0 : items.length) ? (items.length > 1 ? items : items[0]) : "";
+        };
+        this.onLabelClick = () => {
+            this.setFocus();
+        };
+        this.keyDownHandler = (event) => {
+            if (this.readOnly) {
+                return;
+            }
+            const { key } = event;
+            switch (key) {
+                case "Tab":
+                    this.activeChipIndex = -1;
+                    this.activeItemIndex = -1;
+                    if (this.allowCustomValues && this.text) {
+                        this.addCustomChip(this.text, true);
+                        event.preventDefault();
+                    }
+                    else if (this.open) {
+                        this.open = false;
+                        event.preventDefault();
+                    }
+                    else if (!this.allowCustomValues && this.text) {
+                        this.clearInputValue();
+                        this.filterItems("");
+                        this.updateActiveItemIndex(-1);
+                    }
+                    break;
+                case "ArrowLeft":
+                    this.previousChip();
+                    event.preventDefault();
+                    break;
+                case "ArrowRight":
+                    this.nextChip();
+                    event.preventDefault();
+                    break;
+                case "ArrowUp":
+                    event.preventDefault();
+                    if (this.open) {
+                        this.shiftActiveItemIndex(-1);
+                    }
+                    if (!this.comboboxInViewport()) {
+                        this.el.scrollIntoView();
+                    }
+                    break;
+                case "ArrowDown":
+                    event.preventDefault();
+                    if (this.open) {
+                        this.shiftActiveItemIndex(1);
+                    }
+                    else {
+                        this.open = true;
+                        this.ensureRecentSelectedItemIsActive();
+                    }
+                    if (!this.comboboxInViewport()) {
+                        this.el.scrollIntoView();
+                    }
+                    break;
+                case " ":
+                    if (!this.textInput.value && !event.defaultPrevented) {
+                        if (!this.open) {
+                            this.open = true;
+                            this.shiftActiveItemIndex(1);
+                        }
+                        event.preventDefault();
+                    }
+                    break;
+                case "Home":
+                    if (!this.open) {
+                        return;
+                    }
+                    event.preventDefault();
+                    this.updateActiveItemIndex(0);
+                    this.scrollToActiveItem();
+                    if (!this.comboboxInViewport()) {
+                        this.el.scrollIntoView();
+                    }
+                    break;
+                case "End":
+                    if (!this.open) {
+                        return;
+                    }
+                    event.preventDefault();
+                    this.updateActiveItemIndex(this.filteredItems.length - 1);
+                    this.scrollToActiveItem();
+                    if (!this.comboboxInViewport()) {
+                        this.el.scrollIntoView();
+                    }
+                    break;
+                case "Escape":
+                    if (!this.clearDisabled && !this.open) {
+                        this.clearValue();
+                    }
+                    this.open = false;
+                    event.preventDefault();
+                    break;
+                case "Enter":
+                    if (this.open && this.activeItemIndex > -1) {
+                        this.toggleSelection(this.filteredItems[this.activeItemIndex]);
+                        event.preventDefault();
+                    }
+                    else if (this.activeChipIndex > -1) {
+                        this.removeActiveChip();
+                        event.preventDefault();
+                    }
+                    else if (this.allowCustomValues && this.text) {
+                        this.addCustomChip(this.text, true);
+                        event.preventDefault();
+                    }
+                    else if (!event.defaultPrevented) {
+                        if (submitForm(this)) {
+                            event.preventDefault();
+                        }
+                    }
+                    break;
+                case "Delete":
+                case "Backspace":
+                    const notDeletable = this.selectionDisplay === "single" ||
+                        (this.selectionDisplay === "fit" && this.selectedHiddenChipsCount > 0);
+                    if (notDeletable) {
+                        return;
+                    }
+                    if (this.activeChipIndex > -1) {
+                        event.preventDefault();
+                        this.removeActiveChip();
+                    }
+                    else if (!this.text && this.isMulti()) {
+                        event.preventDefault();
+                        this.removeLastChip();
+                    }
+                    break;
+            }
+        };
+        this.toggleCloseEnd = () => {
+            this.open = false;
+            this.el.removeEventListener("calciteComboboxClose", this.toggleCloseEnd);
+        };
+        this.toggleOpenEnd = () => {
+            this.open = false;
+            this.el.removeEventListener("calciteComboboxOpen", this.toggleOpenEnd);
+        };
+        this.setMaxScrollerHeight = async () => {
+            const { listContainerEl, open, referenceEl } = this;
+            if (!listContainerEl || !open) {
+                return;
+            }
+            await this.reposition(true);
+            const maxScrollerHeight = this.getMaxScrollerHeight();
+            listContainerEl.style.maxHeight = maxScrollerHeight > 0 ? `${maxScrollerHeight}px` : "";
+            listContainerEl.style.minWidth = `${referenceEl.clientWidth}px`;
+            await this.reposition(true);
+        };
+        this.calciteChipCloseHandler = (comboboxItem) => {
+            this.open = false;
+            const selection = this.items.find((item) => item === comboboxItem);
+            if (selection) {
+                this.toggleSelection(selection, false);
+            }
+            this.calciteComboboxChipClose.emit();
+        };
+        this.clickHandler = (event) => {
+            if (this.readOnly) {
+                return;
+            }
+            const composedPath = event.composedPath();
+            if (composedPath.some((node) => node.tagName === "CALCITE-CHIP")) {
+                this.open = false;
+                event.preventDefault();
+                return;
+            }
+            if (composedPath.some((node) => { var _a; return (_a = node.classList) === null || _a === void 0 ? void 0 : _a.contains(CSS$1.button); })) {
+                this.clearValue();
+                event.preventDefault();
+                return;
+            }
+            this.open = !this.open;
+            this.ensureRecentSelectedItemIsActive();
+        };
+        this.refreshSelectionDisplay = async () => {
+            await componentLoaded(this);
+            if (isSingleLike(this.selectionMode)) {
+                return;
+            }
+            if (!this.textInput) {
+                return;
+            }
+            const { allSelectedIndicatorChipEl, chipContainerEl, selectionDisplay, placeholder, selectedIndicatorChipEl, textInput, } = this;
+            const chipContainerElGap = parseInt(getComputedStyle(chipContainerEl).gap.replace("px", ""));
+            const chipContainerElWidth = getElementWidth(chipContainerEl);
+            const { fontSize, fontFamily } = getComputedStyle(textInput);
+            const inputTextWidth = getTextWidth(placeholder, `${fontSize} ${fontFamily}`);
+            const inputWidth = (inputTextWidth || parseInt(calciteSize48)) + chipContainerElGap;
+            const allSelectedIndicatorChipElWidth = getElementWidth(allSelectedIndicatorChipEl);
+            const selectedIndicatorChipElWidth = getElementWidth(selectedIndicatorChipEl);
+            const largestSelectedIndicatorChipWidth = Math.max(allSelectedIndicatorChipElWidth, selectedIndicatorChipElWidth);
+            this.setCompactSelectionDisplay({
+                chipContainerElGap,
+                chipContainerElWidth,
+                inputWidth,
+                largestSelectedIndicatorChipWidth,
+            });
+            if (selectionDisplay === "fit") {
+                const chipEls = Array.from(this.el.shadowRoot.querySelectorAll("calcite-chip")).filter((chipEl) => chipEl.closable);
+                const availableHorizontalChipElSpace = Math.round(chipContainerElWidth -
+                    ((this.selectedHiddenChipsCount > 0 ? selectedIndicatorChipElWidth : 0) +
+                        chipContainerElGap +
+                        inputWidth +
+                        chipContainerElGap));
+                this.refreshChipDisplay({ availableHorizontalChipElSpace, chipContainerElGap, chipEls });
+                this.setVisibleAndHiddenChips(chipEls);
+            }
+        };
+        this.setFloatingEl = (el) => {
+            this.floatingEl = el;
+            connectFloatingUI(this, this.referenceEl, this.floatingEl);
+        };
+        this.setContainerEl = (el) => {
+            this.resizeObserver.observe(el);
+            this.listContainerEl = el;
+            this.transitionEl = el;
+        };
+        this.setChipContainerEl = (el) => {
+            this.resizeObserver.observe(el);
+            this.chipContainerEl = el;
+        };
+        this.setReferenceEl = (el) => {
+            this.referenceEl = el;
+            connectFloatingUI(this, this.referenceEl, this.floatingEl);
+        };
+        this.setAllSelectedIndicatorChipEl = (el) => {
+            this.allSelectedIndicatorChipEl = el;
+        };
+        this.setSelectedIndicatorChipEl = (el) => {
+            this.selectedIndicatorChipEl = el;
+        };
+        this.inputHandler = (event) => {
+            const value = event.target.value;
+            this.text = value;
+            this.filterItems(value);
+            if (value) {
+                this.activeChipIndex = -1;
+            }
+        };
+        this.filterItems = (() => {
+            const find = (item, filteredData) => item &&
+                filteredData.some(({ label, value }) => isGroup(item) ? label === item.label : value === item.value && label === item.textLabel);
+            return debounce((text) => {
+                const filteredData = filter(this.data, text);
+                const itemsAndGroups = this.getItemsAndGroups();
+                itemsAndGroups.forEach((item) => {
+                    const hidden = !find(item, filteredData);
+                    item.hidden = hidden;
+                    const [parent, grandparent] = item.ancestors;
+                    if (find(parent, filteredData) || find(grandparent, filteredData)) {
+                        item.hidden = false;
+                    }
+                    if (!hidden) {
+                        item.ancestors.forEach((ancestor) => (ancestor.hidden = false));
+                    }
+                });
+                this.filteredItems = this.getFilteredItems();
+                this.calciteComboboxFilterChange.emit();
+            }, 100);
+        })();
+        this.internalComboboxChangeEvent = () => {
+            this.calciteComboboxChange.emit();
+        };
+        this.emitComboboxChange = debounce(this.internalComboboxChangeEvent, 0);
+        this.getSelectedItems = () => {
+            if (!this.isMulti()) {
+                const match = this.items.find(({ selected }) => selected);
+                return match ? [match] : [];
+            }
+            return (this.items
+                .filter((item) => item.selected && (this.selectionMode !== "ancestors" || !hasActiveChildren(item)))
+                /** Preserve order of entered tags */
+                .sort((a, b) => {
+                const aIdx = this.selectedItems.indexOf(a);
+                const bIdx = this.selectedItems.indexOf(b);
+                if (aIdx > -1 && bIdx > -1) {
+                    return aIdx - bIdx;
+                }
+                return bIdx - aIdx;
+            }));
+        };
+        this.updateItems = () => {
+            this.items = this.getItems();
+            this.groupItems = this.getGroupItems();
+            this.data = this.getData();
+            this.selectedItems = this.getSelectedItems();
+            this.filteredItems = this.getFilteredItems();
+            this.needsIcon = this.getNeedsIcon();
+            this.items.forEach((item) => {
+                item.selectionMode = this.selectionMode;
+                item.scale = this.scale;
+            });
+            if (!this.allowCustomValues) {
+                this.setMaxScrollerHeight();
+            }
+            this.groupItems.forEach((groupItem, index, items) => {
+                if (index === 0) {
+                    groupItem.afterEmptyGroup = false;
+                }
+                const nextGroupItem = items[index + 1];
+                if (nextGroupItem) {
+                    nextGroupItem.afterEmptyGroup = groupItem.children.length === 0;
+                }
+            });
+        };
+        this.scrollToActiveItem = () => {
+            const activeItem = this.filteredItems[this.activeItemIndex];
+            if (!activeItem) {
+                return;
+            }
+            const height = this.calculateSingleItemHeight(activeItem);
+            const { offsetHeight, scrollTop } = this.listContainerEl;
+            if (offsetHeight + scrollTop < activeItem.offsetTop + height) {
+                this.listContainerEl.scrollTop = activeItem.offsetTop - offsetHeight + height;
+            }
+            else if (activeItem.offsetTop < scrollTop) {
+                this.listContainerEl.scrollTop = activeItem.offsetTop;
+            }
+        };
+        this.comboboxFocusHandler = () => {
+            var _a;
+            if (this.disabled) {
+                return;
+            }
+            (_a = this.textInput) === null || _a === void 0 ? void 0 : _a.focus();
+        };
+        this.clearDisabled = false;
+        this.selectionDisplay = "all";
+        this.open = false;
+        this.disabled = false;
+        this.form = undefined;
+        this.label = undefined;
+        this.placeholder = undefined;
+        this.placeholderIcon = undefined;
+        this.placeholderIconFlipRtl = false;
+        this.maxItems = 0;
+        this.validationMessage = undefined;
+        this.validationIcon = undefined;
+        this.validity = {
+            valid: false,
+            badInput: false,
+            customError: false,
+            patternMismatch: false,
+            rangeOverflow: false,
+            rangeUnderflow: false,
+            stepMismatch: false,
+            tooLong: false,
+            tooShort: false,
+            typeMismatch: false,
+            valueMissing: false,
+        };
+        this.name = undefined;
+        this.allowCustomValues = undefined;
+        this.overlayPositioning = "absolute";
+        this.required = false;
+        this.selectionMode = "multiple";
+        this.scale = "m";
+        this.status = "idle";
+        this.value = null;
+        this.flipPlacements = undefined;
+        this.messages = undefined;
+        this.messageOverrides = undefined;
+        this.selectedItems = [];
+        this.filteredItems = [];
+        this.readOnly = false;
+        this.items = [];
+        this.groupItems = [];
+        this.needsIcon = undefined;
+        this.activeItemIndex = -1;
+        this.activeChipIndex = -1;
+        this.activeDescendant = "";
+        this.compactSelectionDisplay = false;
+        this.selectedHiddenChipsCount = 0;
+        this.selectedVisibleChipsCount = 0;
+        this.text = "";
+        this.effectiveLocale = undefined;
+        this.defaultMessages = undefined;
+    }
+    openHandler() {
+        onToggleOpenCloseComponent(this);
+        if (this.disabled) {
+            this.open = false;
+            return;
+        }
+        this.setMaxScrollerHeight();
+    }
+    handleDisabledChange(value) {
+        if (!value) {
+            this.open = false;
+        }
+    }
+    maxItemsHandler() {
+        this.setMaxScrollerHeight();
+    }
+    overlayPositioningHandler() {
+        this.reposition(true);
+    }
+    handlePropsChange() {
+        this.updateItems();
+    }
+    valueHandler(value) {
+        if (!this.internalValueChangeFlag) {
+            const items = this.getItems();
+            if (Array.isArray(value)) {
+                items.forEach((item) => (item.selected = value.includes(item.value)));
+            }
+            else if (value) {
+                items.forEach((item) => (item.selected = value === item.value));
+            }
+            else {
+                items.forEach((item) => (item.selected = false));
+            }
+            this.updateItems();
+        }
+    }
+    onMessagesChange() {
+        /*  wired up by t9n util */
+    }
+    flipPlacementsHandler() {
+        this.setFilteredPlacements();
+        this.reposition(true);
+    }
+    selectedItemsHandler() {
+        this.internalValueChangeFlag = true;
+        this.value = this.getValue();
+        this.internalValueChangeFlag = false;
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Event Listeners
+    //
+    //--------------------------------------------------------------------------
+    documentClickHandler(event) {
+        if (this.disabled) {
+            return;
+        }
+        const composedPath = event.composedPath();
+        if (composedPath.includes(this.el) || composedPath.includes(this.referenceEl)) {
+            return;
+        }
+        if (!this.allowCustomValues && this.textInput.value) {
+            this.clearInputValue();
+            this.filterItems("");
+            this.updateActiveItemIndex(-1);
+        }
+        if (this.allowCustomValues && this.text.trim().length) {
+            this.addCustomChip(this.text);
+        }
+        this.open = false;
+    }
+    calciteComboboxItemChangeHandler(event) {
+        if (this.ignoreSelectedEventsFlag) {
+            return;
+        }
+        const target = event.target;
+        const newIndex = this.filteredItems.indexOf(target);
+        this.updateActiveItemIndex(newIndex);
+        this.toggleSelection(target, target.selected);
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Public Methods
+    //
+    //--------------------------------------------------------------------------
+    /**
+     * Updates the position of the component.
+     *
+     * @param delayed Reposition the component after a delay
+     * @returns Promise
+     */
+    async reposition(delayed = false) {
+        const { floatingEl, referenceEl, placement, overlayPositioning, filteredFlipPlacements } = this;
+        return reposition(this, {
+            floatingEl,
+            referenceEl,
+            overlayPositioning,
+            placement,
+            flipPlacements: filteredFlipPlacements,
+            type: "menu",
+        }, delayed);
+    }
+    /** Sets focus on the component. */
+    async setFocus() {
+        var _a;
+        await componentFocusable(this);
+        (_a = this.textInput) === null || _a === void 0 ? void 0 : _a.focus();
+        this.activeChipIndex = -1;
+        this.activeItemIndex = -1;
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    // --------------------------------------------------------------------------
+    connectedCallback() {
+        var _a;
+        connectInteractive(this);
+        connectLocalized(this);
+        connectMessages(this);
+        connectLabel(this);
+        connectForm(this);
+        this.internalValueChangeFlag = true;
+        this.value = this.getValue();
+        this.internalValueChangeFlag = false;
+        (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.observe(this.el, { childList: true, subtree: true });
+        this.updateItems();
+        this.setFilteredPlacements();
+        if (this.open) {
+            this.openHandler();
+            onToggleOpenCloseComponent(this);
+        }
+        connectFloatingUI(this, this.referenceEl, this.floatingEl);
+    }
+    async componentWillLoad() {
+        setUpLoadableComponent(this);
+        this.updateItems();
+        await setUpMessages(this);
+    }
+    componentDidLoad() {
+        afterConnectDefaultValueSet(this, this.getValue());
+        connectFloatingUI(this, this.referenceEl, this.floatingEl);
+        setComponentLoaded(this);
+    }
+    componentDidRender() {
+        if (this.el.offsetHeight !== this.inputHeight) {
+            this.reposition(true);
+            this.inputHeight = this.el.offsetHeight;
+        }
+        updateHostInteraction(this);
+    }
+    componentDidUpdate() {
+        this.refreshSelectionDisplay();
+    }
+    disconnectedCallback() {
+        var _a, _b;
+        (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        (_b = this.resizeObserver) === null || _b === void 0 ? void 0 : _b.disconnect();
+        disconnectInteractive(this);
+        disconnectLabel(this);
+        disconnectForm(this);
+        disconnectFloatingUI(this, this.referenceEl, this.floatingEl);
+        disconnectLocalized(this);
+        disconnectMessages(this);
+    }
+    /** when search text is cleared, reset active to  */
+    textHandler() {
+        this.updateActiveItemIndex(-1);
+    }
+    effectiveLocaleChange() {
+        updateMessages(this, this.effectiveLocale);
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    // --------------------------------------------------------------------------
+    clearValue() {
+        this.ignoreSelectedEventsFlag = true;
+        this.items.forEach((el) => (el.selected = false));
+        this.ignoreSelectedEventsFlag = false;
+        this.selectedItems = [];
+        this.emitComboboxChange();
+        this.open = false;
+        this.updateActiveItemIndex(-1);
+        this.resetText();
+        this.filterItems("");
+        this.setFocus();
+    }
+    clearInputValue() {
+        this.textInput.value = "";
+        this.text = "";
+    }
+    comboboxInViewport() {
+        const bounding = this.el.getBoundingClientRect();
+        return (bounding.top >= 0 &&
+            bounding.left >= 0 &&
+            bounding.right <= (window.innerWidth || document.documentElement.clientWidth) &&
+            bounding.bottom <= (window.innerHeight || document.documentElement.clientHeight));
+    }
+    onBeforeOpen() {
+        this.scrollToActiveItem();
+        this.calciteComboboxBeforeOpen.emit();
+    }
+    onOpen() {
+        this.calciteComboboxOpen.emit();
+    }
+    onBeforeClose() {
+        this.calciteComboboxBeforeClose.emit();
+    }
+    onClose() {
+        this.calciteComboboxClose.emit();
+    }
+    ensureRecentSelectedItemIsActive() {
+        const { selectedItems } = this;
+        const targetIndex = selectedItems.length === 0 ? 0 : this.items.indexOf(selectedItems[selectedItems.length - 1]);
+        this.updateActiveItemIndex(targetIndex);
+    }
+    hideChip(chipEl) {
+        chipEl.classList.add(CSS$2.chipInvisible);
+    }
+    showChip(chipEl) {
+        chipEl.classList.remove(CSS$2.chipInvisible);
+    }
+    refreshChipDisplay({ chipEls, availableHorizontalChipElSpace, chipContainerElGap, }) {
+        chipEls.forEach((chipEl) => {
+            if (!chipEl.selected) {
+                this.hideChip(chipEl);
+            }
+            else {
+                const chipElWidth = getElementWidth(chipEl);
+                if (chipElWidth && chipElWidth < availableHorizontalChipElSpace) {
+                    availableHorizontalChipElSpace -= chipElWidth + chipContainerElGap;
+                    this.showChip(chipEl);
+                    return;
+                }
+            }
+            this.hideChip(chipEl);
+        });
+    }
+    setCompactSelectionDisplay({ chipContainerElGap, chipContainerElWidth, inputWidth, largestSelectedIndicatorChipWidth, }) {
+        const newCompactBreakpoint = Math.round(largestSelectedIndicatorChipWidth + chipContainerElGap + inputWidth);
+        if (!this.maxCompactBreakpoint || this.maxCompactBreakpoint < newCompactBreakpoint) {
+            this.maxCompactBreakpoint = newCompactBreakpoint;
+        }
+        this.compactSelectionDisplay = chipContainerElWidth < this.maxCompactBreakpoint;
+    }
+    setVisibleAndHiddenChips(chipEls) {
+        let newSelectedVisibleChipsCount = 0;
+        chipEls.forEach((chipEl) => {
+            if (chipEl.selected && !chipEl.classList.contains(CSS$2.chipInvisible)) {
+                newSelectedVisibleChipsCount++;
+            }
+        });
+        if (newSelectedVisibleChipsCount !== this.selectedVisibleChipsCount) {
+            this.selectedVisibleChipsCount = newSelectedVisibleChipsCount;
+        }
+        const newSelectedHiddenChipsCount = this.getSelectedItems().length - newSelectedVisibleChipsCount;
+        if (newSelectedHiddenChipsCount !== this.selectedHiddenChipsCount) {
+            this.selectedHiddenChipsCount = newSelectedHiddenChipsCount;
+        }
+    }
+    getMaxScrollerHeight() {
+        const items = this.getItemsAndGroups().filter((item) => !item.hidden);
+        const { maxItems } = this;
+        let itemsToProcess = 0;
+        let maxScrollerHeight = 0;
+        if (items.length > maxItems) {
+            items.forEach((item) => {
+                if (itemsToProcess < maxItems && maxItems > 0) {
+                    const height = this.calculateSingleItemHeight(item);
+                    if (height > 0) {
+                        maxScrollerHeight += height;
+                        itemsToProcess++;
+                    }
+                }
+            });
+        }
+        return maxScrollerHeight;
+    }
+    calculateSingleItemHeight(item) {
+        if (!item) {
+            return;
+        }
+        let height = item.offsetHeight;
+        // if item has children items, don't count their height twice
+        const children = Array.from(item.querySelectorAll(ComboboxChildSelector));
+        children
+            .map((child) => child === null || child === void 0 ? void 0 : child.offsetHeight)
+            .forEach((offsetHeight) => {
+            height -= offsetHeight;
+        });
+        return height;
+    }
+    getItemsAndGroups() {
+        return [...this.groupItems, ...this.items];
+    }
+    toggleSelection(item, value = !item.selected) {
+        if (!item ||
+            (this.selectionMode === "single-persist" && item.selected && item.value === this.value)) {
+            return;
+        }
+        if (this.isMulti()) {
+            item.selected = value;
+            this.updateAncestors(item);
+            this.selectedItems = this.getSelectedItems();
+            this.emitComboboxChange();
+            this.resetText();
+            this.filterItems("");
+        }
+        else {
+            this.ignoreSelectedEventsFlag = true;
+            this.items.forEach((el) => (el.selected = el === item ? value : false));
+            this.ignoreSelectedEventsFlag = false;
+            this.selectedItems = this.getSelectedItems();
+            this.emitComboboxChange();
+            if (this.textInput) {
+                this.textInput.value = item.textLabel;
+            }
+            this.open = false;
+            this.updateActiveItemIndex(-1);
+            this.resetText();
+            this.filterItems("");
+        }
+    }
+    updateAncestors(item) {
+        if (this.selectionMode !== "ancestors") {
+            return;
+        }
+        const ancestors = getItemAncestors(item);
+        const children = getItemChildren(item);
+        if (item.selected) {
+            ancestors.forEach((el) => {
+                el.selected = true;
+            });
+        }
+        else {
+            children.forEach((el) => (el.selected = false));
+            [...ancestors].forEach((el) => {
+                if (!hasActiveChildren(el)) {
+                    el.selected = false;
+                }
+            });
+        }
+    }
+    getFilteredItems() {
+        return this.items.filter((item) => !item.hidden);
+    }
+    getData() {
+        return this.items.map((item) => ({
+            filterDisabled: item.filterDisabled,
+            value: item.value,
+            label: item.textLabel,
+        }));
+    }
+    getNeedsIcon() {
+        return isSingleLike(this.selectionMode) && this.items.some((item) => item.icon);
+    }
+    resetText() {
+        if (this.textInput) {
+            this.textInput.value = "";
+        }
+        this.text = "";
+    }
+    getItems() {
+        const items = Array.from(this.el.querySelectorAll(ComboboxItem));
+        return items.filter((item) => !item.disabled);
+    }
+    getGroupItems() {
+        return Array.from(this.el.querySelectorAll(ComboboxItemGroup));
+    }
+    addCustomChip(value, focus) {
+        const existingItem = this.items.find((el) => el.textLabel === value);
+        if (existingItem) {
+            this.toggleSelection(existingItem, true);
+        }
+        else {
+            if (!this.isMulti()) {
+                this.toggleSelection(this.selectedItems[this.selectedItems.length - 1], false);
+            }
+            const item = document.createElement("calcite-combobox-item");
+            item.value = value;
+            item.textLabel = value;
+            item.selected = true;
+            this.el.appendChild(item);
+            this.resetText();
+            if (focus) {
+                this.setFocus();
+            }
+            this.updateItems();
+            this.filterItems("");
+            this.emitComboboxChange();
+        }
+    }
+    removeActiveChip() {
+        this.toggleSelection(this.selectedItems[this.activeChipIndex], false);
+        this.setFocus();
+    }
+    removeLastChip() {
+        this.toggleSelection(this.selectedItems[this.selectedItems.length - 1], false);
+        this.setFocus();
+    }
+    previousChip() {
+        if (this.text) {
+            return;
+        }
+        const length = this.selectedItems.length - 1;
+        const active = this.activeChipIndex;
+        this.activeChipIndex = active === -1 ? length : Math.max(active - 1, 0);
+        this.updateActiveItemIndex(-1);
+        this.focusChip();
+    }
+    nextChip() {
+        if (this.text || this.activeChipIndex === -1) {
+            return;
+        }
+        const last = this.selectedItems.length - 1;
+        const newIndex = this.activeChipIndex + 1;
+        if (newIndex > last) {
+            this.activeChipIndex = -1;
+            this.setFocus();
+        }
+        else {
+            this.activeChipIndex = newIndex;
+            this.focusChip();
+        }
+        this.updateActiveItemIndex(-1);
+    }
+    focusChip() {
+        var _a;
+        const guid = (_a = this.selectedItems[this.activeChipIndex]) === null || _a === void 0 ? void 0 : _a.guid;
+        const chip = guid
+            ? this.referenceEl.querySelector(`#${chipUidPrefix}${guid}`)
+            : null;
+        chip === null || chip === void 0 ? void 0 : chip.setFocus();
+    }
+    shiftActiveItemIndex(delta) {
+        const { length } = this.filteredItems;
+        const newIndex = (this.activeItemIndex + length + delta) % length;
+        this.updateActiveItemIndex(newIndex);
+        this.scrollToActiveItem();
+    }
+    updateActiveItemIndex(index) {
+        this.activeItemIndex = index;
+        let activeDescendant = null;
+        this.filteredItems.forEach((el, i) => {
+            if (i === index) {
+                el.active = true;
+                activeDescendant = `${itemUidPrefix}${el.guid}`;
+            }
+            else {
+                el.active = false;
+            }
+        });
+        this.activeDescendant = activeDescendant;
+        if (this.activeItemIndex > -1) {
+            this.activeChipIndex = -1;
+        }
+    }
+    isAllSelected() {
+        return this.getItems().length === this.getSelectedItems().length;
+    }
+    isMulti() {
+        return !isSingleLike(this.selectionMode);
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Render Methods
+    //
+    //--------------------------------------------------------------------------
+    renderChips() {
+        const { activeChipIndex, readOnly, scale, selectionMode, messages } = this;
+        return this.selectedItems.map((item, i) => {
+            const chipClasses = {
+                chip: true,
+                "chip--active": activeChipIndex === i,
+            };
+            const ancestors = [...getItemAncestors(item)].reverse();
+            const pathLabel = [...ancestors, item].map((el) => el.textLabel);
+            const label = selectionMode !== "ancestors" ? item.textLabel : pathLabel.join(" / ");
+            return (h("calcite-chip", { appearance: readOnly ? "outline" : "solid", class: chipClasses, closable: !readOnly, icon: item.icon, iconFlipRtl: item.iconFlipRtl, id: item.guid ? `${chipUidPrefix}${item.guid}` : null, key: item.textLabel, messageOverrides: { dismissLabel: messages.removeTag }, onCalciteChipClose: () => this.calciteChipCloseHandler(item), scale: scale, selected: item.selected, title: label, value: item.value }, label));
+        });
+    }
+    renderAllSelectedIndicatorChip() {
+        const { compactSelectionDisplay, scale, selectedVisibleChipsCount, setAllSelectedIndicatorChipEl, } = this;
+        const label = this.messages.allSelected;
+        return (h("calcite-chip", { class: {
+                chip: true,
+                [CSS$2.chipInvisible]: !(this.isAllSelected() &&
+                    !selectedVisibleChipsCount &&
+                    !compactSelectionDisplay),
+            }, scale: scale, title: label, 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: setAllSelectedIndicatorChipEl }, label));
+    }
+    renderAllSelectedIndicatorChipCompact() {
+        const { compactSelectionDisplay, scale, selectedVisibleChipsCount } = this;
+        const label = this.messages.all || "All";
+        return (h("calcite-chip", { class: {
+                chip: true,
+                [CSS$2.chipInvisible]: !(this.isAllSelected() &&
+                    !selectedVisibleChipsCount &&
+                    compactSelectionDisplay),
+            }, scale: scale, title: label, value: "" }, label));
+    }
+    renderSelectedIndicatorChip() {
+        const { compactSelectionDisplay, selectionDisplay, getSelectedItems, scale, selectedHiddenChipsCount, selectedVisibleChipsCount, setSelectedIndicatorChipEl, } = this;
+        let chipInvisible;
+        let label;
+        if (compactSelectionDisplay) {
+            chipInvisible = true;
+        }
+        else {
+            if (selectionDisplay === "single") {
+                const selectedItemsCount = getSelectedItems().length;
+                if (this.isAllSelected()) {
+                    chipInvisible = true;
+                }
+                else if (selectedItemsCount > 0) {
+                    chipInvisible = false;
+                }
+                else {
+                    chipInvisible = true;
+                }
+                label = `${selectedItemsCount} ${this.messages.selected}`;
+            }
+            else if (selectionDisplay === "fit") {
+                chipInvisible = !!((this.isAllSelected() && selectedVisibleChipsCount === 0) ||
+                    selectedHiddenChipsCount === 0);
+                label =
+                    selectedVisibleChipsCount > 0
+                        ? `+${selectedHiddenChipsCount}`
+                        : `${selectedHiddenChipsCount} ${this.messages.selected}`;
+            }
+        }
+        return (h("calcite-chip", { class: {
+                chip: true,
+                [CSS$2.chipInvisible]: chipInvisible,
+            }, scale: scale, title: label, 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: setSelectedIndicatorChipEl }, label));
+    }
+    renderSelectedIndicatorChipCompact() {
+        const { compactSelectionDisplay, selectionDisplay, getSelectedItems, scale, selectedHiddenChipsCount, } = this;
+        let chipInvisible;
+        let label;
+        if (compactSelectionDisplay) {
+            const selectedItemsCount = getSelectedItems().length;
+            if (this.isAllSelected()) {
+                chipInvisible = true;
+            }
+            else if (selectionDisplay === "fit") {
+                chipInvisible = !(selectedHiddenChipsCount > 0);
+                label = `${selectedHiddenChipsCount || 0}`;
+            }
+            else if (selectionDisplay === "single") {
+                chipInvisible = !(selectedItemsCount > 0);
+                label = `${selectedItemsCount}`;
+            }
+        }
+        else {
+            chipInvisible = true;
+        }
+        return (h("calcite-chip", { class: {
+                chip: true,
+                [CSS$2.chipInvisible]: chipInvisible,
+            }, scale: scale, title: label, value: "" }, label));
+    }
+    get showingInlineIcon() {
+        const { placeholderIcon, selectionMode, selectedItems, open } = this;
+        const selectedItem = selectedItems[0];
+        const selectedIcon = selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.icon;
+        const singleSelectionMode = isSingleLike(selectionMode);
+        return !open && selectedItem
+            ? !!selectedIcon && singleSelectionMode
+            : !!placeholderIcon && (!selectedItem || singleSelectionMode);
+    }
+    renderInput() {
+        const { guid, disabled, placeholder, selectionMode, selectedItems, open } = this;
+        const single = isSingleLike(selectionMode);
+        const selectedItem = selectedItems[0];
+        const showLabel = !open && single && !!selectedItem;
+        return (h("span", { class: {
+                "input-wrap": true,
+                "input-wrap--single": single,
+            } }, showLabel && (h("span", { class: {
+                label: true,
+                "label--icon": !!(selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.icon),
+            }, key: "label" }, selectedItem.textLabel)), h("input", { "aria-activedescendant": this.activeDescendant, "aria-autocomplete": "list", "aria-controls": `${listboxUidPrefix}${guid}`, "aria-expanded": toAriaBoolean(open), "aria-haspopup": "listbox", "aria-label": getLabelText(this), "aria-owns": `${listboxUidPrefix}${guid}`, class: {
+                [CSS$2.input]: true,
+                "input--single": true,
+                "input--transparent": this.activeChipIndex > -1,
+                "input--hidden": showLabel,
+                "input--icon": this.showingInlineIcon && !!this.placeholderIcon,
+            }, disabled: disabled, id: `${inputUidPrefix}${guid}`, key: "input", onFocus: this.comboboxFocusHandler, onInput: this.inputHandler, placeholder: placeholder, readOnly: this.readOnly, role: "combobox", 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: (el) => (this.textInput = el) })));
+    }
+    renderListBoxOptions() {
+        return this.filteredItems.map((item) => (h("li", { "aria-selected": toAriaBoolean(item.selected), id: item.guid ? `${itemUidPrefix}${item.guid}` : null, role: "option", tabindex: "-1" }, item.textLabel)));
+    }
+    renderFloatingUIContainer() {
+        const { setFloatingEl, setContainerEl, open } = this;
+        const classes = {
+            [CSS$2.listContainer]: true,
+            [FloatingCSS.animation]: true,
+            [FloatingCSS.animationActive]: open,
+        };
+        return (h("div", { "aria-hidden": "true", class: {
+                "floating-ui-container": true,
+                "floating-ui-container--active": 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: setFloatingEl }, h("div", { class: classes,
+            // 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: setContainerEl }, h("ul", { class: { list: true, "list--hide": !open } }, h("slot", null)))));
+    }
+    renderSelectedOrPlaceholderIcon() {
+        const { selectedItems, placeholderIcon, placeholderIconFlipRtl } = this;
+        const selectedItem = selectedItems[0];
+        const selectedIcon = selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.icon;
+        return (this.showingInlineIcon && (h("span", { class: "icon-start", key: "selected-placeholder-icon" }, h("calcite-icon", { class: "selected-icon", flipRtl: this.open && selectedItem ? selectedItem.iconFlipRtl : placeholderIconFlipRtl, icon: !this.open && selectedItem ? selectedIcon : placeholderIcon, scale: getIconScale(this.scale) }))));
+    }
+    renderChevronIcon() {
+        const { open } = this;
+        return (h("span", { class: "icon-end", key: "chevron" }, h("calcite-icon", { class: CSS$2.icon, icon: open ? "chevron-up" : "chevron-down", scale: getIconScale(this.scale) })));
+    }
+    render() {
+        var _a;
+        const { selectionDisplay, guid, label, open, readOnly } = this;
+        const singleSelectionMode = isSingleLike(this.selectionMode);
+        const allSelectionDisplay = selectionDisplay === "all";
+        const singleSelectionDisplay = selectionDisplay === "single";
+        const fitSelectionDisplay = !singleSelectionMode && selectionDisplay === "fit";
+        const isClearable = !this.clearDisabled && ((_a = this.value) === null || _a === void 0 ? void 0 : _a.length) > 0;
+        return (h(Host, { key: 'd7bb6fbd99d46d6baacd027bf67d440156aa8235', onClick: this.comboboxFocusHandler }, h(InteractiveContainer, { key: 'f0e960f155ffed736782818874432e49aec7da43', disabled: this.disabled }, h("div", { key: '5b69d59411f589c99d1087ffc9d2f34a02ce4abf', "aria-live": "polite", class: {
+                wrapper: true,
+                "wrapper--single": singleSelectionMode || !this.selectedItems.length,
+                "wrapper--active": open,
+            }, onClick: this.clickHandler, 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 }, this.renderSelectedOrPlaceholderIcon(), h("div", { class: {
+                "grid-input": true,
+                [CSS$2.selectionDisplayFit]: fitSelectionDisplay,
+                [CSS$2.selectionDisplaySingle]: singleSelectionDisplay,
+            }, key: "grid",
+            // eslint-disable-next-line react/jsx-sort-props -- auto-generated by @esri/calcite-components/enforce-ref-last-prop
+            ref: this.setChipContainerEl }, !singleSelectionMode && !singleSelectionDisplay && this.renderChips(), !singleSelectionMode &&
+            !allSelectionDisplay && [
+            this.renderSelectedIndicatorChip(),
+            this.renderSelectedIndicatorChipCompact(),
+            this.renderAllSelectedIndicatorChip(),
+            this.renderAllSelectedIndicatorChipCompact(),
+        ], h("label", { key: '9b9988f68638cbf4b5379e815dd9ed88b5b83430', class: "screen-readers-only", htmlFor: `${inputUidPrefix}${guid}`, id: `${labelUidPrefix}${guid}` }, label), this.renderInput()), !readOnly && isClearable ? (h(XButton, { disabled: this.disabled, key: "close-button", label: this.messages.clear, scale: this.scale })) : null, !readOnly && this.renderChevronIcon()), h("ul", { key: 'e52aae918a2ad75c1f84e6761d4651a59397e5f7', "aria-labelledby": `${labelUidPrefix}${guid}`, "aria-multiselectable": "true", class: "screen-readers-only", id: `${listboxUidPrefix}${guid}`, role: "listbox", tabIndex: -1 }, this.renderListBoxOptions()), this.renderFloatingUIContainer(), h(HiddenFormInputSlot, { key: 'feb9c678d698e149bc58b0aed458dee9d6fb8115', component: this }), this.validationMessage && this.status === "invalid" ? (h(Validation, { icon: this.validationIcon, message: this.validationMessage, scale: this.scale, status: this.status })) : null)));
+    }
+    static get assetsDirs() { return ["assets"]; }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "open": ["openHandler"],
+        "disabled": ["handleDisabledChange"],
+        "maxItems": ["maxItemsHandler"],
+        "overlayPositioning": ["overlayPositioningHandler"],
+        "selectionMode": ["handlePropsChange"],
+        "scale": ["handlePropsChange"],
+        "value": ["valueHandler"],
+        "messageOverrides": ["onMessagesChange"],
+        "flipPlacements": ["flipPlacementsHandler"],
+        "selectedItems": ["selectedItemsHandler"],
+        "text": ["textHandler"],
+        "effectiveLocale": ["effectiveLocaleChange"]
+    }; }
+};
+Combobox.style = CalciteComboboxStyle0;
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v2.8.2
+ */
+/**
+ * Calculate slope of the tangents
+ * uses Steffen interpolation as it's monotonic
+ * http://jrwalsh1.github.io/posts/interpolations/
+ *
+ * @param p0
+ * @param p1
+ * @param p2
+ */
+function slope(p0, p1, p2) {
+    const dx = p1[0] - p0[0];
+    const dx1 = p2[0] - p1[0];
+    const dy = p1[1] - p0[1];
+    const dy1 = p2[1] - p1[1];
+    const m = dy / (dx || (dx1 < 0 && 0));
+    const m1 = dy1 / (dx1 || (dx < 0 && 0));
+    const p = (m * dx1 + m1 * dx) / (dx + dx1);
+    return (Math.sign(m) + Math.sign(m1)) * Math.min(Math.abs(m), Math.abs(m1), 0.5 * Math.abs(p)) || 0;
+}
+/**
+ * Calculate slope for just one tangent (single-sided)
+ *
+ * @param p0
+ * @param p1
+ * @param m
+ */
+function slopeSingle(p0, p1, m) {
+    const dx = p1[0] - p0[0];
+    const dy = p1[1] - p0[1];
+    return dx ? ((3 * dy) / dx - m) / 2 : m;
+}
+/**
+ * Given two points and their tangent slopes,
+ * calculate the bezier handle coordinates and return draw command.
+ *
+ * Translates Hermite Spline to Bézier curve:
+ * https://stackoverflow.com/questions/42574940/
+ *
+ * @param p0
+ * @param p1
+ * @param m0
+ * @param m1
+ * @param t
+ */
+function bezier(p0, p1, m0, m1, t) {
+    const [x0, y0] = p0;
+    const [x1, y1] = p1;
+    const dx = (x1 - x0) / 3;
+    const h1 = t([x0 + dx, y0 + dx * m0]).join(",");
+    const h2 = t([x1 - dx, y1 - dx * m1]).join(",");
+    const p = t([x1, y1]).join(",");
+    return `C ${h1} ${h2} ${p}`;
+}
+/**
+ * Generate a function which will translate a point
+ * from the data coordinate space to svg viewbox oriented pixels
+ *
+ * @param root0
+ * @param root0.width
+ * @param root0.height
+ * @param root0.min
+ * @param root0.max
+ */
+function translate({ width, height, min, max }) {
+    const rangeX = max[0] - min[0];
+    const rangeY = max[1] - min[1];
+    return (point) => {
+        const x = ((point[0] - min[0]) / rangeX) * width;
+        const y = height - (point[1] / rangeY) * height;
+        return [x, y];
+    };
+}
+/**
+ * Get the min and max values from the dataset
+ *
+ * @param data
+ */
+function range(data) {
+    const [startX, startY] = data[0];
+    const min = [startX, startY];
+    const max = [startX, startY];
+    return data.reduce(({ min, max }, [x, y]) => ({
+        min: [Math.min(min[0], x), Math.min(min[1], y)],
+        max: [Math.max(max[0], x), Math.max(max[1], y)],
+    }), { min, max });
+}
+/**
+ * Generate drawing commands for an area graph
+ * returns a string can can be passed directly to a path element's `d` attribute
+ *
+ * @param root0
+ * @param root0.data
+ * @param root0.min
+ * @param root0.max
+ * @param root0.t
+ */
+function area({ data, min, max, t }) {
+    if (data.length === 0) {
+        return "";
+    }
+    // important points for beginning and ending the path
+    const [startX, startY] = t(data[0]);
+    const [minX, minY] = t(min);
+    const [maxX] = t(max);
+    // keep track of previous slope/points
+    let m;
+    let p0;
+    let p1;
+    // iterate over data points, calculating command for each
+    const commands = data.reduce((acc, point, i) => {
+        p0 = data[i - 2];
+        p1 = data[i - 1];
+        if (i > 1) {
+            const m1 = slope(p0, p1, point);
+            const m0 = m === undefined ? slopeSingle(p0, p1, m1) : m;
+            const command = bezier(p0, p1, m0, m1, t);
+            m = m1;
+            return `${acc} ${command}`;
+        }
+        return acc;
+    }, `M ${minX},${minY} L ${minX},${startY} L ${startX},${startY}`);
+    // close the path
+    const last = data[data.length - 1];
+    const end = bezier(p1, last, m, slopeSingle(p1, last, m), t);
+    return `${commands} ${end} L ${maxX},${minY} Z`;
+}
+
+const graphCss = ":host{display:block;block-size:100%}.svg{fill:currentColor;stroke:transparent;margin:0px;display:block;block-size:100%;inline-size:100%;padding:0px}.svg .graph-path--highlight{fill:var(--calcite-color-brand);opacity:0.5}:host([hidden]){display:none}[hidden]{display:none}";
+const CalciteGraphStyle0 = graphCss;
+
+const Graph = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.graphId = `calcite-graph-${guid()}`;
+        this.resizeObserver = createObserver("resize", () => forceUpdate(this));
+        this.data = [];
+        this.colorStops = undefined;
+        this.highlightMin = undefined;
+        this.highlightMax = undefined;
+        this.min = undefined;
+        this.max = undefined;
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    connectedCallback() {
+        var _a;
+        (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.observe(this.el);
+    }
+    disconnectedCallback() {
+        var _a;
+        (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+    }
+    render() {
+        const { data, colorStops, el, highlightMax, highlightMin, min, max } = this;
+        const id = this.graphId;
+        const { clientHeight: height, clientWidth: width } = el;
+        // if we have no data, return empty svg
+        if (!data || data.length === 0) {
+            return (h("svg", { "aria-hidden": "true", class: "svg", height: height, preserveAspectRatio: "none", viewBox: `0 0 ${width} ${height}`, width: width }));
+        }
+        const { min: rangeMin, max: rangeMax } = range(data);
+        let currentMin = rangeMin;
+        let currentMax = rangeMax;
+        if (min < rangeMin[0] || min > rangeMin[0]) {
+            currentMin = [min, 0];
+        }
+        if (max > rangeMax[0] || max < rangeMax[0]) {
+            currentMax = [max, rangeMax[1]];
+        }
+        const t = translate({ min: currentMin, max: currentMax, width, height });
+        const [hMinX] = t([highlightMin, currentMax[1]]);
+        const [hMaxX] = t([highlightMax, currentMax[1]]);
+        const areaPath = area({ data, min: rangeMin, max: rangeMax, t });
+        const fill = colorStops ? `url(#linear-gradient-${id})` : undefined;
+        return (h("svg", { "aria-hidden": "true", class: "svg", height: height, preserveAspectRatio: "none", viewBox: `0 0 ${width} ${height}`, width: width }, colorStops ? (h("defs", null, h("linearGradient", { id: `linear-gradient-${id}`, x1: "0", x2: "1", y1: "0", y2: "0" }, colorStops.map(({ offset, color, opacity }) => (h("stop", { offset: `${offset * 100}%`, "stop-color": color, "stop-opacity": opacity })))))) : null, highlightMin !== undefined ? ([
+            h("mask", { height: "100%", id: `${id}1`, width: "100%", x: "0%", y: "0%" }, h("path", { d: `
+            M 0,0
+            L ${hMinX - 1},0
+            L ${hMinX - 1},${height}
+            L 0,${height}
+            Z
+          `, fill: "white" })),
+            h("mask", { height: "100%", id: `${id}2`, width: "100%", x: "0%", y: "0%" }, h("path", { d: `
+            M ${hMinX + 1},0
+            L ${hMaxX - 1},0
+            L ${hMaxX - 1},${height}
+            L ${hMinX + 1}, ${height}
+            Z
+          `, fill: "white" })),
+            h("mask", { height: "100%", id: `${id}3`, width: "100%", x: "0%", y: "0%" }, h("path", { d: `
+                M ${hMaxX + 1},0
+                L ${width},0
+                L ${width},${height}
+                L ${hMaxX + 1}, ${height}
+                Z
+              `, fill: "white" })),
+            h("path", { class: "graph-path", d: areaPath, fill: fill, mask: `url(#${id}1)` }),
+            h("path", { class: "graph-path--highlight", d: areaPath, fill: fill, mask: `url(#${id}2)` }),
+            h("path", { class: "graph-path", d: areaPath, fill: fill, mask: `url(#${id}3)` }),
+        ]) : (h("path", { class: "graph-path", d: areaPath, fill: fill }))));
+    }
+    get el() { return getElement(this); }
+};
+Graph.style = CalciteGraphStyle0;
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v2.8.2
+ */
+const CSS = {
+    container: "container",
+    containerRange: "container--range",
+    graph: "graph",
+    handle: "handle",
+    handleExtension: "handle-extension",
+    handleLabel: "handle__label",
+    handleLabelMinValue: "handle__label--minValue",
+    handleLabelValue: "handle__label--value",
+    hyphen: "hyphen",
+    hyphenWrap: "hyphen--wrap",
+    static: "static",
+    thumb: "thumb",
+    thumbActive: "thumb--active",
+    thumbContainer: "thumb-container",
+    thumbMinValue: "thumb--minValue",
+    thumbPrecise: "thumb--precise",
+    thumbValue: "thumb--value",
+    tick: "tick",
+    tickActive: "tick--active",
+    tickLabel: "tick__label",
+    tickMax: "tick__label--max",
+    tickMin: "tick__label--min",
+    ticks: "ticks",
+    track: "track",
+    trackRange: "track__range",
+    transformed: "transformed",
+};
+const maxTickElementThreshold = 250;
+
+const sliderCss = "@charset \"UTF-8\";:host([disabled]){cursor:default;-webkit-user-select:none;-moz-user-select:none;user-select:none;opacity:var(--calcite-opacity-disabled)}:host([disabled]) *,:host([disabled]) ::slotted(*){pointer-events:none}.scale--s{--calcite-slider-handle-size:0.625rem;--calcite-slider-handle-extension-height:0.4rem;--calcite-slider-container-font-size:var(--calcite-font-size--3)}.scale--s .handle__label,.scale--s .tick__label{line-height:.75rem}.scale--m{--calcite-slider-handle-size:0.875rem;--calcite-slider-handle-extension-height:0.5rem;--calcite-slider-container-font-size:var(--calcite-font-size--2)}.scale--m .handle__label,.scale--m .tick__label{line-height:1rem}.scale--l{--calcite-slider-handle-size:1rem;--calcite-slider-handle-extension-height:0.65rem;--calcite-slider-container-font-size:var(--calcite-font-size--1)}.scale--l .handle__label,.scale--l .tick__label{line-height:1rem}.handle__label,.tick__label{font-weight:var(--calcite-font-weight-medium);color:var(--calcite-color-text-2);font-size:var(--calcite-slider-container-font-size)}:host{display:block}.container{position:relative;display:block;overflow-wrap:normal;word-break:normal;padding-inline:calc(var(--calcite-slider-handle-size) * 0.5);padding-block:calc(var(--calcite-slider-handle-size) * 0.5);margin-block:calc(var(--calcite-slider-handle-size) * 0.5);margin-inline:0;--calcite-slider-full-handle-height:calc(\n    var(--calcite-slider-handle-size) + var(--calcite-slider-handle-extension-height)\n  );touch-action:none}:host([disabled]) .track__range,:host([disabled]) .tick--active{background-color:var(--calcite-color-text-3)}:host([disabled]) ::slotted([calcite-hydrated][disabled]),:host([disabled]) [calcite-hydrated][disabled]{opacity:1}.interaction-container{display:contents}.scale--s .thumb:not(.thumb--precise){--calcite-slider-thumb-y-offset:-0.375rem}.scale--m .thumb:not(.thumb--precise){--calcite-slider-thumb-y-offset:-0.5rem}.scale--l .thumb:not(.thumb--precise){--calcite-slider-thumb-y-offset:-0.55rem}:host([precise]:not([has-histogram])) .container .thumb--value{--calcite-slider-thumb-y-offset:calc(var(--calcite-slider-full-handle-height) * -1)}.thumb-container{position:relative;max-inline-size:100%}.thumb{--calcite-slider-thumb-x-offset:calc(var(--calcite-slider-handle-size) * 0.5);position:absolute;margin:0px;display:flex;cursor:pointer;flex-direction:column;align-items:center;border-style:none;background-color:transparent;padding:0px;font-family:inherit;outline:2px solid transparent;outline-offset:2px;transform:translate(var(--calcite-slider-thumb-x-offset), var(--calcite-slider-thumb-y-offset))}.thumb .handle__label.static,.thumb .handle__label.transformed{position:absolute;inset-block:0px;opacity:0}.thumb .handle__label.hyphen::after{content:\"—\";display:inline-block;inline-size:1em}.thumb .handle__label.hyphen--wrap{display:flex}.thumb .handle{box-sizing:border-box;border-radius:9999px;background-color:var(--calcite-color-foreground-1);outline-color:transparent;block-size:var(--calcite-slider-handle-size);inline-size:var(--calcite-slider-handle-size);box-shadow:0 0 0 2px var(--calcite-color-text-3) inset;transition:border var(--calcite-internal-animation-timing-medium) ease, background-color var(--calcite-internal-animation-timing-medium) ease, box-shadow var(--calcite-animation-timing) ease}.thumb .handle-extension{inline-size:0.125rem;block-size:var(--calcite-slider-handle-extension-height);background-color:var(--calcite-color-text-3)}.thumb:hover .handle{box-shadow:0 0 0 3px var(--calcite-color-brand) inset}.thumb:hover .handle-extension{background-color:var(--calcite-color-brand)}.thumb:focus .handle{outline:2px solid var(--calcite-ui-focus-color, var(--calcite-color-brand));outline-offset:calc(\n            2px *\n            calc(\n              1 -\n              2 * clamp(\n                0,\n                var(--calcite-offset-invert-focus),\n                1\n              )\n            )\n          )}.thumb:focus .handle-extension{background-color:var(--calcite-color-brand)}.thumb.thumb--minValue{transform:translate(calc(var(--calcite-slider-thumb-x-offset) * -1), var(--calcite-slider-thumb-y-offset))}.thumb.thumb--precise{--calcite-slider-thumb-y-offset:-0.125rem}:host([label-handles]) .thumb{--calcite-slider-thumb-x-offset:50%}:host([label-handles]):host(:not([has-histogram])) .scale--s .thumb:not(.thumb--precise){--calcite-slider-thumb-y-offset:-1.4375rem}:host([label-handles]):host(:not([has-histogram])) .scale--m .thumb:not(.thumb--precise){--calcite-slider-thumb-y-offset:-1.875rem}:host([label-handles]):host(:not([has-histogram])) .scale--l .thumb:not(.thumb--precise){--calcite-slider-thumb-y-offset:-2rem}:host([has-histogram][label-handles]) .handle__label,:host([label-handles]:not([has-histogram])) .thumb--minValue.thumb--precise .handle__label{margin-block-start:0.5em}:host(:not([has-histogram]):not([precise])) .handle__label,:host([label-handles]:not([has-histogram])) .thumb--value .handle__label{margin-block-end:0.5em}:host([label-handles][precise]):host(:not([has-histogram])) .scale--s .thumb--value{--calcite-slider-thumb-y-offset:-2.075rem}:host([label-handles][precise]):host(:not([has-histogram])) .scale--m .thumb--value{--calcite-slider-thumb-y-offset:-2.75rem}:host([label-handles][precise]):host(:not([has-histogram])) .scale--l .thumb--value{--calcite-slider-thumb-y-offset:-3.0625rem}.thumb:focus .handle,.thumb--active .handle{background-color:var(--calcite-color-brand);box-shadow:0 0 8px 0 rgba(0, 0, 0, 0.16)}.thumb:hover.thumb--precise:after,.thumb:focus.thumb--precise:after,.thumb--active.thumb--precise:after{background-color:var(--calcite-color-brand)}.track{position:relative;block-size:0.125rem;border-radius:0px;background-color:var(--calcite-color-border-2);transition:all var(--calcite-internal-animation-timing-medium) ease-in}.track__range{position:absolute;inset-block-start:0px;block-size:0.125rem;background-color:var(--calcite-color-brand)}.container--range .track__range:hover{cursor:ew-resize}.container--range .track__range:after{position:absolute;inline-size:100%;content:\"\";inset-block-start:calc(var(--calcite-slider-full-handle-height) * 0.5 * -1);block-size:calc(var(--calcite-slider-handle-size) + var(--calcite-slider-handle-extension-height))}@media (forced-colors: active){.thumb{outline-width:0;outline-offset:0}.handle{outline:2px solid transparent;outline-offset:2px}.thumb:focus .handle,.thumb .handle-extension,.thumb:hover .handle-extension,.thumb:focus .handle-extension,.thumb:active .handle-extension{background-color:canvasText}.track{background-color:canvasText}.track__range{background-color:highlight}}.tick{position:absolute;block-size:0.25rem;inline-size:0.125rem;border-width:1px;border-style:solid;background-color:var(--calcite-color-border-input);border-color:var(--calcite-color-foreground-1);inset-block-start:-2px;pointer-events:none;margin-inline-start:calc(-1 * 0.125rem)}.tick--active{background-color:var(--calcite-color-brand)}.tick__label{pointer-events:none;margin-block-start:0.875rem;display:flex;justify-content:center}.tick__label--min{transition:opacity var(--calcite-animation-timing)}.tick__label--max{transition:opacity var(--calcite-internal-animation-timing-fast)}:host([has-histogram][label-handles]) .tick__label--min,:host([has-histogram][label-handles]) .tick__label--max,:host([has-histogram][precise]) .tick__label--min,:host([has-histogram][precise]) .tick__label--max{font-weight:var(--calcite-font-weight-normal);color:var(--calcite-color-text-3)}.graph{color:var(--calcite-color-foreground-3);block-size:48px}:host([label-ticks][ticks]) .container{padding-block-end:calc(0.875rem + var(--calcite-slider-container-font-size))}:host([has-histogram]):host([precise][label-handles]) .container{padding-block-end:calc(var(--calcite-slider-full-handle-height) + 1em)}:host([has-histogram]):host([label-handles]:not([precise])) .container{padding-block-end:calc(var(--calcite-slider-handle-size) * 0.5 + 1em)}:host([has-histogram]):host([precise]:not([label-handles])) .container{padding-block-end:var(--calcite-slider-full-handle-height)}:host(:not([has-histogram])):host([precise]:not([label-handles])) .container{padding-block-start:var(--calcite-slider-full-handle-height)}:host(:not([has-histogram])):host([precise]:not([label-handles])) .container--range{padding-block-end:var(--calcite-slider-full-handle-height)}:host(:not([has-histogram])):host([label-handles]:not([precise])) .container{padding-block-start:calc(var(--calcite-slider-full-handle-height) + 4px)}:host(:not([has-histogram])):host([label-handles][precise]) .container{padding-block-start:calc(var(--calcite-slider-full-handle-height) + var(--calcite-slider-container-font-size) + 4px)}:host(:not([has-histogram])):host([label-handles][precise]) .container--range{padding-block-end:calc(var(--calcite-slider-full-handle-height) + var(--calcite-slider-container-font-size) + 4px)}::slotted(input[slot=hidden-form-input]){margin:0 !important;opacity:0 !important;outline:none !important;padding:0 !important;position:absolute !important;inset:0 !important;transform:none !important;-webkit-appearance:none !important;z-index:-1 !important}:host([hidden]){display:none}[hidden]{display:none}";
+const CalciteSliderStyle0 = sliderCss;
+
+function isRange(value) {
+    return Array.isArray(value);
+}
+const Slider = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.calciteSliderInput = createEvent(this, "calciteSliderInput", 6);
+        this.calciteSliderChange = createEvent(this, "calciteSliderChange", 6);
+        //--------------------------------------------------------------------------
+        //
+        //  Event Listeners
+        //
+        //--------------------------------------------------------------------------
+        this.handleKeyDown = (event) => {
+            const mirror = this.shouldMirror();
+            const { activeProp, max, min, pageStep, step } = this;
+            const value = this[activeProp];
+            const { key } = event;
+            if (isActivationKey(key)) {
+                event.preventDefault();
+                return;
+            }
+            let adjustment;
+            if (key === "ArrowUp" || key === "ArrowRight") {
+                const directionFactor = mirror && key === "ArrowRight" ? -1 : 1;
+                adjustment = value + step * directionFactor;
+            }
+            else if (key === "ArrowDown" || key === "ArrowLeft") {
+                const directionFactor = mirror && key === "ArrowLeft" ? -1 : 1;
+                adjustment = value - step * directionFactor;
+            }
+            else if (key === "PageUp") {
+                if (pageStep) {
+                    adjustment = value + pageStep;
+                }
+            }
+            else if (key === "PageDown") {
+                if (pageStep) {
+                    adjustment = value - pageStep;
+                }
+            }
+            else if (key === "Home") {
+                adjustment = min;
+            }
+            else if (key === "End") {
+                adjustment = max;
+            }
+            if (isNaN(adjustment)) {
+                return;
+            }
+            event.preventDefault();
+            const fixedDecimalAdjustment = Number(adjustment.toFixed(decimalPlaces(step)));
+            this.setValue({
+                [activeProp]: this.clamp(fixedDecimalAdjustment, activeProp),
+            });
+        };
+        this.activeProp = "value";
+        this.guid = `calcite-slider-${guid()}`;
+        this.onThumbBlur = () => {
+            this.activeProp = null;
+        };
+        this.onThumbFocus = (event) => {
+            const thumb = event.currentTarget;
+            this.activeProp = thumb.getAttribute("data-value-prop");
+        };
+        this.onThumbPointerDown = (event) => {
+            const thumb = event.currentTarget;
+            this.pointerDownDragStart(event, thumb.getAttribute("data-value-prop"));
+        };
+        this.onTrackPointerDown = (event) => {
+            this.pointerDownDragStart(event, "minMaxValue");
+        };
+        this.dragUpdate = (event) => {
+            if (this.disabled) {
+                return;
+            }
+            event.preventDefault();
+            if (this.dragProp) {
+                const value = this.translate(event.clientX || event.pageX);
+                if (isRange(this.value) && this.dragProp === "minMaxValue") {
+                    if (this.minValueDragRange && this.maxValueDragRange && this.minMaxValueRange) {
+                        const newMinValue = value - this.minValueDragRange;
+                        const newMaxValue = value + this.maxValueDragRange;
+                        if (newMaxValue <= this.max &&
+                            newMinValue >= this.min &&
+                            newMaxValue - newMinValue === this.minMaxValueRange) {
+                            this.setValue({
+                                minValue: this.clamp(newMinValue, "minValue"),
+                                maxValue: this.clamp(newMaxValue, "maxValue"),
+                            });
+                        }
+                    }
+                    else {
+                        this.minValueDragRange = value - this.minValue;
+                        this.maxValueDragRange = this.maxValue - value;
+                        this.minMaxValueRange = this.maxValue - this.minValue;
+                    }
+                }
+                else {
+                    this.setValue({ [this.dragProp]: this.clamp(value, this.dragProp) });
+                }
+            }
+        };
+        this.pointerUpDragEnd = (event) => {
+            if (this.disabled || !isPrimaryPointerButton(event)) {
+                return;
+            }
+            this.dragEnd(event);
+        };
+        this.dragEnd = (event) => {
+            if (this.disabled) {
+                return;
+            }
+            this.removeDragListeners();
+            this.focusActiveHandle(event.clientX);
+            if (this.lastDragPropValue != this[this.dragProp]) {
+                this.emitChange();
+            }
+            this.dragProp = null;
+            this.lastDragPropValue = null;
+            this.minValueDragRange = null;
+            this.maxValueDragRange = null;
+            this.minMaxValueRange = null;
+        };
+        this.storeTrackRef = (node) => {
+            this.trackEl = node;
+        };
+        this.storeThumbRef = (el) => {
+            if (!el) {
+                return;
+            }
+            const valueProp = el.getAttribute("data-value-prop");
+            valueProp === "minValue" ? (this.minHandle = el) : (this.maxHandle = el);
+        };
+        /**
+         * Returns a string representing the localized label value based if the groupSeparator prop is parsed.
+         *
+         * @param value
+         */
+        this.formatValue = (value) => {
+            numberStringFormatter.numberFormatOptions = {
+                locale: this.effectiveLocale,
+                numberingSystem: this.numberingSystem,
+                useGrouping: this.groupSeparator,
+            };
+            return numberStringFormatter.localize(value.toString());
+        };
+        this.disabled = false;
+        this.fillPlacement = "start";
+        this.form = undefined;
+        this.groupSeparator = false;
+        this.hasHistogram = false;
+        this.histogram = undefined;
+        this.histogramStops = undefined;
+        this.labelHandles = false;
+        this.labelFormatter = undefined;
+        this.labelTicks = false;
+        this.max = 100;
+        this.maxLabel = undefined;
+        this.maxValue = undefined;
+        this.min = 0;
+        this.minLabel = undefined;
+        this.minValue = undefined;
+        this.mirrored = false;
+        this.name = undefined;
+        this.numberingSystem = undefined;
+        this.pageStep = undefined;
+        this.precise = false;
+        this.required = false;
+        this.snap = false;
+        this.step = 1;
+        this.ticks = undefined;
+        this.value = 0;
+        this.scale = "m";
+        this.effectiveLocale = "";
+        this.minMaxValueRange = null;
+        this.minValueDragRange = null;
+        this.maxValueDragRange = null;
+        this.tickValues = [];
+    }
+    histogramWatcher(newHistogram) {
+        this.hasHistogram = !!newHistogram;
+    }
+    ticksWatcher() {
+        this.tickValues = this.generateTickValues();
+    }
+    valueHandler() {
+        this.setMinMaxFromValue();
+    }
+    minMaxValueHandler() {
+        this.setValueFromMinMax();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    connectedCallback() {
+        connectInteractive(this);
+        connectLocalized(this);
+        this.setMinMaxFromValue();
+        this.setValueFromMinMax();
+        connectLabel(this);
+        connectForm(this);
+    }
+    disconnectedCallback() {
+        disconnectInteractive(this);
+        disconnectLabel(this);
+        disconnectForm(this);
+        disconnectLocalized(this);
+        this.removeDragListeners();
+    }
+    componentWillLoad() {
+        setUpLoadableComponent(this);
+        if (!isRange(this.value)) {
+            this.value = this.snap ? this.getClosestStep(this.value) : this.clamp(this.value);
+        }
+        this.ticksWatcher();
+        this.histogramWatcher(this.histogram);
+        afterConnectDefaultValueSet(this, this.value);
+    }
+    componentDidLoad() {
+        setComponentLoaded(this);
+    }
+    componentDidRender() {
+        if (this.labelHandles) {
+            this.adjustHostObscuredHandleLabel("value");
+            if (isRange(this.value)) {
+                this.adjustHostObscuredHandleLabel("minValue");
+                if (!(this.precise && !this.hasHistogram)) {
+                    this.hyphenateCollidingRangeHandleLabels();
+                }
+            }
+        }
+        this.hideObscuredBoundingTickLabels();
+        updateHostInteraction(this);
+    }
+    render() {
+        const id = this.el.id || this.guid;
+        const value = isRange(this.value) ? this.maxValue : this.value;
+        const min = this.minValue || this.min;
+        const useMinValue = this.shouldUseMinValue();
+        const minInterval = this.getUnitInterval(useMinValue ? this.minValue : min) * 100;
+        const maxInterval = this.getUnitInterval(value) * 100;
+        const mirror = this.shouldMirror();
+        const valueIsRange = isRange(this.value);
+        const thumbTypes = this.buildThumbType("max");
+        const thumb = this.renderThumb({
+            type: thumbTypes,
+            thumbPlacement: thumbTypes.includes("histogram") ? "below" : "above",
+            maxInterval,
+            minInterval,
+            mirror,
+        });
+        const minThumbTypes = this.buildThumbType("min");
+        const minThumb = valueIsRange &&
+            this.renderThumb({
+                type: minThumbTypes,
+                thumbPlacement: minThumbTypes.includes("histogram") || minThumbTypes.includes("precise")
+                    ? "below"
+                    : "above",
+                maxInterval,
+                minInterval,
+                mirror,
+            });
+        const fillPlacement = valueIsRange ? "start" : this.fillPlacement;
+        const trackRangePlacementStyles = fillPlacement === "none"
+            ? {
+                left: `unset`,
+                right: `unset`,
+            }
+            : fillPlacement === "end"
+                ? {
+                    left: `${mirror ? minInterval : maxInterval}%`,
+                    right: `${mirror ? maxInterval : minInterval}%`,
+                }
+                : /* default */
+                    {
+                        left: `${mirror ? 100 - maxInterval : minInterval}%`,
+                        right: `${mirror ? minInterval : 100 - maxInterval}%`,
+                    };
+        return (h(Host, { key: '86ec64bfb42495e7fc927751ad7d2a667b0a625d', id: id, onKeyDown: this.handleKeyDown, onTouchStart: this.handleTouchStart }, h(InteractiveContainer, { key: '842aacebaf4199a088f71b2d2ad7420845cf2629', disabled: this.disabled }, h("div", { key: '364511c370bbf454958accdd4c3084a1c339de22', "aria-label": getLabelText(this), class: {
+                [CSS.container]: true,
+                [CSS.containerRange]: valueIsRange,
+                [`scale--${this.scale}`]: true,
+            } }, this.renderGraph(), h("div", { key: 'b382bc88c07796d339dd972bcea3459ce8664de9', class: CSS.track,
+            // 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.storeTrackRef }, h("div", { key: 'ba6aeb6fca50edd0c2d13077a49ac00f0aa93cf3', class: CSS.trackRange, onPointerDown: this.onTrackPointerDown, style: trackRangePlacementStyles }), h("div", { key: '013d292f6046b456443c9537facac8a6a2b1c4e6', class: CSS.ticks }, this.tickValues.map((tick) => {
+            const tickOffset = `${this.getUnitInterval(tick) * 100}%`;
+            let activeTicks = false;
+            if (fillPlacement === "start" || fillPlacement === "end") {
+                if (useMinValue) {
+                    activeTicks = tick >= this.minValue && tick <= this.maxValue;
+                }
+                else {
+                    const rangeStart = fillPlacement === "start" ? min : value;
+                    const rangeEnd = fillPlacement === "start" ? value : this.max;
+                    activeTicks = tick >= rangeStart && tick <= rangeEnd;
+                }
+            }
+            return (h("span", { class: {
+                    [CSS.tick]: true,
+                    [CSS.tickActive]: activeTicks,
+                }, style: {
+                    left: mirror ? "" : tickOffset,
+                    right: mirror ? tickOffset : "",
+                } }, this.renderTickLabel(tick)));
+        }))), h("div", { key: '31e1150688ac0371ed3b32a839c855b79ae9ed47', class: CSS.thumbContainer }, minThumb, thumb, h(HiddenFormInputSlot, { key: '3de3bb38e26cd71ee3a49541d61534b004ff137b', component: this }))))));
+    }
+    renderThumb({ type, mirror, thumbPlacement, minInterval, maxInterval, }) {
+        const isLabeled = type.includes("labeled");
+        const isPrecise = type.includes("precise");
+        const isMinThumb = type.includes("min");
+        const valueIsRange = isRange(this.value);
+        const value = isMinThumb
+            ? this.minValue
+            : valueIsRange
+                ? this.maxValue
+                : this.value;
+        const valueProp = isMinThumb ? "minValue" : valueIsRange ? "maxValue" : "value";
+        const ariaLabel = isMinThumb ? this.minLabel : valueIsRange ? this.maxLabel : this.minLabel;
+        const ariaValuenow = isMinThumb ? this.minValue : value;
+        const displayedValue = valueProp === "minValue"
+            ? this.internalLabelFormatter(this.minValue, "min")
+            : valueProp === "maxValue"
+                ? this.internalLabelFormatter(this.maxValue, "max")
+                : this.internalLabelFormatter(value, "value");
+        const thumbStyle = isMinThumb
+            ? { left: `${mirror ? 100 - minInterval : minInterval}%` }
+            : { right: `${mirror ? maxInterval : 100 - maxInterval}%` };
+        const thumbLabelClasses = `${CSS.handleLabel} ${isMinThumb ? CSS.handleLabelMinValue : CSS.handleLabelValue}`;
+        const labels = isLabeled
+            ? [
+                h("span", { "aria-hidden": "true", class: thumbLabelClasses }, displayedValue),
+                h("span", { "aria-hidden": "true", class: `${thumbLabelClasses} ${CSS.static}` }, displayedValue),
+                h("span", { "aria-hidden": "true", class: `${thumbLabelClasses} ${CSS.transformed}` }, displayedValue),
+            ]
+            : [];
+        const thumbContent = [
+            ...labels,
+            h("div", { class: CSS.handle }),
+            isPrecise && h("div", { class: CSS.handleExtension }),
+        ];
+        if (thumbPlacement === "below") {
+            thumbContent.reverse();
+        }
+        return (h("div", { "aria-disabled": this.disabled, "aria-label": ariaLabel, "aria-orientation": "horizontal", "aria-valuemax": this.max, "aria-valuemin": this.min, "aria-valuenow": ariaValuenow, class: {
+                [CSS.thumb]: true,
+                [CSS.thumbValue]: !isMinThumb,
+                [CSS.thumbActive]: this.lastDragProp !== "minMaxValue" && this.dragProp === valueProp,
+                [CSS.thumbPrecise]: isPrecise,
+                [CSS.thumbMinValue]: isMinThumb,
+            }, "data-value-prop": valueProp, key: type, onBlur: this.onThumbBlur, onFocus: this.onThumbFocus, onPointerDown: this.onThumbPointerDown, role: "slider", style: thumbStyle, 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.storeThumbRef }, thumbContent));
+    }
+    renderGraph() {
+        return this.histogram ? (h("calcite-graph", { class: CSS.graph, colorStops: this.histogramStops, data: this.histogram, highlightMax: isRange(this.value) ? this.maxValue : this.value, highlightMin: isRange(this.value) ? this.minValue : this.min, max: this.max, min: this.min })) : null;
+    }
+    renderTickLabel(tick) {
+        const { hasHistogram, labelHandles, labelTicks, max, min, precise, value } = this;
+        const valueIsRange = isRange(value);
+        const isMinTickLabel = tick === min;
+        const isMaxTickLabel = tick === max;
+        const isAtEdge = isMinTickLabel || isMaxTickLabel;
+        const shouldDisplayLabel = labelTicks &&
+            ((!hasHistogram && (isAtEdge || !precise || !valueIsRange)) ||
+                (hasHistogram && (isAtEdge || (!precise && !labelHandles))));
+        return shouldDisplayLabel ? (h("span", { class: {
+                [CSS.tickLabel]: true,
+                [CSS.tickMin]: isMinTickLabel,
+                [CSS.tickMax]: isMaxTickLabel,
+            } }, this.internalLabelFormatter(tick, "tick"))) : null;
+    }
+    pointerDownHandler(event) {
+        if (this.disabled || !isPrimaryPointerButton(event)) {
+            return;
+        }
+        const x = event.clientX || event.pageX;
+        const position = this.translate(x);
+        let prop = "value";
+        if (isRange(this.value)) {
+            const inRange = position >= this.minValue && position <= this.maxValue;
+            if (inRange && this.lastDragProp === "minMaxValue") {
+                prop = "minMaxValue";
+            }
+            else {
+                const closerToMax = Math.abs(this.maxValue - position) < Math.abs(this.minValue - position);
+                prop = closerToMax || position >= this.maxValue ? "maxValue" : "minValue";
+            }
+        }
+        this.lastDragPropValue = this[prop];
+        this.dragStart(prop);
+        const isThumbActive = this.el.shadowRoot.querySelector(`.${CSS.thumb}:active`);
+        if (!isThumbActive) {
+            this.setValue({ [prop]: this.clamp(position, prop) });
+        }
+        this.focusActiveHandle(x);
+    }
+    handleTouchStart(event) {
+        // needed to prevent extra click at the end of a handle drag
+        event.preventDefault();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Public Methods
+    //
+    //--------------------------------------------------------------------------
+    /** Sets focus on the component. */
+    async setFocus() {
+        await componentFocusable(this);
+        const handle = this.minHandle ? this.minHandle : this.maxHandle;
+        handle === null || handle === void 0 ? void 0 : handle.focus();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    buildThumbType(type) {
+        const thumbTypeParts = [type];
+        if (this.labelHandles) {
+            thumbTypeParts.push("labeled");
+        }
+        if (this.precise) {
+            thumbTypeParts.push("precise");
+        }
+        if (this.hasHistogram) {
+            thumbTypeParts.push("histogram");
+        }
+        return thumbTypeParts.join("-");
+    }
+    setValueFromMinMax() {
+        const { minValue, maxValue } = this;
+        if (typeof minValue === "number" && typeof maxValue === "number") {
+            this.value = [minValue, maxValue];
+        }
+    }
+    setMinMaxFromValue() {
+        const { value } = this;
+        if (isRange(value)) {
+            this.minValue = value[0];
+            this.maxValue = value[1];
+        }
+    }
+    onLabelClick() {
+        this.setFocus();
+    }
+    shouldMirror() {
+        return this.mirrored && !this.hasHistogram;
+    }
+    shouldUseMinValue() {
+        if (!isRange(this.value)) {
+            return false;
+        }
+        return ((this.hasHistogram && this.maxValue === 0) || (!this.hasHistogram && this.minValue === 0));
+    }
+    getTickDensity() {
+        const density = (this.max - this.min) / this.ticks / maxTickElementThreshold;
+        return density < 1 ? 1 : density;
+    }
+    generateTickValues() {
+        var _a;
+        const tickInterval = (_a = this.ticks) !== null && _a !== void 0 ? _a : 0;
+        if (tickInterval <= 0) {
+            return [];
+        }
+        const ticks = [this.min];
+        const density = this.getTickDensity();
+        const tickOffset = tickInterval * density;
+        let current = this.min;
+        while (current < this.max) {
+            current += tickOffset;
+            ticks.push(Math.min(current, this.max));
+        }
+        if (!ticks.includes(this.max)) {
+            ticks.push(this.max);
+        }
+        return ticks;
+    }
+    pointerDownDragStart(event, prop) {
+        if (!isPrimaryPointerButton(event)) {
+            return;
+        }
+        this.dragStart(prop);
+    }
+    dragStart(prop) {
+        this.dragProp = prop;
+        this.lastDragProp = this.dragProp;
+        this.activeProp = prop;
+        window.addEventListener("pointermove", this.dragUpdate);
+        window.addEventListener("pointerup", this.pointerUpDragEnd);
+        window.addEventListener("pointercancel", this.dragEnd);
+    }
+    focusActiveHandle(valueX) {
+        if (this.dragProp === "minValue") {
+            this.minHandle.focus();
+        }
+        else if (this.dragProp === "maxValue" || this.dragProp === "value") {
+            this.maxHandle.focus();
+        }
+        else if (this.dragProp === "minMaxValue") {
+            this.getClosestHandle(valueX).focus();
+        }
+    }
+    emitInput() {
+        this.calciteSliderInput.emit();
+    }
+    emitChange() {
+        this.calciteSliderChange.emit();
+    }
+    removeDragListeners() {
+        window.removeEventListener("pointermove", this.dragUpdate);
+        window.removeEventListener("pointerup", this.pointerUpDragEnd);
+        window.removeEventListener("pointercancel", this.dragEnd);
+    }
+    /**
+     * Set prop value(s) if changed at the component level
+     *
+     * @param {object} values - a set of key/value pairs delineating what properties in the component to update
+     */
+    setValue(values) {
+        let valueChanged;
+        Object.keys(values).forEach((propName) => {
+            const newValue = values[propName];
+            if (!valueChanged) {
+                const oldValue = this[propName];
+                valueChanged = oldValue !== newValue;
+            }
+            this[propName] = newValue;
+        });
+        if (!valueChanged) {
+            return;
+        }
+        const dragging = this.dragProp;
+        if (!dragging) {
+            this.emitChange();
+        }
+        this.emitInput();
+    }
+    /**
+     * If number is outside range, constrain to min or max
+     *
+     * @param value
+     * @param prop
+     * @internal
+     */
+    clamp(value, prop) {
+        value = clamp(value, this.min, this.max);
+        // ensure that maxValue and minValue don't swap positions
+        if (prop === "maxValue") {
+            value = Math.max(value, this.minValue);
+        }
+        if (prop === "minValue") {
+            value = Math.min(value, this.maxValue);
+        }
+        return value;
+    }
+    /**
+     * Translate a pixel position to value along the range
+     *
+     * @param x
+     * @internal
+     */
+    translate(x) {
+        const range = this.max - this.min;
+        const { left, width } = this.trackEl.getBoundingClientRect();
+        const percent = (x - left) / width;
+        const mirror = this.shouldMirror();
+        const clampedValue = this.clamp(this.min + range * (mirror ? 1 - percent : percent));
+        const value = Number(clampedValue.toFixed(decimalPlaces(this.step)));
+        return !(this.snap && this.step) ? value : this.getClosestStep(value);
+    }
+    /**
+     * Get closest allowed value along stepped values
+     *
+     * @param value
+     * @internal
+     */
+    getClosestStep(value) {
+        const { max, min, step } = this;
+        let snappedValue = Math.floor((value - min) / step) * step + min;
+        snappedValue = Math.min(Math.max(snappedValue, min), max);
+        if (snappedValue > max) {
+            snappedValue -= step;
+        }
+        return snappedValue;
+    }
+    getClosestHandle(valueX) {
+        return this.getDistanceX(this.maxHandle, valueX) > this.getDistanceX(this.minHandle, valueX)
+            ? this.minHandle
+            : this.maxHandle;
+    }
+    getDistanceX(el, valueX) {
+        return Math.abs(el.getBoundingClientRect().left - valueX);
+    }
+    getFontSizeForElement(element) {
+        return Number(window.getComputedStyle(element).getPropertyValue("font-size").match(/\d+/)[0]);
+    }
+    /**
+     * Get position of value along range as fractional value
+     *
+     * @param num
+     * @return {number} number in the unit interval [0,1]
+     * @internal
+     */
+    getUnitInterval(num) {
+        num = this.clamp(num);
+        const range = this.max - this.min;
+        return (num - this.min) / range;
+    }
+    adjustHostObscuredHandleLabel(name) {
+        const label = this.el.shadowRoot.querySelector(`.handle__label--${name}`);
+        const labelStatic = this.el.shadowRoot.querySelector(`.handle__label--${name}.static`);
+        const labelTransformed = this.el.shadowRoot.querySelector(`.handle__label--${name}.transformed`);
+        const labelStaticBounds = labelStatic.getBoundingClientRect();
+        const labelStaticOffset = this.getHostOffset(labelStaticBounds.left, labelStaticBounds.right);
+        label.style.transform = `translateX(${labelStaticOffset}px)`;
+        labelTransformed.style.transform = `translateX(${labelStaticOffset}px)`;
+    }
+    hyphenateCollidingRangeHandleLabels() {
+        const { shadowRoot } = this.el;
+        const mirror = this.shouldMirror();
+        const leftModifier = mirror ? "value" : "minValue";
+        const rightModifier = mirror ? "minValue" : "value";
+        const leftValueLabel = shadowRoot.querySelector(`.handle__label--${leftModifier}`);
+        const leftValueLabelStatic = shadowRoot.querySelector(`.handle__label--${leftModifier}.static`);
+        const leftValueLabelTransformed = shadowRoot.querySelector(`.handle__label--${leftModifier}.transformed`);
+        const leftValueLabelStaticHostOffset = this.getHostOffset(leftValueLabelStatic.getBoundingClientRect().left, leftValueLabelStatic.getBoundingClientRect().right);
+        const rightValueLabel = shadowRoot.querySelector(`.handle__label--${rightModifier}`);
+        const rightValueLabelStatic = shadowRoot.querySelector(`.handle__label--${rightModifier}.static`);
+        const rightValueLabelTransformed = shadowRoot.querySelector(`.handle__label--${rightModifier}.transformed`);
+        const rightValueLabelStaticHostOffset = this.getHostOffset(rightValueLabelStatic.getBoundingClientRect().left, rightValueLabelStatic.getBoundingClientRect().right);
+        const labelFontSize = this.getFontSizeForElement(leftValueLabel);
+        const labelTransformedOverlap = this.getRangeLabelOverlap(leftValueLabelTransformed, rightValueLabelTransformed);
+        const hyphenLabel = leftValueLabel;
+        const labelOffset = labelFontSize / 2;
+        if (labelTransformedOverlap > 0) {
+            hyphenLabel.classList.add(CSS.hyphen, CSS.hyphenWrap);
+            if (rightValueLabelStaticHostOffset === 0 && leftValueLabelStaticHostOffset === 0) {
+                // Neither handle overlaps the host boundary
+                let leftValueLabelTranslate = labelTransformedOverlap / 2 - labelOffset;
+                leftValueLabelTranslate =
+                    Math.sign(leftValueLabelTranslate) === -1
+                        ? Math.abs(leftValueLabelTranslate)
+                        : -leftValueLabelTranslate;
+                const leftValueLabelTransformedHostOffset = this.getHostOffset(leftValueLabelTransformed.getBoundingClientRect().left +
+                    leftValueLabelTranslate -
+                    labelOffset, leftValueLabelTransformed.getBoundingClientRect().right +
+                    leftValueLabelTranslate -
+                    labelOffset);
+                let rightValueLabelTranslate = labelTransformedOverlap / 2;
+                const rightValueLabelTransformedHostOffset = this.getHostOffset(rightValueLabelTransformed.getBoundingClientRect().left + rightValueLabelTranslate, rightValueLabelTransformed.getBoundingClientRect().right + rightValueLabelTranslate);
+                if (leftValueLabelTransformedHostOffset !== 0) {
+                    leftValueLabelTranslate += leftValueLabelTransformedHostOffset;
+                    rightValueLabelTranslate += leftValueLabelTransformedHostOffset;
+                }
+                if (rightValueLabelTransformedHostOffset !== 0) {
+                    leftValueLabelTranslate += rightValueLabelTransformedHostOffset;
+                    rightValueLabelTranslate += rightValueLabelTransformedHostOffset;
+                }
+                leftValueLabel.style.transform = `translateX(${leftValueLabelTranslate}px)`;
+                leftValueLabelTransformed.style.transform = `translateX(${leftValueLabelTranslate - labelOffset}px)`;
+                rightValueLabel.style.transform = `translateX(${rightValueLabelTranslate}px)`;
+                rightValueLabelTransformed.style.transform = `translateX(${rightValueLabelTranslate}px)`;
+            }
+            else if (leftValueLabelStaticHostOffset > 0 || rightValueLabelStaticHostOffset > 0) {
+                // labels overlap host boundary on the left side
+                leftValueLabel.style.transform = `translateX(${leftValueLabelStaticHostOffset + labelOffset}px)`;
+                rightValueLabel.style.transform = `translateX(${labelTransformedOverlap + rightValueLabelStaticHostOffset}px)`;
+                rightValueLabelTransformed.style.transform = `translateX(${labelTransformedOverlap + rightValueLabelStaticHostOffset}px)`;
+            }
+            else if (leftValueLabelStaticHostOffset < 0 || rightValueLabelStaticHostOffset < 0) {
+                // labels overlap host boundary on the right side
+                let leftValueLabelTranslate = Math.abs(leftValueLabelStaticHostOffset) + labelTransformedOverlap - labelOffset;
+                leftValueLabelTranslate =
+                    Math.sign(leftValueLabelTranslate) === -1
+                        ? Math.abs(leftValueLabelTranslate)
+                        : -leftValueLabelTranslate;
+                leftValueLabel.style.transform = `translateX(${leftValueLabelTranslate}px)`;
+                leftValueLabelTransformed.style.transform = `translateX(${leftValueLabelTranslate - labelOffset}px)`;
+            }
+        }
+        else {
+            hyphenLabel.classList.remove(CSS.hyphen, CSS.hyphenWrap);
+            leftValueLabel.style.transform = `translateX(${leftValueLabelStaticHostOffset}px)`;
+            leftValueLabelTransformed.style.transform = `translateX(${leftValueLabelStaticHostOffset}px)`;
+            rightValueLabel.style.transform = `translateX(${rightValueLabelStaticHostOffset}px)`;
+            rightValueLabelTransformed.style.transform = `translateX(${rightValueLabelStaticHostOffset}px)`;
+        }
+    }
+    /**
+     * Hides bounding tick labels that are obscured by either handle.
+     */
+    hideObscuredBoundingTickLabels() {
+        const valueIsRange = isRange(this.value);
+        if (!this.hasHistogram && !valueIsRange && !this.labelHandles && !this.precise) {
+            return;
+        }
+        if (!this.hasHistogram && !valueIsRange && this.labelHandles && !this.precise) {
+            return;
+        }
+        if (!this.hasHistogram && !valueIsRange && !this.labelHandles && this.precise) {
+            return;
+        }
+        if (!this.hasHistogram && !valueIsRange && this.labelHandles && this.precise) {
+            return;
+        }
+        if (!this.hasHistogram && valueIsRange && !this.precise) {
+            return;
+        }
+        if (this.hasHistogram && !this.precise && !this.labelHandles) {
+            return;
+        }
+        const minHandle = this.el.shadowRoot.querySelector(`.${CSS.thumbMinValue}`);
+        const maxHandle = this.el.shadowRoot.querySelector(`.${CSS.thumbValue}`);
+        const minTickLabel = this.el.shadowRoot.querySelector(`.${CSS.tickMin}`);
+        const maxTickLabel = this.el.shadowRoot.querySelector(`.${CSS.tickMax}`);
+        if (!minHandle && maxHandle && minTickLabel && maxTickLabel) {
+            minTickLabel.style.opacity = this.isMinTickLabelObscured(minTickLabel, maxHandle) ? "0" : "1";
+            maxTickLabel.style.opacity = this.isMaxTickLabelObscured(maxTickLabel, maxHandle) ? "0" : "1";
+        }
+        if (minHandle && maxHandle && minTickLabel && maxTickLabel) {
+            minTickLabel.style.opacity =
+                this.isMinTickLabelObscured(minTickLabel, minHandle) ||
+                    this.isMinTickLabelObscured(minTickLabel, maxHandle)
+                    ? "0"
+                    : "1";
+            maxTickLabel.style.opacity =
+                this.isMaxTickLabelObscured(maxTickLabel, minHandle) ||
+                    (this.isMaxTickLabelObscured(maxTickLabel, maxHandle) && this.hasHistogram)
+                    ? "0"
+                    : "1";
+        }
+    }
+    /**
+     * Returns an integer representing the number of pixels to offset on the left or right side based on desired position behavior.
+     *
+     * @param leftBounds
+     * @param rightBounds
+     * @internal
+     */
+    getHostOffset(leftBounds, rightBounds) {
+        const hostBounds = this.el.getBoundingClientRect();
+        const buffer = 7;
+        if (leftBounds + buffer < hostBounds.left) {
+            return hostBounds.left - leftBounds - buffer;
+        }
+        if (rightBounds - buffer > hostBounds.right) {
+            return -(rightBounds - hostBounds.right) + buffer;
+        }
+        return 0;
+    }
+    /**
+     * Returns an integer representing the number of pixels that the two given span elements are overlapping, taking into account
+     * a space in between the two spans equal to the font-size set on them to account for the space needed to render a hyphen.
+     *
+     * @param leftLabel
+     * @param rightLabel
+     */
+    getRangeLabelOverlap(leftLabel, rightLabel) {
+        const leftLabelBounds = leftLabel.getBoundingClientRect();
+        const rightLabelBounds = rightLabel.getBoundingClientRect();
+        const leftLabelFontSize = this.getFontSizeForElement(leftLabel);
+        const rangeLabelOverlap = leftLabelBounds.right + leftLabelFontSize - rightLabelBounds.left;
+        return Math.max(rangeLabelOverlap, 0);
+    }
+    /**
+     * Returns a boolean value representing if the minLabel span element is obscured (being overlapped) by the given handle div element.
+     *
+     * @param minLabel
+     * @param handle
+     */
+    isMinTickLabelObscured(minLabel, handle) {
+        const minLabelBounds = minLabel.getBoundingClientRect();
+        const handleBounds = handle.getBoundingClientRect();
+        return intersects(minLabelBounds, handleBounds);
+    }
+    /**
+     * Returns a boolean value representing if the maxLabel span element is obscured (being overlapped) by the given handle div element.
+     *
+     * @param maxLabel
+     * @param handle
+     */
+    isMaxTickLabelObscured(maxLabel, handle) {
+        const maxLabelBounds = maxLabel.getBoundingClientRect();
+        const handleBounds = handle.getBoundingClientRect();
+        return intersects(maxLabelBounds, handleBounds);
+    }
+    internalLabelFormatter(value, type) {
+        const customFormatter = this.labelFormatter;
+        if (!customFormatter) {
+            return this.formatValue(value);
+        }
+        const formattedValue = customFormatter(value, type, this.formatValue);
+        if (formattedValue == null) {
+            return this.formatValue(value);
+        }
+        return formattedValue;
+    }
+    static get delegatesFocus() { return true; }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "histogram": ["histogramWatcher"],
+        "ticks": ["ticksWatcher"],
+        "value": ["valueHandler"],
+        "minValue": ["minMaxValueHandler"],
+        "maxValue": ["minMaxValueHandler"]
+    }; }
+};
+Slider.style = CalciteSliderStyle0;
+
+export { Combobox as calcite_combobox, Graph as calcite_graph, Slider as calcite_slider };