@sbb-esta/lyne-elements 4.9.0 → 4.10.0

package/development/autocomplete-base-element-YwfObJzm.js

@@ -0,0 +1,678 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, nothing, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbOpenCloseBaseElement } from "./core/base-elements.js";
+import { forceType, idReference } from "./core/decorators.js";
+import { isLean, isSafari, isZeroAnimationDuration } from "./core/dom.js";
+import { SbbNegativeMixin } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { SbbEscapableOverlayController, SbbPropertyWatcherController } from "./core/controllers.js";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { ref } from "lit/directives/ref.js";
+import { isEventOnElement, overlayGapFixCorners, removeAriaComboBoxAttributes, setOverlayPosition } from "./core/overlay.js";
+//#region src/elements/autocomplete/autocomplete-base-element.scss?inline
+var autocomplete_base_element_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-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-pointer-events: all;\n  --sbb-options-panel-internal-z-index: var(\n    --sbb-autocomplete-z-index,\n    var(--sbb-overlay-default-z-index)\n  );\n  display: none;\n  font-weight: normal;\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(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))) {\n  display: block;\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-1-negative);\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\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  --sbb-options-pointer-events: none;\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:host([preserve-icon-space]) {\n  --sbb-option-icon-container-display: block;\n}\n\n::slotted(sbb-divider) {\n  margin-block: var(--sbb-options-panel-divider-margin-block);\n}\n\n.sbb-autocomplete__container {\n  position: fixed;\n  pointer-events: none;\n  inset: 0;\n  z-index: var(--sbb-options-panel-internal-z-index);\n}\n\n.sbb-autocomplete__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-autocomplete__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-autocomplete__panel::before, .sbb-autocomplete__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-autocomplete__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-autocomplete__panel {\n  box-shadow: var(--sbb-box-shadow-level-5-hard);\n}\n:host(:is(:is(:state(state-opened),[state--state-opened]), :is(:state(state-opening),[state--state-opening]))[negative]) .sbb-autocomplete__panel {\n  box-shadow: var(--sbb-box-shadow-level-5-hard-negative);\n}\n:host(:is(:state(options-panel-position-below),[state--options-panel-position-below])) .sbb-autocomplete__panel::before {\n  display: block;\n}\n:host(:is(:state(options-panel-position-above),[state--options-panel-position-above])) .sbb-autocomplete__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-autocomplete__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-autocomplete__panel::after {\n  box-shadow: var(--sbb-box-shadow-level-5-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-autocomplete__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-autocomplete__panel::after {\n  box-shadow: var(--sbb-box-shadow-level-5-hard-negative);\n}\n\n.sbb-autocomplete__wrapper {\n  overflow: hidden;\n}\n\n.sbb-autocomplete__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  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);\n}\n.sbb-autocomplete__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-autocomplete__options::-webkit-scrollbar-corner {\n  background-color: var(--sbb-scrollbar-track-color, transparent);\n}\n.sbb-autocomplete__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-autocomplete__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-autocomplete__options::-webkit-scrollbar-button, .sbb-autocomplete__options::-webkit-scrollbar-corner {\n  display: none;\n}\n@supports not selector(::-webkit-scrollbar) {\n  .sbb-autocomplete__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.sbb-autocomplete__options {\n  pointer-events: var(--sbb-options-pointer-events);\n}\n@media (forced-colors: active) {\n  .sbb-autocomplete__options {\n    border: var(--sbb-border-width-1x) solid CanvasText;\n    border-top: 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/autocomplete/autocomplete-base-element.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 "closer" to the options, or else optgroups won't work.
+*/
+var ariaRoleOnHost = isSafari;
+var SbbAutocompleteBaseElement = (() => {
+	let _classSuper = SbbNegativeMixin(SbbOpenCloseBaseElement);
+	let _origin_decorators;
+	let _origin_initializers = [];
+	let _origin_extraInitializers = [];
+	let _trigger_decorators;
+	let _trigger_initializers = [];
+	let _trigger_extraInitializers = [];
+	let _preserveIconSpace_decorators;
+	let _preserveIconSpace_initializers = [];
+	let _preserveIconSpace_extraInitializers = [];
+	let _autoActiveFirstOption_decorators;
+	let _autoActiveFirstOption_initializers = [];
+	let _autoActiveFirstOption_extraInitializers = [];
+	let _displayWith_decorators;
+	let _displayWith_initializers = [];
+	let _displayWith_extraInitializers = [];
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let _autoSelectActiveOption_decorators;
+	let _autoSelectActiveOption_initializers = [];
+	let _autoSelectActiveOption_extraInitializers = [];
+	let _autoSelectActiveOptionOnBlur_decorators;
+	let _autoSelectActiveOptionOnBlur_initializers = [];
+	let _autoSelectActiveOptionOnBlur_extraInitializers = [];
+	let _requireSelection_decorators;
+	let _requireSelection_initializers = [];
+	let _requireSelection_extraInitializers = [];
+	let _position_decorators;
+	let _position_initializers = [];
+	let _position_extraInitializers = [];
+	return class SbbAutocompleteBaseElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_origin_decorators = [idReference(), property()];
+			_trigger_decorators = [idReference(), property()];
+			_preserveIconSpace_decorators = [forceType(), property({
+				attribute: "preserve-icon-space",
+				reflect: true,
+				type: Boolean
+			})];
+			_autoActiveFirstOption_decorators = [forceType(), property({
+				attribute: "auto-active-first-option",
+				type: Boolean
+			})];
+			_displayWith_decorators = [property({ attribute: false })];
+			_size_decorators = [property({ reflect: true })];
+			_autoSelectActiveOption_decorators = [forceType(), property({
+				attribute: "auto-select-active-option",
+				type: Boolean
+			})];
+			_autoSelectActiveOptionOnBlur_decorators = [forceType(), property({
+				attribute: "auto-select-active-option-on-blur",
+				type: Boolean
+			})];
+			_requireSelection_decorators = [forceType(), property({
+				attribute: "require-selection",
+				type: Boolean
+			})];
+			_position_decorators = [property()];
+			__esDecorate(this, null, _origin_decorators, {
+				kind: "accessor",
+				name: "origin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "origin" in obj,
+					get: (obj) => obj.origin,
+					set: (obj, value) => {
+						obj.origin = value;
+					}
+				},
+				metadata: _metadata
+			}, _origin_initializers, _origin_extraInitializers);
+			__esDecorate(this, null, _trigger_decorators, {
+				kind: "accessor",
+				name: "trigger",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "trigger" in obj,
+					get: (obj) => obj.trigger,
+					set: (obj, value) => {
+						obj.trigger = value;
+					}
+				},
+				metadata: _metadata
+			}, _trigger_initializers, _trigger_extraInitializers);
+			__esDecorate(this, null, _preserveIconSpace_decorators, {
+				kind: "accessor",
+				name: "preserveIconSpace",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "preserveIconSpace" in obj,
+					get: (obj) => obj.preserveIconSpace,
+					set: (obj, value) => {
+						obj.preserveIconSpace = value;
+					}
+				},
+				metadata: _metadata
+			}, _preserveIconSpace_initializers, _preserveIconSpace_extraInitializers);
+			__esDecorate(this, null, _autoActiveFirstOption_decorators, {
+				kind: "accessor",
+				name: "autoActiveFirstOption",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "autoActiveFirstOption" in obj,
+					get: (obj) => obj.autoActiveFirstOption,
+					set: (obj, value) => {
+						obj.autoActiveFirstOption = value;
+					}
+				},
+				metadata: _metadata
+			}, _autoActiveFirstOption_initializers, _autoActiveFirstOption_extraInitializers);
+			__esDecorate(this, null, _displayWith_decorators, {
+				kind: "accessor",
+				name: "displayWith",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "displayWith" in obj,
+					get: (obj) => obj.displayWith,
+					set: (obj, value) => {
+						obj.displayWith = value;
+					}
+				},
+				metadata: _metadata
+			}, _displayWith_initializers, _displayWith_extraInitializers);
+			__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, _autoSelectActiveOption_decorators, {
+				kind: "accessor",
+				name: "autoSelectActiveOption",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "autoSelectActiveOption" in obj,
+					get: (obj) => obj.autoSelectActiveOption,
+					set: (obj, value) => {
+						obj.autoSelectActiveOption = value;
+					}
+				},
+				metadata: _metadata
+			}, _autoSelectActiveOption_initializers, _autoSelectActiveOption_extraInitializers);
+			__esDecorate(this, null, _autoSelectActiveOptionOnBlur_decorators, {
+				kind: "accessor",
+				name: "autoSelectActiveOptionOnBlur",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "autoSelectActiveOptionOnBlur" in obj,
+					get: (obj) => obj.autoSelectActiveOptionOnBlur,
+					set: (obj, value) => {
+						obj.autoSelectActiveOptionOnBlur = value;
+					}
+				},
+				metadata: _metadata
+			}, _autoSelectActiveOptionOnBlur_initializers, _autoSelectActiveOptionOnBlur_extraInitializers);
+			__esDecorate(this, null, _requireSelection_decorators, {
+				kind: "accessor",
+				name: "requireSelection",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "requireSelection" in obj,
+					get: (obj) => obj.requireSelection,
+					set: (obj, value) => {
+						obj.requireSelection = value;
+					}
+				},
+				metadata: _metadata
+			}, _requireSelection_initializers, _requireSelection_extraInitializers);
+			__esDecorate(this, null, _position_decorators, {
+				kind: "accessor",
+				name: "position",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "position" in obj,
+					get: (obj) => obj.position,
+					set: (obj, value) => {
+						obj.position = value;
+					}
+				},
+				metadata: _metadata
+			}, _position_initializers, _position_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.styles = [boxSizingStyles, unsafeCSS(autocomplete_base_element_default)];
+		}
+		#origin_accessor_storage;
+		/**
+		* The element where the autocomplete will attach.
+		* If not set, as fallback there are two elements which can act as origin with following priority order:
+		* 1. `sbb-form-field` if it is an ancestor.
+		* 2. trigger element if set.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get origin() {
+			return this.#origin_accessor_storage;
+		}
+		set origin(value) {
+			this.#origin_accessor_storage = value;
+		}
+		#trigger_accessor_storage;
+		/**
+		* The input element that will trigger the autocomplete opening.
+		* By default, the autocomplete will open on focus, click, input or `ArrowDown` keypress of the 'trigger' element.
+		* If not set, will search for the first 'input' child of a 'sbb-form-field' ancestor.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get trigger() {
+			return this.#trigger_accessor_storage;
+		}
+		set trigger(value) {
+			this.#trigger_accessor_storage = value;
+		}
+		#preserveIconSpace_accessor_storage;
+		/** Whether the icon space is preserved when no icon is set. */
+		get preserveIconSpace() {
+			return this.#preserveIconSpace_accessor_storage;
+		}
+		set preserveIconSpace(value) {
+			this.#preserveIconSpace_accessor_storage = value;
+		}
+		#autoActiveFirstOption_accessor_storage;
+		/** Whether the first option is automatically activated when the autocomplete is opened. */
+		get autoActiveFirstOption() {
+			return this.#autoActiveFirstOption_accessor_storage;
+		}
+		set autoActiveFirstOption(value) {
+			this.#autoActiveFirstOption_accessor_storage = value;
+		}
+		#displayWith_accessor_storage;
+		/** Function that maps an option's control value to its display value in the trigger. */
+		get displayWith() {
+			return this.#displayWith_accessor_storage;
+		}
+		set displayWith(value) {
+			this.#displayWith_accessor_storage = 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;
+		}
+		#autoSelectActiveOption_accessor_storage;
+		/** Whether the active option should be selected as the user is navigating. */
+		get autoSelectActiveOption() {
+			return this.#autoSelectActiveOption_accessor_storage;
+		}
+		set autoSelectActiveOption(value) {
+			this.#autoSelectActiveOption_accessor_storage = value;
+		}
+		#autoSelectActiveOptionOnBlur_accessor_storage;
+		/**
+		* When enabled, the active option is automatically selected on blur.
+		* This is an experimental feature. It might be subject to changes.
+		*/
+		get autoSelectActiveOptionOnBlur() {
+			return this.#autoSelectActiveOptionOnBlur_accessor_storage;
+		}
+		set autoSelectActiveOptionOnBlur(value) {
+			this.#autoSelectActiveOptionOnBlur_accessor_storage = value;
+		}
+		#requireSelection_accessor_storage;
+		/**
+		* Whether the user is required to make a selection when they're interacting with the
+		* autocomplete. If the user moves away from the autocomplete without selecting an option from
+		* the list, the value will be reset. If the user opens the panel and closes it without
+		* interacting or selecting a value, the initial value will be kept.
+		*/
+		get requireSelection() {
+			return this.#requireSelection_accessor_storage;
+		}
+		set requireSelection(value) {
+			this.#requireSelection_accessor_storage = value;
+		}
+		#position_accessor_storage;
+		/**
+		* The position of the autocomplete panel relative to the trigger.
+		* @default 'auto'
+		*/
+		get position() {
+			return this.#position_accessor_storage;
+		}
+		set position(value) {
+			this.#position_accessor_storage = value;
+		}
+		/** Returns the element where the autocomplete overlay is attached to. */
+		get originElement() {
+			return this.origin ?? this.closest?.("sbb-form-field")?.shadowRoot?.querySelector?.("#overlay-anchor") ?? this.trigger ?? null;
+		}
+		/** Returns the trigger element. */
+		get triggerElement() {
+			return this._triggerElement ?? null;
+		}
+		constructor() {
+			super();
+			this.#origin_accessor_storage = __runInitializers(this, _origin_initializers, null);
+			this.#trigger_accessor_storage = (__runInitializers(this, _origin_extraInitializers), __runInitializers(this, _trigger_initializers, null));
+			this.#preserveIconSpace_accessor_storage = (__runInitializers(this, _trigger_extraInitializers), __runInitializers(this, _preserveIconSpace_initializers, false));
+			this.#autoActiveFirstOption_accessor_storage = (__runInitializers(this, _preserveIconSpace_extraInitializers), __runInitializers(this, _autoActiveFirstOption_initializers, false));
+			this.#displayWith_accessor_storage = (__runInitializers(this, _autoActiveFirstOption_extraInitializers), __runInitializers(this, _displayWith_initializers, null));
+			this.#size_accessor_storage = (__runInitializers(this, _displayWith_extraInitializers), __runInitializers(this, _size_initializers, isLean() ? "s" : "m"));
+			this.#autoSelectActiveOption_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _autoSelectActiveOption_initializers, false));
+			this.#autoSelectActiveOptionOnBlur_accessor_storage = (__runInitializers(this, _autoSelectActiveOption_extraInitializers), __runInitializers(this, _autoSelectActiveOptionOnBlur_initializers, false));
+			this.#requireSelection_accessor_storage = (__runInitializers(this, _autoSelectActiveOptionOnBlur_extraInitializers), __runInitializers(this, _requireSelection_initializers, false));
+			this.#position_accessor_storage = (__runInitializers(this, _requireSelection_extraInitializers), __runInitializers(this, _position_initializers, "auto"));
+			this._triggerElement = __runInitializers(this, _position_extraInitializers);
+			this.activeOption = null;
+			this.pendingAutoSelectedOption = null;
+			this._originResizeObserver = new ResizeController(this, {
+				target: null,
+				skipInitial: true,
+				callback: () => {
+					if (this.state === "opened") this._setOverlayPosition();
+				}
+			});
+			/** Listens to the changes on the `disabled` or `readonly` attribute of the trigger. */
+			this._triggerAttributeObserver = !isServer ? new MutationObserver((mutations) => {
+				const input = mutations[0].target;
+				if (input.hasAttribute("disabled") || input.hasAttribute("readonly")) this.close();
+			}) : null;
+			this._isPointerDownEventOnMenu = false;
+			this._escapableOverlayController = new SbbEscapableOverlayController(this);
+			this._optionsCount = 0;
+			/** Tracks input from keyboard. */
+			this._lastUserInput = null;
+			/** If true, the 'change' event source is an option selection or a 'requireSelection' field cleanup */
+			this._isCustomChangeEvent = false;
+			this._pointerDownListener = (event) => {
+				this._isPointerDownEventOnMenu = isEventOnElement(this._overlay, event);
+			};
+			this._closeOnBackdropClick = (event) => {
+				if (!this._isPointerDownEventOnMenu && !isEventOnElement(this._overlay, event) && !isEventOnElement(this.originElement, event)) this.close();
+			};
+			this.addEventListener?.("optionselected", (e) => this.onOptionSelected(e));
+			this.addEventListener?.("ɵoptgroupslotchange", () => this._handleSlotchange(), { capture: true });
+			this.addController(new SbbPropertyWatcherController(this, () => this.closest("sbb-form-field"), {
+				negative: (e) => {
+					this.negative = e.negative;
+					this.syncNegative();
+				},
+				borderless: (e) => this.toggleState("option-panel-origin-borderless", e.borderless)
+			}));
+		}
+		/** Opens the autocomplete. */
+		open() {
+			if (this.state === "opening" || this.state === "opened" || !this._overlay || this.options.length === 0 || this._readonly() || !this.dispatchBeforeOpenEvent()) return;
+			this.showPopover?.();
+			this.state = "opening";
+			this.triggerElement?.toggleAttribute("data-expanded", true);
+			const originElement = this.originElement;
+			if (!originElement) throw new Error("Cannot find the origin element. Please specify a valid element or check the usage of the \"origin\" property from the documentation");
+			this._setOverlayPosition(originElement);
+			this._setNextActiveOptionIfAutoActiveFirstOption();
+			this._attachOpenPanelEvents();
+			this._escapableOverlayController.connect();
+			if (this._isZeroAnimationDuration()) this._handleOpening();
+		}
+		/** Closes the autocomplete. */
+		close() {
+			if (this.state === "closing" || this.state === "closed" || !this.dispatchBeforeCloseEvent()) return;
+			if (this.pendingAutoSelectedOption) {
+				this.pendingAutoSelectedOption.selected = true;
+				this._setValueAndDispatchEvents(this.pendingAutoSelectedOption, true);
+			}
+			this.state = "closing";
+			this.triggerElement?.removeAttribute("data-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");
+		}
+		connectedCallback() {
+			this.popover = "manual";
+			super.connectedCallback();
+			if (ariaRoleOnHost) this.id ||= this.overlayId;
+			if (this.hasUpdated) this._componentSetup();
+			this.syncNegative();
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("negative")) this.syncNegative();
+			if (changedProperties.has("autoActiveFirstOption") && this.isOpen) this._setNextActiveOptionIfAutoActiveFirstOption();
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._componentSetup();
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this._triggerElement = null;
+			this._triggerAbortController?.abort();
+			this._openPanelEventsController?.abort();
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (isServer || !this.hasUpdated) return;
+			if (!name || name === "trigger") this._configureTrigger();
+			else if ((!name || name === "origin") && this.isOpen) this._setOverlayPosition();
+		}
+		/** When an option is selected, update the input value and close the autocomplete. */
+		onOptionSelected(event) {
+			const target = event.target;
+			this._setValueAndDispatchEvents(target);
+			this.close();
+		}
+		/** @deprecated */
+		onOptionArrowsSelected(_activeOption) {}
+		/**
+		* A 'pending selection' sets the option value in the input element without emitting events.
+		* A 'pending selection' is confirmed when the panel closes. Any other user interaction
+		* will reset the pending value.
+		*/
+		setPendingSelection(activeOption) {
+			this.pendingAutoSelectedOption = activeOption;
+			this._setInputValue(activeOption);
+		}
+		_setValueAndDispatchEvents(selectedOption, preventFocus = false) {
+			this.options.filter((option) => option.id !== selectedOption.id && option.selected).forEach((option) => option.selected = false);
+			this.pendingAutoSelectedOption = null;
+			if (this.triggerElement) {
+				this._setInputValue(selectedOption);
+				this._isCustomChangeEvent = true;
+				this.triggerElement.dispatchEvent(new Event("change", { bubbles: true }));
+				this.triggerElement.dispatchEvent(new InputEvent("input", {
+					bubbles: true,
+					composed: true
+				}));
+				this._lastUserInput = null;
+				this.triggerElement.dispatchEvent(new CustomEvent("inputAutocomplete", { detail: { option: selectedOption } }));
+				if (!preventFocus) this.triggerElement.focus();
+			}
+		}
+		/** Set the option value within the input element */
+		_setInputValue(option) {
+			if (!this.triggerElement) return;
+			const toDisplay = this.displayWith?.(option.value) ?? option.value;
+			Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value").set.call(this.triggerElement, toDisplay);
+		}
+		_handleSlotchange() {
+			this._highlightOptions(this.triggerElement?.value);
+			/**
+			* It's possible to filter out options with an opened panel on input change.
+			* In this case, the panel's position must be recalculated considering the new option's list.
+			*/
+			if (this.isOpen) {
+				this._setOverlayPosition();
+				this._setNextActiveOptionIfAutoActiveFirstOption();
+				if (this._optionsCount > 0 && this.options.length === 0) this.close();
+			} else if (document?.activeElement === this.triggerElement && this._optionsCount === 0 && this.options.length > 0) this.open();
+			this._optionsCount = this.options.length;
+		}
+		_setNextActiveOptionIfAutoActiveFirstOption() {
+			if (this.autoActiveFirstOption) {
+				this.resetActiveElement();
+				this.setNextActiveOption();
+			}
+		}
+		/** The autocomplete should inherit 'readonly' state from the trigger. */
+		_readonly() {
+			return this.triggerElement?.hasAttribute("readonly") ?? false;
+		}
+		_componentSetup() {
+			if (isServer) return;
+			this._configureTrigger();
+		}
+		_configureTrigger() {
+			const triggerElement = this.trigger ?? this.closest?.("sbb-form-field")?.querySelector("input");
+			if (triggerElement === this.triggerElement) return;
+			this._triggerAbortController?.abort();
+			removeAriaComboBoxAttributes(this.triggerElement);
+			this.triggerElement?.removeAttribute("data-expanded");
+			this._triggerElement = triggerElement;
+			if (!this.triggerElement) return;
+			const originElement = this.originElement;
+			if (this.triggerElement === originElement && this.isOpen) this._setOverlayPosition(originElement);
+			this._triggerAttributeObserver?.observe(this.triggerElement, {
+				attributes: true,
+				attributeFilter: ["disabled", "readonly"]
+			});
+			this.setTriggerAttributes(this.triggerElement);
+			this._triggerAbortController = new AbortController();
+			this.triggerElement.addEventListener("focus", () => this.open(), { signal: this._triggerAbortController.signal });
+			this.triggerElement.addEventListener("click", () => this.open(), { signal: this._triggerAbortController.signal });
+			this.triggerElement.addEventListener("input", (event) => {
+				const value = event.target.value;
+				if (value) this.open();
+				this._highlightOptions(value);
+				this._lastUserInput = value;
+				this.pendingAutoSelectedOption = null;
+			}, { signal: this._triggerAbortController.signal });
+			this.triggerElement.addEventListener("change", (event) => {
+				/**
+				* In 'requireSelection' mode, we block the native change events and
+				* let only pass the ones that come with a valid value (when an option is selected)
+				*/
+				if (this.requireSelection && !this._isCustomChangeEvent) event.stopImmediatePropagation();
+				this._isCustomChangeEvent = false;
+			}, {
+				signal: this._triggerAbortController.signal,
+				capture: true
+			});
+			this.triggerElement.addEventListener("keydown", (event) => this._closedPanelKeyboardInteraction(event), {
+				signal: this._triggerAbortController.signal,
+				capture: true
+			});
+			this.triggerElement.addEventListener("blur", (e) => {
+				if (this.contains(e.relatedTarget)) return;
+				if (this.autoSelectActiveOptionOnBlur && this.activeOption && this._lastUserInput && this.triggerElement?.value) {
+					this.activeOption.selected = true;
+					this._setValueAndDispatchEvents(this.activeOption, true);
+				}
+				if (this.requireSelection && this.triggerElement && this._lastUserInput != null) {
+					Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value").set.call(this.triggerElement, "");
+					this._highlightOptions("");
+					this._isCustomChangeEvent = true;
+					this.triggerElement.dispatchEvent(new Event("change", { bubbles: true }));
+					this.triggerElement.dispatchEvent(new InputEvent("input", {
+						bubbles: true,
+						composed: true
+					}));
+				}
+				this.close();
+			}, {
+				signal: this._triggerAbortController.signal,
+				capture: true
+			});
+		}
+		_setOverlayPosition(originElement = this.originElement) {
+			if (!originElement) return;
+			setOverlayPosition(this._overlay, originElement, this._optionContainer, this.shadowRoot.querySelector(".sbb-autocomplete__container"), this, this.position);
+		}
+		/**
+		* On open/close animation end.
+		* In rare cases it can be that the animationEnd event is triggered twice.
+		* To avoid entering a corrupt state, exit when state is not expected.
+		*/
+		_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";
+			if (this.originElement) this._originResizeObserver.observe(this.originElement);
+			this.triggerElement?.setAttribute("aria-expanded", "true");
+			this.dispatchOpenEvent();
+		}
+		_handleClosing() {
+			this.state = "closed";
+			this.hidePopover?.();
+			this.triggerElement?.setAttribute("aria-expanded", "false");
+			this.resetActiveElement();
+			this._optionContainer.scrollTop = 0;
+			this._escapableOverlayController.disconnect();
+			this.dispatchCloseEvent();
+		}
+		_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 });
+			this.addEventListener("ɵdisabledchange", () => {
+				if (this.activeOption?.disabled) this.resetActiveElement();
+				this._setNextActiveOptionIfAutoActiveFirstOption();
+			}, { signal: this._openPanelEventsController.signal });
+			this.triggerElement?.addEventListener("keydown", (event) => this.openedPanelKeyboardInteraction(event), {
+				signal: this._openPanelEventsController.signal,
+				capture: true
+			});
+		}
+		_closedPanelKeyboardInteraction(event) {
+			if (this.state === "opening" || this.state === "opened") return;
+			switch (event.key) {
+				case "ArrowDown":
+				case "ArrowUp":
+					this.open();
+					break;
+			}
+		}
+		/** Highlight the searched text on the options. */
+		_highlightOptions(searchTerm) {
+			if (searchTerm === null || searchTerm === void 0) return;
+			this.options.forEach((option) => option.highlight(searchTerm));
+		}
+		render() {
+			return html`
+      <div class="sbb-autocomplete__gap-fix"></div>
+      <div class="sbb-autocomplete__container">
+        <div class="sbb-autocomplete__gap-fix">${overlayGapFixCorners()}</div>
+        <div
+          @animationend=${this._onAnimationEnd}
+          class="sbb-autocomplete__panel"
+          ${ref((overlayRef) => this._overlay = overlayRef)}
+        >
+          <div class="sbb-autocomplete__wrapper">
+            <div
+              class="sbb-autocomplete__options"
+              role=${!ariaRoleOnHost ? this.panelRole : nothing}
+              id=${!ariaRoleOnHost ? this.overlayId : nothing}
+              tabindex="-1"
+              ${ref((containerRef) => this._optionContainer = containerRef)}
+            >
+              <slot @slotchange=${this._handleSlotchange}></slot>
+            </div>
+          </div>
+        </div>
+      </div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbAutocompleteBaseElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"autocomplete-base-element-YwfObJzm.js","names":[],"sources":["../../../src/elements/autocomplete/autocomplete-base-element.scss?inline","../../../src/elements/autocomplete/autocomplete-base-element.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-pointer-events: all;\n  --sbb-options-panel-internal-z-index: var(\n    --sbb-autocomplete-z-index,\n    var(--sbb-overlay-default-z-index)\n  );\n\n  display: none;\n  font-weight: normal;\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(:is(:state(state-opening), :state(state-opened), :state(state-closing))) {\n  display: block;\n}\n\n:host([negative]) {\n  @include sbb.options-panel-overlay-negative-variables;\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  --sbb-options-pointer-events: none;\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:host([preserve-icon-space]) {\n  --sbb-option-icon-container-display: block;\n}\n\n::slotted(sbb-divider) {\n  margin-block: var(--sbb-options-panel-divider-margin-block);\n}\n\n.sbb-autocomplete__container {\n  @include sbb.options-panel-overlay-container;\n}\n\n.sbb-autocomplete__gap-fix {\n  @include sbb.options-panel-overlay-gap;\n}\n\n.sbb-autocomplete__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-5-hard);\n  }\n\n  :host(:is(:state(state-opened), :state(state-opening))[negative]) & {\n    box-shadow: var(--sbb-box-shadow-level-5-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-5-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-5-hard-negative);\n    }\n  }\n}\n\n.sbb-autocomplete__wrapper {\n  overflow: hidden;\n}\n\n.sbb-autocomplete__options {\n  @include sbb.optionsOverlay;\n  @include sbb.scrollbar-rules;\n\n  pointer-events: var(--sbb-options-pointer-events);\n\n  @include sbb.if-forced-colors {\n    border: var(--sbb-border-width-1x) solid CanvasText;\n    border-top: 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 { 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 } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport { SbbOpenCloseBaseElement } from '../core/base-elements.ts';\nimport {\n  SbbPropertyWatcherController,\n  SbbEscapableOverlayController,\n} from '../core/controllers.ts';\nimport { forceType, idReference } from '../core/decorators.ts';\nimport { isLean, isSafari, isZeroAnimationDuration } from '../core/dom.ts';\nimport { SbbNegativeMixin } from '../core/mixins.ts';\nimport {\n  isEventOnElement,\n  overlayGapFixCorners,\n  removeAriaComboBoxAttributes,\n  setOverlayPosition,\n} from '../core/overlay.ts';\nimport { boxSizingStyles } from '../core/styles.ts';\nimport type { SbbFormFieldElement } from '../form-field/form-field/form-field.component.ts';\nimport type { SbbOptionBaseElement } from '../option.ts';\n\nimport style from './autocomplete-base-element.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 \"closer\" to the options, or else optgroups won't work.\n */\nconst ariaRoleOnHost = isSafari;\n\nexport abstract class SbbAutocompleteBaseElement<T = string> extends SbbNegativeMixin(\n  SbbOpenCloseBaseElement,\n) {\n  public static override styles: CSSResultGroup = [boxSizingStyles, unsafeCSS(style)];\n\n  /**\n   * The element where the autocomplete will attach.\n   * If not set, as fallback there are two elements which can act as origin with following priority order:\n   * 1. `sbb-form-field` if it is an ancestor.\n   * 2. trigger element if set.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property()\n  public accessor origin: HTMLElement | null = null;\n\n  /**\n   * The input element that will trigger the autocomplete opening.\n   * By default, the autocomplete will open on focus, click, input or `ArrowDown` keypress of the 'trigger' element.\n   * If not set, will search for the first 'input' child of a 'sbb-form-field' ancestor.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property()\n  public accessor trigger: HTMLInputElement | null = null;\n\n  /** Whether the icon space is preserved when no icon is set. */\n  @forceType()\n  @property({ attribute: 'preserve-icon-space', reflect: true, type: Boolean })\n  public accessor preserveIconSpace: boolean = false;\n\n  /** Whether the first option is automatically activated when the autocomplete is opened. */\n  @forceType()\n  @property({ attribute: 'auto-active-first-option', type: Boolean })\n  public accessor autoActiveFirstOption: boolean = false;\n\n  /** Function that maps an option's control value to its display value in the trigger. */\n  @property({ attribute: false })\n  public accessor displayWith: ((value: T) => string) | 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  /** Whether the active option should be selected as the user is navigating. */\n  @forceType()\n  @property({ attribute: 'auto-select-active-option', type: Boolean })\n  public accessor autoSelectActiveOption: boolean = false;\n\n  /**\n   * When enabled, the active option is automatically selected on blur.\n   * This is an experimental feature. It might be subject to changes.\n   */\n  @forceType()\n  @property({ attribute: 'auto-select-active-option-on-blur', type: Boolean })\n  public accessor autoSelectActiveOptionOnBlur: boolean = false;\n\n  /**\n   * Whether the user is required to make a selection when they're interacting with the\n   * autocomplete. If the user moves away from the autocomplete without selecting an option from\n   * the list, the value will be reset. If the user opens the panel and closes it without\n   * interacting or selecting a value, the initial value will be kept.\n   */\n  @forceType()\n  @property({ attribute: 'require-selection', type: Boolean })\n  public accessor requireSelection: boolean = false;\n\n  /**\n   * The position of the autocomplete panel relative to the trigger.\n   * @default 'auto'\n   */\n  @property()\n  public accessor position: 'auto' | 'above' | 'below' = 'auto';\n\n  /** Returns the element where the autocomplete overlay is attached to. */\n  public get originElement(): HTMLElement | null {\n    return (\n      this.origin ??\n      this.closest?.('sbb-form-field')?.shadowRoot?.querySelector?.('#overlay-anchor') ??\n      this.trigger ??\n      null\n    );\n  }\n\n  /** Returns the trigger element. */\n  public get triggerElement(): HTMLInputElement | null {\n    return this._triggerElement ?? null;\n  }\n  private _triggerElement?: HTMLInputElement | null;\n\n  protected abstract overlayId: string;\n  protected abstract panelRole: string;\n  protected activeOption: SbbOptionBaseElement<T> | null = null;\n  protected pendingAutoSelectedOption: SbbOptionBaseElement<T> | null = null;\n  private _originResizeObserver = new ResizeController(this, {\n    target: null,\n    skipInitial: true,\n    callback: () => {\n      if (this.state === 'opened') {\n        this._setOverlayPosition();\n      }\n    },\n  });\n  /** Listens to the changes on the `disabled` or `readonly` attribute of the trigger. */\n  private _triggerAttributeObserver = !isServer\n    ? new MutationObserver((mutations: MutationRecord[]): void => {\n        const input = mutations[0].target as HTMLInputElement;\n        if (input.hasAttribute('disabled') || input.hasAttribute('readonly')) {\n          this.close();\n        }\n      })\n    : null;\n  private _overlay!: HTMLElement;\n  private _optionContainer!: HTMLElement;\n  private _triggerAbortController!: AbortController;\n  private _openPanelEventsController!: AbortController;\n  private _isPointerDownEventOnMenu: boolean = false;\n  private _escapableOverlayController = new SbbEscapableOverlayController(this);\n  private _optionsCount = 0;\n\n  /** Tracks input from keyboard. */\n  private _lastUserInput: string | null = null;\n\n  /** If true, the 'change' event source is an option selection or a 'requireSelection' field cleanup */\n  private _isCustomChangeEvent = false;\n\n  protected abstract get options(): SbbOptionBaseElement<T>[];\n\n  public constructor() {\n    super();\n    this.addEventListener?.('optionselected', (e: Event) => this.onOptionSelected(e));\n    this.addEventListener?.('ɵoptgroupslotchange', () => this._handleSlotchange(), {\n      capture: true,\n    });\n    this.addController(\n      new SbbPropertyWatcherController(\n        this,\n        () => this.closest<SbbFormFieldElement>('sbb-form-field'),\n        {\n          negative: (e) => {\n            this.negative = e.negative;\n            this.syncNegative();\n          },\n          borderless: (e) => this.toggleState('option-panel-origin-borderless', e.borderless),\n        },\n      ),\n    );\n  }\n\n  protected abstract syncNegative(): void;\n  protected abstract setTriggerAttributes(element: HTMLInputElement): void;\n  protected abstract openedPanelKeyboardInteraction(event: KeyboardEvent): void;\n  protected abstract selectByKeyboard(event: KeyboardEvent): void;\n  protected abstract setNextActiveOption(event?: KeyboardEvent): void;\n  protected abstract resetActiveElement(): void;\n\n  /** Opens the autocomplete. */\n  public open(): void {\n    if (\n      this.state === 'opening' ||\n      this.state === 'opened' ||\n      !this._overlay ||\n      this.options.length === 0 ||\n      this._readonly() ||\n      !this.dispatchBeforeOpenEvent()\n    ) {\n      return;\n    }\n\n    this.showPopover?.();\n    this.state = 'opening';\n    this.triggerElement?.toggleAttribute('data-expanded', true);\n    const originElement = this.originElement;\n    if (!originElement) {\n      throw new Error(\n        'Cannot find the origin element. Please specify a valid element or check the usage of the \"origin\" property from the documentation',\n      );\n    }\n    this._setOverlayPosition(originElement);\n    this._setNextActiveOptionIfAutoActiveFirstOption();\n    this._attachOpenPanelEvents();\n    this._escapableOverlayController.connect();\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 autocomplete. */\n  public close(): void {\n    if (this.state === 'closing' || this.state === 'closed' || !this.dispatchBeforeCloseEvent()) {\n      return;\n    }\n\n    // A 'pending selection' is confirmed on panel close\n    if (this.pendingAutoSelectedOption) {\n      this.pendingAutoSelectedOption.selected = true;\n      this._setValueAndDispatchEvents(this.pendingAutoSelectedOption, true);\n    }\n\n    this.state = 'closing';\n    this.triggerElement?.removeAttribute('data-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  public override connectedCallback(): void {\n    this.popover = 'manual';\n    super.connectedCallback();\n    if (ariaRoleOnHost) {\n      this.id ||= this.overlayId;\n    }\n\n    if (this.hasUpdated) {\n      this._componentSetup();\n    }\n    this.syncNegative();\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\n    if (changedProperties.has('autoActiveFirstOption') && this.isOpen) {\n      this._setNextActiveOptionIfAutoActiveFirstOption();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._componentSetup();\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._triggerElement = null;\n    this._triggerAbortController?.abort();\n    this._openPanelEventsController?.abort();\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n\n    if (isServer || !this.hasUpdated) {\n      return;\n    }\n    if (!name || name === 'trigger') {\n      this._configureTrigger();\n    } else if ((!name || name === 'origin') && this.isOpen) {\n      this._setOverlayPosition();\n    }\n  }\n\n  /** When an option is selected, update the input value and close the autocomplete. */\n  protected onOptionSelected(event: Event): void {\n    const target = event.target as SbbOptionBaseElement<T>;\n    this._setValueAndDispatchEvents(target);\n    this.close();\n  }\n\n  /** @deprecated */\n  protected onOptionArrowsSelected(_activeOption: SbbOptionBaseElement<T>): void {}\n\n  /**\n   * A 'pending selection' sets the option value in the input element without emitting events.\n   * A 'pending selection' is confirmed when the panel closes. Any other user interaction\n   * will reset the pending value.\n   */\n  protected setPendingSelection(activeOption: SbbOptionBaseElement<T>): void {\n    this.pendingAutoSelectedOption = activeOption;\n    this._setInputValue(activeOption);\n  }\n\n  private _setValueAndDispatchEvents(\n    selectedOption: SbbOptionBaseElement<T>,\n    preventFocus = false,\n  ): void {\n    // Deselect the previous options\n    this.options\n      .filter((option) => option.id !== selectedOption.id && option.selected)\n      .forEach((option) => (option.selected = false));\n    this.pendingAutoSelectedOption = null;\n\n    if (this.triggerElement) {\n      this._setInputValue(selectedOption);\n\n      // Manually trigger the change events\n      this._isCustomChangeEvent = true;\n      this.triggerElement.dispatchEvent(new Event('change', { bubbles: true }));\n      this.triggerElement.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n\n      // Dispatching the input event changes _lastInput, which should stay empty since there's no keyboard interaction.\n      this._lastUserInput = null;\n\n      // Custom input event emitted when input value changes after an option is selected\n      this.triggerElement.dispatchEvent(\n        new CustomEvent<{ option: SbbOptionBaseElement<T> }>('inputAutocomplete', {\n          detail: { option: selectedOption },\n        }),\n      );\n      if (!preventFocus) {\n        this.triggerElement.focus();\n      }\n    }\n  }\n\n  /** Set the option value within the input element */\n  private _setInputValue(option: SbbOptionBaseElement<T>): void {\n    if (!this.triggerElement) {\n      return;\n    }\n\n    // Given a value, returns the string that should be shown within the input.\n    const toDisplay = this.displayWith?.(option.value as T) ?? option.value;\n\n    // Set the option value\n    // In order to support React onChange event, we have to get the setter and call it.\n    // https://github.com/facebook/react/issues/11600#issuecomment-345813130\n    const setValue = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!;\n    setValue.call(this.triggerElement, toDisplay);\n  }\n\n  private _handleSlotchange(): void {\n    this._highlightOptions(this.triggerElement?.value);\n\n    /**\n     * It's possible to filter out options with an opened panel on input change.\n     * In this case, the panel's position must be recalculated considering the new option's list.\n     */\n    if (this.isOpen) {\n      this._setOverlayPosition();\n      this._setNextActiveOptionIfAutoActiveFirstOption();\n\n      // If the autocomplete is open and the option count gets to zero, we close the autocomplete.\n      if (this._optionsCount > 0 && this.options.length === 0) {\n        this.close();\n      }\n    } else if (\n      // If the 'input' is focused and the count of options changes from 0 to > 0,\n      // the autocomplete should open automatically.\n      document?.activeElement === this.triggerElement &&\n      this._optionsCount === 0 &&\n      this.options.length > 0\n    ) {\n      this.open();\n    }\n\n    this._optionsCount = this.options.length;\n  }\n\n  private _setNextActiveOptionIfAutoActiveFirstOption(): void {\n    if (this.autoActiveFirstOption) {\n      this.resetActiveElement();\n      this.setNextActiveOption();\n    }\n  }\n\n  /** The autocomplete should inherit 'readonly' state from the trigger. */\n  private _readonly(): boolean {\n    return this.triggerElement?.hasAttribute('readonly') ?? false;\n  }\n\n  private _componentSetup(): void {\n    if (isServer) {\n      return;\n    }\n\n    this._configureTrigger();\n  }\n\n  private _configureTrigger(): void {\n    const triggerElement = (this.trigger ??\n      this.closest?.('sbb-form-field')?.querySelector('input')) as HTMLInputElement | null;\n    if (triggerElement === this.triggerElement) {\n      return;\n    }\n\n    this._triggerAbortController?.abort();\n    removeAriaComboBoxAttributes(this.triggerElement);\n    this.triggerElement?.removeAttribute('data-expanded');\n    this._triggerElement = triggerElement;\n\n    if (!this.triggerElement) {\n      return;\n    }\n\n    // As the trigger can be the fallback of the origin, we eventually have to update the position.\n    const originElement = this.originElement;\n    if (this.triggerElement === originElement && this.isOpen) {\n      this._setOverlayPosition(originElement);\n    }\n\n    this._triggerAttributeObserver?.observe(this.triggerElement!, {\n      attributes: true,\n      attributeFilter: ['disabled', 'readonly'],\n    });\n\n    this.setTriggerAttributes(this.triggerElement);\n    this._triggerAbortController = new AbortController();\n\n    // Open the overlay on focus, click, input and `ArrowDown` event\n    this.triggerElement.addEventListener('focus', () => this.open(), {\n      signal: this._triggerAbortController.signal,\n    });\n    this.triggerElement.addEventListener('click', () => this.open(), {\n      signal: this._triggerAbortController.signal,\n    });\n    this.triggerElement.addEventListener(\n      'input',\n      (event) => {\n        const value: string = (event.target as HTMLInputElement).value;\n\n        if (value) {\n          this.open();\n        }\n        this._highlightOptions(value);\n        this._lastUserInput = value;\n        this.pendingAutoSelectedOption = null;\n      },\n      { signal: this._triggerAbortController.signal },\n    );\n    this.triggerElement.addEventListener(\n      'change',\n      (event) => {\n        /**\n         * In 'requireSelection' mode, we block the native change events and\n         * let only pass the ones that come with a valid value (when an option is selected)\n         */\n        if (this.requireSelection && !this._isCustomChangeEvent) {\n          event.stopImmediatePropagation();\n        }\n        this._isCustomChangeEvent = false;\n      },\n      { signal: this._triggerAbortController.signal, capture: true },\n    );\n    this.triggerElement.addEventListener(\n      'keydown',\n      (event: KeyboardEvent) => this._closedPanelKeyboardInteraction(event),\n      {\n        signal: this._triggerAbortController.signal,\n        // We need key event to run before any other subscription to guarantee a correct\n        // interaction with other components (necessary for the 'sbb-chip-group' use case).\n        capture: true,\n      },\n    );\n\n    this.triggerElement.addEventListener(\n      'blur',\n      (e) => {\n        // If the new focus is the autocomplete or inside of it then an option\n        // was selected. Therefore, the focus is still on the component.\n        if (this.contains(e.relatedTarget as Node)) {\n          return;\n        }\n\n        // If 'autoSelectActiveOptionOnBlur' is enabled, select the active option on blur\n        if (\n          this.autoSelectActiveOptionOnBlur &&\n          this.activeOption &&\n          this._lastUserInput &&\n          this.triggerElement?.value\n        ) {\n          this.activeOption.selected = true;\n          this._setValueAndDispatchEvents(this.activeOption, true);\n        }\n\n        // Clears the input if there's user interaction without selection (selection clears `_lastUserInput`).\n        if (this.requireSelection && this.triggerElement && this._lastUserInput != null) {\n          const setValue = Object.getOwnPropertyDescriptor(\n            HTMLInputElement.prototype,\n            'value',\n          )!.set!;\n          setValue.call(this.triggerElement, '');\n          this._highlightOptions('');\n          this._isCustomChangeEvent = true;\n          this.triggerElement.dispatchEvent(new Event('change', { bubbles: true }));\n          this.triggerElement.dispatchEvent(\n            new InputEvent('input', { bubbles: true, composed: true }),\n          );\n        }\n\n        this.close();\n      },\n      { signal: this._triggerAbortController.signal, capture: true },\n    );\n  }\n\n  // Set overlay position, width and max height\n  private _setOverlayPosition(originElement = this.originElement): void {\n    // An undefined originElement should only occur in the unlikely event\n    // that the autocomplete loses its originElement and triggerElement during an open state.\n    if (!originElement) {\n      return;\n    }\n    setOverlayPosition(\n      this._overlay,\n      originElement,\n      this._optionContainer,\n      this.shadowRoot!.querySelector('.sbb-autocomplete__container')!,\n      this,\n      this.position,\n    );\n  }\n\n  /**\n   * On open/close animation end.\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   */\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    if (this.originElement) {\n      this._originResizeObserver.observe(this.originElement);\n    }\n    this.triggerElement?.setAttribute('aria-expanded', 'true');\n    this.dispatchOpenEvent();\n  }\n\n  private _handleClosing(): void {\n    this.state = 'closed';\n    this.hidePopover?.();\n    this.triggerElement?.setAttribute('aria-expanded', 'false');\n\n    this.resetActiveElement();\n    this._optionContainer.scrollTop = 0;\n    this._escapableOverlayController.disconnect();\n    this.dispatchCloseEvent();\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 autocomplete 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    this.addEventListener(\n      'ɵdisabledchange',\n      () => {\n        if (this.activeOption?.disabled) {\n          this.resetActiveElement();\n        }\n        this._setNextActiveOptionIfAutoActiveFirstOption();\n      },\n      {\n        signal: this._openPanelEventsController.signal,\n      },\n    );\n\n    // Keyboard interactions\n    this.triggerElement?.addEventListener(\n      'keydown',\n      (event: KeyboardEvent) => this.openedPanelKeyboardInteraction(event),\n      {\n        signal: this._openPanelEventsController.signal,\n        // We need key event to run before any other subscription to guarantee a correct\n        // interaction with other components (necessary for the 'sbb-chip-group' use case).\n        capture: true,\n      },\n    );\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  // If the click is outside the autocomplete, closes the panel.\n  private _closeOnBackdropClick = (event: PointerEvent): void => {\n    if (\n      !this._isPointerDownEventOnMenu &&\n      !isEventOnElement(this._overlay, event) &&\n      !isEventOnElement(this.originElement, event)\n    ) {\n      this.close();\n    }\n  };\n\n  private _closedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (this.state === 'opening' || this.state === 'opened') {\n      return;\n    }\n\n    switch (event.key) {\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this.open();\n        break;\n    }\n  }\n\n  /** Highlight the searched text on the options. */\n  private _highlightOptions(searchTerm?: string): void {\n    if (searchTerm === null || searchTerm === undefined) {\n      return;\n    }\n    this.options.forEach((option) => option.highlight(searchTerm));\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-autocomplete__options gets focus.\n    // As elements inside the panel should never get focus, we have to avoid that by setting tabindex=-1.\n    return html`\n      <div class=\"sbb-autocomplete__gap-fix\"></div>\n      <div class=\"sbb-autocomplete__container\">\n        <div class=\"sbb-autocomplete__gap-fix\">${overlayGapFixCorners()}</div>\n        <div\n          @animationend=${this._onAnimationEnd}\n          class=\"sbb-autocomplete__panel\"\n          ${ref((overlayRef?: Element) => (this._overlay = overlayRef as HTMLElement))}\n        >\n          <div class=\"sbb-autocomplete__wrapper\">\n            <div\n              class=\"sbb-autocomplete__options\"\n              role=${!ariaRoleOnHost ? this.panelRole : nothing}\n              id=${!ariaRoleOnHost ? this.overlayId : nothing}\n              tabindex=\"-1\"\n              ${ref((containerRef) => (this._optionContainer = containerRef as HTMLElement))}\n            >\n              <slot @slotchange=${this._handleSlotchange}></slot>\n            </div>\n          </div>\n        </div>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementEventMap {\n    inputAutocomplete: CustomEvent<{ option: SbbOptionBaseElement<any> }>;\n  }\n}\n"],"mappings":"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"}