npm - @sbb-esta/lyne-elements - Versions diffs - 5.0.0-next → 5.0.0-next.1 - Mend

@sbb-esta/lyne-elements 5.0.0-next → 5.0.0-next.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (984) hide show

package/development/select.component-BnHx3v3c.js ADDED Viewed

@@ -0,0 +1,806 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, nothing, unsafeCSS } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SbbDisabledMixin, SbbEscapableOverlayController, SbbFormAssociatedMixin, SbbLanguageController, SbbNegativeMixin, SbbOpenCloseBaseElement, SbbPropertyWatcherController, SbbReadonlyMixin, SbbRequiredMixin, SbbUpdateSchedulerMixin, boxSizingStyles, forceType, getNextElementIndex, getOverride, handleDistinctChange, i18nSelectionRequired, isEventOnElement, isLean, isNextjs, isSafari, isZeroAnimationDuration, overlayGapFixCorners, setOrRemoveAttribute, setOverlayPosition } from "./core.js";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { ref } from "lit/directives/ref.js";
+import { MutationController } from "@lit-labs/observers/mutation-controller.js";
+import { until } from "lit/directives/until.js";
+//#region src/elements/select/select.scss?inline
+var select_default = ".sbb-gap-fix-wrapper {\n  position: relative;\n  overflow: hidden;\n  width: var(--sbb-options-panel-border-radius);\n  height: var(--sbb-options-panel-border-radius);\n  background-color: transparent;\n}\n\n.sbb-gap-fix-corner {\n  position: absolute;\n  border-radius: 50%;\n  border: calc(var(--sbb-options-panel-border-radius) / 2) solid var(--sbb-options-panel-background-color);\n  width: calc(var(--sbb-options-panel-border-radius) * 3);\n  height: calc(var(--sbb-options-panel-border-radius) * 3);\n  bottom: calc(var(--sbb-options-panel-border-radius) / 2 * -1);\n}\n\n.sbb-gap-fix-corner#left {\n  left: calc(var(--sbb-options-panel-border-radius) / 2 * -1);\n}\n:host(:dir(rtl)) .sbb-gap-fix-corner#left {\n  right: calc(var(--sbb-options-panel-border-radius) / 2 * -1);\n  left: unset;\n}\n\n.sbb-gap-fix-corner#right {\n  right: calc(var(--sbb-options-panel-border-radius) / 2 * -1);\n}\n:host(:dir(rtl)) .sbb-gap-fix-corner#right {\n  left: calc(var(--sbb-options-panel-border-radius) / 2 * -1);\n  right: unset;\n}\n\n:host {\n  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);\n  --sbb-scrollbar-thumb-width: 0.125rem;\n  --sbb-scrollbar-thumb-width-hover: 0.25rem;\n  --sbb-scrollbar-width-firefox: thin;\n  --sbb-scrollbar-color: color-mix(in srgb, var(--sbb-color-black) 30%, transparent);\n  --sbb-scrollbar-color: light-dark(\n    color-mix(in srgb, var(--sbb-color-black) 30%, transparent),\n    color-mix(in srgb, var(--sbb-color-white) 30%, transparent)\n  );\n  --sbb-scrollbar-color-hover: color-mix(in srgb, var(--sbb-color-black) 60%, transparent);\n  --sbb-scrollbar-color-hover: light-dark(\n    color-mix(in srgb, var(--sbb-color-black) 60%, transparent),\n    color-mix(in srgb, var(--sbb-color-white) 60%, transparent)\n  );\n  --sbb-scrollbar-track-color: transparent;\n  --sbb-options-panel-position-x: 0;\n  --sbb-options-panel-position-y: 0;\n  --_sbb-options-panel-max-height: min(\n    var(--sbb-options-panel-max-height-calculated),\n    var(--sbb-options-panel-max-height, 100000em)\n  );\n  --sbb-options-panel-min-height: var(--sbb-options-panel-origin-height);\n  --sbb-options-panel-options-border-radius: 0 0 var(--sbb-options-panel-border-radius)\n    var(--sbb-options-panel-border-radius);\n  --sbb-options-panel-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-4x)\n  );\n  --sbb-options-panel-gap-fix-top: calc(\n    var(--sbb-options-panel-position-y) - var(--sbb-options-panel-border-radius)\n  );\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-default);\n  --sbb-focus-outline-color: light-dark(\n    var(--sbb-focus-outline-color-default),\n    var(--sbb-focus-outline-color-dark)\n  );\n  --sbb-options-panel-internal-z-index: var(\n    --sbb-select-z-index,\n    var(--sbb-overlay-default-z-index)\n  );\n  display: block;\n  font-weight: normal;\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n:host([size=s]) {\n  --sbb-options-panel-padding-block: var(--sbb-spacing-fixed-1x);\n}\n\n:host([size=m]) {\n  --sbb-options-panel-padding-block: var(--sbb-spacing-fixed-2x);\n}\n\n:host([negative]) {\n  --sbb-scrollbar-color: color-mix(in srgb, var(--sbb-color-white) 30%, transparent);\n  --sbb-scrollbar-color-hover: color-mix(in srgb, var(--sbb-color-white) 60%, transparent);\n  --sbb-options-panel-background-color: var(--sbb-background-color-2-negative);\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\n  --sbb-select-placeholder-fallback-color: var(--sbb-color-5);\n}\n\n:host(:not(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))),\n:host(:is(:state(state-closed),[state--state-closed])) {\n  --sbb-options-panel-visibility: hidden;\n}\n\n:host(:is(:state(state-opening),[state--state-opening])) {\n  --sbb-options-panel-animation-name: open;\n}\n\n:host(:is(:state(state-closing),[state--state-closing])) {\n  --sbb-options-panel-animation-name: close;\n}\n\n:host(:is(:state(state-opened),[state--state-opened])),\n:host(:is(:state(state-opening),[state--state-opening])) {\n  --sbb-options-panel-gap-fix-opacity: 1;\n}\n\n:host(:is(:state(options-panel-position-below),[state--options-panel-position-below])) {\n  --sbb-options-panel-animation-transform: translateY(\n    calc((var(--sbb-options-panel-origin-height) / 2) * -1)\n  );\n}\n\n:host(:is(:state(options-panel-position-above),[state--options-panel-position-above])) {\n  --sbb-options-panel-options-border-radius: var(--sbb-options-panel-border-radius)\n    var(--sbb-options-panel-border-radius) 0 0;\n  --sbb-options-panel-gap-fix-top: var(--_sbb-options-panel-max-height);\n  --sbb-options-panel-gap-fix-transform: rotate(180deg);\n  --sbb-options-panel-animation-transform: translateY(\n    calc(var(--sbb-options-panel-origin-height) / 2)\n  );\n}\n\n::slotted(sbb-divider) {\n  margin-block: var(--sbb-options-panel-divider-margin-block);\n}\n\n:host([preserve-icon-space]) {\n  --sbb-option-icon-container-display: block;\n}\n\n.sbb-select__trigger {\n  overflow: hidden;\n  white-space: nowrap;\n  text-overflow: ellipsis;\n  cursor: var(--sbb-cursor-default);\n  height: calc(1em * var(--sbb-typo-line-height-text));\n}\n:host(:not(:is(:state(has-display-value),[state--has-display-value]))) .sbb-select__trigger {\n  color: var(--sbb-select-placeholder-color, var(--sbb-select-placeholder-fallback-color));\n  -webkit-text-fill-color: var(--sbb-select-placeholder-color, var(--sbb-select-placeholder-fallback-color));\n}\n\n.sbb-select__container {\n  position: fixed;\n  pointer-events: none;\n  inset: 0;\n  z-index: var(--sbb-options-panel-internal-z-index);\n}\n.sbb-select__container[popover] {\n  margin: 0;\n  padding: 0;\n  border: none;\n  width: auto;\n  height: auto;\n  background-color: transparent;\n}\n\n.sbb-select__gap-fix {\n  display: flex;\n  justify-content: space-between;\n  position: fixed;\n  visibility: var(--sbb-options-panel-visibility, visible);\n  opacity: var(--sbb-options-panel-gap-fix-opacity, 0);\n  background-color: transparent;\n  width: var(--sbb-options-panel-width, fit-content);\n  height: var(--sbb-options-panel-border-radius);\n  top: var(--sbb-options-panel-gap-fix-top);\n  left: var(--sbb-options-panel-position-x);\n  transform: var(--sbb-options-panel-gap-fix-transform, none);\n  transition: opacity var(--sbb-options-panel-animation-duration) var(--sbb-options-panel-animation-timing-function);\n}\n\n.sbb-select__panel {\n  display: block;\n  position: absolute;\n  visibility: var(--sbb-options-panel-visibility, \"visible\");\n  overflow: hidden;\n  background-color: transparent;\n  border: none;\n  border-radius: var(--sbb-options-panel-border-radius);\n  top: var(--sbb-options-panel-position-y);\n  left: var(--sbb-options-panel-position-x);\n  width: var(--sbb-options-panel-width, fit-content);\n  transition: box-shadow var(--sbb-options-panel-animation-duration) var(--sbb-options-panel-animation-timing-function);\n}\n.sbb-select__panel::before, .sbb-select__panel::after {\n  content: \"\";\n  display: none;\n  position: relative;\n  width: 100%;\n  height: var(--sbb-options-panel-origin-height);\n  background-color: transparent;\n  border-radius: var(--sbb-options-panel-border-radius);\n  pointer-events: none;\n  transition: box-shadow var(--sbb-options-panel-animation-duration) var(--sbb-options-panel-animation-timing-function);\n  z-index: 1;\n}\n:host(:is(:state(options-panel-position-below),[state--options-panel-position-below])) .sbb-select__panel {\n  inset-block-start: calc(var(--sbb-options-panel-position-y) - var(--sbb-options-panel-origin-height));\n}\n:host(:is(:is(:state(state-opened),[state--state-opened]), :is(:state(state-opening),[state--state-opening]))) .sbb-select__panel {\n  box-shadow: var(--sbb-box-shadow-level-9-hard);\n}\n:host(:is(:is(:state(state-opened),[state--state-opened]), :is(:state(state-opening),[state--state-opening]))[negative]) .sbb-select__panel {\n  box-shadow: var(--sbb-box-shadow-level-9-hard-negative);\n}\n:host(:is(:state(options-panel-position-below),[state--options-panel-position-below])) .sbb-select__panel::before {\n  display: block;\n}\n:host(:is(:state(options-panel-position-above),[state--options-panel-position-above])) .sbb-select__panel::after {\n  display: block;\n}\n:host(:is(:is(:state(state-opened),[state--state-opened]), :is(:state(state-opening),[state--state-opening])):is(:state(option-panel-origin-borderless),[state--option-panel-origin-borderless])) .sbb-select__panel::before, :host(:is(:is(:state(state-opened),[state--state-opened]), :is(:state(state-opening),[state--state-opening])):is(:state(option-panel-origin-borderless),[state--option-panel-origin-borderless])) .sbb-select__panel::after {\n  box-shadow: var(--sbb-box-shadow-level-9-hard);\n}\n:host(:is(:is(:state(state-opened),[state--state-opened]), :is(:state(state-opening),[state--state-opening])):is(:state(option-panel-origin-borderless),[state--option-panel-origin-borderless])[negative]) .sbb-select__panel::before, :host(:is(:is(:state(state-opened),[state--state-opened]), :is(:state(state-opening),[state--state-opening])):is(:state(option-panel-origin-borderless),[state--option-panel-origin-borderless])[negative]) .sbb-select__panel::after {\n  box-shadow: var(--sbb-box-shadow-level-9-hard-negative);\n}\n\n.sbb-select__wrapper {\n  overflow: hidden;\n}\n\n.sbb-select__options {\n  background-color: var(--sbb-options-panel-background-color);\n  padding-block: var(--sbb-options-panel-padding-block);\n  padding-inline: 0;\n  border-radius: var(--sbb-options-panel-options-border-radius);\n  max-height: var(--_sbb-options-panel-max-height);\n  min-height: var(--sbb-options-panel-min-height);\n  pointer-events: all;\n  overflow-y: auto;\n  animation-name: var(--sbb-options-panel-animation-name);\n  animation-duration: var(--sbb-options-panel-animation-duration);\n  animation-timing-function: var(--sbb-options-panel-animation-timing-function);\n}\n.sbb-select__options::-webkit-scrollbar {\n  width: var(--sbb-scrollbar-width);\n  height: var(--sbb-scrollbar-width);\n  background-color: var(--sbb-scrollbar-track-color, transparent);\n}\n.sbb-select__options::-webkit-scrollbar-corner {\n  background-color: var(--sbb-scrollbar-track-color, transparent);\n}\n.sbb-select__options::-webkit-scrollbar-thumb {\n  background-color: var(--sbb-scrollbar-color, currentcolor);\n  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;\n  border-radius: var(--sbb-border-radius-4x);\n  background-clip: padding-box;\n}\n.sbb-select__options::-webkit-scrollbar-thumb:hover {\n  background-color: var(--sbb-scrollbar-color-hover, currentcolor);\n  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));\n}\n.sbb-select__options::-webkit-scrollbar-button, .sbb-select__options::-webkit-scrollbar-corner {\n  display: none;\n}\n@supports not selector(::-webkit-scrollbar) {\n  .sbb-select__options {\n    scrollbar-width: var(--sbb-scrollbar-width-firefox);\n    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);\n  }\n}\n@media (forced-colors: active) {\n  .sbb-select__options {\n    border: var(--sbb-border-width-1x) solid CanvasText;\n    border-block-start: none;\n  }\n}\n\n@keyframes open {\n  from {\n    transform: var(--sbb-options-panel-animation-transform);\n    opacity: 0;\n  }\n  to {\n    transform: translateY(0);\n    opacity: 1;\n  }\n}\n@keyframes close {\n  from {\n    transform: translateY(0);\n    opacity: 1;\n  }\n  to {\n    transform: var(--sbb-options-panel-animation-transform);\n    opacity: 0;\n  }\n}";
+//#endregion
+//#region src/elements/select/select.component.ts
+/**
+* On Safari, the aria role 'listbox' must be on the host element, or else VoiceOver won't work at all.
+* On the other hand, JAWS and NVDA need the role to be an "immediate parent" to the options, or else optgroups won't work.
+*/
+var ariaRoleOnHost = isSafari;
+var nextId = 0;
+/**
+* It displays a panel with selectable options.
+*
+* @slot - Use the unnamed slot to add options.
+* @cssprop [--sbb-select-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+* the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+* component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+* @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.
+* If the calculated remaining space is smaller, the value gets ignored.
+* @overrideType value - (T = string | string[]) | null
+*/
+var SbbSelectElement = (() => {
+	let _classSuper = SbbUpdateSchedulerMixin(SbbDisabledMixin(SbbNegativeMixin(SbbRequiredMixin(SbbReadonlyMixin(SbbFormAssociatedMixin(SbbOpenCloseBaseElement))))));
+	let _instanceExtraInitializers = [];
+	let _placeholder_decorators;
+	let _placeholder_initializers = [];
+	let _placeholder_extraInitializers = [];
+	let _multiple_decorators;
+	let _multiple_initializers = [];
+	let _multiple_extraInitializers = [];
+	let _compareWith_decorators;
+	let _compareWith_initializers = [];
+	let _compareWith_extraInitializers = [];
+	let _disabled_decorators;
+	let _disabled_initializers = [];
+	let _disabled_extraInitializers = [];
+	let _set_value_decorators;
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let __displayValue_decorators;
+	let __displayValue_initializers = [];
+	let __displayValue_extraInitializers = [];
+	return class SbbSelectElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_placeholder_decorators = [forceType(), property()];
+			_multiple_decorators = [
+				forceType(),
+				handleDistinctChange((e, newValue) => e._onMultipleChanged(newValue)),
+				property({
+					reflect: true,
+					type: Boolean
+				})
+			];
+			_compareWith_decorators = [property({ attribute: false })];
+			_disabled_decorators = [
+				forceType(),
+				handleDistinctChange((e, newValue) => e._closeOnDisabledReadonlyChanged(newValue)),
+				property({
+					reflect: true,
+					type: Boolean
+				}),
+				getOverride((e, v) => v || e.isDisabledExternally())
+			];
+			_set_value_decorators = [property()];
+			_size_decorators = [property({ reflect: true })];
+			__displayValue_decorators = [state()];
+			__esDecorate(this, null, _placeholder_decorators, {
+				kind: "accessor",
+				name: "placeholder",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "placeholder" in obj,
+					get: (obj) => obj.placeholder,
+					set: (obj, value) => {
+						obj.placeholder = value;
+					}
+				},
+				metadata: _metadata
+			}, _placeholder_initializers, _placeholder_extraInitializers);
+			__esDecorate(this, null, _multiple_decorators, {
+				kind: "accessor",
+				name: "multiple",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "multiple" in obj,
+					get: (obj) => obj.multiple,
+					set: (obj, value) => {
+						obj.multiple = value;
+					}
+				},
+				metadata: _metadata
+			}, _multiple_initializers, _multiple_extraInitializers);
+			__esDecorate(this, null, _compareWith_decorators, {
+				kind: "accessor",
+				name: "compareWith",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "compareWith" in obj,
+					get: (obj) => obj.compareWith,
+					set: (obj, value) => {
+						obj.compareWith = value;
+					}
+				},
+				metadata: _metadata
+			}, _compareWith_initializers, _compareWith_extraInitializers);
+			__esDecorate(this, null, _disabled_decorators, {
+				kind: "accessor",
+				name: "disabled",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "disabled" in obj,
+					get: (obj) => obj.disabled,
+					set: (obj, value) => {
+						obj.disabled = value;
+					}
+				},
+				metadata: _metadata
+			}, _disabled_initializers, _disabled_extraInitializers);
+			__esDecorate(this, null, _set_value_decorators, {
+				kind: "setter",
+				name: "value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "value" in obj,
+					set: (obj, value) => {
+						obj.value = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _size_decorators, {
+				kind: "accessor",
+				name: "size",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "size" in obj,
+					get: (obj) => obj.size,
+					set: (obj, value) => {
+						obj.size = value;
+					}
+				},
+				metadata: _metadata
+			}, _size_initializers, _size_extraInitializers);
+			__esDecorate(this, null, __displayValue_decorators, {
+				kind: "accessor",
+				name: "_displayValue",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_displayValue" in obj,
+					get: (obj) => obj._displayValue,
+					set: (obj, value) => {
+						obj._displayValue = value;
+					}
+				},
+				metadata: _metadata
+			}, __displayValue_initializers, __displayValue_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-select";
+		}
+		static {
+			this.role = ariaRoleOnHost ? "listbox" : null;
+		}
+		static {
+			this.styles = [boxSizingStyles, unsafeCSS(select_default)];
+		}
+		static {
+			this.events = {
+				change: "change",
+				input: "input",
+				displayvaluechange: "displayvaluechange",
+				beforeopen: "beforeopen",
+				open: "open",
+				beforeclose: "beforeclose",
+				close: "close"
+			};
+		}
+		#placeholder_accessor_storage;
+		/** The placeholder used if no value has been selected. */
+		get placeholder() {
+			return this.#placeholder_accessor_storage;
+		}
+		set placeholder(value) {
+			this.#placeholder_accessor_storage = value;
+		}
+		#multiple_accessor_storage;
+		/** Whether the select allows for multiple selection. */
+		get multiple() {
+			return this.#multiple_accessor_storage;
+		}
+		set multiple(value) {
+			this.#multiple_accessor_storage = value;
+		}
+		#compareWith_accessor_storage;
+		/** Function used to compare option values. */
+		get compareWith() {
+			return this.#compareWith_accessor_storage;
+		}
+		set compareWith(value) {
+			this.#compareWith_accessor_storage = value;
+		}
+		#disabled_accessor_storage;
+		get disabled() {
+			return this.#disabled_accessor_storage;
+		}
+		set disabled(value) {
+			this.#disabled_accessor_storage = value;
+		}
+		/** Value of the form element. */
+		set value(value) {
+			this._value = value;
+			this._isValueManuallyAssigned = true;
+			this._updateOptionsFromValue();
+		}
+		get value() {
+			return this._value;
+		}
+		#size_accessor_storage;
+		/**
+		* Size variant, either m or s.
+		* @default 'm' / 's' (lean)
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		/**
+		* Form type of element.
+		* @default 'select-one / select-multiple'
+		*/
+		get type() {
+			return this.multiple ? "select-multiple" : "select-one";
+		}
+		#_displayValue_accessor_storage;
+		/** The value displayed by the component. */
+		get _displayValue() {
+			return this.#_displayValue_accessor_storage;
+		}
+		set _displayValue(value) {
+			this.#_displayValue_accessor_storage = value;
+		}
+		/**
+		* The 'combobox' input element
+		* @internal
+		*/
+		get inputElement() {
+			return this._triggerElement ?? null;
+		}
+		/** Returns all SbbOptionElements from this sbb-select instance. */
+		get options() {
+			const options = [];
+			this.querySelectorAll?.("sbb-option").forEach((option) => {
+				customElements.upgrade(option);
+				options.push(option);
+			});
+			return options;
+		}
+		constructor() {
+			super();
+			this.#placeholder_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _placeholder_initializers, ""));
+			this.#multiple_accessor_storage = (__runInitializers(this, _placeholder_extraInitializers), __runInitializers(this, _multiple_initializers, false));
+			this.#compareWith_accessor_storage = (__runInitializers(this, _multiple_extraInitializers), __runInitializers(this, _compareWith_initializers, (v1, v2) => v1 === v2));
+			this.#disabled_accessor_storage = (__runInitializers(this, _compareWith_extraInitializers), __runInitializers(this, _disabled_initializers, false));
+			this._value = (__runInitializers(this, _disabled_extraInitializers), null);
+			this.#size_accessor_storage = __runInitializers(this, _size_initializers, isLean() ? "s" : "m");
+			this.#_displayValue_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, __displayValue_initializers, null));
+			this._originResizeObserver = (__runInitializers(this, __displayValue_extraInitializers), new ResizeController(this, {
+				target: null,
+				skipInitial: true,
+				callback: () => {
+					if (this.isOpen) this._setOverlayPosition();
+				}
+			}));
+			this._originElement = null;
+			this._triggerElement = null;
+			this._escapableOverlayController = new SbbEscapableOverlayController(this);
+			this._overlayId = `sbb-select-${++nextId}`;
+			this._activeItemIndex = -1;
+			this._searchString = "";
+			this._didLoad = false;
+			this._isPointerDownEventOnMenu = false;
+			this._languageController = new SbbLanguageController(this);
+			this._isValueManuallyAssigned = false;
+			this._pointerDownListener = (event) => {
+				this._isPointerDownEventOnMenu = isEventOnElement(this._overlay, event);
+			};
+			this._closeOnBackdropClick = (event) => {
+				if (!this._isPointerDownEventOnMenu && !isEventOnElement(this._overlay, event)) this.close();
+			};
+			this.addEventListener?.("optionselectionchange", (e) => this._onOptionChanged(e));
+			this.addEventListener?.("optionLabelChanged", (e) => this._onOptionLabelChanged(e));
+			/** Forces the sbb-select to update his value. */
+			this.addEventListener?.("ɵoptionvaluechange", () => this._updateValueOptionState());
+			this.addEventListener?.("ɵoptgroupslotchange", () => this._updateValueOptionState(), { capture: true });
+			this.addEventListener?.("click", (e) => {
+				const target = e.target;
+				if (target.localName === "sbb-option") {
+					if (!this.multiple && !target.disabled) {
+						this.close();
+						this.focus();
+					}
+				} else this._toggleOpening();
+			});
+			this.addController(new MutationController(this, {
+				config: { attributeFilter: [
+					"aria-labelledby",
+					"aria-label",
+					"aria-describedby"
+				] },
+				callback: () => this._syncAriaLabels()
+			}));
+			this.addController(new SbbPropertyWatcherController(this, () => this.closest("sbb-form-field"), { negative: (e) => {
+				this.negative = e.negative;
+				this._syncNegative();
+			} }));
+		}
+		_syncAriaLabels() {
+			if (!this._triggerElement || isServer) return;
+			setOrRemoveAttribute(this._triggerElement, "aria-labelledby", this.getAttribute("aria-labelledby"));
+			setOrRemoveAttribute(this._triggerElement, "aria-label", this.getAttribute("aria-label"));
+			setOrRemoveAttribute(this._triggerElement, "aria-describedby", this.getAttribute("aria-describedby"));
+			if (!this.getAttribute("aria-label") && !this.getAttribute("aria-labelledby") && this.internals.labels.length) this._triggerElement?.setAttribute("aria-label", Array.from(this.internals.labels).map((label) => label.textContent).join(", "));
+		}
+		/** Opens the selection panel. */
+		open() {
+			if (this.state === "opening" || this.state === "opened" || !this._overlay || this.options.length === 0 || this.disabled || this.formDisabled || !this.dispatchBeforeOpenEvent()) return;
+			this.shadowRoot?.querySelector(".sbb-select__container")?.showPopover?.();
+			this.state = "opening";
+			this.internals.states.add("expanded");
+			this._setOverlayPosition();
+			this._escapableOverlayController.connect();
+			this._attachOpenPanelEvents();
+			if (this._isZeroAnimationDuration()) this._handleOpening();
+		}
+		/** Closes the selection panel. */
+		close() {
+			if (this.state === "closing" || this.state === "closed" || !this.dispatchBeforeCloseEvent()) return;
+			this.state = "closing";
+			this.internals.states.delete("expanded");
+			this._openPanelEventsController?.abort();
+			if (this._originElement) this._originResizeObserver.unobserve(this._originElement);
+			if (this._isZeroAnimationDuration()) this._handleClosing();
+		}
+		_isZeroAnimationDuration() {
+			return isZeroAnimationDuration(this, "--sbb-options-panel-animation-duration");
+		}
+		/** Gets the current displayed value. */
+		getDisplayValue() {
+			return this._displayValue ?? "";
+		}
+		_selectableOptions() {
+			return this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
+		}
+		/** Listens to option changes. */
+		_onOptionChanged(event) {
+			const target = event.target;
+			if (target.selected) this._onOptionSelected(target);
+			else this._onOptionDeselected(target);
+		}
+		/** Listens to option changes. */
+		_onOptionLabelChanged(event) {
+			const target = event.target;
+			const selected = this._getSelected();
+			if (!Array.isArray(selected) && target !== selected || Array.isArray(selected) && !selected.includes(target)) return;
+			this._updateDisplayValue();
+		}
+		_updateDisplayValue() {
+			const selected = this._getSelected();
+			if (Array.isArray(selected)) this._displayValue = selected.map((o) => o.textContent?.trim()).join(", ") || null;
+			else if (selected) this._displayValue = selected?.textContent?.trim() || null;
+			else this._displayValue = null;
+			this.toggleState("has-display-value", !!this._displayValue);
+			/** @internal */
+			this.dispatchEvent(new Event("displayvaluechange", {
+				bubbles: true,
+				composed: true
+			}));
+		}
+		/**
+		* The `value` property should be adapted when the `multiple` property changes:
+		*   - if it changes to true, the 'value' is set to an array;
+		*   - if it changes to false, the first available option is set as 'value' otherwise it's set to null.
+		*/
+		_onMultipleChanged(isChangingToMultiple) {
+			if (isChangingToMultiple) this._value = this._isValueManuallyAssigned || this.value != null ? [this.value] : [];
+			else if (Array.isArray(this.value)) this._value = this.value.length ? this.value[0] : null;
+			this._updateDisplayValue();
+		}
+		/**
+		* If the `disabled` or the `readonly` properties are set, and the panel is open, close it.
+		*/
+		_closeOnDisabledReadonlyChanged(newValue) {
+			if ((this.state === "opening" || this.state === "opened") && newValue) this.close();
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._updateValueOptionState();
+			if (!isNextjs()) {
+				this.startUpdate();
+				this._setupSelect();
+			}
+		}
+		/** @internal */
+		focus() {
+			this._triggerElement?.focus();
+		}
+		/** @internal */
+		blur() {
+			this._triggerElement?.blur();
+		}
+		/**
+		* Removes element's first attribute whose qualified name is qualifiedName.
+		*
+		* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/removeAttribute)
+		* @internal We need to override this due to a hydration issue with Next.js.
+		*/
+		removeAttribute(qualifiedName) {
+			if (isNextjs() && qualifiedName === "defer-hydration" && !this._didLoad) this.updateComplete.then(() => this._setupSelect());
+			super.removeAttribute(qualifiedName);
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			if (ariaRoleOnHost) this.id ||= this._overlayId;
+			this._syncNegative();
+			this._syncAriaLabels();
+			if (this._didLoad) {
+				this._setupOrigin();
+				this._setupTrigger();
+			}
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (!name && this.hasUpdated) setTimeout(() => this._syncAriaLabels());
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("negative")) this._syncNegative();
+			if (changedProperties.has("readOnly")) this._closeOnDisabledReadonlyChanged(this.readOnly);
+		}
+		disconnectedCallback() {
+			if (this._triggerElement) this.prepend(this._triggerElement);
+			super.disconnectedCallback();
+			this._openPanelEventsController?.abort();
+		}
+		/**
+		* The reset value is the attribute value (the setup value), null otherwise.
+		* @internal
+		*/
+		formResetCallback() {
+			this.value = this.hasAttribute("value") ? this.getAttribute("value") : null;
+		}
+		/**
+		* @internal
+		*/
+		formStateRestoreCallback(state, _reason) {
+			try {
+				const { value, manuallyAssigned } = JSON.parse(state);
+				this._isValueManuallyAssigned = manuallyAssigned;
+				this._value = value;
+				this._updateOptionsFromValue();
+			} catch {
+				console.warn(`Failed to restore sbb-select with state ${state}`);
+			}
+		}
+		formState() {
+			return JSON.stringify({
+				value: this.value,
+				manuallyAssigned: this._isValueManuallyAssigned
+			});
+		}
+		_syncNegative() {
+			this.querySelectorAll?.("sbb-divider, sbb-option-hint").forEach((el) => el.negative = this.negative);
+		}
+		shouldValidate(name) {
+			return super.shouldValidate(name) || name === "value" || name === "required";
+		}
+		validate() {
+			super.validate();
+			const value = Array.isArray(this.value) ? this.value : this.value === null ? [] : [this.value];
+			if (this.required && (this.options.every((o) => value.every((v) => !this.compareWith(v, o.value))) || !this._isValueManuallyAssigned && this.value == null)) this.setValidityFlag("valueMissing", i18nSelectionRequired[this._languageController.current]);
+			else this.removeValidityFlag("valueMissing");
+		}
+		_setupSelect() {
+			this._setupOrigin();
+			this._setupTrigger();
+			this._didLoad = true;
+			this.completeUpdate();
+		}
+		/** Sets the originElement; if the component is used in a sbb-form-field uses it, otherwise uses the parentElement. */
+		_setupOrigin() {
+			const formField = this.closest?.("sbb-form-field");
+			if (this._originElement) this._originResizeObserver.unobserve(this._originElement);
+			this._originElement = formField?.shadowRoot?.querySelector?.("#overlay-anchor") ?? this.parentElement;
+			if (this._originElement) {
+				this.toggleState("option-panel-origin-borderless", formField?.hasAttribute?.("borderless"));
+				if (this.isOpen) this._originResizeObserver.observe(this._originElement);
+			}
+		}
+		/**
+		* To assess screen-readers problems caused by the interaction between aria patterns and shadow DOM,
+		* we are forced to move the 'combobox' trigger element to the light DOM
+		*/
+		_setupTrigger() {
+			if (this.parentElement && this._triggerElement) this.parentElement.insertBefore?.(this._triggerElement, this);
+		}
+		_setOverlayPosition() {
+			if (!this._originElement) return;
+			setOverlayPosition(this._overlay, this._originElement, this._optionContainer, this.shadowRoot.querySelector(".sbb-select__container"), this);
+		}
+		_onAnimationEnd(event) {
+			if (event.animationName === "open" && this.state === "opening") this._handleOpening();
+			else if (event.animationName === "close" && this.state === "closing") this._handleClosing();
+		}
+		_handleOpening() {
+			this.state = "opened";
+			this._triggerElement?.setAttribute("aria-expanded", "true");
+			if (this._originElement) this._originResizeObserver.observe(this._originElement);
+			this.dispatchOpenEvent();
+		}
+		_handleClosing() {
+			this.state = "closed";
+			this.shadowRoot?.querySelector(".sbb-select__container")?.hidePopover?.();
+			this._triggerElement?.setAttribute("aria-expanded", "false");
+			this._resetActiveElement();
+			this._optionContainer.scrollTop = 0;
+			this._escapableOverlayController.disconnect();
+			this.dispatchCloseEvent();
+		}
+		/** When an option is selected, updates the displayValue; it also closes the select if not `multiple`. */
+		_onOptionSelected(option) {
+			if (!this.multiple) this._value = option.value;
+			else if (!this.value) this._value = [option.value];
+			else if (Array.isArray(this.value) && !this.value.some((v) => this.compareWith(v, option.value))) this._value = [...this.value, option.value];
+			this._updateOptionsFromValue();
+			this._dispatchInputEvents();
+		}
+		/** When an option is unselected in `multiple`, removes it from value and updates displayValue. */
+		_onOptionDeselected(optionSelectionChange) {
+			if (this.multiple && Array.isArray(this.value)) {
+				this._value = this.value.filter((el) => !this.compareWith(el, optionSelectionChange.value));
+				this._updateOptionsFromValue();
+				this._dispatchInputEvents();
+			}
+		}
+		_dispatchInputEvents() {
+			/** The input event fires when the value has been changed as a direct result of a user action. */
+			this.dispatchEvent(new InputEvent("input", {
+				bubbles: true,
+				composed: true
+			}));
+			/**
+			* The change event is fired when the user modifies the element's value.
+			* Unlike the input event, the change event is not necessarily fired
+			* for each alteration to an element's value.
+			*/
+			this.dispatchEvent(new Event("change", { bubbles: true }));
+		}
+		_attachOpenPanelEvents() {
+			this._openPanelEventsController = new AbortController();
+			document.addEventListener("scroll", () => this._setOverlayPosition(), {
+				passive: true,
+				signal: this._openPanelEventsController.signal,
+				capture: true
+			});
+			window.addEventListener("resize", () => this._setOverlayPosition(), {
+				passive: true,
+				signal: this._openPanelEventsController.signal
+			});
+			window.addEventListener("pointerdown", (ev) => this._pointerDownListener(ev), { signal: this._openPanelEventsController.signal });
+			window.addEventListener("pointerup", (ev) => this._closeOnBackdropClick(ev), { signal: this._openPanelEventsController.signal });
+		}
+		_onKeyDown(event) {
+			if (this.readOnly) return;
+			if (this.state === "opening" || this.state === "opened") this._openedPanelKeyboardInteraction(event);
+			else if (this.state === "closed" || this.state === "closing") this._closedPanelKeyboardInteraction(event);
+		}
+		_closedPanelKeyboardInteraction(event) {
+			if (this._checkForLetterSelection(event)) return this._setNextActiveOptionByText(event);
+			switch (event.key) {
+				case "Enter":
+				case " ":
+				case "ArrowDown":
+				case "ArrowUp":
+					event.preventDefault();
+					this.open();
+					break;
+			}
+		}
+		_openedPanelKeyboardInteraction(event) {
+			if (this.readOnly) return;
+			if (this._checkForLetterSelection(event)) return this._setNextActiveOptionByText(event);
+			switch (event.key) {
+				case "Tab":
+					this.close();
+					break;
+				case "Enter":
+				case " ":
+					event.preventDefault();
+					this._selectByKeyboard();
+					break;
+				case "ArrowDown":
+				case "ArrowUp":
+					event.preventDefault();
+					this._setNextActiveOption(event);
+					break;
+				case "Home":
+				case "PageUp":
+					event.preventDefault();
+					this._setNextActiveOption(event, 0);
+					break;
+				case "End":
+				case "PageDown":
+					event.preventDefault();
+					this._setNextActiveOption(event, this._selectableOptions().length - 1);
+					break;
+			}
+		}
+		_checkForLetterSelection(event) {
+			return event.key === "Backspace" || event.key === "Clear" || event.key.length === 1 && event.key !== " " && !event.altKey && !event.ctrlKey && !event.metaKey;
+		}
+		_setNextActiveOptionByText(event) {
+			if (typeof this._searchTimeout === typeof setTimeout) clearTimeout(this._searchTimeout);
+			this._searchTimeout = setTimeout(() => this._searchString = "", 1e3);
+			this._searchString += event.key;
+			const indexForSlice = this._activeItemIndex + 1;
+			const selectableOptions = this._selectableOptions();
+			const filteredOptionsSorted = [...selectableOptions.slice(indexForSlice), ...selectableOptions.slice(0, indexForSlice)];
+			const match = filteredOptionsSorted.find((option) => option.textContent?.toLowerCase().indexOf(this._searchString.toLowerCase()) === 0);
+			if (match) this._setNextActiveOption(event, selectableOptions.indexOf(match));
+			else if (this._searchString.length > 1 && new RegExp(`^${this._searchString.charAt(0)}*$`).test(this._searchString)) {
+				const firstMatch = filteredOptionsSorted.find((option) => option.textContent?.toLowerCase().indexOf(this._searchString[0].toLowerCase()) === 0);
+				if (firstMatch) this._setNextActiveOption(event, selectableOptions.indexOf(firstMatch));
+			} else {
+				clearTimeout(this._searchTimeout);
+				this._searchString = "";
+			}
+		}
+		_selectByKeyboard() {
+			const activeOption = this._selectableOptions()[this._activeItemIndex];
+			if (this.multiple) activeOption?.["selectViaUserInteraction"](!activeOption.selected);
+			else this.close();
+		}
+		_setNextActiveOption(event, index) {
+			const filteredOptions = this._selectableOptions();
+			if (filteredOptions.length === 0) return;
+			const nextIndex = index ?? getNextElementIndex(event, this._activeItemIndex, filteredOptions.length);
+			const nextOption = filteredOptions[nextIndex];
+			const activeOption = filteredOptions[this._activeItemIndex];
+			this._setActiveElement(nextOption, activeOption);
+			if (!this.multiple) this._setSelectedElement(nextOption, activeOption);
+			else if (event?.shiftKey) nextOption["selectViaUserInteraction"](!nextOption.selected);
+			this._activeItemIndex = nextIndex;
+		}
+		_setActiveElement(nextActiveOption, lastActiveOption = null, setActiveDescendant = true) {
+			nextActiveOption.setActive(true);
+			nextActiveOption.scrollIntoView({ block: "nearest" });
+			if (setActiveDescendant) this._triggerElement?.setAttribute("aria-activedescendant", nextActiveOption.id);
+			if (lastActiveOption && !this.compareWith(lastActiveOption.value, nextActiveOption.value)) lastActiveOption.setActive(false);
+		}
+		_setSelectedElement(nextActiveOption, lastActiveOption) {
+			nextActiveOption["selectViaUserInteraction"](true);
+			if (lastActiveOption && !this.compareWith(lastActiveOption.value, nextActiveOption.value)) lastActiveOption["selectViaUserInteraction"](false);
+		}
+		_resetActiveElement() {
+			const activeElement = this._selectableOptions()[this._activeItemIndex];
+			if (activeElement) activeElement.setActive(false);
+			this._activeItemIndex = -1;
+			this._triggerElement?.removeAttribute("aria-activedescendant");
+		}
+		_updateOptionsFromValue() {
+			const value = Array.isArray(this.value) ? this.value : [this.value];
+			const displayValues = [];
+			for (const option of this.options) {
+				option.selected = value.some((v) => this.compareWith(v, option.value));
+				if (option.selected) displayValues.push(option);
+			}
+			this._updateDisplayValue();
+			if (!Array.isArray(this.value)) {
+				const value = this.value;
+				this._activeItemIndex = this._selectableOptions().findIndex((option) => this.compareWith(option.value, value));
+			}
+		}
+		_updateValueFromOptions() {
+			const selected = this._getSelected();
+			if (Array.isArray(selected)) {
+				if (selected && selected.length > 0) {
+					const value = [];
+					for (const option of selected) value.push(option.value);
+					this._value = value;
+				}
+			} else if (selected) {
+				this._activeItemIndex = this._selectableOptions().findIndex((option) => option === selected);
+				this._value = selected.value;
+			}
+			this._updateDisplayValue();
+		}
+		_updateValueOptionState() {
+			if (this._isValueManuallyAssigned) this._updateOptionsFromValue();
+			else this._updateValueFromOptions();
+		}
+		_getSelected() {
+			if (this.multiple) return this.options.filter((option) => option.selected);
+			else return this.options.find((option) => option.selected) ?? null;
+		}
+		_toggleOpening() {
+			if (this.disabled || this.formDisabled || this.readOnly) return;
+			this._triggerElement?.focus();
+			switch (this.state) {
+				case "opening":
+				case "opened":
+					this.close();
+					break;
+				case "closing":
+				case "closed":
+					this.open();
+					break;
+				default: break;
+			}
+		}
+		_spreadDeferredDisplayValue(placeholder) {
+			return [this._deferredDisplayValue(placeholder), placeholder];
+		}
+		async _deferredDisplayValue(placeholder) {
+			if (this.hydrationRequired) await this.hydrationComplete;
+			return this._displayValue ? html`${this._displayValue}` : placeholder;
+		}
+		render() {
+			return html`
+      <!-- This element is visually hidden and will be appended to the light DOM to allow screen
+      readers to work properly -->
+      <div
+        class="sbb-screen-reader-only sbb-select-trigger"
+        tabindex=${this.disabled || this.formDisabled ? nothing : "0"}
+        role="combobox"
+        aria-haspopup="listbox"
+        aria-expanded="false"
+        aria-required=${this.required.toString()}
+        aria-controls=${this._overlayId}
+        aria-owns=${this._overlayId}
+        @keydown=${this._onKeyDown}
+        @click=${this._toggleOpening}
+        ${ref((ref) => this._triggerElement = ref)}
+      >
+        ${until(...this._spreadDeferredDisplayValue(html`${this.placeholder}`))}
+      </div>
+      <!-- Visually display the value -->
+      <div class="sbb-select__trigger" aria-hidden="true">
+        ${until(...this._spreadDeferredDisplayValue(html`${this.placeholder}`))}
+      </div>
+      <div class="sbb-select__gap-fix"></div>
+      <div class="sbb-select__container" popover="manual">
+        <div class="sbb-select__gap-fix">${overlayGapFixCorners()}</div>
+        <div
+          @animationend=${this._onAnimationEnd}
+          class="sbb-select__panel"
+          ${ref((dialogRef) => this._overlay = dialogRef)}
+        >
+          <div class="sbb-select__wrapper">
+            <div
+              id=${!ariaRoleOnHost ? this._overlayId : nothing}
+              class="sbb-select__options"
+              role=${!ariaRoleOnHost ? "listbox" : nothing}
+              ?aria-multiselectable=${this.multiple}
+              ${ref((containerRef) => this._optionContainer = containerRef)}
+              tabindex="-1"
+            >
+              <slot @slotchange=${this._updateValueOptionState}></slot>
+            </div>
+          </div>
+        </div>
+      </div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbSelectElement as t };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"select.component-BnHx3v3c.js","names":[],"sources":["../../../src/elements/select/select.scss?inline","../../../src/elements/select/select.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n// Fixes the gap between the origin and the overlay by creating conjunction\n// corners based on the origin element border radius\n@include sbb.overlay-gap-fix;\n\n:host {\n  @include sbb.options-panel-overlay-variables;\n\n  --sbb-options-panel-internal-z-index: var(\n    --sbb-select-z-index,\n    var(--sbb-overlay-default-z-index)\n  );\n\n  display: block;\n  font-weight: normal;\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n:host([size='s']) {\n  @include sbb.options-panel-overlay-size-s-variables;\n}\n\n:host([size='m']) {\n  @include sbb.options-panel-overlay-size-m-variables;\n}\n\n:host([negative]) {\n  @include sbb.options-panel-overlay-negative-variables;\n\n  --sbb-select-placeholder-fallback-color: var(--sbb-color-5);\n}\n\n:host(:not(:state(state-opening), :state(state-opened), :state(state-closing))),\n:host(:state(state-closed)) {\n  --sbb-options-panel-visibility: hidden;\n}\n\n:host(:state(state-opening)) {\n  --sbb-options-panel-animation-name: open;\n}\n\n:host(:state(state-closing)) {\n  --sbb-options-panel-animation-name: close;\n}\n\n:host(:state(state-opened)),\n:host(:state(state-opening)) {\n  --sbb-options-panel-gap-fix-opacity: 1;\n}\n\n:host(:state(options-panel-position-below)) {\n  --sbb-options-panel-animation-transform: translateY(\n    calc((var(--sbb-options-panel-origin-height) / 2) * -1)\n  );\n}\n\n:host(:state(options-panel-position-above)) {\n  --sbb-options-panel-options-border-radius: var(--sbb-options-panel-border-radius)\n    var(--sbb-options-panel-border-radius) 0 0;\n  --sbb-options-panel-gap-fix-top: var(--_sbb-options-panel-max-height);\n  --sbb-options-panel-gap-fix-transform: rotate(180deg);\n  --sbb-options-panel-animation-transform: translateY(\n    calc(var(--sbb-options-panel-origin-height) / 2)\n  );\n}\n\n::slotted(sbb-divider) {\n  margin-block: var(--sbb-options-panel-divider-margin-block);\n}\n\n:host([preserve-icon-space]) {\n  --sbb-option-icon-container-display: block;\n}\n\n.sbb-select__trigger {\n  @include sbb.ellipsis;\n\n  cursor: var(--sbb-cursor-default);\n  height: calc(1em * var(--sbb-typo-line-height-text));\n\n  :host(:not(:state(has-display-value))) & {\n    color: var(--sbb-select-placeholder-color, var(--sbb-select-placeholder-fallback-color));\n\n    // Note: when the sbb-select is used within a sbb-form-field, some style are applied from it\n    // (see selector `.sbb-form-field__input ::slotted(:where(input, select, sbb-select))` in the sbb-form-field.scss);\n    // so, next line is mandatory because we need to override the rule from the parent.\n    -webkit-text-fill-color: var(\n      --sbb-select-placeholder-color,\n      var(--sbb-select-placeholder-fallback-color)\n    );\n  }\n}\n\n.sbb-select__container {\n  @include sbb.options-panel-overlay-container;\n\n  // Hide popover artifacts\n  &[popover] {\n    margin: 0;\n    padding: 0;\n    border: none;\n    width: auto;\n    height: auto;\n    background-color: transparent;\n  }\n}\n\n.sbb-select__gap-fix {\n  @include sbb.options-panel-overlay-gap;\n}\n\n.sbb-select__panel {\n  @include sbb.options-panel-overlay;\n\n  :host(:state(options-panel-position-below)) & {\n    inset-block-start: calc(\n      var(--sbb-options-panel-position-y) - var(--sbb-options-panel-origin-height)\n    );\n  }\n\n  :host(:is(:state(state-opened), :state(state-opening))) & {\n    box-shadow: var(--sbb-box-shadow-level-9-hard);\n  }\n\n  :host(:is(:state(state-opened), :state(state-opening))[negative]) & {\n    box-shadow: var(--sbb-box-shadow-level-9-hard-negative);\n  }\n\n  &::before {\n    :host(:state(options-panel-position-below)) & {\n      display: block;\n    }\n  }\n\n  &::after {\n    :host(:state(options-panel-position-above)) & {\n      display: block;\n    }\n  }\n\n  // stylelint-disable-next-line no-descending-specificity\n  &::before,\n  &::after {\n    :host(:is(:state(state-opened), :state(state-opening)):state(option-panel-origin-borderless))\n      & {\n      box-shadow: var(--sbb-box-shadow-level-9-hard);\n    }\n\n    :host(\n        :is(:state(state-opened), :state(state-opening)):state(\n            option-panel-origin-borderless\n          )[negative]\n      )\n      & {\n      box-shadow: var(--sbb-box-shadow-level-9-hard-negative);\n    }\n  }\n}\n\n.sbb-select__wrapper {\n  overflow: hidden;\n}\n\n.sbb-select__options {\n  @include sbb.optionsOverlay;\n  @include sbb.scrollbar-rules;\n\n  @include sbb.if-forced-colors {\n    border: var(--sbb-border-width-1x) solid CanvasText;\n    border-block-start: none;\n  }\n}\n\n@keyframes open {\n  from {\n    transform: var(--sbb-options-panel-animation-transform);\n    opacity: 0;\n  }\n\n  to {\n    transform: translateY(0);\n    opacity: 1;\n  }\n}\n\n@keyframes close {\n  from {\n    transform: translateY(0);\n    opacity: 1;\n  }\n\n  to {\n    transform: var(--sbb-options-panel-animation-transform);\n    opacity: 0;\n  }\n}\n","import { MutationController } from '@lit-labs/observers/mutation-controller.js';\nimport { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  isServer,\n  nothing,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property, state } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\nimport { until } from 'lit/directives/until.js';\n\nimport {\n  boxSizingStyles,\n  forceType,\n  type FormRestoreReason,\n  type FormRestoreState,\n  getNextElementIndex,\n  getOverride,\n  handleDistinctChange,\n  i18nSelectionRequired,\n  isEventOnElement,\n  isLean,\n  isNextjs,\n  isSafari,\n  isZeroAnimationDuration,\n  overlayGapFixCorners,\n  SbbDisabledMixin,\n  SbbEscapableOverlayController,\n  SbbFormAssociatedMixin,\n  SbbLanguageController,\n  SbbNegativeMixin,\n  SbbOpenCloseBaseElement,\n  SbbPropertyWatcherController,\n  SbbReadonlyMixin,\n  SbbRequiredMixin,\n  SbbUpdateSchedulerMixin,\n  setOrRemoveAttribute,\n  setOverlayPosition,\n} from '../core.ts';\nimport type { SbbDividerElement } from '../divider.pure.ts';\nimport type { SbbFormFieldElement } from '../form-field/form-field/form-field.component.ts';\nimport type { SbbOptionElement, SbbOptionHintElement } from '../option.pure.ts';\n\nimport style from './select.scss?inline';\n\n/**\n * On Safari, the aria role 'listbox' must be on the host element, or else VoiceOver won't work at all.\n * On the other hand, JAWS and NVDA need the role to be an \"immediate parent\" to the options, or else optgroups won't work.\n */\nconst ariaRoleOnHost = isSafari;\n\nlet nextId = 0;\n\n/**\n * It displays a panel with selectable options.\n *\n * @slot - Use the unnamed slot to add options.\n * @cssprop [--sbb-select-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n * @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.\n * If the calculated remaining space is smaller, the value gets ignored.\n * @overrideType value - (T = string | string[]) | null\n */\nexport class SbbSelectElement<T = string> extends SbbUpdateSchedulerMixin(\n  SbbDisabledMixin(\n    SbbNegativeMixin(\n      SbbRequiredMixin(\n        SbbReadonlyMixin(\n          SbbFormAssociatedMixin<typeof SbbOpenCloseBaseElement>(SbbOpenCloseBaseElement),\n        ),\n      ),\n    ),\n  ),\n) {\n  public static override readonly elementName: string = 'sbb-select';\n  public static override readonly role = ariaRoleOnHost ? 'listbox' : null;\n  public static override styles: CSSResultGroup = [boxSizingStyles, unsafeCSS(style)];\n\n  // TODO: fix using ...super.events requires: https://github.com/sbb-design-systems/lyne-components/issues/2600\n  public static override readonly events = {\n    change: 'change',\n    input: 'input',\n    displayvaluechange: 'displayvaluechange',\n    beforeopen: 'beforeopen',\n    open: 'open',\n    beforeclose: 'beforeclose',\n    close: 'close',\n  } as const;\n\n  /** The placeholder used if no value has been selected. */\n  @forceType()\n  @property()\n  public accessor placeholder: string = '';\n\n  /** Whether the select allows for multiple selection. */\n  @forceType()\n  @handleDistinctChange((e: SbbSelectElement<T>, newValue: boolean) =>\n    e._onMultipleChanged(newValue),\n  )\n  @property({ reflect: true, type: Boolean })\n  public accessor multiple: boolean = false;\n\n  /** Function used to compare option values. */\n  @property({ attribute: false })\n  public accessor compareWith: (v1: T | null, v2: T | null) => boolean = (v1, v2) => v1 === v2;\n\n  @forceType()\n  @handleDistinctChange((e: SbbSelectElement<T>, newValue: boolean) =>\n    e._closeOnDisabledReadonlyChanged(newValue),\n  )\n  @property({ reflect: true, type: Boolean })\n  @getOverride((e: SbbSelectElement<T>, v: boolean): boolean => v || e.isDisabledExternally())\n  public override accessor disabled: boolean = false;\n\n  /** Value of the form element. */\n  @property()\n  public set value(value: T[] | T) {\n    this._value = value;\n    this._isValueManuallyAssigned = true;\n    this._updateOptionsFromValue();\n  }\n  public get value(): T[] | T | null {\n    return this._value;\n  }\n  private _value: T | T[] | null = null;\n\n  /**\n   * Size variant, either m or s.\n   * @default 'm' / 's' (lean)\n   */\n  @property({ reflect: true }) public accessor size: 'm' | 's' = isLean() ? 's' : 'm';\n\n  /**\n   * Form type of element.\n   * @default 'select-one / select-multiple'\n   */\n  public override get type(): string {\n    return this.multiple ? 'select-multiple' : 'select-one';\n  }\n\n  /** The value displayed by the component. */\n  @state() private accessor _displayValue: string | null = null;\n\n  private _originResizeObserver = new ResizeController(this, {\n    target: null,\n    skipInitial: true,\n    callback: () => {\n      if (this.isOpen) {\n        this._setOverlayPosition();\n      }\n    },\n  });\n\n  private _overlay!: HTMLElement;\n  private _optionContainer!: HTMLElement;\n  private _originElement: HTMLElement | null = null;\n  private _triggerElement: HTMLElement | null = null;\n  private _openPanelEventsController?: AbortController;\n  private _escapableOverlayController = new SbbEscapableOverlayController(this);\n  private _overlayId = `sbb-select-${++nextId}`;\n  private _activeItemIndex = -1;\n  private _searchTimeout?: ReturnType<typeof setTimeout>;\n  private _searchString = '';\n  private _didLoad = false;\n  private _isPointerDownEventOnMenu: boolean = false;\n  private _languageController = new SbbLanguageController(this);\n  private _isValueManuallyAssigned = false;\n\n  /**\n   * The 'combobox' input element\n   * @internal\n   */\n  public get inputElement(): HTMLElement | null {\n    return this._triggerElement ?? null;\n  }\n\n  /** Returns all SbbOptionElements from this sbb-select instance. */\n  public get options(): SbbOptionElement<T>[] {\n    const options: SbbOptionElement<T>[] = [];\n    this.querySelectorAll?.<SbbOptionElement<T>>('sbb-option').forEach((option) => {\n      customElements.upgrade(option);\n      options.push(option);\n    });\n    return options;\n  }\n\n  public constructor() {\n    super();\n    this.addEventListener?.('optionselectionchange', (e: Event) => this._onOptionChanged(e));\n    this.addEventListener?.('optionLabelChanged', (e: Event) => this._onOptionLabelChanged(e));\n    /** Forces the sbb-select to update his value. */\n    this.addEventListener?.('ɵoptionvaluechange', () => this._updateValueOptionState());\n    this.addEventListener?.('ɵoptgroupslotchange', () => this._updateValueOptionState(), {\n      capture: true,\n    });\n    this.addEventListener?.('click', (e: MouseEvent) => {\n      const target = e.target as SbbSelectElement<T> | SbbOptionElement<T>;\n      if (target.localName === 'sbb-option') {\n        // Option click\n        if (!this.multiple && !target.disabled) {\n          this.close();\n          this.focus();\n        }\n      } else {\n        this._toggleOpening();\n      }\n    });\n\n    this.addController(\n      new MutationController(this, {\n        config: { attributeFilter: ['aria-labelledby', 'aria-label', 'aria-describedby'] },\n        callback: () => this._syncAriaLabels(),\n      }),\n    );\n\n    this.addController(\n      new SbbPropertyWatcherController(this, () => this.closest('sbb-form-field'), {\n        negative: (e) => {\n          this.negative = e.negative;\n          this._syncNegative();\n        },\n      }),\n    );\n  }\n\n  private _syncAriaLabels(): void {\n    if (!this._triggerElement || isServer) {\n      return;\n    }\n\n    setOrRemoveAttribute(\n      this._triggerElement,\n      'aria-labelledby',\n      this.getAttribute('aria-labelledby'),\n    );\n    setOrRemoveAttribute(this._triggerElement, 'aria-label', this.getAttribute('aria-label'));\n    setOrRemoveAttribute(\n      this._triggerElement,\n      'aria-describedby',\n      this.getAttribute('aria-describedby'),\n    );\n\n    // Using the associated labels is only a fallback.\n    // The drawback is, that it doesn't get updated automatically when the list of label changes.\n    if (\n      !this.getAttribute('aria-label') &&\n      !this.getAttribute('aria-labelledby') &&\n      this.internals.labels.length\n    ) {\n      this._triggerElement?.setAttribute(\n        'aria-label',\n        Array.from(this.internals.labels)\n          .map((label) => label.textContent)\n          .join(', '),\n      );\n    }\n  }\n\n  /** Opens the selection panel. */\n  public open(): void {\n    if (\n      this.state === 'opening' ||\n      this.state === 'opened' ||\n      !this._overlay ||\n      this.options.length === 0 ||\n      this.disabled ||\n      this.formDisabled ||\n      !this.dispatchBeforeOpenEvent()\n    ) {\n      return;\n    }\n\n    this.shadowRoot?.querySelector<HTMLDivElement>('.sbb-select__container')?.showPopover?.();\n    this.state = 'opening';\n    this.internals.states.add('expanded');\n    this._setOverlayPosition();\n    this._escapableOverlayController.connect();\n    this._attachOpenPanelEvents();\n\n    // If the animation duration is zero, the animationend event is not always fired reliably.\n    // In this case we directly set the `opened` state.\n    if (this._isZeroAnimationDuration()) {\n      this._handleOpening();\n    }\n  }\n\n  /** Closes the selection panel. */\n  public close(): void {\n    if (this.state === 'closing' || this.state === 'closed' || !this.dispatchBeforeCloseEvent()) {\n      return;\n    }\n\n    this.state = 'closing';\n    this.internals.states.delete('expanded');\n    this._openPanelEventsController?.abort();\n    if (this._originElement) {\n      this._originResizeObserver.unobserve(this._originElement);\n    }\n\n    // If the animation duration is zero, the animationend event is not always fired reliably.\n    // In this case we directly set the `closed` state.\n    if (this._isZeroAnimationDuration()) {\n      this._handleClosing();\n    }\n  }\n\n  private _isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-options-panel-animation-duration');\n  }\n\n  /** Gets the current displayed value. */\n  public getDisplayValue(): string {\n    return this._displayValue ?? '';\n  }\n\n  private _selectableOptions(): SbbOptionElement<T>[] {\n    return this.options.filter((opt) => !opt.matches(':state(disabled)'));\n  }\n\n  /** Listens to option changes. */\n  private _onOptionChanged(event: Event): void {\n    const target = event.target as SbbOptionElement<T>;\n    if (target.selected) {\n      this._onOptionSelected(target);\n    } else {\n      this._onOptionDeselected(target);\n    }\n  }\n\n  /** Listens to option changes. */\n  private _onOptionLabelChanged(event: Event): void {\n    const target = event.target as SbbOptionElement<T>;\n    const selected = this._getSelected();\n\n    if (\n      (!Array.isArray(selected) && target !== selected) ||\n      (Array.isArray(selected) && !selected.includes(target))\n    ) {\n      return;\n    }\n\n    this._updateDisplayValue();\n  }\n\n  private _updateDisplayValue(): void {\n    const selected = this._getSelected();\n    if (Array.isArray(selected)) {\n      this._displayValue = selected.map((o) => o.textContent?.trim()).join(', ') || null;\n    } else if (selected) {\n      this._displayValue = selected?.textContent?.trim() || null;\n    } else {\n      this._displayValue = null;\n    }\n\n    this.toggleState('has-display-value', !!this._displayValue);\n\n    /** @internal */\n    this.dispatchEvent(new Event('displayvaluechange', { bubbles: true, composed: true }));\n  }\n\n  /**\n   * The `value` property should be adapted when the `multiple` property changes:\n   *   - if it changes to true, the 'value' is set to an array;\n   *   - if it changes to false, the first available option is set as 'value' otherwise it's set to null.\n   */\n  private _onMultipleChanged(isChangingToMultiple: boolean): void {\n    if (isChangingToMultiple) {\n      this._value = this._isValueManuallyAssigned || this.value != null ? [this.value as T] : [];\n    } else if (Array.isArray(this.value)) {\n      this._value = this.value.length ? this.value[0] : null;\n    }\n    this._updateDisplayValue();\n  }\n\n  /**\n   * If the `disabled` or the `readonly` properties are set, and the panel is open, close it.\n   */\n  private _closeOnDisabledReadonlyChanged(newValue: boolean): void {\n    if ((this.state === 'opening' || this.state === 'opened') && newValue) {\n      this.close();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._updateValueOptionState();\n\n    // Wait for ssr hydration\n    if (!isNextjs()) {\n      this.startUpdate();\n      this._setupSelect();\n    }\n  }\n\n  /** @internal */\n  public override focus(): void {\n    // Forward focus to the trigger element.\n    this._triggerElement?.focus();\n  }\n\n  /** @internal */\n  public override blur(): void {\n    // Forward blur to the trigger element.\n    this._triggerElement?.blur();\n  }\n\n  /**\n   * Removes element's first attribute whose qualified name is qualifiedName.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/removeAttribute)\n   * @internal We need to override this due to a hydration issue with Next.js.\n   */\n  public override removeAttribute(qualifiedName: string): void {\n    // In Next.js the hydration needs to finish before we can manipulate the light DOM.\n    // @lit/react calls removeAttribute('defer-hydration') in a useLayoutEffect,\n    // which is done after hydration is finished. Due to this we intercept this call\n    // in overriding removeAttribute to finish initialization of the sbb-select.\n    // https://github.com/lit/lit/blob/main/packages/react/src/create-component.ts#L293-L296\n    // We also need to wait for update complete in order to be sure that the shadow DOM has been rendered.\n    if (isNextjs() && qualifiedName === 'defer-hydration' && !this._didLoad) {\n      this.updateComplete.then(() => this._setupSelect());\n    }\n    super.removeAttribute(qualifiedName);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    if (ariaRoleOnHost) {\n      this.id ||= this._overlayId;\n    }\n\n    this._syncNegative();\n    this._syncAriaLabels();\n\n    if (this._didLoad) {\n      this._setupOrigin();\n      this._setupTrigger();\n    }\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n    if (!name && this.hasUpdated) {\n      setTimeout(() => this._syncAriaLabels());\n    }\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('negative')) {\n      this._syncNegative();\n    }\n    if (changedProperties.has('readOnly')) {\n      this._closeOnDisabledReadonlyChanged(this.readOnly);\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    // Take back the trigger element previously moved to the light DOM.\n    // Due to timing issues, this needs to be done before calling super.disconnectedCallback().\n    if (this._triggerElement) {\n      this.prepend(this._triggerElement);\n    }\n    super.disconnectedCallback();\n    this._openPanelEventsController?.abort();\n  }\n\n  /**\n   * The reset value is the attribute value (the setup value), null otherwise.\n   * @internal\n   */\n  public formResetCallback(): void {\n    this.value = (this.hasAttribute('value') ? this.getAttribute('value') : null) as T;\n  }\n\n  /**\n   * @internal\n   */\n  public formStateRestoreCallback(\n    state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {\n    try {\n      const { value, manuallyAssigned } = JSON.parse(state as string) as {\n        value: T | T[];\n        manuallyAssigned: boolean;\n      };\n\n      this._isValueManuallyAssigned = manuallyAssigned;\n      this._value = value;\n      this._updateOptionsFromValue();\n    } catch {\n      console.warn(`Failed to restore sbb-select with state ${state}`);\n    }\n  }\n\n  protected override formState(): FormRestoreState {\n    return JSON.stringify({ value: this.value, manuallyAssigned: this._isValueManuallyAssigned });\n  }\n\n  private _syncNegative(): void {\n    this.querySelectorAll?.<SbbDividerElement | SbbOptionHintElement>(\n      'sbb-divider, sbb-option-hint',\n    ).forEach((el) => (el.negative = this.negative));\n  }\n\n  protected override shouldValidate(name: PropertyKey | undefined): boolean {\n    return super.shouldValidate(name) || name === 'value' || name === 'required';\n  }\n\n  protected override validate(): void {\n    super.validate();\n\n    const value: T[] = Array.isArray(this.value)\n      ? this.value\n      : this.value === null\n        ? []\n        : [this.value];\n\n    if (\n      this.required &&\n      (this.options.every((o) => value.every((v) => !this.compareWith(v, o.value))) ||\n        (!this._isValueManuallyAssigned && this.value == null))\n    ) {\n      this.setValidityFlag('valueMissing', i18nSelectionRequired[this._languageController.current]);\n    } else {\n      this.removeValidityFlag('valueMissing');\n    }\n  }\n\n  private _setupSelect(): void {\n    this._setupOrigin();\n    this._setupTrigger();\n    this._didLoad = true;\n    this.completeUpdate();\n  }\n\n  /** Sets the originElement; if the component is used in a sbb-form-field uses it, otherwise uses the parentElement. */\n  private _setupOrigin(): void {\n    const formField = this.closest?.<SbbFormFieldElement>('sbb-form-field');\n    if (this._originElement) {\n      this._originResizeObserver.unobserve(this._originElement);\n    }\n    this._originElement =\n      formField?.shadowRoot?.querySelector?.('#overlay-anchor') ?? this.parentElement!;\n    if (this._originElement) {\n      this.toggleState('option-panel-origin-borderless', formField?.hasAttribute?.('borderless'));\n\n      if (this.isOpen) {\n        this._originResizeObserver.observe(this._originElement);\n      }\n    }\n  }\n\n  /**\n   * To assess screen-readers problems caused by the interaction between aria patterns and shadow DOM,\n   * we are forced to move the 'combobox' trigger element to the light DOM\n   */\n  private _setupTrigger(): void {\n    // Move the trigger before the sbb-select\n    if (this.parentElement && this._triggerElement) {\n      this.parentElement.insertBefore?.(this._triggerElement, this);\n    }\n  }\n\n  private _setOverlayPosition(): void {\n    if (!this._originElement) {\n      return;\n    }\n    setOverlayPosition(\n      this._overlay,\n      this._originElement,\n      this._optionContainer,\n      this.shadowRoot!.querySelector('.sbb-select__container')!,\n      this,\n    );\n  }\n\n  // In rare cases it can be that the animationEnd event is triggered twice.\n  // To avoid entering a corrupt state, exit when state is not expected.\n  private _onAnimationEnd(event: AnimationEvent): void {\n    if (event.animationName === 'open' && this.state === 'opening') {\n      this._handleOpening();\n    } else if (event.animationName === 'close' && this.state === 'closing') {\n      this._handleClosing();\n    }\n  }\n\n  private _handleOpening(): void {\n    this.state = 'opened';\n    this._triggerElement?.setAttribute('aria-expanded', 'true');\n    if (this._originElement) {\n      this._originResizeObserver.observe(this._originElement);\n    }\n    this.dispatchOpenEvent();\n  }\n\n  private _handleClosing(): void {\n    this.state = 'closed';\n    this.shadowRoot?.querySelector<HTMLDivElement>('.sbb-select__container')?.hidePopover?.();\n    this._triggerElement?.setAttribute('aria-expanded', 'false');\n    this._resetActiveElement();\n    this._optionContainer.scrollTop = 0;\n    this._escapableOverlayController.disconnect();\n    this.dispatchCloseEvent();\n  }\n\n  /** When an option is selected, updates the displayValue; it also closes the select if not `multiple`. */\n  private _onOptionSelected(option: SbbOptionElement<T>): void {\n    if (!this.multiple) {\n      this._value = option.value;\n    } else if (!this.value) {\n      this._value = [option.value!];\n    } else if (\n      Array.isArray(this.value) &&\n      !this.value.some((v) => this.compareWith(v, option.value!))\n    ) {\n      this._value = [...this.value, option.value!];\n    }\n\n    this._updateOptionsFromValue();\n    this._dispatchInputEvents();\n  }\n\n  /** When an option is unselected in `multiple`, removes it from value and updates displayValue. */\n  private _onOptionDeselected(optionSelectionChange: SbbOptionElement<T>): void {\n    if (this.multiple && Array.isArray(this.value)) {\n      this._value = this.value.filter((el) => !this.compareWith(el, optionSelectionChange.value));\n      this._updateOptionsFromValue();\n      this._dispatchInputEvents();\n    }\n  }\n\n  private _dispatchInputEvents(): void {\n    /** The input event fires when the value has been changed as a direct result of a user action. */\n    this.dispatchEvent(\n      new InputEvent('input', {\n        bubbles: true,\n        composed: true,\n      }),\n    );\n\n    /**\n     * The change event is fired when the user modifies the element's value.\n     * Unlike the input event, the change event is not necessarily fired\n     * for each alteration to an element's value.\n     */\n    this.dispatchEvent(new Event('change', { bubbles: true }));\n  }\n\n  private _attachOpenPanelEvents(): void {\n    this._openPanelEventsController = new AbortController();\n\n    // Recalculate the overlay position on scroll and window resize\n    document.addEventListener('scroll', () => this._setOverlayPosition(), {\n      passive: true,\n      signal: this._openPanelEventsController.signal,\n      // Without capture, other scroll contexts would not bubble to this event listener.\n      // Capture allows us to react to all scroll contexts in this DOM.\n      capture: true,\n    });\n    window.addEventListener('resize', () => this._setOverlayPosition(), {\n      passive: true,\n      signal: this._openPanelEventsController.signal,\n    });\n\n    // Close menu on backdrop click\n    window.addEventListener('pointerdown', (ev) => this._pointerDownListener(ev), {\n      signal: this._openPanelEventsController.signal,\n    });\n    window.addEventListener('pointerup', (ev) => this._closeOnBackdropClick(ev), {\n      signal: this._openPanelEventsController.signal,\n    });\n  }\n\n  private _onKeyDown(event: KeyboardEvent): void {\n    if (this.readOnly) {\n      return;\n    }\n\n    if (this.state === 'opening' || this.state === 'opened') {\n      this._openedPanelKeyboardInteraction(event);\n    } else if (this.state === 'closed' || this.state === 'closing') {\n      this._closedPanelKeyboardInteraction(event);\n    }\n  }\n\n  private _closedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (this._checkForLetterSelection(event)) {\n      return this._setNextActiveOptionByText(event);\n    }\n\n    switch (event.key) {\n      case 'Enter':\n      case ' ':\n      case 'ArrowDown':\n      case 'ArrowUp':\n        event.preventDefault();\n        this.open();\n        break;\n    }\n  }\n\n  private _openedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (this.readOnly) {\n      return;\n    }\n\n    if (this._checkForLetterSelection(event)) {\n      return this._setNextActiveOptionByText(event);\n    }\n\n    switch (event.key) {\n      case 'Tab':\n        this.close();\n        break;\n\n      case 'Enter':\n      case ' ':\n        event.preventDefault();\n        this._selectByKeyboard();\n        break;\n\n      case 'ArrowDown':\n      case 'ArrowUp':\n        event.preventDefault();\n        this._setNextActiveOption(event);\n        break;\n\n      case 'Home':\n      case 'PageUp':\n        event.preventDefault();\n        this._setNextActiveOption(event, 0);\n        break;\n\n      case 'End':\n      case 'PageDown':\n        event.preventDefault();\n        this._setNextActiveOption(event, this._selectableOptions().length - 1);\n        break;\n    }\n  }\n\n  private _checkForLetterSelection(event: KeyboardEvent): boolean {\n    return (\n      event.key === 'Backspace' ||\n      event.key === 'Clear' ||\n      (event.key.length === 1 &&\n        event.key !== ' ' &&\n        !event.altKey &&\n        !event.ctrlKey &&\n        !event.metaKey)\n    );\n  }\n\n  private _setNextActiveOptionByText(event: KeyboardEvent): void {\n    // Set timeout and the string to search.\n    if (typeof this._searchTimeout === typeof setTimeout) {\n      clearTimeout(this._searchTimeout);\n    }\n    this._searchTimeout = setTimeout(() => (this._searchString = ''), 1000);\n    this._searchString += event.key;\n\n    // Reorder the _filteredOption array to have the last selected element at the bottom.\n    const indexForSlice: number = this._activeItemIndex + 1;\n    const selectableOptions = this._selectableOptions();\n    const filteredOptionsSorted = [\n      ...selectableOptions.slice(indexForSlice),\n      ...selectableOptions.slice(0, indexForSlice),\n    ];\n\n    const match = filteredOptionsSorted.find(\n      (option) => option.textContent?.toLowerCase().indexOf(this._searchString.toLowerCase()) === 0,\n    );\n    if (match) {\n      // If an exact match has been found, go to that option.\n      this._setNextActiveOption(event, selectableOptions.indexOf(match));\n    } else if (\n      this._searchString.length > 1 &&\n      new RegExp(`^${this._searchString.charAt(0)}*$`).test(this._searchString)\n    ) {\n      // If no exact match has been found but the string to search is made by the same repeated letter,\n      // go to the first element, if exists, that matches the letter.\n      const firstMatch = filteredOptionsSorted.find(\n        (option) =>\n          option.textContent?.toLowerCase().indexOf(this._searchString[0].toLowerCase()) === 0,\n      );\n      if (firstMatch) {\n        this._setNextActiveOption(event, selectableOptions.indexOf(firstMatch));\n      }\n    } else {\n      // No match found, clear the timeout and the search term.\n      clearTimeout(this._searchTimeout);\n      this._searchString = '';\n    }\n  }\n\n  private _selectByKeyboard(): void {\n    const activeOption = this._selectableOptions()[this._activeItemIndex];\n\n    if (this.multiple) {\n      activeOption?.['selectViaUserInteraction'](!activeOption.selected);\n    } else {\n      this.close();\n    }\n  }\n\n  private _setNextActiveOption(event: KeyboardEvent, index?: number): void {\n    const filteredOptions = this._selectableOptions();\n\n    // Prevent keyboard navigation if all options are disabled\n    if (filteredOptions.length === 0) {\n      return;\n    }\n\n    const nextIndex =\n      index ?? getNextElementIndex(event, this._activeItemIndex, filteredOptions.length);\n    const nextOption = filteredOptions[nextIndex];\n    const activeOption = filteredOptions[this._activeItemIndex];\n\n    this._setActiveElement(nextOption, activeOption);\n\n    if (!this.multiple) {\n      this._setSelectedElement(nextOption, activeOption);\n    } else if (event?.shiftKey) {\n      nextOption['selectViaUserInteraction'](!nextOption.selected);\n    }\n    this._activeItemIndex = nextIndex;\n  }\n\n  private _setActiveElement(\n    nextActiveOption: SbbOptionElement<T>,\n    lastActiveOption: SbbOptionElement<T> | null = null,\n    setActiveDescendant = true,\n  ): void {\n    nextActiveOption.setActive(true);\n    nextActiveOption.scrollIntoView({ block: 'nearest' });\n\n    if (setActiveDescendant) {\n      this._triggerElement?.setAttribute('aria-activedescendant', nextActiveOption.id);\n    }\n\n    // Reset the previous\n    if (lastActiveOption && !this.compareWith(lastActiveOption.value, nextActiveOption.value)) {\n      lastActiveOption.setActive(false);\n    }\n  }\n\n  private _setSelectedElement(\n    nextActiveOption: SbbOptionElement<T>,\n    lastActiveOption: SbbOptionElement<T>,\n  ): void {\n    nextActiveOption['selectViaUserInteraction'](true);\n\n    if (lastActiveOption && !this.compareWith(lastActiveOption.value, nextActiveOption.value)) {\n      lastActiveOption['selectViaUserInteraction'](false);\n    }\n  }\n\n  private _resetActiveElement(): void {\n    const activeElement = this._selectableOptions()[this._activeItemIndex];\n\n    if (activeElement) {\n      activeElement.setActive(false);\n    }\n    this._activeItemIndex = -1;\n    this._triggerElement?.removeAttribute('aria-activedescendant');\n  }\n\n  // Check if the pointerdown event target is triggered on the menu.\n  private _pointerDownListener = (event: PointerEvent): void => {\n    this._isPointerDownEventOnMenu = isEventOnElement(this._overlay, event);\n  };\n\n  // Close menu on backdrop click.\n  private _closeOnBackdropClick = (event: PointerEvent): void => {\n    if (!this._isPointerDownEventOnMenu && !isEventOnElement(this._overlay, event)) {\n      this.close();\n    }\n  };\n\n  private _updateOptionsFromValue(): void {\n    const value = Array.isArray(this.value) ? this.value : [this.value];\n\n    const displayValues = [];\n    for (const option of this.options) {\n      option.selected = value.some((v) => this.compareWith(v, option.value));\n      if (option.selected) {\n        displayValues.push(option);\n      }\n    }\n\n    this._updateDisplayValue();\n\n    if (!Array.isArray(this.value)) {\n      const value: T | null = this.value;\n      this._activeItemIndex = this._selectableOptions().findIndex((option) =>\n        this.compareWith(option.value, value),\n      );\n    }\n  }\n\n  private _updateValueFromOptions(): void {\n    const selected = this._getSelected();\n\n    if (Array.isArray(selected)) {\n      if (selected && selected.length > 0) {\n        const value: T[] = [];\n        for (const option of selected) {\n          value.push(option.value!);\n        }\n        this._value = value;\n      }\n    } else if (selected) {\n      this._activeItemIndex = this._selectableOptions().findIndex((option) => option === selected);\n      this._value = selected.value;\n    }\n\n    this._updateDisplayValue();\n  }\n\n  private _updateValueOptionState(): void {\n    if (this._isValueManuallyAssigned) {\n      this._updateOptionsFromValue();\n    } else {\n      this._updateValueFromOptions();\n    }\n  }\n\n  private _getSelected(): SbbOptionElement<T> | SbbOptionElement<T>[] | null {\n    if (this.multiple) {\n      return this.options.filter((option) => option.selected);\n    } else {\n      return this.options.find((option) => option.selected) ?? null;\n    }\n  }\n\n  private _toggleOpening(): void {\n    if (this.disabled || this.formDisabled || this.readOnly) {\n      return;\n    }\n    this._triggerElement?.focus();\n\n    switch (this.state) {\n      case 'opening':\n      case 'opened': {\n        this.close();\n        break;\n      }\n      case 'closing':\n      case 'closed': {\n        this.open();\n        break;\n      }\n      default:\n        break;\n    }\n  }\n\n  private _spreadDeferredDisplayValue(\n    placeholder: TemplateResult,\n  ): (TemplateResult | Promise<TemplateResult>)[] {\n    return [this._deferredDisplayValue(placeholder), placeholder];\n  }\n\n  private async _deferredDisplayValue(placeholder: TemplateResult): Promise<TemplateResult> {\n    if (this.hydrationRequired) {\n      await this.hydrationComplete;\n    }\n    return this._displayValue ? html`${this._displayValue}` : placeholder;\n  }\n\n  protected override render(): TemplateResult {\n    // Scroll areas without containing an interactive element will receive focus when tabbing through the document.\n    // If there are a lot of options and when pressing tab key, the scroll area on sbb-select__options gets focus.\n    // As elements inside the panel should never get focus, we have to avoid that by setting tabindex=-1.\n\n    return html`\n      <!-- This element is visually hidden and will be appended to the light DOM to allow screen\n      readers to work properly -->\n      <div\n        class=\"sbb-screen-reader-only sbb-select-trigger\"\n        tabindex=${this.disabled || this.formDisabled ? nothing : '0'}\n        role=\"combobox\"\n        aria-haspopup=\"listbox\"\n        aria-expanded=\"false\"\n        aria-required=${this.required.toString()}\n        aria-controls=${this._overlayId}\n        aria-owns=${this._overlayId}\n        @keydown=${this._onKeyDown}\n        @click=${this._toggleOpening}\n        ${ref((ref) => (this._triggerElement = ref as HTMLElement))}\n      >\n        ${until(...this._spreadDeferredDisplayValue(html`${this.placeholder}`))}\n      </div>\n\n      <!-- Visually display the value -->\n      <div class=\"sbb-select__trigger\" aria-hidden=\"true\">\n        ${until(...this._spreadDeferredDisplayValue(html`${this.placeholder}`))}\n      </div>\n\n      <div class=\"sbb-select__gap-fix\"></div>\n      <div class=\"sbb-select__container\" popover=\"manual\">\n        <div class=\"sbb-select__gap-fix\">${overlayGapFixCorners()}</div>\n        <div\n          @animationend=${this._onAnimationEnd}\n          class=\"sbb-select__panel\"\n          ${ref((dialogRef) => (this._overlay = dialogRef as HTMLElement))}\n        >\n          <div class=\"sbb-select__wrapper\">\n            <div\n              id=${!ariaRoleOnHost ? this._overlayId : nothing}\n              class=\"sbb-select__options\"\n              role=${!ariaRoleOnHost ? 'listbox' : nothing}\n              ?aria-multiselectable=${this.multiple}\n              ${ref((containerRef) => (this._optionContainer = containerRef as HTMLElement))}\n              tabindex=\"-1\"\n            >\n              <slot @slotchange=${this._updateValueOptionState}></slot>\n            </div>\n          </div>\n        </div>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-select': SbbSelectElement;\n  }\n}\n"],"mappings":"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"}