@sbb-esta/lyne-elements 1.13.0 → 1.14.1

package/development/calendar.js

@@ -1,10 +1,19 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __esDecorate, __runInitializers } from "tslib";
 import { css, LitElement, isServer, html, nothing } from "lit";
-import { property, state, customElement } from "lit/decorators.js";
+import { customElement, property, state } from "lit/decorators.js";
 import { classMap } from "lit/directives/class-map.js";
 import { sbbInputModalityDetector, isArrowKeyOrPageKeysPressed } from "./core/a11y.js";
 import { readConfig } from "./core/config.js";
 import { SbbConnectedAbortController, SbbLanguageController } from "./core/controllers.js";
 import { defaultDateAdapter, YEARS_PER_PAGE, DAYS_PER_ROW, MONTHS_PER_ROW, YEARS_PER_ROW } from "./core/datetime.js";
+import { forceType } from "./core/decorators.js";
 import { isBreakpoint } from "./core/dom.js";
 import { EventEmitter } from "./core/eventing.js";
 import { i18nPreviousMonth, i18nNextMonth, i18nYearMonthSelection, i18nPreviousYear, i18nNextYear, i18nCalendarDateSelection, i18nPreviousYearRange, i18nNextYearRange } from "./core/i18n.js";
@@ -322,573 +331,597 @@ const style = css`*,
     transform: translateY(var(--sbb-calendar-table-animation-shift));
   }
 }`;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
-  constructor() {
-    var _a;
-    super();
-    this.wide = false;
-    this.view = "day";
-    this._now = null;
-    this._dateAdapter = ((_a = readConfig().datetime) == null ? void 0 : _a.dateAdapter) ?? defaultDateAdapter;
-    this._dateSelected = new EventEmitter(
-      this,
-      SbbCalendarElement.events.dateSelected
-    );
-    this._activeDate = this.now;
-    this._calendarView = "day";
-    this._nextCalendarView = "day";
-    this._weeks = [];
-    this._monthNames = this._dateAdapter.getMonthNames("long");
-    this._resetFocus = false;
-    this._initialized = false;
-    this._abort = new SbbConnectedAbortController(this);
-    this._language = new SbbLanguageController(this).withHandler(() => {
+let SbbCalendarElement = (() => {
+  var _wide_accessor_storage, _view_accessor_storage, _dateFilter_accessor_storage, __activeDate_accessor_storage, __selected_accessor_storage, __calendarView_accessor_storage, __initialized_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-calendar")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbHydrationMixin(LitElement);
+  let _instanceExtraInitializers = [];
+  let _wide_decorators;
+  let _wide_initializers = [];
+  let _wide_extraInitializers = [];
+  let _view_decorators;
+  let _view_initializers = [];
+  let _view_extraInitializers = [];
+  let _set_min_decorators;
+  let _set_max_decorators;
+  let _set_now_decorators;
+  let _set_selected_decorators;
+  let _dateFilter_decorators;
+  let _dateFilter_initializers = [];
+  let _dateFilter_extraInitializers = [];
+  let __activeDate_decorators;
+  let __activeDate_initializers = [];
+  let __activeDate_extraInitializers = [];
+  let __selected_decorators;
+  let __selected_initializers = [];
+  let __selected_extraInitializers = [];
+  let _set__wide_decorators;
+  let __calendarView_decorators;
+  let __calendarView_initializers = [];
+  let __calendarView_extraInitializers = [];
+  let __initialized_decorators;
+  let __initialized_initializers = [];
+  let __initialized_extraInitializers = [];
+  var SbbCalendarElement2 = (_a = class extends _classSuper {
+    constructor() {
+      var _a2;
+      super();
+      __privateAdd(this, _wide_accessor_storage);
+      __privateAdd(this, _view_accessor_storage);
+      __privateAdd(this, _dateFilter_accessor_storage);
+      __privateAdd(this, __activeDate_accessor_storage);
+      __privateAdd(this, __selected_accessor_storage);
+      __privateAdd(this, __calendarView_accessor_storage);
+      __privateAdd(this, __initialized_accessor_storage);
+      __privateSet(this, _wide_accessor_storage, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _wide_initializers, false)));
+      __privateSet(this, _view_accessor_storage, (__runInitializers(this, _wide_extraInitializers), __runInitializers(this, _view_initializers, "day")));
+      this._min = __runInitializers(this, _view_extraInitializers);
+      this._now = null;
+      __privateSet(this, _dateFilter_accessor_storage, __runInitializers(this, _dateFilter_initializers, null));
+      this._dateAdapter = (__runInitializers(this, _dateFilter_extraInitializers), ((_a2 = readConfig().datetime) == null ? void 0 : _a2.dateAdapter) ?? defaultDateAdapter);
+      this._dateSelected = new EventEmitter(this, SbbCalendarElement2.events.dateSelected);
+      __privateSet(this, __activeDate_accessor_storage, __runInitializers(this, __activeDate_initializers, this.now));
+      __privateSet(this, __selected_accessor_storage, (__runInitializers(this, __activeDate_extraInitializers), __runInitializers(this, __selected_initializers, void 0)));
+      __privateSet(this, __calendarView_accessor_storage, (__runInitializers(this, __selected_extraInitializers), __runInitializers(this, __calendarView_initializers, "day")));
+      this._nextCalendarView = (__runInitializers(this, __calendarView_extraInitializers), "day");
+      this._weeks = [];
       this._monthNames = this._dateAdapter.getMonthNames("long");
+      this._resetFocus = false;
+      __privateSet(this, __initialized_accessor_storage, __runInitializers(this, __initialized_initializers, false));
+      this._abort = (__runInitializers(this, __initialized_extraInitializers), new SbbConnectedAbortController(this));
+      this._language = new SbbLanguageController(this).withHandler(() => {
+        this._monthNames = this._dateAdapter.getMonthNames("long");
+        this._createMonthRows();
+      });
       this._createMonthRows();
-    });
-    this._createMonthRows();
-    this._setWeekdays();
-  }
-  set min(value) {
-    this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
-  }
-  get min() {
-    return this._min ?? null;
-  }
-  set max(value) {
-    this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
-  }
-  get max() {
-    return this._max ?? null;
-  }
-  set now(value) {
-    this._now = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
-  }
-  get now() {
-    return this._now ?? this._dateAdapter.today();
-  }
-  set selected(value) {
-    this._selectedDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
-    if (!!this._selectedDate && (!this._isDayInRange(this._dateAdapter.toIso8601(this._selectedDate)) || this._dateFilter(this._selectedDate))) {
-      this._selected = this._dateAdapter.toIso8601(this._selectedDate);
-    } else {
-      this._selected = void 0;
+      this._setWeekdays();
     }
-  }
-  get selected() {
-    return this._selectedDate ?? null;
-  }
-  set _wide(wide) {
-    this.toggleAttribute("data-wide", wide);
-  }
-  get _wide() {
-    return this.hasAttribute("data-wide");
-  }
-  /** A list of buttons corresponding to days, months or years depending on the view. */
-  get _cells() {
-    return Array.from(
-      this.shadowRoot.querySelectorAll(".sbb-calendar__cell") ?? []
-    );
-  }
-  _dateFilter(date) {
-    var _a;
-    return ((_a = this.dateFilter) == null ? void 0 : _a.call(this, date)) ?? true;
-  }
-  /** Resets the active month according to the new state of the calendar. */
-  resetPosition() {
-    this._resetCalendarView();
-    this._init();
-  }
-  connectedCallback() {
-    var _a;
-    super.connectedCallback();
-    this.resetPosition();
-    this.focus = () => {
-      this._resetFocus = true;
-      this._focusCell();
-    };
-    (_a = globalThis.window) == null ? void 0 : _a.addEventListener("resize", () => this._init(), {
-      passive: true,
-      signal: this._abort.signal
-    });
-  }
-  willUpdate(changedProperties) {
-    super.willUpdate(changedProperties);
-    if (!this._initialized) {
-      return;
+    /** If set to true, two months are displayed */
+    get wide() {
+      return __privateGet(this, _wide_accessor_storage);
     }
-    if (changedProperties.has("wide")) {
-      this.resetPosition();
+    set wide(value) {
+      __privateSet(this, _wide_accessor_storage, value);
     }
-    if (changedProperties.has("view")) {
-      this._setChosenYear();
-      this._chosenMonth = void 0;
-      this._nextCalendarView = this._calendarView = this.view;
+    /** The initial view of the calendar which should be displayed on opening. */
+    get view() {
+      return __privateGet(this, _view_accessor_storage);
     }
-  }
-  updated(changedProperties) {
-    super.updated(changedProperties);
-    this._setTabIndex();
-    if (sbbInputModalityDetector.mostRecentModality === "keyboard") {
-      this._focusCell();
+    set view(value) {
+      __privateSet(this, _view_accessor_storage, value);
     }
-  }
-  /** Initializes the component. */
-  _init(activeDate) {
-    if (isServer) {
-      return;
-    } else if (this.hydrationRequired) {
-      this.hydrationComplete.then(() => this._init());
-      return;
-    }
-    if (activeDate) {
-      this._assignActiveDate(activeDate);
-    }
-    this._wide = isBreakpoint("medium") && this.wide;
-    this._weeks = this._createWeekRows(this._activeDate);
-    this._years = this._createYearRows();
-    this._nextMonthWeeks = [[]];
-    this._nextMonthYears = [[]];
-    if (this._wide) {
-      const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);
-      this._nextMonthWeeks = this._createWeekRows(nextMonthDate);
-      this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);
-    }
-    this._initialized = true;
-  }
-  /** Focuses on a day cell prioritizing the selected day, the current day, and lastly, the first selectable day. */
-  _focusCell() {
-    var _a;
-    if (this._resetFocus) {
-      (_a = this._getFirstFocusable()) == null ? void 0 : _a.focus();
-      this._resetFocus = false;
+    /** The minimum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */
+    set min(value) {
+      this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
     }
-  }
-  /** Creates the array of weekdays. */
-  _setWeekdays() {
-    const narrowWeekdays = this._dateAdapter.getDayOfWeekNames("narrow");
-    const longWeekdays = this._dateAdapter.getDayOfWeekNames("long");
-    const weekdays = longWeekdays.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 for each week. */
-  _createWeekRows(value) {
-    const daysInMonth = this._dateAdapter.getNumDaysInMonth(value);
-    const dateNames = this._dateAdapter.getDateNames();
-    const weeks = [[]];
-    const weekOffset = this._dateAdapter.getFirstWeekOffset(value);
-    for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {
-      if (cell === DAYS_PER_ROW) {
-        weeks.push([]);
-        cell = 0;
+    get min() {
+      return this._min ?? null;
+    }
+    /** The maximum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */
+    set max(value) {
+      this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+    }
+    get max() {
+      return this._max ?? null;
+    }
+    /** A configured date which acts as the current date instead of the real current date. Recommended for testing purposes. */
+    set now(value) {
+      this._now = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+    }
+    get now() {
+      return this._now ?? this._dateAdapter.today();
+    }
+    /** The selected date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */
+    set selected(value) {
+      this._selectedDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+      if (!!this._selectedDate && (!this._isDayInRange(this._dateAdapter.toIso8601(this._selectedDate)) || this._dateFilter(this._selectedDate))) {
+        this._selected = this._dateAdapter.toIso8601(this._selectedDate);
+      } else {
+        this._selected = void 0;
       }
-      const date = this._dateAdapter.createDate(
-        this._dateAdapter.getYear(value),
-        this._dateAdapter.getMonth(value),
-        i + 1
-      );
-      weeks[weeks.length - 1].push({
-        value: this._dateAdapter.toIso8601(date),
-        dayValue: dateNames[i],
-        monthValue: String(this._dateAdapter.getMonth(date)),
-        yearValue: String(this._dateAdapter.getYear(date))
+    }
+    get selected() {
+      return this._selectedDate ?? null;
+    }
+    /** A function used to filter out dates. */
+    get dateFilter() {
+      return __privateGet(this, _dateFilter_accessor_storage);
+    }
+    set dateFilter(value) {
+      __privateSet(this, _dateFilter_accessor_storage, value);
+    }
+    /** The currently active date. */
+    get _activeDate() {
+      return __privateGet(this, __activeDate_accessor_storage);
+    }
+    set _activeDate(value) {
+      __privateSet(this, __activeDate_accessor_storage, value);
+    }
+    /** The selected date as ISOString. */
+    get _selected() {
+      return __privateGet(this, __selected_accessor_storage);
+    }
+    set _selected(value) {
+      __privateSet(this, __selected_accessor_storage, value);
+    }
+    /** The current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */
+    set _wide(wide) {
+      this.toggleAttribute("data-wide", wide);
+    }
+    get _wide() {
+      return this.hasAttribute("data-wide");
+    }
+    get _calendarView() {
+      return __privateGet(this, __calendarView_accessor_storage);
+    }
+    set _calendarView(value) {
+      __privateSet(this, __calendarView_accessor_storage, value);
+    }
+    /** A list of buttons corresponding to days, months or years depending on the view. */
+    get _cells() {
+      return Array.from(this.shadowRoot.querySelectorAll(".sbb-calendar__cell") ?? []);
+    }
+    get _initialized() {
+      return __privateGet(this, __initialized_accessor_storage);
+    }
+    set _initialized(value) {
+      __privateSet(this, __initialized_accessor_storage, value);
+    }
+    _dateFilter(date) {
+      var _a2;
+      return ((_a2 = this.dateFilter) == null ? void 0 : _a2.call(this, date)) ?? true;
+    }
+    /** Resets the active month according to the new state of the calendar. */
+    resetPosition() {
+      this._resetCalendarView();
+      this._init();
+    }
+    connectedCallback() {
+      var _a2;
+      super.connectedCallback();
+      this.resetPosition();
+      this.focus = () => {
+        this._resetFocus = true;
+        this._focusCell();
+      };
+      (_a2 = globalThis.window) == null ? void 0 : _a2.addEventListener("resize", () => this._init(), {
+        passive: true,
+        signal: this._abort.signal
       });
     }
-    return weeks;
-  }
-  /** Creates the rows for the month selection view. */
-  _createMonthRows() {
-    const shortNames = this._dateAdapter.getMonthNames("short");
-    const months = new Array(12).fill(null).map(
-      (_, i) => ({
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (!this._initialized) {
+        return;
+      }
+      if (changedProperties.has("wide")) {
+        this.resetPosition();
+      }
+      if (changedProperties.has("view")) {
+        this._setChosenYear();
+        this._chosenMonth = void 0;
+        this._nextCalendarView = this._calendarView = this.view;
+      }
+    }
+    updated(changedProperties) {
+      super.updated(changedProperties);
+      this._setTabIndex();
+      if (sbbInputModalityDetector.mostRecentModality === "keyboard") {
+        this._focusCell();
+      }
+    }
+    /** Initializes the component. */
+    _init(activeDate) {
+      if (isServer) {
+        return;
+      } else if (this.hydrationRequired) {
+        this.hydrationComplete.then(() => this._init());
+        return;
+      }
+      if (activeDate) {
+        this._assignActiveDate(activeDate);
+      }
+      this._wide = isBreakpoint("medium") && this.wide;
+      this._weeks = this._createWeekRows(this._activeDate);
+      this._years = this._createYearRows();
+      this._nextMonthWeeks = [[]];
+      this._nextMonthYears = [[]];
+      if (this._wide) {
+        const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);
+        this._nextMonthWeeks = this._createWeekRows(nextMonthDate);
+        this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);
+      }
+      this._initialized = true;
+    }
+    /** Focuses on a day cell prioritizing the selected day, the current day, and lastly, the first selectable day. */
+    _focusCell() {
+      var _a2;
+      if (this._resetFocus) {
+        (_a2 = this._getFirstFocusable()) == null ? void 0 : _a2.focus();
+        this._resetFocus = false;
+      }
+    }
+    /** Creates the array of weekdays. */
+    _setWeekdays() {
+      const narrowWeekdays = this._dateAdapter.getDayOfWeekNames("narrow");
+      const longWeekdays = this._dateAdapter.getDayOfWeekNames("long");
+      const weekdays = longWeekdays.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 for each week. */
+    _createWeekRows(value) {
+      const daysInMonth = this._dateAdapter.getNumDaysInMonth(value);
+      const dateNames = this._dateAdapter.getDateNames();
+      const weeks = [[]];
+      const weekOffset = this._dateAdapter.getFirstWeekOffset(value);
+      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({
+          value: this._dateAdapter.toIso8601(date),
+          dayValue: dateNames[i],
+          monthValue: String(this._dateAdapter.getMonth(date)),
+          yearValue: String(this._dateAdapter.getYear(date))
+        });
+      }
+      return weeks;
+    }
+    /** Creates the rows for the month selection view. */
+    _createMonthRows() {
+      const shortNames = this._dateAdapter.getMonthNames("short");
+      const months = new Array(12).fill(null).map((_, i) => ({
         value: shortNames[i],
         longValue: this._monthNames[i],
         monthValue: i + 1
-      })
-    );
-    const rows = 12 / MONTHS_PER_ROW;
-    const monthArray = [];
-    for (let i = 0; i < rows; i++) {
-      monthArray.push(months.slice(MONTHS_PER_ROW * i, MONTHS_PER_ROW * (i + 1)));
-    }
-    this._months = monthArray;
-  }
-  /** Creates the rows for the year selection view. */
-  _createYearRows(offset = 0) {
-    const startValueYearView = this._getStartValueYearView();
-    const allYears = new Array(YEARS_PER_PAGE).fill(0).map((_, i) => startValueYearView + offset + i);
-    const rows = YEARS_PER_PAGE / YEARS_PER_ROW;
-    const yearArray = [];
-    for (let i = 0; i < rows; i++) {
-      yearArray.push(allYears.slice(YEARS_PER_ROW * i, YEARS_PER_ROW * (i + 1)));
-    }
-    return yearArray;
-  }
-  /**
-   * Calculates the first year that will be shown in the year selection panel.
-   * If `minDate` and `maxDate` are both null, the starting year is calculated as
-   * the multiple of YEARS_PER_PAGE closest to and less than activeDate,
-   * e.g., with `YEARS_PER_PAGE` = 24 and `activeDate` = 2020, the function will return 2016 (24 * 83),
-   * while with `activeDate` = 2000, the function will return 1992 (24 * 82).
-   * If `minDate` is not null, it returns the corresponding year; if `maxDate` is not null,
-   * it returns the corresponding year minus `YEARS_PER_PAGE`, so that the `maxDate` is the last rendered year.
-   * If both are not null, `maxDate` has priority over `minDate`.
-   */
-  _getStartValueYearView() {
-    let startingYear = 0;
-    if (this.max) {
-      startingYear = this._dateAdapter.getYear(this.max) - YEARS_PER_PAGE + 1;
-    } else if (this.min) {
-      startingYear = this._dateAdapter.getYear(this.min);
-    }
-    const activeYear = this._dateAdapter.getYear(this._activeDate);
-    return activeYear - ((activeYear - startingYear) % YEARS_PER_PAGE + YEARS_PER_PAGE) % YEARS_PER_PAGE;
-  }
-  /** Checks if date is within the min-max range. */
-  _isDayInRange(date) {
-    if (!this._min && !this._max) {
-      return true;
-    }
-    const isBeforeMin = this._dateAdapter.isValid(this._min) && this._dateAdapter.compareDate(this._min, this._dateAdapter.deserialize(date)) > 0;
-    const isAfterMax = this._dateAdapter.isValid(this._max) && this._dateAdapter.compareDate(this._max, this._dateAdapter.deserialize(date)) < 0;
-    return !(isBeforeMin || isAfterMax);
-  }
-  _isMonthInRange(month) {
-    if (!this._min && !this._max) {
-      return true;
+      }));
+      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;
     }
-    const isBeforeMin = this._dateAdapter.isValid(this._min) && this._dateAdapter.getYear(this._min) >= this._chosenYear && this._dateAdapter.getMonth(this._min) > month;
-    const isAfterMax = this._dateAdapter.isValid(this._max) && this._dateAdapter.getYear(this._max) <= this._chosenYear && this._dateAdapter.getMonth(this._max) < month;
-    return !(isBeforeMin || isAfterMax);
-  }
-  _isYearInRange(year) {
-    if (!this._min && !this._max) {
-      return true;
+    /** Creates the rows for the year selection view. */
+    _createYearRows(offset = 0) {
+      const startValueYearView = this._getStartValueYearView();
+      const allYears = new Array(YEARS_PER_PAGE).fill(0).map((_, i) => startValueYearView + offset + i);
+      const rows = YEARS_PER_PAGE / YEARS_PER_ROW;
+      const yearArray = [];
+      for (let i = 0; i < rows; i++) {
+        yearArray.push(allYears.slice(YEARS_PER_ROW * i, YEARS_PER_ROW * (i + 1)));
+      }
+      return yearArray;
     }
-    const isBeforeMin = this._dateAdapter.isValid(this._min) && this._dateAdapter.getYear(this._min) > year;
-    const isAfterMax = this._dateAdapter.isValid(this._max) && this._dateAdapter.getYear(this._max) < year;
-    return !(isBeforeMin || isAfterMax);
-  }
-  // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/year-view.ts#L366
-  _isMonthFilteredOut(month) {
-    if (!this.dateFilter) {
-      return true;
-    }
-    const firstOfMonth = this._dateAdapter.createDate(this._chosenYear, month, 1);
-    for (let date = firstOfMonth; this._dateAdapter.getMonth(date) == month; date = this._dateAdapter.addCalendarDays(date, 1)) {
-      if (this.dateFilter(date)) {
+    /**
+     * 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(date) {
+      if (!this.min && !this.max) {
         return true;
       }
+      const isBeforeMin = this._dateAdapter.isValid(this.min) && this._dateAdapter.compareDate(this.min, this._dateAdapter.deserialize(date)) > 0;
+      const isAfterMax = this._dateAdapter.isValid(this.max) && this._dateAdapter.compareDate(this.max, this._dateAdapter.deserialize(date)) < 0;
+      return !(isBeforeMin || isAfterMax);
     }
-    return false;
-  }
-  // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/multi-year-view.ts#L351
-  _isYearFilteredOut(year) {
-    if (!this.dateFilter) {
-      return true;
-    }
-    const firstOfYear = this._dateAdapter.createDate(year, 1, 1);
-    for (let date = firstOfYear; this._dateAdapter.getYear(date) == year; date = this._dateAdapter.addCalendarDays(date, 1)) {
-      if (this.dateFilter(date)) {
+    _isMonthInRange(month, year) {
+      if (!this.min && !this.max) {
         return true;
       }
+      const isBeforeMin = this._dateAdapter.isValid(this.min) && (year < this._dateAdapter.getYear(this.min) || year === this._dateAdapter.getYear(this.min) && month < this._dateAdapter.getMonth(this.min));
+      const isAfterMax = this._dateAdapter.isValid(this.max) && (year > this._dateAdapter.getYear(this.max) || year === this._dateAdapter.getYear(this.max) && month > this._dateAdapter.getMonth(this.max));
+      return !(isBeforeMin || isAfterMax);
     }
-    return false;
-  }
-  /** Emits the selected date and sets it internally. */
-  _selectDate(day) {
-    this._chosenMonth = void 0;
-    this._setChosenYear();
-    if (this._selected !== day) {
-      this._selected = day;
-      this._dateSelected.emit(this._dateAdapter.deserialize(day));
+    _isYearInRange(year) {
+      if (!this.min && !this.max) {
+        return true;
+      }
+      const isBeforeMin = this._dateAdapter.isValid(this.min) && this._dateAdapter.getYear(this.min) > year;
+      const isAfterMax = this._dateAdapter.isValid(this.max) && this._dateAdapter.getYear(this.max) < year;
+      return !(isBeforeMin || isAfterMax);
     }
-  }
-  _setChosenYear() {
-    if (this.view === "month") {
-      this._chosenYear = this._dateAdapter.getYear(
-        this._dateAdapter.deserialize(this._selected) ?? this.selected ?? this.now
-      );
-    } else {
-      this._chosenYear = void 0;
+    // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/year-view.ts#L366
+    _isMonthFilteredOut(month, year) {
+      if (!this.dateFilter) {
+        return true;
+      }
+      const firstOfMonth = this._dateAdapter.createDate(year, month, 1);
+      for (let date = firstOfMonth; this._dateAdapter.getMonth(date) == month; date = this._dateAdapter.addCalendarDays(date, 1)) {
+        if (this.dateFilter(date)) {
+          return true;
+        }
+      }
+      return false;
     }
-  }
-  _assignActiveDate(date) {
-    if (this._min && this._dateAdapter.compareDate(this._min, date) > 0) {
-      this._activeDate = this._min;
-      return;
+    // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/multi-year-view.ts#L351
+    _isYearFilteredOut(year) {
+      if (!this.dateFilter) {
+        return true;
+      }
+      const firstOfYear = this._dateAdapter.createDate(year, 1, 1);
+      for (let date = firstOfYear; this._dateAdapter.getYear(date) == year; date = this._dateAdapter.addCalendarDays(date, 1)) {
+        if (this.dateFilter(date)) {
+          return true;
+        }
+      }
+      return false;
     }
-    if (this._max && this._dateAdapter.compareDate(this._max, date) < 0) {
-      this._activeDate = this._max;
-      return;
+    /** Emits the selected date and sets it internally. */
+    _selectDate(day) {
+      this._chosenMonth = void 0;
+      this._setChosenYear();
+      if (this._selected !== day) {
+        this._selected = day;
+        this._dateSelected.emit(this._dateAdapter.deserialize(day));
+      }
     }
-    this._activeDate = date;
-  }
-  /** Goes to the month identified by the shift. */
-  _goToDifferentMonth(months) {
-    this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));
-  }
-  _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;
+    _setChosenYear() {
+      if (this.view === "month") {
+        this._chosenYear = this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected) ?? this.selected ?? this.now);
+      } else {
+        this._chosenYear = void 0;
+      }
     }
-    return this._dateAdapter.compareDate(prevDate, this._min) < 0;
-  }
-  _nextDisabled(nextDate) {
-    if (!this._max) {
-      return false;
+    _assignActiveDate(date) {
+      if (this.min && this._dateAdapter.compareDate(this.min, date) > 0) {
+        this._activeDate = this.min;
+        return;
+      }
+      if (this.max && this._dateAdapter.compareDate(this.max, date) < 0) {
+        this._activeDate = this.max;
+        return;
+      }
+      this._activeDate = date;
     }
-    return this._dateAdapter.compareDate(nextDate, this._max) > 0;
-  }
-  /** Checks if the "previous month" button should be disabled. */
-  _previousMonthDisabled() {
-    const prevMonth = this._dateAdapter.addCalendarDays(
-      this._activeDate,
-      this._dateAdapter.getDate(this._activeDate) * -1
-    );
-    return this._prevDisabled(prevMonth);
-  }
-  /** Checks if the "next month" button should be disabled. */
-  _nextMonthDisabled() {
-    let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);
-    nextMonth = this._dateAdapter.createDate(
-      this._dateAdapter.getYear(nextMonth),
-      this._dateAdapter.getMonth(nextMonth),
-      1
-    );
-    return this._nextDisabled(nextMonth);
-  }
-  _previousYearDisabled() {
-    const prevYear = this._dateAdapter.createDate(
-      this._dateAdapter.getYear(this._activeDate) - 1,
-      12,
-      31
-    );
-    return this._prevDisabled(prevYear);
-  }
-  _nextYearDisabled() {
-    const nextYear = this._dateAdapter.createDate(
-      this._dateAdapter.getYear(this._activeDate) + 1,
-      1,
-      1
-    );
-    return this._nextDisabled(nextYear);
-  }
-  _previousYearRangeDisabled() {
-    const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);
-    return this._prevDisabled(prevYear);
-  }
-  _nextYearRangeDisabled() {
-    const years = isBreakpoint("medium") && this.wide ? this._nextMonthYears : this._years;
-    const lastYearRange = years[years.length - 1];
-    const lastYear = lastYearRange[lastYearRange.length - 1];
-    const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);
-    return this._nextDisabled(nextYear);
-  }
-  _handleTableBlur(eventTarget) {
-    if ((eventTarget == null ? void 0 : eventTarget.localName) !== "button") {
-      this._setTabIndex();
+    /** Goes to the month identified by the shift. */
+    _goToDifferentMonth(months) {
+      this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));
     }
-  }
-  _setTabIndex() {
-    Array.from(
-      this.shadowRoot.querySelectorAll('.sbb-calendar__cell[tabindex="0"]') ?? []
-    ).forEach((day) => day.tabIndex = -1);
-    const firstFocusable = this._getFirstFocusable();
-    if (firstFocusable) {
-      firstFocusable.tabIndex = 0;
+    _goToDifferentYear(years) {
+      this._chosenYear += years;
+      this._activeDate = this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate));
+      this._init();
     }
-  }
-  _getFirstFocusable() {
-    const active = this._selected ? this._dateAdapter.deserialize(this._selected) : this.now;
-    let firstFocusable = this.shadowRoot.querySelector(".sbb-calendar__selected") ?? this.shadowRoot.querySelector(
-      `[data-day="${this._dateAdapter.getDate(active)} ${this._dateAdapter.getMonth(
-        active
-      )} ${this._dateAdapter.getYear(active)}"]`
-    ) ?? this.shadowRoot.querySelector(`[data-month="${this._dateAdapter.getMonth(active)}"]`) ?? this.shadowRoot.querySelector(`[data-year="${this._dateAdapter.getYear(active)}"]`);
-    if (!firstFocusable || (firstFocusable == null ? void 0 : firstFocusable.disabled)) {
-      firstFocusable = this.shadowRoot.querySelector(".sbb-calendar__cell:not([disabled])");
-    }
-    return firstFocusable || null;
-  }
-  _handleKeyboardEvent(event, day) {
-    if (isArrowKeyOrPageKeysPressed(event)) {
-      event.preventDefault();
-    }
-    const cells = this._cells;
-    const index = cells.findIndex((e) => e === event.target);
-    const nextEl = this._navigateByKeyboard(event, index, cells, day);
-    const activeEl = this.shadowRoot.activeElement;
-    if (nextEl !== activeEl) {
-      nextEl.tabIndex = 0;
-      nextEl == null ? void 0 : nextEl.focus();
-      activeEl.tabIndex = -1;
+    _goToDifferentYearRange(years) {
+      this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));
     }
-  }
-  /**
-   * 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, day) {
-    const {
-      elementIndexForWideMode,
-      offsetForWideMode,
-      lastElementIndexForWideMode,
-      verticalOffset
-    } = this._calculateParametersForKeyboardNavigation(
-      cells,
-      index,
-      day
-    );
-    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];
+    _prevDisabled(prevDate) {
+      if (!this.min) {
+        return false;
+      }
+      return this._dateAdapter.compareDate(prevDate, this.min) < 0;
     }
-  }
-  /**
-   * Calculates the parameter needed in keyboard navigation.
-   * Since three views are now available, the function creates and returns the correct parameters for each of them
-   * by considering the number of cells per each row and the correction for the wide mode.
-   * @param cells The array of rendered table cells; they are buttons that can represent days, months or years.
-   * @param index The starting element's index in the cell array.
-   * @param day (optional) Only in the day view, the day represented by the starting cell.
-   */
-  _calculateParametersForKeyboardNavigation(cells, index, day) {
-    switch (this._calendarView) {
-      case "day": {
-        const indexInView = +day.dayValue - 1;
-        return {
-          verticalOffset: DAYS_PER_ROW,
-          elementIndexForWideMode: indexInView,
-          offsetForWideMode: index - indexInView,
-          lastElementIndexForWideMode: index === indexInView ? this._dateAdapter.getNumDaysInMonth(
-            this._dateAdapter.addCalendarMonths(
-              this._dateAdapter.deserialize(day.value),
-              -1
-            )
-          ) : cells.length
-        };
+    _nextDisabled(nextDate) {
+      if (!this.max) {
+        return false;
       }
-      case "month": {
-        return {
-          verticalOffset: MONTHS_PER_ROW,
-          elementIndexForWideMode: index,
-          offsetForWideMode: 0,
-          lastElementIndexForWideMode: 12
-        };
+      return this._dateAdapter.compareDate(nextDate, this.max) > 0;
+    }
+    /** Checks if the "previous month" button should be disabled. */
+    _previousMonthDisabled() {
+      const prevMonth = this._dateAdapter.addCalendarDays(this._activeDate, this._dateAdapter.getDate(this._activeDate) * -1);
+      return this._prevDisabled(prevMonth);
+    }
+    /** Checks if the "next month" button should be disabled. */
+    _nextMonthDisabled() {
+      let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);
+      nextMonth = this._dateAdapter.createDate(this._dateAdapter.getYear(nextMonth), this._dateAdapter.getMonth(nextMonth), 1);
+      return this._nextDisabled(nextMonth);
+    }
+    _previousYearDisabled() {
+      const prevYear = this._dateAdapter.createDate(this._dateAdapter.getYear(this._activeDate) - 1, 12, 31);
+      return this._prevDisabled(prevYear);
+    }
+    _nextYearDisabled() {
+      const nextYear = this._dateAdapter.createDate(this._dateAdapter.getYear(this._activeDate) + (this._wide ? 2 : 1), 1, 1);
+      return this._nextDisabled(nextYear);
+    }
+    _previousYearRangeDisabled() {
+      const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);
+      return this._prevDisabled(prevYear);
+    }
+    _nextYearRangeDisabled() {
+      const years = this._wide ? this._nextMonthYears : this._years;
+      const lastYearRange = years[years.length - 1];
+      const lastYear = lastYearRange[lastYearRange.length - 1];
+      const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);
+      return this._nextDisabled(nextYear);
+    }
+    _handleTableBlur(eventTarget) {
+      if ((eventTarget == null ? void 0 : eventTarget.localName) !== "button") {
+        this._setTabIndex();
       }
-      case "year": {
-        const offset = Math.trunc(index / YEARS_PER_PAGE) * YEARS_PER_PAGE;
-        const indexInView = offset === 0 ? index : index - YEARS_PER_PAGE;
-        return {
-          verticalOffset: YEARS_PER_ROW,
-          elementIndexForWideMode: indexInView,
-          offsetForWideMode: index - indexInView,
-          lastElementIndexForWideMode: offset === 0 ? YEARS_PER_PAGE : YEARS_PER_PAGE * 2
-        };
+    }
+    _setTabIndex() {
+      Array.from(this.shadowRoot.querySelectorAll('.sbb-calendar__cell[tabindex="0"]') ?? []).forEach((day) => day.tabIndex = -1);
+      const firstFocusable = this._getFirstFocusable();
+      if (firstFocusable) {
+        firstFocusable.tabIndex = 0;
       }
     }
-  }
-  /**
-   * 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) {
-    var _a;
-    let nextIndex = index + delta;
-    while (nextIndex < days.length && ((_a = days[nextIndex]) == null ? void 0 : _a.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);
-  }
-  _resetCalendarView(initTransition = false) {
-    this._resetFocus = true;
-    this._activeDate = this.selected ?? this.now;
-    this._setChosenYear();
-    this._chosenMonth = void 0;
-    this._nextCalendarView = this._calendarView = this.view;
-    if (initTransition) {
-      this._startTableTransition();
+    _getFirstFocusable() {
+      const active = this._selected ? this._dateAdapter.deserialize(this._selected) : this.now;
+      let firstFocusable = this.shadowRoot.querySelector(".sbb-calendar__selected") ?? this.shadowRoot.querySelector(`[data-day="${this._dateAdapter.getDate(active)} ${this._dateAdapter.getMonth(active)} ${this._dateAdapter.getYear(active)}"]`) ?? this.shadowRoot.querySelector(`[data-month="${this._dateAdapter.getMonth(active)}"]`) ?? this.shadowRoot.querySelector(`[data-year="${this._dateAdapter.getYear(active)}"]`);
+      if (!firstFocusable || (firstFocusable == null ? void 0 : firstFocusable.disabled)) {
+        firstFocusable = this.shadowRoot.querySelector(".sbb-calendar__cell:not([disabled])");
+      }
+      return firstFocusable || null;
     }
-  }
-  /** Render the view for the day selection. */
-  _renderDayView() {
-    const nextMonthActiveDate = this._wide ? this._dateAdapter.addCalendarMonths(this._activeDate, 1) : void 0;
-    return html`
+    _handleKeyboardEvent(event, day) {
+      if (isArrowKeyOrPageKeysPressed(event)) {
+        event.preventDefault();
+      }
+      const cells = this._cells;
+      const index = cells.findIndex((e) => e === event.target);
+      const nextEl = this._navigateByKeyboard(event, index, cells, day);
+      const activeEl = this.shadowRoot.activeElement;
+      if (nextEl !== activeEl) {
+        nextEl.tabIndex = 0;
+        nextEl == null ? void 0 : nextEl.focus();
+        activeEl.tabIndex = -1;
+      }
+    }
+    /**
+     * 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, day) {
+      const { elementIndexForWideMode, offsetForWideMode, lastElementIndexForWideMode, verticalOffset } = this._calculateParametersForKeyboardNavigation(cells, index, day);
+      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 parameter needed in keyboard navigation.
+     * Since three views are now available, the function creates and returns the correct parameters for each of them
+     * by considering the number of cells per each row and the correction for the wide mode.
+     * @param cells The array of rendered table cells; they are buttons that can represent days, months or years.
+     * @param index The starting element's index in the cell array.
+     * @param day (optional) Only in the day view, the day represented by the starting cell.
+     */
+    _calculateParametersForKeyboardNavigation(cells, index, day) {
+      switch (this._calendarView) {
+        case "day": {
+          const indexInView = +day.dayValue - 1;
+          return {
+            verticalOffset: DAYS_PER_ROW,
+            elementIndexForWideMode: indexInView,
+            offsetForWideMode: index - indexInView,
+            lastElementIndexForWideMode: index === indexInView ? this._dateAdapter.getNumDaysInMonth(this._dateAdapter.addCalendarMonths(this._dateAdapter.deserialize(day.value), -1)) : cells.length
+          };
+        }
+        case "month": {
+          return {
+            verticalOffset: MONTHS_PER_ROW,
+            elementIndexForWideMode: index,
+            offsetForWideMode: 0,
+            lastElementIndexForWideMode: 12
+          };
+        }
+        case "year": {
+          const offset = Math.trunc(index / YEARS_PER_PAGE) * YEARS_PER_PAGE;
+          const indexInView = offset === 0 ? index : index - YEARS_PER_PAGE;
+          return {
+            verticalOffset: YEARS_PER_ROW,
+            elementIndexForWideMode: indexInView,
+            offsetForWideMode: index - indexInView,
+            lastElementIndexForWideMode: offset === 0 ? YEARS_PER_PAGE : YEARS_PER_PAGE * 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) {
+      var _a2;
+      let nextIndex = index + delta;
+      while (nextIndex < days.length && ((_a2 = days[nextIndex]) == null ? void 0 : _a2.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);
+    }
+    _resetCalendarView(initTransition = false) {
+      this._resetFocus = true;
+      this._activeDate = this.selected ?? this.now;
+      this._setChosenYear();
+      this._chosenMonth = void 0;
+      this._nextCalendarView = this._calendarView = this.view;
+      if (initTransition) {
+        this._startTableTransition();
+      }
+    }
+    /** Render the view for the day selection. */
+    _renderDayView() {
+      const nextMonthActiveDate = this._wide ? this._dateAdapter.addCalendarMonths(this._activeDate, 1) : void 0;
+      return html`
       <div class="sbb-calendar__controls">
-        ${this._getArrow(
-      "left",
-      () => this._goToDifferentMonth(-1),
-      i18nPreviousMonth[this._language.current],
-      this._previousMonthDisabled()
-    )}
+        ${this._getArrow("left", () => this._goToDifferentMonth(-1), i18nPreviousMonth[this._language.current], this._previousMonthDisabled())}
         <div class="sbb-calendar__controls-month">
           ${this._createLabelForDayView(this._activeDate)}
           ${this._wide ? this._createLabelForDayView(nextMonthActiveDate) : nothing}
@@ -896,52 +929,46 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
             ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate)}
           </sbb-screen-reader-only>
         </div>
-        ${this._getArrow(
-      "right",
-      () => this._goToDifferentMonth(1),
-      i18nNextMonth[this._language.current],
-      this._nextMonthDisabled()
-    )}
+        ${this._getArrow("right", () => this._goToDifferentMonth(1), i18nNextMonth[this._language.current], this._nextMonthDisabled())}
       </div>
       <div class="sbb-calendar__table-container sbb-calendar__table-day-view">
         ${this._createDayTable(this._weeks)}
         ${this._wide ? this._createDayTable(this._nextMonthWeeks) : nothing}
       </div>
     `;
-  }
-  /** Creates the label with the month for the daily view. */
-  _createLabelForDayView(d) {
-    const monthLabel = `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)}`;
-    return html`
+    }
+    /** Creates the label with the month for the daily view. */
+    _createLabelForDayView(d) {
+      const monthLabel = `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)}`;
+      return html`
       <button
         type="button"
-        id="sbb-calendar__date-selection"
-        class="sbb-calendar__controls-change-date"
+        class="sbb-calendar__date-selection sbb-calendar__controls-change-date"
         aria-label="${i18nYearMonthSelection[this._language.current]} ${monthLabel}"
         @click=${() => {
-      this._resetFocus = true;
-      this._nextCalendarView = "year";
-      this._startTableTransition();
-    }}
+        this._resetFocus = true;
+        this._nextCalendarView = "year";
+        this._startTableTransition();
+      }}
       >
         ${monthLabel}
         <sbb-icon name="chevron-small-down-small"></sbb-icon>
       </button>
     `;
-  }
-  /** Creates the aria-label for the daily view. */
-  _createAriaLabelForDayView(...dates) {
-    let monthLabel = "";
-    for (const d of dates) {
-      if (d) {
-        monthLabel += `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)} `;
+    }
+    /** Creates the aria-label for the daily view. */
+    _createAriaLabelForDayView(...dates) {
+      let monthLabel = "";
+      for (const d of dates) {
+        if (d) {
+          monthLabel += `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)} `;
+        }
       }
+      return monthLabel;
     }
-    return monthLabel;
-  }
-  /** Creates the calendar table for the daily view. */
-  _createDayTable(weeks) {
-    return html`
+    /** Creates the calendar table for the daily view. */
+    _createDayTable(weeks) {
+      return html`
       <table
         class="sbb-calendar__table"
         @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
@@ -957,64 +984,60 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
         </tbody>
       </table>
     `;
-  }
-  /** Creates the table header with the month header cells. */
-  _createDayTableHeader() {
-    return this._weekdays.map(
-      (day) => html`
+    }
+    /** Creates the table header with the month header cells. */
+    _createDayTableHeader() {
+      return this._weekdays.map((day) => html`
         <th class="sbb-calendar__table-header">
           <sbb-screen-reader-only>${day.long}</sbb-screen-reader-only>
           <span aria-hidden="true">${day.narrow}</span>
         </th>
-      `
-    );
-  }
-  /** Creates the table body with the day cells. For the first row, it also considers the possible day's offset. */
-  _createDayTableBody(weeks) {
-    const today = this._dateAdapter.toIso8601(this.now);
-    return weeks.map((week, rowIndex) => {
-      const firstRowOffset = DAYS_PER_ROW - week.length;
-      if (rowIndex === 0 && firstRowOffset) {
-        return html`
+      `);
+    }
+    /** Creates the table body with the day cells. For the first row, it also considers the possible day's offset. */
+    _createDayTableBody(weeks) {
+      const today = this._dateAdapter.toIso8601(this.now);
+      return weeks.map((week, rowIndex) => {
+        const firstRowOffset = DAYS_PER_ROW - week.length;
+        if (rowIndex === 0 && firstRowOffset) {
+          return html`
           <tr>
-            ${[...Array(firstRowOffset).keys()].map(
-          () => html`<td
+            ${[...Array(firstRowOffset).keys()].map(() => html`<td
                   class="sbb-calendar__table-data"
                   data-day=${`0 ${week[0].monthValue} ${week[0].yearValue}`}
-                ></td>`
-        )}
+                ></td>`)}
             ${this._createDayCells(week, today)}
           </tr>
         `;
-      }
-      return html`<tr>
+        }
+        return html`<tr>
         ${this._createDayCells(week, today)}
       </tr>`;
-    });
-  }
-  /** Creates the cells for the daily view. */
-  _createDayCells(week, today) {
-    return week.map((day) => {
-      const isOutOfRange = !this._isDayInRange(day.value);
-      const isFilteredOut = !this._dateFilter(this._dateAdapter.deserialize(day.value));
-      const selected = !!this._selected && day.value === this._selected;
-      const dayValue = `${day.dayValue} ${day.monthValue} ${day.yearValue}`;
-      const isToday = day.value === today;
-      return html`
+      });
+    }
+    /** Creates the cells for the daily view. */
+    _createDayCells(week, today) {
+      return week.map((day) => {
+        const isOutOfRange = !this._isDayInRange(day.value);
+        const isFilteredOut = !this._dateFilter(this._dateAdapter.deserialize(day.value));
+        const selected = !!this._selected && day.value === this._selected;
+        const dayValue = `${day.dayValue} ${day.monthValue} ${day.yearValue}`;
+        const isToday = day.value === today;
+        return html`
         <td
           class=${classMap({
-        "sbb-calendar__table-data": true,
-        "sbb-calendar__table-data-selected": selected
-      })}
+          "sbb-calendar__table-data": true,
+          "sbb-calendar__table-data-selected": selected
+        })}
         >
           <button
             class=${classMap({
-        "sbb-calendar__cell": true,
-        "sbb-calendar__day": true,
-        "sbb-calendar__cell-current": isToday,
-        "sbb-calendar__selected": selected,
-        "sbb-calendar__crossed-out": !isOutOfRange && isFilteredOut
-      })}
+          "sbb-calendar__cell": true,
+          "sbb-calendar__day": true,
+          "sbb-calendar__cell-current": isToday,
+          "sbb-calendar__selected": selected,
+          "sbb-calendar__crossed-out": !isOutOfRange && isFilteredOut
+        })}
             @click=${() => this._selectDate(day.value)}
             ?disabled=${isOutOfRange || isFilteredOut}
             aria-label=${this._dateAdapter.getAccessibilityFormatDate(day.value)}
@@ -1030,35 +1053,25 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
           </button>
         </td>
       `;
-    });
-  }
-  /** Render the view for the month selection. */
-  _renderMonthView() {
-    return html`
+      });
+    }
+    /** Render the view for the month selection. */
+    _renderMonthView() {
+      return html`
       <div class="sbb-calendar__controls">
-        ${this._getArrow(
-      "left",
-      () => this._goToDifferentYear(-1),
-      i18nPreviousYear[this._language.current],
-      this._previousYearDisabled()
-    )}
+        ${this._getArrow("left", () => this._goToDifferentYear(-1), i18nPreviousYear[this._language.current], this._previousYearDisabled())}
         <div class="sbb-calendar__controls-month">${this._createLabelForMonthView()}</div>
-        ${this._getArrow(
-      "right",
-      () => this._goToDifferentYear(1),
-      i18nNextYear[this._language.current],
-      this._nextYearDisabled()
-    )}
+        ${this._getArrow("right", () => this._goToDifferentYear(1), i18nNextYear[this._language.current], this._nextYearDisabled())}
       </div>
       <div class="sbb-calendar__table-container sbb-calendar__table-month-view">
         ${this._createMonthTable(this._months, this._chosenYear)}
-        ${this._wide ? this._createMonthTable(this._months, this._chosenYear + 1, true) : nothing}
+        ${this._wide ? this._createMonthTable(this._months, this._chosenYear + 1) : nothing}
       </div>
     `;
-  }
-  /** Creates the label with the year for the monthly view. */
-  _createLabelForMonthView() {
-    return html` <button
+    }
+    /** Creates the label with the year for the monthly view. */
+    _createLabelForMonthView() {
+      return html` <button
         type="button"
         id="sbb-calendar__month-selection"
         class="sbb-calendar__controls-change-date"
@@ -1069,10 +1082,10 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
         <sbb-icon name="chevron-small-up-small"></sbb-icon>
       </button>
       <sbb-screen-reader-only role="status"> ${this._chosenYear} </sbb-screen-reader-only>`;
-  }
-  /** Creates the table for the month selection view. */
-  _createMonthTable(months, year, shiftRight = false) {
-    return html`
+    }
+    /** Creates the table for the month selection view. */
+    _createMonthTable(months, year) {
+      return html`
       <table
         class="sbb-calendar__table"
         @animationend=${(e) => this._tableAnimationEnd(e)}
@@ -1083,12 +1096,11 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
               </tr>
             </thead>` : nothing}
         <tbody class="sbb-calendar__table-body">
-          ${months.map(
-      (row) => html`
+          ${months.map((row) => html`
               <tr>
                 ${row.map((month) => {
-        const isOutOfRange = !this._isMonthInRange(month.monthValue);
-        const isFilteredOut = !this._isMonthFilteredOut(month.monthValue);
+        const isOutOfRange = !this._isMonthInRange(month.monthValue, year);
+        const isFilteredOut = !this._isMonthFilteredOut(month.monthValue, year);
         const selectedMonth = this._selected ? this._dateAdapter.getMonth(this._dateAdapter.deserialize(this._selected)) : void 0;
         const selectedYear = this._selected ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)) : void 0;
         const selected = !!this._selected && year === selectedYear && month.monthValue === selectedMonth;
@@ -1107,9 +1119,9 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
           "sbb-calendar__crossed-out": !isOutOfRange && isFilteredOut,
           "sbb-calendar__selected": selected
         })}
-                      @click=${() => this._onMonthSelection(month.monthValue, year, shiftRight)}
+                      @click=${() => this._onMonthSelection(month.monthValue, year)}
                       ?disabled=${isOutOfRange || isFilteredOut}
-                      aria-label=${`${month.longValue} ${this._chosenYear}`}
+                      aria-label=${`${month.longValue} ${year}`}
                       aria-pressed=${selected}
                       aria-disabled=${String(isOutOfRange || isFilteredOut)}
                       tabindex="-1"
@@ -1121,52 +1133,35 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
                   </td>`;
       })}
               </tr>
-            `
-    )}
+            `)}
         </tbody>
       </table>
     `;
-  }
-  /** Select the month and change the view to day selection. */
-  _onMonthSelection(month, year, shiftRight) {
-    this._chosenMonth = shiftRight ? month + 1 : month;
-    this._nextCalendarView = "day";
-    this._init(
-      this._dateAdapter.createDate(
-        year,
-        this._chosenMonth,
-        this._dateAdapter.getDate(this._activeDate)
-      )
-    );
-    this._startTableTransition();
-  }
-  /** Render the view for the year selection. */
-  _renderYearView() {
-    return html`
+    }
+    /** Select the month and change the view to day selection. */
+    _onMonthSelection(month, year) {
+      this._chosenMonth = month;
+      this._nextCalendarView = "day";
+      this._init(this._dateAdapter.createDate(year, this._chosenMonth, this._dateAdapter.getDate(this._activeDate)));
+      this._startTableTransition();
+    }
+    /** Render the view for the year selection. */
+    _renderYearView() {
+      return html`
       <div class="sbb-calendar__controls">
-        ${this._getArrow(
-      "left",
-      () => this._goToDifferentYearRange(-YEARS_PER_PAGE),
-      i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current],
-      this._previousYearRangeDisabled()
-    )}
+        ${this._getArrow("left", () => this._goToDifferentYearRange(-YEARS_PER_PAGE), i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current], this._previousYearRangeDisabled())}
         <div class="sbb-calendar__controls-month">${this._createLabelForYearView()}</div>
-        ${this._getArrow(
-      "right",
-      () => this._goToDifferentYearRange(YEARS_PER_PAGE),
-      i18nNextYearRange(YEARS_PER_PAGE)[this._language.current],
-      this._nextYearRangeDisabled()
-    )}
+        ${this._getArrow("right", () => this._goToDifferentYearRange(YEARS_PER_PAGE), i18nNextYearRange(YEARS_PER_PAGE)[this._language.current], this._nextYearRangeDisabled())}
       </div>
       <div class="sbb-calendar__table-container sbb-calendar__table-year-view">
         ${this._createYearTable(this._years)}
         ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}
       </div>
     `;
-  }
-  /** Creates the button arrow for all the views. */
-  _getArrow(direction, click, ariaLabel, disabled) {
-    return html`<sbb-secondary-button
+    }
+    /** Creates the button arrow for all the views. */
+    _getArrow(direction, click, ariaLabel, disabled) {
+      return html`<sbb-secondary-button
       size="m"
       icon-name="chevron-small-${direction}-small"
       aria-label=${ariaLabel}
@@ -1174,14 +1169,14 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
       ?disabled=${disabled}
       id="sbb-calendar__controls-${direction === "left" ? "previous" : "next"}"
     ></sbb-secondary-button>`;
-  }
-  /** Creates the label with the year range for the yearly view. */
-  _createLabelForYearView() {
-    const firstYear = this._years.flat()[0];
-    const lastYearArray = (isBreakpoint("medium") && this.wide ? this._nextMonthYears : this._years).flat();
-    const lastYear = lastYearArray[lastYearArray.length - 1];
-    const yearLabel = `${firstYear} - ${lastYear}`;
-    return html`
+    }
+    /** Creates the label with the year range for the yearly view. */
+    _createLabelForYearView() {
+      const firstYear = this._years.flat()[0];
+      const lastYearArray = (this._wide ? this._nextMonthYears : this._years).flat();
+      const lastYear = lastYearArray[lastYearArray.length - 1];
+      const yearLabel = `${firstYear} - ${lastYear}`;
+      return html`
       <button
         type="button"
         id="sbb-calendar__year-selection"
@@ -1194,17 +1189,16 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
       </button>
       <sbb-screen-reader-only role="status"> ${yearLabel} </sbb-screen-reader-only>
     `;
-  }
-  /** Creates the table for the year selection view. */
-  _createYearTable(years, shiftRight = false) {
-    const now = this.now;
-    return html` <table
+    }
+    /** Creates the table for the year selection view. */
+    _createYearTable(years, shiftRight = false) {
+      const now = this.now;
+      return html` <table
       class="sbb-calendar__table"
       @animationend=${(e) => this._tableAnimationEnd(e)}
     >
       <tbody class="sbb-calendar__table-body">
-        ${years.map(
-      (row) => html` <tr>
+        ${years.map((row) => html` <tr>
               ${row.map((year) => {
         const isOutOfRange = !this._isYearInRange(year);
         const isFilteredOut = !this._isYearFilteredOut(year);
@@ -1233,101 +1227,108 @@ let SbbCalendarElement = class extends SbbHydrationMixin(LitElement) {
                   </button>
                 </td>`;
       })}
-            </tr>`
-    )}
+            </tr>`)}
       </tbody>
     </table>`;
-  }
-  /** Select the year and change the view to month selection. */
-  _onYearSelection(year, rightSide) {
-    this._chosenYear = rightSide ? year - 1 : year;
-    this._nextCalendarView = "month";
-    this._assignActiveDate(
-      this._dateAdapter.createDate(
-        this._chosenYear,
-        this._dateAdapter.getMonth(this._activeDate),
-        this._dateAdapter.getDate(this._activeDate)
-      )
-    );
-    this._startTableTransition();
-  }
-  _getView() {
-    if (isServer || this.hydrationRequired) {
-      return html`${nothing}`;
-    }
-    switch (this._calendarView) {
-      case "year":
-        return this._renderYearView();
-      case "month":
-        return this._renderMonthView();
-      case "day":
-      default:
-        return this._renderDayView();
     }
-  }
-  _tableAnimationEnd(event) {
-    const table = event.target;
-    if (event.animationName === "hide") {
-      table.classList.remove("sbb-calendar__table-hide");
-      this._resetFocus = true;
-      this._calendarView = this._nextCalendarView;
-    } else if (event.animationName === "show") {
-      this.removeAttribute("data-transition");
+    /** Select the year and change the view to month selection. */
+    _onYearSelection(year, rightSide) {
+      this._chosenYear = rightSide ? year - 1 : year;
+      this._nextCalendarView = "month";
+      this._assignActiveDate(this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate)));
+      this._startTableTransition();
     }
-  }
-  _startTableTransition() {
-    var _a, _b;
-    this.toggleAttribute("data-transition", true);
-    (_b = (_a = this.shadowRoot) == null ? void 0 : _a.querySelectorAll("table")) == null ? void 0 : _b.forEach((e) => e.classList.toggle("sbb-calendar__table-hide"));
-  }
-  render() {
-    return html`<div class="sbb-calendar__wrapper">${this._getView()}</div>`;
-  }
-};
-SbbCalendarElement.styles = style;
-SbbCalendarElement.events = {
-  dateSelected: "dateSelected"
-};
-__decorateClass([
-  property({ type: Boolean })
-], SbbCalendarElement.prototype, "wide", 2);
-__decorateClass([
-  property()
-], SbbCalendarElement.prototype, "view", 2);
-__decorateClass([
-  property()
-], SbbCalendarElement.prototype, "min", 1);
-__decorateClass([
-  property()
-], SbbCalendarElement.prototype, "max", 1);
-__decorateClass([
-  property()
-], SbbCalendarElement.prototype, "now", 1);
-__decorateClass([
-  property()
-], SbbCalendarElement.prototype, "selected", 1);
-__decorateClass([
-  property({ attribute: "date-filter" })
-], SbbCalendarElement.prototype, "dateFilter", 2);
-__decorateClass([
-  state()
-], SbbCalendarElement.prototype, "_activeDate", 2);
-__decorateClass([
-  state()
-], SbbCalendarElement.prototype, "_selected", 2);
-__decorateClass([
-  state()
-], SbbCalendarElement.prototype, "_wide", 1);
-__decorateClass([
-  state()
-], SbbCalendarElement.prototype, "_calendarView", 2);
-__decorateClass([
-  state()
-], SbbCalendarElement.prototype, "_initialized", 2);
-SbbCalendarElement = __decorateClass([
-  customElement("sbb-calendar")
-], SbbCalendarElement);
+    _getView() {
+      if (isServer || this.hydrationRequired) {
+        return html`${nothing}`;
+      }
+      switch (this._calendarView) {
+        case "year":
+          return this._renderYearView();
+        case "month":
+          return this._renderMonthView();
+        case "day":
+        default:
+          return this._renderDayView();
+      }
+    }
+    _tableAnimationEnd(event) {
+      const table = event.target;
+      if (event.animationName === "hide") {
+        table.classList.remove("sbb-calendar__table-hide");
+        this._resetFocus = true;
+        this._calendarView = this._nextCalendarView;
+      } else if (event.animationName === "show") {
+        this.removeAttribute("data-transition");
+      }
+    }
+    _startTableTransition() {
+      var _a2, _b;
+      this.toggleAttribute("data-transition", true);
+      (_b = (_a2 = this.shadowRoot) == null ? void 0 : _a2.querySelectorAll("table")) == null ? void 0 : _b.forEach((e) => e.classList.toggle("sbb-calendar__table-hide"));
+    }
+    render() {
+      return html`<div class="sbb-calendar__wrapper">${this._getView()}</div>`;
+    }
+  }, _wide_accessor_storage = new WeakMap(), _view_accessor_storage = new WeakMap(), _dateFilter_accessor_storage = new WeakMap(), __activeDate_accessor_storage = new WeakMap(), __selected_accessor_storage = new WeakMap(), __calendarView_accessor_storage = new WeakMap(), __initialized_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _wide_decorators = [forceType(), property({ type: Boolean })];
+    _view_decorators = [property()];
+    _set_min_decorators = [property()];
+    _set_max_decorators = [property()];
+    _set_now_decorators = [property()];
+    _set_selected_decorators = [property()];
+    _dateFilter_decorators = [property({ attribute: "date-filter" })];
+    __activeDate_decorators = [state()];
+    __selected_decorators = [state()];
+    _set__wide_decorators = [state()];
+    __calendarView_decorators = [state()];
+    __initialized_decorators = [state()];
+    __esDecorate(_a, null, _wide_decorators, { kind: "accessor", name: "wide", static: false, private: false, access: { has: (obj) => "wide" in obj, get: (obj) => obj.wide, set: (obj, value) => {
+      obj.wide = value;
+    } }, metadata: _metadata }, _wide_initializers, _wide_extraInitializers);
+    __esDecorate(_a, 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(_a, null, _set_min_decorators, { kind: "setter", name: "min", static: false, private: false, access: { has: (obj) => "min" in obj, set: (obj, value) => {
+      obj.min = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _set_max_decorators, { kind: "setter", name: "max", static: false, private: false, access: { has: (obj) => "max" in obj, set: (obj, value) => {
+      obj.max = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _set_now_decorators, { kind: "setter", name: "now", static: false, private: false, access: { has: (obj) => "now" in obj, set: (obj, value) => {
+      obj.now = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _set_selected_decorators, { kind: "setter", name: "selected", static: false, private: false, access: { has: (obj) => "selected" in obj, set: (obj, value) => {
+      obj.selected = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, 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(_a, 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(_a, null, __selected_decorators, { kind: "accessor", name: "_selected", static: false, private: false, access: { has: (obj) => "_selected" in obj, get: (obj) => obj._selected, set: (obj, value) => {
+      obj._selected = value;
+    } }, metadata: _metadata }, __selected_initializers, __selected_extraInitializers);
+    __esDecorate(_a, null, _set__wide_decorators, { kind: "setter", name: "_wide", static: false, private: false, access: { has: (obj) => "_wide" in obj, set: (obj, value) => {
+      obj._wide = value;
+    } }, metadata: _metadata }, null, _instanceExtraInitializers);
+    __esDecorate(_a, 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(_a, 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);
+    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    SbbCalendarElement2 = _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = style, _a.events = {
+    dateSelected: "dateSelected"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a);
+  return SbbCalendarElement2 = _classThis;
+})();
 export {
   SbbCalendarElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"calendar.js","sources":["../../../src/elements/calendar/calendar.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  LitElement,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\nimport { classMap } from 'lit/directives/class-map.js';\n\nimport { isArrowKeyOrPageKeysPressed, sbbInputModalityDetector } from '../core/a11y.js';\nimport { readConfig } from '../core/config.js';\nimport { SbbConnectedAbortController, SbbLanguageController } from '../core/controllers.js';\nimport type { DateAdapter } from '../core/datetime.js';\nimport {\n  DAYS_PER_ROW,\n  defaultDateAdapter,\n  MONTHS_PER_ROW,\n  YEARS_PER_PAGE,\n  YEARS_PER_ROW,\n} from '../core/datetime.js';\nimport { isBreakpoint } from '../core/dom.js';\nimport { EventEmitter } from '../core/eventing.js';\nimport {\n  i18nCalendarDateSelection,\n  i18nNextMonth,\n  i18nNextYear,\n  i18nNextYearRange,\n  i18nPreviousMonth,\n  i18nPreviousYear,\n  i18nPreviousYearRange,\n  i18nYearMonthSelection,\n} from '../core/i18n.js';\nimport type { SbbDateLike } from '../core/interfaces.js';\nimport { SbbHydrationMixin } from '../core/mixins.js';\n\nimport style from './calendar.scss?lit&inline';\n\nimport '../button/secondary-button.js';\nimport '../icon.js';\nimport '../screen-reader-only.js';\n\n/**\n * In keyboard navigation, the cell's index and the element's index in its month / year batch must be distinguished;\n * this is necessary because the navigation in the vertical direction using some keys is restricted to a single month for days,\n * and to a single range of 24 years for years. While the latter is easy to understand, the cell's index is the index\n * of the element in the array of all the rendered cells. In non-wide mode, there's no issue because the element index\n * is basically the cell's index plus 1 (element with index 0 displays the 1st of month, element with index 1 displays the 2nd and so on).\n * In wide mode, the cell's index can go from 0 to 47 for years (two batches of 24 years), and from 0 to a maximum of 61 for days\n * (two consecutive months of 31 days, as July-August or December-January), depending on the lengths of the rendered months;\n * the element index instead goes from 0 to a max value of 24 for years and 31 for days.\n * Moreover, in day view, the index of the first day of the second rendered month and the index of the last rendered day\n * can also vary depending on which months are rendered; for July-August they are equals to 31 and 61, while for February-March they are 28 and 58.\n * So, some additional parameters are needed, beside the cell's index, to correctly calculate the element to navigate to.\n */\ninterface CalendarKeyboardNavigationParameters {\n  /** The element index within its month (or year 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 {\n  value: string;\n  dayValue: string;\n  monthValue: string;\n  yearValue: string;\n}\n\nexport interface Month {\n  value: string;\n  longValue: string;\n  monthValue: number;\n}\n\nexport interface Weekday {\n  long: string;\n  narrow: string;\n}\n\nexport type CalendarView = 'day' | 'month' | 'year';\n\n/**\n * It displays a calendar which allows to choose a date.\n *\n * @event {CustomEvent<T>} dateSelected - Event emitted on date selection.\n */\n@customElement('sbb-calendar')\nexport class SbbCalendarElement<T = Date> extends SbbHydrationMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    dateSelected: 'dateSelected',\n  } as const;\n\n  /** If set to true, two months are displayed */\n  @property({ type: Boolean }) public wide = false;\n\n  /** The initial view of the calendar which should be displayed on opening. */\n  @property() public view: CalendarView = 'day';\n\n  /** The minimum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set min(value: SbbDateLike<T> | null) {\n    this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get min(): T | null {\n    return this._min ?? null;\n  }\n  private _min?: T | null;\n\n  /** The maximum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set max(value: SbbDateLike<T> | undefined) {\n    this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get max(): T | null {\n    return this._max ?? null;\n  }\n  private _max?: T | null;\n\n  /** A configured date which acts as the current date instead of the real current date. Recommended for testing purposes. */\n  @property()\n  public set now(value: SbbDateLike<T> | undefined) {\n    this._now = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get now(): T {\n    return this._now ?? this._dateAdapter.today();\n  }\n  private _now: T | null = null;\n\n  /** The selected date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set selected(value: SbbDateLike<T> | undefined) {\n    this._selectedDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    if (\n      !!this._selectedDate &&\n      (!this._isDayInRange(this._dateAdapter.toIso8601(this._selectedDate)) ||\n        this._dateFilter(this._selectedDate))\n    ) {\n      this._selected = this._dateAdapter.toIso8601(this._selectedDate);\n    } else {\n      this._selected = undefined;\n    }\n  }\n  public get selected(): T | null {\n    return this._selectedDate ?? null;\n  }\n  private _selectedDate?: T | null;\n\n  /** A function used to filter out dates. */\n  @property({ attribute: 'date-filter' }) public dateFilter?: (date: T | null) => boolean;\n\n  private _dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n\n  /** Event emitted on date selection. */\n  private _dateSelected: EventEmitter<T> = new EventEmitter(\n    this,\n    SbbCalendarElement.events.dateSelected,\n  );\n\n  /** The currently active date. */\n  @state() private _activeDate: T = this.now;\n\n  /** The selected date as ISOString. */\n  @state() private _selected?: string;\n\n  /** The current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */\n  @state()\n  private set _wide(wide: boolean) {\n    this.toggleAttribute('data-wide', wide);\n  }\n  private get _wide(): boolean {\n    return this.hasAttribute('data-wide');\n  }\n\n  @state() private _calendarView: CalendarView = 'day';\n\n  private _nextCalendarView: CalendarView = '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[][] = [];\n\n  /** Grid of calendar cells representing months. */\n  private _months!: Month[][];\n\n  /** Grid of calendar cells representing years. */\n  private _years!: number[][];\n\n  /** Grid of calendar cells representing years for the wide view. */\n  private _nextMonthYears!: number[][];\n\n  /** Grid of calendar cells representing the dates of the next month. */\n  private _nextMonthWeeks!: Day[][];\n\n  /** An array containing all the month names in the current language. */\n  private _monthNames: string[] = this._dateAdapter.getMonthNames('long');\n\n  /** A list of buttons corresponding to days, months or years depending on the view. */\n  private get _cells(): HTMLButtonElement[] {\n    return Array.from(\n      this.shadowRoot!.querySelectorAll('.sbb-calendar__cell') ?? [],\n    ) as HTMLButtonElement[];\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  @state()\n  private _initialized = false;\n\n  private _abort = new SbbConnectedAbortController(this);\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\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.focus = () => {\n      this._resetFocus = true;\n      this._focusCell();\n    };\n    globalThis.window?.addEventListener('resize', () => this._init(), {\n      passive: true,\n      signal: this._abort.signal,\n    });\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (!this._initialized) {\n      return;\n    }\n\n    if (changedProperties.has('wide')) {\n      this.resetPosition();\n    }\n\n    if (changedProperties.has('view')) {\n      this._setChosenYear();\n      this._chosenMonth = undefined;\n      this._nextCalendarView = this._calendarView = this.view;\n    }\n  }\n\n  protected override updated(changedProperties: PropertyValues<this>): void {\n    super.updated(changedProperties);\n    // The calendar needs to calculate tab-indexes on first render,\n    // and every time a date is selected or the month view changes.\n    this._setTabIndex();\n    // When changing view to year/month, the tabindex is changed, but the focused element is not,\n    // so if the navigation is done via keyboard, there's the need\n    // to call the `_focusCell()` method explicitly to correctly set the focus.\n    if (sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n      this._focusCell();\n    }\n  }\n\n  /** Initializes the component. */\n  private _init(activeDate?: T): void {\n    //Due to its complexity, the caledar is only initialized on client side\n    if (isServer) {\n      return;\n    } else if (this.hydrationRequired) {\n      this.hydrationComplete.then(() => this._init());\n      return;\n    }\n\n    if (activeDate) {\n      this._assignActiveDate(activeDate);\n    }\n    this._wide = isBreakpoint('medium') && this.wide;\n    this._weeks = this._createWeekRows(this._activeDate);\n    this._years = this._createYearRows();\n    this._nextMonthWeeks = [[]];\n    this._nextMonthYears = [[]];\n    if (this._wide) {\n      const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);\n      this._nextMonthWeeks = this._createWeekRows(nextMonthDate);\n      this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);\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 for each week. */\n  private _createWeekRows(value: T): Day[][] {\n    const daysInMonth: number = this._dateAdapter.getNumDaysInMonth(value);\n    const dateNames: string[] = this._dateAdapter.getDateNames();\n    const weeks: Day[][] = [[]];\n    const weekOffset = this._dateAdapter.getFirstWeekOffset(value);\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({\n        value: this._dateAdapter.toIso8601(date),\n        dayValue: dateNames[i],\n        monthValue: String(this._dateAdapter.getMonth(date)),\n        yearValue: String(this._dateAdapter.getYear(date)),\n      });\n    }\n    return weeks;\n  }\n\n  /** Creates the rows for the month selection view. */\n  private _createMonthRows(): void {\n    const shortNames: string[] = this._dateAdapter.getMonthNames('short');\n    const months: Month[] = new Array(12).fill(null).map(\n      (_, i: number): Month => ({\n        value: shortNames[i],\n        longValue: this._monthNames[i],\n        monthValue: i + 1,\n      }),\n    );\n    const rows: number = 12 / MONTHS_PER_ROW;\n    const monthArray: Month[][] = [];\n    for (let i: number = 0; i < rows; i++) {\n      monthArray.push(months.slice(MONTHS_PER_ROW * i, MONTHS_PER_ROW * (i + 1)));\n    }\n    this._months = monthArray;\n  }\n\n  /** Creates the rows for the year selection view. */\n  private _createYearRows(offset: number = 0): number[][] {\n    const startValueYearView: number = this._getStartValueYearView();\n    const allYears: number[] = new Array(YEARS_PER_PAGE)\n      .fill(0)\n      .map((_, i: number) => startValueYearView + offset + i);\n    const rows: number = YEARS_PER_PAGE / YEARS_PER_ROW;\n    const yearArray: number[][] = [];\n    for (let i: number = 0; i < rows; i++) {\n      yearArray.push(allYears.slice(YEARS_PER_ROW * i, YEARS_PER_ROW * (i + 1)));\n    }\n    return yearArray;\n  }\n\n  /**\n   * Calculates the first year that will be shown in the year selection panel.\n   * If `minDate` and `maxDate` are both null, the starting year is calculated as\n   * the multiple of YEARS_PER_PAGE closest to and less than activeDate,\n   * e.g., with `YEARS_PER_PAGE` = 24 and `activeDate` = 2020, the function will return 2016 (24 * 83),\n   * while with `activeDate` = 2000, the function will return 1992 (24 * 82).\n   * If `minDate` is not null, it returns the corresponding year; if `maxDate` is not null,\n   * it returns the corresponding year minus `YEARS_PER_PAGE`, so that the `maxDate` is the last rendered year.\n   * If both are not null, `maxDate` has priority over `minDate`.\n   */\n  private _getStartValueYearView(): number {\n    let startingYear = 0;\n    if (this.max) {\n      startingYear = this._dateAdapter.getYear(this.max) - YEARS_PER_PAGE + 1;\n    } else if (this.min) {\n      startingYear = this._dateAdapter.getYear(this.min);\n    }\n    const activeYear = this._dateAdapter.getYear(this._activeDate);\n    return (\n      activeYear -\n      ((((activeYear - startingYear) % YEARS_PER_PAGE) + YEARS_PER_PAGE) % YEARS_PER_PAGE)\n    );\n  }\n\n  /** Checks if date is within the min-max range. */\n  private _isDayInRange(date: string): boolean {\n    if (!this._min && !this._max) {\n      return true;\n    }\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this._min) &&\n      this._dateAdapter.compareDate(this._min!, this._dateAdapter.deserialize(date)!) > 0;\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this._max) &&\n      this._dateAdapter.compareDate(this._max!, this._dateAdapter.deserialize(date)!) < 0;\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  private _isMonthInRange(month: number): boolean {\n    if (!this._min && !this._max) {\n      return true;\n    }\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this._min) &&\n      this._dateAdapter.getYear(this._min!) >= this._chosenYear! &&\n      this._dateAdapter.getMonth(this._min!) > month;\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this._max) &&\n      this._dateAdapter.getYear(this._max!) <= this._chosenYear! &&\n      this._dateAdapter.getMonth(this._max!) < month;\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  private _isYearInRange(year: number): boolean {\n    if (!this._min && !this._max) {\n      return true;\n    }\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this._min) && this._dateAdapter.getYear(this._min!) > year;\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this._max) && this._dateAdapter.getYear(this._max!) < year;\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/year-view.ts#L366\n  private _isMonthFilteredOut(month: number): boolean {\n    if (!this.dateFilter) {\n      return true;\n    }\n\n    const firstOfMonth = this._dateAdapter.createDate(this._chosenYear!, month, 1)!;\n    for (\n      let date: T = firstOfMonth;\n      this._dateAdapter.getMonth(date) == month;\n      date = this._dateAdapter.addCalendarDays(date, 1)\n    ) {\n      if (this.dateFilter(date)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/multi-year-view.ts#L351\n  private _isYearFilteredOut(year: number): boolean {\n    if (!this.dateFilter) {\n      return true;\n    }\n\n    const firstOfYear = this._dateAdapter.createDate(year, 1, 1)!;\n    for (\n      let date: T = firstOfYear;\n      this._dateAdapter.getYear(date) == year;\n      date = this._dateAdapter.addCalendarDays(date, 1)\n    ) {\n      if (this.dateFilter(date)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /** Emits the selected date and sets it internally. */\n  private _selectDate(day: string): void {\n    this._chosenMonth = undefined;\n    this._setChosenYear();\n    if (this._selected !== day) {\n      this._selected = day;\n      this._dateSelected.emit(this._dateAdapter.deserialize(day)!);\n    }\n  }\n\n  private _setChosenYear(): void {\n    if (this.view === 'month') {\n      this._chosenYear = this._dateAdapter.getYear(\n        this._dateAdapter.deserialize(this._selected) ?? this.selected ?? this.now,\n      );\n    } else {\n      this._chosenYear = undefined;\n    }\n  }\n\n  private _assignActiveDate(date: T): void {\n    if (this._min && this._dateAdapter.compareDate(this._min, date) > 0) {\n      this._activeDate = this._min;\n      return;\n    }\n    if (this._max && this._dateAdapter.compareDate(this._max, date) < 0) {\n      this._activeDate = this._max;\n      return;\n    }\n    this._activeDate = date;\n  }\n\n  /** Goes to the month identified by the shift. */\n  private _goToDifferentMonth(months: number): void {\n    this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));\n  }\n\n  private _goToDifferentYear(years: number): void {\n    this._chosenYear! += years;\n    // Can't use `_assignActiveDate(...)` here, because it will set it to min/max value if argument is out of range\n    this._activeDate = this._dateAdapter.createDate(\n      this._chosenYear!,\n      this._dateAdapter.getMonth(this._activeDate),\n      this._dateAdapter.getDate(this._activeDate),\n    );\n    this._init();\n  }\n\n  private _goToDifferentYearRange(years: number): void {\n    this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));\n  }\n\n  private _prevDisabled(prevDate: T): boolean {\n    if (!this._min) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(prevDate, this._min) < 0;\n  }\n\n  private _nextDisabled(nextDate: T): boolean {\n    if (!this._max) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(nextDate, this._max) > 0;\n  }\n\n  /** Checks if the \"previous month\" button should be disabled. */\n  private _previousMonthDisabled(): boolean {\n    const prevMonth = this._dateAdapter.addCalendarDays(\n      this._activeDate,\n      this._dateAdapter.getDate(this._activeDate) * -1,\n    );\n    return this._prevDisabled(prevMonth);\n  }\n\n  /** Checks if the \"next month\" button should be disabled. */\n  private _nextMonthDisabled(): boolean {\n    let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);\n    nextMonth = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(nextMonth),\n      this._dateAdapter.getMonth(nextMonth),\n      1,\n    );\n    return this._nextDisabled(nextMonth);\n  }\n\n  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  private _nextYearDisabled(): boolean {\n    const nextYear = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(this._activeDate) + 1,\n      1,\n      1,\n    );\n    return this._nextDisabled(nextYear);\n  }\n\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  private _nextYearRangeDisabled(): boolean {\n    const years = isBreakpoint('medium') && this.wide ? this._nextMonthYears : this._years;\n    const lastYearRange = years[years.length - 1];\n    const lastYear = lastYearRange[lastYearRange.length - 1];\n    const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);\n    return this._nextDisabled(nextYear);\n  }\n\n  private _handleTableBlur(eventTarget: HTMLElement): void {\n    if (eventTarget?.localName !== 'button') {\n      this._setTabIndex();\n    }\n  }\n\n  private _setTabIndex(): void {\n    Array.from(\n      this.shadowRoot!.querySelectorAll('.sbb-calendar__cell[tabindex=\"0\"]') ?? [],\n    ).forEach((day) => ((day as HTMLElement).tabIndex = -1));\n    const firstFocusable = this._getFirstFocusable();\n    if (firstFocusable) {\n      firstFocusable.tabIndex = 0;\n    }\n  }\n\n  private _getFirstFocusable(): HTMLButtonElement {\n    const active = this._selected ? this._dateAdapter.deserialize(this._selected)! : this.now;\n    let firstFocusable =\n      this.shadowRoot!.querySelector('.sbb-calendar__selected') ??\n      this.shadowRoot!.querySelector(\n        `[data-day=\"${this._dateAdapter.getDate(active)} ${this._dateAdapter.getMonth(\n          active,\n        )} ${this._dateAdapter.getYear(active)}\"]`,\n      ) ??\n      this.shadowRoot!.querySelector(`[data-month=\"${this._dateAdapter.getMonth(active)}\"]`) ??\n      this.shadowRoot!.querySelector(`[data-year=\"${this._dateAdapter.getYear(active)}\"]`);\n    if (!firstFocusable || (firstFocusable as HTMLButtonElement)?.disabled) {\n      firstFocusable = this.shadowRoot!.querySelector('.sbb-calendar__cell:not([disabled])');\n    }\n    return (firstFocusable as HTMLButtonElement) || null;\n  }\n\n  private _handleKeyboardEvent(event: KeyboardEvent, day?: Day): void {\n    if (isArrowKeyOrPageKeysPressed(event)) {\n      event.preventDefault();\n    }\n    // Gets the currently rendered table's cell;\n    // they could be days, months or years based on the current selection view.\n    // If `wide` is true, years are doubled in number and days are (roughly) doubled too, affecting the `index` calculation.\n    const cells: HTMLButtonElement[] = this._cells;\n    const index: number = cells.findIndex((e: HTMLButtonElement) => e === event.target);\n    const nextEl: HTMLButtonElement = this._navigateByKeyboard(event, index, cells, day);\n    const activeEl: HTMLButtonElement = this.shadowRoot!.activeElement as HTMLButtonElement;\n    if (nextEl !== activeEl) {\n      (nextEl as HTMLButtonElement).tabIndex = 0;\n      nextEl?.focus();\n      (activeEl as HTMLButtonElement).tabIndex = -1;\n    }\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: HTMLButtonElement[],\n    day?: Day,\n  ): HTMLButtonElement {\n    const {\n      elementIndexForWideMode,\n      offsetForWideMode,\n      lastElementIndexForWideMode,\n      verticalOffset,\n    }: CalendarKeyboardNavigationParameters = this._calculateParametersForKeyboardNavigation(\n      cells,\n      index,\n      day,\n    );\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 parameter needed in keyboard navigation.\n   * Since three views are now available, the function creates and returns the correct parameters for each of them\n   * by considering the number of cells per each row and the correction for the wide mode.\n   * @param cells The array of rendered table cells; they are buttons that can represent days, months or years.\n   * @param index The starting element's index in the cell array.\n   * @param day (optional) Only in the day view, the day represented by the starting cell.\n   */\n  private _calculateParametersForKeyboardNavigation(\n    cells: HTMLButtonElement[],\n    index: number,\n    day?: Day,\n  ): CalendarKeyboardNavigationParameters {\n    switch (this._calendarView) {\n      case 'day': {\n        const indexInView = +day!.dayValue - 1;\n        return {\n          verticalOffset: DAYS_PER_ROW,\n          elementIndexForWideMode: indexInView,\n          offsetForWideMode: index - indexInView,\n          lastElementIndexForWideMode:\n            index === indexInView\n              ? this._dateAdapter.getNumDaysInMonth(\n                  this._dateAdapter.addCalendarMonths(\n                    this._dateAdapter.deserialize(day!.value)!,\n                    -1,\n                  ),\n                )\n              : cells.length,\n        };\n      }\n      // Month view is not dependent from `wide` value, so some parameters are fixed.\n      case 'month': {\n        return {\n          verticalOffset: MONTHS_PER_ROW,\n          elementIndexForWideMode: index,\n          offsetForWideMode: 0,\n          lastElementIndexForWideMode: 12,\n        };\n      }\n      case 'year': {\n        const offset: number = Math.trunc(index / YEARS_PER_PAGE) * YEARS_PER_PAGE;\n        const indexInView: number = offset === 0 ? index : index - YEARS_PER_PAGE;\n        return {\n          verticalOffset: YEARS_PER_ROW,\n          elementIndexForWideMode: indexInView,\n          offsetForWideMode: index - indexInView,\n          lastElementIndexForWideMode: offset === 0 ? YEARS_PER_PAGE : YEARS_PER_PAGE * 2,\n        };\n      }\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(days: HTMLButtonElement[], index: number, delta: number): HTMLButtonElement {\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(days: HTMLButtonElement[], firstOfCurrentMonth: number): HTMLButtonElement {\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(days: HTMLButtonElement[], lastOfCurrentMonth: number): HTMLButtonElement {\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: HTMLButtonElement[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): HTMLButtonElement {\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: HTMLButtonElement[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): HTMLButtonElement {\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 _resetCalendarView(initTransition = false): void {\n    this._resetFocus = true;\n    this._activeDate = this.selected ?? this.now;\n    this._setChosenYear();\n    this._chosenMonth = undefined;\n    this._nextCalendarView = this._calendarView = this.view;\n\n    if (initTransition) {\n      this._startTableTransition();\n    }\n  }\n\n  /** Render the view for the day selection. */\n  private _renderDayView(): TemplateResult {\n    const nextMonthActiveDate = this._wide\n      ? this._dateAdapter.addCalendarMonths(this._activeDate, 1)\n      : undefined;\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentMonth(-1),\n          i18nPreviousMonth[this._language.current],\n          this._previousMonthDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">\n          ${this._createLabelForDayView(this._activeDate)}\n          ${this._wide ? this._createLabelForDayView(nextMonthActiveDate!) : nothing}\n          <sbb-screen-reader-only role=\"status\">\n            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate!)}\n          </sbb-screen-reader-only>\n        </div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentMonth(1),\n          i18nNextMonth[this._language.current],\n          this._nextMonthDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-day-view\">\n        ${this._createDayTable(this._weeks)}\n        ${this._wide ? this._createDayTable(this._nextMonthWeeks) : nothing}\n      </div>\n    `;\n  }\n\n  /** Creates the label with the month for the daily view. */\n  private _createLabelForDayView(d: T): TemplateResult {\n    const monthLabel = `${\n      this._monthNames[this._dateAdapter.getMonth(d) - 1]\n    } ${this._dateAdapter.getYear(d)}`;\n    return html`\n      <button\n        type=\"button\"\n        id=\"sbb-calendar__date-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nYearMonthSelection[this._language.current]} ${monthLabel}\"\n        @click=${() => {\n          this._resetFocus = true;\n          this._nextCalendarView = 'year';\n          this._startTableTransition();\n        }}\n      >\n        ${monthLabel}\n        <sbb-icon name=\"chevron-small-down-small\"></sbb-icon>\n      </button>\n    `;\n  }\n\n  /** Creates the aria-label for the daily view. */\n  private _createAriaLabelForDayView(...dates: T[]): string {\n    let monthLabel = '';\n    for (const d of dates) {\n      if (d) {\n        monthLabel += `${\n          this._monthNames[this._dateAdapter.getMonth(d) - 1]\n        } ${this._dateAdapter.getYear(d)} `;\n      }\n    }\n    return monthLabel;\n  }\n\n  /** Creates the calendar table for the daily view. */\n  private _createDayTable(weeks: Day[][]): TemplateResult {\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @focusout=${(event: FocusEvent) =>\n          this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        <thead class=\"sbb-calendar__table-header\">\n          <tr class=\"sbb-calendar__table-header-row\">\n            ${this._createDayTableHeader()}\n          </tr>\n        </thead>\n        <tbody class=\"sbb-calendar__table-body\">\n          ${this._createDayTableBody(weeks)}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Creates the table header with the month header cells. */\n  private _createDayTableHeader(): TemplateResult[] {\n    return this._weekdays.map(\n      (day: Weekday) => html`\n        <th class=\"sbb-calendar__table-header\">\n          <sbb-screen-reader-only>${day.long}</sbb-screen-reader-only>\n          <span aria-hidden=\"true\">${day.narrow}</span>\n        </th>\n      `,\n    );\n  }\n\n  /** Creates the table body with the day cells. For the first row, it also considers the possible day's offset. */\n  private _createDayTableBody(weeks: Day[][]): TemplateResult[] {\n    const today: string = this._dateAdapter.toIso8601(this.now);\n    return weeks.map((week: Day[], rowIndex: number) => {\n      const firstRowOffset: number = DAYS_PER_ROW - week.length;\n      if (rowIndex === 0 && firstRowOffset) {\n        return html`\n          <tr>\n            ${[...Array(firstRowOffset).keys()].map(\n              () =>\n                html`<td\n                  class=\"sbb-calendar__table-data\"\n                  data-day=${`0 ${week[0].monthValue} ${week[0].yearValue}`}\n                ></td>`,\n            )}\n            ${this._createDayCells(week, today)}\n          </tr>\n        `;\n      }\n      return html`<tr>\n        ${this._createDayCells(week, today)}\n      </tr>`;\n    });\n  }\n\n  /** Creates the cells for the daily view. */\n  private _createDayCells(week: Day[], today: string): TemplateResult[] {\n    return week.map((day: Day) => {\n      const isOutOfRange = !this._isDayInRange(day.value);\n      const isFilteredOut = !this._dateFilter(this._dateAdapter.deserialize(day.value)!);\n      const selected: boolean = !!this._selected && day.value === this._selected;\n      const dayValue = `${day.dayValue} ${day.monthValue} ${day.yearValue}`;\n      const isToday = day.value === today;\n      return html`\n        <td\n          class=${classMap({\n            'sbb-calendar__table-data': true,\n            'sbb-calendar__table-data-selected': selected,\n          })}\n        >\n          <button\n            class=${classMap({\n              'sbb-calendar__cell': true,\n              'sbb-calendar__day': true,\n              'sbb-calendar__cell-current': isToday,\n              'sbb-calendar__selected': selected,\n              'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n            })}\n            @click=${() => this._selectDate(day.value)}\n            ?disabled=${isOutOfRange || isFilteredOut}\n            aria-label=${this._dateAdapter.getAccessibilityFormatDate(day.value)}\n            aria-pressed=${selected}\n            aria-disabled=${isOutOfRange || isFilteredOut}\n            aria-current=${isToday ? 'date' : nothing}\n            data-day=${dayValue || nothing}\n            tabindex=\"-1\"\n            @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt, day)}\n            sbb-popover-close\n          >\n            ${day.dayValue}\n          </button>\n        </td>\n      `;\n    });\n  }\n\n  /** Render the view for the month selection. */\n  private _renderMonthView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYear(-1),\n          i18nPreviousYear[this._language.current],\n          this._previousYearDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForMonthView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYear(1),\n          i18nNextYear[this._language.current],\n          this._nextYearDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-month-view\">\n        ${this._createMonthTable(this._months, this._chosenYear!)}\n        ${this._wide ? this._createMonthTable(this._months, this._chosenYear! + 1, true) : nothing}\n      </div>\n    `;\n  }\n\n  /** Creates the label with the year for the monthly view. */\n  private _createLabelForMonthView(): TemplateResult {\n    return html` <button\n        type=\"button\"\n        id=\"sbb-calendar__month-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=${`${i18nCalendarDateSelection[this._language.current]} ${this._chosenYear}`}\n        @click=${() => this._resetCalendarView(true)}\n      >\n        ${this._chosenYear} ${this._wide ? ` - ${this._chosenYear! + 1}` : nothing}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${this._chosenYear} </sbb-screen-reader-only>`;\n  }\n\n  /** Creates the table for the month selection view. */\n  private _createMonthTable(months: Month[][], year: number, shiftRight = false): TemplateResult {\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        ${this._wide\n          ? html`<thead class=\"sbb-calendar__table-header\" aria-hidden=\"true\">\n              <tr class=\"sbb-calendar__table-header-row\">\n                <th class=\"sbb-calendar__table-header\" colspan=${MONTHS_PER_ROW}>${year}</th>\n              </tr>\n            </thead>`\n          : nothing}\n        <tbody class=\"sbb-calendar__table-body\">\n          ${months.map(\n            (row: Month[]) => html`\n              <tr>\n                ${row.map((month: Month) => {\n                  const isOutOfRange = !this._isMonthInRange(month.monthValue);\n                  const isFilteredOut = !this._isMonthFilteredOut(month.monthValue);\n                  const selectedMonth = this._selected\n                    ? this._dateAdapter.getMonth(this._dateAdapter.deserialize(this._selected)!)\n                    : undefined;\n                  const selectedYear = this._selected\n                    ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)!)\n                    : undefined;\n                  const selected: boolean =\n                    !!this._selected && year === selectedYear && month.monthValue === selectedMonth;\n\n                  const isCurrentMonth =\n                    year === this._dateAdapter.getYear(this.now) &&\n                    this._dateAdapter.getMonth(this.now) === month.monthValue;\n\n                  return html` <td\n                    class=${classMap({\n                      'sbb-calendar__table-data': true,\n                      'sbb-calendar__table-month': true,\n                    })}\n                  >\n                    <button\n                      class=${classMap({\n                        'sbb-calendar__cell': true,\n                        'sbb-calendar__pill': true,\n                        'sbb-calendar__cell-current': isCurrentMonth,\n                        'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n                        'sbb-calendar__selected': selected,\n                      })}\n                      @click=${() => this._onMonthSelection(month.monthValue, year, shiftRight)}\n                      ?disabled=${isOutOfRange || isFilteredOut}\n                      aria-label=${`${month.longValue} ${this._chosenYear}`}\n                      aria-pressed=${selected}\n                      aria-disabled=${String(isOutOfRange || isFilteredOut)}\n                      tabindex=\"-1\"\n                      data-month=${month.monthValue || nothing}\n                      @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt)}\n                    >\n                      ${month.value}\n                    </button>\n                  </td>`;\n                })}\n              </tr>\n            `,\n          )}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Select the month and change the view to day selection. */\n  private _onMonthSelection(month: number, year: number, shiftRight: boolean): void {\n    this._chosenMonth = shiftRight ? month + 1 : month;\n    this._nextCalendarView = 'day';\n    this._init(\n      this._dateAdapter.createDate(\n        year,\n        this._chosenMonth,\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._startTableTransition();\n  }\n\n  /** Render the view for the year selection. */\n  private _renderYearView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYearRange(-YEARS_PER_PAGE),\n          i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._previousYearRangeDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForYearView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYearRange(YEARS_PER_PAGE),\n          i18nNextYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._nextYearRangeDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-year-view\">\n        ${this._createYearTable(this._years)}\n        ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}\n      </div>\n    `;\n  }\n\n  /** Creates the button arrow for all the views. */\n  private _getArrow(\n    direction: 'left' | 'right',\n    click: () => void,\n    ariaLabel: string,\n    disabled: boolean,\n  ): TemplateResult {\n    return html`<sbb-secondary-button\n      size=\"m\"\n      icon-name=\"chevron-small-${direction}-small\"\n      aria-label=${ariaLabel}\n      @click=${click}\n      ?disabled=${disabled}\n      id=\"sbb-calendar__controls-${direction === 'left' ? 'previous' : 'next'}\"\n    ></sbb-secondary-button>`;\n  }\n\n  /** Creates the label with the year range for the yearly view. */\n  private _createLabelForYearView(): TemplateResult {\n    const firstYear: number = this._years.flat()[0];\n    const lastYearArray: number[] = (\n      isBreakpoint('medium') && this.wide ? this._nextMonthYears : this._years\n    ).flat();\n    const lastYear: number = lastYearArray[lastYearArray.length - 1];\n    const yearLabel = `${firstYear} - ${lastYear}`;\n    return html`\n      <button\n        type=\"button\"\n        id=\"sbb-calendar__year-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nCalendarDateSelection[this._language.current]} ${yearLabel}\"\n        @click=${() => this._resetCalendarView(true)}\n      >\n        ${yearLabel}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${yearLabel} </sbb-screen-reader-only>\n    `;\n  }\n\n  /** Creates the table for the year selection view. */\n  private _createYearTable(years: number[][], shiftRight = false): TemplateResult {\n    const now = this.now;\n    return html` <table\n      class=\"sbb-calendar__table\"\n      @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n    >\n      <tbody class=\"sbb-calendar__table-body\">\n        ${years.map(\n          (row: number[]) =>\n            html` <tr>\n              ${row.map((year: number) => {\n                const isOutOfRange = !this._isYearInRange(year);\n                const isFilteredOut = !this._isYearFilteredOut(year);\n                const selectedYear = this._selected\n                  ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)!)\n                  : undefined;\n                const selected: boolean = !!this._selected && year === selectedYear;\n                const isCurrentYear = this._dateAdapter.getYear(now) === year;\n                return html` <td class=\"sbb-calendar__table-data sbb-calendar__table-year\">\n                  <button\n                    class=${classMap({\n                      'sbb-calendar__cell': true,\n                      'sbb-calendar__pill': true,\n                      'sbb-calendar__cell-current': isCurrentYear,\n                      'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n                      'sbb-calendar__selected': selected,\n                    })}\n                    @click=${() => this._onYearSelection(year, shiftRight)}\n                    ?disabled=${isOutOfRange || isFilteredOut}\n                    aria-label=${year}\n                    aria-pressed=${selected}\n                    aria-disabled=${String(isOutOfRange || isFilteredOut)}\n                    tabindex=\"-1\"\n                    data-year=${year || nothing}\n                    @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt)}\n                  >\n                    ${year}\n                  </button>\n                </td>`;\n              })}\n            </tr>`,\n        )}\n      </tbody>\n    </table>`;\n  }\n\n  /** Select the year and change the view to month selection. */\n  private _onYearSelection(year: number, rightSide: boolean): void {\n    this._chosenYear = rightSide ? year - 1 : year;\n    this._nextCalendarView = 'month';\n    this._assignActiveDate(\n      this._dateAdapter.createDate(\n        this._chosenYear,\n        this._dateAdapter.getMonth(this._activeDate),\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._startTableTransition();\n  }\n\n  private _getView(): TemplateResult {\n    if (isServer || this.hydrationRequired) {\n      // TODO: We disable SSR for calendar for now. Figure our, if there is a way\n      // to enable it, while considering i18n and date information.\n      return html`${nothing}`;\n    }\n    switch (this._calendarView) {\n      case 'year':\n        return this._renderYearView();\n      case 'month':\n        return this._renderMonthView();\n      case 'day':\n      default:\n        return this._renderDayView();\n    }\n  }\n\n  private _tableAnimationEnd(event: AnimationEvent): void {\n    const table = event.target as HTMLElement;\n    if (event.animationName === 'hide') {\n      table.classList.remove('sbb-calendar__table-hide');\n      this._resetFocus = true;\n      this._calendarView = this._nextCalendarView;\n    } else if (event.animationName === 'show') {\n      this.removeAttribute('data-transition');\n    }\n  }\n\n  private _startTableTransition(): void {\n    this.toggleAttribute('data-transition', true);\n    this.shadowRoot\n      ?.querySelectorAll('table')\n      ?.forEach((e) => e.classList.toggle('sbb-calendar__table-hide'));\n  }\n\n  protected override render(): TemplateResult {\n    return html`<div class=\"sbb-calendar__wrapper\">${this._getView()}</div>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-calendar': SbbCalendarElement;\n  }\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"calendar.js","sources":["../../../src/elements/calendar/calendar.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  LitElement,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\nimport { classMap } from 'lit/directives/class-map.js';\n\nimport { isArrowKeyOrPageKeysPressed, sbbInputModalityDetector } from '../core/a11y.js';\nimport { readConfig } from '../core/config.js';\nimport { SbbConnectedAbortController, SbbLanguageController } from '../core/controllers.js';\nimport type { DateAdapter } from '../core/datetime.js';\nimport {\n  DAYS_PER_ROW,\n  defaultDateAdapter,\n  MONTHS_PER_ROW,\n  YEARS_PER_PAGE,\n  YEARS_PER_ROW,\n} from '../core/datetime.js';\nimport { forceType } from '../core/decorators.js';\nimport { isBreakpoint } from '../core/dom.js';\nimport { EventEmitter } from '../core/eventing.js';\nimport {\n  i18nCalendarDateSelection,\n  i18nNextMonth,\n  i18nNextYear,\n  i18nNextYearRange,\n  i18nPreviousMonth,\n  i18nPreviousYear,\n  i18nPreviousYearRange,\n  i18nYearMonthSelection,\n} from '../core/i18n.js';\nimport type { SbbDateLike } from '../core/interfaces.js';\nimport { SbbHydrationMixin } from '../core/mixins.js';\n\nimport style from './calendar.scss?lit&inline';\n\nimport '../button/secondary-button.js';\nimport '../icon.js';\nimport '../screen-reader-only.js';\n\n/**\n * In keyboard navigation, the cell's index and the element's index in its month / year batch must be distinguished;\n * this is necessary because the navigation in the vertical direction using some keys is restricted to a single month for days,\n * and to a single range of 24 years for years. While the latter is easy to understand, the cell's index is the index\n * of the element in the array of all the rendered cells. In non-wide mode, there's no issue because the element index\n * is basically the cell's index plus 1 (element with index 0 displays the 1st of month, element with index 1 displays the 2nd and so on).\n * In wide mode, the cell's index can go from 0 to 47 for years (two batches of 24 years), and from 0 to a maximum of 61 for days\n * (two consecutive months of 31 days, as July-August or December-January), depending on the lengths of the rendered months;\n * the element index instead goes from 0 to a max value of 24 for years and 31 for days.\n * Moreover, in day view, the index of the first day of the second rendered month and the index of the last rendered day\n * can also vary depending on which months are rendered; for July-August they are equals to 31 and 61, while for February-March they are 28 and 58.\n * So, some additional parameters are needed, beside the cell's index, to correctly calculate the element to navigate to.\n */\ninterface CalendarKeyboardNavigationParameters {\n  /** The element index within its month (or year 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 {\n  value: string;\n  dayValue: string;\n  monthValue: string;\n  yearValue: string;\n}\n\nexport interface Month {\n  value: string;\n  longValue: string;\n  monthValue: number;\n}\n\nexport interface Weekday {\n  long: string;\n  narrow: string;\n}\n\nexport type CalendarView = 'day' | 'month' | 'year';\n\n/**\n * It displays a calendar which allows to choose a date.\n *\n * @event {CustomEvent<T>} dateSelected - Event emitted on date selection.\n */\nexport\n@customElement('sbb-calendar')\nclass SbbCalendarElement<T = Date> extends SbbHydrationMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    dateSelected: 'dateSelected',\n  } as const;\n\n  /** If set to true, two months are displayed */\n  @forceType()\n  @property({ type: Boolean })\n  public accessor wide: boolean = false;\n\n  /** The initial view of the calendar which should be displayed on opening. */\n  @property() public accessor view: CalendarView = 'day';\n\n  /** The minimum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set min(value: SbbDateLike<T> | null) {\n    this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get min(): T | null {\n    return this._min ?? null;\n  }\n  private _min?: T | null;\n\n  /** The maximum valid date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set max(value: SbbDateLike<T> | undefined) {\n    this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get max(): T | null {\n    return this._max ?? null;\n  }\n  private _max?: T | null;\n\n  /** A configured date which acts as the current date instead of the real current date. Recommended for testing purposes. */\n  @property()\n  public set now(value: SbbDateLike<T> | undefined) {\n    this._now = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get now(): T {\n    return this._now ?? this._dateAdapter.today();\n  }\n  private _now: T | null = null;\n\n  /** The selected date. Takes T Object, ISOString, and Unix Timestamp (number of seconds since Jan 1, 1970). */\n  @property()\n  public set selected(value: SbbDateLike<T> | undefined) {\n    this._selectedDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    if (\n      !!this._selectedDate &&\n      (!this._isDayInRange(this._dateAdapter.toIso8601(this._selectedDate)) ||\n        this._dateFilter(this._selectedDate))\n    ) {\n      this._selected = this._dateAdapter.toIso8601(this._selectedDate);\n    } else {\n      this._selected = undefined;\n    }\n  }\n  public get selected(): T | null {\n    return this._selectedDate ?? null;\n  }\n  private _selectedDate?: T | null;\n\n  /** A function used to filter out dates. */\n  @property({ attribute: 'date-filter' }) public accessor dateFilter:\n    | ((date: T | null) => boolean)\n    | null = null;\n\n  private _dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n\n  /** Event emitted on date selection. */\n  private _dateSelected: EventEmitter<T> = new EventEmitter(\n    this,\n    SbbCalendarElement.events.dateSelected,\n  );\n\n  /** The currently active date. */\n  @state() private accessor _activeDate: T = this.now;\n\n  /** The selected date as ISOString. */\n  @state() private accessor _selected: string | undefined;\n\n  /** The current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */\n  @state()\n  private set _wide(wide: boolean) {\n    this.toggleAttribute('data-wide', wide);\n  }\n  private get _wide(): boolean {\n    return this.hasAttribute('data-wide');\n  }\n\n  @state() private accessor _calendarView: CalendarView = 'day';\n\n  private _nextCalendarView: CalendarView = '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[][] = [];\n\n  /** Grid of calendar cells representing months. */\n  private _months!: Month[][];\n\n  /** Grid of calendar cells representing years. */\n  private _years!: number[][];\n\n  /** Grid of calendar cells representing years for the wide view. */\n  private _nextMonthYears!: number[][];\n\n  /** Grid of calendar cells representing the dates of the next month. */\n  private _nextMonthWeeks!: Day[][];\n\n  /** An array containing all the month names in the current language. */\n  private _monthNames: string[] = this._dateAdapter.getMonthNames('long');\n\n  /** A list of buttons corresponding to days, months or years depending on the view. */\n  private get _cells(): HTMLButtonElement[] {\n    return Array.from(\n      this.shadowRoot!.querySelectorAll('.sbb-calendar__cell') ?? [],\n    ) as HTMLButtonElement[];\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  @state()\n  private accessor _initialized = false;\n\n  private _abort = new SbbConnectedAbortController(this);\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\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.focus = () => {\n      this._resetFocus = true;\n      this._focusCell();\n    };\n    globalThis.window?.addEventListener('resize', () => this._init(), {\n      passive: true,\n      signal: this._abort.signal,\n    });\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (!this._initialized) {\n      return;\n    }\n\n    if (changedProperties.has('wide')) {\n      this.resetPosition();\n    }\n\n    if (changedProperties.has('view')) {\n      this._setChosenYear();\n      this._chosenMonth = undefined;\n      this._nextCalendarView = this._calendarView = this.view;\n    }\n  }\n\n  protected override updated(changedProperties: PropertyValues<this>): void {\n    super.updated(changedProperties);\n    // The calendar needs to calculate tab-indexes on first render,\n    // and every time a date is selected or the month view changes.\n    this._setTabIndex();\n    // When changing view to year/month, the tabindex is changed, but the focused element is not,\n    // so if the navigation is done via keyboard, there's the need\n    // to call the `_focusCell()` method explicitly to correctly set the focus.\n    if (sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n      this._focusCell();\n    }\n  }\n\n  /** Initializes the component. */\n  private _init(activeDate?: T): void {\n    //Due to its complexity, the caledar is only initialized on client side\n    if (isServer) {\n      return;\n    } else if (this.hydrationRequired) {\n      this.hydrationComplete.then(() => this._init());\n      return;\n    }\n\n    if (activeDate) {\n      this._assignActiveDate(activeDate);\n    }\n    this._wide = isBreakpoint('medium') && this.wide;\n    this._weeks = this._createWeekRows(this._activeDate);\n    this._years = this._createYearRows();\n    this._nextMonthWeeks = [[]];\n    this._nextMonthYears = [[]];\n    if (this._wide) {\n      const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);\n      this._nextMonthWeeks = this._createWeekRows(nextMonthDate);\n      this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);\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 for each week. */\n  private _createWeekRows(value: T): Day[][] {\n    const daysInMonth: number = this._dateAdapter.getNumDaysInMonth(value);\n    const dateNames: string[] = this._dateAdapter.getDateNames();\n    const weeks: Day[][] = [[]];\n    const weekOffset = this._dateAdapter.getFirstWeekOffset(value);\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({\n        value: this._dateAdapter.toIso8601(date),\n        dayValue: dateNames[i],\n        monthValue: String(this._dateAdapter.getMonth(date)),\n        yearValue: String(this._dateAdapter.getYear(date)),\n      });\n    }\n    return weeks;\n  }\n\n  /** Creates the rows for the month selection view. */\n  private _createMonthRows(): void {\n    const shortNames: string[] = this._dateAdapter.getMonthNames('short');\n    const months: Month[] = new Array(12).fill(null).map(\n      (_, i: number): Month => ({\n        value: shortNames[i],\n        longValue: this._monthNames[i],\n        monthValue: i + 1,\n      }),\n    );\n    const rows: number = 12 / MONTHS_PER_ROW;\n    const monthArray: Month[][] = [];\n    for (let i: number = 0; i < rows; i++) {\n      monthArray.push(months.slice(MONTHS_PER_ROW * i, MONTHS_PER_ROW * (i + 1)));\n    }\n    this._months = monthArray;\n  }\n\n  /** Creates the rows for the year selection view. */\n  private _createYearRows(offset: number = 0): number[][] {\n    const startValueYearView: number = this._getStartValueYearView();\n    const allYears: number[] = new Array(YEARS_PER_PAGE)\n      .fill(0)\n      .map((_, i: number) => startValueYearView + offset + i);\n    const rows: number = YEARS_PER_PAGE / YEARS_PER_ROW;\n    const yearArray: number[][] = [];\n    for (let i: number = 0; i < rows; i++) {\n      yearArray.push(allYears.slice(YEARS_PER_ROW * i, YEARS_PER_ROW * (i + 1)));\n    }\n    return yearArray;\n  }\n\n  /**\n   * Calculates the first year that will be shown in the year selection panel.\n   * If `minDate` and `maxDate` are both null, the starting year is calculated as\n   * the multiple of YEARS_PER_PAGE closest to and less than activeDate,\n   * e.g., with `YEARS_PER_PAGE` = 24 and `activeDate` = 2020, the function will return 2016 (24 * 83),\n   * while with `activeDate` = 2000, the function will return 1992 (24 * 82).\n   * If `minDate` is not null, it returns the corresponding year; if `maxDate` is not null,\n   * it returns the corresponding year minus `YEARS_PER_PAGE`, so that the `maxDate` is the last rendered year.\n   * If both are not null, `maxDate` has priority over `minDate`.\n   */\n  private _getStartValueYearView(): number {\n    let startingYear = 0;\n    if (this.max) {\n      startingYear = this._dateAdapter.getYear(this.max) - YEARS_PER_PAGE + 1;\n    } else if (this.min) {\n      startingYear = this._dateAdapter.getYear(this.min);\n    }\n    const activeYear = this._dateAdapter.getYear(this._activeDate);\n    return (\n      activeYear -\n      ((((activeYear - startingYear) % YEARS_PER_PAGE) + YEARS_PER_PAGE) % YEARS_PER_PAGE)\n    );\n  }\n\n  /** Checks if date is within the min-max range. */\n  private _isDayInRange(date: string): boolean {\n    if (!this.min && !this.max) {\n      return true;\n    }\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this.min) &&\n      this._dateAdapter.compareDate(this.min!, this._dateAdapter.deserialize(date)!) > 0;\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this.max) &&\n      this._dateAdapter.compareDate(this.max!, this._dateAdapter.deserialize(date)!) < 0;\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  private _isMonthInRange(month: number, year: number): boolean {\n    if (!this.min && !this.max) {\n      return true;\n    }\n\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this.min) &&\n      (year < this._dateAdapter.getYear(this.min!) ||\n        (year === this._dateAdapter.getYear(this.min!) &&\n          month < this._dateAdapter.getMonth(this.min!)));\n\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this.max) &&\n      (year > this._dateAdapter.getYear(this.max!) ||\n        (year === this._dateAdapter.getYear(this.max!) &&\n          month > this._dateAdapter.getMonth(this.max!)));\n\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  private _isYearInRange(year: number): boolean {\n    if (!this.min && !this.max) {\n      return true;\n    }\n    const isBeforeMin: boolean =\n      this._dateAdapter.isValid(this.min) && this._dateAdapter.getYear(this.min!) > year;\n    const isAfterMax: boolean =\n      this._dateAdapter.isValid(this.max) && this._dateAdapter.getYear(this.max!) < year;\n    return !(isBeforeMin || isAfterMax);\n  }\n\n  // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/year-view.ts#L366\n  private _isMonthFilteredOut(month: number, year: number): boolean {\n    if (!this.dateFilter) {\n      return true;\n    }\n\n    const firstOfMonth = this._dateAdapter.createDate(year, month, 1)!;\n    for (\n      let date: T = firstOfMonth;\n      this._dateAdapter.getMonth(date) == month;\n      date = this._dateAdapter.addCalendarDays(date, 1)\n    ) {\n      if (this.dateFilter(date)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  // Implementation adapted from https://github.com/angular/components/blob/main/src/material/datepicker/multi-year-view.ts#L351\n  private _isYearFilteredOut(year: number): boolean {\n    if (!this.dateFilter) {\n      return true;\n    }\n\n    const firstOfYear = this._dateAdapter.createDate(year, 1, 1)!;\n    for (\n      let date: T = firstOfYear;\n      this._dateAdapter.getYear(date) == year;\n      date = this._dateAdapter.addCalendarDays(date, 1)\n    ) {\n      if (this.dateFilter(date)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /** Emits the selected date and sets it internally. */\n  private _selectDate(day: string): void {\n    this._chosenMonth = undefined;\n    this._setChosenYear();\n    if (this._selected !== day) {\n      this._selected = day;\n      this._dateSelected.emit(this._dateAdapter.deserialize(day)!);\n    }\n  }\n\n  private _setChosenYear(): void {\n    if (this.view === 'month') {\n      this._chosenYear = this._dateAdapter.getYear(\n        this._dateAdapter.deserialize(this._selected) ?? this.selected ?? this.now,\n      );\n    } else {\n      this._chosenYear = undefined;\n    }\n  }\n\n  private _assignActiveDate(date: T): void {\n    if (this.min && this._dateAdapter.compareDate(this.min, date) > 0) {\n      this._activeDate = this.min;\n      return;\n    }\n    if (this.max && this._dateAdapter.compareDate(this.max, date) < 0) {\n      this._activeDate = this.max;\n      return;\n    }\n    this._activeDate = date;\n  }\n\n  /** Goes to the month identified by the shift. */\n  private _goToDifferentMonth(months: number): void {\n    this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));\n  }\n\n  private _goToDifferentYear(years: number): void {\n    this._chosenYear! += years;\n    // Can't use `_assignActiveDate(...)` here, because it will set it to min/max value if argument is out of range\n    this._activeDate = this._dateAdapter.createDate(\n      this._chosenYear!,\n      this._dateAdapter.getMonth(this._activeDate),\n      this._dateAdapter.getDate(this._activeDate),\n    );\n    this._init();\n  }\n\n  private _goToDifferentYearRange(years: number): void {\n    this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));\n  }\n\n  private _prevDisabled(prevDate: T): boolean {\n    if (!this.min) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(prevDate, this.min) < 0;\n  }\n\n  private _nextDisabled(nextDate: T): boolean {\n    if (!this.max) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(nextDate, this.max) > 0;\n  }\n\n  /** Checks if the \"previous month\" button should be disabled. */\n  private _previousMonthDisabled(): boolean {\n    const prevMonth = this._dateAdapter.addCalendarDays(\n      this._activeDate,\n      this._dateAdapter.getDate(this._activeDate) * -1,\n    );\n    return this._prevDisabled(prevMonth);\n  }\n\n  /** Checks if the \"next month\" button should be disabled. */\n  private _nextMonthDisabled(): boolean {\n    let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);\n    nextMonth = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(nextMonth),\n      this._dateAdapter.getMonth(nextMonth),\n      1,\n    );\n    return this._nextDisabled(nextMonth);\n  }\n\n  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  private _nextYearDisabled(): boolean {\n    const nextYear = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(this._activeDate) + (this._wide ? 2 : 1),\n      1,\n      1,\n    );\n    return this._nextDisabled(nextYear);\n  }\n\n  private _previousYearRangeDisabled(): boolean {\n    const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);\n    return this._prevDisabled(prevYear);\n  }\n\n  private _nextYearRangeDisabled(): boolean {\n    const years = this._wide ? this._nextMonthYears : this._years;\n    const lastYearRange = years[years.length - 1];\n    const lastYear = lastYearRange[lastYearRange.length - 1];\n    const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);\n    return this._nextDisabled(nextYear);\n  }\n\n  private _handleTableBlur(eventTarget: HTMLElement): void {\n    if (eventTarget?.localName !== 'button') {\n      this._setTabIndex();\n    }\n  }\n\n  private _setTabIndex(): void {\n    Array.from(\n      this.shadowRoot!.querySelectorAll('.sbb-calendar__cell[tabindex=\"0\"]') ?? [],\n    ).forEach((day) => ((day as HTMLElement).tabIndex = -1));\n    const firstFocusable = this._getFirstFocusable();\n    if (firstFocusable) {\n      firstFocusable.tabIndex = 0;\n    }\n  }\n\n  private _getFirstFocusable(): HTMLButtonElement {\n    const active = this._selected ? this._dateAdapter.deserialize(this._selected)! : this.now;\n    let firstFocusable =\n      this.shadowRoot!.querySelector('.sbb-calendar__selected') ??\n      this.shadowRoot!.querySelector(\n        `[data-day=\"${this._dateAdapter.getDate(active)} ${this._dateAdapter.getMonth(\n          active,\n        )} ${this._dateAdapter.getYear(active)}\"]`,\n      ) ??\n      this.shadowRoot!.querySelector(`[data-month=\"${this._dateAdapter.getMonth(active)}\"]`) ??\n      this.shadowRoot!.querySelector(`[data-year=\"${this._dateAdapter.getYear(active)}\"]`);\n    if (!firstFocusable || (firstFocusable as HTMLButtonElement)?.disabled) {\n      firstFocusable = this.shadowRoot!.querySelector('.sbb-calendar__cell:not([disabled])');\n    }\n    return (firstFocusable as HTMLButtonElement) || null;\n  }\n\n  private _handleKeyboardEvent(event: KeyboardEvent, day?: Day): void {\n    if (isArrowKeyOrPageKeysPressed(event)) {\n      event.preventDefault();\n    }\n    // Gets the currently rendered table's cell;\n    // they could be days, months or years based on the current selection view.\n    // If `wide` is true, years are doubled in number and days are (roughly) doubled too, affecting the `index` calculation.\n    const cells: HTMLButtonElement[] = this._cells;\n    const index: number = cells.findIndex((e: HTMLButtonElement) => e === event.target);\n    const nextEl: HTMLButtonElement = this._navigateByKeyboard(event, index, cells, day);\n    const activeEl: HTMLButtonElement = this.shadowRoot!.activeElement as HTMLButtonElement;\n    if (nextEl !== activeEl) {\n      (nextEl as HTMLButtonElement).tabIndex = 0;\n      nextEl?.focus();\n      (activeEl as HTMLButtonElement).tabIndex = -1;\n    }\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: HTMLButtonElement[],\n    day?: Day,\n  ): HTMLButtonElement {\n    const {\n      elementIndexForWideMode,\n      offsetForWideMode,\n      lastElementIndexForWideMode,\n      verticalOffset,\n    }: CalendarKeyboardNavigationParameters = this._calculateParametersForKeyboardNavigation(\n      cells,\n      index,\n      day,\n    );\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 parameter needed in keyboard navigation.\n   * Since three views are now available, the function creates and returns the correct parameters for each of them\n   * by considering the number of cells per each row and the correction for the wide mode.\n   * @param cells The array of rendered table cells; they are buttons that can represent days, months or years.\n   * @param index The starting element's index in the cell array.\n   * @param day (optional) Only in the day view, the day represented by the starting cell.\n   */\n  private _calculateParametersForKeyboardNavigation(\n    cells: HTMLButtonElement[],\n    index: number,\n    day?: Day,\n  ): CalendarKeyboardNavigationParameters {\n    switch (this._calendarView) {\n      case 'day': {\n        const indexInView = +day!.dayValue - 1;\n        return {\n          verticalOffset: DAYS_PER_ROW,\n          elementIndexForWideMode: indexInView,\n          offsetForWideMode: index - indexInView,\n          lastElementIndexForWideMode:\n            index === indexInView\n              ? this._dateAdapter.getNumDaysInMonth(\n                  this._dateAdapter.addCalendarMonths(\n                    this._dateAdapter.deserialize(day!.value)!,\n                    -1,\n                  ),\n                )\n              : cells.length,\n        };\n      }\n      // Month view is not dependent from `wide` value, so some parameters are fixed.\n      case 'month': {\n        return {\n          verticalOffset: MONTHS_PER_ROW,\n          elementIndexForWideMode: index,\n          offsetForWideMode: 0,\n          lastElementIndexForWideMode: 12,\n        };\n      }\n      case 'year': {\n        const offset: number = Math.trunc(index / YEARS_PER_PAGE) * YEARS_PER_PAGE;\n        const indexInView: number = offset === 0 ? index : index - YEARS_PER_PAGE;\n        return {\n          verticalOffset: YEARS_PER_ROW,\n          elementIndexForWideMode: indexInView,\n          offsetForWideMode: index - indexInView,\n          lastElementIndexForWideMode: offset === 0 ? YEARS_PER_PAGE : YEARS_PER_PAGE * 2,\n        };\n      }\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(days: HTMLButtonElement[], index: number, delta: number): HTMLButtonElement {\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(days: HTMLButtonElement[], firstOfCurrentMonth: number): HTMLButtonElement {\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(days: HTMLButtonElement[], lastOfCurrentMonth: number): HTMLButtonElement {\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: HTMLButtonElement[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): HTMLButtonElement {\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: HTMLButtonElement[],\n    index: number,\n    offset: number,\n    verticalOffset: number,\n  ): HTMLButtonElement {\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 _resetCalendarView(initTransition = false): void {\n    this._resetFocus = true;\n    this._activeDate = this.selected ?? this.now;\n    this._setChosenYear();\n    this._chosenMonth = undefined;\n    this._nextCalendarView = this._calendarView = this.view;\n\n    if (initTransition) {\n      this._startTableTransition();\n    }\n  }\n\n  /** Render the view for the day selection. */\n  private _renderDayView(): TemplateResult {\n    const nextMonthActiveDate = this._wide\n      ? this._dateAdapter.addCalendarMonths(this._activeDate, 1)\n      : undefined;\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentMonth(-1),\n          i18nPreviousMonth[this._language.current],\n          this._previousMonthDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">\n          ${this._createLabelForDayView(this._activeDate)}\n          ${this._wide ? this._createLabelForDayView(nextMonthActiveDate!) : nothing}\n          <sbb-screen-reader-only role=\"status\">\n            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate!)}\n          </sbb-screen-reader-only>\n        </div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentMonth(1),\n          i18nNextMonth[this._language.current],\n          this._nextMonthDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-day-view\">\n        ${this._createDayTable(this._weeks)}\n        ${this._wide ? this._createDayTable(this._nextMonthWeeks) : nothing}\n      </div>\n    `;\n  }\n\n  /** Creates the label with the month for the daily view. */\n  private _createLabelForDayView(d: T): TemplateResult {\n    const monthLabel = `${\n      this._monthNames[this._dateAdapter.getMonth(d) - 1]\n    } ${this._dateAdapter.getYear(d)}`;\n    return html`\n      <button\n        type=\"button\"\n        class=\"sbb-calendar__date-selection sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nYearMonthSelection[this._language.current]} ${monthLabel}\"\n        @click=${() => {\n          this._resetFocus = true;\n          this._nextCalendarView = 'year';\n          this._startTableTransition();\n        }}\n      >\n        ${monthLabel}\n        <sbb-icon name=\"chevron-small-down-small\"></sbb-icon>\n      </button>\n    `;\n  }\n\n  /** Creates the aria-label for the daily view. */\n  private _createAriaLabelForDayView(...dates: T[]): string {\n    let monthLabel = '';\n    for (const d of dates) {\n      if (d) {\n        monthLabel += `${\n          this._monthNames[this._dateAdapter.getMonth(d) - 1]\n        } ${this._dateAdapter.getYear(d)} `;\n      }\n    }\n    return monthLabel;\n  }\n\n  /** Creates the calendar table for the daily view. */\n  private _createDayTable(weeks: Day[][]): TemplateResult {\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @focusout=${(event: FocusEvent) =>\n          this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        <thead class=\"sbb-calendar__table-header\">\n          <tr class=\"sbb-calendar__table-header-row\">\n            ${this._createDayTableHeader()}\n          </tr>\n        </thead>\n        <tbody class=\"sbb-calendar__table-body\">\n          ${this._createDayTableBody(weeks)}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Creates the table header with the month header cells. */\n  private _createDayTableHeader(): TemplateResult[] {\n    return this._weekdays.map(\n      (day: Weekday) => html`\n        <th class=\"sbb-calendar__table-header\">\n          <sbb-screen-reader-only>${day.long}</sbb-screen-reader-only>\n          <span aria-hidden=\"true\">${day.narrow}</span>\n        </th>\n      `,\n    );\n  }\n\n  /** Creates the table body with the day cells. For the first row, it also considers the possible day's offset. */\n  private _createDayTableBody(weeks: Day[][]): TemplateResult[] {\n    const today: string = this._dateAdapter.toIso8601(this.now);\n    return weeks.map((week: Day[], rowIndex: number) => {\n      const firstRowOffset: number = DAYS_PER_ROW - week.length;\n      if (rowIndex === 0 && firstRowOffset) {\n        return html`\n          <tr>\n            ${[...Array(firstRowOffset).keys()].map(\n              () =>\n                html`<td\n                  class=\"sbb-calendar__table-data\"\n                  data-day=${`0 ${week[0].monthValue} ${week[0].yearValue}`}\n                ></td>`,\n            )}\n            ${this._createDayCells(week, today)}\n          </tr>\n        `;\n      }\n      return html`<tr>\n        ${this._createDayCells(week, today)}\n      </tr>`;\n    });\n  }\n\n  /** Creates the cells for the daily view. */\n  private _createDayCells(week: Day[], today: string): TemplateResult[] {\n    return week.map((day: Day) => {\n      const isOutOfRange = !this._isDayInRange(day.value);\n      const isFilteredOut = !this._dateFilter(this._dateAdapter.deserialize(day.value)!);\n      const selected: boolean = !!this._selected && day.value === this._selected;\n      const dayValue = `${day.dayValue} ${day.monthValue} ${day.yearValue}`;\n      const isToday = day.value === today;\n      return html`\n        <td\n          class=${classMap({\n            'sbb-calendar__table-data': true,\n            'sbb-calendar__table-data-selected': selected,\n          })}\n        >\n          <button\n            class=${classMap({\n              'sbb-calendar__cell': true,\n              'sbb-calendar__day': true,\n              'sbb-calendar__cell-current': isToday,\n              'sbb-calendar__selected': selected,\n              'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n            })}\n            @click=${() => this._selectDate(day.value)}\n            ?disabled=${isOutOfRange || isFilteredOut}\n            aria-label=${this._dateAdapter.getAccessibilityFormatDate(day.value)}\n            aria-pressed=${selected}\n            aria-disabled=${isOutOfRange || isFilteredOut}\n            aria-current=${isToday ? 'date' : nothing}\n            data-day=${dayValue || nothing}\n            tabindex=\"-1\"\n            @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt, day)}\n            sbb-popover-close\n          >\n            ${day.dayValue}\n          </button>\n        </td>\n      `;\n    });\n  }\n\n  /** Render the view for the month selection. */\n  private _renderMonthView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYear(-1),\n          i18nPreviousYear[this._language.current],\n          this._previousYearDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForMonthView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYear(1),\n          i18nNextYear[this._language.current],\n          this._nextYearDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-month-view\">\n        ${this._createMonthTable(this._months, this._chosenYear!)}\n        ${this._wide ? this._createMonthTable(this._months, this._chosenYear! + 1) : nothing}\n      </div>\n    `;\n  }\n\n  /** Creates the label with the year for the monthly view. */\n  private _createLabelForMonthView(): TemplateResult {\n    return html` <button\n        type=\"button\"\n        id=\"sbb-calendar__month-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=${`${i18nCalendarDateSelection[this._language.current]} ${this._chosenYear}`}\n        @click=${() => this._resetCalendarView(true)}\n      >\n        ${this._chosenYear} ${this._wide ? ` - ${this._chosenYear! + 1}` : nothing}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${this._chosenYear} </sbb-screen-reader-only>`;\n  }\n\n  /** Creates the table for the month selection view. */\n  private _createMonthTable(months: Month[][], year: number): TemplateResult {\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        ${this._wide\n          ? html`<thead class=\"sbb-calendar__table-header\" aria-hidden=\"true\">\n              <tr class=\"sbb-calendar__table-header-row\">\n                <th class=\"sbb-calendar__table-header\" colspan=${MONTHS_PER_ROW}>${year}</th>\n              </tr>\n            </thead>`\n          : nothing}\n        <tbody class=\"sbb-calendar__table-body\">\n          ${months.map(\n            (row: Month[]) => html`\n              <tr>\n                ${row.map((month: Month) => {\n                  const isOutOfRange = !this._isMonthInRange(month.monthValue, year);\n                  const isFilteredOut = !this._isMonthFilteredOut(month.monthValue, year);\n                  const selectedMonth = this._selected\n                    ? this._dateAdapter.getMonth(this._dateAdapter.deserialize(this._selected)!)\n                    : undefined;\n                  const selectedYear = this._selected\n                    ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)!)\n                    : undefined;\n                  const selected: boolean =\n                    !!this._selected && year === selectedYear && month.monthValue === selectedMonth;\n\n                  const isCurrentMonth =\n                    year === this._dateAdapter.getYear(this.now) &&\n                    this._dateAdapter.getMonth(this.now) === month.monthValue;\n\n                  return html` <td\n                    class=${classMap({\n                      'sbb-calendar__table-data': true,\n                      'sbb-calendar__table-month': true,\n                    })}\n                  >\n                    <button\n                      class=${classMap({\n                        'sbb-calendar__cell': true,\n                        'sbb-calendar__pill': true,\n                        'sbb-calendar__cell-current': isCurrentMonth,\n                        'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n                        'sbb-calendar__selected': selected,\n                      })}\n                      @click=${() => this._onMonthSelection(month.monthValue, year)}\n                      ?disabled=${isOutOfRange || isFilteredOut}\n                      aria-label=${`${month.longValue} ${year}`}\n                      aria-pressed=${selected}\n                      aria-disabled=${String(isOutOfRange || isFilteredOut)}\n                      tabindex=\"-1\"\n                      data-month=${month.monthValue || nothing}\n                      @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt)}\n                    >\n                      ${month.value}\n                    </button>\n                  </td>`;\n                })}\n              </tr>\n            `,\n          )}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Select the month and change the view to day selection. */\n  private _onMonthSelection(month: number, year: number): void {\n    this._chosenMonth = month;\n    this._nextCalendarView = 'day';\n    this._init(\n      this._dateAdapter.createDate(\n        year,\n        this._chosenMonth,\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._startTableTransition();\n  }\n\n  /** Render the view for the year selection. */\n  private _renderYearView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYearRange(-YEARS_PER_PAGE),\n          i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._previousYearRangeDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForYearView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYearRange(YEARS_PER_PAGE),\n          i18nNextYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._nextYearRangeDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-container sbb-calendar__table-year-view\">\n        ${this._createYearTable(this._years)}\n        ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}\n      </div>\n    `;\n  }\n\n  /** Creates the button arrow for all the views. */\n  private _getArrow(\n    direction: 'left' | 'right',\n    click: () => void,\n    ariaLabel: string,\n    disabled: boolean,\n  ): TemplateResult {\n    return html`<sbb-secondary-button\n      size=\"m\"\n      icon-name=\"chevron-small-${direction}-small\"\n      aria-label=${ariaLabel}\n      @click=${click}\n      ?disabled=${disabled}\n      id=\"sbb-calendar__controls-${direction === 'left' ? 'previous' : 'next'}\"\n    ></sbb-secondary-button>`;\n  }\n\n  /** Creates the label with the year range for the yearly view. */\n  private _createLabelForYearView(): TemplateResult {\n    const firstYear: number = this._years.flat()[0];\n    const lastYearArray: number[] = (this._wide ? this._nextMonthYears : this._years).flat();\n    const lastYear: number = lastYearArray[lastYearArray.length - 1];\n    const yearLabel = `${firstYear} - ${lastYear}`;\n    return html`\n      <button\n        type=\"button\"\n        id=\"sbb-calendar__year-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nCalendarDateSelection[this._language.current]} ${yearLabel}\"\n        @click=${() => this._resetCalendarView(true)}\n      >\n        ${yearLabel}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${yearLabel} </sbb-screen-reader-only>\n    `;\n  }\n\n  /** Creates the table for the year selection view. */\n  private _createYearTable(years: number[][], shiftRight = false): TemplateResult {\n    const now = this.now;\n    return html` <table\n      class=\"sbb-calendar__table\"\n      @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n    >\n      <tbody class=\"sbb-calendar__table-body\">\n        ${years.map(\n          (row: number[]) =>\n            html` <tr>\n              ${row.map((year: number) => {\n                const isOutOfRange = !this._isYearInRange(year);\n                const isFilteredOut = !this._isYearFilteredOut(year);\n                const selectedYear = this._selected\n                  ? this._dateAdapter.getYear(this._dateAdapter.deserialize(this._selected)!)\n                  : undefined;\n                const selected: boolean = !!this._selected && year === selectedYear;\n                const isCurrentYear = this._dateAdapter.getYear(now) === year;\n                return html` <td class=\"sbb-calendar__table-data sbb-calendar__table-year\">\n                  <button\n                    class=${classMap({\n                      'sbb-calendar__cell': true,\n                      'sbb-calendar__pill': true,\n                      'sbb-calendar__cell-current': isCurrentYear,\n                      'sbb-calendar__crossed-out': !isOutOfRange && isFilteredOut,\n                      'sbb-calendar__selected': selected,\n                    })}\n                    @click=${() => this._onYearSelection(year, shiftRight)}\n                    ?disabled=${isOutOfRange || isFilteredOut}\n                    aria-label=${year}\n                    aria-pressed=${selected}\n                    aria-disabled=${String(isOutOfRange || isFilteredOut)}\n                    tabindex=\"-1\"\n                    data-year=${year || nothing}\n                    @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt)}\n                  >\n                    ${year}\n                  </button>\n                </td>`;\n              })}\n            </tr>`,\n        )}\n      </tbody>\n    </table>`;\n  }\n\n  /** Select the year and change the view to month selection. */\n  private _onYearSelection(year: number, rightSide: boolean): void {\n    this._chosenYear = rightSide ? year - 1 : year;\n    this._nextCalendarView = 'month';\n    this._assignActiveDate(\n      this._dateAdapter.createDate(\n        this._chosenYear,\n        this._dateAdapter.getMonth(this._activeDate),\n        this._dateAdapter.getDate(this._activeDate),\n      ),\n    );\n    this._startTableTransition();\n  }\n\n  private _getView(): TemplateResult {\n    if (isServer || this.hydrationRequired) {\n      // TODO: We disable SSR for calendar for now. Figure our, if there is a way\n      // to enable it, while considering i18n and date information.\n      return html`${nothing}`;\n    }\n    switch (this._calendarView) {\n      case 'year':\n        return this._renderYearView();\n      case 'month':\n        return this._renderMonthView();\n      case 'day':\n      default:\n        return this._renderDayView();\n    }\n  }\n\n  private _tableAnimationEnd(event: AnimationEvent): void {\n    const table = event.target as HTMLElement;\n    if (event.animationName === 'hide') {\n      table.classList.remove('sbb-calendar__table-hide');\n      this._resetFocus = true;\n      this._calendarView = this._nextCalendarView;\n    } else if (event.animationName === 'show') {\n      this.removeAttribute('data-transition');\n    }\n  }\n\n  private _startTableTransition(): void {\n    this.toggleAttribute('data-transition', true);\n    this.shadowRoot\n      ?.querySelectorAll('table')\n      ?.forEach((e) => e.classList.toggle('sbb-calendar__table-hide'));\n  }\n\n  protected override render(): TemplateResult {\n    return html`<div class=\"sbb-calendar__wrapper\">${this._getView()}</div>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-calendar': SbbCalendarElement;\n  }\n}\n"],"names":["SbbCalendarElement","_a"],"mappings":"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"}