@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/autocomplete.js

@@ -0,0 +1,720 @@
+import { css, isServer, html, nothing } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { ref } from "lit/directives/ref.js";
+import { getNextElementIndex } from "./core/a11y.js";
+import { SbbOpenCloseBaseElement } from "./core/base-elements.js";
+import { SbbConnectedAbortController } from "./core/controllers.js";
+import { hostAttributes } from "./core/decorators.js";
+import { findReferencedElement, getDocumentWritingMode, isSafari } from "./core/dom.js";
+import { SbbNegativeMixin, SbbHydrationMixin } from "./core/mixins.js";
+import { isEventOnElement, setOverlayPosition, setAriaComboBoxAttributes, removeAriaComboBoxAttributes, overlayGapFixCorners } from "./core/overlay.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+.sbb-gap-fix-wrapper {
+  position: relative;
+  overflow: hidden;
+  width: var(--sbb-options-panel-border-radius);
+  height: var(--sbb-options-panel-border-radius);
+  background-color: transparent;
+}
+
+.sbb-gap-fix-corner {
+  position: absolute;
+  border-radius: 50%;
+  border: calc(var(--sbb-options-panel-border-radius) / 2) solid var(--sbb-options-panel-background-color);
+  width: calc(var(--sbb-options-panel-border-radius) * 3);
+  height: calc(var(--sbb-options-panel-border-radius) * 3);
+  bottom: calc(var(--sbb-options-panel-border-radius) / 2 * -1);
+}
+
+.sbb-gap-fix-corner#left {
+  left: calc(var(--sbb-options-panel-border-radius) / 2 * -1);
+}
+:host([dir=rtl]) .sbb-gap-fix-corner#left {
+  right: calc(var(--sbb-options-panel-border-radius) / 2 * -1);
+  left: unset;
+}
+
+.sbb-gap-fix-corner#right {
+  right: calc(var(--sbb-options-panel-border-radius) / 2 * -1);
+}
+:host([dir=rtl]) .sbb-gap-fix-corner#right {
+  left: calc(var(--sbb-options-panel-border-radius) / 2 * -1);
+  right: unset;
+}
+
+:host {
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: var(--sbb-color-black-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-black-alpha-60);
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-options-panel-position-x: 0;
+  --sbb-options-panel-position-y: 0;
+  --sbb-options-panel-active-option-y: 0;
+  --sbb-options-panel-max-height: calc(85vh - var(--sbb-spacing-fixed-8x));
+  --sbb-options-panel-min-height: var(--sbb-options-panel-origin-height);
+  --sbb-options-panel-visibility: visible;
+  --sbb-options-panel-width: fit-content;
+  --sbb-options-panel-border-radius: var(--sbb-border-radius-4x);
+  --sbb-options-panel-options-border-radius: 0 0 var(--sbb-options-panel-border-radius)
+    var(--sbb-options-panel-border-radius);
+  --sbb-options-panel-animation-duration: var(
+    --sbb-disable-animation-time,
+    var(--sbb-animation-duration-4x)
+  );
+  --sbb-options-panel-animation-timing-function: ease;
+  --sbb-options-panel-gap-fix-opacity: 0;
+  --sbb-options-panel-gap-fix-transform: none;
+  --sbb-options-panel-gap-fix-top: calc(
+    var(--sbb-options-panel-position-y) - var(--sbb-options-panel-border-radius)
+  );
+  --sbb-options-panel-background-color: var(--sbb-color-white);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-default);
+  --sbb-options-panel-internal-z-index: var(
+    --sbb-autocomplete-z-index,
+    var(--sbb-overlay-default-z-index)
+  );
+  display: block;
+}
+
+:host([negative]) {
+  --sbb-scrollbar-color: var(--sbb-color-white-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-white-alpha-60);
+  --sbb-options-panel-background-color: var(--sbb-color-midnight);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+}
+
+:host(:not([data-state])),
+:host([data-state=closed]) {
+  --sbb-options-panel-visibility: hidden;
+}
+
+:host([data-state=opening]) {
+  --sbb-options-panel-animation-name: open;
+}
+
+:host([data-state=closing]) {
+  --sbb-options-panel-animation-name: close;
+}
+
+:host([data-state=opened]),
+:host([data-state=opening]) {
+  --sbb-options-panel-gap-fix-opacity: 1;
+}
+
+:host([data-options-panel-position=below]) {
+  --sbb-options-panel-animation-transform: translateY(
+    calc((var(--sbb-options-panel-origin-height) / 2) * -1)
+  );
+}
+
+:host([data-options-panel-position=above]) {
+  --sbb-options-panel-options-border-radius: var(--sbb-options-panel-border-radius)
+    var(--sbb-options-panel-border-radius) 0 0;
+  --sbb-options-panel-gap-fix-top: var(--sbb-options-panel-max-height);
+  --sbb-options-panel-gap-fix-transform: rotate(180deg);
+  --sbb-options-panel-animation-transform: translateY(
+    calc(var(--sbb-options-panel-origin-height) / 2)
+  );
+}
+
+:host([preserve-icon-space]) {
+  --sbb-option-icon-container-display: block;
+}
+
+::slotted(sbb-divider) {
+  margin-block: var(--sbb-spacing-fixed-3x);
+}
+
+.sbb-autocomplete__container {
+  position: fixed;
+  pointer-events: none;
+  inset: 0;
+  z-index: var(--sbb-options-panel-internal-z-index);
+}
+
+.sbb-autocomplete__gap-fix {
+  display: flex;
+  justify-content: space-between;
+  position: fixed;
+  visibility: var(--sbb-options-panel-visibility);
+  opacity: var(--sbb-options-panel-gap-fix-opacity);
+  background-color: transparent;
+  width: var(--sbb-options-panel-width);
+  height: var(--sbb-options-panel-border-radius);
+  top: var(--sbb-options-panel-gap-fix-top);
+  left: var(--sbb-options-panel-position-x);
+  transform: var(--sbb-options-panel-gap-fix-transform);
+  transition: opacity var(--sbb-options-panel-animation-duration) var(--sbb-options-panel-animation-timing-function);
+}
+
+.sbb-autocomplete__panel {
+  display: block;
+  position: absolute;
+  visibility: var(--sbb-options-panel-visibility);
+  overflow: hidden;
+  background-color: transparent;
+  border: none;
+  border-radius: var(--sbb-options-panel-border-radius);
+  top: var(--sbb-options-panel-position-y);
+  left: var(--sbb-options-panel-position-x);
+  width: var(--sbb-options-panel-width);
+  transition: box-shadow var(--sbb-options-panel-animation-duration) var(--sbb-options-panel-animation-timing-function);
+  /* stylelint-disable-next-line no-descending-specificity */
+}
+.sbb-autocomplete__panel::before, .sbb-autocomplete__panel::after {
+  content: "";
+  display: none;
+  position: relative;
+  width: 100%;
+  height: var(--sbb-options-panel-origin-height);
+  background-color: transparent;
+  border-radius: var(--sbb-options-panel-border-radius);
+  pointer-events: none;
+  transition: box-shadow var(--sbb-options-panel-animation-duration) var(--sbb-options-panel-animation-timing-function);
+  z-index: 1;
+}
+:host([data-options-panel-position=below]) .sbb-autocomplete__panel {
+  inset-block-start: calc(var(--sbb-options-panel-position-y) - var(--sbb-options-panel-origin-height));
+}
+:host(:is([data-state=opened], [data-state=opening])) .sbb-autocomplete__panel {
+  box-shadow: var(--sbb-shadow-elevation-level-5-shadow-2-offset-x) var(--sbb-shadow-elevation-level-5-shadow-2-offset-y) var(--sbb-shadow-elevation-level-5-shadow-2-blur) var(--sbb-shadow-elevation-level-5-shadow-2-spread) var(--sbb-shadow-elevation-level-5-hard-2-color), var(--sbb-shadow-elevation-level-5-shadow-1-offset-x) var(--sbb-shadow-elevation-level-5-shadow-1-offset-y) var(--sbb-shadow-elevation-level-5-shadow-1-blur) var(--sbb-shadow-elevation-level-5-shadow-1-spread) var(--sbb-shadow-elevation-level-5-hard-1-color);
+}
+:host(:is([data-state=opened], [data-state=opening])[negative]) .sbb-autocomplete__panel {
+  box-shadow: var(--sbb-shadow-elevation-level-5-shadow-2-offset-x) var(--sbb-shadow-elevation-level-5-shadow-2-offset-y) var(--sbb-shadow-elevation-level-5-shadow-2-blur) var(--sbb-shadow-elevation-level-5-shadow-2-spread) var(--sbb-shadow-elevation-level-5-hard-negative-2-color), var(--sbb-shadow-elevation-level-5-shadow-1-offset-x) var(--sbb-shadow-elevation-level-5-shadow-1-offset-y) var(--sbb-shadow-elevation-level-5-shadow-1-blur) var(--sbb-shadow-elevation-level-5-shadow-1-spread) var(--sbb-shadow-elevation-level-5-hard-negative-1-color);
+}
+:host([data-options-panel-position=below]) .sbb-autocomplete__panel::before {
+  display: block;
+}
+:host([data-options-panel-position=above]) .sbb-autocomplete__panel::after {
+  display: block;
+}
+:host(:is([data-state=opened], [data-state=opening])[data-option-panel-origin-borderless]) .sbb-autocomplete__panel::before, :host(:is([data-state=opened], [data-state=opening])[data-option-panel-origin-borderless]) .sbb-autocomplete__panel::after {
+  box-shadow: var(--sbb-shadow-elevation-level-5-shadow-2-offset-x) var(--sbb-shadow-elevation-level-5-shadow-2-offset-y) var(--sbb-shadow-elevation-level-5-shadow-2-blur) var(--sbb-shadow-elevation-level-5-shadow-2-spread) var(--sbb-shadow-elevation-level-5-hard-2-color), var(--sbb-shadow-elevation-level-5-shadow-1-offset-x) var(--sbb-shadow-elevation-level-5-shadow-1-offset-y) var(--sbb-shadow-elevation-level-5-shadow-1-blur) var(--sbb-shadow-elevation-level-5-shadow-1-spread) var(--sbb-shadow-elevation-level-5-hard-1-color);
+}
+:host(:is([data-state=opened],
+[data-state=opening])[data-option-panel-origin-borderless][negative]) .sbb-autocomplete__panel::before, :host(:is([data-state=opened],
+[data-state=opening])[data-option-panel-origin-borderless][negative]) .sbb-autocomplete__panel::after {
+  box-shadow: var(--sbb-shadow-elevation-level-5-shadow-2-offset-x) var(--sbb-shadow-elevation-level-5-shadow-2-offset-y) var(--sbb-shadow-elevation-level-5-shadow-2-blur) var(--sbb-shadow-elevation-level-5-shadow-2-spread) var(--sbb-shadow-elevation-level-5-hard-negative-2-color), var(--sbb-shadow-elevation-level-5-shadow-1-offset-x) var(--sbb-shadow-elevation-level-5-shadow-1-offset-y) var(--sbb-shadow-elevation-level-5-shadow-1-blur) var(--sbb-shadow-elevation-level-5-shadow-1-spread) var(--sbb-shadow-elevation-level-5-hard-negative-1-color);
+}
+
+.sbb-autocomplete__wrapper {
+  overflow: hidden;
+}
+
+.sbb-autocomplete__options {
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+  /* Scrollbar itself */
+  /* Hide button (top and bottom of the scrollbar) */
+  background-color: var(--sbb-options-panel-background-color);
+  padding-block: var(--sbb-spacing-fixed-3x);
+  padding-inline: 0;
+  border-radius: var(--sbb-options-panel-options-border-radius);
+  max-height: var(--sbb-options-panel-max-height);
+  min-height: var(--sbb-options-panel-min-height);
+  pointer-events: all;
+  overflow-y: auto;
+  animation-name: var(--sbb-options-panel-animation-name);
+  animation-duration: var(--sbb-options-panel-animation-duration);
+  animation-timing-function: var(--sbb-options-panel-animation-timing-function);
+}
+.sbb-autocomplete__options::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-autocomplete__options::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-autocomplete__options::-webkit-scrollbar-thumb {
+  background-color: var(--sbb-scrollbar-color, currentcolor);
+  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;
+  border-radius: var(--sbb-border-radius-4x);
+  background-clip: padding-box;
+}
+.sbb-autocomplete__options::-webkit-scrollbar-thumb:hover {
+  background-color: var(--sbb-scrollbar-color-hover, currentcolor);
+  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));
+}
+.sbb-autocomplete__options::-webkit-scrollbar-button, .sbb-autocomplete__options::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-autocomplete__options {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+@media (forced-colors: active) {
+  .sbb-autocomplete__options {
+    border: var(--sbb-border-width-1x) solid CanvasText;
+    border-top: none;
+  }
+}
+
+@keyframes open {
+  from {
+    transform: var(--sbb-options-panel-animation-transform);
+    opacity: 0;
+  }
+  to {
+    transform: translateY(0);
+    opacity: 1;
+  }
+}
+@keyframes close {
+  from {
+    transform: translateY(0);
+    opacity: 1;
+  }
+  to {
+    transform: var(--sbb-options-panel-animation-transform);
+    opacity: 0;
+  }
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+let nextId = 0;
+const ariaRoleOnHost = isSafari;
+let SbbAutocompleteElement = class extends SbbNegativeMixin(
+  SbbHydrationMixin(SbbOpenCloseBaseElement)
+) {
+  constructor() {
+    super(...arguments);
+    this._overlayId = `sbb-autocomplete-${++nextId}`;
+    this._activeItemIndex = -1;
+    this._didLoad = false;
+    this._isPointerDownEventOnMenu = false;
+    this._abort = new SbbConnectedAbortController(this);
+    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();
+      }
+    };
+  }
+  /** Returns the element where autocomplete overlay is attached to. */
+  get originElement() {
+    if (!this._originElement) {
+      this._originElement = this._findOriginElement();
+    }
+    return this._originElement;
+  }
+  /** Returns the trigger element. */
+  get triggerElement() {
+    return this._triggerElement;
+  }
+  /** The autocomplete should inherit 'readonly' state from the trigger. */
+  get _readonly() {
+    var _a;
+    return ((_a = this.triggerElement) == null ? void 0 : _a.hasAttribute("readonly")) ?? false;
+  }
+  get _options() {
+    var _a;
+    return Array.from(((_a = this.querySelectorAll) == null ? void 0 : _a.call(this, "sbb-option")) ?? []);
+  }
+  /** Opens the autocomplete. */
+  open() {
+    if (this.state !== "closed" || !this._overlay || this._options.length === 0 || this._readonly) {
+      return;
+    }
+    if (!this.willOpen.emit()) {
+      return;
+    }
+    this.state = "opening";
+    this._setOverlayPosition();
+  }
+  /** Closes the autocomplete. */
+  close() {
+    if (this.state !== "opened") {
+      return;
+    }
+    if (!this.willClose.emit()) {
+      return;
+    }
+    this.state = "closing";
+    this._openPanelEventsController.abort();
+  }
+  /** Removes trigger click listener on trigger change. */
+  _resetOriginClickListener(newValue, oldValue) {
+    if (newValue !== oldValue) {
+      this._componentSetup();
+    }
+  }
+  /** Removes trigger click listener on trigger change. */
+  _resetTriggerClickListener(newValue, oldValue) {
+    if (newValue !== oldValue) {
+      this._componentSetup();
+    }
+  }
+  /** When an option is selected, update the input value and close the autocomplete. */
+  _onOptionSelected(event) {
+    const target = event.target;
+    if (!target.selected) {
+      return;
+    }
+    this._options.filter((option) => option.id !== target.id && option.selected).forEach((option) => option.selected = false);
+    if (this.triggerElement) {
+      this.triggerElement.value = target.value;
+      this.triggerElement.dispatchEvent(new Event("change", { bubbles: true }));
+      this.triggerElement.dispatchEvent(new InputEvent("input", { bubbles: true, composed: true }));
+    }
+    this.close();
+  }
+  _onOptionClick(event) {
+    if (event.target.localName !== "sbb-option" || event.target.disabled) {
+      return;
+    }
+    this.close();
+  }
+  connectedCallback() {
+    var _a, _b;
+    super.connectedCallback();
+    if (ariaRoleOnHost) {
+      this.id || (this.id = this._overlayId);
+    }
+    const signal = this._abort.signal;
+    const formField = ((_a = this.closest) == null ? void 0 : _a.call(this, "sbb-form-field")) ?? ((_b = this.closest) == null ? void 0 : _b.call(this, "[data-form-field]"));
+    if (formField) {
+      this.negative = formField.hasAttribute("negative");
+    }
+    if (this._didLoad) {
+      this._componentSetup();
+    }
+    this._syncNegative();
+    this.addEventListener(
+      "optionSelectionChange",
+      (e) => this._onOptionSelected(e),
+      { signal }
+    );
+    this.addEventListener("click", (e) => this._onOptionClick(e), { signal });
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("origin")) {
+      this._resetOriginClickListener(this.origin, changedProperties.get("origin"));
+    }
+    if (changedProperties.has("trigger")) {
+      this._resetTriggerClickListener(this.trigger, changedProperties.get("trigger"));
+    }
+    if (changedProperties.has("negative")) {
+      this._syncNegative();
+    }
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this._componentSetup();
+    this._didLoad = true;
+  }
+  _syncNegative() {
+    var _a, _b;
+    (_a = this.querySelectorAll) == null ? void 0 : _a.call(this, "sbb-divider").forEach((divider) => divider.negative = this.negative);
+    (_b = this.querySelectorAll) == null ? void 0 : _b.call(
+      this,
+      "sbb-option, sbb-optgroup"
+    ).forEach((element) => element.toggleAttribute("data-negative", this.negative));
+  }
+  disconnectedCallback() {
+    var _a, _b;
+    super.disconnectedCallback();
+    (_a = this._triggerEventsController) == null ? void 0 : _a.abort();
+    (_b = this._openPanelEventsController) == null ? void 0 : _b.abort();
+  }
+  _componentSetup() {
+    var _a, _b, _c, _d;
+    if (isServer) {
+      return;
+    }
+    (_a = this._triggerEventsController) == null ? void 0 : _a.abort();
+    (_b = this._openPanelEventsController) == null ? void 0 : _b.abort();
+    this._originElement = void 0;
+    this.toggleAttribute(
+      "data-option-panel-origin-borderless",
+      !!((_d = (_c = this.closest) == null ? void 0 : _c.call(this, "sbb-form-field")) == null ? void 0 : _d.hasAttribute("borderless"))
+    );
+    this._bindTo(this._getTriggerElement());
+  }
+  /**
+   * Retrieve the element where the autocomplete will be attached.
+   * @returns 'origin' or the first 'sbb-form-field' ancestor.
+   */
+  _findOriginElement() {
+    var _a, _b, _c, _d;
+    let result;
+    if (!this.origin) {
+      result = (_d = (_c = (_b = (_a = this.closest) == null ? void 0 : _a.call(this, "sbb-form-field")) == null ? void 0 : _b.shadowRoot) == null ? void 0 : _c.querySelector) == null ? void 0 : _d.call(_c, "#overlay-anchor");
+    } else {
+      result = findReferencedElement(this.origin);
+    }
+    if (!result) {
+      throw new Error(
+        'Cannot find the origin element. Please specify a valid element or read the "origin" prop documentation'
+      );
+    }
+    return result;
+  }
+  /**
+   * Retrieve the element that will trigger the autocomplete opening.
+   * @returns 'trigger' or the first 'input' inside the origin element.
+   */
+  _getTriggerElement() {
+    var _a, _b;
+    if (!this.trigger) {
+      return (_b = (_a = this.closest) == null ? void 0 : _a.call(this, "sbb-form-field")) == null ? void 0 : _b.querySelector("input");
+    }
+    const result = findReferencedElement(this.trigger);
+    if (!result) {
+      throw new Error(
+        'Cannot find the trigger element. Please specify a valid element or read the "trigger" prop documentation'
+      );
+    }
+    return result;
+  }
+  _bindTo(triggerElem) {
+    if (!triggerElem) {
+      return;
+    }
+    this._removeTriggerAttributes(this.triggerElement);
+    this._setTriggerAttributes(triggerElem);
+    this._triggerElement = triggerElem;
+    this._setupTriggerEvents();
+  }
+  _setupTriggerEvents() {
+    var _a, _b, _c, _d;
+    this._triggerEventsController = new AbortController();
+    (_a = this.triggerElement) == null ? void 0 : _a.addEventListener("focus", () => this.open(), {
+      signal: this._triggerEventsController.signal
+    });
+    (_b = this.triggerElement) == null ? void 0 : _b.addEventListener("click", () => this.open(), {
+      signal: this._triggerEventsController.signal
+    });
+    (_c = this.triggerElement) == null ? void 0 : _c.addEventListener(
+      "input",
+      (event) => {
+        this.open();
+        this._highlightOptions(event.target.value);
+      },
+      { signal: this._triggerEventsController.signal }
+    );
+    (_d = this.triggerElement) == null ? void 0 : _d.addEventListener(
+      "keydown",
+      (event) => this._closedPanelKeyboardInteraction(event),
+      { signal: this._triggerEventsController.signal }
+    );
+  }
+  // Set overlay position, width and max height
+  _setOverlayPosition() {
+    setOverlayPosition(
+      this._overlay,
+      this.originElement,
+      this._optionContainer,
+      this.shadowRoot.querySelector(".sbb-autocomplete__container"),
+      this
+    );
+  }
+  /** 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._onOpenAnimationEnd();
+    } else if (event.animationName === "close" && this.state === "closing") {
+      this._onCloseAnimationEnd();
+    }
+  }
+  _onOpenAnimationEnd() {
+    var _a;
+    this.state = "opened";
+    this._attachOpenPanelEvents();
+    (_a = this.triggerElement) == null ? void 0 : _a.setAttribute("aria-expanded", "true");
+    this.didOpen.emit();
+  }
+  _onCloseAnimationEnd() {
+    var _a;
+    this.state = "closed";
+    (_a = this.triggerElement) == null ? void 0 : _a.setAttribute("aria-expanded", "false");
+    this._resetActiveElement();
+    this._optionContainer.scrollTop = 0;
+    this.didClose.emit();
+  }
+  _attachOpenPanelEvents() {
+    var _a;
+    this._openPanelEventsController = new AbortController();
+    document.addEventListener("scroll", () => this._setOverlayPosition(), {
+      passive: true,
+      signal: this._openPanelEventsController.signal
+    });
+    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
+    });
+    (_a = this.triggerElement) == null ? void 0 : _a.addEventListener(
+      "keydown",
+      (event) => this._openedPanelKeyboardInteraction(event),
+      {
+        signal: this._openPanelEventsController.signal
+      }
+    );
+  }
+  _closedPanelKeyboardInteraction(event) {
+    if (this.state !== "closed") {
+      return;
+    }
+    switch (event.key) {
+      case "Enter":
+      case "ArrowDown":
+      case "ArrowUp":
+        this.open();
+        break;
+    }
+  }
+  _openedPanelKeyboardInteraction(event) {
+    if (this.state !== "opened") {
+      return;
+    }
+    switch (event.key) {
+      case "Escape":
+      case "Tab":
+        this.close();
+        break;
+      case "Enter":
+        this._selectByKeyboard();
+        break;
+      case "ArrowDown":
+      case "ArrowUp":
+        this._setNextActiveOption(event);
+        break;
+    }
+  }
+  _selectByKeyboard() {
+    const activeOption = this._options[this._activeItemIndex];
+    if (activeOption) {
+      activeOption.setSelectedViaUserInteraction(true);
+    }
+  }
+  _setNextActiveOption(event) {
+    var _a;
+    const filteredOptions = this._options.filter(
+      (opt) => !opt.disabled && !opt.hasAttribute("data-group-disabled")
+    );
+    const next = getNextElementIndex(event, this._activeItemIndex, filteredOptions.length);
+    const nextActiveOption = filteredOptions[next];
+    nextActiveOption.active = true;
+    (_a = this.triggerElement) == null ? void 0 : _a.setAttribute("aria-activedescendant", nextActiveOption.id);
+    nextActiveOption.scrollIntoView({ block: "nearest" });
+    const lastActiveOption = filteredOptions[this._activeItemIndex];
+    if (lastActiveOption) {
+      lastActiveOption.active = false;
+    }
+    this._activeItemIndex = next;
+  }
+  _resetActiveElement() {
+    var _a;
+    const activeElement = this._options[this._activeItemIndex];
+    if (activeElement) {
+      activeElement.active = false;
+    }
+    this._activeItemIndex = -1;
+    (_a = this.triggerElement) == null ? void 0 : _a.removeAttribute("aria-activedescendant");
+  }
+  /** Highlight the searched text on the options. */
+  _highlightOptions(searchTerm) {
+    if (!searchTerm) {
+      return;
+    }
+    this._options.forEach((option) => option.highlight(searchTerm));
+  }
+  _setTriggerAttributes(element) {
+    setAriaComboBoxAttributes(element, this.id || this._overlayId, false);
+  }
+  _removeTriggerAttributes(element) {
+    removeAriaComboBoxAttributes(element);
+  }
+  _handleSlotchange() {
+    var _a;
+    this._highlightOptions((_a = this.triggerElement) == null ? void 0 : _a.value);
+  }
+  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 ? "listbox" : nothing}
+              id=${!ariaRoleOnHost ? this._overlayId : nothing}
+              ${ref((containerRef) => this._optionContainer = containerRef)}
+            >
+              <slot @slotchange=${this._handleSlotchange}></slot>
+            </div>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+};
+SbbAutocompleteElement.styles = style;
+__decorateClass([
+  property()
+], SbbAutocompleteElement.prototype, "origin", 2);
+__decorateClass([
+  property()
+], SbbAutocompleteElement.prototype, "trigger", 2);
+__decorateClass([
+  property({ attribute: "preserve-icon-space", reflect: true, type: Boolean })
+], SbbAutocompleteElement.prototype, "preserveIconSpace", 2);
+SbbAutocompleteElement = __decorateClass([
+  customElement("sbb-autocomplete"),
+  hostAttributes({
+    dir: getDocumentWritingMode(),
+    role: ariaRoleOnHost ? "listbox" : null
+  })
+], SbbAutocompleteElement);
+export {
+  SbbAutocompleteElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"autocomplete.js","sources":["../../../src/elements/autocomplete/autocomplete.ts"],"sourcesContent":["import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, isServer, nothing } from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport { getNextElementIndex } from '../core/a11y.js';\nimport { SbbOpenCloseBaseElement } from '../core/base-elements.js';\nimport { SbbConnectedAbortController } from '../core/controllers.js';\nimport { hostAttributes } from '../core/decorators.js';\nimport { findReferencedElement, getDocumentWritingMode, isSafari } from '../core/dom.js';\nimport { SbbHydrationMixin, SbbNegativeMixin } from '../core/mixins.js';\nimport {\n  isEventOnElement,\n  overlayGapFixCorners,\n  removeAriaComboBoxAttributes,\n  setAriaComboBoxAttributes,\n  setOverlayPosition,\n} from '../core/overlay.js';\nimport type { SbbOptGroupElement, SbbOptionElement } from '../option.js';\n\nimport style from './autocomplete.scss?lit&inline';\n\nlet nextId = 0;\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\n/**\n * Combined with a native input, it displays a panel with a list of available options.\n *\n * @slot - Use the unnamed slot to add `sbb-option` or `sbb-optgroup` elements to the `sbb-autocomplete`.\n * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-autocomplete` starts the opening transition. Can be canceled.\n * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-autocomplete` is opened.\n * @event {CustomEvent<void>} willClose - Emits whenever the `sbb-autocomplete` begins the closing transition. Can be canceled.\n * @event {CustomEvent<void>} didClose - Emits whenever the `sbb-autocomplete` is closed.\n * @cssprop [--sbb-autocomplete-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 */\n@customElement('sbb-autocomplete')\n@hostAttributes({\n  dir: getDocumentWritingMode(),\n  role: ariaRoleOnHost ? 'listbox' : null,\n})\nexport class SbbAutocompleteElement extends SbbNegativeMixin(\n  SbbHydrationMixin(SbbOpenCloseBaseElement),\n) {\n  public static override styles: CSSResultGroup = style;\n\n  /**\n   * The element where the autocomplete will attach; accepts both an element's id or an HTMLElement.\n   * If not set, will search for the first 'sbb-form-field' ancestor.\n   */\n  @property() public origin?: string | HTMLElement;\n\n  /**\n   * The input element that will trigger the autocomplete opening; accepts both an element's id or an HTMLElement.\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  @property() public trigger?: string | HTMLInputElement;\n\n  /** Whether the icon space is preserved when no icon is set. */\n  @property({ attribute: 'preserve-icon-space', reflect: true, type: Boolean })\n  public preserveIconSpace?: boolean;\n\n  private _overlay!: HTMLElement;\n  private _optionContainer!: HTMLElement;\n\n  /** Returns the element where autocomplete overlay is attached to. */\n  public get originElement(): HTMLElement {\n    if (!this._originElement) {\n      this._originElement = this._findOriginElement();\n    }\n    return this._originElement;\n  }\n  private _originElement?: HTMLElement;\n\n  /** Returns the trigger element. */\n  public get triggerElement(): HTMLInputElement | undefined {\n    return this._triggerElement;\n  }\n  private _triggerElement: HTMLInputElement | undefined;\n\n  private _triggerEventsController!: AbortController;\n  private _openPanelEventsController!: AbortController;\n  private _overlayId = `sbb-autocomplete-${++nextId}`;\n  private _activeItemIndex = -1;\n  private _didLoad = false;\n  private _isPointerDownEventOnMenu: boolean = false;\n  private _abort = new SbbConnectedAbortController(this);\n\n  /** The autocomplete should inherit 'readonly' state from the trigger. */\n  private get _readonly(): boolean {\n    return this.triggerElement?.hasAttribute('readonly') ?? false;\n  }\n\n  private get _options(): SbbOptionElement[] {\n    return Array.from(this.querySelectorAll?.('sbb-option') ?? []);\n  }\n\n  /** Opens the autocomplete. */\n  public open(): void {\n    if (this.state !== 'closed' || !this._overlay || this._options.length === 0 || this._readonly) {\n      return;\n    }\n    if (!this.willOpen.emit()) {\n      return;\n    }\n\n    this.state = 'opening';\n    this._setOverlayPosition();\n  }\n\n  /** Closes the autocomplete. */\n  public close(): void {\n    if (this.state !== 'opened') {\n      return;\n    }\n    if (!this.willClose.emit()) {\n      return;\n    }\n\n    this.state = 'closing';\n    this._openPanelEventsController.abort();\n  }\n\n  /** Removes trigger click listener on trigger change. */\n  private _resetOriginClickListener(\n    newValue?: string | HTMLElement,\n    oldValue?: string | HTMLElement,\n  ): void {\n    if (newValue !== oldValue) {\n      this._componentSetup();\n    }\n  }\n\n  /** Removes trigger click listener on trigger change. */\n  private _resetTriggerClickListener(\n    newValue?: string | HTMLElement,\n    oldValue?: string | HTMLElement,\n  ): void {\n    if (newValue !== oldValue) {\n      this._componentSetup();\n    }\n  }\n\n  /** When an option is selected, update the input value and close the autocomplete. */\n  private _onOptionSelected(event: CustomEvent): void {\n    const target = event.target as SbbOptionElement;\n    if (!target.selected) {\n      return;\n    }\n\n    // Deselect the previous options\n    this._options\n      .filter((option) => option.id !== target.id && option.selected)\n      .forEach((option) => (option.selected = false));\n\n    if (this.triggerElement) {\n      // Set the option value\n      this.triggerElement.value = target.value as string;\n\n      // Manually trigger the change events\n      this.triggerElement.dispatchEvent(new Event('change', { bubbles: true }));\n      this.triggerElement.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n    }\n\n    this.close();\n  }\n\n  private _onOptionClick(event: MouseEvent): void {\n    if (\n      (event.target as Element).localName !== 'sbb-option' ||\n      (event.target as SbbOptionElement).disabled\n    ) {\n      return;\n    }\n    this.close();\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    if (ariaRoleOnHost) {\n      this.id ||= this._overlayId;\n    }\n\n    const signal = this._abort.signal;\n    const formField = this.closest?.('sbb-form-field') ?? this.closest?.('[data-form-field]');\n\n    if (formField) {\n      this.negative = formField.hasAttribute('negative');\n    }\n\n    if (this._didLoad) {\n      this._componentSetup();\n    }\n    this._syncNegative();\n\n    this.addEventListener(\n      'optionSelectionChange',\n      (e: CustomEvent<void>) => this._onOptionSelected(e),\n      { signal },\n    );\n    this.addEventListener('click', (e: MouseEvent) => this._onOptionClick(e), { signal });\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('origin')) {\n      this._resetOriginClickListener(this.origin, changedProperties.get('origin'));\n    }\n    if (changedProperties.has('trigger')) {\n      this._resetTriggerClickListener(this.trigger, changedProperties.get('trigger'));\n    }\n    if (changedProperties.has('negative')) {\n      this._syncNegative();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._componentSetup();\n    this._didLoad = true;\n  }\n\n  private _syncNegative(): void {\n    this.querySelectorAll?.('sbb-divider').forEach((divider) => (divider.negative = this.negative));\n\n    this.querySelectorAll?.<SbbOptionElement | SbbOptGroupElement>(\n      'sbb-option, sbb-optgroup',\n    ).forEach((element) => element.toggleAttribute('data-negative', this.negative));\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._triggerEventsController?.abort();\n    this._openPanelEventsController?.abort();\n  }\n\n  private _componentSetup(): void {\n    if (isServer) {\n      return;\n    }\n    this._triggerEventsController?.abort();\n    this._openPanelEventsController?.abort();\n\n    this._originElement = undefined;\n    this.toggleAttribute(\n      'data-option-panel-origin-borderless',\n      !!this.closest?.('sbb-form-field')?.hasAttribute('borderless'),\n    );\n\n    this._bindTo(this._getTriggerElement());\n  }\n\n  /**\n   * Retrieve the element where the autocomplete will be attached.\n   * @returns 'origin' or the first 'sbb-form-field' ancestor.\n   */\n  private _findOriginElement(): HTMLElement {\n    let result: HTMLElement | undefined | null;\n\n    if (!this.origin) {\n      result = this.closest?.('sbb-form-field')?.shadowRoot?.querySelector?.('#overlay-anchor');\n    } else {\n      result = findReferencedElement(this.origin);\n    }\n\n    if (!result) {\n      throw new Error(\n        'Cannot find the origin element. Please specify a valid element or read the \"origin\" prop documentation',\n      );\n    }\n\n    return result;\n  }\n\n  /**\n   * Retrieve the element that will trigger the autocomplete opening.\n   * @returns 'trigger' or the first 'input' inside the origin element.\n   */\n  private _getTriggerElement(): HTMLInputElement {\n    if (!this.trigger) {\n      return this.closest?.('sbb-form-field')?.querySelector('input') as HTMLInputElement;\n    }\n\n    const result = findReferencedElement<HTMLInputElement>(this.trigger);\n\n    if (!result) {\n      throw new Error(\n        'Cannot find the trigger element. Please specify a valid element or read the \"trigger\" prop documentation',\n      );\n    }\n\n    return result;\n  }\n\n  private _bindTo(triggerElem: HTMLInputElement): void {\n    if (!triggerElem) {\n      return;\n    }\n\n    // Reset attributes to the old trigger and add them to the new one\n    this._removeTriggerAttributes(this.triggerElement);\n    this._setTriggerAttributes(triggerElem);\n\n    this._triggerElement = triggerElem;\n\n    this._setupTriggerEvents();\n  }\n\n  private _setupTriggerEvents(): void {\n    this._triggerEventsController = new AbortController();\n\n    // Open the overlay on focus, click, input and `ArrowDown` event\n    this.triggerElement?.addEventListener('focus', () => this.open(), {\n      signal: this._triggerEventsController.signal,\n    });\n    this.triggerElement?.addEventListener('click', () => this.open(), {\n      signal: this._triggerEventsController.signal,\n    });\n    this.triggerElement?.addEventListener(\n      'input',\n      (event) => {\n        this.open();\n        this._highlightOptions((event.target as HTMLInputElement).value);\n      },\n      { signal: this._triggerEventsController.signal },\n    );\n    this.triggerElement?.addEventListener(\n      'keydown',\n      (event: KeyboardEvent) => this._closedPanelKeyboardInteraction(event),\n      { signal: this._triggerEventsController.signal },\n    );\n  }\n\n  // Set overlay position, width and max height\n  private _setOverlayPosition(): void {\n    setOverlayPosition(\n      this._overlay,\n      this.originElement,\n      this._optionContainer,\n      this.shadowRoot!.querySelector('.sbb-autocomplete__container')!,\n      this,\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._onOpenAnimationEnd();\n    } else if (event.animationName === 'close' && this.state === 'closing') {\n      this._onCloseAnimationEnd();\n    }\n  }\n\n  private _onOpenAnimationEnd(): void {\n    this.state = 'opened';\n    this._attachOpenPanelEvents();\n    this.triggerElement?.setAttribute('aria-expanded', 'true');\n    this.didOpen.emit();\n  }\n\n  private _onCloseAnimationEnd(): void {\n    this.state = 'closed';\n    this.triggerElement?.setAttribute('aria-expanded', 'false');\n    this._resetActiveElement();\n    this._optionContainer.scrollTop = 0;\n    this.didClose.emit();\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    });\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    // Keyboard interactions\n    this.triggerElement?.addEventListener(\n      'keydown',\n      (event: KeyboardEvent) => this._openedPanelKeyboardInteraction(event),\n      {\n        signal: this._openPanelEventsController.signal,\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 !== 'closed') {\n      return;\n    }\n\n    switch (event.key) {\n      case 'Enter':\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this.open();\n        break;\n    }\n  }\n\n  private _openedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (this.state !== 'opened') {\n      return;\n    }\n\n    switch (event.key) {\n      case 'Escape':\n      case 'Tab':\n        this.close();\n        break;\n\n      case 'Enter':\n        this._selectByKeyboard();\n        break;\n\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this._setNextActiveOption(event);\n        break;\n    }\n  }\n\n  private _selectByKeyboard(): void {\n    const activeOption = this._options[this._activeItemIndex];\n\n    if (activeOption) {\n      activeOption.setSelectedViaUserInteraction(true);\n    }\n  }\n\n  private _setNextActiveOption(event: KeyboardEvent): void {\n    const filteredOptions = this._options.filter(\n      (opt) => !opt.disabled && !opt.hasAttribute('data-group-disabled'),\n    );\n\n    // Get and activate the next active option\n    const next = getNextElementIndex(event, this._activeItemIndex, filteredOptions.length);\n    const nextActiveOption = filteredOptions[next];\n    nextActiveOption.active = true;\n    this.triggerElement?.setAttribute('aria-activedescendant', nextActiveOption.id);\n    nextActiveOption.scrollIntoView({ block: 'nearest' });\n\n    // Reset the previous active option\n    const lastActiveOption = filteredOptions[this._activeItemIndex];\n    if (lastActiveOption) {\n      lastActiveOption.active = false;\n    }\n\n    this._activeItemIndex = next;\n  }\n\n  private _resetActiveElement(): void {\n    const activeElement = this._options[this._activeItemIndex];\n\n    if (activeElement) {\n      activeElement.active = false;\n    }\n    this._activeItemIndex = -1;\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n  }\n\n  /** Highlight the searched text on the options. */\n  private _highlightOptions(searchTerm?: string): void {\n    if (!searchTerm) {\n      return;\n    }\n    this._options.forEach((option) => option.highlight(searchTerm));\n  }\n\n  private _setTriggerAttributes(element: HTMLInputElement): void {\n    setAriaComboBoxAttributes(element, this.id || this._overlayId, false);\n  }\n\n  private _removeTriggerAttributes(element?: HTMLInputElement): void {\n    removeAriaComboBoxAttributes(element);\n  }\n\n  private _handleSlotchange(): void {\n    this._highlightOptions(this.triggerElement?.value);\n  }\n\n  protected override render(): TemplateResult {\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 ? 'listbox' : nothing}\n              id=${!ariaRoleOnHost ? this._overlayId : nothing}\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 HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-autocomplete': SbbAutocompleteElement;\n  }\n}\n"],"names":[],"mappings":"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"}