@sbb-esta/lyne-elements-dev 5.0.0-next.3-dev.1779242419 → 5.0.0-next.3-dev.1779265349

package/development/calendar.component-CG96KGTg.js

@@ -0,0 +1,1469 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, nothing, unsafeCSS } from "lit";
+import { property, state } from "lit/decorators.js";
+import { DAYS_PER_ROW, MONDAY, MONTHS_PER_PAGE, MONTHS_PER_ROW, SbbElement, SbbLanguageController, SbbMediaMatcherController, SbbMediaQueryBreakpointLargeAndAbove, THURSDAY, TUESDAY, WEDNESDAY, YEARS_PER_PAGE, YEARS_PER_ROW, defaultDateAdapter, forceType, handleDistinctChange, i18nCalendarDateSelection, i18nCalendarWeekNumber, i18nNextMonth, i18nNextYear, i18nNextYearRange, i18nPreviousMonth, i18nPreviousYear, i18nPreviousYearRange, i18nYearMonthSelection, isArrowKeyOrPageKeysPressed, plainDate, readConfig, screenReaderOnlyStyles } from "./core.js";
+import { SbbSecondaryButtonElement } from "./button.pure.js";
+import { SbbIconElement } from "./icon.pure.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";
+//#region src/elements/calendar/calendar/calendar.scss?inline
+var calendar_default = ":host {\n  display: block;\n  width: max-content;\n  line-height: var(--sbb-typo-line-height-text);\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  line-height: 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
+var SbbMonthChangeEvent = class extends Event {
+	get range() {
+		return this._range;
+	}
+	constructor(range) {
+		super("monthchange", {
+			bubbles: true,
+			composed: true
+		});
+		this._range = Object.freeze(range || []);
+	}
+};
+var SbbDateSelectedEvent = class extends Event {
+	get dateSelected() {
+		return this._dateSelected;
+	}
+	constructor(dates) {
+		super("dateselected", {
+			bubbles: true,
+			composed: true
+		});
+		this._dateSelected = Object.freeze(dates);
+	}
+};
+/**
+* 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.elementDependencies = [
+				SbbCalendarDayElement,
+				SbbCalendarMonthElement,
+				SbbCalendarWeekdayElement,
+				SbbCalendarWeeknumberElement,
+				SbbCalendarYearElement,
+				SbbIconElement,
+				SbbSecondaryButtonElement
+			];
+		}
+		static {
+			this.styles = [screenReaderOnlyStyles, 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)).sort(this._sortDate);
+			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._lastSelection = null;
+			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._sortDate = (a, b) => this._dateAdapter.compareDate(a, b);
+			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);
+			const resolveDay = (event) => event.target.closest("sbb-calendar-day") ?? event.composedPath().find((e) => e.localName === "sbb-calendar-day") ?? null;
+			this.addEventListener("click", (event) => {
+				const day = resolveDay(event);
+				if (day) this._selectDate(day.value, event);
+			});
+			this.addEventListener("keydown", (event) => {
+				const day = resolveDay(event);
+				if (day) this._handleKeyboardEvent(event, day);
+			});
+			this.addEventListener("blur", () => this._lastSelection = null);
+		}
+		_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, event) {
+			this._chosenMonth = void 0;
+			this._setChosenYear();
+			if (this.multiple) {
+				window.getSelection()?.removeAllRanges();
+				let selected = !this._selected ? [] : Array.isArray(this._selected) ? this._selected : [this._selected];
+				const serializedSelected = selected.map((s) => this._dateAdapter.toIso8601(s));
+				if (event.shiftKey && this._lastSelection && serializedSelected.includes(this._dateAdapter.toIso8601(this._lastSelection)) && !serializedSelected.includes(this._dateAdapter.toIso8601(day))) {
+					const offset = this._dateAdapter.compareDate(this._lastSelection, day) < 0 ? 1 : -1;
+					const range = [];
+					let current = this._lastSelection;
+					while (!this._dateAdapter.sameDate(current, day)) {
+						current = this._dateAdapter.addCalendarDays(current, offset);
+						const serializedCurrent = this._dateAdapter.toIso8601(current);
+						if (!serializedSelected.includes(serializedCurrent)) range.push(serializedCurrent);
+					}
+					selected = this._mergeDates(range, serializedSelected);
+				} else if (selected.some((sel) => this._dateAdapter.sameDate(sel, day))) selected = selected.filter((sel) => !this._dateAdapter.sameDate(sel, day));
+				else selected = [...selected, day].sort(this._sortDate);
+				this._lastSelection = day;
+				this._selected = selected;
+				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) {
+			this._selected = this._mergeDates(days.map((e) => e.value));
+			this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)));
+		}
+		_mergeDates(dates, selected) {
+			selected ??= this._selected.map((s) => this._dateAdapter.toIso8601(s));
+			const enabledDays = this._cells.filter((e) => !e.disabled).map((e) => this._mapValueToISODate(e.value));
+			const daysToAdd = dates.filter((isoDate) => enabledDays.includes(isoDate));
+			if (daysToAdd.every((day) => selected.includes(day))) selected = selected.filter((day) => !daysToAdd.includes(day));
+			else selected = [...selected, ...daysToAdd].filter((v, i, a) => a.indexOf(v) === i);
+			return selected.map((s) => this._dateAdapter.deserialize(s)).sort(this._sortDate);
+		}
+		/**
+		* Emits the dateselected event given the detail (as T or T[] based on the value of the multiple flag).
+		* FIXME: the name of the variable appears as event name in the readme
+		*  due to a bug in the custom-elements-manifest library.
+		*  https://github.com/open-wc/custom-elements-manifest/issues/149
+		*/
+		_emitDateSelectedEvent(dateselected) {
+			/** @type {SbbDateSelectedEvent<T>} Event emitted on date selection. */
+			this.dispatchEvent(new SbbDateSelectedEvent(dateselected));
+		}
+		_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));
+		}
+		_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 origin = day ?? event.target;
+			const cells = this._cells;
+			const index = cells.indexOf(origin);
+			let nextEl;
+			if (day) nextEl = this._navigateByKeyboardDayView(event, index, cells, this._mapDateToDay(day.value));
+			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}
+          <span class="sbb-screen-reader-only" role="status">
+            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate)}
+          </span>
+        </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`
+                        <span class="sbb-screen-reader-only">${weekDay.long}</span>
+                        <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`
+                                <span class="sbb-screen-reader-only"
+                                  >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[0]}`}</span
+                                >
+                                <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`
+                              <span class="sbb-screen-reader-only"
+                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[rowIndex]}`}</span
+                              >
+                              <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`
+                              <span class="sbb-screen-reader-only"
+                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumber}`}</span
+                              >
+                              <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`
+                              <span class="sbb-screen-reader-only">${weekday.long}</span>
+                              <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}></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>
+      <span class="sbb-screen-reader-only" role="status"> ${this._chosenYear} </span>`;
+		}
+		/** 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>
+      <span class="sbb-screen-reader-only" role="status"> ${yearLabel} </span>
+    `;
+		}
+		/** 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 { SbbDateSelectedEvent as n, SbbMonthChangeEvent as r, SbbCalendarElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"calendar.component-CG96KGTg.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  // Set the line-height for adjacent elements in order to prevent from influence of a consumer-set line-height.\n  line-height: var(--sbb-typo-line-height-text);\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  line-height: 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 {\n  type DateAdapter,\n  DAYS_PER_ROW,\n  defaultDateAdapter,\n  forceType,\n  handleDistinctChange,\n  i18nCalendarDateSelection,\n  i18nCalendarWeekNumber,\n  i18nNextMonth,\n  i18nNextYear,\n  i18nNextYearRange,\n  i18nPreviousMonth,\n  i18nPreviousYear,\n  i18nPreviousYearRange,\n  i18nYearMonthSelection,\n  isArrowKeyOrPageKeysPressed,\n  MONDAY,\n  MONTHS_PER_PAGE,\n  MONTHS_PER_ROW,\n  plainDate,\n  readConfig,\n  SbbElement,\n  type SbbElementType,\n  SbbLanguageController,\n  SbbMediaMatcherController,\n  SbbMediaQueryBreakpointLargeAndAbove,\n  screenReaderOnlyStyles,\n  THURSDAY,\n  TUESDAY,\n  WEDNESDAY,\n  YEARS_PER_PAGE,\n  YEARS_PER_ROW,\n} from '../../core.ts';\nimport { SbbIconElement } from '../../icon.pure.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/calendar-cell-base-element.ts';\n\nimport style from './calendar.scss?inline';\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\nexport class SbbDateSelectedEvent<T> extends Event {\n  private readonly _dateSelected: Readonly<T | T[]>;\n\n  public get dateSelected(): Readonly<T | T[]> {\n    return this._dateSelected;\n  }\n\n  public constructor(dates: T | T[]) {\n    super('dateselected', { bubbles: true, composed: true });\n    this._dateSelected = Object.freeze(dates);\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\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 elementDependencies: SbbElementType[] = [\n    SbbCalendarDayElement,\n    SbbCalendarMonthElement,\n    SbbCalendarWeekdayElement,\n    SbbCalendarWeeknumberElement,\n    SbbCalendarYearElement,\n    SbbIconElement,\n    SbbSecondaryButtonElement,\n  ];\n  public static override styles: CSSResultGroup = [screenReaderOnlyStyles, 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: 'day' | 'month' | 'year' = '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        .sort(this._sortDate);\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: 'horizontal' | 'vertical' =\n    '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: SbbCalendarElement['view'] = 'day';\n\n  private _nextCalendarView: SbbCalendarElement['view'] = '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<T>[] {\n    return Array.from<SbbCalendarCellBaseElement<T>>(\n      (this._calendarView === 'day'\n        ? (Array.from(this.shadowRoot!.querySelectorAll('slot')).flatMap((e: HTMLSlotElement) =>\n            e.assignedElements({ flatten: true }),\n          ) as SbbCalendarDayElement<T>[])\n        : this.shadowRoot?.querySelectorAll<SbbCalendarCellBaseElement<T>>(\n            `sbb-calendar-${this._calendarView}`,\n          )) ?? [],\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  private _lastSelection: T | null = null;\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    const resolveDay = (event: PointerEvent | KeyboardEvent): SbbCalendarDayElement<T> | null =>\n      (event.target as HTMLElement).closest<SbbCalendarDayElement<T>>('sbb-calendar-day') ??\n      event\n        .composedPath()\n        .find(\n          (e): e is SbbCalendarDayElement<T> => (e as HTMLElement).localName === 'sbb-calendar-day',\n        ) ??\n      null;\n    this.addEventListener('click', (event) => {\n      const day = resolveDay(event);\n      if (day) {\n        this._selectDate(day.value!, event);\n      }\n    });\n    this.addEventListener('keydown', (event) => {\n      const day = resolveDay(event);\n      if (day) {\n        this._handleKeyboardEvent(event, day);\n      }\n    });\n    this.addEventListener('blur', () => (this._lastSelection = null));\n  }\n\n  private readonly _sortDate = (a: T, b: T): number => this._dateAdapter.compareDate(a, b);\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 | T): 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, event: PointerEvent): void {\n    this._chosenMonth = undefined;\n    this._setChosenYear();\n    if (this.multiple) {\n      // If a range is selected via Shift, a text selection range will be active.\n      // We need to remove it to avoid having a text selection on top of the calendar cells,\n      // which would create a confusing UX.\n      // This also must be very early in the event handler, otherwise there will be a flash\n      // of selection.\n      window.getSelection()?.removeAllRanges();\n      let selected = !this._selected\n        ? []\n        : Array.isArray(this._selected)\n          ? this._selected\n          : [this._selected];\n      const serializedSelected = selected.map((s) => this._dateAdapter.toIso8601(s));\n      if (\n        event.shiftKey &&\n        this._lastSelection &&\n        serializedSelected.includes(this._dateAdapter.toIso8601(this._lastSelection)) &&\n        !serializedSelected.includes(this._dateAdapter.toIso8601(day))\n      ) {\n        const offset = this._dateAdapter.compareDate(this._lastSelection, day) < 0 ? 1 : -1;\n        const range: string[] = [];\n        let current = this._lastSelection;\n        while (!this._dateAdapter.sameDate(current, day)) {\n          current = this._dateAdapter.addCalendarDays(current, offset)!;\n          const serializedCurrent = this._dateAdapter.toIso8601(current);\n          if (!serializedSelected.includes(serializedCurrent)) {\n            range.push(serializedCurrent);\n          }\n        }\n        selected = this._mergeDates(range, serializedSelected);\n      } else if (selected.some((sel) => this._dateAdapter.sameDate(sel, day))) {\n        selected = selected.filter((sel) => !this._dateAdapter.sameDate(sel, day));\n      } else {\n        selected = [...selected, day].sort(this._sortDate);\n      }\n\n      this._lastSelection = day;\n      this._selected = selected;\n      this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)!));\n    } else if (!this._selected || this._dateAdapter.compareDate(this._selected as T, day) !== 0) {\n      // In single selection, check if the day is already selected\n      this._selected = day;\n      this._emitDateSelectedEvent(this._dateAdapter.deserialize(day)!);\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    this._selected = this._mergeDates(days.map((e) => e.value));\n    this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)!));\n  }\n\n  private _mergeDates(dates: string[], selected?: string[]): T[] {\n    selected ??= (this._selected as T[]).map((s) => this._dateAdapter.toIso8601(s));\n    // Filter disabled days by matching the provided `dates` 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<T>[])\n      .filter((e) => !e.disabled)\n      .map((e) => this._mapValueToISODate(e.value!));\n    const daysToAdd: string[] = dates.filter((isoDate) => enabledDays.includes(isoDate));\n\n    // In case of multiple selection, newly added days must be added to the\n    // existing ones, without duplication.\n    // If the days to add are exactly the same as the selected ones, the set\n    // must be emptied.\n    if (daysToAdd.every((day: string) => selected!.includes(day))) {\n      selected = selected.filter((day: string) => !daysToAdd.includes(day));\n    } else {\n      selected = [...selected, ...daysToAdd].filter((v, i, a) => a.indexOf(v) === i);\n    }\n    return selected.map((s) => this._dateAdapter.deserialize(s)!).sort(this._sortDate);\n  }\n\n  /**\n   * Emits the dateselected event given the detail (as T or T[] based on the value of the multiple flag).\n   * FIXME: the name of the 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   */\n  private _emitDateSelectedEvent(dateselected: T | T[]): void {\n    /** @type {SbbDateSelectedEvent<T>} Event emitted on date selection. */\n    this.dispatchEvent(new SbbDateSelectedEvent<T>(dateselected));\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  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<T> | 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<T>>(':state(selected)') ??\n        this.shadowRoot?.querySelector<SbbCalendarCellBaseElement<T>>(':state(current)');\n      return selectedOrCurrent && !selectedOrCurrent.disabled\n        ? selectedOrCurrent\n        : this.shadowRoot!.querySelector<SbbCalendarCellBaseElement<T>>(\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<T> | null {\n    const cells = this._cells as SbbCalendarDayElement<T>[];\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?: SbbCalendarDayElement<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    const origin = day ?? (event.target as SbbCalendarDayElement<T>);\n    const cells = this._cells;\n    const index: number = cells.indexOf(origin);\n    let nextEl: SbbCalendarCellBaseElement<T>;\n    if (day) {\n      nextEl = this._navigateByKeyboardDayView(\n        event,\n        index,\n        cells as SbbCalendarDayElement<T>[],\n        this._mapDateToDay(day.value! as T),\n      );\n    } else {\n      nextEl = this._navigateByKeyboard(event, index, cells);\n    }\n    const activeEl = (this._enhancedVariant ? document : this.shadowRoot!)\n      .activeElement as SbbCalendarCellBaseElement<T>;\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<T>[],\n    day: Day<T>,\n  ): SbbCalendarDayElement<T> {\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<T>[],\n    index: number,\n    date: T,\n    delta: number,\n  ): SbbCalendarDayElement<T> {\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<T>[],\n    index: number,\n    day: Day<T>,\n    delta: number,\n    deltaIfDisabled: number,\n  ): SbbCalendarDayElement<T> {\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<T>[],\n    index: number,\n    day: Day<T>,\n    date: number,\n  ): SbbCalendarDayElement<T> {\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<T>[],\n    index: number,\n    firstNextMonth: T,\n  ): SbbCalendarDayElement<T> {\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<T>[],\n  ): SbbCalendarCellBaseElement<T> {\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<T>[],\n    index: number,\n    delta: number,\n  ): SbbCalendarCellBaseElement<T> {\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<T>[],\n    firstOfCurrentMonth: number,\n  ): SbbCalendarCellBaseElement<T> {\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<T>[],\n    lastOfCurrentMonth: number,\n  ): SbbCalendarCellBaseElement<T> {\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<T>[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): SbbCalendarCellBaseElement<T> {\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<T>[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): SbbCalendarCellBaseElement<T> {\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          <span class=\"sbb-screen-reader-only\" role=\"status\">\n            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate!)}\n          </span>\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                        <span class=\"sbb-screen-reader-only\">${weekDay.long}</span>\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                                <span class=\"sbb-screen-reader-only\"\n                                  >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[0]}`}</span\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                              <span class=\"sbb-screen-reader-only\"\n                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[rowIndex]}`}</span\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                              <span class=\"sbb-screen-reader-only\"\n                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumber}`}</span\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                              <span class=\"sbb-screen-reader-only\">${weekday.long}</span>\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 slot=${day.value}></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      <span class=\"sbb-screen-reader-only\" role=\"status\"> ${this._chosenYear} </span>`;\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      <span class=\"sbb-screen-reader-only\" role=\"status\"> ${yearLabel} </span>\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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"}