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

package/development/seat-reservation.component-Cq_aJKR0.js

@@ -0,0 +1,818 @@
+import { SeatReservationBaseElement } from "./seat-reservation/seat-reservation/seat-reservation-base-element.js";
+import { SbbLanguageController } from "@sbb-esta/lyne-elements/core/controllers.js";
+import { boxSizingStyles } from "@sbb-esta/lyne-elements/core/styles.js";
+import { css, html, nothing } from "lit";
+import "@sbb-esta/lyne-elements/screen-reader-only.js";
+import { styleMap } from "lit/directives/style-map.js";
+import { SbbSeatReservationAreaElement } from "./seat-reservation/seat-reservation-area/seat-reservation-area.component.js";
+import { classMap } from "lit/directives/class-map.js";
+import { getI18nSeatReservation } from "./seat-reservation/common/translations.js";
+import { SbbSeatReservationGraphicElement } from "./seat-reservation/seat-reservation-graphic/seat-reservation-graphic.component.js";
+import { repeat } from "lit/directives/repeat.js";
+import { SbbSeatReservationNavigationCoachElement } from "./seat-reservation/seat-reservation-navigation-coach/seat-reservation-navigation-coach.component.js";
+import { SbbSeatReservationPlaceControlElement } from "./seat-reservation/seat-reservation-place-control/seat-reservation-place-control.component.js";
+import { SbbSeatReservationScopedElement } from "./seat-reservation/seat-reservation-scoped/seat-reservation-scoped.component.js";
+import "@sbb-esta/lyne-elements/button.js";
+import "@sbb-esta/lyne-elements/popover.js";
+//#region src/elements-experimental/seat-reservation/seat-reservation/seat-reservation.scss?lit&inline
+var seat_reservation_default = css`:host {
+  --sbb-seat-reservation-grid-size: 16px;
+  --sbb-seat-reservation-height: 0;
+  --sbb-seat-reservation-decks: 1;
+  display: block;
+  height: inherit;
+}
+:host ::part(coach-floor) {
+  fill: var(--sbb-background-color-2);
+}
+@media (forced-colors: active) {
+  :host ::part(coach-floor) {
+    fill: transparent;
+  }
+}
+
+:host(:dir(rtl)) :not(.sbb-sr-place-ctrl--type-bicycle,
+.sbb-sr-place-ctrl--orientation-90,
+.sbb-sr-place-ctrl--orientation-270,
+.sbb-sr-place-ctrl--state-selected) ::part(coach-floor) {
+  rotate: calc(180 * 1deg);
+}
+
+[popover]:where(sbb-popover) {
+  margin: 0;
+  padding: 0;
+  border: none;
+  width: auto;
+  height: auto;
+  background-color: transparent;
+  color: inherit;
+  pointer-events: none;
+}
+[popover]:where(sbb-popover) .sbb-sr-popover {
+  margin-block: calc(4 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+:host([align-vertical]) .sbb-sr__component {
+  flex-direction: row-reverse;
+  justify-content: flex-end;
+  gap: calc(22 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  height: inherit;
+}
+@media (min-width: calc(37.5rem)) {
+  :host([align-vertical]) .sbb-sr__component {
+    gap: calc(54 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  }
+}
+:host([align-vertical]) .sbb-sr__component nav.sbb-sr-navigation,
+:host([align-vertical]) .sbb-sr__component ul.sbb-sr-navigation__list-coaches {
+  flex-direction: column;
+}
+:host([align-vertical]) .sbb-sr__component nav.sbb-sr-navigation {
+  padding: calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) 0;
+}
+:host([align-vertical]) .sbb-sr__component nav.sbb-sr-navigation .sbb-sr__navigation-control-button {
+  left: calc(1 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  top: 0;
+  rotate: 90deg;
+}
+@media (min-width: calc(64rem)) {
+  :host([align-vertical]) .sbb-sr__component nav.sbb-sr-navigation .sbb-sr__navigation-control-button {
+    left: calc(-1 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  }
+}
+:host([align-vertical]) .sbb-sr__component nav.sbb-sr-navigation ul.sbb-sr-navigation__list-coaches {
+  max-width: initial;
+  padding: calc(5 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  overflow: hidden scroll;
+}
+:host([align-vertical]) .sbb-sr__wrapper-coach-decks {
+  flex-direction: column;
+}
+:host([align-vertical]) .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper-deck-labels {
+  flex-direction: column-reverse;
+  width: calc((var(--sbb-seat-reservation-height) + 24) * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  height: initial;
+}
+:host([align-vertical]) .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper-deck-labels b {
+  inline-size: calc(50% - 16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  block-size: calc(20 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  margin-bottom: calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  rotate: initial;
+  writing-mode: initial;
+}
+:host([align-vertical]) .sbb-sr__wrapper-scrollarea {
+  width: calc((var(--sbb-seat-reservation-height) + 24) * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  height: 100%;
+  overflow: hidden scroll;
+}
+:host([align-vertical]) .sbb-sr__wrapper-scrollarea .sbb-sr__parent {
+  rotate: 90deg;
+}
+:host([align-vertical]) .sbb-sr-travel-direction-wrapper {
+  width: calc(var(--sbb-seat-reservation-height) * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  margin-block-start: calc(4 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr-navigation {
+  gap: calc(3 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr-navigation .sbb-sr__navigation-control-button {
+  position: relative;
+  top: calc(2 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+@media (min-width: calc(64rem)) {
+  .sbb-sr-navigation .sbb-sr__navigation-control-button {
+    top: 0;
+  }
+}
+
+.sbb-sr__component {
+  display: flex;
+  flex-direction: column;
+  gap: calc(64 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem) - 16px);
+}
+
+.sbb-sr-travel-direction-wrapper {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  column-gap: calc(4 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  margin-block: calc(8 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) calc(4 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  font-size: var(--sbb-text-font-size-s);
+}
+.sbb-sr-travel-direction-wrapper .sbb-sr__travel-direction--arrow {
+  display: flex;
+  align-items: center;
+}
+
+.sbb-sr-navigation-wrapper {
+  display: flex;
+}
+
+.sbb-sr-navigation {
+  display: flex;
+  justify-content: center;
+  width: 100%;
+  padding-inline: 16px;
+}
+
+.sbb-sr-navigation__list-coaches {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: color-mix(in srgb, var(--sbb-color-black) 30%, transparent);
+  --sbb-scrollbar-color: light-dark(
+    color-mix(in srgb, var(--sbb-color-black) 30%, transparent),
+    color-mix(in srgb, var(--sbb-color-white) 30%, transparent)
+  );
+  --sbb-scrollbar-color-hover: color-mix(in srgb, var(--sbb-color-black) 60%, transparent);
+  --sbb-scrollbar-color-hover: light-dark(
+    color-mix(in srgb, var(--sbb-color-black) 60%, transparent),
+    color-mix(in srgb, var(--sbb-color-white) 60%, transparent)
+  );
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+}
+.sbb-sr-navigation__list-coaches::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr-navigation__list-coaches::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr-navigation__list-coaches::-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-sr-navigation__list-coaches::-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-sr-navigation__list-coaches::-webkit-scrollbar-button, .sbb-sr-navigation__list-coaches::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-sr-navigation__list-coaches {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+.sbb-sr-navigation__list-coaches {
+  display: flex;
+  flex-wrap: nowrap;
+  gap: calc(4 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  padding: calc(6 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) calc(5 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) 0;
+  max-width: 856px;
+  --sbb-scrollbar-color: transparent;
+  overflow: scroll hidden;
+  position: relative;
+}
+
+.sbb-sr__wrapper-coach-decks {
+  display: flex;
+  overflow: hidden;
+  height: inherit;
+}
+.sbb-sr__wrapper-coach-decks .sbb-sr__wrapper-deck-labels {
+  display: flex;
+  justify-content: space-between;
+  height: calc(var(--sbb-seat-reservation-height) * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  writing-mode: vertical-lr;
+}
+.sbb-sr__wrapper-coach-decks .sbb-sr__wrapper-deck-labels b {
+  height: calc(50% - 16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  width: calc(20 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  margin-block-end: 16px;
+  rotate: 180deg;
+  text-align: center;
+  line-height: calc(20 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr__wrapper-scrollarea {
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: color-mix(in srgb, var(--sbb-color-black) 30%, transparent);
+  --sbb-scrollbar-color: light-dark(
+    color-mix(in srgb, var(--sbb-color-black) 30%, transparent),
+    color-mix(in srgb, var(--sbb-color-white) 30%, transparent)
+  );
+  --sbb-scrollbar-color-hover: color-mix(in srgb, var(--sbb-color-black) 60%, transparent);
+  --sbb-scrollbar-color-hover: light-dark(
+    color-mix(in srgb, var(--sbb-color-black) 60%, transparent),
+    color-mix(in srgb, var(--sbb-color-white) 60%, transparent)
+  );
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+}
+.sbb-sr__wrapper-scrollarea::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr__wrapper-scrollarea::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr__wrapper-scrollarea::-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-sr__wrapper-scrollarea::-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-sr__wrapper-scrollarea::-webkit-scrollbar-button, .sbb-sr__wrapper-scrollarea::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-sr__wrapper-scrollarea {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+.sbb-sr__wrapper-scrollarea {
+  overflow: scroll hidden;
+  padding-block: calc(8 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+.sbb-sr__wrapper-scrollarea .sbb-sr__parent {
+  display: flex;
+  flex-direction: column;
+  position: relative;
+}
+
+.sbb-sr__list-decks {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  display: flex;
+  flex-direction: column;
+}
+
+.sbb-sr__list-decks--gap {
+  gap: calc(48 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr__list-item-deck {
+  position: relative;
+}
+
+.sbb-sr__list-coaches {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  display: flex;
+  gap: calc(4 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr__list-decks:has(.sbb-sr-coach-has-overhanging-elements) .sbb-sr__list-coaches {
+  gap: calc(8 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr__item-coach {
+  position: relative;
+}
+
+.sbb-sr-coach-wrapper__table {
+  outline: 0;
+}`;
+//#endregion
+//#region src/elements-experimental/seat-reservation/seat-reservation/seat-reservation.component.ts
+SbbSeatReservationAreaElement.define();
+SbbSeatReservationGraphicElement.define();
+SbbSeatReservationPlaceControlElement.define();
+SbbSeatReservationNavigationCoachElement.define();
+SbbSeatReservationScopedElement.define();
+/**
+* Main component for the seat reservation.
+*
+*/
+var SbbSeatReservationElement = class extends SeatReservationBaseElement {
+	constructor() {
+		super(...arguments);
+		this._language = new SbbLanguageController(this);
+		this._notFixedRotatableAreaIcons = ["ENTRY_EXIT"];
+	}
+	static {
+		this.elementName = "sbb-seat-reservation";
+	}
+	static {
+		this.styles = [boxSizingStyles, seat_reservation_default];
+	}
+	willUpdate(changedProperties) {
+		super.willUpdate(changedProperties);
+		if (changedProperties.has("hasNavigation")) if (this.hasNavigation) this.shadowRoot?.querySelectorAll("table").forEach((table) => table.removeAttribute("tabindex"));
+		else this.shadowRoot?.querySelectorAll("table").forEach((table) => table.setAttribute("tabindex", "0"));
+	}
+	firstUpdated(changedProperties) {
+		super.firstUpdated(changedProperties);
+		this.updateComplete.then(() => {
+			this.initNavigationSelectionByScrollEvent();
+		});
+	}
+	render() {
+		this._initVehicleSeatReservationConstruction();
+		return this._coachesHtmlTemplate || null;
+	}
+	_initVehicleSeatReservationConstruction() {
+		this._coachesHtmlTemplate = html`
+      ${this._renderTravelDirection()}
+      <div class="sbb-sr__component">
+        ${this._renderNavigation()}
+        <div
+          class="sbb-sr__wrapper-coach-decks"
+          @keydown=${(evt) => this.keyboardSeatmapEventHandling(evt)}
+        >
+          <div class="sbb-sr__wrapper-deck-labels">${this._renderDeckLabels()}</div>
+          <div
+            @scroll=${() => this.coachAreaScrollend()}
+            id="sbb-sr__wrapper-scrollarea"
+            class="sbb-sr__wrapper-scrollarea"
+            tabindex="-1"
+          >
+            <div id="sbb-sr__parent-area" class="sbb-sr__parent">
+              <ul
+                class="${classMap({
+			"sbb-sr__list-decks": true,
+			"sbb-sr__list-decks--gap": this.hasMultipleDecks
+		})}"
+              >
+                ${this.seatReservations?.map((seatReservation, coachDeckIndex) => {
+			return html`<li class="sbb-sr__list-item-deck">
+                      <ul class="sbb-sr__list-coaches" role="presentation">
+                        ${this._renderCoaches(seatReservation, coachDeckIndex)}
+                      </ul>
+                    </li>`;
+		})}
+              </ul>
+            </div>
+          </div>
+        </div>
+      </div>
+    `;
+	}
+	_renderDeckLabels() {
+		if (!this.hasMultipleDecks) return null;
+		return this.seatReservations.map((seatReservation) => {
+			return html`<b aria-hidden="true">${getI18nSeatReservation(seatReservation.deckCoachLevel, this._language.current)}</b>`;
+		});
+	}
+	_renderNavigationControlButton(btnDirection) {
+		if (!this.hasNavigation || !this.seatReservations) return null;
+		const btnNavigationDirectionId = btnDirection == "DIRECTION_RIGHT" ? "sbb-sr-navigation__wrapper-button-direction--right" : "sbb-sr-navigation__wrapper-button-direction--left";
+		const btnIcon = btnDirection == "DIRECTION_RIGHT" ? "chevron-small-right-small" : "chevron-small-left-small";
+		const btnAriaDescription = btnDirection == "DIRECTION_RIGHT" ? getI18nSeatReservation("SEAT_RESERVATION_END", this._language.current) : getI18nSeatReservation("SEAT_RESERVATION_BEGIN", this._language.current);
+		let btnDisabled = true;
+		if (btnDirection == "DIRECTION_LEFT" && this.selectedCoachIndex > 0) btnDisabled = false;
+		else if (btnDirection == "DIRECTION_RIGHT" && this.selectedCoachIndex < this.coachItemDetailsElements.length - 1) btnDisabled = false;
+		return html`<div class="sbb-sr-navigation__wrapper-button-direction">
+      <sbb-secondary-button
+        @click="${() => this.navigateByDirectionBtn(btnDirection)}"
+        @focus="${() => this.onFocusNavDirectionButton()}"
+        id="${btnNavigationDirectionId}"
+        class="sbb-sr__navigation-control-button"
+        size="m"
+        icon-name="${btnIcon}"
+        type="button"
+        aria-label="${btnAriaDescription}"
+        role="button"
+        .disabledInteractive="${btnDisabled || nothing}"
+        .disabled="${btnDisabled || nothing}"
+      ></sbb-secondary-button>
+    </div>`;
+	}
+	_renderTravelDirection() {
+		if (!this.travelDirection || this.travelDirection === "NONE") return null;
+		const labelText = getI18nSeatReservation("SEAT_RESERVATION_TRAVEL_DIRECTION", this._language.current);
+		return html`<div class="sbb-sr-travel-direction-wrapper">
+      <div class="sbb-sr__travel-direction--arrow">
+        <sbb-icon slot="icon" name="${`arrow-${this.alignVertical ? this.travelDirection === "RIGHT" ? "down" : "up" : this.travelDirection === "RIGHT" ? "right" : "left"}-small`}"></sbb-icon>
+      </div>
+      <div class="sbb-sr__travel-direction--label">${labelText}</div>
+    </div>`;
+	}
+	_renderNavigation() {
+		if (!this.hasNavigation || !this.seatReservations) return null;
+		return html`<div class="sbb-sr-navigation-wrapper">
+      <nav id="sbb-sr-navigation" class="sbb-sr-navigation">
+        ${this._renderNavigationControlButton("DIRECTION_LEFT")}
+        <ul
+          id="sbb-sr__navigation-list-coaches"
+          class="sbb-sr-navigation__list-coaches"
+          aria-label="${getI18nSeatReservation("SEAT_RESERVATION_NAVIGATION", this._language.current)}"
+        >
+          ${this.coachItemDetailsElements.map((coachItemDetails, index) => {
+			return html`<li>
+                <sbb-seat-reservation-navigation-coach
+                  @selectcoach=${(event) => this._onSelectNavCoach(event)}
+                  @focuscoach=${() => this._onFocusNavCoach()}
+                  @keyup=${(evt) => this.onKeyNavigationNavCoachButton(evt, index)}
+                  index="${index}"
+                  .selected=${this.selectedCoachIndex === index}
+                  .focused=${this.focusedCoachIndex === index}
+                  .hovered=${this.hoveredCoachIndex === index}
+                  .nativeFocusActive=${this.hasSeatReservationNativeFocus}
+                  .coachItemDetails="${coachItemDetails}"
+                  ?vertical="${this.alignVertical}"
+                  ?showTitleInfo="${this.showTitleInfo}"
+                >
+                </sbb-seat-reservation-navigation-coach>
+              </li>`;
+		})}
+        </ul>
+        ${this._renderNavigationControlButton("DIRECTION_RIGHT")}
+      </nav>
+    </div>`;
+	}
+	/**
+	*
+	* @returns
+	* @param seatReservation
+	* @param coachDeckIndex
+	*/
+	_renderCoaches(seatReservation, coachDeckIndex) {
+		const coaches = JSON.parse(JSON.stringify(seatReservation?.coachItems));
+		if (!coaches) return null;
+		return coaches.map((coachItem, coachIndex) => {
+			return html`
+        <li class="sbb-sr__item-coach">
+          ${this._renderCoachElement(coachItem, coachIndex, coachDeckIndex, seatReservation.deckCoachIndex)}
+        </li>
+      `;
+		});
+	}
+	_renderCoachElement(coachItem, coachIndex, coachDeckIndex, placeCoachDeckIndex) {
+		const calculatedCoachDimension = this.getCalculatedDimension(coachItem.dimension);
+		const descriptionTableCoachWithServices = this._getDescriptionTableCoach(coachItem);
+		return html`<sbb-seat-reservation-scoped
+      style=${styleMap({
+			"--sbb-seat-reservation-scoped-width": calculatedCoachDimension.w,
+			"--sbb-seat-reservation-scoped-height": calculatedCoachDimension.h
+		})}
+    >
+      ${this._getRenderedCoachBorders(coachItem, coachIndex)}
+      ${this._getRenderedGraphicalElements(coachItem.graphicElements || [], coachItem.dimension, coachIndex, coachDeckIndex)}
+      ${this._getRenderedServiceElements(coachIndex, coachDeckIndex, coachItem.serviceElements)}
+
+      <table
+        @focus=${() => this.onFocusTableCoachAndPreselectPlace(coachIndex)}
+        id="sbb-sr-coach-${coachIndex}"
+        class="sbb-sr-coach-wrapper__table"
+        aria-describedby="sbb-sr-coach-caption-${coachIndex}"
+        tabindex="-1"
+      >
+        <caption id="sbb-sr-coach-caption-${coachIndex}" tabindex="-1">
+          <sbb-screen-reader-only>${descriptionTableCoachWithServices}</sbb-screen-reader-only>
+        </caption>
+        ${this._getRenderedRowPlaces(coachItem, coachIndex, coachDeckIndex, placeCoachDeckIndex)}
+      </table>
+    </sbb-seat-reservation-scoped>`;
+	}
+	/**
+	* @returns Returns the border graphic (COACH_BORDER_MIDDLE) of a coach with calculated border gap and coach width,
+	* depending on whether the coach is with a driver area or without.
+	*/
+	_getRenderedCoachBorders(coachItem, coachIndex) {
+		if (!coachItem.graphicElements) return null;
+		const COACH_PASSAGE_WIDTH = 1;
+		const driverArea = this.coachItemDetailsElements[coachIndex]?.driverAreaElements?.driverArea;
+		const driverAreaNoVerticalWall = this.coachItemDetailsElements[coachIndex]?.driverAreaElements?.driverAreaNoVerticalWall;
+		let borderWidth = driverArea ? coachItem.dimension.w - driverArea.dimension.w - COACH_PASSAGE_WIDTH : coachItem.dimension.w - COACH_PASSAGE_WIDTH * 2;
+		borderWidth *= this.baseGridSize;
+		const borderHeight = (coachItem.dimension.h + this.coachBorderOffset * 2) * this.baseGridSize;
+		let borderOffsetX = driverArea && driverArea.position.x === 0 ? driverArea?.dimension.w * this.baseGridSize : this.baseGridSize;
+		if (driverAreaNoVerticalWall) {
+			borderWidth = this.getCalculatedDimension(coachItem.dimension).w - 2 * (driverAreaNoVerticalWall.dimension.w * this.baseGridSize);
+			borderOffsetX = driverAreaNoVerticalWall.dimension.w * this.baseGridSize;
+		}
+		const currentCoachOverlappingInfo = this.overHangingElementInformation.find((el) => el.coachId == coachItem.id);
+		if (currentCoachOverlappingInfo?.overhangingPlaces || currentCoachOverlappingInfo?.overhangingGraphicAreas) {
+			borderWidth += 2 * this.baseGridSize;
+			borderOffsetX = 0;
+		}
+		return html`
+      <sbb-seat-reservation-graphic
+        class="${classMap({ "sbb-sr-coach-has-overhanging-elements": currentCoachOverlappingInfo?.overhangingPlaces || currentCoachOverlappingInfo?.overhangingGraphicAreas || false })}"
+        style=${styleMap({
+			"--sbb-seat-reservation-graphic-width": borderWidth,
+			"--sbb-seat-reservation-graphic-height": borderHeight,
+			"--sbb-seat-reservation-graphic-top": this.coachBorderPadding * -1,
+			"--sbb-seat-reservation-graphic-left": borderOffsetX,
+			"--sbb-seat-reservation-graphic-position": "absolute"
+		})}
+        name="COACH_BORDER_MIDDLE"
+        ?stretch=${true}
+        role="presentation"
+      ></sbb-seat-reservation-graphic>
+    `;
+	}
+	_getRenderedRowPlaces(coach, coachIndex, coachDeckIndex, placeCoachDeckIndex) {
+		if (!coach.places) return null;
+		const tableRowPlaces = {};
+		for (const place of coach.places) if (!tableRowPlaces[place.position.y]) tableRowPlaces[place.position.y] = [place];
+		else tableRowPlaces[place.position.y].push(place);
+		return Object.values(tableRowPlaces).map((rowPlaces, index) => {
+			return html`
+          <tr id="row-${coachIndex}-${rowPlaces[0].position.y}" data-row-index=${index}>
+            ${this._getRenderedColumnPlaces(rowPlaces, coachIndex, coachDeckIndex, placeCoachDeckIndex)}
+          </tr>
+        `;
+		}).flatMap((rowTemplate) => rowTemplate);
+	}
+	_getRenderedColumnPlaces(places, coachIndex, deckIndex, placeCoachDeckIndex) {
+		places.sort((placeA, placeB) => Number(placeA.position.x) - Number(placeB.position.x));
+		const trackPlaceId = coachIndex + "-" + placeCoachDeckIndex;
+		return html`${repeat(places, (place) => trackPlaceId + "-" + place.number, (place, index) => {
+			const calculatedDimension = this.getCalculatedDimension(place.dimension);
+			const calculatedPosition = this.getCalculatedPosition(place.position);
+			const rotation = place.rotation || 0;
+			const textRotation = this.alignVertical ? -90 : 0;
+			const placeId = this.getPlaceElementId(deckIndex, coachIndex, place.number);
+			return html`
+          <td
+            id="cell-${deckIndex}-${coachIndex}-${place.position.y}-${index}"
+            class="graphical-element"
+          >
+            <sbb-seat-reservation-place-control
+              style=${styleMap({
+				"--sbb-seat-reservation-place-control-text-scale-value": Math.min(calculatedDimension.w, calculatedDimension.h),
+				"--sbb-seat-reservation-place-control-width": calculatedDimension.w,
+				"--sbb-seat-reservation-place-control-height": calculatedDimension.h,
+				"--sbb-seat-reservation-place-control-top": calculatedPosition.y,
+				"--sbb-seat-reservation-place-control-left": calculatedPosition.x,
+				"--sbb-seat-reservation-place-control-rotation": rotation,
+				"--sbb-seat-reservation-place-control-text-rotation": textRotation
+			})}
+              @selectplace=${(selectPlaceEvent) => this._onSelectPlace(selectPlaceEvent)}
+              exportparts="sbb-sr-place-part"
+              id=${placeId}
+              class="seat-reservation-place-control"
+              text=${place.number}
+              type=${place.type}
+              state=${place.state}
+              travel-direction=${this.travelDirection}
+              coach-index=${coachIndex}
+              deck-index=${placeCoachDeckIndex}
+              data-deck-index=${deckIndex}
+              .propertyIds=${place.propertyIds}
+              .preventClick=${this.preventPlaceClick}
+              ?showTitleInfo="${this.showTitleInfo}"
+            ></sbb-seat-reservation-place-control>
+          </td>
+        `;
+		})}`;
+	}
+	_getRenderedGraphicalElements(graphicalElements, coachDimension, coachIndex, coachDeckIndex) {
+		if (!graphicalElements) return null;
+		return graphicalElements?.map((graphicalElement) => {
+			const icon = graphicalElement.icon ?? "";
+			const elementRotation = graphicalElement.rotation || 0;
+			const isNotFixedRotationGraphicalElement = this._notFixedRotatableAreaIcons.indexOf(graphicalElement.icon) === -1;
+			const elementFixedRotation = this.alignVertical && isNotFixedRotationGraphicalElement ? elementRotation - 90 : elementRotation;
+			if (this.notAreaElements.findIndex((notAreaElement) => notAreaElement === icon) > -1) return this._getRenderElementWithoutArea(graphicalElement, elementRotation, coachDimension);
+			return this._getRenderElementWithArea(graphicalElement, elementFixedRotation, coachDimension, coachIndex, coachDeckIndex);
+		});
+	}
+	/**
+	* creates a rendered element with an area component
+	* @param graphicalElement
+	* @param rotation
+	* @param coachDimension
+	* @param coachIndex used to generate a unique id for the popover trigger
+	* @param coachDeckIndex used to generate a unique id
+	* @private
+	*/
+	_getRenderElementWithArea(graphicalElement, rotation, coachDimension, coachIndex, coachDeckIndex) {
+		const isNotTableGraphic = graphicalElement.icon?.indexOf("TABLE") === -1;
+		const areaProperty = graphicalElement.icon && isNotTableGraphic ? graphicalElement.icon : null;
+		const stretchHeight = this.isElementDirectlyOnBorder(graphicalElement, coachDimension) && areaProperty !== "ENTRY_EXIT";
+		const ariaLabelForArea = graphicalElement.icon ? getI18nSeatReservation(graphicalElement.icon, this._language.current) : nothing;
+		const calculatedDimension = this.getCalculatedDimension(graphicalElement.dimension, coachDimension, true, stretchHeight);
+		const calculatedPosition = this.getCalculatedPosition(graphicalElement.position, graphicalElement.dimension, coachDimension, true);
+		const triggerId = `popover-trigger-${coachDeckIndex}-${coachIndex}-${calculatedPosition.x}-${calculatedPosition.y}`;
+		let elementMounting = "free";
+		if (graphicalElement.position.y === this.coachBorderOffset * -1) elementMounting = "upper-border";
+		else if (graphicalElement.position.y + graphicalElement.dimension.h === coachDimension.h + this.coachBorderOffset) elementMounting = "lower-border";
+		if (elementMounting !== "free") {
+			calculatedPosition.y += elementMounting === "upper-border" ? 2 : 1;
+			calculatedDimension.h -= 3;
+		}
+		return html`
+      <sbb-seat-reservation-area
+        id="${triggerId}"
+        class="${classMap({ "sbb-seat-reservation-area--cursor-pointer": areaProperty !== null })}"
+        style=${styleMap({
+			"--sbb-seat-reservation-area-width": calculatedDimension.w,
+			"--sbb-seat-reservation-area-height": calculatedDimension.h,
+			"--sbb-seat-reservation-area-top": calculatedPosition.y,
+			"--sbb-seat-reservation-area-left": calculatedPosition.x
+		})}
+        mounting=${elementMounting}
+        background="dark"
+        aria-hidden="true"
+      >
+        ${areaProperty ? html`
+              <sbb-seat-reservation-graphic
+                style=${styleMap({
+			"--sbb-seat-reservation-graphic-max-width": calculatedDimension.w,
+			"--sbb-seat-reservation-graphic-height": this.baseGridSize,
+			"--sbb-seat-reservation-graphic-rotation": rotation
+		})}
+                name=${areaProperty}
+                role="img"
+                aria-hidden="true"
+                class="auto-width"
+              ></sbb-seat-reservation-graphic>
+            ` : nothing}
+      </sbb-seat-reservation-area>
+      ${areaProperty ? this._popover(triggerId, ariaLabelForArea) : nothing}
+    `;
+	}
+	_getRenderElementWithoutArea(graphicalElement, rotation, coachDimension) {
+		const calculatedDimension = this.getCalculatedDimension(graphicalElement.dimension, coachDimension);
+		const calculatedPosition = this.getCalculatedPosition(graphicalElement.position, graphicalElement.dimension, coachDimension);
+		const icon = graphicalElement.icon && graphicalElement.icon.endsWith("DRIVER_AREA") ? graphicalElement.icon?.concat("_", this.seatReservations[this.currSelectedDeckIndex].vehicleType) : graphicalElement.icon;
+		return html` <sbb-seat-reservation-graphic
+      style=${styleMap({
+			"--sbb-seat-reservation-graphic-width": calculatedDimension.w,
+			"--sbb-seat-reservation-graphic-height": calculatedDimension.h,
+			"--sbb-seat-reservation-graphic-top": calculatedPosition.y,
+			"--sbb-seat-reservation-graphic-left": calculatedPosition.x,
+			"--sbb-seat-reservation-graphic-position": "absolute",
+			"--sbb-seat-reservation-graphic-rotation": rotation
+		})}
+      name=${icon ?? nothing}
+      aria-hidden="true"
+      ?stretch=${true}
+    ></sbb-seat-reservation-graphic>`;
+	}
+	_getRenderedServiceElements(coachIndex, coachDeckIndex, serviceElements) {
+		if (!serviceElements) return null;
+		return serviceElements?.map((serviceElement) => {
+			const titleDescription = serviceElement.icon ? getI18nSeatReservation(serviceElement.icon, this._language.current) : null;
+			const calculatedDimension = this.getCalculatedDimension(serviceElement.dimension);
+			const calculatedPosition = this.getCalculatedPosition(serviceElement.position);
+			const elementRotation = serviceElement.rotation || 0;
+			const elementFixedRotation = this.alignVertical ? elementRotation - 90 : elementRotation;
+			const triggerId = `popover-trigger-${coachDeckIndex}-${coachIndex}-${calculatedPosition.x}-${calculatedPosition.y}`;
+			return html`
+        <sbb-seat-reservation-graphic
+          id="${triggerId}"
+          style=${styleMap({
+				"--sbb-seat-reservation-graphic-width": calculatedDimension.w,
+				"--sbb-seat-reservation-graphic-height": calculatedDimension.h,
+				"--sbb-seat-reservation-graphic-top": calculatedPosition.y,
+				"--sbb-seat-reservation-graphic-left": calculatedPosition.x,
+				"--sbb-seat-reservation-graphic-position": "absolute",
+				"--sbb-seat-reservation-graphic-rotation": elementFixedRotation
+			})}
+          class="sbb-seat-reservation-graphic--cursor-pointer"
+          name=${serviceElement.icon ?? nothing}
+          role="img"
+          aria-hidden="true"
+        ></sbb-seat-reservation-graphic>
+        ${this._popover(triggerId, titleDescription)}
+      `;
+		});
+	}
+	/**
+	* Manages the selected place event triggered from the place
+	* Each selection emits an array of all selected places
+	* @param selectPlaceEvent
+	*/
+	_onSelectPlace(selectPlaceEvent) {
+		const selectedPlace = selectPlaceEvent.detail;
+		this.preventCoachScrollByPlaceClick = true;
+		this.isCoachGridFocusable = false;
+		this.focusedCoachIndex = -1;
+		if (!this.hasSeatReservationNativeFocus) this.hasSeatReservationNativeFocus = true;
+		if (!this.preventPlaceClick) {
+			this.updateSelectedSeatReservationPlaces(selectedPlace);
+			this.updateCurrentSelectedPlaceInCoach(selectedPlace);
+		}
+	}
+	_onSelectNavCoach(event) {
+		const selectedNavCoachIndex = event.detail;
+		this.isKeyboardNavigation = false;
+		this.preventCoachScrollByPlaceClick = false;
+		this.hasSeatReservationNativeFocus = true;
+		if (selectedNavCoachIndex !== null && selectedNavCoachIndex !== this.currSelectedCoachIndex) {
+			this.unfocusPlaceElement();
+			this.scrollToSelectedNavCoach(selectedNavCoachIndex);
+		} else if (selectedNavCoachIndex === this.currSelectedCoachIndex) {
+			this.updateCurrentSelectedCoach();
+			this.preselectPlaceInCoach();
+		}
+		this._closePopover();
+	}
+	_onFocusNavCoach() {
+		if (!this.preventCoachScrollByPlaceClick) this.preselectPlaceInCoach();
+		else this.focusPlaceElement(this.currSelectedPlace);
+		this.isAutoScrolling = false;
+	}
+	/**
+	* Creates a popover for extra service information
+	* @param triggerId
+	* @param popoverContent
+	* @private
+	*/
+	_popover(triggerId, popoverContent) {
+		return html`
+      <sbb-popover trigger="${triggerId}" hover-trigger="">
+        <p class="sbb-text-s sbb-sr-popover">${popoverContent}</p>
+      </sbb-popover>
+    `;
+	}
+	/**
+	* trigger to close all opened popovers (normally only one is opened at a time)
+	* @private
+	*/
+	_closePopover() {
+		this.shadowRoot?.querySelectorAll("sbb-popover:is(:state(state-opened),[state--state-opened])").forEach((popover) => popover.close());
+	}
+	_getDescriptionTableCoach(coachItem) {
+		if (coachItem.type === "LOCOMOTIVE_COACH") return getI18nSeatReservation("COACH_LOCOMOTIVE", this._language.current);
+		if (!coachItem.places?.length) return getI18nSeatReservation("COACH_BLOCKED_TABLE_CAPTION", this._language.current, [coachItem.id]);
+		let tableCoachDescription;
+		const areaDescriptions = this._getTitleDescriptionListString(coachItem.graphicElements);
+		const serviceDescriptions = this._getTitleDescriptionListString(coachItem.serviceElements);
+		tableCoachDescription = getI18nSeatReservation("COACH_TABLE_CAPTION", this._language.current, [coachItem.id]);
+		if (!this.hasNavigation) {
+			const freePlaces = this.getAvailableFreePlacesNumFromCoach(coachItem.places);
+			const freePlacesTxt = getI18nSeatReservation("COACH_AVAILABLE_NUMBER_OF_PLACES", this._language.current, [freePlaces.seats, freePlaces.bicycles]);
+			tableCoachDescription = tableCoachDescription.concat(". ").concat(freePlacesTxt).concat(". ");
+		}
+		if (!!areaDescriptions || !!serviceDescriptions) {
+			tableCoachDescription += ". " + getI18nSeatReservation("COACH_AVAILABLE_SERVICES", this._language.current) + ": ";
+			tableCoachDescription += serviceDescriptions + ", " + areaDescriptions + ".";
+		}
+		return tableCoachDescription;
+	}
+	_getTitleDescriptionListString(descriptionsElements) {
+		const uniqueDescriptions = [];
+		return descriptionsElements?.map((descriptionElement) => {
+			const icon = descriptionElement.icon;
+			if (!icon) return null;
+			const descriptionAlreadyExist = uniqueDescriptions.indexOf(icon) > -1;
+			const translation = getI18nSeatReservation(descriptionElement.icon, this._language.current);
+			const isValidDescription = this._notFixedRotatableAreaIcons.indexOf(icon) === -1 && this.notAreaElements.indexOf(icon) === -1;
+			if (!descriptionAlreadyExist) uniqueDescriptions.push(descriptionElement.icon);
+			return !!translation && !descriptionAlreadyExist && isValidDescription ? translation : null;
+		}).filter((description) => !!description).join(", ");
+	}
+};
+//#endregion
+export { SbbSeatReservationElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"seat-reservation.component-Cq_aJKR0.js","names":[],"sources":["../../../src/elements-experimental/seat-reservation/seat-reservation/seat-reservation.scss?lit&inline","../../../src/elements-experimental/seat-reservation/seat-reservation/seat-reservation.component.ts"],"sourcesContent":["@use '@sbb-esta/lyne-elements/core/styles' as sbb;\n@use '../common/styles/seat-reservation-mixins' as sbb-sr-mixins;\n@use '../common/styles/seat-reservation-functions' as sbb-sr-functions;\n\n// Maximum responsive navigation width, consists of the maximum navigation extent minus 2x nav direction buttons 96px and 8px padding.\n$max-coach-navigation-width: calc(960px - 96px - 8px);\n$scrollbar-height: 16px;\n\n:host {\n  // Note: The use of px is intentional here, because many widths/heights, rotations, scales, etc. depends on this.\n  --sbb-seat-reservation-grid-size: 16px;\n  --sbb-seat-reservation-height: 0;\n  --sbb-seat-reservation-decks: 1;\n\n  display: block;\n  height: inherit;\n\n  ::part(coach-floor) {\n    fill: var(--sbb-background-color-2);\n\n    // In High Contrast Mode we set floor color to transparent\n    @include sbb.if-forced-colors {\n      fill: transparent;\n    }\n  }\n}\n\n// rotates the DOM-part \"coach-floor\" by 180 degrees if the host is in RTL mode.\n@include sbb-sr-mixins.rotate-dom-part(coach-floor);\n\n[popover]:where(sbb-popover) {\n  @include sbb.popover-reset;\n\n  .sbb-sr-popover {\n    margin-block: sbb-sr-functions.sr-px-to-rem(4);\n  }\n}\n\n// START - Vertical mode\n:host([align-vertical]) {\n  $coach-navigation-padding: 5;\n  $coach-scollbar-width: 24;\n  $coach-grid-width: calc(var(--sbb-seat-reservation-height) + $coach-scollbar-width);\n\n  .sbb-sr__component {\n    flex-direction: row-reverse;\n    justify-content: flex-end;\n    gap: sbb-sr-functions.sr-px-to-rem(22);\n    height: inherit;\n\n    @include sbb.mq($from: small) {\n      gap: sbb-sr-functions.sr-px-to-rem(54);\n    }\n\n    nav.sbb-sr-navigation,\n    ul.sbb-sr-navigation__list-coaches {\n      flex-direction: column;\n    }\n\n    nav.sbb-sr-navigation {\n      padding: sbb-sr-functions.sr-px-to-rem(16) 0;\n\n      .sbb-sr__navigation-control-button {\n        left: sbb-sr-functions.sr-px-to-rem(1);\n        top: 0;\n        rotate: 90deg;\n\n        @include sbb.mq($from: large) {\n          left: sbb-sr-functions.sr-px-to-rem(-1);\n        }\n      }\n\n      ul.sbb-sr-navigation__list-coaches {\n        max-width: initial;\n\n        // Padding needs to visual focus-visible style for nav button inside overflow content,\n        // otherwise focus-visible style is cutted.\n        padding: sbb-sr-functions.sr-px-to-rem($coach-navigation-padding);\n        overflow: hidden scroll;\n      }\n    }\n  }\n\n  // VERTICAL MODE - LABELMULTIPLE DECKS - LABELS\n  .sbb-sr__wrapper-coach-decks {\n    flex-direction: column;\n\n    .sbb-sr__wrapper-deck-labels {\n      flex-direction: column-reverse;\n      width: sbb-sr-functions.sr-px-to-rem($coach-grid-width);\n      height: initial;\n\n      b {\n        inline-size: calc(50% - sbb-sr-functions.sr-px-to-rem(16));\n        block-size: sbb-sr-functions.sr-px-to-rem(20);\n        margin-bottom: sbb-sr-functions.sr-px-to-rem(16);\n        rotate: initial;\n        writing-mode: initial;\n      }\n    }\n  }\n\n  // VERTICAL MODE - SEATMAP SCROLL AREA\n  .sbb-sr__wrapper-scrollarea {\n    width: sbb-sr-functions.sr-px-to-rem($coach-grid-width);\n    height: 100%;\n    overflow: hidden scroll;\n\n    .sbb-sr__parent {\n      rotate: 90deg;\n    }\n  }\n\n  // VERTICAL MODE - TRAVEL-DIRECTION\n  .sbb-sr-travel-direction-wrapper {\n    width: sbb-sr-functions.sr-px-to-rem(var(--sbb-seat-reservation-height));\n    margin-block-start: sbb-sr-functions.sr-px-to-rem(4);\n  }\n}\n\n// END - Vertical mode\n\n.sbb-sr-navigation {\n  gap: sbb-sr-functions.sr-px-to-rem(3);\n}\n\n.sbb-sr-navigation .sbb-sr__navigation-control-button {\n  position: relative;\n  top: sbb-sr-functions.sr-px-to-rem(2);\n\n  @include sbb.mq($from: large) {\n    top: 0;\n  }\n}\n\n.sbb-sr__component {\n  display: flex;\n  flex-direction: column;\n  gap: calc(sbb-sr-functions.sr-px-to-rem(64) - $scrollbar-height);\n}\n\n// TRAVEL DIRECTION\n.sbb-sr-travel-direction-wrapper {\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  column-gap: sbb-sr-functions.sr-px-to-rem(4);\n  margin-block: sbb-sr-functions.sr-px-to-rem(8) sbb-sr-functions.sr-px-to-rem(4);\n  font-size: var(--sbb-text-font-size-s);\n\n  .sbb-sr__travel-direction--arrow {\n    display: flex;\n    align-items: center;\n  }\n}\n\n// NAVIGATION NEW\n.sbb-sr-navigation-wrapper {\n  display: flex;\n}\n\n.sbb-sr-navigation {\n  display: flex;\n  justify-content: center;\n  width: 100%;\n  padding-inline: 16px;\n}\n\n.sbb-sr-navigation__list-coaches {\n  @include sbb.list-reset;\n  @include sbb.scrollbar;\n\n  display: flex;\n  flex-wrap: nowrap;\n  gap: sbb-sr-functions.sr-px-to-rem(4);\n  padding: sbb-sr-functions.sr-px-to-rem(6) sbb-sr-functions.sr-px-to-rem(5) 0;\n  max-width: $max-coach-navigation-width;\n\n  // Set sbb scrollbar transparent by default\n  --sbb-scrollbar-color: transparent;\n\n  overflow: scroll hidden;\n  position: relative;\n}\n\n// --------------- Seat Reservation Main Navigation - END ----------------\n\n// ------------- Seat Reservation Coaches - START -----------------\n.sbb-sr__wrapper-coach-decks {\n  display: flex;\n  overflow: hidden;\n  height: inherit;\n\n  .sbb-sr__wrapper-deck-labels {\n    display: flex;\n    justify-content: space-between;\n    height: sbb-sr-functions.sr-px-to-rem(var(--sbb-seat-reservation-height));\n    writing-mode: vertical-lr;\n\n    b {\n      height: calc(50% - sbb-sr-functions.sr-px-to-rem(16));\n      width: sbb-sr-functions.sr-px-to-rem(20);\n      margin-block-end: 16px;\n      rotate: 180deg;\n      text-align: center;\n      line-height: sbb-sr-functions.sr-px-to-rem(20);\n    }\n  }\n}\n\n.sbb-sr__wrapper-scrollarea {\n  @include sbb.scrollbar;\n\n  overflow: scroll hidden;\n  padding-block: sbb-sr-functions.sr-px-to-rem(8) sbb-sr-functions.sr-px-to-rem(16);\n\n  .sbb-sr__parent {\n    display: flex;\n    flex-direction: column;\n    position: relative;\n  }\n}\n\n.sbb-sr__list-decks {\n  @include sbb.list-reset;\n\n  display: flex;\n  flex-direction: column;\n}\n\n.sbb-sr__list-decks--gap {\n  gap: sbb-sr-functions.sr-px-to-rem(48);\n}\n\n.sbb-sr__list-item-deck {\n  position: relative;\n}\n\n.sbb-sr__list-coaches {\n  @include sbb.list-reset;\n\n  display: flex;\n  gap: sbb-sr-functions.sr-px-to-rem(4);\n}\n\n// If there are overhanging elements we need to increase the gap between coaches\n.sbb-sr__list-decks:has(.sbb-sr-coach-has-overhanging-elements) .sbb-sr__list-coaches {\n  gap: sbb-sr-functions.sr-px-to-rem(8);\n}\n\n.sbb-sr__item-coach {\n  position: relative;\n}\n\n.sbb-sr-coach-wrapper__table {\n  outline: 0;\n}\n","import { SbbLanguageController } from '@sbb-esta/lyne-elements/core/controllers.js';\nimport { boxSizingStyles } from '@sbb-esta/lyne-elements/core/styles.js';\nimport type { SbbPopoverElement } from '@sbb-esta/lyne-elements/popover.js';\nimport { html, nothing } from 'lit';\nimport type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { classMap } from 'lit/directives/class-map.js';\nimport { repeat } from 'lit/directives/repeat.js';\nimport { styleMap } from 'lit/directives/style-map.js';\n\nimport { getI18nSeatReservation } from '../common/translations.ts';\nimport type {\n  CoachItem,\n  CoachItemDetails,\n  Place,\n  ElementDimension,\n  BaseElement,\n  PlaceSelection,\n  SeatReservation,\n} from '../common/types.ts';\nimport { SbbSeatReservationAreaElement } from '../seat-reservation-area/seat-reservation-area.component.ts';\nimport { SbbSeatReservationGraphicElement } from '../seat-reservation-graphic/seat-reservation-graphic.component.ts';\nimport { SbbSeatReservationNavigationCoachElement } from '../seat-reservation-navigation-coach/seat-reservation-navigation-coach.component.ts';\nimport { SbbSeatReservationPlaceControlElement } from '../seat-reservation-place-control/seat-reservation-place-control.component.ts';\nimport { SbbSeatReservationScopedElement } from '../seat-reservation-scoped/seat-reservation-scoped.component.ts';\n\nimport { SeatReservationBaseElement } from './seat-reservation-base-element.ts';\nimport style from './seat-reservation.scss?lit&inline';\n\nimport '@sbb-esta/lyne-elements/button.js';\nimport '@sbb-esta/lyne-elements/screen-reader-only.js';\nimport '@sbb-esta/lyne-elements/popover.js';\n\nSbbSeatReservationAreaElement.define();\nSbbSeatReservationGraphicElement.define();\nSbbSeatReservationPlaceControlElement.define();\nSbbSeatReservationNavigationCoachElement.define();\nSbbSeatReservationScopedElement.define();\n\n/**\n * Main component for the seat reservation.\n *\n */\nexport class SbbSeatReservationElement extends SeatReservationBaseElement {\n  public static override readonly elementName: string = 'sbb-seat-reservation';\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  private _language = new SbbLanguageController(this);\n  private _coachesHtmlTemplate?: TemplateResult;\n\n  // Area icons that should not be fixed during rotation when vertical mode is selected\n  private _notFixedRotatableAreaIcons = ['ENTRY_EXIT'];\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('hasNavigation')) {\n      if (this.hasNavigation) {\n        this.shadowRoot\n          ?.querySelectorAll('table')\n          .forEach((table) => table.removeAttribute('tabindex'));\n      } else {\n        this.shadowRoot\n          ?.querySelectorAll('table')\n          .forEach((table) => table.setAttribute('tabindex', '0'));\n      }\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    // We need to wait until the first update is complete to init different HTML element dimensions\n    this.updateComplete.then(() => {\n      this.initNavigationSelectionByScrollEvent();\n    });\n  }\n\n  protected override render(): TemplateResult | null {\n    this._initVehicleSeatReservationConstruction();\n    return this._coachesHtmlTemplate || null;\n  }\n\n  private _initVehicleSeatReservationConstruction(): void {\n    this._coachesHtmlTemplate = html`\n      ${this._renderTravelDirection()}\n      <div class=\"sbb-sr__component\">\n        ${this._renderNavigation()}\n        <div\n          class=\"sbb-sr__wrapper-coach-decks\"\n          @keydown=${(evt: KeyboardEvent) => this.keyboardSeatmapEventHandling(evt)}\n        >\n          <div class=\"sbb-sr__wrapper-deck-labels\">${this._renderDeckLabels()}</div>\n          <div\n            @scroll=${() => this.coachAreaScrollend()}\n            id=\"sbb-sr__wrapper-scrollarea\"\n            class=\"sbb-sr__wrapper-scrollarea\"\n            tabindex=\"-1\"\n          >\n            <div id=\"sbb-sr__parent-area\" class=\"sbb-sr__parent\">\n              <ul\n                class=\"${classMap({\n                  'sbb-sr__list-decks': true,\n                  'sbb-sr__list-decks--gap': this.hasMultipleDecks,\n                })}\"\n              >\n                ${this.seatReservations?.map(\n                  (seatReservation: SeatReservation, coachDeckIndex: number) => {\n                    return html`<li class=\"sbb-sr__list-item-deck\">\n                      <ul class=\"sbb-sr__list-coaches\" role=\"presentation\">\n                        ${this._renderCoaches(seatReservation, coachDeckIndex)}\n                      </ul>\n                    </li>`;\n                  },\n                )}\n              </ul>\n            </div>\n          </div>\n        </div>\n      </div>\n    `;\n  }\n\n  private _renderDeckLabels(): TemplateResult[] | null {\n    if (!this.hasMultipleDecks) return null;\n\n    return this.seatReservations.map((seatReservation) => {\n      const deckDescription = getI18nSeatReservation(\n        seatReservation.deckCoachLevel,\n        this._language.current,\n      );\n      return html`<b aria-hidden=\"true\">${deckDescription}</b>`;\n    });\n  }\n\n  private _renderNavigationControlButton(btnDirection: string): TemplateResult | null {\n    if (!this.hasNavigation || !this.seatReservations) return null;\n    const btnNavigationDirectionId =\n      btnDirection == 'DIRECTION_RIGHT'\n        ? 'sbb-sr-navigation__wrapper-button-direction--right'\n        : 'sbb-sr-navigation__wrapper-button-direction--left';\n    const btnIcon =\n      btnDirection == 'DIRECTION_RIGHT' ? 'chevron-small-right-small' : 'chevron-small-left-small';\n    const btnAriaDescription =\n      btnDirection == 'DIRECTION_RIGHT'\n        ? getI18nSeatReservation('SEAT_RESERVATION_END', this._language.current)\n        : getI18nSeatReservation('SEAT_RESERVATION_BEGIN', this._language.current);\n    let btnDisabled = true;\n\n    if (btnDirection == 'DIRECTION_LEFT' && this.selectedCoachIndex > 0) {\n      btnDisabled = false;\n    } else if (\n      btnDirection == 'DIRECTION_RIGHT' &&\n      this.selectedCoachIndex < this.coachItemDetailsElements.length - 1\n    ) {\n      btnDisabled = false;\n    }\n\n    return html`<div class=\"sbb-sr-navigation__wrapper-button-direction\">\n      <sbb-secondary-button\n        @click=\"${() => this.navigateByDirectionBtn(btnDirection)}\"\n        @focus=\"${() => this.onFocusNavDirectionButton()}\"\n        id=\"${btnNavigationDirectionId}\"\n        class=\"sbb-sr__navigation-control-button\"\n        size=\"m\"\n        icon-name=\"${btnIcon}\"\n        type=\"button\"\n        aria-label=\"${btnAriaDescription}\"\n        role=\"button\"\n        .disabledInteractive=\"${btnDisabled || nothing}\"\n        .disabled=\"${btnDisabled || nothing}\"\n      ></sbb-secondary-button>\n    </div>`;\n  }\n\n  private _renderTravelDirection(): TemplateResult | null {\n    if (!this.travelDirection || this.travelDirection === 'NONE') return null;\n\n    const labelText = getI18nSeatReservation(\n      'SEAT_RESERVATION_TRAVEL_DIRECTION',\n      this._language.current,\n    );\n\n    const arrowDirection = this.alignVertical\n      ? this.travelDirection === 'RIGHT'\n        ? 'down'\n        : 'up'\n      : this.travelDirection === 'RIGHT'\n        ? 'right'\n        : 'left';\n\n    const iconName = `arrow-${arrowDirection}-small`;\n\n    return html`<div class=\"sbb-sr-travel-direction-wrapper\">\n      <div class=\"sbb-sr__travel-direction--arrow\">\n        <sbb-icon slot=\"icon\" name=\"${iconName}\"></sbb-icon>\n      </div>\n      <div class=\"sbb-sr__travel-direction--label\">${labelText}</div>\n    </div>`;\n  }\n\n  private _renderNavigation(): TemplateResult | null {\n    if (!this.hasNavigation || !this.seatReservations) return null;\n    return html`<div class=\"sbb-sr-navigation-wrapper\">\n      <nav id=\"sbb-sr-navigation\" class=\"sbb-sr-navigation\">\n        ${this._renderNavigationControlButton('DIRECTION_LEFT')}\n        <ul\n          id=\"sbb-sr__navigation-list-coaches\"\n          class=\"sbb-sr-navigation__list-coaches\"\n          aria-label=\"${getI18nSeatReservation(\n            'SEAT_RESERVATION_NAVIGATION',\n            this._language.current,\n          )}\"\n        >\n          ${this.coachItemDetailsElements.map(\n            (coachItemDetails: CoachItemDetails, index: number) => {\n              return html`<li>\n                <sbb-seat-reservation-navigation-coach\n                  @selectcoach=${(event: CustomEvent<number>) => this._onSelectNavCoach(event)}\n                  @focuscoach=${() => this._onFocusNavCoach()}\n                  @keyup=${(evt: KeyboardEvent) => this.onKeyNavigationNavCoachButton(evt, index)}\n                  index=\"${index}\"\n                  .selected=${this.selectedCoachIndex === index}\n                  .focused=${this.focusedCoachIndex === index}\n                  .hovered=${this.hoveredCoachIndex === index}\n                  .nativeFocusActive=${this.hasSeatReservationNativeFocus}\n                  .coachItemDetails=\"${coachItemDetails}\"\n                  ?vertical=\"${this.alignVertical}\"\n                  ?showTitleInfo=\"${this.showTitleInfo}\"\n                >\n                </sbb-seat-reservation-navigation-coach>\n              </li>`;\n            },\n          )}\n        </ul>\n        ${this._renderNavigationControlButton('DIRECTION_RIGHT')}\n      </nav>\n    </div>`;\n  }\n  /**\n   *\n   * @returns\n   * @param seatReservation\n   * @param coachDeckIndex\n   */\n  private _renderCoaches(\n    seatReservation: SeatReservation,\n    coachDeckIndex: number,\n  ): TemplateResult[] | null {\n    const coaches: CoachItem[] = JSON.parse(JSON.stringify(seatReservation?.coachItems));\n\n    if (!coaches) {\n      return null;\n    }\n    return coaches.map((coachItem: CoachItem, coachIndex: number) => {\n      return html`\n        <li class=\"sbb-sr__item-coach\">\n          ${this._renderCoachElement(\n            coachItem,\n            coachIndex,\n            coachDeckIndex,\n            seatReservation.deckCoachIndex,\n          )}\n        </li>\n      `;\n    });\n  }\n\n  private _renderCoachElement(\n    coachItem: CoachItem,\n    coachIndex: number,\n    coachDeckIndex: number,\n    placeCoachDeckIndex: number,\n  ): TemplateResult {\n    const calculatedCoachDimension = this.getCalculatedDimension(coachItem.dimension);\n    const descriptionTableCoachWithServices = this._getDescriptionTableCoach(coachItem);\n\n    return html`<sbb-seat-reservation-scoped\n      style=${styleMap({\n        '--sbb-seat-reservation-scoped-width': calculatedCoachDimension.w,\n        '--sbb-seat-reservation-scoped-height': calculatedCoachDimension.h,\n      })}\n    >\n      ${this._getRenderedCoachBorders(coachItem, coachIndex)}\n      ${this._getRenderedGraphicalElements(\n        coachItem.graphicElements || [],\n        coachItem.dimension,\n        coachIndex,\n        coachDeckIndex,\n      )}\n      ${this._getRenderedServiceElements(coachIndex, coachDeckIndex, coachItem.serviceElements)}\n\n      <table\n        @focus=${() => this.onFocusTableCoachAndPreselectPlace(coachIndex)}\n        id=\"sbb-sr-coach-${coachIndex}\"\n        class=\"sbb-sr-coach-wrapper__table\"\n        aria-describedby=\"sbb-sr-coach-caption-${coachIndex}\"\n        tabindex=\"-1\"\n      >\n        <caption id=\"sbb-sr-coach-caption-${coachIndex}\" tabindex=\"-1\">\n          <sbb-screen-reader-only>${descriptionTableCoachWithServices}</sbb-screen-reader-only>\n        </caption>\n        ${this._getRenderedRowPlaces(coachItem, coachIndex, coachDeckIndex, placeCoachDeckIndex)}\n      </table>\n    </sbb-seat-reservation-scoped>`;\n  }\n\n  /**\n   * @returns Returns the border graphic (COACH_BORDER_MIDDLE) of a coach with calculated border gap and coach width,\n   * depending on whether the coach is with a driver area or without.\n   */\n  private _getRenderedCoachBorders(\n    coachItem: CoachItem,\n    coachIndex: number,\n  ): TemplateResult | null {\n    if (!coachItem.graphicElements) return null;\n\n    const COACH_PASSAGE_WIDTH = 1;\n    const driverArea = this.coachItemDetailsElements[coachIndex]?.driverAreaElements?.driverArea;\n    const driverAreaNoVerticalWall =\n      this.coachItemDetailsElements[coachIndex]?.driverAreaElements?.driverAreaNoVerticalWall;\n\n    let borderWidth = driverArea\n      ? coachItem.dimension.w - driverArea.dimension.w - COACH_PASSAGE_WIDTH\n      : coachItem.dimension.w - COACH_PASSAGE_WIDTH * 2;\n\n    //multiply with base grid size always for all kind of borderWidth\n    borderWidth *= this.baseGridSize;\n\n    const borderHeight = (coachItem.dimension.h + this.coachBorderOffset * 2) * this.baseGridSize;\n    let borderOffsetX =\n      driverArea && driverArea.position.x === 0\n        ? driverArea?.dimension.w * this.baseGridSize\n        : this.baseGridSize;\n\n    //recalculate the border width and offset if there is a driver area without vertical wall on both sides\n    if (driverAreaNoVerticalWall) {\n      const coachWidth = this.getCalculatedDimension(coachItem.dimension).w;\n\n      //recalculated borderWidth = coachWidth - 2 * driver area width, since the driver area is on both sides\n      borderWidth = coachWidth - 2 * (driverAreaNoVerticalWall.dimension.w * this.baseGridSize);\n\n      //recalculated borderOffsetX = driver area width, since the border starts after the driver area on the left side\n      borderOffsetX = driverAreaNoVerticalWall.dimension.w * this.baseGridSize;\n    }\n\n    const currentCoachOverlappingInfo = this.overHangingElementInformation.find(\n      (el) => el.coachId == coachItem.id,\n    );\n\n    // check if there are overhanging places or graphical elements to adjust the border width and offset + gap\n    // We do not differentiate whether there is something to be done on both sides as this would lead to unnecessary\n    // complexity. So if there is something on one side, we just increase the coach-border on both sides.\n    if (\n      currentCoachOverlappingInfo?.overhangingPlaces ||\n      currentCoachOverlappingInfo?.overhangingGraphicAreas\n    ) {\n      borderWidth += 2 * this.baseGridSize; // we increase the width by 2 grid sizes to have enough space for protruded places on both sides\n      borderOffsetX = 0; // we start at 0 to have enough space on the left side as well\n    }\n\n    return html`\n      <sbb-seat-reservation-graphic\n        class=\"${classMap({\n          'sbb-sr-coach-has-overhanging-elements':\n            currentCoachOverlappingInfo?.overhangingPlaces ||\n            currentCoachOverlappingInfo?.overhangingGraphicAreas ||\n            false,\n        })}\"\n        style=${styleMap({\n          '--sbb-seat-reservation-graphic-width': borderWidth,\n          '--sbb-seat-reservation-graphic-height': borderHeight,\n          '--sbb-seat-reservation-graphic-top': this.coachBorderPadding * -1,\n          '--sbb-seat-reservation-graphic-left': borderOffsetX,\n          '--sbb-seat-reservation-graphic-position': 'absolute',\n        })}\n        name=\"COACH_BORDER_MIDDLE\"\n        ?stretch=${true}\n        role=\"presentation\"\n      ></sbb-seat-reservation-graphic>\n    `;\n  }\n\n  private _getRenderedRowPlaces(\n    coach: CoachItem,\n    coachIndex: number,\n    coachDeckIndex: number,\n    placeCoachDeckIndex: number,\n  ): TemplateResult[] | null {\n    if (!coach.places) {\n      return null;\n    }\n\n    // Prepare rows with the places to render a table\n    const tableRowPlaces: Record<number, Place[]> = {};\n    for (const place of coach.places) {\n      if (!tableRowPlaces[place.position.y]) {\n        tableRowPlaces[place.position.y] = [place];\n      } else {\n        tableRowPlaces[place.position.y].push(place);\n      }\n    }\n\n    return Object.values(tableRowPlaces)\n      .map((rowPlaces: Place[], index) => {\n        return html`\n          <tr id=\"row-${coachIndex}-${rowPlaces[0].position.y}\" data-row-index=${index}>\n            ${this._getRenderedColumnPlaces(\n              rowPlaces,\n              coachIndex,\n              coachDeckIndex,\n              placeCoachDeckIndex,\n            )}\n          </tr>\n        `;\n      })\n      .flatMap((rowTemplate) => rowTemplate);\n  }\n\n  private _getRenderedColumnPlaces(\n    places: Place[],\n    coachIndex: number,\n    deckIndex: number,\n    placeCoachDeckIndex: number,\n  ): TemplateResult | null {\n    //Sorts each place by its ascending x coordinate\n    places.sort(\n      (placeA: Place, placeB: Place) => Number(placeA.position.x) - Number(placeB.position.x),\n    );\n\n    // For rendering the places within a td element, here we use repeat directive for better performance for reusing elements (track by id).\n    const trackPlaceId = coachIndex + '-' + placeCoachDeckIndex;\n    return html`${repeat(\n      places,\n      (place) => trackPlaceId + '-' + place.number,\n      (place, index) => {\n        const calculatedDimension = this.getCalculatedDimension(place.dimension);\n        const calculatedPosition = this.getCalculatedPosition(place.position);\n        const rotation = place.rotation || 0;\n        const textRotation = this.alignVertical ? -90 : 0;\n        const placeId = this.getPlaceElementId(deckIndex, coachIndex, place.number);\n        return html`\n          <td\n            id=\"cell-${deckIndex}-${coachIndex}-${place.position.y}-${index}\"\n            class=\"graphical-element\"\n          >\n            <sbb-seat-reservation-place-control\n              style=${styleMap({\n                '--sbb-seat-reservation-place-control-text-scale-value': Math.min(\n                  calculatedDimension.w,\n                  calculatedDimension.h,\n                ),\n                '--sbb-seat-reservation-place-control-width': calculatedDimension.w,\n                '--sbb-seat-reservation-place-control-height': calculatedDimension.h,\n                '--sbb-seat-reservation-place-control-top': calculatedPosition.y,\n                '--sbb-seat-reservation-place-control-left': calculatedPosition.x,\n                '--sbb-seat-reservation-place-control-rotation': rotation,\n                '--sbb-seat-reservation-place-control-text-rotation': textRotation,\n              })}\n              @selectplace=${(selectPlaceEvent: CustomEvent<PlaceSelection>) =>\n                this._onSelectPlace(selectPlaceEvent)}\n              exportparts=\"sbb-sr-place-part\"\n              id=${placeId}\n              class=\"seat-reservation-place-control\"\n              text=${place.number}\n              type=${place.type}\n              state=${place.state}\n              travel-direction=${this.travelDirection}\n              coach-index=${coachIndex}\n              deck-index=${placeCoachDeckIndex}\n              data-deck-index=${deckIndex}\n              .propertyIds=${place.propertyIds}\n              .preventClick=${this.preventPlaceClick}\n              ?showTitleInfo=\"${this.showTitleInfo}\"\n            ></sbb-seat-reservation-place-control>\n          </td>\n        `;\n      },\n    )}`;\n  }\n\n  private _getRenderedGraphicalElements(\n    graphicalElements: BaseElement[],\n    coachDimension: ElementDimension,\n    coachIndex: number,\n    coachDeckIndex: number,\n  ): TemplateResult[] | null {\n    if (!graphicalElements) return null;\n\n    return graphicalElements?.map((graphicalElement: BaseElement) => {\n      const icon = graphicalElement.icon ?? '';\n      const elementRotation = graphicalElement.rotation || 0;\n      const isNotFixedRotationGraphicalElement =\n        this._notFixedRotatableAreaIcons.indexOf(graphicalElement.icon!) === -1;\n      const elementFixedRotation =\n        this.alignVertical && isNotFixedRotationGraphicalElement\n          ? elementRotation - 90\n          : elementRotation;\n\n      //check if the current element is not an area element, since this element is drawn without an area component\n      if (this.notAreaElements.findIndex((notAreaElement) => notAreaElement === icon) > -1) {\n        return this._getRenderElementWithoutArea(graphicalElement, elementRotation, coachDimension);\n      }\n      return this._getRenderElementWithArea(\n        graphicalElement,\n        elementFixedRotation,\n        coachDimension,\n        coachIndex,\n        coachDeckIndex,\n      );\n    });\n  }\n\n  /**\n   * creates a rendered element with an area component\n   * @param graphicalElement\n   * @param rotation\n   * @param coachDimension\n   * @param coachIndex used to generate a unique id for the popover trigger\n   * @param coachDeckIndex used to generate a unique id\n   * @private\n   */\n  private _getRenderElementWithArea(\n    graphicalElement: BaseElement,\n    rotation: number,\n    coachDimension: ElementDimension,\n    coachIndex: number,\n    coachDeckIndex: number,\n  ): TemplateResult {\n    // for TABLE, we use the area component itself to display the table instead of the SVG graphic.\n    // Due to different heights and widths, it wouldn't show correctly. To correct this, we would\n    // need difficult calculations for position, rotation and dimension.\n    const isNotTableGraphic = graphicalElement.icon?.indexOf('TABLE') === -1;\n    const areaProperty = graphicalElement.icon && isNotTableGraphic ? graphicalElement.icon : null;\n    const stretchHeight =\n      this.isElementDirectlyOnBorder(graphicalElement, coachDimension) &&\n      areaProperty !== 'ENTRY_EXIT';\n    const ariaLabelForArea = graphicalElement.icon\n      ? getI18nSeatReservation(graphicalElement.icon, this._language.current)\n      : nothing;\n\n    const calculatedDimension = this.getCalculatedDimension(\n      graphicalElement.dimension,\n      coachDimension,\n      true,\n      stretchHeight,\n    );\n\n    const calculatedPosition = this.getCalculatedPosition(\n      graphicalElement.position,\n      graphicalElement.dimension,\n      coachDimension,\n      true,\n    );\n\n    //generate unique index number for the trigger element\n    const triggerId = `popover-trigger-${coachDeckIndex}-${coachIndex}-${calculatedPosition.x}-${calculatedPosition.y}`;\n    let elementMounting = 'free';\n\n    if (graphicalElement.position.y === this.coachBorderOffset * -1) {\n      elementMounting = 'upper-border';\n    } else if (\n      graphicalElement.position.y + graphicalElement.dimension.h ===\n      coachDimension.h + this.coachBorderOffset\n    ) {\n      elementMounting = 'lower-border';\n    }\n\n    // TIMO-45830\n    // If area elements are located at the border of coach,\n    // we have to manually modify the position and height of the area element,\n    // so that we get a gap from the visuel coach border\n    if (elementMounting !== 'free') {\n      calculatedPosition.y += elementMounting === 'upper-border' ? 2 : 1;\n      calculatedDimension.h -= 3;\n    }\n    return html`\n      <sbb-seat-reservation-area\n        id=\"${triggerId}\"\n        class=\"${classMap({ 'sbb-seat-reservation-area--cursor-pointer': areaProperty !== null })}\"\n        style=${styleMap({\n          '--sbb-seat-reservation-area-width': calculatedDimension.w,\n          '--sbb-seat-reservation-area-height': calculatedDimension.h,\n          '--sbb-seat-reservation-area-top': calculatedPosition.y,\n          '--sbb-seat-reservation-area-left': calculatedPosition.x,\n        })}\n        mounting=${elementMounting}\n        background=\"dark\"\n        aria-hidden=\"true\"\n      >\n        ${areaProperty\n          ? html`\n              <sbb-seat-reservation-graphic\n                style=${styleMap({\n                  '--sbb-seat-reservation-graphic-max-width': calculatedDimension.w,\n                  '--sbb-seat-reservation-graphic-height': this.baseGridSize,\n                  '--sbb-seat-reservation-graphic-rotation': rotation,\n                })}\n                name=${areaProperty}\n                role=\"img\"\n                aria-hidden=\"true\"\n                class=\"auto-width\"\n              ></sbb-seat-reservation-graphic>\n            `\n          : nothing}\n      </sbb-seat-reservation-area>\n      ${areaProperty ? this._popover(triggerId, ariaLabelForArea) : nothing}\n    `;\n  }\n\n  private _getRenderElementWithoutArea(\n    graphicalElement: BaseElement,\n    rotation: number,\n    coachDimension: ElementDimension,\n  ): TemplateResult {\n    const calculatedDimension = this.getCalculatedDimension(\n      graphicalElement.dimension,\n      coachDimension,\n    );\n    const calculatedPosition = this.getCalculatedPosition(\n      graphicalElement.position,\n      graphicalElement.dimension,\n      coachDimension,\n    );\n\n    // If the icon is the driver area, then here concat the vehicle type to get the right vehicle chassis icon\n    const icon =\n      graphicalElement.icon && graphicalElement.icon.endsWith('DRIVER_AREA')\n        ? graphicalElement.icon?.concat(\n            '_',\n            this.seatReservations[this.currSelectedDeckIndex].vehicleType,\n          )\n        : graphicalElement.icon;\n\n    return html` <sbb-seat-reservation-graphic\n      style=${styleMap({\n        '--sbb-seat-reservation-graphic-width': calculatedDimension.w,\n        '--sbb-seat-reservation-graphic-height': calculatedDimension.h,\n        '--sbb-seat-reservation-graphic-top': calculatedPosition.y,\n        '--sbb-seat-reservation-graphic-left': calculatedPosition.x,\n        '--sbb-seat-reservation-graphic-position': 'absolute',\n        '--sbb-seat-reservation-graphic-rotation': rotation,\n      })}\n      name=${icon ?? nothing}\n      aria-hidden=\"true\"\n      ?stretch=${true}\n    ></sbb-seat-reservation-graphic>`;\n  }\n\n  private _getRenderedServiceElements(\n    coachIndex: number,\n    coachDeckIndex: number,\n    serviceElements?: BaseElement[],\n  ): TemplateResult[] | null {\n    if (!serviceElements) return null;\n\n    return serviceElements?.map((serviceElement: BaseElement) => {\n      const titleDescription = serviceElement.icon\n        ? getI18nSeatReservation(serviceElement.icon, this._language.current)\n        : null;\n      const calculatedDimension = this.getCalculatedDimension(serviceElement.dimension);\n      const calculatedPosition = this.getCalculatedPosition(serviceElement.position);\n      const elementRotation = serviceElement.rotation || 0;\n      const elementFixedRotation = this.alignVertical ? elementRotation - 90 : elementRotation;\n\n      //generate unique index number for the trigger element\n      const triggerId = `popover-trigger-${coachDeckIndex}-${coachIndex}-${calculatedPosition.x}-${calculatedPosition.y}`;\n\n      return html`\n        <sbb-seat-reservation-graphic\n          id=\"${triggerId}\"\n          style=${styleMap({\n            '--sbb-seat-reservation-graphic-width': calculatedDimension.w,\n            '--sbb-seat-reservation-graphic-height': calculatedDimension.h,\n            '--sbb-seat-reservation-graphic-top': calculatedPosition.y,\n            '--sbb-seat-reservation-graphic-left': calculatedPosition.x,\n            '--sbb-seat-reservation-graphic-position': 'absolute',\n            '--sbb-seat-reservation-graphic-rotation': elementFixedRotation,\n          })}\n          class=\"sbb-seat-reservation-graphic--cursor-pointer\"\n          name=${serviceElement.icon ?? nothing}\n          role=\"img\"\n          aria-hidden=\"true\"\n        ></sbb-seat-reservation-graphic>\n        ${this._popover(triggerId, titleDescription)}\n      `;\n    });\n  }\n\n  /**\n   * Manages the selected place event triggered from the place\n   * Each selection emits an array of all selected places\n   * @param selectPlaceEvent\n   */\n  private _onSelectPlace(selectPlaceEvent: CustomEvent<PlaceSelection>): void {\n    const selectedPlace = selectPlaceEvent.detail;\n    // We have to set preventCoachScrollByPlaceClick to true, to prevent automatic scrolling to the new focused place\n    this.preventCoachScrollByPlaceClick = true;\n    this.isCoachGridFocusable = false;\n    this.focusedCoachIndex = -1;\n    // Check any keyboard event was triggered inside the seat reservation component,\n    // so we can say the native browser focus lies on the component\n    if (!this.hasSeatReservationNativeFocus) {\n      this.hasSeatReservationNativeFocus = true;\n    }\n\n    if (!this.preventPlaceClick) {\n      // Add place to place collection\n      this.updateSelectedSeatReservationPlaces(selectedPlace);\n      this.updateCurrentSelectedPlaceInCoach(selectedPlace);\n    }\n  }\n\n  private _onSelectNavCoach(event: CustomEvent<number>): void {\n    const selectedNavCoachIndex = event.detail;\n\n    this.isKeyboardNavigation = false;\n    this.preventCoachScrollByPlaceClick = false;\n    this.hasSeatReservationNativeFocus = true;\n\n    if (selectedNavCoachIndex !== null && selectedNavCoachIndex !== this.currSelectedCoachIndex) {\n      this.unfocusPlaceElement();\n      this.scrollToSelectedNavCoach(selectedNavCoachIndex);\n    } else if (selectedNavCoachIndex === this.currSelectedCoachIndex) {\n      this.updateCurrentSelectedCoach();\n      this.preselectPlaceInCoach();\n    }\n\n    //close all opened popovers\n    this._closePopover();\n  }\n\n  private _onFocusNavCoach(): void {\n    if (!this.preventCoachScrollByPlaceClick) {\n      this.preselectPlaceInCoach();\n    } else {\n      this.focusPlaceElement(this.currSelectedPlace);\n    }\n\n    this.isAutoScrolling = false;\n  }\n\n  /**\n   * Creates a popover for extra service information\n   * @param triggerId\n   * @param popoverContent\n   * @private\n   */\n  private _popover(\n    triggerId: string,\n    popoverContent: string | null | typeof nothing,\n  ): TemplateResult {\n    return html`\n      <sbb-popover trigger=\"${triggerId}\" hover-trigger=\"\">\n        <p class=\"sbb-text-s sbb-sr-popover\">${popoverContent}</p>\n      </sbb-popover>\n    `;\n  }\n\n  /**\n   * trigger to close all opened popovers (normally only one is opened at a time)\n   * @private\n   */\n  private _closePopover(): void {\n    this.shadowRoot\n      ?.querySelectorAll<SbbPopoverElement>('sbb-popover:state(state-opened)')\n      .forEach((popover) => popover.close());\n  }\n\n  private _getDescriptionTableCoach(coachItem: CoachItem): string {\n    //show different table caption for screenreader if it is a locomotive\n    if (coachItem.type === 'LOCOMOTIVE_COACH') {\n      return getI18nSeatReservation('COACH_LOCOMOTIVE', this._language.current);\n    }\n\n    if (!coachItem.places?.length) {\n      return getI18nSeatReservation('COACH_BLOCKED_TABLE_CAPTION', this._language.current, [\n        coachItem.id,\n      ]);\n    }\n\n    let tableCoachDescription: string;\n    const areaDescriptions = this._getTitleDescriptionListString(coachItem.graphicElements!);\n    const serviceDescriptions = this._getTitleDescriptionListString(coachItem.serviceElements!);\n\n    tableCoachDescription = getI18nSeatReservation('COACH_TABLE_CAPTION', this._language.current, [\n      coachItem.id,\n    ]);\n\n    if (!this.hasNavigation) {\n      // Expands the number of available seats and bicycle spaces as info\n      const freePlaces = this.getAvailableFreePlacesNumFromCoach(coachItem.places);\n      const freePlacesTxt = getI18nSeatReservation(\n        'COACH_AVAILABLE_NUMBER_OF_PLACES',\n        this._language.current,\n        [freePlaces.seats, freePlaces.bicycles],\n      );\n      tableCoachDescription = tableCoachDescription.concat('. ').concat(freePlacesTxt).concat('. ');\n    }\n\n    if (!!areaDescriptions || !!serviceDescriptions) {\n      tableCoachDescription +=\n        '. ' + getI18nSeatReservation('COACH_AVAILABLE_SERVICES', this._language.current) + ': ';\n      tableCoachDescription += serviceDescriptions + ', ' + areaDescriptions + '.';\n    }\n    return tableCoachDescription;\n  }\n\n  private _getTitleDescriptionListString(descriptionsElements: BaseElement[]): string {\n    const uniqueDescriptions: string[] = [];\n\n    return descriptionsElements\n      ?.map((descriptionElement) => {\n        const icon = descriptionElement.icon;\n        if (!icon) return null;\n\n        const descriptionAlreadyExist = uniqueDescriptions.indexOf(icon) > -1;\n        const translation = getI18nSeatReservation(\n          descriptionElement.icon!,\n          this._language.current,\n        );\n        const isValidDescription =\n          this._notFixedRotatableAreaIcons.indexOf(icon) === -1 &&\n          this.notAreaElements.indexOf(icon) === -1;\n\n        if (!descriptionAlreadyExist) {\n          uniqueDescriptions.push(descriptionElement.icon!);\n        }\n        return !!translation && !descriptionAlreadyExist && isValidDescription ? translation : null;\n      })\n      .filter((description) => !!description)\n      .join(', ');\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-seat-reservation': SbbSeatReservationElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACgCA,8BAA8B,QAAQ;AACtC,iCAAiC,QAAQ;AACzC,sCAAsC,QAAQ;AAC9C,yCAAyC,QAAQ;AACjD,gCAAgC,QAAQ;;;;;AAMxC,IAAa,4BAAb,cAA+C,2BAA0B;CAAzE,cAAA;;AAIU,OAAA,YAAY,IAAI,sBAAsB,KAAK;AAI3C,OAAA,8BAA8B,CAAC,aAAa;;;AAPpB,OAAA,cAAsB;;;AAC/B,OAAA,SAAyB,CAAC,iBAAiB,yBAAM;;CAQrD,WAAW,mBAAuC;AACnE,QAAM,WAAW,kBAAkB;AAEnC,MAAI,kBAAkB,IAAI,gBAAgB,CACxC,KAAI,KAAK,cACP,MAAK,YACD,iBAAiB,QAAQ,CAC1B,SAAS,UAAU,MAAM,gBAAgB,WAAW,CAAC;MAExD,MAAK,YACD,iBAAiB,QAAQ,CAC1B,SAAS,UAAU,MAAM,aAAa,YAAY,IAAI,CAAC;;CAK7C,aAAa,mBAAuC;AACrE,QAAM,aAAa,kBAAkB;AAGrC,OAAK,eAAe,WAAU;AAC5B,QAAK,sCAAsC;IAC3C;;CAGe,SAAM;AACvB,OAAK,yCAAyC;AAC9C,SAAO,KAAK,wBAAwB;;CAG9B,0CAAuC;AAC7C,OAAK,uBAAuB,IAAI;QAC5B,KAAK,wBAAwB,CAAA;;UAE3B,KAAK,mBAAmB,CAAA;;;sBAGZ,QAAuB,KAAK,6BAA6B,IAAI,CAAA;;qDAE9B,KAAK,mBAAmB,CAAA;;4BAEjD,KAAK,oBAAoB,CAAA;;;;;;;yBAO5B,SAAS;GAChB,sBAAsB;GACtB,2BAA2B,KAAK;GACjC,CAAC,CAAA;;kBAEA,KAAK,kBAAkB,KACtB,iBAAkC,mBAA0B;AAC3D,UAAO,IAAI;;0BAEL,KAAK,eAAe,iBAAiB,eAAe,CAAA;;;IAI7D,CAAA;;;;;;;;CASP,oBAAiB;AACvB,MAAI,CAAC,KAAK,iBAAkB,QAAO;AAEnC,SAAO,KAAK,iBAAiB,KAAK,oBAAmB;AAKnD,UAAO,IAAI,yBAJa,uBACtB,gBAAgB,gBAChB,KAAK,UAAU,QAChB,CACkD;IACnD;;CAGI,+BAA+B,cAAoB;AACzD,MAAI,CAAC,KAAK,iBAAiB,CAAC,KAAK,iBAAkB,QAAO;EAC1D,MAAM,2BACJ,gBAAgB,oBACZ,uDACA;EACN,MAAM,UACJ,gBAAgB,oBAAoB,8BAA8B;EACpE,MAAM,qBACJ,gBAAgB,oBACZ,uBAAuB,wBAAwB,KAAK,UAAU,QAAQ,GACtE,uBAAuB,0BAA0B,KAAK,UAAU,QAAQ;EAC9E,IAAI,cAAc;AAElB,MAAI,gBAAgB,oBAAoB,KAAK,qBAAqB,EAChE,eAAc;WAEd,gBAAgB,qBAChB,KAAK,qBAAqB,KAAK,yBAAyB,SAAS,EAEjE,eAAc;AAGhB,SAAO,IAAI;;wBAES,KAAK,uBAAuB,aAAa,CAAA;wBACzC,KAAK,2BAA2B,CAAA;cAC1C,yBAAwB;;;qBAGjB,QAAO;;sBAEN,mBAAkB;;gCAER,eAAe,QAAO;qBACjC,eAAe,QAAO;;;;CAKjC,yBAAsB;AAC5B,MAAI,CAAC,KAAK,mBAAmB,KAAK,oBAAoB,OAAQ,QAAO;EAErE,MAAM,YAAY,uBAChB,qCACA,KAAK,UAAU,QAChB;AAYD,SAAO,IAAI;;sCAFM,SARM,KAAK,gBACxB,KAAK,oBAAoB,UACvB,SACA,OACF,KAAK,oBAAoB,UACvB,UACA,OAEkC,QAIE;;qDAEO,UAAS;;;CAIpD,oBAAiB;AACvB,MAAI,CAAC,KAAK,iBAAiB,CAAC,KAAK,iBAAkB,QAAO;AAC1D,SAAO,IAAI;;UAEL,KAAK,+BAA+B,iBAAiB,CAAA;;;;wBAIvC,uBACZ,+BACA,KAAK,UAAU,QAChB,CAAA;;YAEC,KAAK,yBAAyB,KAC7B,kBAAoC,UAAiB;AACpD,UAAO,IAAI;;kCAES,UAA+B,KAAK,kBAAkB,MAAM,CAAA;sCACxD,KAAK,kBAAkB,CAAA;4BACjC,QAAuB,KAAK,8BAA8B,KAAK,MAAM,CAAA;2BACtE,MAAK;8BACF,KAAK,uBAAuB,MAAA;6BAC7B,KAAK,sBAAsB,MAAA;6BAC3B,KAAK,sBAAsB,MAAA;uCACjB,KAAK,8BAAA;uCACL,iBAAgB;+BACxB,KAAK,cAAa;oCACb,KAAK,cAAa;;;;IAK3C,CAAA;;UAED,KAAK,+BAA+B,kBAAkB,CAAA;;;;;;;;;;CAUtD,eACN,iBACA,gBAAsB;EAEtB,MAAM,UAAuB,KAAK,MAAM,KAAK,UAAU,iBAAiB,WAAW,CAAC;AAEpF,MAAI,CAAC,QACH,QAAO;AAET,SAAO,QAAQ,KAAK,WAAsB,eAAsB;AAC9D,UAAO,IAAI;;YAEL,KAAK,oBACL,WACA,YACA,gBACA,gBAAgB,eACjB,CAAA;;;IAGL;;CAGI,oBACN,WACA,YACA,gBACA,qBAA2B;EAE3B,MAAM,2BAA2B,KAAK,uBAAuB,UAAU,UAAU;EACjF,MAAM,oCAAoC,KAAK,0BAA0B,UAAU;AAEnF,SAAO,IAAI;cACD,SAAS;GACf,uCAAuC,yBAAyB;GAChE,wCAAwC,yBAAyB;GAClE,CAAC,CAAA;;QAEA,KAAK,yBAAyB,WAAW,WAAW,CAAA;QACpD,KAAK,8BACL,UAAU,mBAAmB,EAAE,EAC/B,UAAU,WACV,YACA,eACD,CAAA;QACC,KAAK,4BAA4B,YAAY,gBAAgB,UAAU,gBAAgB,CAAA;;;uBAGxE,KAAK,mCAAmC,WAAW,CAAA;2BAC/C,WAAU;;iDAEY,WAAU;;;4CAGf,WAAU;oCAClB,kCAAiC;;UAE3D,KAAK,sBAAsB,WAAW,YAAY,gBAAgB,oBAAoB,CAAA;;;;;;;;CAStF,yBACN,WACA,YAAkB;AAElB,MAAI,CAAC,UAAU,gBAAiB,QAAO;EAEvC,MAAM,sBAAsB;EAC5B,MAAM,aAAa,KAAK,yBAAyB,aAAa,oBAAoB;EAClF,MAAM,2BACJ,KAAK,yBAAyB,aAAa,oBAAoB;EAEjE,IAAI,cAAc,aACd,UAAU,UAAU,IAAI,WAAW,UAAU,IAAI,sBACjD,UAAU,UAAU,IAAI,sBAAsB;AAGlD,iBAAe,KAAK;EAEpB,MAAM,gBAAgB,UAAU,UAAU,IAAI,KAAK,oBAAoB,KAAK,KAAK;EACjF,IAAI,gBACF,cAAc,WAAW,SAAS,MAAM,IACpC,YAAY,UAAU,IAAI,KAAK,eAC/B,KAAK;AAGX,MAAI,0BAA0B;AAI5B,iBAHmB,KAAK,uBAAuB,UAAU,UAAU,CAAC,IAGzC,KAAK,yBAAyB,UAAU,IAAI,KAAK;AAG5E,mBAAgB,yBAAyB,UAAU,IAAI,KAAK;;EAG9D,MAAM,8BAA8B,KAAK,8BAA8B,MACpE,OAAO,GAAG,WAAW,UAAU,GACjC;AAKD,MACE,6BAA6B,qBAC7B,6BAA6B,yBAC7B;AACA,kBAAe,IAAI,KAAK;AACxB,mBAAgB;;AAGlB,SAAO,IAAI;;iBAEE,SAAS,EAChB,yCACE,6BAA6B,qBAC7B,6BAA6B,2BAC7B,OACH,CAAC,CAAA;gBACM,SAAS;GACf,wCAAwC;GACxC,yCAAyC;GACzC,sCAAsC,KAAK,qBAAqB;GAChE,uCAAuC;GACvC,2CAA2C;GAC5C,CAAC,CAAA;;mBAES,KAAA;;;;;CAMT,sBACN,OACA,YACA,gBACA,qBAA2B;AAE3B,MAAI,CAAC,MAAM,OACT,QAAO;EAIT,MAAM,iBAA0C,EAAE;AAClD,OAAK,MAAM,SAAS,MAAM,OACxB,KAAI,CAAC,eAAe,MAAM,SAAS,GACjC,gBAAe,MAAM,SAAS,KAAK,CAAC,MAAM;MAE1C,gBAAe,MAAM,SAAS,GAAG,KAAK,MAAM;AAIhD,SAAO,OAAO,OAAO,eAAe,CACjC,KAAK,WAAoB,UAAS;AACjC,UAAO,IAAI;wBACK,WAAU,GAAI,UAAU,GAAG,SAAS,EAAC,mBAAoB,MAAK;cACxE,KAAK,yBACL,WACA,YACA,gBACA,oBACD,CAAA;;;IAGL,CACD,SAAS,gBAAgB,YAAY;;CAGlC,yBACN,QACA,YACA,WACA,qBAA2B;AAG3B,SAAO,MACJ,QAAe,WAAkB,OAAO,OAAO,SAAS,EAAE,GAAG,OAAO,OAAO,SAAS,EAAE,CACxF;EAGD,MAAM,eAAe,aAAa,MAAM;AACxC,SAAO,IAAI,GAAG,OACZ,SACC,UAAU,eAAe,MAAM,MAAM,SACrC,OAAO,UAAS;GACf,MAAM,sBAAsB,KAAK,uBAAuB,MAAM,UAAU;GACxE,MAAM,qBAAqB,KAAK,sBAAsB,MAAM,SAAS;GACrE,MAAM,WAAW,MAAM,YAAY;GACnC,MAAM,eAAe,KAAK,gBAAgB,MAAM;GAChD,MAAM,UAAU,KAAK,kBAAkB,WAAW,YAAY,MAAM,OAAO;AAC3E,UAAO,IAAI;;uBAEI,UAAS,GAAI,WAAU,GAAI,MAAM,SAAS,EAAC,GAAI,MAAK;;;;sBAIrD,SAAS;IACf,yDAAyD,KAAK,IAC5D,oBAAoB,GACpB,oBAAoB,EACrB;IACD,8CAA8C,oBAAoB;IAClE,+CAA+C,oBAAoB;IACnE,4CAA4C,mBAAmB;IAC/D,6CAA6C,mBAAmB;IAChE,iDAAiD;IACjD,sDAAsD;IACvD,CAAC,CAAA;8BACc,qBACd,KAAK,eAAe,iBAAiB,CAAA;;mBAElC,QAAA;;qBAEE,MAAM,OAAA;qBACN,MAAM,KAAA;sBACL,MAAM,MAAA;iCACK,KAAK,gBAAA;4BACV,WAAA;2BACD,oBAAA;gCACK,UAAA;6BACH,MAAM,YAAA;8BACL,KAAK,kBAAA;gCACH,KAAK,cAAa;;;;IAK7C;;CAGK,8BACN,mBACA,gBACA,YACA,gBAAsB;AAEtB,MAAI,CAAC,kBAAmB,QAAO;AAE/B,SAAO,mBAAmB,KAAK,qBAAiC;GAC9D,MAAM,OAAO,iBAAiB,QAAQ;GACtC,MAAM,kBAAkB,iBAAiB,YAAY;GACrD,MAAM,qCACJ,KAAK,4BAA4B,QAAQ,iBAAiB,KAAM,KAAK;GACvE,MAAM,uBACJ,KAAK,iBAAiB,qCAClB,kBAAkB,KAClB;AAGN,OAAI,KAAK,gBAAgB,WAAW,mBAAmB,mBAAmB,KAAK,GAAG,GAChF,QAAO,KAAK,6BAA6B,kBAAkB,iBAAiB,eAAe;AAE7F,UAAO,KAAK,0BACV,kBACA,sBACA,gBACA,YACA,eACD;IACD;;;;;;;;;;;CAYI,0BACN,kBACA,UACA,gBACA,YACA,gBAAsB;EAKtB,MAAM,oBAAoB,iBAAiB,MAAM,QAAQ,QAAQ,KAAK;EACtE,MAAM,eAAe,iBAAiB,QAAQ,oBAAoB,iBAAiB,OAAO;EAC1F,MAAM,gBACJ,KAAK,0BAA0B,kBAAkB,eAAe,IAChE,iBAAiB;EACnB,MAAM,mBAAmB,iBAAiB,OACtC,uBAAuB,iBAAiB,MAAM,KAAK,UAAU,QAAQ,GACrE;EAEJ,MAAM,sBAAsB,KAAK,uBAC/B,iBAAiB,WACjB,gBACA,MACA,cACD;EAED,MAAM,qBAAqB,KAAK,sBAC9B,iBAAiB,UACjB,iBAAiB,WACjB,gBACA,KACD;EAGD,MAAM,YAAY,mBAAmB,eAAc,GAAI,WAAU,GAAI,mBAAmB,EAAC,GAAI,mBAAmB;EAChH,IAAI,kBAAkB;AAEtB,MAAI,iBAAiB,SAAS,MAAM,KAAK,oBAAoB,GAC3D,mBAAkB;WAElB,iBAAiB,SAAS,IAAI,iBAAiB,UAAU,MACzD,eAAe,IAAI,KAAK,kBAExB,mBAAkB;AAOpB,MAAI,oBAAoB,QAAQ;AAC9B,sBAAmB,KAAK,oBAAoB,iBAAiB,IAAI;AACjE,uBAAoB,KAAK;;AAE3B,SAAO,IAAI;;cAED,UAAS;iBACN,SAAS,EAAE,6CAA6C,iBAAiB,MAAM,CAAC,CAAA;gBACjF,SAAS;GACf,qCAAqC,oBAAoB;GACzD,sCAAsC,oBAAoB;GAC1D,mCAAmC,mBAAmB;GACtD,oCAAoC,mBAAmB;GACxD,CAAC,CAAA;mBACS,gBAAA;;;;UAIT,eACE,IAAI;;wBAEQ,SAAS;GACf,4CAA4C,oBAAoB;GAChE,yCAAyC,KAAK;GAC9C,2CAA2C;GAC5C,CAAC,CAAA;uBACK,aAAA;;;;;gBAMX,QAAA;;QAEJ,eAAe,KAAK,SAAS,WAAW,iBAAiB,GAAG,QAAA;;;CAI1D,6BACN,kBACA,UACA,gBAAgC;EAEhC,MAAM,sBAAsB,KAAK,uBAC/B,iBAAiB,WACjB,eACD;EACD,MAAM,qBAAqB,KAAK,sBAC9B,iBAAiB,UACjB,iBAAiB,WACjB,eACD;EAGD,MAAM,OACJ,iBAAiB,QAAQ,iBAAiB,KAAK,SAAS,cAAc,GAClE,iBAAiB,MAAM,OACrB,KACA,KAAK,iBAAiB,KAAK,uBAAuB,YACnD,GACD,iBAAiB;AAEvB,SAAO,IAAI;cACD,SAAS;GACf,wCAAwC,oBAAoB;GAC5D,yCAAyC,oBAAoB;GAC7D,sCAAsC,mBAAmB;GACzD,uCAAuC,mBAAmB;GAC1D,2CAA2C;GAC3C,2CAA2C;GAC5C,CAAC,CAAA;aACK,QAAQ,QAAA;;iBAEJ,KAAA;;;CAIP,4BACN,YACA,gBACA,iBAA+B;AAE/B,MAAI,CAAC,gBAAiB,QAAO;AAE7B,SAAO,iBAAiB,KAAK,mBAA+B;GAC1D,MAAM,mBAAmB,eAAe,OACpC,uBAAuB,eAAe,MAAM,KAAK,UAAU,QAAQ,GACnE;GACJ,MAAM,sBAAsB,KAAK,uBAAuB,eAAe,UAAU;GACjF,MAAM,qBAAqB,KAAK,sBAAsB,eAAe,SAAS;GAC9E,MAAM,kBAAkB,eAAe,YAAY;GACnD,MAAM,uBAAuB,KAAK,gBAAgB,kBAAkB,KAAK;GAGzE,MAAM,YAAY,mBAAmB,eAAc,GAAI,WAAU,GAAI,mBAAmB,EAAC,GAAI,mBAAmB;AAEhH,UAAO,IAAI;;gBAED,UAAS;kBACP,SAAS;IACf,wCAAwC,oBAAoB;IAC5D,yCAAyC,oBAAoB;IAC7D,sCAAsC,mBAAmB;IACzD,uCAAuC,mBAAmB;IAC1D,2CAA2C;IAC3C,2CAA2C;IAC5C,CAAC,CAAA;;iBAEK,eAAe,QAAQ,QAAA;;;;UAI9B,KAAK,SAAS,WAAW,iBAAiB,CAAA;;IAE9C;;;;;;;CAQI,eAAe,kBAA6C;EAClE,MAAM,gBAAgB,iBAAiB;AAEvC,OAAK,iCAAiC;AACtC,OAAK,uBAAuB;AAC5B,OAAK,oBAAoB;AAGzB,MAAI,CAAC,KAAK,8BACR,MAAK,gCAAgC;AAGvC,MAAI,CAAC,KAAK,mBAAmB;AAE3B,QAAK,oCAAoC,cAAc;AACvD,QAAK,kCAAkC,cAAc;;;CAIjD,kBAAkB,OAA0B;EAClD,MAAM,wBAAwB,MAAM;AAEpC,OAAK,uBAAuB;AAC5B,OAAK,iCAAiC;AACtC,OAAK,gCAAgC;AAErC,MAAI,0BAA0B,QAAQ,0BAA0B,KAAK,wBAAwB;AAC3F,QAAK,qBAAqB;AAC1B,QAAK,yBAAyB,sBAAsB;aAC3C,0BAA0B,KAAK,wBAAwB;AAChE,QAAK,4BAA4B;AACjC,QAAK,uBAAuB;;AAI9B,OAAK,eAAe;;CAGd,mBAAgB;AACtB,MAAI,CAAC,KAAK,+BACR,MAAK,uBAAuB;MAE5B,MAAK,kBAAkB,KAAK,kBAAkB;AAGhD,OAAK,kBAAkB;;;;;;;;CASjB,SACN,WACA,gBAA8C;AAE9C,SAAO,IAAI;8BACe,UAAS;+CACQ,eAAc;;;;;;;;CASnD,gBAAa;AACnB,OAAK,YACD,iBAAoC,6DAAkC,CACvE,SAAS,YAAY,QAAQ,OAAO,CAAC;;CAGlC,0BAA0B,WAAoB;AAEpD,MAAI,UAAU,SAAS,mBACrB,QAAO,uBAAuB,oBAAoB,KAAK,UAAU,QAAQ;AAG3E,MAAI,CAAC,UAAU,QAAQ,OACrB,QAAO,uBAAuB,+BAA+B,KAAK,UAAU,SAAS,CACnF,UAAU,GACX,CAAC;EAGJ,IAAI;EACJ,MAAM,mBAAmB,KAAK,+BAA+B,UAAU,gBAAiB;EACxF,MAAM,sBAAsB,KAAK,+BAA+B,UAAU,gBAAiB;AAE3F,0BAAwB,uBAAuB,uBAAuB,KAAK,UAAU,SAAS,CAC5F,UAAU,GACX,CAAC;AAEF,MAAI,CAAC,KAAK,eAAe;GAEvB,MAAM,aAAa,KAAK,mCAAmC,UAAU,OAAO;GAC5E,MAAM,gBAAgB,uBACpB,oCACA,KAAK,UAAU,SACf,CAAC,WAAW,OAAO,WAAW,SAAS,CACxC;AACD,2BAAwB,sBAAsB,OAAO,KAAK,CAAC,OAAO,cAAc,CAAC,OAAO,KAAK;;AAG/F,MAAI,CAAC,CAAC,oBAAoB,CAAC,CAAC,qBAAqB;AAC/C,4BACE,OAAO,uBAAuB,4BAA4B,KAAK,UAAU,QAAQ,GAAG;AACtF,4BAAyB,sBAAsB,OAAO,mBAAmB;;AAE3E,SAAO;;CAGD,+BAA+B,sBAAmC;EACxE,MAAM,qBAA+B,EAAE;AAEvC,SAAO,sBACH,KAAK,uBAAsB;GAC3B,MAAM,OAAO,mBAAmB;AAChC,OAAI,CAAC,KAAM,QAAO;GAElB,MAAM,0BAA0B,mBAAmB,QAAQ,KAAK,GAAG;GACnE,MAAM,cAAc,uBAClB,mBAAmB,MACnB,KAAK,UAAU,QAChB;GACD,MAAM,qBACJ,KAAK,4BAA4B,QAAQ,KAAK,KAAK,MACnD,KAAK,gBAAgB,QAAQ,KAAK,KAAK;AAEzC,OAAI,CAAC,wBACH,oBAAmB,KAAK,mBAAmB,KAAM;AAEnD,UAAO,CAAC,CAAC,eAAe,CAAC,2BAA2B,qBAAqB,cAAc;IACvF,CACD,QAAQ,gBAAgB,CAAC,CAAC,YAAY,CACtC,KAAK,KAAK"}