@sbb-esta/lyne-elements 4.8.1 → 4.10.0

package/development/calendar.component-6p9vsp-V.js

@@ -0,0 +1,1452 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, nothing, unsafeCSS } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SbbElement } from "./core/base-elements.js";
+import { forceType, handleDistinctChange, plainDate } from "./core/decorators.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { SbbSecondaryButtonElement } from "./button.pure.js";
+import { SbbLanguageController, SbbMediaMatcherController, SbbMediaQueryBreakpointLargeAndAbove } from "./core/controllers.js";
+import { i18nCalendarDateSelection, i18nCalendarWeekNumber, i18nNextMonth, i18nNextYear, i18nNextYearRange, i18nPreviousMonth, i18nPreviousYear, i18nPreviousYearRange, i18nYearMonthSelection } from "./core/i18n.js";
+import "./icon.js";
+import { isArrowKeyOrPageKeysPressed } from "./core/a11y.js";
+import { readConfig } from "./core/config.js";
+import { DAYS_PER_ROW, MONDAY, MONTHS_PER_PAGE, MONTHS_PER_ROW, THURSDAY, TUESDAY, WEDNESDAY, YEARS_PER_PAGE, YEARS_PER_ROW, defaultDateAdapter } from "./core/datetime.js";
+import { SbbCalendarDayElement } from "./calendar/calendar-day/calendar-day.component.js";
+import { SbbCalendarMonthElement } from "./calendar/calendar-month/calendar-month.component.js";
+import { SbbCalendarWeekdayElement } from "./calendar/calendar-weekday/calendar-weekday.component.js";
+import { SbbCalendarWeeknumberElement } from "./calendar/calendar-weeknumber/calendar-weeknumber.component.js";
+import { SbbCalendarYearElement } from "./calendar/calendar-year/calendar-year.component.js";
+import "./screen-reader-only.js";
+//#region src/elements/calendar/calendar/calendar.scss?inline
+var calendar_default = ":host {\n  display: block;\n  width: max-content;\n  --sbb-calendar-cell-size: 2.75rem;\n  --sbb-calendar-cell-border-radius: calc(\n    var(--sbb-border-radius-4x) + var(--sbb-calendar-cell-border-width)\n  );\n  --sbb-calendar-cell-transition-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-2x)\n  );\n}\n@media (min-width: calc(37.5rem)) {\n  :host {\n    --sbb-calendar-control-view-change-height: 3rem;\n  }\n}\n\n:host(:is(:state(enhanced),[state--enhanced])) {\n  --sbb-calendar-cell-padding-block-end: var(--sbb-spacing-fixed-3x);\n}\n\n.sbb-calendar__wrapper {\n  width: 100%;\n  display: block;\n  transition-duration: var(--sbb-calendar-cell-transition-duration);\n}\n\n.sbb-calendar__controls {\n  width: 100%;\n  display: inline-flex;\n  align-items: center;\n  gap: var(--sbb-calendar-control-gap);\n  margin-block-end: var(--sbb-calendar-control-margin-block-end);\n}\n\n.sbb-calendar__controls-month {\n  width: 100%;\n  display: flex;\n  gap: var(--sbb-calendar-tables-gap);\n}\n\n#sbb-calendar__controls-previous,\n#sbb-calendar__controls-next {\n  -webkit-tap-highlight-color: transparent;\n}\n\n.sbb-calendar__controls-change-date {\n  appearance: none;\n  box-sizing: border-box;\n  margin: 0;\n  outline: none;\n  border: none;\n  border-radius: 0;\n  padding: 0;\n  background: none;\n  -webkit-tap-highlight-color: transparent;\n  color: inherit;\n  display: flex;\n  align-items: center;\n  margin: auto;\n  height: var(--sbb-calendar-control-view-change-height);\n  font-size: var(--sbb-text-font-size-s);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  text-transform: capitalize;\n  cursor: var(--sbb-cursor-pointer);\n  padding-inline: var(--sbb-calendar-control-view-change-padding-inline);\n  border-radius: var(--sbb-border-radius-infinity);\n  background-color: var(--sbb-calendar-control-view-change-background);\n  color: var(--sbb-calendar-control-view-change-color);\n  transition-duration: var(--sbb-calendar-cell-transition-duration);\n  transition-timing-function: var(--sbb-calendar-cell-transition-easing-function);\n  transition-property: background-color, padding-block-end;\n}\n.sbb-calendar__controls-change-date:disabled {\n  --sbb-calendar-control-view-change-background: var(--sbb-color-milk);\n  --sbb-calendar-control-view-change-background: light-dark(\n    var(--sbb-color-milk),\n    var(--sbb-color-anthracite)\n  );\n  --sbb-calendar-control-view-change-color: var(--sbb-color-granite);\n  --sbb-calendar-control-view-change-color: light-dark(\n    var(--sbb-color-granite),\n    var(--sbb-color-aluminium)\n  );\n  cursor: unset;\n}\n.sbb-calendar__controls-change-date:focus-visible {\n  outline-offset: var(--sbb-focus-outline-offset);\n  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);\n  outline-offset: var(--sbb-spacing-fixed-1x);\n}\n@media (any-hover: hover) {\n  .sbb-calendar__controls-change-date:not(:active, :disabled):hover {\n    padding-block-end: var(--sbb-calendar-cell-hover-shift);\n  }\n}\n.sbb-calendar__controls-change-date:not(:disabled):active {\n  --sbb-calendar-control-view-change-background: var(--sbb-background-color-3);\n}\n\n.sbb-calendar__table-month-view,\n.sbb-calendar__table-year-view {\n  --sbb-calendar-table-column-spaces: 6;\n}\n\n.sbb-calendar__table-overflow-break {\n  contain: layout;\n}\n\n.sbb-calendar__table-container {\n  display: flex;\n  gap: var(--sbb-calendar-tables-gap);\n  margin-inline: var(--sbb-calendar-margin);\n  --sbb-calendar-min-width: calc(7 * var(--sbb-calendar-cell-size));\n  --sbb-calendar-overflow: calc(100% - var(--sbb-calendar-min-width));\n  --sbb-calendar-start-offset: min(\n    0px,\n    -1 * (var(--sbb-calendar-overflow) / var(--sbb-calendar-table-column-spaces))\n  );\n  --sbb-calendar-margin: var(--sbb-calendar-start-offset);\n}\n:host(:is(:state(wide),[state--wide])) .sbb-calendar__table-container {\n  --sbb-calendar-min-width: calc(\n    2 * 7 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)\n  );\n  --sbb-calendar-margin: calc(0.5 * var(--sbb-calendar-start-offset));\n}\n:host([orientation=horizontal][week-numbers]) .sbb-calendar__table-container {\n  --sbb-calendar-min-width: calc(8 * var(--sbb-calendar-cell-size));\n}\n:host([orientation=horizontal][week-numbers]:is(:state(wide),[state--wide])) .sbb-calendar__table-container {\n  --sbb-calendar-min-width: calc(\n    2 * 8 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)\n  );\n}\n:host([orientation=vertical]) .sbb-calendar__table-container {\n  min-width: var(--sbb-calendar-min-width);\n  --sbb-calendar-start-offset: 0;\n}\n:host([orientation=vertical]:is(:state(wide),[state--wide])) .sbb-calendar__table-container {\n  --sbb-calendar-min-width: calc(\n    13 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)\n  );\n}\n\n.sbb-calendar__table {\n  width: 100%;\n  border-collapse: collapse;\n  height: max-content;\n  animation-name: show;\n  animation-duration: var(--sbb-calendar-table-animation-duration);\n}\n.sbb-calendar__table.sbb-calendar__table-hide {\n  --sbb-calendar-cell-transition-duration: 0ms;\n  animation-name: hide;\n  animation-duration: var(--sbb-calendar-table-animation-duration);\n}\n:host(:not(:is(:state(wide),[state--wide]))) .sbb-calendar__table {\n  min-width: 100%;\n}\n\n.sbb-calendar__table-header {\n  text-align: center;\n}\n\n.sbb-calendar__table-body {\n  text-align: center;\n}\n\n.sbb-calendar__table-header-cell,\n.sbb-calendar__table-header-cell-vertical {\n  width: var(--sbb-calendar-cell-size);\n  color: var(--sbb-calendar-header-color);\n  padding: 0;\n  font-size: var(--sbb-text-font-size-xs);\n  font-weight: normal;\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n}\n:host(:not([multiple])) .sbb-calendar__table-header-cell,\n:host(:not([multiple])) .sbb-calendar__table-header-cell-vertical {\n  height: var(--sbb-calendar-cell-size);\n}\n\n.sbb-calendar__table-header-cell-vertical {\n  padding-block-end: var(--sbb-calendar-cell-padding-block-end);\n}\n\n.sbb-calendar__table-data {\n  position: relative;\n  padding: 0;\n  text-align: center;\n}\n\n.sbb-calendar__day-cell {\n  padding-block-end: var(--sbb-calendar-cell-padding-block-end);\n}\n\n:host(:not(:is(:state(enhanced),[state--enhanced]))) sbb-calendar-day {\n  --sbb-calendar-cell-justify-content: center;\n  --sbb-calendar-day-height: 2.75rem;\n  --sbb-calendar-day-extra-display: none;\n  --sbb-calendar-day-value-height: unset;\n  --sbb-calendar-day-crossed-out-top: 50%;\n  --sbb-calendar-day-crossed-out-translate: translate(-50%, -50%) rotate(-45deg);\n}\n\n@keyframes show {\n  from {\n    opacity: 0;\n    transform: translateY(var(--sbb-calendar-table-animation-shift));\n  }\n  to {\n    opacity: 1;\n    transform: translateY(0%);\n  }\n}\n@keyframes hide {\n  from {\n    opacity: 1;\n    transform: translateY(0%);\n  }\n  to {\n    opacity: 0;\n    transform: translateY(var(--sbb-calendar-table-animation-shift));\n  }\n}";
+//#endregion
+//#region src/elements/calendar/calendar/calendar.component.ts
+SbbSecondaryButtonElement.define();
+SbbCalendarDayElement.define();
+SbbCalendarMonthElement.define();
+SbbCalendarYearElement.define();
+SbbCalendarWeekdayElement.define();
+SbbCalendarWeeknumberElement.define();
+var SbbMonthChangeEvent = class extends Event {
+	get range() {
+		return this._range;
+	}
+	constructor(range) {
+		super("monthchange", {
+			bubbles: true,
+			composed: true
+		});
+		this._range = Object.freeze(range || []);
+	}
+};
+/**
+* It displays a calendar which allows choosing a date.
+*
+* @slot - Use the unnamed slot to add customized `sbb-calendar-day` elements.
+*/
+var SbbCalendarElement = (() => {
+	let _classSuper = SbbElement;
+	let _instanceExtraInitializers = [];
+	let _wide_decorators;
+	let _wide_initializers = [];
+	let _wide_extraInitializers = [];
+	let _view_decorators;
+	let _view_initializers = [];
+	let _view_extraInitializers = [];
+	let _min_decorators;
+	let _min_initializers = [];
+	let _min_extraInitializers = [];
+	let _max_decorators;
+	let _max_initializers = [];
+	let _max_extraInitializers = [];
+	let _multiple_decorators;
+	let _multiple_initializers = [];
+	let _multiple_extraInitializers = [];
+	let _set_selected_decorators;
+	let __selected_decorators;
+	let __selected_initializers = [];
+	let __selected_extraInitializers = [];
+	let _dateFilter_decorators;
+	let _dateFilter_initializers = [];
+	let _dateFilter_extraInitializers = [];
+	let _orientation_decorators;
+	let _orientation_initializers = [];
+	let _orientation_extraInitializers = [];
+	let _weekNumbers_decorators;
+	let _weekNumbers_initializers = [];
+	let _weekNumbers_extraInitializers = [];
+	let __activeDate_decorators;
+	let __activeDate_initializers = [];
+	let __activeDate_extraInitializers = [];
+	let _set__wide_decorators;
+	let __calendarView_decorators;
+	let __calendarView_initializers = [];
+	let __calendarView_extraInitializers = [];
+	let __initialized_decorators;
+	let __initialized_initializers = [];
+	let __initialized_extraInitializers = [];
+	return class SbbCalendarElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_wide_decorators = [forceType(), property({ type: Boolean })];
+			_view_decorators = [property()];
+			_min_decorators = [plainDate(), property()];
+			_max_decorators = [plainDate(), property()];
+			_multiple_decorators = [
+				forceType(),
+				handleDistinctChange((e, newValue) => e._onMultipleChanged(newValue)),
+				property({ type: Boolean })
+			];
+			_set_selected_decorators = [property()];
+			__selected_decorators = [state()];
+			_dateFilter_decorators = [property({ attribute: "date-filter" })];
+			_orientation_decorators = [property({ reflect: true })];
+			_weekNumbers_decorators = [forceType(), property({
+				attribute: "week-numbers",
+				type: Boolean
+			})];
+			__activeDate_decorators = [state()];
+			_set__wide_decorators = [state()];
+			__calendarView_decorators = [state()];
+			__initialized_decorators = [state()];
+			__esDecorate(this, null, _wide_decorators, {
+				kind: "accessor",
+				name: "wide",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "wide" in obj,
+					get: (obj) => obj.wide,
+					set: (obj, value) => {
+						obj.wide = value;
+					}
+				},
+				metadata: _metadata
+			}, _wide_initializers, _wide_extraInitializers);
+			__esDecorate(this, null, _view_decorators, {
+				kind: "accessor",
+				name: "view",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "view" in obj,
+					get: (obj) => obj.view,
+					set: (obj, value) => {
+						obj.view = value;
+					}
+				},
+				metadata: _metadata
+			}, _view_initializers, _view_extraInitializers);
+			__esDecorate(this, null, _min_decorators, {
+				kind: "accessor",
+				name: "min",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "min" in obj,
+					get: (obj) => obj.min,
+					set: (obj, value) => {
+						obj.min = value;
+					}
+				},
+				metadata: _metadata
+			}, _min_initializers, _min_extraInitializers);
+			__esDecorate(this, null, _max_decorators, {
+				kind: "accessor",
+				name: "max",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "max" in obj,
+					get: (obj) => obj.max,
+					set: (obj, value) => {
+						obj.max = value;
+					}
+				},
+				metadata: _metadata
+			}, _max_initializers, _max_extraInitializers);
+			__esDecorate(this, null, _multiple_decorators, {
+				kind: "accessor",
+				name: "multiple",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "multiple" in obj,
+					get: (obj) => obj.multiple,
+					set: (obj, value) => {
+						obj.multiple = value;
+					}
+				},
+				metadata: _metadata
+			}, _multiple_initializers, _multiple_extraInitializers);
+			__esDecorate(this, null, _set_selected_decorators, {
+				kind: "setter",
+				name: "selected",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "selected" in obj,
+					set: (obj, value) => {
+						obj.selected = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, __selected_decorators, {
+				kind: "accessor",
+				name: "_selected",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_selected" in obj,
+					get: (obj) => obj._selected,
+					set: (obj, value) => {
+						obj._selected = value;
+					}
+				},
+				metadata: _metadata
+			}, __selected_initializers, __selected_extraInitializers);
+			__esDecorate(this, null, _dateFilter_decorators, {
+				kind: "accessor",
+				name: "dateFilter",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "dateFilter" in obj,
+					get: (obj) => obj.dateFilter,
+					set: (obj, value) => {
+						obj.dateFilter = value;
+					}
+				},
+				metadata: _metadata
+			}, _dateFilter_initializers, _dateFilter_extraInitializers);
+			__esDecorate(this, null, _orientation_decorators, {
+				kind: "accessor",
+				name: "orientation",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "orientation" in obj,
+					get: (obj) => obj.orientation,
+					set: (obj, value) => {
+						obj.orientation = value;
+					}
+				},
+				metadata: _metadata
+			}, _orientation_initializers, _orientation_extraInitializers);
+			__esDecorate(this, null, _weekNumbers_decorators, {
+				kind: "accessor",
+				name: "weekNumbers",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "weekNumbers" in obj,
+					get: (obj) => obj.weekNumbers,
+					set: (obj, value) => {
+						obj.weekNumbers = value;
+					}
+				},
+				metadata: _metadata
+			}, _weekNumbers_initializers, _weekNumbers_extraInitializers);
+			__esDecorate(this, null, __activeDate_decorators, {
+				kind: "accessor",
+				name: "_activeDate",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_activeDate" in obj,
+					get: (obj) => obj._activeDate,
+					set: (obj, value) => {
+						obj._activeDate = value;
+					}
+				},
+				metadata: _metadata
+			}, __activeDate_initializers, __activeDate_extraInitializers);
+			__esDecorate(this, null, _set__wide_decorators, {
+				kind: "setter",
+				name: "_wide",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_wide" in obj,
+					set: (obj, value) => {
+						obj._wide = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, __calendarView_decorators, {
+				kind: "accessor",
+				name: "_calendarView",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_calendarView" in obj,
+					get: (obj) => obj._calendarView,
+					set: (obj, value) => {
+						obj._calendarView = value;
+					}
+				},
+				metadata: _metadata
+			}, __calendarView_initializers, __calendarView_extraInitializers);
+			__esDecorate(this, null, __initialized_decorators, {
+				kind: "accessor",
+				name: "_initialized",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_initialized" in obj,
+					get: (obj) => obj._initialized,
+					set: (obj, value) => {
+						obj._initialized = value;
+					}
+				},
+				metadata: _metadata
+			}, __initialized_initializers, __initialized_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-calendar";
+		}
+		static {
+			this.styles = [boxSizingStyles, unsafeCSS(calendar_default)];
+		}
+		static {
+			this.events = {
+				dateselected: "dateselected",
+				monthchange: "monthchange"
+			};
+		}
+		#wide_accessor_storage;
+		/** If set to true, two months are displayed */
+		get wide() {
+			return this.#wide_accessor_storage;
+		}
+		set wide(value) {
+			this.#wide_accessor_storage = value;
+		}
+		#view_accessor_storage;
+		/** The initial view of the calendar which should be displayed on opening. */
+		get view() {
+			return this.#view_accessor_storage;
+		}
+		set view(value) {
+			this.#view_accessor_storage = value;
+		}
+		#min_accessor_storage;
+		/**
+		* The minimum valid date. Accepts a date object or null.
+		* Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.
+		*/
+		get min() {
+			return this.#min_accessor_storage;
+		}
+		set min(value) {
+			this.#min_accessor_storage = value;
+		}
+		#max_accessor_storage;
+		/**
+		* The maximum valid date. Accepts a date object or null.
+		* Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.
+		*/
+		get max() {
+			return this.#max_accessor_storage;
+		}
+		set max(value) {
+			this.#max_accessor_storage = value;
+		}
+		#multiple_accessor_storage;
+		/** Whether the calendar allows for multiple date selection. */
+		get multiple() {
+			return this.#multiple_accessor_storage;
+		}
+		set multiple(value) {
+			this.#multiple_accessor_storage = value;
+		}
+		/**
+		* The selected date: accepts a date object, or, if `multiple`, an array of dates.
+		*/
+		set selected(value) {
+			if (Array.isArray(value)) this._selected = value.map((dateLike) => this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(dateLike))).filter((date) => date !== null).filter((date) => !this._isDayInRange(this._dateAdapter.toIso8601(date)) || this._dateFilter(date));
+			else {
+				const selectedDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+				if (!!selectedDate && (!this._isDayInRange(this._dateAdapter.toIso8601(selectedDate)) || this._dateFilter(selectedDate))) this._selected = selectedDate;
+				else this._selected = null;
+			}
+		}
+		get selected() {
+			return this._selected;
+		}
+		#_selected_accessor_storage;
+		get _selected() {
+			return this.#_selected_accessor_storage;
+		}
+		set _selected(value) {
+			this.#_selected_accessor_storage = value;
+		}
+		#dateFilter_accessor_storage;
+		/** A function used to filter out dates. */
+		get dateFilter() {
+			return this.#dateFilter_accessor_storage;
+		}
+		set dateFilter(value) {
+			this.#dateFilter_accessor_storage = value;
+		}
+		#orientation_accessor_storage;
+		/** The orientation of days in the calendar. */
+		get orientation() {
+			return this.#orientation_accessor_storage;
+		}
+		set orientation(value) {
+			this.#orientation_accessor_storage = value;
+		}
+		#weekNumbers_accessor_storage;
+		/** Whether it has to display the week numbers in addition to week days. */
+		get weekNumbers() {
+			return this.#weekNumbers_accessor_storage;
+		}
+		set weekNumbers(value) {
+			this.#weekNumbers_accessor_storage = value;
+		}
+		#_activeDate_accessor_storage;
+		/** The currently active date. */
+		get _activeDate() {
+			return this.#_activeDate_accessor_storage;
+		}
+		set _activeDate(value) {
+			this.#_activeDate_accessor_storage = value;
+		}
+		/** The current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */
+		set _wide(wide) {
+			this.toggleState("wide", wide);
+			this._wideInternal = wide;
+		}
+		get _wide() {
+			return this._wideInternal;
+		}
+		#_calendarView_accessor_storage;
+		get _calendarView() {
+			return this.#_calendarView_accessor_storage;
+		}
+		set _calendarView(value) {
+			this.#_calendarView_accessor_storage = value;
+		}
+		/** A list of calendar's cells corresponding to days, months or years depending on the view. */
+		get _cells() {
+			return Array.from((this._calendarView === "day" ? Array.from(this.shadowRoot.querySelectorAll("slot")).flatMap((e) => e.assignedElements({ flatten: true })) : this.shadowRoot?.querySelectorAll(`sbb-calendar-${this._calendarView}`)) ?? []);
+		}
+		#_initialized_accessor_storage;
+		get _initialized() {
+			return this.#_initialized_accessor_storage;
+		}
+		set _initialized(value) {
+			this.#_initialized_accessor_storage = value;
+		}
+		constructor() {
+			super();
+			this.#wide_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _wide_initializers, false));
+			this.#view_accessor_storage = (__runInitializers(this, _wide_extraInitializers), __runInitializers(this, _view_initializers, "day"));
+			this.#min_accessor_storage = (__runInitializers(this, _view_extraInitializers), __runInitializers(this, _min_initializers, null));
+			this.#max_accessor_storage = (__runInitializers(this, _min_extraInitializers), __runInitializers(this, _max_initializers, null));
+			this.#multiple_accessor_storage = (__runInitializers(this, _max_extraInitializers), __runInitializers(this, _multiple_initializers, false));
+			this.#_selected_accessor_storage = (__runInitializers(this, _multiple_extraInitializers), __runInitializers(this, __selected_initializers, null));
+			this.#dateFilter_accessor_storage = (__runInitializers(this, __selected_extraInitializers), __runInitializers(this, _dateFilter_initializers, null));
+			this.#orientation_accessor_storage = (__runInitializers(this, _dateFilter_extraInitializers), __runInitializers(this, _orientation_initializers, "horizontal"));
+			this.#weekNumbers_accessor_storage = (__runInitializers(this, _orientation_extraInitializers), __runInitializers(this, _weekNumbers_initializers, false));
+			this._dateAdapter = (__runInitializers(this, _weekNumbers_extraInitializers), readConfig().datetime?.dateAdapter ?? defaultDateAdapter);
+			this.#_activeDate_accessor_storage = __runInitializers(this, __activeDate_initializers, this._dateAdapter.today());
+			this._wideInternal = (__runInitializers(this, __activeDate_extraInitializers), false);
+			this.#_calendarView_accessor_storage = __runInitializers(this, __calendarView_initializers, "day");
+			this._nextCalendarView = (__runInitializers(this, __calendarView_extraInitializers), "day");
+			/** Information about the rendered day view; used in keyboard navigation. */
+			this._keyboardNavigationDayViewParameters = {
+				firstDayInView: null,
+				lastDayInView: null,
+				firstMonthOffset: 0,
+				firstMonthLength: 0,
+				secondMonthOffset: 0
+			};
+			/** Grid of calendar cells representing the dates of the month. */
+			this._weeks = [];
+			/** An array containing all the month names in the current language. */
+			this._monthNames = this._dateAdapter.getMonthNames("long");
+			this._enhancedVariant = false;
+			/** Whether the focus should be reset on focusCell. */
+			this._resetFocus = false;
+			/** Whether an element inside the calendar is currently focused. */
+			this._containingFocus = false;
+			this.#_initialized_accessor_storage = __runInitializers(this, __initialized_initializers, false);
+			this._language = (__runInitializers(this, __initialized_extraInitializers), new SbbLanguageController(this).withHandler(() => {
+				this._monthNames = this._dateAdapter.getMonthNames("long");
+				this._createMonthRows();
+			}));
+			this._mediaMatcher = new SbbMediaMatcherController(this, { [SbbMediaQueryBreakpointLargeAndAbove]: () => this._init() });
+			this._onSlotChange = () => {
+				this._enhancedVariant = Array.from(this.children).some((c) => c.localName === "sbb-calendar-day");
+				this.toggleState("enhanced", this._enhancedVariant);
+				this._setTabIndex();
+			};
+			this._createMonthRows();
+			this._setWeekdays();
+			this.addEventListener("focusin", () => this._containingFocus = true);
+			this.addEventListener("focusout", () => this._containingFocus = false);
+			this.addEventListener("click", (e) => {
+				const day = e.target.closest("sbb-calendar-day");
+				if (day) this._selectDate(day.value);
+			});
+			this.addEventListener("keydown", (e) => {
+				if (e.target.localName === "sbb-calendar-day") this._handleKeyboardEvent(e, this._mapDateToDay(e.target.value));
+			});
+		}
+		_dateFilter(date) {
+			return this.dateFilter?.(date) ?? true;
+		}
+		/** Resets the active month according to the new state of the calendar. */
+		resetPosition() {
+			this._resetCalendarView();
+			this._init();
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.resetPosition();
+			this.shadowRoot?.addEventListener("slotchange", this._onSlotChange, { capture: true });
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this.shadowRoot?.removeEventListener("slotchange", this._onSlotChange, { capture: true });
+		}
+		/** @internal */
+		focus() {
+			this._resetFocus = true;
+			this._focusCell();
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (!this._initialized) return;
+			if (changedProperties.has("wide") || changedProperties.has("orientation")) this.resetPosition();
+			if (changedProperties.has("view")) {
+				this._setChosenYear();
+				this._chosenMonth = void 0;
+				this._nextCalendarView = this._calendarView = this.view;
+			}
+		}
+		updated(changedProperties) {
+			super.updated(changedProperties);
+			this._setTabIndex();
+			this._focusCell();
+		}
+		/**
+		* The `_selected` state should be adapted when the `multiple` property changes:
+		*   - if it changes to true, the '_selected' is set to an array;
+		*   - if it changes to false, the first available option is set as 'value' otherwise it's set to null.
+		*/
+		_onMultipleChanged(isMultiple) {
+			if (isMultiple && !Array.isArray(this._selected)) this._selected = this._selected ? [this._selected] : [];
+			if (!isMultiple && Array.isArray(this._selected)) this._selected = this._selected.length ? this._selected[0] : null;
+		}
+		/** Initializes the component. */
+		_init(activeDate) {
+			if (isServer) return;
+			else if (this.hydrationRequired) {
+				this.hydrationComplete.then(() => this._init());
+				return;
+			}
+			if (activeDate) this._assignActiveDate(activeDate);
+			this._wide = (this._mediaMatcher.matches(SbbMediaQueryBreakpointLargeAndAbove) ?? false) && this.wide;
+			this._weeks = this._createWeekRows(this._activeDate);
+			this._years = this._createYearRows();
+			this._weekNumbers = this._weeks.flat().sort((a, b) => a.value.localeCompare(b.value)).map((day) => day.weekValue).filter((v, i, a) => a.indexOf(v) === i);
+			this._nextMonthWeeks = [[]];
+			this._nextMonthYears = [[]];
+			if (this._wide) {
+				const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);
+				this._nextMonthWeeks = this._createWeekRows(nextMonthDate, true);
+				this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);
+				this._nextMonthWeekNumbers = this._nextMonthWeeks.flat().sort((a, b) => a.value.localeCompare(b.value)).map((day) => day.weekValue).filter((v, i, a) => a.indexOf(v) === i);
+			}
+			this._initialized = true;
+		}
+		/** Focuses on a day cell prioritizing the selected day, the current day, and lastly, the first selectable day. */
+		_focusCell() {
+			if (this._resetFocus) {
+				this._getFirstFocusable()?.focus();
+				this._resetFocus = false;
+			}
+		}
+		/** Creates the array of weekdays. */
+		_setWeekdays() {
+			const narrowWeekdays = this._dateAdapter.getDayOfWeekNames("narrow");
+			const weekdays = this._dateAdapter.getDayOfWeekNames("long").map((long, i) => ({
+				long,
+				narrow: narrowWeekdays[i]
+			}));
+			const firstDayOfWeek = this._dateAdapter.getFirstDayOfWeek();
+			this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));
+		}
+		/** Creates the rows along the horizontal direction and sets the parameters used in keyboard navigation. */
+		_createWeekRows(value, isSecondMonthInView = false) {
+			const daysInMonth = this._dateAdapter.getNumDaysInMonth(value);
+			const weekOffset = this._dateAdapter.getFirstWeekOffset(value);
+			if (!isSecondMonthInView) {
+				this._keyboardNavigationDayViewParameters.firstMonthLength = daysInMonth;
+				this._keyboardNavigationDayViewParameters.firstMonthOffset = weekOffset;
+				this._keyboardNavigationDayViewParameters.firstDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), 1));
+				this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), daysInMonth));
+			} else {
+				this._keyboardNavigationDayViewParameters.secondMonthOffset = weekOffset;
+				this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), daysInMonth));
+			}
+			return this.orientation === "horizontal" ? this._createWeekRowsHorizontal(value, daysInMonth, weekOffset) : this._createWeekRowsVertical(value, daysInMonth, weekOffset);
+		}
+		/**
+		* Creates the rows for each week in orientation='horizontal'.
+		*
+		* Iterates through the days of the months, creates a Day object for each and pushes it into and array.
+		* Each seven days (considering the offset at the beginning of the month) restarts from an empty array.
+		*
+		* The result is a matrix in which every row is a week (or part of it, considering offset).
+		*/
+		_createWeekRowsHorizontal(value, daysInMonth, weekOffset) {
+			const weeks = [[]];
+			for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {
+				if (cell === DAYS_PER_ROW) {
+					weeks.push([]);
+					cell = 0;
+				}
+				const date = this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), i + 1);
+				weeks[weeks.length - 1].push(this._mapDateToDay(date));
+			}
+			return weeks;
+		}
+		/**
+		* Creates the rows for each week in orientation='vertical'.
+		*
+		* Creates a matrix with seven empty rows.
+		* Iterates through the days of the months, creates a Day object for each
+		* and pushes it into the correct array considering the offset at the beginning of the month.
+		* Each seven days (including offset) restarts from the first.
+		*
+		* The result is a matrix in which every row is a set of weekdays, so:
+		* - row 0: all the Mondays;
+		* - row 1: all the Tuesdays;
+		* - ...
+		* - row 7: all the Sundays.
+		*/
+		_createWeekRowsVertical(value, daysInMonth, weekOffset) {
+			const weeks = Array.from({ length: DAYS_PER_ROW }, () => []);
+			for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {
+				if (cell === DAYS_PER_ROW) cell = 0;
+				const date = this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), i + 1);
+				weeks[cell].push(this._mapDateToDay(date));
+			}
+			return weeks;
+		}
+		_mapDateToDay(date) {
+			return {
+				value: this._dateAdapter.toIso8601(date),
+				dateValue: date,
+				dayValue: String(this._dateAdapter.getDate(date)),
+				monthValue: String(this._dateAdapter.getMonth(date)),
+				yearValue: String(this._dateAdapter.getYear(date)),
+				weekValue: this._getWeek(date),
+				weekDayValue: this._dateAdapter.getDayOfWeek(date)
+			};
+		}
+		_getWeek(date) {
+			const firstDayOfYear = this._dateAdapter.createDate(this._dateAdapter.getYear(date), 1, 1);
+			const weekday = this._dateAdapter.getDayOfWeek(firstDayOfYear);
+			let weekIndex = [
+				MONDAY,
+				TUESDAY,
+				WEDNESDAY,
+				THURSDAY
+			].includes(weekday) ? 1 : 0;
+			let weekStart = this._dateAdapter.addCalendarDays(firstDayOfYear, this._dateAdapter.getFirstWeekOffset(firstDayOfYear) * -1);
+			while (this._dateAdapter.compareDate(weekStart, date) <= 0) {
+				const weekEnd = this._dateAdapter.addCalendarDays(weekStart, 6);
+				if (this._dateAdapter.compareDate(date, weekEnd) <= 0) return weekIndex > 0 ? weekIndex : this._getWeek(this._dateAdapter.addCalendarDays(firstDayOfYear, -1));
+				weekStart = this._dateAdapter.addCalendarDays(weekStart, DAYS_PER_ROW);
+				weekIndex++;
+			}
+			throw new Error("The provided date is invalid");
+		}
+		/** Force the conversion to ISO8601 formatted string. */
+		_mapValueToISODate(value) {
+			return typeof value === "string" ? value : this._dateAdapter.toIso8601(value);
+		}
+		/** Creates the rows for the month selection view. */
+		_createMonthRows() {
+			const months = new Array(12).fill(null).map((_, i) => ({
+				value: String(i + 1).padStart(2, "0"),
+				monthValue: i + 1
+			}));
+			const rows = 12 / MONTHS_PER_ROW;
+			const monthArray = [];
+			for (let i = 0; i < rows; i++) monthArray.push(months.slice(MONTHS_PER_ROW * i, MONTHS_PER_ROW * (i + 1)));
+			this._months = monthArray;
+		}
+		/** Creates the rows for the year selection view. */
+		_createYearRows(offset = 0) {
+			const startValueYearView = this._getStartValueYearView();
+			const allYears = new Array(YEARS_PER_PAGE).fill(0).map((_, i) => startValueYearView + offset + i);
+			const rows = YEARS_PER_PAGE / YEARS_PER_ROW;
+			const yearArray = [];
+			for (let i = 0; i < rows; i++) yearArray.push(allYears.slice(YEARS_PER_ROW * i, YEARS_PER_ROW * (i + 1)));
+			return yearArray;
+		}
+		/**
+		* Calculates the first year that will be shown in the year selection panel.
+		* If `minDate` and `maxDate` are both null, the starting year is calculated as
+		* the multiple of YEARS_PER_PAGE closest to and less than activeDate,
+		* e.g., with `YEARS_PER_PAGE` = 24 and `activeDate` = 2020, the function will return 2016 (24 * 83),
+		* while with `activeDate` = 2000, the function will return 1992 (24 * 82).
+		* If `minDate` is not null, it returns the corresponding year; if `maxDate` is not null,
+		* it returns the corresponding year minus `YEARS_PER_PAGE`, so that the `maxDate` is the last rendered year.
+		* If both are not null, `maxDate` has priority over `minDate`.
+		*/
+		_getStartValueYearView() {
+			let startingYear = 0;
+			if (this.max) startingYear = this._dateAdapter.getYear(this.max) - YEARS_PER_PAGE + 1;
+			else if (this.min) startingYear = this._dateAdapter.getYear(this.min);
+			const activeYear = this._dateAdapter.getYear(this._activeDate);
+			return activeYear - ((activeYear - startingYear) % YEARS_PER_PAGE + YEARS_PER_PAGE) % YEARS_PER_PAGE;
+		}
+		/** Checks if date is within the min-max range. */
+		_isDayInRange(dateString) {
+			if (!this.min && !this.max) return true;
+			const date = this._dateAdapter.deserialize(dateString);
+			return this._dateAdapter.sameDate(date, this._dateAdapter.clampDate(date, this.min, this.max));
+		}
+		/** Emits the selected date and sets it internally. */
+		_selectDate(day) {
+			this._chosenMonth = void 0;
+			this._setChosenYear();
+			if (this.multiple) {
+				if (this._selected && this._selected.length > 0) {
+					const indexOfSelectedDay = this._selected.findIndex((sel) => this._dateAdapter.compareDate(sel, day) === 0);
+					if (indexOfSelectedDay !== -1) this._selected = this._selected.filter((_, i) => i !== indexOfSelectedDay);
+					else this._selected = [...this._selected, day];
+				} else this._selected = [day];
+				this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)));
+			} else if (!this._selected || this._dateAdapter.compareDate(this._selected, day) !== 0) {
+				this._selected = day;
+				this._emitDateSelectedEvent(this._dateAdapter.deserialize(day));
+			}
+		}
+		/**
+		* Handle multiple dates selection via weekNumber / weekDay buttons:
+		* - if Cmd or Ctrl are pressed, add the new date to the current ones;
+		* - if not,
+		*     - if the new dates are the same of the current ones, it means that the same button has been clicked twice, so do nothing;
+		*     - if not, the selected dates are the new ones.
+		*/
+		_selectMultipleDates(days) {
+			const enabledDays = this._cells.filter((e) => !e.disabled).map((e) => this._mapValueToISODate(e.value));
+			const daysToAdd = days.map((e) => e.value).filter((isoDate) => enabledDays.includes(isoDate));
+			const daysToAddSet = new Set(daysToAdd);
+			const selectedSet = new Set(this._selected.map((s) => this._dateAdapter.toIso8601(s)));
+			this._selected = this._updateSelectedWithMultipleDates(daysToAdd, daysToAddSet, selectedSet).map((s) => this._dateAdapter.deserialize(s));
+			this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)));
+		}
+		/**
+		* Emits the dateselected event given the detail (as T or T[] based on the value of the multiple flag).
+		*/
+		_emitDateSelectedEvent(detail) {
+			/** @type {CustomEvent<T | T[]>} Event emitted on date selection. */
+			this.dispatchEvent(new CustomEvent("dateselected", {
+				detail,
+				composed: true,
+				bubbles: true
+			}));
+		}
+		_emitMonthChange() {
+			const monthchange = (this.wide ? [...this._weeks, ...this._nextMonthWeeks] : this._weeks).flat().sort((a, b) => a.value.localeCompare(b.value));
+			/**
+			* @type {SbbMonthChangeEvent}
+			* Emits when the month changes.
+			* The `range` property contains the days array of the chosen month.
+			*/
+			this.dispatchEvent(new SbbMonthChangeEvent(monthchange));
+		}
+		/**
+		* In case of multiple selection, newly added days must be added to the existing ones, without duplication.
+		* If the days to add are exactly the same as the selected ones, the set must be emptied.
+		*/
+		_updateSelectedWithMultipleDates(daysToAdd, daysToAddSet, selectedSet) {
+			if (daysToAdd.every((day) => selectedSet.has(day))) daysToAddSet.forEach((day) => selectedSet.delete(day));
+			else daysToAddSet.forEach((day) => selectedSet.add(day));
+			return Array.from(selectedSet);
+		}
+		_setChosenYear() {
+			if (this.view === "month") {
+				let selectedDate;
+				if (this.multiple) selectedDate = this.selected.at(-1);
+				else selectedDate = this.selected;
+				this._chosenYear = this._dateAdapter.getYear(selectedDate ?? this._dateAdapter.today());
+			} else this._chosenYear = void 0;
+		}
+		_assignActiveDate(date) {
+			if (this.min && this._dateAdapter.compareDate(this.min, date) > 0) {
+				this._activeDate = this.min;
+				return;
+			}
+			if (this.max && this._dateAdapter.compareDate(this.max, date) < 0) {
+				this._activeDate = this.max;
+				return;
+			}
+			this._activeDate = date;
+		}
+		/** Goes to the month identified by the shift. */
+		_goToDifferentMonth(months) {
+			this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));
+			this._emitMonthChange();
+		}
+		_goToDifferentYear(years) {
+			this._chosenYear += years;
+			this._activeDate = this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate));
+			this._init();
+		}
+		_goToDifferentYearRange(years) {
+			this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));
+		}
+		_prevDisabled(prevDate) {
+			if (!this.min) return false;
+			return this._dateAdapter.compareDate(prevDate, this.min) < 0;
+		}
+		_nextDisabled(nextDate) {
+			if (!this.max) return false;
+			return this._dateAdapter.compareDate(nextDate, this.max) > 0;
+		}
+		/** Checks if the "previous month" button should be disabled. */
+		_previousMonthDisabled() {
+			const prevMonth = this._dateAdapter.addCalendarDays(this._activeDate, this._dateAdapter.getDate(this._activeDate) * -1);
+			return this._prevDisabled(prevMonth);
+		}
+		/** Checks if the "next month" button should be disabled. */
+		_nextMonthDisabled() {
+			let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);
+			nextMonth = this._dateAdapter.createDate(this._dateAdapter.getYear(nextMonth), this._dateAdapter.getMonth(nextMonth), 1);
+			return this._nextDisabled(nextMonth);
+		}
+		/** Checks if the "previous year" button should be disabled. */
+		_previousYearDisabled() {
+			const prevYear = this._dateAdapter.createDate(this._dateAdapter.getYear(this._activeDate) - 1, 12, 31);
+			return this._prevDisabled(prevYear);
+		}
+		/** Checks if the "next year" button should be disabled. */
+		_nextYearDisabled() {
+			const nextYear = this._dateAdapter.createDate(this._dateAdapter.getYear(this._activeDate) + (this._wide ? 2 : 1), 1, 1);
+			return this._nextDisabled(nextYear);
+		}
+		/** Checks if the "previous year" button should be disabled in year view. */
+		_previousYearRangeDisabled() {
+			const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);
+			return this._prevDisabled(prevYear);
+		}
+		/** Checks if the "next year" button should be disabled in year view. */
+		_nextYearRangeDisabled() {
+			const years = this._wide ? this._nextMonthYears : this._years;
+			const lastYearRange = years[years.length - 1];
+			const lastYear = lastYearRange[lastYearRange.length - 1];
+			const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);
+			return this._nextDisabled(nextYear);
+		}
+		_handleTableBlur(eventTarget) {
+			if (eventTarget?.localName !== "sbb-calendar-day") this._setTabIndex();
+		}
+		_setTabIndex() {
+			Array.from(this._cells.filter((e) => e.tabIndex === 0) ?? []).forEach((day) => day.tabIndex = -1);
+			const firstFocusable = this._getFirstFocusable();
+			if (firstFocusable) firstFocusable.tabIndex = 0;
+		}
+		/** Get the element in the calendar to assign focus. */
+		_getFirstFocusable() {
+			if (this._calendarView === "day") {
+				const selectedOrCurrent = this._cells.find((e) => e.matches(":is(:state(selected),[state--selected])")) ?? this._cells.find((e) => e.matches(":is(:state(current),[state--current])"));
+				return selectedOrCurrent && !selectedOrCurrent.disabled ? selectedOrCurrent : this._getFirstFocusableDay();
+			} else {
+				const selectedOrCurrent = this.shadowRoot?.querySelector(":is(:state(selected),[state--selected])") ?? this.shadowRoot?.querySelector(":is(:state(current),[state--current])");
+				return selectedOrCurrent && !selectedOrCurrent.disabled ? selectedOrCurrent : this.shadowRoot.querySelector(`sbb-calendar-${this._calendarView}:not([disabled])`);
+			}
+		}
+		/**
+		* In `day` view in `vertical` orientation,
+		* if the first of the month is not a Monday, it is not the first rendered element in the table,
+		* so `this.shadowRoot!.querySelector('sbb-calendar-day:not([disabled])')` will return a wrong value.
+		*
+		* To solve this, the element with the lowest `value` is taken (ISO String are ordered).
+		*/
+		_getFirstFocusableDay() {
+			const cells = this._cells;
+			const daysInView = cells.filter((e) => !e.disabled);
+			if (!daysInView || daysInView.length === 0) return null;
+			else {
+				const firstElement = daysInView.map((e) => this._dateAdapter.toIso8601(e.value)).sort()[0];
+				return cells.find((e) => e.matches(`[slot="${firstElement}"]`)) ?? null;
+			}
+		}
+		_handleKeyboardEvent(event, day) {
+			if (isArrowKeyOrPageKeysPressed(event)) event.preventDefault();
+			const cells = this._cells;
+			const index = cells.findIndex((e) => e === event.target);
+			let nextEl;
+			if (day) nextEl = this._navigateByKeyboardDayView(event, index, cells, day);
+			else nextEl = this._navigateByKeyboard(event, index, cells);
+			const activeEl = (this._enhancedVariant ? document : this.shadowRoot).activeElement;
+			if (nextEl !== activeEl) {
+				nextEl.tabIndex = 0;
+				nextEl?.focus();
+				activeEl.tabIndex = -1;
+			}
+		}
+		_navigateByKeyboardDayView(evt, index, cells, day) {
+			const arrowsOffset = this.orientation === "horizontal" ? {
+				leftRight: 1,
+				upDown: DAYS_PER_ROW
+			} : {
+				leftRight: DAYS_PER_ROW,
+				upDown: 1
+			};
+			const offsetForVertical = index < this._keyboardNavigationDayViewParameters.firstMonthLength ? this._keyboardNavigationDayViewParameters.firstMonthOffset : this._keyboardNavigationDayViewParameters.secondMonthOffset;
+			switch (evt.key) {
+				case "ArrowUp": return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.upDown);
+				case "ArrowDown": return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.upDown);
+				case "ArrowLeft": return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.leftRight);
+				case "ArrowRight": return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.leftRight);
+				case "PageUp": if (this.orientation === "horizontal") {
+					const delta = (+day.dayValue % DAYS_PER_ROW || DAYS_PER_ROW) - +day.dayValue;
+					return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);
+				} else {
+					const delta = (Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW) - 1) * DAYS_PER_ROW - offsetForVertical + 1 - +day.dayValue;
+					return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);
+				}
+				case "PageDown": if (this.orientation === "horizontal") {
+					const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;
+					const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;
+					const firstNextMonth = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);
+					const lastOfMonth = this._dateAdapter.getDate(this._dateAdapter.addCalendarDays(firstNextMonth, -1));
+					const delta = Math.trunc((lastOfMonth - +day.dayValue) / DAYS_PER_ROW) * DAYS_PER_ROW;
+					return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);
+				} else {
+					const delta = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW) * DAYS_PER_ROW - offsetForVertical - +day.dayValue;
+					return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);
+				}
+				case "Home": return this._findDayFirst(cells, index, day, 1);
+				case "End": {
+					const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;
+					const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;
+					const firstNextMonth = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);
+					return this._findDayLast(cells, index, firstNextMonth);
+				}
+				default: return cells[index];
+			}
+		}
+		_isDayOutOfView(date) {
+			return date < this._keyboardNavigationDayViewParameters.firstDayInView || date > this._keyboardNavigationDayViewParameters.lastDayInView;
+		}
+		_findDayArrows(cells, index, date, delta) {
+			const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(date, delta));
+			if (this._isDayOutOfView(newDateValue)) return cells[index];
+			const nextCell = cells.find((e) => this._mapValueToISODate(e.value) === newDateValue);
+			if (!nextCell || nextCell.disabled) return this._findDayArrows(cells, index, this._dateAdapter.deserialize(newDateValue), delta);
+			return nextCell;
+		}
+		_findDayPageUpDown(cells, index, day, delta, deltaIfDisabled) {
+			const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(day.dateValue, delta));
+			if (this._isDayOutOfView(newDateValue)) return cells[index];
+			const nextCell = cells.find((e) => this._mapValueToISODate(e.value) === newDateValue);
+			if (!nextCell || nextCell.disabled) return this._findDayPageUpDown(cells, index, day, delta + deltaIfDisabled, deltaIfDisabled);
+			return nextCell;
+		}
+		_findDayFirst(cells, index, day, date) {
+			const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.createDate(+day.yearValue, +day.monthValue, date));
+			if (this._isDayOutOfView(newDateValue)) return cells[index];
+			const nextCell = cells.find((e) => this._mapValueToISODate(e.value) === newDateValue);
+			if (!nextCell || nextCell.disabled) return this._findDayFirst(cells, index, day, date + 1);
+			return nextCell;
+		}
+		_findDayLast(cells, index, firstNextMonth) {
+			const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(firstNextMonth, -1));
+			if (this._isDayOutOfView(newDateValue)) return cells[index];
+			const nextCell = cells.find((e) => this._mapValueToISODate(e.value) === newDateValue);
+			if (!nextCell || nextCell.disabled) return this._findDayLast(cells, index, this._dateAdapter.deserialize(newDateValue));
+			return nextCell;
+		}
+		/**
+		* Gets the index of the element to move to, based on a list of elements (which can be potentially disabled),
+		* the keyboard input and the position of the current element in the list.
+		* In the day view, the `day?: Day` parameter is mandatory for calculation,
+		* while in month and year view it's not due to the fixed amount of rendered cells.
+		*/
+		_navigateByKeyboard(evt, index, cells) {
+			const { elementIndexForWideMode, offsetForWideMode, lastElementIndexForWideMode, verticalOffset } = this._calculateParametersForKeyboardNavigation(index, this._calendarView === "year");
+			switch (evt.key) {
+				case "ArrowUp": return this._findNext(cells, index, -verticalOffset);
+				case "ArrowDown": return this._findNext(cells, index, verticalOffset);
+				case "ArrowLeft": return this._findNext(cells, index, -1);
+				case "ArrowRight": return this._findNext(cells, index, 1);
+				case "Home": return this._findFirst(cells, offsetForWideMode);
+				case "PageUp": return this._findFirstOnColumn(cells, elementIndexForWideMode, offsetForWideMode, verticalOffset);
+				case "PageDown": return this._findLastOnColumn(cells, index, lastElementIndexForWideMode, verticalOffset);
+				case "End": return this._findLast(cells, lastElementIndexForWideMode - 1);
+				default: return cells[index];
+			}
+		}
+		/**
+		* Calculates the parameters needed in keyboard navigation in year and month view.
+		* @param index The starting element's index in the cell array.
+		* @param isYearView Whether the displayed `view` is the year one.
+		*/
+		_calculateParametersForKeyboardNavigation(index, isYearView) {
+			const elementsPerPage = isYearView ? YEARS_PER_PAGE : MONTHS_PER_PAGE;
+			const offset = Math.trunc(index / elementsPerPage) * elementsPerPage;
+			const indexInView = offset === 0 ? index : index - elementsPerPage;
+			return {
+				verticalOffset: isYearView ? YEARS_PER_ROW : MONTHS_PER_ROW,
+				elementIndexForWideMode: indexInView,
+				offsetForWideMode: index - indexInView,
+				lastElementIndexForWideMode: offset === 0 ? elementsPerPage : elementsPerPage * 2
+			};
+		}
+		/**
+		* Gets the next element of the provided array starting from `index` by adding `delta`.
+		* If the found element is disabled, it continues adding `delta` until it finds an enabled one in the array bounds.
+		*/
+		_findNext(days, index, delta) {
+			let nextIndex = index + delta;
+			while (nextIndex < days.length && days[nextIndex]?.disabled) nextIndex += delta;
+			return days[nextIndex] ?? days[index];
+		}
+		/** Find the first enabled element in the provided array. */
+		_findFirst(days, firstOfCurrentMonth) {
+			return !days[firstOfCurrentMonth].disabled ? days[firstOfCurrentMonth] : this._findNext(days, firstOfCurrentMonth, 1);
+		}
+		/** Find the last enabled element in the provided array. */
+		_findLast(days, lastOfCurrentMonth) {
+			return !days[lastOfCurrentMonth].disabled ? days[lastOfCurrentMonth] : this._findNext(days, lastOfCurrentMonth, -1);
+		}
+		/** Find the first enabled element in the same column of the provided array. */
+		_findFirstOnColumn(days, index, offset, verticalOffset) {
+			const nextIndex = index % verticalOffset + offset;
+			return !days[nextIndex].disabled ? days[nextIndex] : this._findNext(days, nextIndex, verticalOffset);
+		}
+		/** Find the last enabled element in the same column of the provided array. */
+		_findLastOnColumn(days, index, offset, verticalOffset) {
+			const nextIndex = index + Math.trunc((offset - index - 1) / verticalOffset) * verticalOffset;
+			return !days[nextIndex].disabled ? days[nextIndex] : this._findNext(days, nextIndex, -verticalOffset);
+		}
+		_resetCalendarViewAndEmitMonthChange(initTransition = false) {
+			this._resetCalendarView(initTransition);
+			this._emitMonthChange();
+		}
+		_resetCalendarView(initTransition = false) {
+			if (this._containingFocus) this._resetFocus = true;
+			this._activeDate = (this.multiple ? this._selected.at(-1) : this._selected) ?? this._dateAdapter.today();
+			this._setChosenYear();
+			this._chosenMonth = void 0;
+			this._init();
+			this._nextCalendarView = this._calendarView = this.view;
+			if (initTransition) this._startTableTransition();
+		}
+		/** Render the view for the day selection. */
+		_renderDayView() {
+			const nextMonthActiveDate = this._wide ? this._dateAdapter.addCalendarMonths(this._activeDate, 1) : void 0;
+			return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentMonth(-1), i18nPreviousMonth[this._language.current], this._previousMonthDisabled())}
+        <div class="sbb-calendar__controls-month">
+          ${this._createLabelForDayView(this._activeDate)}
+          ${this._wide ? this._createLabelForDayView(nextMonthActiveDate) : nothing}
+          <sbb-screen-reader-only role="status">
+            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate)}
+          </sbb-screen-reader-only>
+        </div>
+        ${this._getArrow("right", () => this._goToDifferentMonth(1), i18nNextMonth[this._language.current], this._nextMonthDisabled())}
+      </div>
+      <div class="sbb-calendar__table-overflow-break">
+        <div class="sbb-calendar__table-container sbb-calendar__table-day-view">
+          ${this.orientation === "horizontal" ? html`
+                ${this._createDayTable(this._weeks, this._weekNumbers)}
+                ${this._wide ? this._createDayTable(this._nextMonthWeeks, this._nextMonthWeekNumbers, true) : nothing}
+              ` : html`
+                ${this._createDayTableVertical(this._weeks, this._weekNumbers)}
+                ${this._wide ? this._createDayTableVertical(this._nextMonthWeeks, this._nextMonthWeekNumbers, nextMonthActiveDate) : nothing}
+              `}
+        </div>
+      </div>
+    `;
+		}
+		/** Creates the label with the month for the daily view. */
+		_createLabelForDayView(d) {
+			const monthLabel = `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)}`;
+			return html`
+      <button
+        type="button"
+        class="sbb-calendar__date-selection sbb-calendar__controls-change-date"
+        aria-label="${i18nYearMonthSelection[this._language.current]} ${monthLabel}"
+        @click=${() => {
+				this._resetFocus = true;
+				this._nextCalendarView = "year";
+				this._startTableTransition();
+			}}
+      >
+        ${monthLabel}
+        <sbb-icon name="chevron-small-down-small"></sbb-icon>
+      </button>
+    `;
+		}
+		/** Creates the aria-label for the daily view. */
+		_createAriaLabelForDayView(...dates) {
+			let monthLabel = "";
+			for (const d of dates) if (d) monthLabel += `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)} `;
+			return monthLabel;
+		}
+		/** Creates the calendar table for the daily view. */
+		_createDayTable(weeks, weekNumbers, isWideNextMonth = false) {
+			const weeksForSelectMultipleWeekNumbers = (this._wide ? [...this._weeks, ...this._nextMonthWeeks] : isWideNextMonth ? this._nextMonthWeeks : this._weeks).flat();
+			const weeksForSelectMultipleWeekDays = (isWideNextMonth ? this._nextMonthWeeks : this._weeks).flat();
+			return html`
+      <table
+        class="sbb-calendar__table"
+        @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        <thead class="sbb-calendar__table-header">
+          <tr>
+            ${this.weekNumbers ? html`<th class="sbb-calendar__table-header-cell"></th>` : nothing}
+            ${this._weekdays.map((weekDay, index) => html`
+                <th class="sbb-calendar__table-header-cell">
+                  ${this.multiple ? html`
+                        <sbb-calendar-weekday
+                          .value=${weekDay}
+                          @click=${() => {
+				const days = weeksForSelectMultipleWeekDays.filter((day) => day.weekDayValue === (index + 1) % 7);
+				this._selectMultipleDates(days);
+			}}
+                        ></sbb-calendar-weekday>
+                      ` : html`
+                        <sbb-screen-reader-only>${weekDay.long}</sbb-screen-reader-only>
+                        <span aria-hidden="true">${weekDay.narrow}</span>
+                      `}
+                </th>
+              `)}
+          </tr>
+        </thead>
+        <tbody class="sbb-calendar__table-body">
+          ${weeks.map((week, rowIndex) => {
+				const firstRowOffset = DAYS_PER_ROW - week.length;
+				if (rowIndex === 0 && firstRowOffset) return html`
+                <tr>
+                  ${this.weekNumbers ? html`
+                        <td class="sbb-calendar__table-header-cell-vertical">
+                          ${this.multiple ? html`
+                                <sbb-calendar-weeknumber
+                                  .value=${weekNumbers[0]}
+                                  @click=${() => {
+					const days = weeksForSelectMultipleWeekNumbers.filter((day) => day.weekValue === weekNumbers[0]);
+					this._selectMultipleDates(days);
+				}}
+                                ></sbb-calendar-weeknumber>
+                              ` : html`
+                                <sbb-screen-reader-only
+                                  >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[0]}`}</sbb-screen-reader-only
+                                >
+                                <span aria-hidden="true">${weekNumbers[0]}</span>
+                              `}
+                        </td>
+                      ` : nothing}
+                  ${[...Array(firstRowOffset).keys()].map(() => html`<td class="sbb-calendar__table-data"></td>`)}
+                  ${this._createDayCells(week)}
+                </tr>
+              `;
+				return html`
+              <tr>
+                ${this.weekNumbers ? html`
+                      <td class="sbb-calendar__table-header-cell-vertical">
+                        ${this.multiple ? html`
+                              <sbb-calendar-weeknumber
+                                .value=${weekNumbers[rowIndex]}
+                                @click=${() => {
+					const days = weeksForSelectMultipleWeekNumbers.filter((day) => day.weekValue === weekNumbers[rowIndex]);
+					this._selectMultipleDates(days);
+				}}
+                              ></sbb-calendar-weeknumber>
+                            ` : html`
+                              <sbb-screen-reader-only
+                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[rowIndex]}`}</sbb-screen-reader-only
+                              >
+                              <span aria-hidden="true">${weekNumbers[rowIndex]}</span>
+                            `}
+                      </td>
+                    ` : nothing}
+                ${this._createDayCells(week)}
+              </tr>
+            `;
+			})}
+        </tbody>
+      </table>
+    `;
+		}
+		/** Creates the table in orientation='vertical'. */
+		_createDayTableVertical(weeks, weekNumbers, nextMonthActiveDate) {
+			const weekOffset = this._dateAdapter.getFirstWeekOffset(nextMonthActiveDate ?? this._activeDate);
+			const weeksForSelectMultipleWeekNumbers = (this._wide ? [...this._weeks, ...this._nextMonthWeeks] : nextMonthActiveDate ? this._nextMonthWeeks : this._weeks).flat();
+			return html`
+      <table
+        class="sbb-calendar__table"
+        @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        ${this.weekNumbers ? html`
+              <thead class="sbb-calendar__table-header">
+                <tr>
+                  ${nextMonthActiveDate ? nothing : html`<th class="sbb-calendar__table-data"></th>`}
+                  ${weekNumbers.map((weekNumber) => html`
+                      <th class="sbb-calendar__table-header-cell">
+                        ${this.multiple ? html`
+                              <sbb-calendar-weeknumber
+                                .value=${weekNumber}
+                                @click=${() => {
+				const days = weeksForSelectMultipleWeekNumbers.filter((day) => day.weekValue === weekNumber);
+				this._selectMultipleDates(days);
+			}}
+                              ></sbb-calendar-weeknumber>
+                            ` : html`
+                              <sbb-screen-reader-only
+                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumber}`}</sbb-screen-reader-only
+                              >
+                              <span aria-hidden="true">${weekNumber}</span>
+                            `}
+                      </th>
+                    `)}
+                </tr>
+              </thead>
+            ` : nothing}
+        <tbody class="sbb-calendar__table-body">
+          ${weeks.map((week, rowIndex) => {
+				const weekday = this._weekdays[rowIndex];
+				const selectableDays = this._wide ? [...week, ...this._nextMonthWeeks[rowIndex]] : week;
+				return html`
+              <tr>
+                ${nextMonthActiveDate ? nothing : html`
+                      <td class="sbb-calendar__table-header-cell-vertical">
+                        ${this.multiple ? html`
+                              <sbb-calendar-weekday
+                                .value=${weekday}
+                                @click=${() => this._selectMultipleDates(selectableDays)}
+                              >
+                                ${weekday.narrow}
+                              </sbb-calendar-weekday>
+                            ` : html`
+                              <sbb-screen-reader-only>${weekday.long}</sbb-screen-reader-only>
+                              <span aria-hidden="true">${weekday.narrow}</span>
+                            `}
+                      </td>
+                    `}
+                ${rowIndex < weekOffset ? html`<td class="sbb-calendar__table-data"></td>` : nothing}
+                ${this._createDayCells(week)}
+              </tr>
+            `;
+			})}
+        </tbody>
+      </table>
+    `;
+		}
+		/** Creates the cells for the daily view. */
+		_createDayCells(week) {
+			return week.map((day) => {
+				return html`
+        <td class="sbb-calendar__table-data sbb-calendar__day-cell">
+          <slot name=${day.value}>
+            <sbb-calendar-day
+              slot=${day.value}
+              @click=${() => this._selectDate(day.dateValue)}
+              @keydown=${(evt) => this._handleKeyboardEvent(evt, day)}
+            ></sbb-calendar-day>
+          </slot>
+        </td>
+      `;
+			});
+		}
+		/** Render the view for the month selection. */
+		_renderMonthView() {
+			return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentYear(-1), i18nPreviousYear[this._language.current], this._previousYearDisabled())}
+        <div class="sbb-calendar__controls-month">${this._createLabelForMonthView()}</div>
+        ${this._getArrow("right", () => this._goToDifferentYear(1), i18nNextYear[this._language.current], this._nextYearDisabled())}
+      </div>
+      <div class="sbb-calendar__table-overflow-break">
+        <div class="sbb-calendar__table-container sbb-calendar__table-month-view">
+          ${this._createMonthTable(this._months, this._chosenYear)}
+          ${this._wide ? this._createMonthTable(this._months, this._chosenYear + 1) : nothing}
+        </div>
+      </div>
+    `;
+		}
+		/** Creates the label with the year for the monthly view. */
+		_createLabelForMonthView() {
+			return html` <button
+        type="button"
+        id="sbb-calendar__month-selection"
+        class="sbb-calendar__controls-change-date"
+        aria-label=${`${i18nCalendarDateSelection[this._language.current]} ${this._chosenYear}`}
+        @click=${() => this._resetCalendarViewAndEmitMonthChange(true)}
+      >
+        ${this._chosenYear} ${this._wide ? ` - ${this._chosenYear + 1}` : nothing}
+        <sbb-icon name="chevron-small-up-small"></sbb-icon>
+      </button>
+      <sbb-screen-reader-only role="status"> ${this._chosenYear} </sbb-screen-reader-only>`;
+		}
+		/** Creates the table for the month selection view. */
+		_createMonthTable(months, year) {
+			return html`
+      <table
+        class="sbb-calendar__table"
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        ${this._wide ? html`<thead class="sbb-calendar__table-header" aria-hidden="true">
+              <tr>
+                <th class="sbb-calendar__table-header-cell" colspan=${MONTHS_PER_ROW}>${year}</th>
+              </tr>
+            </thead>` : nothing}
+        <tbody class="sbb-calendar__table-body">
+          ${months.map((row) => html`
+              <tr>
+                ${row.map((month) => {
+				return html`
+                    <td class="sbb-calendar__table-data">
+                      <sbb-calendar-month
+                        .value="${year}-${month.value}"
+                        @click=${() => this._onMonthSelection(month.monthValue, year)}
+                        @keydown=${(evt) => this._handleKeyboardEvent(evt)}
+                      >
+                      </sbb-calendar-month>
+                    </td>
+                  `;
+			})}
+              </tr>
+            `)}
+        </tbody>
+      </table>
+    `;
+		}
+		/** Select the month and change the view to day selection. */
+		_onMonthSelection(month, year) {
+			this._chosenMonth = month;
+			this._nextCalendarView = "day";
+			this._init(this._dateAdapter.createDate(year, this._chosenMonth, this._dateAdapter.getDate(this._activeDate)));
+			this._startTableTransition();
+			this._emitMonthChange();
+		}
+		/** Render the view for the year selection. */
+		_renderYearView() {
+			return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentYearRange(-YEARS_PER_PAGE), i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current], this._previousYearRangeDisabled())}
+        <div class="sbb-calendar__controls-month">${this._createLabelForYearView()}</div>
+        ${this._getArrow("right", () => this._goToDifferentYearRange(YEARS_PER_PAGE), i18nNextYearRange(YEARS_PER_PAGE)[this._language.current], this._nextYearRangeDisabled())}
+      </div>
+      <div class="sbb-calendar__table-overflow-break">
+        <div class="sbb-calendar__table-container sbb-calendar__table-year-view">
+          ${this._createYearTable(this._years)}
+          ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}
+        </div>
+      </div>
+    `;
+		}
+		/** Creates the button arrow for all the views. */
+		_getArrow(direction, click, ariaLabel, disabled) {
+			return html`<sbb-secondary-button
+      size="m"
+      icon-name="chevron-small-${direction}-small"
+      aria-label=${ariaLabel}
+      @click=${click}
+      ?disabled=${disabled}
+      id="sbb-calendar__controls-${direction === "left" ? "previous" : "next"}"
+    ></sbb-secondary-button>`;
+		}
+		/** Creates the label with the year range for the yearly view. */
+		_createLabelForYearView() {
+			const firstYear = this._years.flat()[0];
+			const lastYearArray = (this._wide ? this._nextMonthYears : this._years).flat();
+			const yearLabel = `${firstYear} - ${lastYearArray[lastYearArray.length - 1]}`;
+			return html`
+      <button
+        type="button"
+        id="sbb-calendar__year-selection"
+        class="sbb-calendar__controls-change-date"
+        aria-label="${i18nCalendarDateSelection[this._language.current]} ${yearLabel}"
+        @click=${() => this._resetCalendarViewAndEmitMonthChange(true)}
+      >
+        ${yearLabel}
+        <sbb-icon name="chevron-small-up-small"></sbb-icon>
+      </button>
+      <sbb-screen-reader-only role="status"> ${yearLabel} </sbb-screen-reader-only>
+    `;
+		}
+		/** Creates the table for the year selection view. */
+		_createYearTable(years, shiftRight = false) {
+			return html` <table
+      class="sbb-calendar__table"
+      @animationend=${(e) => this._tableAnimationEnd(e)}
+    >
+      <tbody class="sbb-calendar__table-body">
+        ${years.map((row) => html` <tr>
+              ${row.map((year) => {
+				return html`
+                  <td class="sbb-calendar__table-data">
+                    <sbb-calendar-year
+                      .value=${String(year)}
+                      @keydown=${(evt) => this._handleKeyboardEvent(evt)}
+                      @click=${() => this._onYearSelection(year, shiftRight)}
+                    >
+                    </sbb-calendar-year>
+                  </td>
+                `;
+			})}
+            </tr>`)}
+      </tbody>
+    </table>`;
+		}
+		/** Select the year and change the view to month selection. */
+		_onYearSelection(year, rightSide) {
+			this._chosenYear = rightSide ? year - 1 : year;
+			this._nextCalendarView = "month";
+			this._assignActiveDate(this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate)));
+			this._startTableTransition();
+		}
+		_getView() {
+			if (isServer || this.hydrationRequired) return html`${nothing}`;
+			switch (this._calendarView) {
+				case "year": return this._renderYearView();
+				case "month": return this._renderMonthView();
+				default: return this._renderDayView();
+			}
+		}
+		_tableAnimationEnd(event) {
+			const table = event.target;
+			if (event.animationName === "hide") {
+				table.classList.remove("sbb-calendar__table-hide");
+				if (this._containingFocus) this._resetFocus = true;
+				this._calendarView = this._nextCalendarView;
+			} else if (event.animationName === "show") this.internals.states.delete("transition");
+		}
+		_startTableTransition() {
+			this.internals.states.add("transition");
+			this.shadowRoot?.querySelectorAll("table")?.forEach((e) => e.classList.toggle("sbb-calendar__table-hide"));
+		}
+		render() {
+			return html`<div class="sbb-calendar__wrapper">${this._getView()}</div>`;
+		}
+	};
+})();
+//#endregion
+export { SbbMonthChangeEvent as n, SbbCalendarElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"calendar.component-6p9vsp-V.js","names":[],"sources":["../../../src/elements/calendar/calendar/calendar.scss?inline","../../../src/elements/calendar/calendar/calendar.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  display: block;\n\n  // We add width definition to host, to make overwriting easy for consumers.\n  width: max-content;\n\n  --sbb-calendar-cell-size: #{sbb.px-to-rem-build(44)};\n\n  // Match Figma design\n  --sbb-calendar-cell-border-radius: calc(\n    var(--sbb-border-radius-4x) + var(--sbb-calendar-cell-border-width)\n  );\n  --sbb-calendar-cell-transition-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-2x)\n  );\n\n  @include sbb.mq($from: small) {\n    --sbb-calendar-control-view-change-height: #{sbb.px-to-rem-build(48)};\n  }\n}\n\n:host(:state(enhanced)) {\n  --sbb-calendar-cell-padding-block-end: var(--sbb-spacing-fixed-3x);\n}\n\n.sbb-calendar__wrapper {\n  width: 100%;\n  display: block;\n  transition-duration: var(--sbb-calendar-cell-transition-duration);\n}\n\n.sbb-calendar__controls {\n  width: 100%;\n  display: inline-flex;\n  align-items: center;\n  gap: var(--sbb-calendar-control-gap);\n  margin-block-end: var(--sbb-calendar-control-margin-block-end);\n}\n\n.sbb-calendar__controls-month {\n  width: 100%;\n  display: flex;\n  gap: var(--sbb-calendar-tables-gap);\n}\n\n#sbb-calendar__controls-previous,\n#sbb-calendar__controls-next {\n  -webkit-tap-highlight-color: transparent;\n}\n\n.sbb-calendar__controls-change-date {\n  @include sbb.button-reset;\n\n  display: flex;\n  align-items: center;\n  margin: auto;\n  height: var(--sbb-calendar-control-view-change-height);\n  font-size: var(--sbb-text-font-size-s);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  text-transform: capitalize;\n  cursor: var(--sbb-cursor-pointer);\n  padding-inline: var(--sbb-calendar-control-view-change-padding-inline);\n  border-radius: var(--sbb-border-radius-infinity);\n  background-color: var(--sbb-calendar-control-view-change-background);\n  color: var(--sbb-calendar-control-view-change-color);\n  transition-duration: var(--sbb-calendar-cell-transition-duration);\n  transition-timing-function: var(--sbb-calendar-cell-transition-easing-function);\n  transition-property: background-color, padding-block-end;\n\n  &:disabled {\n    --sbb-calendar-control-view-change-background: light-dark(\n      var(--sbb-color-milk),\n      var(--sbb-color-anthracite)\n    );\n    --sbb-calendar-control-view-change-color: light-dark(\n      var(--sbb-color-granite),\n      var(--sbb-color-aluminium)\n    );\n\n    cursor: unset;\n  }\n\n  &:focus-visible {\n    @include sbb.focus-outline;\n\n    outline-offset: var(--sbb-spacing-fixed-1x);\n  }\n\n  @include sbb.hover-mq {\n    &:not(:active, :disabled):hover {\n      padding-block-end: var(--sbb-calendar-cell-hover-shift);\n    }\n  }\n\n  &:not(:disabled):active {\n    --sbb-calendar-control-view-change-background: var(--sbb-background-color-3);\n  }\n}\n\n.sbb-calendar__table-month-view,\n.sbb-calendar__table-year-view {\n  --sbb-calendar-table-column-spaces: 6;\n}\n\n.sbb-calendar__table-overflow-break {\n  // We have to cut the negative margin which is built by the containing sbb-calendar__table-container.\n  // Overflow: hidden would cut the focus outline. Therefore we take `contain` here.\n  contain: layout;\n}\n\n.sbb-calendar__table-container {\n  display: flex;\n  gap: var(--sbb-calendar-tables-gap);\n  margin-inline: var(--sbb-calendar-margin);\n\n  // The padding of the first and last column should not be visible if calendar is stretched.\n  // Therefore we need a negative inline margin.\n  // As we don't want to squeeze, the margin should never be greater than zero.\n\n  // Min width is equals to the normal width of the calendar\n  --sbb-calendar-min-width: calc(7 * var(--sbb-calendar-cell-size));\n\n  // The overflow variable is equals the difference between the actual width and the min width.\n  --sbb-calendar-overflow: calc(100% - var(--sbb-calendar-min-width));\n\n  // The start offset is negative margin which should overlap the parent container. Should never be a positive value.\n  --sbb-calendar-start-offset: min(\n    0px,\n    -1 * (var(--sbb-calendar-overflow) / var(--sbb-calendar-table-column-spaces))\n  );\n  --sbb-calendar-margin: var(--sbb-calendar-start-offset);\n\n  :host(:state(wide)) & {\n    --sbb-calendar-min-width: calc(\n      2 * 7 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)\n    );\n    --sbb-calendar-margin: calc(0.5 * var(--sbb-calendar-start-offset));\n  }\n\n  :host([orientation='horizontal'][week-numbers]) & {\n    --sbb-calendar-min-width: calc(8 * var(--sbb-calendar-cell-size));\n  }\n\n  :host([orientation='horizontal'][week-numbers]:state(wide)) & {\n    --sbb-calendar-min-width: calc(\n      2 * 8 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)\n    );\n  }\n\n  // The container's min-width is set in vertical mode;\n  // the value `calc(7 * var(--sbb-calendar-cell-size))` is fine\n  // considering that the maximum number of weeks in a month is 6, plus 1 for the header at the table's left side.\n  :host([orientation='vertical']) & {\n    min-width: var(--sbb-calendar-min-width);\n\n    // The variable that defines the margin is set to 0 to correctly display the table if consumers set a custom width.\n    --sbb-calendar-start-offset: 0;\n  }\n\n  // The min-width in wide is calculated as (max number of weeks in a month) * (displayed months) + (header column) = 6 * 2 + 1 = 13.\n  :host([orientation='vertical']:state(wide)) & {\n    --sbb-calendar-min-width: calc(\n      13 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)\n    );\n  }\n}\n\n.sbb-calendar__table {\n  width: 100%;\n  border-collapse: collapse;\n  height: max-content;\n\n  animation: {\n    name: show;\n    duration: var(--sbb-calendar-table-animation-duration);\n  }\n\n  &.sbb-calendar__table-hide {\n    --sbb-calendar-cell-transition-duration: 0ms;\n\n    animation: {\n      name: hide;\n      duration: var(--sbb-calendar-table-animation-duration);\n    }\n  }\n\n  :host(:not(:state(wide))) & {\n    // Due to a Safari iOS rendering bug we need to define min-width as well.\n    // Otherwise, after orientation change, there is a wrong width if placed in an sbb-dialog.\n    min-width: 100%;\n  }\n}\n\n.sbb-calendar__table-header {\n  // Depending where in the DOM it's used, it's possible that browser defaults set text-align to left.\n  text-align: center;\n}\n\n.sbb-calendar__table-body {\n  // Depending where in the DOM it's used, it's possible that browser defaults set text-align to left.\n  text-align: center;\n}\n\n.sbb-calendar__table-header-cell,\n.sbb-calendar__table-header-cell-vertical {\n  width: var(--sbb-calendar-cell-size);\n  color: var(--sbb-calendar-header-color);\n  padding: 0;\n  font-size: var(--sbb-text-font-size-xs);\n  font-weight: normal;\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n\n  :host(:not([multiple])) & {\n    height: var(--sbb-calendar-cell-size);\n  }\n}\n\n.sbb-calendar__table-header-cell-vertical {\n  padding-block-end: var(--sbb-calendar-cell-padding-block-end);\n}\n\n.sbb-calendar__table-data {\n  position: relative;\n  padding: 0;\n  text-align: center;\n}\n\n.sbb-calendar__day-cell {\n  padding-block-end: var(--sbb-calendar-cell-padding-block-end);\n}\n\nsbb-calendar-day {\n  :host(:not(:state(enhanced))) & {\n    --sbb-calendar-cell-justify-content: center;\n    --sbb-calendar-day-height: #{sbb.px-to-rem-build(44)};\n    --sbb-calendar-day-extra-display: none;\n    --sbb-calendar-day-value-height: unset;\n    --sbb-calendar-day-crossed-out-top: 50%;\n    --sbb-calendar-day-crossed-out-translate: translate(-50%, -50%) rotate(-45deg);\n  }\n}\n\n@keyframes show {\n  from {\n    opacity: 0;\n    transform: translateY(var(--sbb-calendar-table-animation-shift));\n  }\n\n  to {\n    opacity: 1;\n    transform: translateY(0%);\n  }\n}\n\n@keyframes hide {\n  from {\n    opacity: 1;\n    transform: translateY(0%);\n  }\n\n  to {\n    opacity: 0;\n    transform: translateY(var(--sbb-calendar-table-animation-shift));\n  }\n}\n","import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport { SbbSecondaryButtonElement } from '../../button.pure.ts';\nimport { isArrowKeyOrPageKeysPressed } from '../../core/a11y.ts';\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { readConfig } from '../../core/config.ts';\nimport {\n  SbbLanguageController,\n  SbbMediaMatcherController,\n  SbbMediaQueryBreakpointLargeAndAbove,\n} from '../../core/controllers.ts';\nimport type { DateAdapter } from '../../core/datetime.ts';\nimport {\n  DAYS_PER_ROW,\n  defaultDateAdapter,\n  MONDAY,\n  MONTHS_PER_PAGE,\n  MONTHS_PER_ROW,\n  THURSDAY,\n  TUESDAY,\n  WEDNESDAY,\n  YEARS_PER_PAGE,\n  YEARS_PER_ROW,\n} from '../../core/datetime.ts';\nimport { forceType, handleDistinctChange, plainDate } from '../../core/decorators.ts';\nimport {\n  i18nCalendarDateSelection,\n  i18nCalendarWeekNumber,\n  i18nNextMonth,\n  i18nNextYear,\n  i18nNextYearRange,\n  i18nPreviousMonth,\n  i18nPreviousYear,\n  i18nPreviousYearRange,\n  i18nYearMonthSelection,\n} from '../../core/i18n.ts';\nimport type { SbbOrientation } from '../../core/interfaces.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport { SbbCalendarDayElement } from '../calendar-day/calendar-day.component.ts';\nimport { SbbCalendarMonthElement } from '../calendar-month/calendar-month.component.ts';\nimport { SbbCalendarWeekdayElement } from '../calendar-weekday/calendar-weekday.component.ts';\nimport { SbbCalendarWeeknumberElement } from '../calendar-weeknumber/calendar-weeknumber.component.ts';\nimport { SbbCalendarYearElement } from '../calendar-year/calendar-year.component.ts';\nimport type { SbbCalendarCellBaseElement } from '../common.ts';\n\nimport style from './calendar.scss?inline';\n\nimport '../../icon.ts';\nimport '../../screen-reader-only.ts';\n\n// TODO(breaking-change): Remove call to define.\nSbbSecondaryButtonElement.define();\n\nSbbCalendarDayElement.define();\nSbbCalendarMonthElement.define();\nSbbCalendarYearElement.define();\nSbbCalendarWeekdayElement.define();\nSbbCalendarWeeknumberElement.define();\n\nexport class SbbMonthChangeEvent extends Event {\n  private readonly _range: readonly Day[];\n\n  public get range(): readonly Day[] {\n    return this._range;\n  }\n\n  public constructor(range: readonly Day[]) {\n    super('monthchange', { bubbles: true, composed: true });\n    this._range = Object.freeze(range || []);\n  }\n}\n\n/**\n * Parameters needed in year and month views to correctly calculate the next element in keyboard navigation.\n *\n * The cell's index and the element's index in its month / year batch must be distinguished:\n * the first is the index of the element in the array of all the rendered cells, while the second is the index of the element relative to its table.\n * In non-wide mode, the wto are the same, while in wide mode the cell's index can go from 0 to 47 for years and from 0 to 23 for months,\n * while the element index goes from 0 to, respectively, 23 and 11.\n */\ninterface CalendarKeyboardNavigationMonthYearViewsParameters {\n  /** The element index within its year or month range. */\n  elementIndexForWideMode: number;\n  /** In wide mode, the index of the first element in the second panel, or, alternatively, the number of elements in the first panel. */\n  offsetForWideMode: number;\n  /** The index of the last element within the element's month (or year range). */\n  lastElementIndexForWideMode: number;\n  /** The number of cells displayed in a single row, depending on the rendered view. */\n  verticalOffset: number;\n}\n\n/**\n * Parameters needed in day view to correctly calculate the next element in keyboard navigation.\n *\n * In orientation='vertical', it's not possible to rely on any array/index to calculate the element to navigate to,\n * so calculations on dates must be done, which should consider view boundaries, offsets and month's length.\n */\ninterface CalendarKeyboardNavigationDayViewParameters {\n  /** The first day rendered. */\n  firstDayInView: string | null;\n  /** The last day rendered. It depends on the 'wide' value. */\n  lastDayInView: string | null;\n  /** The offset from the first day of the week (Monday) of the first rendered month. */\n  firstMonthOffset: number;\n  /** The number of days in the first rendered month. */\n  firstMonthLength: number;\n  /** The offset from the first day of the week (Monday) of the second rendered month. If wide is false, it's equal to zero. */\n  secondMonthOffset: number;\n}\n\nexport interface Day<T = Date> {\n  /** Date as ISO string. */\n  value: string;\n  dayValue: string;\n  monthValue: string;\n  yearValue: string;\n  dateValue: T;\n  weekValue: number;\n  weekDayValue: number;\n}\n\n/** @deprecated use MonthCell */\nexport interface Month {\n  value: string;\n  longValue: string;\n  monthValue: number;\n}\n\nexport interface MonthCell {\n  value: string;\n  monthValue: number;\n}\n\nexport interface Weekday {\n  long: string;\n  narrow: string;\n}\n\nexport type CalendarView = 'day' | 'month' | 'year';\n\n/**\n * It displays a calendar which allows choosing a date.\n *\n * @slot - Use the unnamed slot to add customized `sbb-calendar-day` elements.\n */\nexport class SbbCalendarElement<T = Date> extends SbbElement {\n  public static override readonly elementName: string = 'sbb-calendar';\n  public static override styles: CSSResultGroup = [boxSizingStyles, unsafeCSS(style)];\n  public static readonly events = {\n    dateselected: 'dateselected',\n    monthchange: 'monthchange',\n  } as const;\n\n  /** If set to true, two months are displayed */\n  @forceType()\n  @property({ type: Boolean })\n  public accessor wide: boolean = false;\n\n  /** The initial view of the calendar which should be displayed on opening. */\n  @property() public accessor view: CalendarView = 'day';\n\n  /**\n   * The minimum valid date. Accepts a date object or null.\n   * Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.\n   */\n  @plainDate()\n  @property()\n  public accessor min: T | null = null;\n\n  /**\n   * The maximum valid date. Accepts a date object or null.\n   * Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.\n   */\n  @plainDate()\n  @property()\n  public accessor max: T | null = null;\n\n  /** Whether the calendar allows for multiple date selection. */\n  @forceType()\n  @handleDistinctChange((e: SbbCalendarElement<T>, newValue: boolean) =>\n    e._onMultipleChanged(newValue),\n  )\n  @property({ type: Boolean })\n  public accessor multiple: boolean = false;\n\n  /**\n   * The selected date: accepts a date object, or, if `multiple`, an array of dates.\n   */\n  @property()\n  public set selected(value: T | T[] | null) {\n    if (Array.isArray(value)) {\n      this._selected = value\n        .map((dateLike: T) =>\n          this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(dateLike)),\n        )\n        .filter((date: T | null): date is T => date !== null)\n        .filter(\n          (date: T) =>\n            !this._isDayInRange(this._dateAdapter.toIso8601(date)) || this._dateFilter(date),\n        );\n    } else {\n      const selectedDate = this._dateAdapter.getValidDateOrNull(\n        this._dateAdapter.deserialize(value),\n      );\n      if (\n        !!selectedDate &&\n        (!this._isDayInRange(this._dateAdapter.toIso8601(selectedDate)) ||\n          this._dateFilter(selectedDate))\n      ) {\n        this._selected = selectedDate;\n      } else {\n        this._selected = null;\n      }\n    }\n  }\n  public get selected(): T | T[] | null {\n    return this._selected;\n  }\n  @state() private accessor _selected: T | T[] | null = null;\n\n  /** A function used to filter out dates. */\n  @property({ attribute: 'date-filter' })\n  public accessor dateFilter: ((date: T | null) => boolean) | null = null;\n\n  /** The orientation of days in the calendar. */\n  @property({ reflect: true }) public accessor orientation: SbbOrientation = 'horizontal';\n\n  /** Whether it has to display the week numbers in addition to week days. */\n  @forceType()\n  @property({ attribute: 'week-numbers', type: Boolean })\n  public accessor weekNumbers: boolean = false;\n\n  private _dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n\n  /** The currently active date. */\n  @state() private accessor _activeDate: T = this._dateAdapter.today();\n\n  /** The current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */\n  @state()\n  private set _wide(wide: boolean) {\n    this.toggleState('wide', wide);\n    this._wideInternal = wide;\n  }\n  private get _wide(): boolean {\n    return this._wideInternal;\n  }\n  // We keep the state in a field because of the WebKit bug https://bugs.webkit.org/show_bug.cgi?id=303467.\n  // TODO: re-check whether field is needed\n  private _wideInternal: boolean = false;\n\n  @state() private accessor _calendarView: CalendarView = 'day';\n\n  private _nextCalendarView: CalendarView = 'day';\n\n  /** Information about the rendered day view; used in keyboard navigation. */\n  private _keyboardNavigationDayViewParameters: CalendarKeyboardNavigationDayViewParameters = {\n    firstDayInView: null,\n    lastDayInView: null,\n    firstMonthOffset: 0,\n    firstMonthLength: 0,\n    secondMonthOffset: 0,\n  };\n\n  /** A list of days, in two formats (long and single char). */\n  private _weekdays!: Weekday[];\n\n  /** Grid of calendar cells representing the dates of the month. */\n  private _weeks: Day<T>[][] = [];\n\n  /** Grid of calendar cells representing months. */\n  private _months!: MonthCell[][];\n\n  /** Grid of calendar cells representing years. */\n  private _years!: number[][];\n\n  /** Grid of calendar cells representing years for the wide view. */\n  private _nextMonthYears!: number[][];\n\n  /** Grid of calendar cells representing the dates of the next month. */\n  private _nextMonthWeeks!: Day<T>[][];\n\n  /** An array containing all the month names in the current language. */\n  private _monthNames: string[] = this._dateAdapter.getMonthNames('long');\n\n  /** An array containing the weeks' numbers for the current month. */\n  private _weekNumbers!: number[];\n\n  /** An array containing the weeks' numbers for the next month in wide mode. */\n  private _nextMonthWeekNumbers!: number[];\n\n  private _enhancedVariant: boolean = false;\n\n  /** A list of calendar's cells corresponding to days, months or years depending on the view. */\n  private get _cells(): SbbCalendarCellBaseElement[] {\n    return Array.from<SbbCalendarCellBaseElement>(\n      (this._calendarView === 'day'\n        ? (Array.from(this.shadowRoot!.querySelectorAll('slot')).flatMap((e: HTMLSlotElement) =>\n            e.assignedElements({ flatten: true }),\n          ) as SbbCalendarDayElement[])\n        : this.shadowRoot?.querySelectorAll(`sbb-calendar-${this._calendarView}`)) ?? [],\n    );\n  }\n\n  /** The chosen year in the year selection view. */\n  private _chosenYear?: number;\n\n  /** The chosen month in the year selection view. */\n  private _chosenMonth?: number;\n\n  /** Whether the focus should be reset on focusCell. */\n  private _resetFocus = false;\n\n  /** Whether an element inside the calendar is currently focused. */\n  private _containingFocus = false;\n\n  @state()\n  private accessor _initialized = false;\n\n  private _language = new SbbLanguageController(this).withHandler(() => {\n    this._monthNames = this._dateAdapter.getMonthNames('long');\n    this._createMonthRows();\n  });\n  private _mediaMatcher = new SbbMediaMatcherController(this, {\n    [SbbMediaQueryBreakpointLargeAndAbove]: () => this._init(),\n  });\n\n  public constructor() {\n    super();\n    this._createMonthRows();\n    this._setWeekdays();\n\n    // We need to track the focus as we should only take focus into the calendar, when the\n    // focus was once set into the calendar.\n    // For shadow DOM compatibility we need to track this programmatically.\n    this.addEventListener('focusin', () => (this._containingFocus = true));\n    this.addEventListener('focusout', () => (this._containingFocus = false));\n    this.addEventListener('click', (e) => {\n      const day = (e.target as HTMLElement).closest<SbbCalendarDayElement<T>>('sbb-calendar-day');\n      if (day) {\n        this._selectDate(day.value!);\n      }\n    });\n    this.addEventListener('keydown', (e) => {\n      if ((e.target as HTMLElement).localName === 'sbb-calendar-day') {\n        this._handleKeyboardEvent(\n          e,\n          this._mapDateToDay((e.target as SbbCalendarDayElement).value! as T),\n        );\n      }\n    });\n  }\n\n  private _dateFilter(date: T): boolean {\n    return this.dateFilter?.(date) ?? true;\n  }\n\n  /** Resets the active month according to the new state of the calendar. */\n  public resetPosition(): void {\n    this._resetCalendarView();\n    this._init();\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.resetPosition();\n    this.shadowRoot?.addEventListener('slotchange', this._onSlotChange, { capture: true });\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this.shadowRoot?.removeEventListener('slotchange', this._onSlotChange, { capture: true });\n  }\n\n  /** @internal */\n  public override focus(): void {\n    this._resetFocus = true;\n    this._focusCell();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (!this._initialized) {\n      return;\n    }\n\n    if (changedProperties.has('wide') || changedProperties.has('orientation')) {\n      this.resetPosition();\n    }\n\n    if (changedProperties.has('view')) {\n      this._setChosenYear();\n      this._chosenMonth = undefined;\n      this._nextCalendarView = this._calendarView = this.view;\n    }\n  }\n\n  protected override updated(changedProperties: PropertyValues<this>): void {\n    super.updated(changedProperties);\n    // The calendar needs to calculate tab-indexes on first render,\n    // and every time a date is selected or the month view changes.\n    this._setTabIndex();\n\n    // When changing view to year/month, the tabindex is changed, but the focused element is getting lost.\n    // We need to call `_focusCell()` method explicitly to correctly set the focus.\n    this._focusCell();\n  }\n\n  private _onSlotChange = (): void => {\n    this._enhancedVariant = Array.from(this.children).some(\n      (c) => c.localName === 'sbb-calendar-day',\n    );\n    this.toggleState('enhanced', this._enhancedVariant);\n    this._setTabIndex();\n  };\n\n  /**\n   * The `_selected` state should be adapted when the `multiple` property changes:\n   *   - if it changes to true, the '_selected' is set to an array;\n   *   - if it changes to false, the first available option is set as 'value' otherwise it's set to null.\n   */\n  private _onMultipleChanged(isMultiple: boolean): void {\n    if (isMultiple && !Array.isArray(this._selected)) {\n      this._selected = this._selected ? [this._selected as T] : [];\n    }\n    if (!isMultiple && Array.isArray(this._selected)) {\n      this._selected = (this._selected as T[]).length ? (this._selected as T[])[0] : null;\n    }\n  }\n\n  /** Initializes the component. */\n  private _init(activeDate?: T): void {\n    // Due to its complexity, the calendar is only initialized on client side\n    if (isServer) {\n      return;\n    } else if (this.hydrationRequired) {\n      this.hydrationComplete.then(() => this._init());\n      return;\n    }\n\n    if (activeDate) {\n      this._assignActiveDate(activeDate);\n    }\n    this._wide =\n      (this._mediaMatcher.matches(SbbMediaQueryBreakpointLargeAndAbove) ?? false) && this.wide;\n    this._weeks = this._createWeekRows(this._activeDate);\n    this._years = this._createYearRows();\n    this._weekNumbers = this._weeks\n      .flat()\n      .sort((a, b) => a.value.localeCompare(b.value))\n      .map((day: Day<T>) => day.weekValue)\n      .filter((v, i, a) => a.indexOf(v) === i);\n    this._nextMonthWeeks = [[]];\n    this._nextMonthYears = [[]];\n    if (this._wide) {\n      const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);\n      this._nextMonthWeeks = this._createWeekRows(nextMonthDate, true);\n      this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);\n      this._nextMonthWeekNumbers = this._nextMonthWeeks\n        .flat()\n        .sort((a, b) => a.value.localeCompare(b.value))\n        .map((day: Day<T>) => day.weekValue)\n        .filter((v, i, a) => a.indexOf(v) === i);\n    }\n    this._initialized = true;\n  }\n\n  /** Focuses on a day cell prioritizing the selected day, the current day, and lastly, the first selectable day. */\n  private _focusCell(): void {\n    if (this._resetFocus) {\n      this._getFirstFocusable()?.focus();\n      this._resetFocus = false;\n    }\n  }\n\n  /** Creates the array of weekdays. */\n  private _setWeekdays(): void {\n    const narrowWeekdays: string[] = this._dateAdapter.getDayOfWeekNames('narrow');\n    const longWeekdays: string[] = this._dateAdapter.getDayOfWeekNames('long');\n    const weekdays: Weekday[] = longWeekdays.map((long: string, i: number) => ({\n      long,\n      narrow: narrowWeekdays[i],\n    }));\n\n    // Rotates the labels for days of the week based on the configured first day of the week.\n    const firstDayOfWeek: number = this._dateAdapter.getFirstDayOfWeek();\n    this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));\n  }\n\n  /** Creates the rows along the horizontal direction and sets the parameters used in keyboard navigation. */\n  private _createWeekRows(value: T, isSecondMonthInView = false): Day<T>[][] {\n    const daysInMonth: number = this._dateAdapter.getNumDaysInMonth(value);\n    const weekOffset: number = this._dateAdapter.getFirstWeekOffset(value);\n    if (!isSecondMonthInView) {\n      this._keyboardNavigationDayViewParameters.firstMonthLength = daysInMonth;\n      this._keyboardNavigationDayViewParameters.firstMonthOffset = weekOffset;\n      this._keyboardNavigationDayViewParameters.firstDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          1,\n        ),\n      );\n      this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          daysInMonth,\n        ),\n      );\n    } else {\n      this._keyboardNavigationDayViewParameters.secondMonthOffset = weekOffset;\n      this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          daysInMonth,\n        ),\n      );\n    }\n    return this.orientation === 'horizontal'\n      ? this._createWeekRowsHorizontal(value, daysInMonth, weekOffset)\n      : this._createWeekRowsVertical(value, daysInMonth, weekOffset);\n  }\n\n  /**\n   * Creates the rows for each week in orientation='horizontal'.\n   *\n   * Iterates through the days of the months, creates a Day object for each and pushes it into and array.\n   * Each seven days (considering the offset at the beginning of the month) restarts from an empty array.\n   *\n   * The result is a matrix in which every row is a week (or part of it, considering offset).\n   */\n  private _createWeekRowsHorizontal(value: T, daysInMonth: number, weekOffset: number): Day<T>[][] {\n    const weeks: Day<T>[][] = [[]];\n    for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {\n      if (cell === DAYS_PER_ROW) {\n        weeks.push([]);\n        cell = 0;\n      }\n      const date = this._dateAdapter.createDate(\n        this._dateAdapter.getYear(value),\n        this._dateAdapter.getMonth(value),\n        i + 1,\n      )!;\n      weeks[weeks.length - 1].push(this._mapDateToDay(date));\n    }\n    return weeks;\n  }\n\n  /**\n   * Creates the rows for each week in orientation='vertical'.\n   *\n   * Creates a matrix with seven empty rows.\n   * Iterates through the days of the months, creates a Day object for each\n   * and pushes it into the correct array considering the offset at the beginning of the month.\n   * Each seven days (including offset) restarts from the first.\n   *\n   * The result is a matrix in which every row is a set of weekdays, so:\n   * - row 0: all the Mondays;\n   * - row 1: all the Tuesdays;\n   * - ...\n   * - row 7: all the Sundays.\n   */\n  private _createWeekRowsVertical(value: T, daysInMonth: number, weekOffset: number): Day<T>[][] {\n    const weeks: Day<T>[][] = Array.from({ length: DAYS_PER_ROW }, () => []);\n    for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {\n      if (cell === DAYS_PER_ROW) {\n        cell = 0;\n      }\n      const date = this._dateAdapter.createDate(\n        this._dateAdapter.getYear(value),\n        this._dateAdapter.getMonth(value),\n        i + 1,\n      )!;\n      weeks[cell].push(this._mapDateToDay(date));\n    }\n    return weeks;\n  }\n\n  private _mapDateToDay(date: T): Day<T> {\n    const isoDate = this._dateAdapter.toIso8601(date);\n    return {\n      value: isoDate,\n      dateValue: date,\n      dayValue: String(this._dateAdapter.getDate(date)),\n      monthValue: String(this._dateAdapter.getMonth(date)),\n      yearValue: String(this._dateAdapter.getYear(date)),\n      // TODO: Improve performance of this, by keeping track of the\n      // week number while iterating through the days.\n      weekValue: this._getWeek(date),\n      weekDayValue: this._dateAdapter.getDayOfWeek(date),\n    };\n  }\n\n  private _getWeek(date: T): number {\n    const firstDayOfYear = this._dateAdapter.createDate(this._dateAdapter.getYear(date), 1, 1);\n    const weekday = this._dateAdapter.getDayOfWeek(firstDayOfYear);\n\n    let weekIndex = [MONDAY, TUESDAY, WEDNESDAY, THURSDAY].includes(weekday) ? 1 : 0;\n    let weekStart = this._dateAdapter.addCalendarDays(\n      firstDayOfYear,\n      this._dateAdapter.getFirstWeekOffset(firstDayOfYear) * -1,\n    );\n    while (this._dateAdapter.compareDate(weekStart, date) <= 0) {\n      const weekEnd = this._dateAdapter.addCalendarDays(weekStart, 6);\n      if (this._dateAdapter.compareDate(date, weekEnd) <= 0) {\n        return weekIndex > 0\n          ? weekIndex\n          : this._getWeek(this._dateAdapter.addCalendarDays(firstDayOfYear, -1));\n      }\n      weekStart = this._dateAdapter.addCalendarDays(weekStart, DAYS_PER_ROW);\n      weekIndex++;\n    }\n\n    throw new Error('The provided date is invalid');\n  }\n\n  /** Force the conversion to ISO8601 formatted string. */\n  private _mapValueToISODate(value: string | Date): string {\n    return typeof value === 'string' ? value : this._dateAdapter.toIso8601(value as T);\n  }\n\n  /** Creates the rows for the month selection view. */\n  private _createMonthRows(): void {\n    const months: MonthCell[] = new Array(12).fill(null).map(\n      (_, i: number): MonthCell => ({\n        value: String(i + 1).padStart(2, '0'),\n        monthValue: i + 1,\n      }),\n    );\n    const rows: number = 12 / MONTHS_PER_ROW;\n    const monthArray: MonthCell[][] = [];\n    for (let i: number = 0; i < rows; i++) {\n      monthArray.push(months.slice(MONTHS_PER_ROW * i, MONTHS_PER_ROW * (i + 1)));\n    }\n    this._months = monthArray;\n  }\n\n  /** Creates the rows for the year selection view. */\n  private _createYearRows(offset: number = 0): number[][] {\n    const startValueYearView: number = this._getStartValueYearView();\n    const allYears: number[] = new Array(YEARS_PER_PAGE)\n      .fill(0)\n      .map((_, i: number) => startValueYearView + offset + i);\n    const rows: number = YEARS_PER_PAGE / YEARS_PER_ROW;\n    const yearArray: number[][] = [];\n    for (let i: number = 0; i < rows; i++) {\n      yearArray.push(allYears.slice(YEARS_PER_ROW * i, YEARS_PER_ROW * (i + 1)));\n    }\n    return yearArray;\n  }\n\n  /**\n   * Calculates the first year that will be shown in the year selection panel.\n   * If `minDate` and `maxDate` are both null, the starting year is calculated as\n   * the multiple of YEARS_PER_PAGE closest to and less than activeDate,\n   * e.g., with `YEARS_PER_PAGE` = 24 and `activeDate` = 2020, the function will return 2016 (24 * 83),\n   * while with `activeDate` = 2000, the function will return 1992 (24 * 82).\n   * If `minDate` is not null, it returns the corresponding year; if `maxDate` is not null,\n   * it returns the corresponding year minus `YEARS_PER_PAGE`, so that the `maxDate` is the last rendered year.\n   * If both are not null, `maxDate` has priority over `minDate`.\n   */\n  private _getStartValueYearView(): number {\n    let startingYear = 0;\n    if (this.max) {\n      startingYear = this._dateAdapter.getYear(this.max) - YEARS_PER_PAGE + 1;\n    } else if (this.min) {\n      startingYear = this._dateAdapter.getYear(this.min);\n    }\n    const activeYear = this._dateAdapter.getYear(this._activeDate);\n    return (\n      activeYear -\n      ((((activeYear - startingYear) % YEARS_PER_PAGE) + YEARS_PER_PAGE) % YEARS_PER_PAGE)\n    );\n  }\n\n  /** Checks if date is within the min-max range. */\n  private _isDayInRange(dateString: string): boolean {\n    if (!this.min && !this.max) {\n      return true;\n    }\n    const date = this._dateAdapter.deserialize(dateString)!;\n    return this._dateAdapter.sameDate(date, this._dateAdapter.clampDate(date, this.min, this.max));\n  }\n\n  /** Emits the selected date and sets it internally. */\n  private _selectDate(day: T): void {\n    this._chosenMonth = undefined;\n    this._setChosenYear();\n    if (this.multiple) {\n      // Check if _selected has elements\n      if (this._selected && (this._selected as T[]).length > 0) {\n        const indexOfSelectedDay: number = (this._selected as T[]).findIndex(\n          (sel) => this._dateAdapter.compareDate(sel, day) === 0,\n        );\n        // If the selected date is already in the _selected array, remove it, otherwise add it\n        if (indexOfSelectedDay !== -1) {\n          this._selected = (this._selected as T[]).filter((_, i) => i !== indexOfSelectedDay);\n        } else {\n          this._selected = [...(this._selected as T[]), day];\n        }\n      } else {\n        // If _selected is empty, set it\n        this._selected = [day];\n      }\n      this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)!));\n    } else {\n      // In single selection, check if the day is already selected\n      if (!this._selected || this._dateAdapter.compareDate(this._selected as T, day) !== 0) {\n        this._selected = day;\n        this._emitDateSelectedEvent(this._dateAdapter.deserialize(day)!);\n      }\n    }\n  }\n\n  /**\n   * Handle multiple dates selection via weekNumber / weekDay buttons:\n   * - if Cmd or Ctrl are pressed, add the new date to the current ones;\n   * - if not,\n   *     - if the new dates are the same of the current ones, it means that the same button has been clicked twice, so do nothing;\n   *     - if not, the selected dates are the new ones.\n   */\n  private _selectMultipleDates(days: Day<T>[]): void {\n    // Filter disabled days by matching the provided `days` parameter against the enabled cells.\n    // Since the buttons' value is set to the Day's interface value (ISO string), there's no need to deserialize it.\n    const enabledDays: string[] = (this._cells as SbbCalendarDayElement[])\n      .filter((e) => !e.disabled)\n      .map((e) => this._mapValueToISODate(e.value!));\n    const daysToAdd: string[] = days\n      .map((e: Day<T>) => e.value)\n      .filter((isoDate: string) => enabledDays.includes(isoDate));\n    const daysToAddSet = new Set(daysToAdd);\n    const selectedSet = new Set((this._selected as T[]).map((s) => this._dateAdapter.toIso8601(s)));\n    const selStrings = this._updateSelectedWithMultipleDates(daysToAdd, daysToAddSet, selectedSet);\n    this._selected = selStrings.map((s) => this._dateAdapter.deserialize(s)!);\n\n    this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)!));\n  }\n\n  /**\n   * Emits the dateselected event given the detail (as T or T[] based on the value of the multiple flag).\n   */\n  private _emitDateSelectedEvent(detail: T | T[]): void {\n    /** @type {CustomEvent<T | T[]>} Event emitted on date selection. */\n    this.dispatchEvent(\n      new CustomEvent<T | T[]>('dateselected', {\n        detail,\n        composed: true,\n        bubbles: true,\n      }),\n    );\n  }\n\n  private _emitMonthChange(): void {\n    // FIXME: the name of this variable appears as event name in the readme\n    //  due to a bug in the custom-elements-manifest library.\n    //  https://github.com/open-wc/custom-elements-manifest/issues/149\n    const monthchange = (this.wide ? [...this._weeks, ...this._nextMonthWeeks] : this._weeks)\n      .flat()\n      .sort((a, b) => a.value.localeCompare(b.value)) as Day[];\n    /**\n     * @type {SbbMonthChangeEvent}\n     * Emits when the month changes.\n     * The `range` property contains the days array of the chosen month.\n     */\n    this.dispatchEvent(new SbbMonthChangeEvent(monthchange));\n  }\n\n  /**\n   * In case of multiple selection, newly added days must be added to the existing ones, without duplication.\n   * If the days to add are exactly the same as the selected ones, the set must be emptied.\n   */\n  private _updateSelectedWithMultipleDates(\n    daysToAdd: string[],\n    daysToAddSet: Set<string>,\n    selectedSet: Set<string>,\n  ): string[] {\n    if (daysToAdd.every((day: string) => selectedSet.has(day))) {\n      daysToAddSet.forEach((day: string) => selectedSet.delete(day));\n    } else {\n      daysToAddSet.forEach((day: string) => selectedSet.add(day));\n    }\n    return Array.from(selectedSet);\n  }\n\n  private _setChosenYear(): void {\n    if (this.view === 'month') {\n      let selectedDate: T | undefined;\n      if (this.multiple) {\n        selectedDate = (this.selected as T[]).at(-1);\n      } else {\n        selectedDate = this.selected as T;\n      }\n      this._chosenYear = this._dateAdapter.getYear(selectedDate ?? this._dateAdapter.today());\n    } else {\n      this._chosenYear = undefined;\n    }\n  }\n\n  private _assignActiveDate(date: T): void {\n    if (this.min && this._dateAdapter.compareDate(this.min, date) > 0) {\n      this._activeDate = this.min;\n      return;\n    }\n    if (this.max && this._dateAdapter.compareDate(this.max, date) < 0) {\n      this._activeDate = this.max;\n      return;\n    }\n    this._activeDate = date;\n  }\n\n  /** Goes to the month identified by the shift. */\n  private _goToDifferentMonth(months: number): void {\n    this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));\n    this._emitMonthChange();\n  }\n\n  private _goToDifferentYear(years: number): void {\n    this._chosenYear! += years;\n    // Can't use `_assignActiveDate(...)` here, because it will set it to min/max value if argument is out of range\n    this._activeDate = this._dateAdapter.createDate(\n      this._chosenYear!,\n      this._dateAdapter.getMonth(this._activeDate),\n      this._dateAdapter.getDate(this._activeDate),\n    );\n    this._init();\n  }\n\n  private _goToDifferentYearRange(years: number): void {\n    this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));\n  }\n\n  private _prevDisabled(prevDate: T): boolean {\n    if (!this.min) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(prevDate, this.min) < 0;\n  }\n\n  private _nextDisabled(nextDate: T): boolean {\n    if (!this.max) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(nextDate, this.max) > 0;\n  }\n\n  /** Checks if the \"previous month\" button should be disabled. */\n  private _previousMonthDisabled(): boolean {\n    const prevMonth = this._dateAdapter.addCalendarDays(\n      this._activeDate,\n      this._dateAdapter.getDate(this._activeDate) * -1,\n    );\n    return this._prevDisabled(prevMonth);\n  }\n\n  /** Checks if the \"next month\" button should be disabled. */\n  private _nextMonthDisabled(): boolean {\n    let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);\n    nextMonth = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(nextMonth),\n      this._dateAdapter.getMonth(nextMonth),\n      1,\n    );\n    return this._nextDisabled(nextMonth);\n  }\n\n  /** Checks if the \"previous year\" button should be disabled. */\n  private _previousYearDisabled(): boolean {\n    const prevYear = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(this._activeDate) - 1,\n      12,\n      31,\n    );\n    return this._prevDisabled(prevYear);\n  }\n\n  /** Checks if the \"next year\" button should be disabled. */\n  private _nextYearDisabled(): boolean {\n    const nextYear = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(this._activeDate) + (this._wide ? 2 : 1),\n      1,\n      1,\n    );\n    return this._nextDisabled(nextYear);\n  }\n\n  /** Checks if the \"previous year\" button should be disabled in year view. */\n  private _previousYearRangeDisabled(): boolean {\n    const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);\n    return this._prevDisabled(prevYear);\n  }\n\n  /** Checks if the \"next year\" button should be disabled in year view. */\n  private _nextYearRangeDisabled(): boolean {\n    const years = this._wide ? this._nextMonthYears : this._years;\n    const lastYearRange = years[years.length - 1];\n    const lastYear = lastYearRange[lastYearRange.length - 1];\n    const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);\n    return this._nextDisabled(nextYear);\n  }\n\n  private _handleTableBlur(eventTarget: HTMLElement): void {\n    if (eventTarget?.localName !== 'sbb-calendar-day') {\n      this._setTabIndex();\n    }\n  }\n\n  private _setTabIndex(): void {\n    Array.from(this._cells.filter((e) => e.tabIndex === 0) ?? []).forEach(\n      (day) => (day.tabIndex = -1),\n    );\n    const firstFocusable = this._getFirstFocusable();\n    if (firstFocusable) {\n      firstFocusable.tabIndex = 0;\n    }\n  }\n\n  /** Get the element in the calendar to assign focus. */\n  private _getFirstFocusable(): SbbCalendarCellBaseElement | null {\n    if (this._calendarView === 'day') {\n      const selectedOrCurrent =\n        this._cells.find((e) => e.matches(':state(selected)')) ??\n        this._cells.find((e) => e.matches(':state(current)'));\n      return selectedOrCurrent && !selectedOrCurrent.disabled\n        ? selectedOrCurrent\n        : this._getFirstFocusableDay();\n    } else {\n      const selectedOrCurrent =\n        this.shadowRoot?.querySelector<SbbCalendarCellBaseElement>(':state(selected)') ??\n        this.shadowRoot?.querySelector<SbbCalendarCellBaseElement>(':state(current)');\n      return selectedOrCurrent && !selectedOrCurrent.disabled\n        ? selectedOrCurrent\n        : this.shadowRoot!.querySelector<SbbCalendarCellBaseElement>(\n            `sbb-calendar-${this._calendarView}:not([disabled])`,\n          );\n    }\n  }\n\n  /**\n   * In `day` view in `vertical` orientation,\n   * if the first of the month is not a Monday, it is not the first rendered element in the table,\n   * so `this.shadowRoot!.querySelector('sbb-calendar-day:not([disabled])')` will return a wrong value.\n   *\n   * To solve this, the element with the lowest `value` is taken (ISO String are ordered).\n   */\n  private _getFirstFocusableDay(): SbbCalendarDayElement | null {\n    const cells = this._cells as SbbCalendarDayElement[];\n    const daysInView = cells.filter((e) => !e.disabled);\n    if (!daysInView || daysInView.length === 0) {\n      return null;\n    } else {\n      const firstElement = daysInView\n        .map((e): string => this._dateAdapter.toIso8601(e.value! as T))\n        .sort()[0];\n      return cells.find((e) => e.matches(`[slot=\"${firstElement}\"]`))! ?? null;\n    }\n  }\n\n  private _handleKeyboardEvent(event: KeyboardEvent, day?: Day<T>): void {\n    if (isArrowKeyOrPageKeysPressed(event)) {\n      event.preventDefault();\n    }\n    // Gets the currently rendered table's cell;\n    // they could be days, months or years based on the current selection view.\n    // If `wide` is true, years are doubled in number and days are (roughly) doubled too, affecting the `index` calculation.\n    const cells = this._cells;\n    const index: number = cells.findIndex((e) => e === event.target);\n    let nextEl: SbbCalendarCellBaseElement;\n    if (day) {\n      nextEl = this._navigateByKeyboardDayView(event, index, cells as SbbCalendarDayElement[], day);\n    } else {\n      nextEl = this._navigateByKeyboard(event, index, cells);\n    }\n    const activeEl = (this._enhancedVariant ? document : this.shadowRoot!)\n      .activeElement as SbbCalendarCellBaseElement;\n    if (nextEl !== activeEl) {\n      nextEl.tabIndex = 0;\n      nextEl?.focus();\n      activeEl.tabIndex = -1;\n    }\n  }\n\n  private _navigateByKeyboardDayView(\n    evt: KeyboardEvent,\n    index: number,\n    cells: SbbCalendarDayElement[],\n    day: Day<T>,\n  ): SbbCalendarDayElement {\n    const arrowsOffset =\n      this.orientation === 'horizontal'\n        ? { leftRight: 1, upDown: DAYS_PER_ROW }\n        : { leftRight: DAYS_PER_ROW, upDown: 1 };\n    const offsetForVertical: number =\n      index < this._keyboardNavigationDayViewParameters.firstMonthLength\n        ? this._keyboardNavigationDayViewParameters.firstMonthOffset\n        : this._keyboardNavigationDayViewParameters.secondMonthOffset;\n\n    switch (evt.key) {\n      case 'ArrowUp':\n        return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.upDown);\n      case 'ArrowDown':\n        return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.upDown);\n      case 'ArrowLeft':\n        return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.leftRight);\n      case 'ArrowRight':\n        return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.leftRight);\n      case 'PageUp': {\n        if (this.orientation === 'horizontal') {\n          const firstOfWeek: number = +day.dayValue % DAYS_PER_ROW || DAYS_PER_ROW;\n          const delta: number = firstOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);\n        } else {\n          const weekNumber: number = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);\n          const firstOfWeek: number = (weekNumber - 1) * DAYS_PER_ROW - offsetForVertical + 1;\n          const delta: number = firstOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);\n        }\n      }\n      case 'PageDown': {\n        if (this.orientation === 'horizontal') {\n          const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;\n          const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;\n          const firstNextMonth: T = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);\n          const lastOfMonth: number = this._dateAdapter.getDate(\n            this._dateAdapter.addCalendarDays(firstNextMonth, -1),\n          );\n          const delta: number =\n            Math.trunc((lastOfMonth - +day.dayValue!) / DAYS_PER_ROW) * DAYS_PER_ROW;\n          return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);\n        } else {\n          const weekNumber: number = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);\n          const lastOfWeek: number = weekNumber * DAYS_PER_ROW - offsetForVertical;\n          const delta: number = lastOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);\n        }\n      }\n      case 'Home': {\n        return this._findDayFirst(cells, index, day, 1);\n      }\n      case 'End': {\n        const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;\n        const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;\n        const firstNextMonth: T = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);\n        return this._findDayLast(cells, index, firstNextMonth);\n      }\n      default:\n        return cells[index];\n    }\n  }\n\n  private _isDayOutOfView(date: string): boolean {\n    return (\n      date < this._keyboardNavigationDayViewParameters.firstDayInView! ||\n      date > this._keyboardNavigationDayViewParameters.lastDayInView!\n    );\n  }\n\n  private _findDayArrows(\n    cells: SbbCalendarDayElement[],\n    index: number,\n    date: T,\n    delta: number,\n  ): SbbCalendarDayElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(date, delta),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => this._mapValueToISODate(e.value!) === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayArrows(cells, index, this._dateAdapter.deserialize(newDateValue)!, delta);\n    }\n    return nextCell;\n  }\n\n  private _findDayPageUpDown(\n    cells: SbbCalendarDayElement[],\n    index: number,\n    day: Day<T>,\n    delta: number,\n    deltaIfDisabled: number,\n  ): SbbCalendarDayElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(day.dateValue, delta),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => this._mapValueToISODate(e.value!) === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayPageUpDown(cells, index, day, delta + deltaIfDisabled, deltaIfDisabled);\n    }\n    return nextCell;\n  }\n\n  private _findDayFirst(\n    cells: SbbCalendarDayElement[],\n    index: number,\n    day: Day<T>,\n    date: number,\n  ): SbbCalendarDayElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.createDate(+day.yearValue, +day.monthValue, date),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => this._mapValueToISODate(e.value!) === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayFirst(cells, index, day, date + 1);\n    }\n    return nextCell;\n  }\n\n  private _findDayLast(\n    cells: SbbCalendarDayElement[],\n    index: number,\n    firstNextMonth: T,\n  ): SbbCalendarDayElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(firstNextMonth, -1),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => this._mapValueToISODate(e.value!) === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayLast(cells, index, this._dateAdapter.deserialize(newDateValue)!);\n    }\n    return nextCell;\n  }\n\n  /**\n   * Gets the index of the element to move to, based on a list of elements (which can be potentially disabled),\n   * the keyboard input and the position of the current element in the list.\n   * In the day view, the `day?: Day` parameter is mandatory for calculation,\n   * while in month and year view it's not due to the fixed amount of rendered cells.\n   */\n  private _navigateByKeyboard(\n    evt: KeyboardEvent,\n    index: number,\n    cells: SbbCalendarCellBaseElement[],\n  ): SbbCalendarCellBaseElement {\n    const {\n      elementIndexForWideMode,\n      offsetForWideMode,\n      lastElementIndexForWideMode,\n      verticalOffset,\n    }: CalendarKeyboardNavigationMonthYearViewsParameters =\n      this._calculateParametersForKeyboardNavigation(index, this._calendarView === 'year');\n\n    switch (evt.key) {\n      case 'ArrowUp':\n        return this._findNext(cells, index, -verticalOffset);\n      case 'ArrowDown':\n        return this._findNext(cells, index, verticalOffset);\n      case 'ArrowLeft':\n        return this._findNext(cells, index, -1);\n      case 'ArrowRight':\n        return this._findNext(cells, index, 1);\n      case 'Home':\n        return this._findFirst(cells, offsetForWideMode);\n      case 'PageUp':\n        return this._findFirstOnColumn(\n          cells,\n          elementIndexForWideMode,\n          offsetForWideMode,\n          verticalOffset,\n        );\n      case 'PageDown':\n        return this._findLastOnColumn(cells, index, lastElementIndexForWideMode, verticalOffset);\n      case 'End':\n        return this._findLast(cells, lastElementIndexForWideMode - 1);\n      default:\n        return cells[index];\n    }\n  }\n\n  /**\n   * Calculates the parameters needed in keyboard navigation in year and month view.\n   * @param index The starting element's index in the cell array.\n   * @param isYearView Whether the displayed `view` is the year one.\n   */\n  private _calculateParametersForKeyboardNavigation(\n    index: number,\n    isYearView: boolean,\n  ): CalendarKeyboardNavigationMonthYearViewsParameters {\n    const elementsPerPage = isYearView ? YEARS_PER_PAGE : MONTHS_PER_PAGE;\n    const offset: number = Math.trunc(index / elementsPerPage) * elementsPerPage;\n    const indexInView: number = offset === 0 ? index : index - elementsPerPage;\n    return {\n      verticalOffset: isYearView ? YEARS_PER_ROW : MONTHS_PER_ROW,\n      elementIndexForWideMode: indexInView,\n      offsetForWideMode: index - indexInView,\n      lastElementIndexForWideMode: offset === 0 ? elementsPerPage : elementsPerPage * 2,\n    };\n  }\n\n  /**\n   * Gets the next element of the provided array starting from `index` by adding `delta`.\n   * If the found element is disabled, it continues adding `delta` until it finds an enabled one in the array bounds.\n   */\n  private _findNext(\n    days: SbbCalendarCellBaseElement[],\n    index: number,\n    delta: number,\n  ): SbbCalendarCellBaseElement {\n    let nextIndex = index + delta;\n    while (nextIndex < days.length && days[nextIndex]?.disabled) {\n      nextIndex += delta;\n    }\n    return days[nextIndex] ?? days[index];\n  }\n\n  /** Find the first enabled element in the provided array. */\n  private _findFirst(\n    days: SbbCalendarCellBaseElement[],\n    firstOfCurrentMonth: number,\n  ): SbbCalendarCellBaseElement {\n    return !days[firstOfCurrentMonth].disabled\n      ? days[firstOfCurrentMonth]\n      : this._findNext(days, firstOfCurrentMonth, 1);\n  }\n\n  /** Find the last enabled element in the provided array. */\n  private _findLast(\n    days: SbbCalendarCellBaseElement[],\n    lastOfCurrentMonth: number,\n  ): SbbCalendarCellBaseElement {\n    return !days[lastOfCurrentMonth].disabled\n      ? days[lastOfCurrentMonth]\n      : this._findNext(days, lastOfCurrentMonth, -1);\n  }\n\n  /** Find the first enabled element in the same column of the provided array. */\n  private _findFirstOnColumn(\n    days: SbbCalendarCellBaseElement[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): SbbCalendarCellBaseElement {\n    const nextIndex = (index % verticalOffset) + offset;\n    return !days[nextIndex].disabled\n      ? days[nextIndex]\n      : this._findNext(days, nextIndex, verticalOffset);\n  }\n\n  /** Find the last enabled element in the same column of the provided array. */\n  private _findLastOnColumn(\n    days: SbbCalendarCellBaseElement[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): SbbCalendarCellBaseElement {\n    const nextIndex = index + Math.trunc((offset - index - 1) / verticalOffset) * verticalOffset;\n    return !days[nextIndex].disabled\n      ? days[nextIndex]\n      : this._findNext(days, nextIndex, -verticalOffset);\n  }\n\n  private _resetCalendarViewAndEmitMonthChange(initTransition = false): void {\n    this._resetCalendarView(initTransition);\n    this._emitMonthChange();\n  }\n\n  private _resetCalendarView(initTransition = false): void {\n    if (this._containingFocus) {\n      this._resetFocus = true;\n    }\n    this._activeDate =\n      (this.multiple ? (this._selected as T[]).at(-1) : (this._selected as T)) ??\n      this._dateAdapter.today();\n    this._setChosenYear();\n    this._chosenMonth = undefined;\n    this._init();\n    this._nextCalendarView = this._calendarView = this.view;\n\n    if (initTransition) {\n      this._startTableTransition();\n    }\n  }\n\n  /** Render the view for the day selection. */\n  private _renderDayView(): TemplateResult {\n    const nextMonthActiveDate = this._wide\n      ? this._dateAdapter.addCalendarMonths(this._activeDate, 1)\n      : undefined;\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentMonth(-1),\n          i18nPreviousMonth[this._language.current],\n          this._previousMonthDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">\n          ${this._createLabelForDayView(this._activeDate)}\n          ${this._wide ? this._createLabelForDayView(nextMonthActiveDate!) : nothing}\n          <sbb-screen-reader-only role=\"status\">\n            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate!)}\n          </sbb-screen-reader-only>\n        </div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentMonth(1),\n          i18nNextMonth[this._language.current],\n          this._nextMonthDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-overflow-break\">\n        <div class=\"sbb-calendar__table-container sbb-calendar__table-day-view\">\n          ${this.orientation === 'horizontal'\n            ? html`\n                ${this._createDayTable(this._weeks, this._weekNumbers)}\n                ${this._wide\n                  ? this._createDayTable(this._nextMonthWeeks, this._nextMonthWeekNumbers, true)\n                  : nothing}\n              `\n            : html`\n                ${this._createDayTableVertical(this._weeks, this._weekNumbers)}\n                ${this._wide\n                  ? this._createDayTableVertical(\n                      this._nextMonthWeeks,\n                      this._nextMonthWeekNumbers,\n                      nextMonthActiveDate,\n                    )\n                  : nothing}\n              `}\n        </div>\n      </div>\n    `;\n  }\n\n  /** Creates the label with the month for the daily view. */\n  private _createLabelForDayView(d: T): TemplateResult {\n    const monthLabel = `${\n      this._monthNames[this._dateAdapter.getMonth(d) - 1]\n    } ${this._dateAdapter.getYear(d)}`;\n    return html`\n      <button\n        type=\"button\"\n        class=\"sbb-calendar__date-selection sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nYearMonthSelection[this._language.current]} ${monthLabel}\"\n        @click=${() => {\n          this._resetFocus = true;\n          this._nextCalendarView = 'year';\n          this._startTableTransition();\n        }}\n      >\n        ${monthLabel}\n        <sbb-icon name=\"chevron-small-down-small\"></sbb-icon>\n      </button>\n    `;\n  }\n\n  /** Creates the aria-label for the daily view. */\n  private _createAriaLabelForDayView(...dates: T[]): string {\n    let monthLabel = '';\n    for (const d of dates) {\n      if (d) {\n        monthLabel += `${\n          this._monthNames[this._dateAdapter.getMonth(d) - 1]\n        } ${this._dateAdapter.getYear(d)} `;\n      }\n    }\n    return monthLabel;\n  }\n\n  /** Creates the calendar table for the daily view. */\n  private _createDayTable(\n    weeks: Day<T>[][],\n    weekNumbers: number[],\n    isWideNextMonth: boolean = false,\n  ): TemplateResult {\n    const weeksForSelectMultipleWeekNumbers: Day<T>[] = (\n      this._wide\n        ? [...this._weeks, ...this._nextMonthWeeks]\n        : isWideNextMonth\n          ? this._nextMonthWeeks\n          : this._weeks\n    ).flat();\n    const weeksForSelectMultipleWeekDays: Day<T>[] = (\n      isWideNextMonth ? this._nextMonthWeeks : this._weeks\n    ).flat();\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @focusout=${(event: FocusEvent) =>\n          this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        <thead class=\"sbb-calendar__table-header\">\n          <tr>\n            ${this.weekNumbers ? html`<th class=\"sbb-calendar__table-header-cell\"></th>` : nothing}\n            ${this._weekdays.map(\n              (weekDay: Weekday, index: number) => html`\n                <th class=\"sbb-calendar__table-header-cell\">\n                  ${this.multiple\n                    ? html`\n                        <sbb-calendar-weekday\n                          .value=${weekDay}\n                          @click=${() => {\n                            // NOTE: Sundays have index 7, while their weekDayValue is 0\n                            const days: Day<T>[] = weeksForSelectMultipleWeekDays.filter(\n                              (day: Day<T>) => day.weekDayValue === (index + 1) % 7,\n                            )!;\n                            this._selectMultipleDates(days);\n                          }}\n                        ></sbb-calendar-weekday>\n                      `\n                    : html`\n                        <sbb-screen-reader-only>${weekDay.long}</sbb-screen-reader-only>\n                        <span aria-hidden=\"true\">${weekDay.narrow}</span>\n                      `}\n                </th>\n              `,\n            )}\n          </tr>\n        </thead>\n        <tbody class=\"sbb-calendar__table-body\">\n          ${weeks.map((week: Day<T>[], rowIndex: number) => {\n            const firstRowOffset: number = DAYS_PER_ROW - week.length;\n            if (rowIndex === 0 && firstRowOffset) {\n              return html`\n                <tr>\n                  ${this.weekNumbers\n                    ? html`\n                        <td class=\"sbb-calendar__table-header-cell-vertical\">\n                          ${this.multiple\n                            ? html`\n                                <sbb-calendar-weeknumber\n                                  .value=${weekNumbers[0]}\n                                  @click=${() => {\n                                    const days: Day<T>[] = weeksForSelectMultipleWeekNumbers.filter(\n                                      (day: Day<T>) => day.weekValue === weekNumbers[0],\n                                    )!;\n                                    this._selectMultipleDates(days);\n                                  }}\n                                ></sbb-calendar-weeknumber>\n                              `\n                            : html`\n                                <sbb-screen-reader-only\n                                  >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[0]}`}</sbb-screen-reader-only\n                                >\n                                <span aria-hidden=\"true\">${weekNumbers[0]}</span>\n                              `}\n                        </td>\n                      `\n                    : nothing}\n                  ${[...Array(firstRowOffset).keys()].map(\n                    () => html`<td class=\"sbb-calendar__table-data\"></td>`,\n                  )}\n                  ${this._createDayCells(week)}\n                </tr>\n              `;\n            }\n            return html`\n              <tr>\n                ${this.weekNumbers\n                  ? html`\n                      <td class=\"sbb-calendar__table-header-cell-vertical\">\n                        ${this.multiple\n                          ? html`\n                              <sbb-calendar-weeknumber\n                                .value=${weekNumbers[rowIndex]}\n                                @click=${() => {\n                                  const days: Day<T>[] = weeksForSelectMultipleWeekNumbers.filter(\n                                    (day: Day<T>) => day.weekValue === weekNumbers[rowIndex],\n                                  )!;\n                                  this._selectMultipleDates(days);\n                                }}\n                              ></sbb-calendar-weeknumber>\n                            `\n                          : html`\n                              <sbb-screen-reader-only\n                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[rowIndex]}`}</sbb-screen-reader-only\n                              >\n                              <span aria-hidden=\"true\">${weekNumbers[rowIndex]}</span>\n                            `}\n                      </td>\n                    `\n                  : nothing}\n                ${this._createDayCells(week)}\n              </tr>\n            `;\n          })}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Creates the table in orientation='vertical'. */\n  private _createDayTableVertical(\n    weeks: Day<T>[][],\n    weekNumbers: number[],\n    nextMonthActiveDate?: T,\n  ): TemplateResult {\n    const weekOffset = this._dateAdapter.getFirstWeekOffset(\n      nextMonthActiveDate ?? this._activeDate,\n    );\n    const weeksForSelectMultipleWeekNumbers: Day<T>[] = (\n      this._wide\n        ? [...this._weeks, ...this._nextMonthWeeks]\n        : nextMonthActiveDate\n          ? this._nextMonthWeeks\n          : this._weeks\n    ).flat();\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @focusout=${(event: FocusEvent) =>\n          this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        ${this.weekNumbers\n          ? html`\n              <thead class=\"sbb-calendar__table-header\">\n                <tr>\n                  ${nextMonthActiveDate\n                    ? nothing\n                    : html`<th class=\"sbb-calendar__table-data\"></th>`}\n                  ${weekNumbers.map(\n                    (weekNumber: number) => html`\n                      <th class=\"sbb-calendar__table-header-cell\">\n                        ${this.multiple\n                          ? html`\n                              <sbb-calendar-weeknumber\n                                .value=${weekNumber}\n                                @click=${() => {\n                                  const days: Day<T>[] = weeksForSelectMultipleWeekNumbers.filter(\n                                    (day: Day<T>) => day.weekValue === weekNumber,\n                                  )!;\n                                  this._selectMultipleDates(days);\n                                }}\n                              ></sbb-calendar-weeknumber>\n                            `\n                          : html`\n                              <sbb-screen-reader-only\n                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumber}`}</sbb-screen-reader-only\n                              >\n                              <span aria-hidden=\"true\">${weekNumber}</span>\n                            `}\n                      </th>\n                    `,\n                  )}\n                </tr>\n              </thead>\n            `\n          : nothing}\n        <tbody class=\"sbb-calendar__table-body\">\n          ${weeks.map((week: Day<T>[], rowIndex: number) => {\n            const weekday = this._weekdays[rowIndex];\n            const selectableDays = this._wide ? [...week, ...this._nextMonthWeeks[rowIndex]] : week;\n            return html`\n              <tr>\n                ${nextMonthActiveDate\n                  ? nothing\n                  : html`\n                      <td class=\"sbb-calendar__table-header-cell-vertical\">\n                        ${this.multiple\n                          ? html`\n                              <sbb-calendar-weekday\n                                .value=${weekday}\n                                @click=${() => this._selectMultipleDates(selectableDays)}\n                              >\n                                ${weekday.narrow}\n                              </sbb-calendar-weekday>\n                            `\n                          : html`\n                              <sbb-screen-reader-only>${weekday.long}</sbb-screen-reader-only>\n                              <span aria-hidden=\"true\">${weekday.narrow}</span>\n                            `}\n                      </td>\n                    `}\n                ${rowIndex < weekOffset\n                  ? html`<td class=\"sbb-calendar__table-data\"></td>`\n                  : nothing}\n                ${this._createDayCells(week)}\n              </tr>\n            `;\n          })}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Creates the cells for the daily view. */\n  private _createDayCells(week: Day<T>[]): TemplateResult[] {\n    return week.map((day: Day<T>) => {\n      return html`\n        <td class=\"sbb-calendar__table-data sbb-calendar__day-cell\">\n          <slot name=${day.value}>\n            <sbb-calendar-day\n              slot=${day.value}\n              @click=${() => this._selectDate(day.dateValue)}\n              @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt, day)}\n            ></sbb-calendar-day>\n          </slot>\n        </td>\n      `;\n    });\n  }\n\n  /** Render the view for the month selection. */\n  private _renderMonthView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYear(-1),\n          i18nPreviousYear[this._language.current],\n          this._previousYearDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForMonthView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYear(1),\n          i18nNextYear[this._language.current],\n          this._nextYearDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-overflow-break\">\n        <div class=\"sbb-calendar__table-container sbb-calendar__table-month-view\">\n          ${this._createMonthTable(this._months, this._chosenYear!)}\n          ${this._wide ? this._createMonthTable(this._months, this._chosenYear! + 1) : nothing}\n        </div>\n      </div>\n    `;\n  }\n\n  /** Creates the label with the year for the monthly view. */\n  private _createLabelForMonthView(): TemplateResult {\n    return html` <button\n        type=\"button\"\n        id=\"sbb-calendar__month-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=${`${i18nCalendarDateSelection[this._language.current]} ${this._chosenYear}`}\n        @click=${() => this._resetCalendarViewAndEmitMonthChange(true)}\n      >\n        ${this._chosenYear} ${this._wide ? ` - ${this._chosenYear! + 1}` : nothing}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${this._chosenYear} </sbb-screen-reader-only>`;\n  }\n\n  /** Creates the table for the month selection view. */\n  private _createMonthTable(months: MonthCell[][], year: number): TemplateResult {\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        ${this._wide\n          ? html`<thead class=\"sbb-calendar__table-header\" aria-hidden=\"true\">\n              <tr>\n                <th class=\"sbb-calendar__table-header-cell\" colspan=${MONTHS_PER_ROW}>${year}</th>\n              </tr>\n            </thead>`\n          : nothing}\n        <tbody class=\"sbb-calendar__table-body\">\n          ${months.map(\n            (row: MonthCell[]) => html`\n              <tr>\n                ${row.map((month: MonthCell) => {\n                  return html`\n                    <td class=\"sbb-calendar__table-data\">\n                      <sbb-calendar-month\n                        .value=\"${year}-${month.value}\"\n                        @click=${() => this._onMonthSelection(month.monthValue, year)}\n                        @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt)}\n                      >\n                      </sbb-calendar-month>\n                    </td>\n                  `;\n                })}\n              </tr>\n            `,\n          )}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Select the month and change the view to day selection. */\n  private _onMonthSelection(month: number, year: number): void {\n    this._chosenMonth = month;\n    this._nextCalendarView = 'day';\n    this._init(\n      this._dateAdapter.createDate(\n        year,\n        this._chosenMonth,\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._startTableTransition();\n    this._emitMonthChange();\n  }\n\n  /** Render the view for the year selection. */\n  private _renderYearView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYearRange(-YEARS_PER_PAGE),\n          i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._previousYearRangeDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForYearView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYearRange(YEARS_PER_PAGE),\n          i18nNextYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._nextYearRangeDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-overflow-break\">\n        <div class=\"sbb-calendar__table-container sbb-calendar__table-year-view\">\n          ${this._createYearTable(this._years)}\n          ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}\n        </div>\n      </div>\n    `;\n  }\n\n  /** Creates the button arrow for all the views. */\n  private _getArrow(\n    direction: 'left' | 'right',\n    click: () => void,\n    ariaLabel: string,\n    disabled: boolean,\n  ): TemplateResult {\n    return html`<sbb-secondary-button\n      size=\"m\"\n      icon-name=\"chevron-small-${direction}-small\"\n      aria-label=${ariaLabel}\n      @click=${click}\n      ?disabled=${disabled}\n      id=\"sbb-calendar__controls-${direction === 'left' ? 'previous' : 'next'}\"\n    ></sbb-secondary-button>`;\n  }\n\n  /** Creates the label with the year range for the yearly view. */\n  private _createLabelForYearView(): TemplateResult {\n    const firstYear: number = this._years.flat()[0];\n    const lastYearArray: number[] = (this._wide ? this._nextMonthYears : this._years).flat();\n    const lastYear: number = lastYearArray[lastYearArray.length - 1];\n    const yearLabel = `${firstYear} - ${lastYear}`;\n    return html`\n      <button\n        type=\"button\"\n        id=\"sbb-calendar__year-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nCalendarDateSelection[this._language.current]} ${yearLabel}\"\n        @click=${() => this._resetCalendarViewAndEmitMonthChange(true)}\n      >\n        ${yearLabel}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${yearLabel} </sbb-screen-reader-only>\n    `;\n  }\n\n  /** Creates the table for the year selection view. */\n  private _createYearTable(years: number[][], shiftRight = false): TemplateResult {\n    return html` <table\n      class=\"sbb-calendar__table\"\n      @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n    >\n      <tbody class=\"sbb-calendar__table-body\">\n        ${years.map(\n          (row: number[]) =>\n            html` <tr>\n              ${row.map((year: number) => {\n                return html`\n                  <td class=\"sbb-calendar__table-data\">\n                    <sbb-calendar-year\n                      .value=${String(year)}\n                      @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt)}\n                      @click=${() => this._onYearSelection(year, shiftRight)}\n                    >\n                    </sbb-calendar-year>\n                  </td>\n                `;\n              })}\n            </tr>`,\n        )}\n      </tbody>\n    </table>`;\n  }\n\n  /** Select the year and change the view to month selection. */\n  private _onYearSelection(year: number, rightSide: boolean): void {\n    this._chosenYear = rightSide ? year - 1 : year;\n    this._nextCalendarView = 'month';\n    this._assignActiveDate(\n      this._dateAdapter.createDate(\n        this._chosenYear,\n        this._dateAdapter.getMonth(this._activeDate),\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._startTableTransition();\n  }\n\n  private _getView(): TemplateResult {\n    if (isServer || this.hydrationRequired) {\n      // TODO: We disable SSR for calendar for now. Figure out, if there is a way\n      // to enable it, while considering i18n and date information.\n      return html`${nothing}`;\n    }\n    switch (this._calendarView) {\n      case 'year':\n        return this._renderYearView();\n      case 'month':\n        return this._renderMonthView();\n      case 'day':\n      default:\n        return this._renderDayView();\n    }\n  }\n\n  private _tableAnimationEnd(event: AnimationEvent): void {\n    const table = event.target as HTMLElement;\n    if (event.animationName === 'hide') {\n      table.classList.remove('sbb-calendar__table-hide');\n      if (this._containingFocus) {\n        this._resetFocus = true;\n      }\n      this._calendarView = this._nextCalendarView;\n    } else if (event.animationName === 'show') {\n      this.internals.states.delete('transition');\n    }\n  }\n\n  private _startTableTransition(): void {\n    this.internals.states.add('transition');\n    this.shadowRoot\n      ?.querySelectorAll('table')\n      ?.forEach((e) => e.classList.toggle('sbb-calendar__table-hide'));\n  }\n\n  protected override render(): TemplateResult {\n    return html`<div class=\"sbb-calendar__wrapper\">${this._getView()}</div>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-calendar': SbbCalendarElement;\n  }\n  interface HTMLElementEventMap {\n    monthchange: SbbMonthChangeEvent;\n  }\n}\n"],"mappings":"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"}