@sbb-esta/lyne-elements-experimental-dev 4.7.0-dev.1773333596 → 4.7.0-dev.1773388997

package/development/autocomplete-grid/autocomplete-grid/autocomplete-grid.component.js

@@ -1,128 +1,120 @@
+import { ɵstateController } from "@sbb-esta/lyne-elements/core/mixins.js";
 import { SbbAutocompleteBaseElement } from "@sbb-esta/lyne-elements/autocomplete.js";
 import { getNextElementIndex } from "@sbb-esta/lyne-elements/core/a11y.js";
 import { isSafari } from "@sbb-esta/lyne-elements/core/dom.js";
-import { ɵstateController as _stateController } from "@sbb-esta/lyne-elements/core/mixins.js";
 import { setAriaComboBoxAttributes } from "@sbb-esta/lyne-elements/core/overlay.js";
 import { SbbAutocompleteGridOptionElement } from "../autocomplete-grid-option/autocomplete-grid-option.component.js";
-let nextId = 0;
-const ariaRoleOnHost = isSafari;
-const _SbbAutocompleteGridElement = class _SbbAutocompleteGridElement extends SbbAutocompleteBaseElement {
-  constructor() {
-    super(...arguments);
-    this.overlayId = `sbb-autocomplete-grid-${++nextId}`;
-    this.panelRole = "grid";
-    this._activeColumnIndex = 0;
-  }
-  get options() {
-    return Array.from(this.querySelectorAll?.("sbb-autocomplete-grid-option") ?? []);
-  }
-  syncNegative() {
-    this.querySelectorAll?.("sbb-divider, sbb-autocomplete-grid-button, sbb-option-hint").forEach((e) => e.negative = this.negative);
-    this.querySelectorAll?.("sbb-autocomplete-grid-row, sbb-autocomplete-grid-option, sbb-autocomplete-grid-optgroup").forEach((element) => _stateController(element).toggle("negative", this.negative));
-  }
-  openedPanelKeyboardInteraction(event) {
-    if (!this.isOpen) {
-      return;
-    }
-    switch (event.key) {
-      case "Enter":
-        this.selectByKeyboard(event);
-        break;
-      case "ArrowDown":
-      case "ArrowUp":
-        this.setNextActiveOption(event);
-        break;
-      case "ArrowRight":
-      case "ArrowLeft":
-        this._setNextHorizontalActiveElement(event);
-        break;
-    }
-  }
-  /**
-   * Select an element on 'Enter' keypress.
-   *
-   * Due to keyboard navigation code, the `_activeColumnIndex` is zero when an option is 'focused'
-   * and greater than zero when a button is 'focused', so asking for `querySelectorAll(...)[this._activeColumnIndex]`
-   * would always return a `SbbAutocompleteGridButtonElement`.
-   */
-  selectByKeyboard(event) {
-    if (this.activeOption) {
-      event.preventDefault();
-      if (this._activeColumnIndex !== 0) {
-        this.activeOption.closest("sbb-autocomplete-grid-row")?.querySelectorAll("sbb-autocomplete-grid-button")[
-          // We ignore the option in the selector. Therefore, we have to shift the activeColumnIndex by one.
-          this._activeColumnIndex - 1
-        ]?.click();
-      } else {
-        this.activeOption["selectViaUserInteraction"](true);
-      }
-    }
-  }
-  setNextActiveOption(event) {
-    const enabledOptions = this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
-    this.activeOption?.setActive(false);
-    this.triggerElement?.removeAttribute("aria-activedescendant");
-    Array.from(this.querySelectorAll?.("sbb-autocomplete-grid-row :is(:state(focus-visible),[state--focus-visible])") ?? []).forEach((row) => _stateController(row).delete("focus-visible"));
-    this._activeColumnIndex = 0;
-    if (!enabledOptions.length) {
-      this.activeOption = null;
-      return;
-    }
-    const activeItemIndex = this.activeOption ? enabledOptions.indexOf(this.activeOption) : -1;
-    const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);
-    this.activeOption = enabledOptions[next];
-    this.activeOption.setActive(true);
-    this.triggerElement?.setAttribute("aria-activedescendant", this.activeOption.id);
-    this.activeOption.scrollIntoView({ block: "nearest" });
-    if (event) {
-      event.preventDefault();
-    }
-    if (this.autoSelectActiveOption && event) {
-      this.setPendingSelection(this.activeOption);
-    }
-  }
-  _setNextHorizontalActiveElement(event) {
-    if (!this.activeOption) {
-      return;
-    }
-    const elementsInRow = Array.from(this.activeOption?.closest("sbb-autocomplete-grid-row")?.querySelectorAll("sbb-autocomplete-grid-option, sbb-autocomplete-grid-button") ?? [])?.filter((el) => !el.matches(":is(:state(disabled),[state--disabled])"));
-    if (!elementsInRow.length) {
-      return;
-    }
-    const next = getNextElementIndex(event, this._activeColumnIndex, elementsInRow.length);
-    const nextElement = elementsInRow[next];
-    if (nextElement instanceof SbbAutocompleteGridOptionElement) {
-      nextElement.setActive(true);
-    } else {
-      _stateController(nextElement).add("focus-visible");
-    }
-    const lastActiveElement = elementsInRow[this._activeColumnIndex];
-    if (lastActiveElement instanceof SbbAutocompleteGridOptionElement) {
-      lastActiveElement.setActive(false);
-    } else {
-      _stateController(lastActiveElement).delete("focus-visible");
-    }
-    this.triggerElement?.setAttribute("aria-activedescendant", nextElement.id);
-    nextElement.scrollIntoView({ block: "nearest" });
-    this._activeColumnIndex = next;
-  }
-  resetActiveElement() {
-    if (this._activeColumnIndex !== 0) {
-      this.activeOption?.closest("sbb-autocomplete-grid-row")?.querySelectorAll("sbb-autocomplete-grid-button").forEach((e) => _stateController(e).delete("focus-visible"));
-    }
-    this.activeOption?.setActive(false);
-    this.activeOption = null;
-    this._activeColumnIndex = 0;
-    this.triggerElement?.removeAttribute("aria-activedescendant");
-  }
-  setTriggerAttributes(element) {
-    setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false, "grid");
-  }
+//#region src/elements-experimental/autocomplete-grid/autocomplete-grid/autocomplete-grid.component.ts
+var nextId = 0;
+/**
+* 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;
+/**
+* Combined with a native input, it displays a panel with a list of available options with connected buttons.
+*
+* @slot - Use the unnamed slot to add `sbb-autocomplete-grid-row` or `sbb-autocomplete-grid-optgroup` elements to the `sbb-autocomplete-grid`.
+* @cssprop [--sbb-autocomplete-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+* the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+* component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+* @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.
+* If the calculated remaining space is smaller, the value gets ignored.
+*/
+var SbbAutocompleteGridElement = class extends SbbAutocompleteBaseElement {
+	constructor() {
+		super(...arguments);
+		this.overlayId = `sbb-autocomplete-grid-${++nextId}`;
+		this.panelRole = "grid";
+		this._activeColumnIndex = 0;
+	}
+	static {
+		this.elementName = "sbb-autocomplete-grid";
+	}
+	static {
+		this.role = ariaRoleOnHost ? "grid" : null;
+	}
+	get options() {
+		return Array.from(this.querySelectorAll?.("sbb-autocomplete-grid-option") ?? []);
+	}
+	syncNegative() {
+		this.querySelectorAll?.("sbb-divider, sbb-autocomplete-grid-button, sbb-option-hint").forEach((e) => e.negative = this.negative);
+		this.querySelectorAll?.("sbb-autocomplete-grid-row, sbb-autocomplete-grid-option, sbb-autocomplete-grid-optgroup").forEach((element) => ɵstateController(element).toggle("negative", this.negative));
+	}
+	openedPanelKeyboardInteraction(event) {
+		if (!this.isOpen) return;
+		switch (event.key) {
+			case "Enter":
+				this.selectByKeyboard(event);
+				break;
+			case "ArrowDown":
+			case "ArrowUp":
+				this.setNextActiveOption(event);
+				break;
+			case "ArrowRight":
+			case "ArrowLeft":
+				this._setNextHorizontalActiveElement(event);
+				break;
+		}
+	}
+	/**
+	* Select an element on 'Enter' keypress.
+	*
+	* Due to keyboard navigation code, the `_activeColumnIndex` is zero when an option is 'focused'
+	* and greater than zero when a button is 'focused', so asking for `querySelectorAll(...)[this._activeColumnIndex]`
+	* would always return a `SbbAutocompleteGridButtonElement`.
+	*/
+	selectByKeyboard(event) {
+		if (this.activeOption) {
+			event.preventDefault();
+			if (this._activeColumnIndex !== 0) this.activeOption.closest("sbb-autocomplete-grid-row")?.querySelectorAll("sbb-autocomplete-grid-button")[this._activeColumnIndex - 1]?.click();
+			else this.activeOption["selectViaUserInteraction"](true);
+		}
+	}
+	setNextActiveOption(event) {
+		const enabledOptions = this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
+		this.activeOption?.setActive(false);
+		this.triggerElement?.removeAttribute("aria-activedescendant");
+		Array.from(this.querySelectorAll?.("sbb-autocomplete-grid-row :is(:state(focus-visible),[state--focus-visible])") ?? []).forEach((row) => ɵstateController(row).delete("focus-visible"));
+		this._activeColumnIndex = 0;
+		if (!enabledOptions.length) {
+			this.activeOption = null;
+			return;
+		}
+		this.activeOption = enabledOptions[getNextElementIndex(event, this.activeOption ? enabledOptions.indexOf(this.activeOption) : -1, enabledOptions.length)];
+		this.activeOption.setActive(true);
+		this.triggerElement?.setAttribute("aria-activedescendant", this.activeOption.id);
+		this.activeOption.scrollIntoView({ block: "nearest" });
+		if (event) event.preventDefault();
+		if (this.autoSelectActiveOption && event) this.setPendingSelection(this.activeOption);
+	}
+	_setNextHorizontalActiveElement(event) {
+		if (!this.activeOption) return;
+		const elementsInRow = Array.from(this.activeOption?.closest("sbb-autocomplete-grid-row")?.querySelectorAll("sbb-autocomplete-grid-option, sbb-autocomplete-grid-button") ?? [])?.filter((el) => !el.matches(":is(:state(disabled),[state--disabled])"));
+		if (!elementsInRow.length) return;
+		const next = getNextElementIndex(event, this._activeColumnIndex, elementsInRow.length);
+		const nextElement = elementsInRow[next];
+		if (nextElement instanceof SbbAutocompleteGridOptionElement) nextElement.setActive(true);
+		else ɵstateController(nextElement).add("focus-visible");
+		const lastActiveElement = elementsInRow[this._activeColumnIndex];
+		if (lastActiveElement instanceof SbbAutocompleteGridOptionElement) lastActiveElement.setActive(false);
+		else ɵstateController(lastActiveElement).delete("focus-visible");
+		this.triggerElement?.setAttribute("aria-activedescendant", nextElement.id);
+		nextElement.scrollIntoView({ block: "nearest" });
+		this._activeColumnIndex = next;
+	}
+	resetActiveElement() {
+		if (this._activeColumnIndex !== 0) this.activeOption?.closest("sbb-autocomplete-grid-row")?.querySelectorAll("sbb-autocomplete-grid-button").forEach((e) => ɵstateController(e).delete("focus-visible"));
+		this.activeOption?.setActive(false);
+		this.activeOption = null;
+		this._activeColumnIndex = 0;
+		this.triggerElement?.removeAttribute("aria-activedescendant");
+	}
+	setTriggerAttributes(element) {
+		setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false, "grid");
+	}
 };
-_SbbAutocompleteGridElement.elementName = "sbb-autocomplete-grid";
-_SbbAutocompleteGridElement.role = ariaRoleOnHost ? "grid" : null;
-let SbbAutocompleteGridElement = _SbbAutocompleteGridElement;
-export {
-  SbbAutocompleteGridElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"autocomplete-grid.component.js","sources":["../../../../../src/elements-experimental/autocomplete-grid/autocomplete-grid/autocomplete-grid.component.ts"],"sourcesContent":["import { SbbAutocompleteBaseElement } from '@sbb-esta/lyne-elements/autocomplete.js';\nimport { getNextElementIndex } from '@sbb-esta/lyne-elements/core/a11y.js';\nimport { isSafari } from '@sbb-esta/lyne-elements/core/dom.js';\nimport { ɵstateController } from '@sbb-esta/lyne-elements/core/mixins.js';\nimport { setAriaComboBoxAttributes } from '@sbb-esta/lyne-elements/core/overlay.js';\nimport type { SbbDividerElement } from '@sbb-esta/lyne-elements/divider.js';\nimport type { SbbOptGroupElement, SbbOptionHintElement } from '@sbb-esta/lyne-elements/option.js';\n\nimport type { SbbAutocompleteGridButtonElement } from '../autocomplete-grid-button/autocomplete-grid-button.component.ts';\nimport { SbbAutocompleteGridOptionElement } from '../autocomplete-grid-option/autocomplete-grid-option.component.ts';\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 with connected buttons.\n *\n * @slot - Use the unnamed slot to add `sbb-autocomplete-grid-row` or `sbb-autocomplete-grid-optgroup` elements to the `sbb-autocomplete-grid`.\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 * @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.\n * If the calculated remaining space is smaller, the value gets ignored.\n */\nexport class SbbAutocompleteGridElement<T = string> extends SbbAutocompleteBaseElement<T> {\n  public static override readonly elementName: string = 'sbb-autocomplete-grid';\n  public static override readonly role = ariaRoleOnHost ? 'grid' : null;\n  protected overlayId = `sbb-autocomplete-grid-${++nextId}`;\n  protected panelRole = 'grid';\n  private _activeColumnIndex = 0;\n\n  protected get options(): SbbAutocompleteGridOptionElement<T>[] {\n    return Array.from(\n      this.querySelectorAll?.<SbbAutocompleteGridOptionElement<T>>(\n        'sbb-autocomplete-grid-option',\n      ) ?? [],\n    );\n  }\n\n  protected syncNegative(): void {\n    this.querySelectorAll?.<\n      SbbDividerElement | SbbAutocompleteGridButtonElement | SbbOptionHintElement\n    >('sbb-divider, sbb-autocomplete-grid-button, sbb-option-hint').forEach(\n      (e) => (e.negative = this.negative),\n    );\n\n    this.querySelectorAll?.<SbbAutocompleteGridOptionElement<T> | SbbOptGroupElement>(\n      'sbb-autocomplete-grid-row, sbb-autocomplete-grid-option, sbb-autocomplete-grid-optgroup',\n    ).forEach((element) => ɵstateController(element).toggle('negative', this.negative));\n  }\n\n  protected openedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (!this.isOpen) {\n      return;\n    }\n    switch (event.key) {\n      case 'Enter':\n        this.selectByKeyboard(event);\n        break;\n\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this.setNextActiveOption(event);\n        break;\n\n      case 'ArrowRight':\n      case 'ArrowLeft':\n        this._setNextHorizontalActiveElement(event);\n        break;\n    }\n  }\n\n  /**\n   * Select an element on 'Enter' keypress.\n   *\n   * Due to keyboard navigation code, the `_activeColumnIndex` is zero when an option is 'focused'\n   * and greater than zero when a button is 'focused', so asking for `querySelectorAll(...)[this._activeColumnIndex]`\n   * would always return a `SbbAutocompleteGridButtonElement`.\n   */\n  protected selectByKeyboard(event: KeyboardEvent): void {\n    if (this.activeOption) {\n      // We are currently selecting an option and therefore the Enter press shouldn't trigger a form submit\n      event.preventDefault();\n\n      if (this._activeColumnIndex !== 0) {\n        this.activeOption\n          .closest('sbb-autocomplete-grid-row')\n          ?.querySelectorAll('sbb-autocomplete-grid-button')\n          [\n            // We ignore the option in the selector. Therefore, we have to shift the activeColumnIndex by one.\n            this._activeColumnIndex - 1\n          ]?.click();\n      } else {\n        this.activeOption['selectViaUserInteraction'](true);\n      }\n    }\n  }\n\n  protected setNextActiveOption(event?: KeyboardEvent): void {\n    const enabledOptions = this.options.filter((opt) => !opt.matches(':state(disabled)'));\n\n    // Reset potentially active option\n    this.activeOption?.setActive(false);\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n    Array.from(\n      this.querySelectorAll?.('sbb-autocomplete-grid-row :state(focus-visible)') ?? [],\n    ).forEach((row) => ɵstateController(row).delete('focus-visible'));\n    this._activeColumnIndex = 0;\n\n    if (!enabledOptions.length) {\n      this.activeOption = null;\n      return;\n    }\n\n    const activeItemIndex = this.activeOption\n      ? enabledOptions.indexOf(this.activeOption as SbbAutocompleteGridOptionElement<T>)\n      : -1;\n\n    // Get and activate the next active option\n    const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);\n    this.activeOption = enabledOptions[next];\n    this.activeOption.setActive(true);\n    this.triggerElement?.setAttribute('aria-activedescendant', this.activeOption.id);\n    this.activeOption.scrollIntoView({ block: 'nearest' });\n\n    // Moving the active option should not move the input cursor (caret)\n    if (event) {\n      event.preventDefault();\n    }\n\n    // If 'autoSelectActiveOption' and is triggered from a keyboard event\n    if (this.autoSelectActiveOption && event) {\n      this.setPendingSelection(this.activeOption);\n    }\n  }\n\n  private _setNextHorizontalActiveElement(event: KeyboardEvent): void {\n    if (!this.activeOption) {\n      return;\n    }\n\n    const elementsInRow = Array.from(\n      this.activeOption\n        ?.closest('sbb-autocomplete-grid-row')\n        ?.querySelectorAll<\n          SbbAutocompleteGridOptionElement<T> | SbbAutocompleteGridButtonElement\n        >('sbb-autocomplete-grid-option, sbb-autocomplete-grid-button') ?? [],\n    )?.filter((el) => !el.matches(':state(disabled)'));\n\n    if (!elementsInRow.length) {\n      return;\n    }\n\n    const next: number = getNextElementIndex(event, this._activeColumnIndex, elementsInRow.length);\n    const nextElement: SbbAutocompleteGridOptionElement<T> | SbbAutocompleteGridButtonElement =\n      elementsInRow[next];\n    if (nextElement instanceof SbbAutocompleteGridOptionElement) {\n      nextElement.setActive(true);\n    } else {\n      ɵstateController(nextElement).add('focus-visible');\n    }\n\n    const lastActiveElement = elementsInRow[this._activeColumnIndex];\n    if (lastActiveElement instanceof SbbAutocompleteGridOptionElement) {\n      lastActiveElement.setActive(false);\n    } else {\n      ɵstateController(lastActiveElement).delete('focus-visible');\n    }\n    this.triggerElement?.setAttribute('aria-activedescendant', nextElement.id);\n    nextElement.scrollIntoView({ block: 'nearest' });\n    this._activeColumnIndex = next;\n  }\n\n  protected resetActiveElement(): void {\n    if (this._activeColumnIndex !== 0) {\n      this.activeOption\n        ?.closest('sbb-autocomplete-grid-row')\n        ?.querySelectorAll('sbb-autocomplete-grid-button')\n        .forEach((e) => ɵstateController(e).delete('focus-visible'));\n    }\n    this.activeOption?.setActive(false);\n    this.activeOption = null;\n    this._activeColumnIndex = 0;\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n  }\n\n  protected setTriggerAttributes(element: HTMLInputElement): void {\n    setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false, 'grid');\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-autocomplete-grid': SbbAutocompleteGridElement;\n  }\n}\n"],"names":["ɵstateController"],"mappings":"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"}
+//#endregion
+export { SbbAutocompleteGridElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"autocomplete-grid.component.js","names":[],"sources":["../../../../../src/elements-experimental/autocomplete-grid/autocomplete-grid/autocomplete-grid.component.ts"],"sourcesContent":["import { SbbAutocompleteBaseElement } from '@sbb-esta/lyne-elements/autocomplete.js';\nimport { getNextElementIndex } from '@sbb-esta/lyne-elements/core/a11y.js';\nimport { isSafari } from '@sbb-esta/lyne-elements/core/dom.js';\nimport { ɵstateController } from '@sbb-esta/lyne-elements/core/mixins.js';\nimport { setAriaComboBoxAttributes } from '@sbb-esta/lyne-elements/core/overlay.js';\nimport type { SbbDividerElement } from '@sbb-esta/lyne-elements/divider.js';\nimport type { SbbOptGroupElement, SbbOptionHintElement } from '@sbb-esta/lyne-elements/option.js';\n\nimport type { SbbAutocompleteGridButtonElement } from '../autocomplete-grid-button/autocomplete-grid-button.component.ts';\nimport { SbbAutocompleteGridOptionElement } from '../autocomplete-grid-option/autocomplete-grid-option.component.ts';\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 with connected buttons.\n *\n * @slot - Use the unnamed slot to add `sbb-autocomplete-grid-row` or `sbb-autocomplete-grid-optgroup` elements to the `sbb-autocomplete-grid`.\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 * @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.\n * If the calculated remaining space is smaller, the value gets ignored.\n */\nexport class SbbAutocompleteGridElement<T = string> extends SbbAutocompleteBaseElement<T> {\n  public static override readonly elementName: string = 'sbb-autocomplete-grid';\n  public static override readonly role = ariaRoleOnHost ? 'grid' : null;\n  protected overlayId = `sbb-autocomplete-grid-${++nextId}`;\n  protected panelRole = 'grid';\n  private _activeColumnIndex = 0;\n\n  protected get options(): SbbAutocompleteGridOptionElement<T>[] {\n    return Array.from(\n      this.querySelectorAll?.<SbbAutocompleteGridOptionElement<T>>(\n        'sbb-autocomplete-grid-option',\n      ) ?? [],\n    );\n  }\n\n  protected syncNegative(): void {\n    this.querySelectorAll?.<\n      SbbDividerElement | SbbAutocompleteGridButtonElement | SbbOptionHintElement\n    >('sbb-divider, sbb-autocomplete-grid-button, sbb-option-hint').forEach(\n      (e) => (e.negative = this.negative),\n    );\n\n    this.querySelectorAll?.<SbbAutocompleteGridOptionElement<T> | SbbOptGroupElement>(\n      'sbb-autocomplete-grid-row, sbb-autocomplete-grid-option, sbb-autocomplete-grid-optgroup',\n    ).forEach((element) => ɵstateController(element).toggle('negative', this.negative));\n  }\n\n  protected openedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (!this.isOpen) {\n      return;\n    }\n    switch (event.key) {\n      case 'Enter':\n        this.selectByKeyboard(event);\n        break;\n\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this.setNextActiveOption(event);\n        break;\n\n      case 'ArrowRight':\n      case 'ArrowLeft':\n        this._setNextHorizontalActiveElement(event);\n        break;\n    }\n  }\n\n  /**\n   * Select an element on 'Enter' keypress.\n   *\n   * Due to keyboard navigation code, the `_activeColumnIndex` is zero when an option is 'focused'\n   * and greater than zero when a button is 'focused', so asking for `querySelectorAll(...)[this._activeColumnIndex]`\n   * would always return a `SbbAutocompleteGridButtonElement`.\n   */\n  protected selectByKeyboard(event: KeyboardEvent): void {\n    if (this.activeOption) {\n      // We are currently selecting an option and therefore the Enter press shouldn't trigger a form submit\n      event.preventDefault();\n\n      if (this._activeColumnIndex !== 0) {\n        this.activeOption\n          .closest('sbb-autocomplete-grid-row')\n          ?.querySelectorAll('sbb-autocomplete-grid-button')\n          [\n            // We ignore the option in the selector. Therefore, we have to shift the activeColumnIndex by one.\n            this._activeColumnIndex - 1\n          ]?.click();\n      } else {\n        this.activeOption['selectViaUserInteraction'](true);\n      }\n    }\n  }\n\n  protected setNextActiveOption(event?: KeyboardEvent): void {\n    const enabledOptions = this.options.filter((opt) => !opt.matches(':state(disabled)'));\n\n    // Reset potentially active option\n    this.activeOption?.setActive(false);\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n    Array.from(\n      this.querySelectorAll?.('sbb-autocomplete-grid-row :state(focus-visible)') ?? [],\n    ).forEach((row) => ɵstateController(row).delete('focus-visible'));\n    this._activeColumnIndex = 0;\n\n    if (!enabledOptions.length) {\n      this.activeOption = null;\n      return;\n    }\n\n    const activeItemIndex = this.activeOption\n      ? enabledOptions.indexOf(this.activeOption as SbbAutocompleteGridOptionElement<T>)\n      : -1;\n\n    // Get and activate the next active option\n    const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);\n    this.activeOption = enabledOptions[next];\n    this.activeOption.setActive(true);\n    this.triggerElement?.setAttribute('aria-activedescendant', this.activeOption.id);\n    this.activeOption.scrollIntoView({ block: 'nearest' });\n\n    // Moving the active option should not move the input cursor (caret)\n    if (event) {\n      event.preventDefault();\n    }\n\n    // If 'autoSelectActiveOption' and is triggered from a keyboard event\n    if (this.autoSelectActiveOption && event) {\n      this.setPendingSelection(this.activeOption);\n    }\n  }\n\n  private _setNextHorizontalActiveElement(event: KeyboardEvent): void {\n    if (!this.activeOption) {\n      return;\n    }\n\n    const elementsInRow = Array.from(\n      this.activeOption\n        ?.closest('sbb-autocomplete-grid-row')\n        ?.querySelectorAll<\n          SbbAutocompleteGridOptionElement<T> | SbbAutocompleteGridButtonElement\n        >('sbb-autocomplete-grid-option, sbb-autocomplete-grid-button') ?? [],\n    )?.filter((el) => !el.matches(':state(disabled)'));\n\n    if (!elementsInRow.length) {\n      return;\n    }\n\n    const next: number = getNextElementIndex(event, this._activeColumnIndex, elementsInRow.length);\n    const nextElement: SbbAutocompleteGridOptionElement<T> | SbbAutocompleteGridButtonElement =\n      elementsInRow[next];\n    if (nextElement instanceof SbbAutocompleteGridOptionElement) {\n      nextElement.setActive(true);\n    } else {\n      ɵstateController(nextElement).add('focus-visible');\n    }\n\n    const lastActiveElement = elementsInRow[this._activeColumnIndex];\n    if (lastActiveElement instanceof SbbAutocompleteGridOptionElement) {\n      lastActiveElement.setActive(false);\n    } else {\n      ɵstateController(lastActiveElement).delete('focus-visible');\n    }\n    this.triggerElement?.setAttribute('aria-activedescendant', nextElement.id);\n    nextElement.scrollIntoView({ block: 'nearest' });\n    this._activeColumnIndex = next;\n  }\n\n  protected resetActiveElement(): void {\n    if (this._activeColumnIndex !== 0) {\n      this.activeOption\n        ?.closest('sbb-autocomplete-grid-row')\n        ?.querySelectorAll('sbb-autocomplete-grid-button')\n        .forEach((e) => ɵstateController(e).delete('focus-visible'));\n    }\n    this.activeOption?.setActive(false);\n    this.activeOption = null;\n    this._activeColumnIndex = 0;\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n  }\n\n  protected setTriggerAttributes(element: HTMLInputElement): void {\n    setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false, 'grid');\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-autocomplete-grid': SbbAutocompleteGridElement;\n  }\n}\n"],"mappings":"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"}

package/development/autocomplete-grid/autocomplete-grid-button/autocomplete-grid-button.component.js

@@ -8,74 +8,96 @@ import { SbbDisabledMixin, SbbNegativeMixin } from "@sbb-esta/lyne-elements/core
 import { boxSizingStyles } from "@sbb-esta/lyne-elements/core/styles.js";
 import { SbbIconNameMixin } from "@sbb-esta/lyne-elements/icon.js";
 import { isServer } from "lit";
-let autocompleteButtonNextId = 0;
-let SbbAutocompleteGridButtonElement = (() => {
-  var _a;
-  let _classDecorators = [hostAttributes({
-    tabindex: null
-  })];
-  let _classDescriptor;
-  let _classExtraInitializers = [];
-  let _classThis;
-  let _classSuper = SbbDisabledMixin(SbbNegativeMixin(SbbIconNameMixin(SbbActionBaseElement)));
-  _a = class extends _classSuper {
-    /** Gets the SbbAutocompleteGridOptionElement on the same row of the button. */
-    get option() {
-      return this.closest("sbb-autocomplete-grid-row")?.querySelector("sbb-autocomplete-grid-option") || null;
-    }
-    get optgroup() {
-      return this.closest("sbb-autocomplete-grid-optgroup");
-    }
-    constructor() {
-      super();
-      this._handleButtonClick = async (event) => {
-        if (await isEventPrevented(event) || !this.closest("form")) {
-          return;
-        }
-      };
-      this.internals.states.add("button");
-      if (!isServer) {
-        this.setupBaseEventHandlers();
-        this.addEventListener("click", this._handleButtonClick);
-        this.addController(new SbbPropertyWatcherController(this, () => this.closest("sbb-autocomplete-grid-optgroup"), {
-          disabled: () => this._updateInternals()
-        }));
-      }
-    }
-    isDisabledExternally() {
-      return this.optgroup?.disabled ?? false;
-    }
-    renderTemplate() {
-      return super.renderIconSlot();
-    }
-    connectedCallback() {
-      super.connectedCallback();
-      this.id ||= `sbb-autocomplete-grid-button-${++autocompleteButtonNextId}`;
-    }
-    willUpdate(changedProperties) {
-      super.willUpdate(changedProperties);
-      if (changedProperties.has("disabled")) {
-        this._updateInternals();
-      }
-    }
-    _updateInternals() {
-      if (this.disabled || this.optgroup?.disabled) {
-        this.internals.states.add("disabled");
-        this.internals.ariaDisabled = "true";
-      } else {
-        this.internals.states.delete("disabled");
-        this.internals.ariaDisabled = null;
-      }
-    }
-  }, _classThis = _a, (() => {
-    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-    _classThis = _classDescriptor.value;
-    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-  })(), _a.elementName = "sbb-autocomplete-grid-button", _a.role = "button", _a.styles = [boxSizingStyles, miniButtonStyle], __runInitializers(_classThis, _classExtraInitializers), _a;
-  return _classThis;
+//#region src/elements-experimental/autocomplete-grid/autocomplete-grid-button/autocomplete-grid-button.component.ts
+var autocompleteButtonNextId = 0;
+/**
+* It displays an icon-only button that can be used in `sbb-autocomplete-grid`.
+*
+* @slot icon - Slot used to display the icon, if one is set
+*/
+var SbbAutocompleteGridButtonElement = (() => {
+	let _classDecorators = [hostAttributes({ tabindex: null })];
+	let _classDescriptor;
+	let _classExtraInitializers = [];
+	let _classThis;
+	let _classSuper = SbbDisabledMixin(SbbNegativeMixin(SbbIconNameMixin(SbbActionBaseElement)));
+	var SbbAutocompleteGridButtonElement = class extends _classSuper {
+		static {
+			_classThis = this;
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, {
+				kind: "class",
+				name: _classThis.name,
+				metadata: _metadata
+			}, null, _classExtraInitializers);
+			SbbAutocompleteGridButtonElement = _classThis = _classDescriptor.value;
+			if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-autocomplete-grid-button";
+		}
+		static {
+			this.role = "button";
+		}
+		static {
+			this.styles = [boxSizingStyles, miniButtonStyle];
+		}
+		/** Gets the SbbAutocompleteGridOptionElement on the same row of the button. */
+		get option() {
+			return this.closest("sbb-autocomplete-grid-row")?.querySelector("sbb-autocomplete-grid-option") || null;
+		}
+		get optgroup() {
+			return this.closest("sbb-autocomplete-grid-optgroup");
+		}
+		constructor() {
+			super();
+			this._handleButtonClick = async (event) => {
+				if (await isEventPrevented(event) || !this.closest("form")) return;
+			};
+			this.internals.states.add("button");
+			if (!isServer) {
+				this.setupBaseEventHandlers();
+				this.addEventListener("click", this._handleButtonClick);
+				this.addController(new SbbPropertyWatcherController(this, () => this.closest("sbb-autocomplete-grid-optgroup"), { disabled: () => this._updateInternals() }));
+			}
+		}
+		isDisabledExternally() {
+			return this.optgroup?.disabled ?? false;
+		}
+		renderTemplate() {
+			return super.renderIconSlot();
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.id ||= `sbb-autocomplete-grid-button-${++autocompleteButtonNextId}`;
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("disabled")) this._updateInternals();
+		}
+		_updateInternals() {
+			if (this.disabled || this.optgroup?.disabled) {
+				this.internals.states.add("disabled");
+				this.internals.ariaDisabled = "true";
+			} else {
+				this.internals.states.delete("disabled");
+				this.internals.ariaDisabled = null;
+			}
+		}
+		static {
+			__runInitializers(_classThis, _classExtraInitializers);
+		}
+	};
+	return _classThis;
 })();
-export {
-  SbbAutocompleteGridButtonElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//#endregion
+export { SbbAutocompleteGridButtonElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/autocomplete-grid/autocomplete-grid-button.js

@@ -1,8 +1,10 @@
 import { SbbAutocompleteGridButtonElement } from "./autocomplete-grid-button/autocomplete-grid-button.component.js";
+//#region src/elements-experimental/autocomplete-grid/autocomplete-grid-button.ts
+/** @entrypoint */
 SbbAutocompleteGridButtonElement.define();
 console.warn(`The entrypoint '@sbb-esta/elements-experimental/autocomplete-grid/autocomplete-grid-button.js' has been deprecated.
 Use either '@sbb-esta/elements-experimental/autocomplete-grid.js' or '@sbb-esta/elements-experimental/autocomplete-grid.pure.js' instead.`);
-export {
-  SbbAutocompleteGridButtonElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLWdyaWQtYnV0dG9uLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMtZXhwZXJpbWVudGFsL2F1dG9jb21wbGV0ZS1ncmlkL2F1dG9jb21wbGV0ZS1ncmlkLWJ1dHRvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkF1dG9jb21wbGV0ZUdyaWRCdXR0b25FbGVtZW50IH0gZnJvbSAnLi9hdXRvY29tcGxldGUtZ3JpZC1idXR0b24vYXV0b2NvbXBsZXRlLWdyaWQtYnV0dG9uLmNvbXBvbmVudC50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vYXV0b2NvbXBsZXRlLWdyaWQtYnV0dG9uL2F1dG9jb21wbGV0ZS1ncmlkLWJ1dHRvbi5jb21wb25lbnQudHMnO1xuXG5TYmJBdXRvY29tcGxldGVHcmlkQnV0dG9uRWxlbWVudC5kZWZpbmUoKTtcblxuY29uc29sZS53YXJuKGBUaGUgZW50cnlwb2ludCAnQHNiYi1lc3RhL2VsZW1lbnRzLWV4cGVyaW1lbnRhbC9hdXRvY29tcGxldGUtZ3JpZC9hdXRvY29tcGxldGUtZ3JpZC1idXR0b24uanMnIGhhcyBiZWVuIGRlcHJlY2F0ZWQuXG5Vc2UgZWl0aGVyICdAc2JiLWVzdGEvZWxlbWVudHMtZXhwZXJpbWVudGFsL2F1dG9jb21wbGV0ZS1ncmlkLmpzJyBvciAnQHNiYi1lc3RhL2VsZW1lbnRzLWV4cGVyaW1lbnRhbC9hdXRvY29tcGxldGUtZ3JpZC5wdXJlLmpzJyBpbnN0ZWFkLmApO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFLQSxpQ0FBaUMsT0FBQTtBQUVqQyxRQUFRLEtBQUs7QUFBQSwwSUFDNkg7In0=
+//#endregion
+export { SbbAutocompleteGridButtonElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLWdyaWQtYnV0dG9uLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy1leHBlcmltZW50YWwvYXV0b2NvbXBsZXRlLWdyaWQvYXV0b2NvbXBsZXRlLWdyaWQtYnV0dG9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiQXV0b2NvbXBsZXRlR3JpZEJ1dHRvbkVsZW1lbnQgfSBmcm9tICcuL2F1dG9jb21wbGV0ZS1ncmlkLWJ1dHRvbi9hdXRvY29tcGxldGUtZ3JpZC1idXR0b24uY29tcG9uZW50LnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9hdXRvY29tcGxldGUtZ3JpZC1idXR0b24vYXV0b2NvbXBsZXRlLWdyaWQtYnV0dG9uLmNvbXBvbmVudC50cyc7XG5cblNiYkF1dG9jb21wbGV0ZUdyaWRCdXR0b25FbGVtZW50LmRlZmluZSgpO1xuXG5jb25zb2xlLndhcm4oYFRoZSBlbnRyeXBvaW50ICdAc2JiLWVzdGEvZWxlbWVudHMtZXhwZXJpbWVudGFsL2F1dG9jb21wbGV0ZS1ncmlkL2F1dG9jb21wbGV0ZS1ncmlkLWJ1dHRvbi5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy1leHBlcmltZW50YWwvYXV0b2NvbXBsZXRlLWdyaWQuanMnIG9yICdAc2JiLWVzdGEvZWxlbWVudHMtZXhwZXJpbWVudGFsL2F1dG9jb21wbGV0ZS1ncmlkLnB1cmUuanMnIGluc3RlYWQuYCk7XG4iXSwibWFwcGluZ3MiOiI7OztBQUtBLGlDQUFpQyxRQUFRO0FBRXpDLFFBQVEsS0FBSzsySUFDOEgifQ==

package/development/autocomplete-grid/autocomplete-grid-cell/autocomplete-grid-cell.component.js

@@ -1,29 +1,2 @@
-import { SbbElement } from "@sbb-esta/lyne-elements/core/base-elements.js";
-import { boxSizingStyles } from "@sbb-esta/lyne-elements/core/styles.js";
-import { css, html } from "lit";
-const style = css`:host {
-  --sbb-autocomplete-grid-cell-gap: var(--sbb-spacing-fixed-6x);
-  display: block;
-}
-
-.sbb-autocomplete-grid-cell {
-  display: flex;
-  column-gap: var(--sbb-autocomplete-grid-cell-gap);
-}`;
-const _SbbAutocompleteGridCellElement = class _SbbAutocompleteGridCellElement extends SbbElement {
-  render() {
-    return html`
-      <span class="sbb-autocomplete-grid-cell">
-        <slot></slot>
-      </span>
-    `;
-  }
-};
-_SbbAutocompleteGridCellElement.elementName = "sbb-autocomplete-grid-cell";
-_SbbAutocompleteGridCellElement.role = "gridcell";
-_SbbAutocompleteGridCellElement.styles = [boxSizingStyles, style];
-let SbbAutocompleteGridCellElement = _SbbAutocompleteGridCellElement;
-export {
-  SbbAutocompleteGridCellElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+import { t as SbbAutocompleteGridCellElement } from "../../autocomplete-grid-cell.component-BBvM4o2H.js";
+export { SbbAutocompleteGridCellElement };

package/development/autocomplete-grid/autocomplete-grid-cell.js

@@ -1,8 +1,10 @@
-import { SbbAutocompleteGridCellElement } from "./autocomplete-grid-cell/autocomplete-grid-cell.component.js";
+import { t as SbbAutocompleteGridCellElement } from "../autocomplete-grid-cell.component-BBvM4o2H.js";
+//#region src/elements-experimental/autocomplete-grid/autocomplete-grid-cell.ts
+/** @entrypoint */
 SbbAutocompleteGridCellElement.define();
 console.warn(`The entrypoint '@sbb-esta/elements-experimental/autocomplete-grid/autocomplete-grid-cell.js' has been deprecated.
 Use either '@sbb-esta/elements-experimental/autocomplete-grid.js' or '@sbb-esta/elements-experimental/autocomplete-grid.pure.js' instead.`);
-export {
-  SbbAutocompleteGridCellElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLWdyaWQtY2VsbC5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzLWV4cGVyaW1lbnRhbC9hdXRvY29tcGxldGUtZ3JpZC9hdXRvY29tcGxldGUtZ3JpZC1jZWxsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiQXV0b2NvbXBsZXRlR3JpZENlbGxFbGVtZW50IH0gZnJvbSAnLi9hdXRvY29tcGxldGUtZ3JpZC1jZWxsL2F1dG9jb21wbGV0ZS1ncmlkLWNlbGwuY29tcG9uZW50LnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9hdXRvY29tcGxldGUtZ3JpZC1jZWxsL2F1dG9jb21wbGV0ZS1ncmlkLWNlbGwuY29tcG9uZW50LnRzJztcblxuU2JiQXV0b2NvbXBsZXRlR3JpZENlbGxFbGVtZW50LmRlZmluZSgpO1xuXG5jb25zb2xlLndhcm4oYFRoZSBlbnRyeXBvaW50ICdAc2JiLWVzdGEvZWxlbWVudHMtZXhwZXJpbWVudGFsL2F1dG9jb21wbGV0ZS1ncmlkL2F1dG9jb21wbGV0ZS1ncmlkLWNlbGwuanMnIGhhcyBiZWVuIGRlcHJlY2F0ZWQuXG5Vc2UgZWl0aGVyICdAc2JiLWVzdGEvZWxlbWVudHMtZXhwZXJpbWVudGFsL2F1dG9jb21wbGV0ZS1ncmlkLmpzJyBvciAnQHNiYi1lc3RhL2VsZW1lbnRzLWV4cGVyaW1lbnRhbC9hdXRvY29tcGxldGUtZ3JpZC5wdXJlLmpzJyBpbnN0ZWFkLmApO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFLQSwrQkFBK0IsT0FBQTtBQUUvQixRQUFRLEtBQUs7QUFBQSwwSUFDNkg7In0=
+//#endregion
+export { SbbAutocompleteGridCellElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLWdyaWQtY2VsbC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMtZXhwZXJpbWVudGFsL2F1dG9jb21wbGV0ZS1ncmlkL2F1dG9jb21wbGV0ZS1ncmlkLWNlbGwudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQgeyBTYmJBdXRvY29tcGxldGVHcmlkQ2VsbEVsZW1lbnQgfSBmcm9tICcuL2F1dG9jb21wbGV0ZS1ncmlkLWNlbGwvYXV0b2NvbXBsZXRlLWdyaWQtY2VsbC5jb21wb25lbnQudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2F1dG9jb21wbGV0ZS1ncmlkLWNlbGwvYXV0b2NvbXBsZXRlLWdyaWQtY2VsbC5jb21wb25lbnQudHMnO1xuXG5TYmJBdXRvY29tcGxldGVHcmlkQ2VsbEVsZW1lbnQuZGVmaW5lKCk7XG5cbmNvbnNvbGUud2FybihgVGhlIGVudHJ5cG9pbnQgJ0BzYmItZXN0YS9lbGVtZW50cy1leHBlcmltZW50YWwvYXV0b2NvbXBsZXRlLWdyaWQvYXV0b2NvbXBsZXRlLWdyaWQtY2VsbC5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy1leHBlcmltZW50YWwvYXV0b2NvbXBsZXRlLWdyaWQuanMnIG9yICdAc2JiLWVzdGEvZWxlbWVudHMtZXhwZXJpbWVudGFsL2F1dG9jb21wbGV0ZS1ncmlkLnB1cmUuanMnIGluc3RlYWQuYCk7XG4iXSwibWFwcGluZ3MiOiI7OztBQUtBLCtCQUErQixRQUFRO0FBRXZDLFFBQVEsS0FBSzsySUFDOEgifQ==