@sbb-esta/lyne-elements 5.0.0-next.3 → 5.0.1

package/development/calendar.component-BmB8HoZt.js

@@ -0,0 +1,1399 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, nothing, unsafeCSS } from "lit";
+import { property, state } from "lit/decorators.js";
+import { MONDAY, SbbElement, SbbFormAssociatedMixin, SbbLanguageController, THURSDAY, TUESDAY, WEDNESDAY, buttonResetStyles, 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  max-width: 100%;\n  line-height: var(--sbb-typo-line-height-text);\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: flex;\n  flex-wrap: wrap;\n  gap: var(--sbb-calendar-tables-gap);\n  position: relative;\n}\n\n:is(.sbb-calendar__year-view, .sbb-calendar__month-view) {\n  position: absolute;\n  inset-block-start: 0;\n  inset-inline-start: 0;\n}\n\n:host(:not(:is(:state(view-day),[state--view-day]))) .sbb-calendar__day-view {\n  visibility: hidden;\n}\n\n.sbb-calendar__table-header {\n  display: flex;\n  align-items: center;\n  gap: var(--sbb-calendar-control-gap);\n  height: var(--sbb-size-element-xs);\n  margin-block-end: var(--sbb-spacing-fixed-4x);\n}\n\n.sbb-calendar__table-header span {\n  flex: 1 1 auto;\n  padding-inline-start: var(--sbb-spacing-fixed-3x);\n  color: var(--sbb-calendar-control-view-change-color);\n}\n\n.sbb-calendar__control {\n  -webkit-tap-highlight-color: transparent;\n}\n\n.sbb-calendar__table {\n  width: 100%;\n  border-collapse: collapse;\n  height: max-content;\n  flex: 0 0;\n}\n\n.sbb-calendar__table :is(thead, tbody) {\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  min-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-day-justify-content: center;\n  --sbb-calendar-day-height: var(--sbb-calendar-day-size);\n  --sbb-calendar-day-extra-display: none;\n  --sbb-calendar-day-value-height: unset;\n}";
+//#endregion
+//#region src/elements/calendar/calendar/calendar.component.ts
+var DAYS_PER_ROW = 7;
+var MONTHS_PER_ROW = 4;
+var YEARS_PER_ROW = 4;
+var MONTHS_PER_PAGE = 12;
+var YEARS_PER_PAGE = 24;
+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 = SbbFormAssociatedMixin(SbbElement);
+	let _instanceExtraInitializers = [];
+	let _amount_decorators;
+	let _amount_initializers = [];
+	let _amount_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_value_decorators;
+	let __value_decorators;
+	let __value_initializers = [];
+	let __value_extraInitializers = [];
+	let _dateFilter_decorators;
+	let _dateFilter_initializers = [];
+	let _dateFilter_extraInitializers = [];
+	let _set_fixedMonth_decorators;
+	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 __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;
+			_amount_decorators = [forceType(), property({ type: Number })];
+			_view_decorators = [property()];
+			_min_decorators = [plainDate(), property()];
+			_max_decorators = [plainDate(), property()];
+			_multiple_decorators = [
+				forceType(),
+				handleDistinctChange((e, newValue) => e._onMultipleChanged(newValue)),
+				property({ type: Boolean })
+			];
+			_set_value_decorators = [property()];
+			__value_decorators = [state()];
+			_dateFilter_decorators = [property({ attribute: "date-filter" })];
+			_set_fixedMonth_decorators = [forceType(), property({ attribute: "fixed-month" })];
+			_orientation_decorators = [property({ reflect: true })];
+			_weekNumbers_decorators = [forceType(), property({
+				attribute: "week-numbers",
+				type: Boolean
+			})];
+			__activeDate_decorators = [state()];
+			__calendarView_decorators = [state()];
+			__initialized_decorators = [state()];
+			__esDecorate(this, null, _amount_decorators, {
+				kind: "accessor",
+				name: "amount",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "amount" in obj,
+					get: (obj) => obj.amount,
+					set: (obj, value) => {
+						obj.amount = value;
+					}
+				},
+				metadata: _metadata
+			}, _amount_initializers, _amount_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_value_decorators, {
+				kind: "setter",
+				name: "value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "value" in obj,
+					set: (obj, value) => {
+						obj.value = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, __value_decorators, {
+				kind: "accessor",
+				name: "_value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_value" in obj,
+					get: (obj) => obj._value,
+					set: (obj, value) => {
+						obj._value = value;
+					}
+				},
+				metadata: _metadata
+			}, __value_initializers, __value_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, _set_fixedMonth_decorators, {
+				kind: "setter",
+				name: "fixedMonth",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "fixedMonth" in obj,
+					set: (obj, value) => {
+						obj.fixedMonth = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__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, __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 = [
+				buttonResetStyles,
+				screenReaderOnlyStyles,
+				unsafeCSS(calendar_default)
+			];
+		}
+		static {
+			this.events = {
+				dateselected: "dateselected",
+				monthchange: "monthchange"
+			};
+		}
+		#amount_accessor_storage;
+		/**
+		* The amount of months to display in this calendar.
+		*/
+		get amount() {
+			return this.#amount_accessor_storage;
+		}
+		set amount(value) {
+			this.#amount_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 value(value) {
+			if (Array.isArray(value)) this._value = 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._value = selectedDate;
+				else this._value = null;
+			}
+		}
+		get value() {
+			return this._value;
+		}
+		#_value_accessor_storage;
+		get _value() {
+			return this.#_value_accessor_storage;
+		}
+		set _value(value) {
+			this.#_value_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;
+		}
+		/**
+		* Set this with the format `YYYY-MM` to limit the calendar to a specific month,
+		* and prevent navigation to other months.
+		*/
+		set fixedMonth(value) {
+			const match = value ? value.match(/^(\d{4})-(\d{2})$/) : null;
+			this._fixedMonth = match ? this._dateAdapter.createDate(Number(match[1]), Number(match[2]), 1) : null;
+		}
+		get fixedMonth() {
+			return this._fixedMonth ? this._dateAdapter.toIso8601(this._fixedMonth).split("-").slice(0, 2).join("-") : "";
+		}
+		#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;
+		}
+		#_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.#amount_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _amount_initializers, 1));
+			this.#view_accessor_storage = (__runInitializers(this, _amount_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.#_value_accessor_storage = (__runInitializers(this, _multiple_extraInitializers), __runInitializers(this, __value_initializers, null));
+			this.#dateFilter_accessor_storage = (__runInitializers(this, __value_extraInitializers), __runInitializers(this, _dateFilter_initializers, null));
+			this._fixedMonth = (__runInitializers(this, _dateFilter_extraInitializers), null);
+			this.#orientation_accessor_storage = __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.#_calendarView_accessor_storage = (__runInitializers(this, __activeDate_extraInitializers), __runInitializers(this, __calendarView_initializers, "day"));
+			/** A list of days, in two formats (long and single char). */
+			this._weekdays = __runInitializers(this, __calendarView_extraInitializers);
+			/** Grid of calendar cells representing the dates of the month. */
+			this._weeks = [];
+			/** The first visible day in the calendar. */
+			this._firstVisibleDay = "";
+			/** The last visible day in the calendar. */
+			this._lastVisibleDay = "";
+			/** 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._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 */
+		formResetCallback() {}
+		/** @internal */
+		formStateRestoreCallback(state, reason) {
+			if (reason === "autocomplete" || state == null) return;
+			const restore = (value) => this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+			if (typeof state === "string") this.value = restore(state);
+			else if (state instanceof FormData) {
+				if (this.multiple) {
+					this._readFormData(state).then((array) => this.value = array.map(restore).filter((date) => date != null));
+					return;
+				}
+				const entry = state.get(this.name);
+				if (entry instanceof Blob) entry.text().then((text) => this.value = restore(JSON.parse(text)));
+				else this.value = restore(entry);
+			}
+		}
+		async _readFormData(formData) {
+			return Promise.all(formData.getAll(this.name).map(async (entry) => entry instanceof Blob ? JSON.parse(await entry.text()) : entry));
+		}
+		/** @internal */
+		focus() {
+			this._resetFocus = true;
+			this._focusCell();
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (!this._initialized) return;
+			if (changedProperties.has("amount") || changedProperties.has("orientation") || changedProperties.has("fixedMonth")) this.resetPosition();
+			if (changedProperties.has("view")) {
+				this._setChosenYear();
+				this._chosenMonth = void 0;
+				this._calendarView = this.view;
+			}
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (name === "_calendarView") {
+				this.internals.states.delete(`view-${oldValue}`);
+				this.internals.states.add(`view-${this._calendarView}`);
+				if (this._containingFocus) this._resetFocus = true;
+			}
+		}
+		updated(changedProperties) {
+			super.updated(changedProperties);
+			this._setTabIndex();
+			this._focusCell();
+		}
+		/**
+		* The `_value` state should be adapted when the `multiple` property changes:
+		*   - if it changes to true, the '_value' 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._value)) this._value = this._value ? [this._value] : [];
+			if (!isMultiple && Array.isArray(this._value)) this._value = this._value.length ? this._value[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);
+			const startDate = this._fixedMonth ?? this._activeDate;
+			const amount = this.amount < 1 ? 1 : this.amount;
+			this._weeks = Array.from({ length: amount }, (_, i) => this._createWeekRows(this._dateAdapter.addCalendarMonths(startDate, i)));
+			const dateFromFirstMonth = this._weeks[0][0][0].dateValue;
+			this._firstVisibleDay = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(dateFromFirstMonth), this._dateAdapter.getMonth(dateFromFirstMonth), 1));
+			const dateFromLastMonth = this._weeks[amount - 1][0][0].dateValue;
+			this._lastVisibleDay = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(dateFromLastMonth), this._dateAdapter.getMonth(dateFromLastMonth), this._dateAdapter.getNumDaysInMonth(dateFromLastMonth)));
+			this._years = this._createYearRows();
+			this._weekNumbers = this._weeks.map((week) => week.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) {
+			const daysInMonth = this._dateAdapter.getNumDaysInMonth(value);
+			const weekOffset = this._dateAdapter.getFirstWeekOffset(value);
+			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() {
+			const startValueYearView = this._getStartValueYearView();
+			const allYears = new Array(YEARS_PER_PAGE).fill(0).map((_, i) => startValueYearView + 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._value ? [] : Array.isArray(this._value) ? this._value : [this._value];
+				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._value = selected;
+				this._emitDateSelectedEvent(this._value.map((e) => this._dateAdapter.deserialize(e)));
+			} else if (!this._value || this._dateAdapter.compareDate(this._value, day) !== 0) {
+				this._value = 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._value = this._mergeDates(days.map((e) => e.value));
+			this._emitDateSelectedEvent(this._value.map((e) => this._dateAdapter.deserialize(e)));
+		}
+		_mergeDates(dates, selected) {
+			selected ??= this._value.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));
+			/** @type {InputEvent} Event emitted on user selection. */
+			this.dispatchEvent(new InputEvent("input", {
+				bubbles: true,
+				composed: true
+			}));
+			/** @type {Event} Event emitted on user selection. */
+			this.dispatchEvent(new Event("change", { bubbles: true }));
+		}
+		_emitMonthChange() {
+			const monthchange = this._weeks.flat(2).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.value.at(-1);
+				else selectedDate = this.value;
+				this._chosenYear = this._dateAdapter.getYear(selectedDate ?? this._dateAdapter.today());
+			} else this._chosenYear = void 0;
+		}
+		_assignActiveDate(date) {
+			this._activeDate = this._dateAdapter.clampDate(date, this.min, this.max);
+		}
+		/** 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.amount < 1 ? 1 : this.amount);
+			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.amount < 1 ? 1 : this.amount), 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 lastYear = this._years.flat(2).at(-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(`sbb-calendar-${this._calendarView}:is(:state(selected),[state--selected])`) ?? this.shadowRoot?.querySelector(`sbb-calendar-${this._calendarView}: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();
+				if (cells.includes(activeEl)) 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
+			};
+			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 offsetForVertical = this._dateAdapter.getFirstWeekOffset(day.dateValue);
+					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 offsetForVertical = this._dateAdapter.getFirstWeekOffset(day.dateValue);
+					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._firstVisibleDay || date > this._lastVisibleDay;
+		}
+		_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() {
+			this._resetCalendarView();
+			this._emitMonthChange();
+		}
+		_resetCalendarView() {
+			if (this._containingFocus) this._resetFocus = true;
+			this._activeDate = (this.multiple ? this._value.at(-1) : this._value) ?? this._dateAdapter.today();
+			this._setChosenYear();
+			this._chosenMonth = void 0;
+			this._init();
+			this._calendarView = this.view;
+		}
+		/** Creates the calendar table for the daily view. */
+		_createDayTable(weeks, weekNumbers, first) {
+			const firstDay = weeks[0][0].dateValue;
+			const monthLabel = `${this._monthNames[this._dateAdapter.getMonth(firstDay) - 1]} ${this._dateAdapter.getYear(firstDay)}`;
+			const weeksForSelectMultipleWeekNumbers = weeks.flat();
+			const weeksForSelectMultipleWeekDays = weeks.flat();
+			return html`
+      <div class="sbb-calendar__table-wrapper sbb-calendar__day-view">
+        <div class="sbb-calendar__table-header">
+          <span>${monthLabel}</span> ${first ? this._createDayTableControls(monthLabel) : nothing}
+        </div>
+        <table
+          class="sbb-calendar__table"
+          @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
+        >
+          <thead>
+            <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>
+            ${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>
+      </div>
+    `;
+		}
+		/** Creates the table in orientation='vertical'. */
+		_createDayTableVertical(weeks, weekNumbers, first) {
+			const firstDay = weeks[0][0].dateValue;
+			const monthLabel = `${this._monthNames[this._dateAdapter.getMonth(firstDay) - 1]} ${this._dateAdapter.getYear(firstDay)}`;
+			const activeDate = weeks[0][0].dateValue;
+			const weekOffset = this._dateAdapter.getFirstWeekOffset(activeDate ?? this._activeDate);
+			const weeksForSelectMultipleWeekNumbers = weeks.flat();
+			return html`
+      <div class="sbb-calendar__table-wrapper sbb-calendar__day-view">
+        <div class="sbb-calendar__table-header">
+          <span>${monthLabel}</span> ${first ? this._createDayTableControls(monthLabel) : nothing}
+        </div>
+        <table
+          class="sbb-calendar__table"
+          @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
+        >
+          ${this.weekNumbers ? html`
+                <thead>
+                  <tr>
+                    <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>
+            ${weeks.map((week, rowIndex) => {
+				const weekday = this._weekdays[rowIndex];
+				return html`
+                <tr>
+                  <td class="sbb-calendar__table-header-cell-vertical">
+                    ${this.multiple ? html`
+                          <sbb-calendar-weekday
+                            .value=${weekday}
+                            @click=${() => this._selectMultipleDates(week)}
+                          >
+                            ${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>
+      </div>
+    `;
+		}
+		_createDayTableControls(monthLabel) {
+			return this._fixedMonth ? [] : [
+				this._getArrow("left", () => this._goToDifferentMonth(-1), i18nPreviousMonth[this._language.current], this._previousMonthDisabled()),
+				this._getArrow("right", () => this._goToDifferentMonth(1), i18nNextMonth[this._language.current], this._nextMonthDisabled()),
+				this._getArrow("up", () => {
+					this._resetFocus = true;
+					this._calendarView = "year";
+				}, `${i18nYearMonthSelection[this._language.current]} ${monthLabel}`)
+			];
+		}
+		/** 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__table-wrapper sbb-calendar__month-view">
+        <div class="sbb-calendar__table-header">
+          <span>${this._chosenYear}</span>
+          ${this._fixedMonth ? [] : [
+				this._getArrow("left", () => this._goToDifferentYear(-1), i18nPreviousYear[this._language.current], this._previousYearDisabled()),
+				this._getArrow("right", () => this._goToDifferentYear(1), i18nNextYear[this._language.current], this._nextYearDisabled()),
+				this._getArrow("down", () => this._resetCalendarViewAndEmitMonthChange(), i18nCalendarDateSelection[this._language.current])
+			]}
+          <span class="sbb-screen-reader-only" role="status">${this._chosenYear}</span>
+        </div>
+        <table class="sbb-calendar__table">
+          <tbody>
+            ${this._months.map((row) => html`
+                <tr>
+                  ${row.map((month) => {
+				return html`
+                      <td class="sbb-calendar__table-data">
+                        <sbb-calendar-month
+                          .value="${this._chosenYear}-${month.value}"
+                          @click=${() => this._onMonthSelection(month.monthValue, this._chosenYear)}
+                          @keydown=${(evt) => this._handleKeyboardEvent(evt)}
+                        >
+                        </sbb-calendar-month>
+                      </td>
+                    `;
+			})}
+                </tr>
+              `)}
+          </tbody>
+        </table>
+      </div>
+    `;
+		}
+		/** Select the month and change the view to day selection. */
+		_onMonthSelection(month, year) {
+			this._chosenMonth = month;
+			this._calendarView = "day";
+			this._init(this._dateAdapter.createDate(year, this._chosenMonth, this._dateAdapter.getDate(this._activeDate)));
+			this._emitMonthChange();
+		}
+		/** Render the view for the year selection. */
+		_renderYearView() {
+			const firstYear = this._years.flat(2)[0];
+			const lastYearArray = this._years.at(-1).flat();
+			const yearLabel = `${firstYear} - ${lastYearArray[lastYearArray.length - 1]}`;
+			return html`
+      <div class="sbb-calendar__table-wrapper sbb-calendar__year-view">
+        <div class="sbb-calendar__table-header">
+          <span>${yearLabel}</span>
+          ${this._fixedMonth ? [] : [
+				this._getArrow("left", () => this._goToDifferentYearRange(-24), i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current], this._previousYearRangeDisabled()),
+				this._getArrow("right", () => this._goToDifferentYearRange(YEARS_PER_PAGE), i18nNextYearRange(YEARS_PER_PAGE)[this._language.current], this._nextYearRangeDisabled()),
+				this._getArrow("down", () => this._resetCalendarViewAndEmitMonthChange(), i18nCalendarDateSelection[this._language.current])
+			]}
+          <span class="sbb-screen-reader-only" role="status">${yearLabel}</span>
+        </div>
+        <table class="sbb-calendar__table">
+          <tbody>
+            ${this._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)}
+                        >
+                        </sbb-calendar-year>
+                      </td>
+                    `;
+			})}
+                </tr>`)}
+          </tbody>
+        </table>
+      </div>
+    `;
+		}
+		/** Select the year and change the view to month selection. */
+		_onYearSelection(year) {
+			this._chosenYear = year;
+			this._calendarView = "month";
+			this._assignActiveDate(this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate)));
+		}
+		/** Creates the button arrow for all the views. */
+		_getArrow(direction, click, ariaLabel, disabled = false) {
+			return html`<sbb-secondary-button
+      class="sbb-calendar__control"
+      size="s"
+      icon-name="chevron-small-${direction}-small"
+      aria-label=${ariaLabel}
+      @click=${click}
+      ?disabled=${disabled}
+    ></sbb-secondary-button>`;
+		}
+		_getView() {
+			switch (this._calendarView) {
+				case "year": return this._renderYearView();
+				case "month": return this._renderMonthView();
+				default: return nothing;
+			}
+		}
+		render() {
+			if (isServer || this.hydrationRequired) return html`${nothing}`;
+			return html`<div class="sbb-calendar__wrapper">
+      ${this.orientation === "horizontal" ? this._weeks.map((weeks, i) => this._createDayTable(weeks, this._weekNumbers[i], i === 0)) : this._weeks.map((weeks, i) => this._createDayTableVertical(weeks, this._weekNumbers[i], i === 0))}
+      ${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-BmB8HoZt.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  max-width: 100%;\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\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: flex;\n  flex-wrap: wrap;\n  gap: var(--sbb-calendar-tables-gap);\n  position: relative;\n}\n\n:is(.sbb-calendar__year-view, .sbb-calendar__month-view) {\n  position: absolute;\n  inset-block-start: 0;\n  inset-inline-start: 0;\n}\n\n.sbb-calendar__day-view {\n  :host(:not(:state(view-day))) & {\n    visibility: hidden;\n  }\n}\n\n.sbb-calendar__table-header {\n  display: flex;\n  align-items: center;\n  gap: var(--sbb-calendar-control-gap);\n  height: var(--sbb-size-element-xs);\n  margin-block-end: var(--sbb-spacing-fixed-4x);\n}\n\n.sbb-calendar__table-header span {\n  flex: 1 1 auto;\n  padding-inline-start: var(--sbb-spacing-fixed-3x);\n  color: var(--sbb-calendar-control-view-change-color);\n}\n\n.sbb-calendar__control {\n  -webkit-tap-highlight-color: transparent;\n}\n\n.sbb-calendar__table {\n  width: 100%;\n  border-collapse: collapse;\n  height: max-content;\n  flex: 0 0;\n}\n\n.sbb-calendar__table :is(thead, tbody) {\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  min-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-day-justify-content: center;\n    --sbb-calendar-day-height: var(--sbb-calendar-day-size);\n    --sbb-calendar-day-extra-display: none;\n    --sbb-calendar-day-value-height: unset;\n  }\n}\n","import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  nothing,\n  type PropertyDeclaration,\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  buttonResetStyles,\n  type DateAdapter,\n  defaultDateAdapter,\n  forceType,\n  type FormRestoreReason,\n  type FormRestoreState,\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  plainDate,\n  readConfig,\n  SbbElement,\n  type SbbElementType,\n  SbbFormAssociatedMixin,\n  SbbLanguageController,\n  screenReaderOnlyStyles,\n  THURSDAY,\n  TUESDAY,\n  WEDNESDAY,\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\nconst DAYS_PER_ROW: number = 7;\nconst MONTHS_PER_ROW: number = 4;\nconst YEARS_PER_ROW: number = 4;\nconst MONTHS_PER_PAGE: number = 12;\nconst YEARS_PER_PAGE: number = 24;\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\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\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 SbbFormAssociatedMixin(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 = [\n    buttonResetStyles,\n    screenReaderOnlyStyles,\n    unsafeCSS(style),\n  ];\n  public static readonly events = {\n    dateselected: 'dateselected',\n    monthchange: 'monthchange',\n  } as const;\n\n  /**\n   * The amount of months to display in this calendar.\n   */\n  @forceType()\n  @property({ type: Number })\n  public accessor amount: number = 1;\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 value(value: T | T[] | null) {\n    if (Array.isArray(value)) {\n      this._value = 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._value = selectedDate;\n      } else {\n        this._value = null;\n      }\n    }\n  }\n  public get value(): T | T[] | null {\n    return this._value;\n  }\n  @state() private accessor _value: T | T[] | null = null;\n\n  /** A function used to filter out dates. */\n  @property({ attribute: 'date-filter' })\n  public accessor dateFilter: ((date: T) => boolean) | null = null;\n\n  /**\n   * Set this with the format `YYYY-MM` to limit the calendar to a specific month,\n   * and prevent navigation to other months.\n   */\n  @forceType()\n  @property({ attribute: 'fixed-month' })\n  public set fixedMonth(value: string) {\n    const match = value ? value.match(/^(\\d{4})-(\\d{2})$/) : null;\n    this._fixedMonth = match\n      ? this._dateAdapter.createDate(Number(match[1]), Number(match[2]), 1)\n      : null;\n  }\n  public get fixedMonth(): string {\n    return this._fixedMonth\n      ? this._dateAdapter.toIso8601(this._fixedMonth).split('-').slice(0, 2).join('-')\n      : '';\n  }\n  private _fixedMonth: T | 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  @state() private accessor _calendarView: SbbCalendarElement['view'] = 'day';\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  /** The first visible day in the calendar. */\n  private _firstVisibleDay: string = '';\n\n  /** The last visible day in the calendar. */\n  private _lastVisibleDay: string = '';\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  /** 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  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\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 formResetCallback(): void {}\n\n  /** @internal */\n  public override formStateRestoreCallback(\n    state: FormRestoreState | null,\n    reason: FormRestoreReason,\n  ): void {\n    if (reason === 'autocomplete' || state == null) {\n      return;\n    }\n    const restore = (value: string | T | null): T | null =>\n      this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    if (typeof state === 'string') {\n      this.value = restore(state);\n    } else if (state instanceof FormData) {\n      if (this.multiple) {\n        this._readFormData(state as FormData).then(\n          (array) => (this.value = array.map(restore).filter((date): date is T => date != null)),\n        );\n        return;\n      }\n\n      const entry = state.get(this.name);\n      if (entry instanceof Blob) {\n        entry.text().then((text) => (this.value = restore(JSON.parse(text))));\n      } else {\n        this.value = restore(entry);\n      }\n    }\n  }\n\n  private async _readFormData(formData: FormData): Promise<T[]> {\n    return Promise.all(\n      formData\n        .getAll(this.name)\n        .map(async (entry) =>\n          entry instanceof Blob ? JSON.parse(await entry.text()) : (entry as T),\n        ),\n    );\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 (\n      changedProperties.has('amount') ||\n      changedProperties.has('orientation') ||\n      changedProperties.has('fixedMonth')\n    ) {\n      this.resetPosition();\n    }\n\n    if (changedProperties.has('view')) {\n      this._setChosenYear();\n      this._chosenMonth = undefined;\n      this._calendarView = this.view;\n    }\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n\n    if (name === '_calendarView') {\n      this.internals.states.delete(`view-${oldValue}`);\n      this.internals.states.add(`view-${this._calendarView}`);\n      if (this._containingFocus) {\n        this._resetFocus = true;\n      }\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 `_value` state should be adapted when the `multiple` property changes:\n   *   - if it changes to true, the '_value' 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._value)) {\n      this._value = this._value ? [this._value as T] : [];\n    }\n    if (!isMultiple && Array.isArray(this._value)) {\n      this._value = (this._value as T[]).length ? (this._value 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\n    const startDate = this._fixedMonth ?? this._activeDate;\n    const amount = this.amount < 1 ? 1 : this.amount;\n    this._weeks = Array.from({ length: amount }, (_, i) =>\n      this._createWeekRows(this._dateAdapter.addCalendarMonths(startDate, i)),\n    );\n    const dateFromFirstMonth = this._weeks[0][0][0].dateValue;\n    this._firstVisibleDay = this._dateAdapter.toIso8601(\n      this._dateAdapter.createDate(\n        this._dateAdapter.getYear(dateFromFirstMonth),\n        this._dateAdapter.getMonth(dateFromFirstMonth),\n        1,\n      )!,\n    );\n    const dateFromLastMonth = this._weeks[amount - 1][0][0].dateValue;\n    this._lastVisibleDay = this._dateAdapter.toIso8601(\n      this._dateAdapter.createDate(\n        this._dateAdapter.getYear(dateFromLastMonth),\n        this._dateAdapter.getMonth(dateFromLastMonth),\n        this._dateAdapter.getNumDaysInMonth(dateFromLastMonth),\n      )!,\n    );\n\n    this._years = this._createYearRows();\n    this._weekNumbers = this._weeks.map((week) =>\n      week\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): Day<T>[][] {\n    const daysInMonth: number = this._dateAdapter.getNumDaysInMonth(value);\n    const weekOffset: number = this._dateAdapter.getFirstWeekOffset(value);\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(): number[][] {\n    const startValueYearView: number = this._getStartValueYearView();\n    const allYears: number[] = new Array(YEARS_PER_PAGE)\n      .fill(0)\n      .map((_, i: number) => startValueYearView + 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._value ? [] : Array.isArray(this._value) ? this._value : [this._value];\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._value = selected;\n      this._emitDateSelectedEvent(this._value.map((e) => this._dateAdapter.deserialize(e)!));\n    } else if (!this._value || this._dateAdapter.compareDate(this._value as T, day) !== 0) {\n      // In single selection, check if the day is already selected\n      this._value = 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._value = this._mergeDates(days.map((e) => e.value));\n    this._emitDateSelectedEvent(this._value.map((e) => this._dateAdapter.deserialize(e)!));\n  }\n\n  private _mergeDates(dates: string[], selected?: string[]): T[] {\n    selected ??= (this._value 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    /** @type {InputEvent} Event emitted on user selection. */\n    this.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n    /** @type {Event} Event emitted on user selection. */\n    this.dispatchEvent(new Event('change', { bubbles: true }));\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._weeks.flat(2).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.value as T[]).at(-1);\n      } else {\n        selectedDate = this.value 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    this._activeDate = this._dateAdapter.clampDate(date, this.min, this.max)!;\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(\n      this._activeDate,\n      this.amount < 1 ? 1 : this.amount,\n    );\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.amount < 1 ? 1 : this.amount),\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 lastYear = this._years.flat(2).at(-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>>(\n          `sbb-calendar-${this._calendarView}:state(selected)`,\n        ) ??\n        this.shadowRoot?.querySelector<SbbCalendarCellBaseElement<T>>(\n          `sbb-calendar-${this._calendarView}:state(current)`,\n        );\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\n      if (cells.includes(activeEl)) {\n        activeEl.tabIndex = -1;\n      }\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\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 offsetForVertical: number = this._dateAdapter.getFirstWeekOffset(day.dateValue);\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 offsetForVertical: number = this._dateAdapter.getFirstWeekOffset(day.dateValue);\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 date < this._firstVisibleDay || date > this._lastVisibleDay;\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(): void {\n    this._resetCalendarView();\n    this._emitMonthChange();\n  }\n\n  private _resetCalendarView(): void {\n    if (this._containingFocus) {\n      this._resetFocus = true;\n    }\n    this._activeDate =\n      (this.multiple ? (this._value as T[]).at(-1) : (this._value as T)) ??\n      this._dateAdapter.today();\n    this._setChosenYear();\n    this._chosenMonth = undefined;\n    this._init();\n    this._calendarView = this.view;\n  }\n\n  /** Creates the calendar table for the daily view. */\n  private _createDayTable(\n    weeks: Day<T>[][],\n    weekNumbers: number[],\n    first: boolean,\n  ): TemplateResult {\n    const firstDay = weeks[0][0].dateValue;\n    const monthLabel = `${\n      this._monthNames[this._dateAdapter.getMonth(firstDay) - 1]\n    } ${this._dateAdapter.getYear(firstDay)}`;\n    const weeksForSelectMultipleWeekNumbers: Day<T>[] = weeks.flat();\n    const weeksForSelectMultipleWeekDays: Day<T>[] = weeks.flat();\n    return html`\n      <div class=\"sbb-calendar__table-wrapper sbb-calendar__day-view\">\n        <div class=\"sbb-calendar__table-header\">\n          <span>${monthLabel}</span> ${first ? this._createDayTableControls(monthLabel) : nothing}\n        </div>\n        <table\n          class=\"sbb-calendar__table\"\n          @focusout=${(event: FocusEvent) =>\n            this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        >\n          <thead>\n            <tr>\n              ${this.weekNumbers\n                ? html`<th class=\"sbb-calendar__table-header-cell\"></th>`\n                : 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>\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>[] =\n                                        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      </div>\n    `;\n  }\n\n  /** Creates the table in orientation='vertical'. */\n  private _createDayTableVertical(\n    weeks: Day<T>[][],\n    weekNumbers: number[],\n    first: boolean,\n  ): TemplateResult {\n    const firstDay = weeks[0][0].dateValue;\n    const monthLabel = `${\n      this._monthNames[this._dateAdapter.getMonth(firstDay) - 1]\n    } ${this._dateAdapter.getYear(firstDay)}`;\n    const activeDate = weeks[0][0].dateValue;\n    const weekOffset = this._dateAdapter.getFirstWeekOffset(activeDate ?? this._activeDate);\n    const weeksForSelectMultipleWeekNumbers: Day<T>[] = weeks.flat();\n    return html`\n      <div class=\"sbb-calendar__table-wrapper sbb-calendar__day-view\">\n        <div class=\"sbb-calendar__table-header\">\n          <span>${monthLabel}</span> ${first ? this._createDayTableControls(monthLabel) : nothing}\n        </div>\n        <table\n          class=\"sbb-calendar__table\"\n          @focusout=${(event: FocusEvent) =>\n            this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        >\n          ${this.weekNumbers\n            ? html`\n                <thead>\n                  <tr>\n                    <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>\n            ${weeks.map((week: Day<T>[], rowIndex: number) => {\n              const weekday = this._weekdays[rowIndex];\n              return html`\n                <tr>\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(week)}\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                  ${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      </div>\n    `;\n  }\n\n  private _createDayTableControls(monthLabel: string): TemplateResult[] {\n    return this._fixedMonth\n      ? []\n      : [\n          this._getArrow(\n            'left',\n            () => this._goToDifferentMonth(-1),\n            i18nPreviousMonth[this._language.current],\n            this._previousMonthDisabled(),\n          ),\n          this._getArrow(\n            'right',\n            () => this._goToDifferentMonth(1),\n            i18nNextMonth[this._language.current],\n            this._nextMonthDisabled(),\n          ),\n          this._getArrow(\n            'up',\n            () => {\n              this._resetFocus = true;\n              this._calendarView = 'year';\n            },\n            `${i18nYearMonthSelection[this._language.current]} ${monthLabel}`,\n          ),\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__table-wrapper sbb-calendar__month-view\">\n        <div class=\"sbb-calendar__table-header\">\n          <span>${this._chosenYear}</span>\n          ${this._fixedMonth\n            ? []\n            : [\n                this._getArrow(\n                  'left',\n                  () => this._goToDifferentYear(-1),\n                  i18nPreviousYear[this._language.current],\n                  this._previousYearDisabled(),\n                ),\n                this._getArrow(\n                  'right',\n                  () => this._goToDifferentYear(1),\n                  i18nNextYear[this._language.current],\n                  this._nextYearDisabled(),\n                ),\n                this._getArrow(\n                  'down',\n                  () => this._resetCalendarViewAndEmitMonthChange(),\n                  i18nCalendarDateSelection[this._language.current],\n                ),\n              ]}\n          <span class=\"sbb-screen-reader-only\" role=\"status\">${this._chosenYear}</span>\n        </div>\n        <table class=\"sbb-calendar__table\">\n          <tbody>\n            ${this._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=\"${this._chosenYear}-${month.value}\"\n                          @click=${() =>\n                            this._onMonthSelection(month.monthValue, this._chosenYear!)}\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      </div>\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._calendarView = 'day';\n    this._init(\n      this._dateAdapter.createDate(\n        year,\n        this._chosenMonth,\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._emitMonthChange();\n  }\n\n  /** Render the view for the year selection. */\n  private _renderYearView(): TemplateResult {\n    const firstYear: number = this._years.flat(2)[0];\n    const lastYearArray: number[] = this._years.at(-1)!.flat();\n    const lastYear: number = lastYearArray[lastYearArray.length - 1];\n    const yearLabel = `${firstYear} - ${lastYear}`;\n    return html`\n      <div class=\"sbb-calendar__table-wrapper sbb-calendar__year-view\">\n        <div class=\"sbb-calendar__table-header\">\n          <span>${yearLabel}</span>\n          ${this._fixedMonth\n            ? []\n            : [\n                this._getArrow(\n                  'left',\n                  () => this._goToDifferentYearRange(-YEARS_PER_PAGE),\n                  i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current],\n                  this._previousYearRangeDisabled(),\n                ),\n                this._getArrow(\n                  'right',\n                  () => this._goToDifferentYearRange(YEARS_PER_PAGE),\n                  i18nNextYearRange(YEARS_PER_PAGE)[this._language.current],\n                  this._nextYearRangeDisabled(),\n                ),\n                this._getArrow(\n                  'down',\n                  () => this._resetCalendarViewAndEmitMonthChange(),\n                  i18nCalendarDateSelection[this._language.current],\n                ),\n              ]}\n          <span class=\"sbb-screen-reader-only\" role=\"status\">${yearLabel}</span>\n        </div>\n        <table class=\"sbb-calendar__table\">\n          <tbody>\n            ${this._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)}\n                        >\n                        </sbb-calendar-year>\n                      </td>\n                    `;\n                  })}\n                </tr>`,\n            )}\n          </tbody>\n        </table>\n      </div>\n    `;\n  }\n\n  /** Select the year and change the view to month selection. */\n  private _onYearSelection(year: number): void {\n    this._chosenYear = year;\n    this._calendarView = '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  }\n\n  /** Creates the button arrow for all the views. */\n  private _getArrow(\n    direction: 'left' | 'right' | 'down' | 'up',\n    click: () => void,\n    ariaLabel: string,\n    disabled = false,\n  ): TemplateResult {\n    return html`<sbb-secondary-button\n      class=\"sbb-calendar__control\"\n      size=\"s\"\n      icon-name=\"chevron-small-${direction}-small\"\n      aria-label=${ariaLabel}\n      @click=${click}\n      ?disabled=${disabled}\n    ></sbb-secondary-button>`;\n  }\n\n  private _getView(): TemplateResult | typeof nothing {\n    switch (this._calendarView) {\n      case 'year':\n        return this._renderYearView();\n      case 'month':\n        return this._renderMonthView();\n      default:\n        return nothing;\n    }\n  }\n\n  protected override render(): 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\n    return html`<div class=\"sbb-calendar__wrapper\">\n      ${this.orientation === 'horizontal'\n        ? this._weeks.map((weeks, i) => this._createDayTable(weeks, this._weekNumbers[i], i === 0))\n        : this._weeks.map((weeks, i) =>\n            this._createDayTableVertical(weeks, this._weekNumbers[i], i === 0),\n          )}\n      ${this._getView()}\n    </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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"}