@sbb-esta/lyne-elements 4.5.0 → 4.6.0

package/development/calendar/calendar/calendar.component.js

@@ -0,0 +1,1990 @@
+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, nothing, html } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+import { isArrowKeyOrPageKeysPressed } from "../../core/a11y.js";
+import { readConfig } from "../../core/config.js";
+import { SbbLanguageController, SbbMediaMatcherController, SbbMediaQueryBreakpointLargeAndAbove } from "../../core/controllers.js";
+import { defaultDateAdapter, YEARS_PER_PAGE, DAYS_PER_ROW, MONTHS_PER_ROW, YEARS_PER_ROW, MONTHS_PER_PAGE } from "../../core/datetime.js";
+import { forceType, plainDate, handleDistinctChange } from "../../core/decorators.js";
+import { i18nPreviousMonth, i18nNextMonth, i18nYearMonthSelection, i18nCalendarWeekNumber, i18nPreviousYear, i18nNextYear, i18nCalendarDateSelection, i18nPreviousYearRange, i18nNextYearRange } from "../../core/i18n.js";
+import { SbbHydrationMixin, SbbElementInternalsMixin } from "../../core/mixins.js";
+import { boxSizingStyles } from "../../core/styles.js";
+import "../../button/secondary-button.js";
+import "../../icon.js";
+import "../../screen-reader-only.js";
+import "../calendar-day/calendar-day.component.js";
+const millisecondsInWeek = 6048e5;
+const constructFromSymbol = /* @__PURE__ */ Symbol.for("constructDateFrom");
+function constructFrom(date, value) {
+  if (typeof date === "function") return date(value);
+  if (date && typeof date === "object" && constructFromSymbol in date)
+    return date[constructFromSymbol](value);
+  if (date instanceof Date) return new date.constructor(value);
+  return new Date(value);
+}
+function toDate(argument, context) {
+  return constructFrom(context || argument, argument);
+}
+function addDays(date, amount, options) {
+  const _date = toDate(date, options?.in);
+  if (isNaN(amount)) return constructFrom(date, NaN);
+  if (!amount) return _date;
+  _date.setDate(_date.getDate() + amount);
+  return _date;
+}
+let defaultOptions = {};
+function getDefaultOptions() {
+  return defaultOptions;
+}
+function startOfWeek(date, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
+  const _date = toDate(date, options?.in);
+  const day = _date.getDay();
+  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  _date.setDate(_date.getDate() - diff);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+function normalizeDates(context, ...dates) {
+  const normalize = constructFrom.bind(
+    null,
+    context || dates.find((date) => typeof date === "object")
+  );
+  return dates.map(normalize);
+}
+function addWeeks(date, amount, options) {
+  return addDays(date, amount * 7, options);
+}
+function endOfMonth(date, options) {
+  const _date = toDate(date, options?.in);
+  const month = _date.getMonth();
+  _date.setFullYear(_date.getFullYear(), month + 1, 0);
+  _date.setHours(23, 59, 59, 999);
+  return _date;
+}
+function normalizeInterval(context, interval) {
+  const [start, end] = normalizeDates(context, interval.start, interval.end);
+  return { start, end };
+}
+function eachWeekOfInterval(interval, options) {
+  const { start, end } = normalizeInterval(options?.in, interval);
+  let reversed = +start > +end;
+  const startDateWeek = reversed ? startOfWeek(end, options) : startOfWeek(start, options);
+  const endDateWeek = reversed ? startOfWeek(start, options) : startOfWeek(end, options);
+  startDateWeek.setHours(15);
+  endDateWeek.setHours(15);
+  const endTime = +endDateWeek.getTime();
+  let currentDate = startDateWeek;
+  let step = options?.step ?? 1;
+  if (!step) return [];
+  if (step < 0) {
+    step = -step;
+    reversed = !reversed;
+  }
+  const dates = [];
+  while (+currentDate <= endTime) {
+    currentDate.setHours(0);
+    dates.push(constructFrom(start, currentDate));
+    currentDate = addWeeks(currentDate, step);
+    currentDate.setHours(15);
+  }
+  return reversed ? dates.reverse() : dates;
+}
+function startOfMonth(date, options) {
+  const _date = toDate(date, options?.in);
+  _date.setDate(1);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+function getWeekYear(date, options) {
+  const _date = toDate(date, options?.in);
+  const year = _date.getFullYear();
+  const defaultOptions2 = getDefaultOptions();
+  const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
+  const firstWeekOfNextYear = constructFrom(options?.in || date, 0);
+  firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
+  firstWeekOfNextYear.setHours(0, 0, 0, 0);
+  const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);
+  const firstWeekOfThisYear = constructFrom(options?.in || date, 0);
+  firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
+  firstWeekOfThisYear.setHours(0, 0, 0, 0);
+  const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);
+  if (+_date >= +startOfNextYear) {
+    return year + 1;
+  } else if (+_date >= +startOfThisYear) {
+    return year;
+  } else {
+    return year - 1;
+  }
+}
+function startOfWeekYear(date, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
+  const year = getWeekYear(date, options);
+  const firstWeek = constructFrom(options?.in || date, 0);
+  firstWeek.setFullYear(year, 0, firstWeekContainsDate);
+  firstWeek.setHours(0, 0, 0, 0);
+  const _date = startOfWeek(firstWeek, options);
+  return _date;
+}
+function getWeek(date, options) {
+  const _date = toDate(date, options?.in);
+  const diff = +startOfWeek(_date, options) - +startOfWeekYear(_date, options);
+  return Math.round(diff / millisecondsInWeek) + 1;
+}
+const style = css`:host {
+  display: block;
+  width: max-content;
+  --sbb-calendar-cell-size: 2.5rem;
+  --sbb-calendar-hover-shift: 0.0625rem;
+  --sbb-calendar-wide-cell-size: 4.375rem;
+  --sbb-calendar-header-color: var(--sbb-color-granite);
+  --sbb-calendar-header-color: light-dark(var(--sbb-color-granite), var(--sbb-color-smoke));
+  --sbb-calendar-cell-background-color: transparent;
+  --sbb-calendar-cell-background-color-hover: var(--sbb-background-color-3);
+  --sbb-calendar-cell-background-color-active: var(--sbb-background-color-4);
+  --sbb-calendar-cell-padding: 0.125rem;
+  --sbb-calendar-cell-color: var(--sbb-color-2);
+  --sbb-calendar-cell-border-radius: var(--sbb-border-radius-4x);
+  --sbb-calendar-cell-selected-border: var(--sbb-border-width-2x) solid var(--sbb-border-color-2);
+  --sbb-calendar-cell-selected-background-color: var(--sbb-background-color-2-inverted);
+  --sbb-calendar-cell-disabled-height: 0.09375rem;
+  --sbb-calendar-cell-disabled-width: 1.59375rem;
+  --sbb-calendar-cell-disabled-color: var(--sbb-color-granite);
+  --sbb-calendar-cell-disabled-color: light-dark(var(--sbb-color-granite), var(--sbb-color-smoke));
+  --sbb-calendar-cell-transition-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-2x)
+  );
+  --sbb-calendar-cell-transition-easing-function: var(--sbb-animation-easing);
+  --sbb-calendar-tables-gap: var(--sbb-spacing-fixed-10x);
+  --sbb-calendar-table-animation-shift: 0.00625rem;
+  --sbb-calendar-table-animation-duration: 0.1ms;
+  --sbb-calendar-table-column-spaces: 12;
+  --sbb-calendar-control-view-change-height: 2.75rem;
+  --sbb-calendar-control-view-change-color: var(--sbb-color-3);
+  --sbb-calendar-control-view-change-background: var(--sbb-background-color-1);
+  --sbb-calendar-cell-year-month-width: 4.8125rem;
+  --sbb-calendar-cell-year-month-height: 2.75rem;
+}
+@media (min-width: calc(37.5rem)) {
+  :host {
+    --sbb-calendar-cell-size: 2.75rem;
+    --sbb-calendar-wide-cell-size: 4.8125rem;
+    --sbb-calendar-control-view-change-height: 3rem;
+  }
+}
+
+:host(:is(:state(enhanced),[state--enhanced])) {
+  --sbb-calendar-cell-padding-block-end: var(--sbb-spacing-fixed-3x);
+}
+
+.sbb-calendar__wrapper {
+  width: 100%;
+  display: block;
+  transition-duration: var(--sbb-calendar-cell-transition-duration);
+}
+
+.sbb-calendar__controls {
+  width: 100%;
+  display: inline-flex;
+  align-items: center;
+  gap: var(--sbb-spacing-fixed-2x);
+  margin-block-end: var(--sbb-spacing-fixed-4x);
+}
+
+.sbb-calendar__controls-month {
+  width: 100%;
+  display: flex;
+  gap: var(--sbb-calendar-tables-gap);
+}
+
+#sbb-calendar__controls-previous,
+#sbb-calendar__controls-next {
+  -webkit-tap-highlight-color: transparent;
+}
+
+.sbb-calendar__controls-change-date {
+  appearance: none;
+  box-sizing: border-box;
+  margin: 0;
+  outline: none;
+  border: none;
+  border-radius: 0;
+  padding: 0;
+  background: none;
+  -webkit-tap-highlight-color: transparent;
+  color: inherit;
+  --sbb-text-font-size: var(--sbb-text-font-size-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-size: var(--sbb-text-font-size);
+  display: flex;
+  align-items: center;
+  margin: auto;
+  height: var(--sbb-calendar-control-view-change-height);
+  text-transform: capitalize;
+  cursor: var(--sbb-cursor-pointer);
+  padding-inline: var(--sbb-spacing-fixed-5x) var(--sbb-spacing-fixed-2x);
+  border-radius: var(--sbb-border-radius-infinity);
+  background-color: var(--sbb-calendar-control-view-change-background);
+  color: var(--sbb-calendar-control-view-change-color);
+  transition-duration: var(--sbb-calendar-cell-transition-duration);
+  transition-timing-function: var(--sbb-calendar-cell-transition-easing-function);
+  transition-property: background-color, padding-block-end;
+}
+.sbb-calendar__controls-change-date:disabled {
+  --sbb-calendar-control-view-change-background: var(--sbb-color-milk);
+  --sbb-calendar-control-view-change-background: light-dark(
+    var(--sbb-color-milk),
+    var(--sbb-color-anthracite)
+  );
+  --sbb-calendar-control-view-change-color: var(--sbb-color-granite);
+  --sbb-calendar-control-view-change-color: light-dark(
+    var(--sbb-color-granite),
+    var(--sbb-color-aluminium)
+  );
+  cursor: unset;
+}
+.sbb-calendar__controls-change-date:focus-visible {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+  outline-offset: var(--sbb-spacing-fixed-1x);
+}
+@media (any-hover: hover) {
+  .sbb-calendar__controls-change-date:not(:active, :disabled):hover {
+    padding-block-end: var(--sbb-calendar-hover-shift);
+  }
+}
+.sbb-calendar__controls-change-date:not(:disabled):active {
+  --sbb-calendar-control-view-change-background: var(--sbb-background-color-3);
+}
+
+.sbb-calendar__table-month-view,
+.sbb-calendar__table-year-view {
+  --sbb-calendar-table-column-spaces: 6;
+}
+
+.sbb-calendar__table-overflow-break {
+  contain: layout;
+}
+
+.sbb-calendar__table-container {
+  display: flex;
+  gap: var(--sbb-calendar-tables-gap);
+  margin-inline: var(--sbb-calendar-margin);
+  --sbb-calendar-min-width: calc(7 * var(--sbb-calendar-cell-size));
+  --sbb-calendar-overflow: calc(100% - var(--sbb-calendar-min-width));
+  --sbb-calendar-start-offset: min(
+    0px,
+    -1 * (var(--sbb-calendar-overflow) / var(--sbb-calendar-table-column-spaces))
+  );
+  --sbb-calendar-margin: var(--sbb-calendar-start-offset);
+}
+:host(:is(:state(wide),[state--wide])) .sbb-calendar__table-container {
+  --sbb-calendar-min-width: calc(
+    2 * 7 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)
+  );
+  --sbb-calendar-margin: calc(0.5 * var(--sbb-calendar-start-offset));
+}
+:host([orientation=horizontal][week-numbers]) .sbb-calendar__table-container {
+  --sbb-calendar-min-width: calc(8 * var(--sbb-calendar-cell-size));
+}
+:host([orientation=horizontal][week-numbers]:is(:state(wide),[state--wide])) .sbb-calendar__table-container {
+  --sbb-calendar-min-width: calc(
+    2 * 8 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)
+  );
+}
+:host([orientation=vertical]) .sbb-calendar__table-container {
+  min-width: var(--sbb-calendar-min-width);
+  --sbb-calendar-start-offset: 0;
+}
+:host([orientation=vertical]:is(:state(wide),[state--wide])) .sbb-calendar__table-container {
+  --sbb-calendar-min-width: calc(
+    13 * var(--sbb-calendar-cell-size) + var(--sbb-calendar-tables-gap)
+  );
+}
+
+.sbb-calendar__table {
+  width: 100%;
+  border-collapse: collapse;
+  height: max-content;
+  animation-name: show;
+  animation-duration: var(--sbb-calendar-table-animation-duration);
+}
+.sbb-calendar__table.sbb-calendar__table-hide {
+  --sbb-calendar-cell-transition-duration: 0ms;
+  animation-name: hide;
+  animation-duration: var(--sbb-calendar-table-animation-duration);
+}
+:host(:not(:is(:state(wide),[state--wide]))) .sbb-calendar__table {
+  min-width: 100%;
+}
+
+.sbb-calendar__table-header {
+  text-align: center;
+}
+
+.sbb-calendar__table-body {
+  text-align: center;
+}
+
+.sbb-calendar__table-header-cell,
+.sbb-calendar__table-header-cell-vertical {
+  --sbb-text-font-size: var(--sbb-text-font-size-xs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-size: var(--sbb-text-font-size);
+  width: var(--sbb-calendar-cell-size);
+  color: var(--sbb-calendar-header-color);
+  padding: 0;
+}
+:host(:not([multiple])) .sbb-calendar__table-header-cell,
+:host(:not([multiple])) .sbb-calendar__table-header-cell-vertical {
+  height: var(--sbb-calendar-cell-size);
+}
+
+.sbb-calendar__table-header-cell-vertical {
+  padding-block-end: var(--sbb-calendar-cell-padding-block-end);
+}
+
+.sbb-calendar__table-data {
+  position: relative;
+  padding: 0;
+  text-align: center;
+}
+
+.sbb-calendar__header-cell,
+.sbb-calendar__cell {
+  appearance: none;
+  box-sizing: border-box;
+  margin: 0;
+  outline: none;
+  border: none;
+  border-radius: 0;
+  padding: 0;
+  background: none;
+  -webkit-tap-highlight-color: transparent;
+  color: inherit;
+  --sbb-text-font-size: var(--sbb-text-font-size-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-size: var(--sbb-text-font-size);
+  height: var(--sbb-calendar-cell-size);
+  color: var(--sbb-calendar-cell-color);
+  cursor: var(--sbb-cursor-pointer);
+  position: relative;
+  z-index: 0;
+}
+.sbb-calendar__header-cell::before,
+.sbb-calendar__cell::before {
+  content: "";
+  position: absolute;
+  inset: var(--sbb-calendar-cell-padding);
+  background-color: var(--sbb-calendar-cell-background-color);
+  border-radius: var(--sbb-calendar-cell-border-radius);
+  z-index: -1;
+  transition-duration: var(--sbb-calendar-cell-transition-duration);
+  transition-timing-function: var(--sbb-calendar-cell-transition-easing-function);
+  transition-property: background-color;
+}
+@media (any-hover: hover) {
+  .sbb-calendar__header-cell:not(:active, :disabled):hover,
+  .sbb-calendar__cell:not(:active, :disabled):hover {
+    --sbb-calendar-cell-background-color: var(--sbb-calendar-cell-background-color-hover);
+    padding-block-end: var(--sbb-calendar-hover-shift);
+  }
+}
+@media (any-hover: hover) and (forced-colors: active) {
+  .sbb-calendar__header-cell:not(:active, :disabled):hover::before,
+  .sbb-calendar__cell:not(:active, :disabled):hover::before {
+    outline-offset: var(--sbb-focus-outline-offset);
+    outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+    --sbb-focus-outline-style: initial;
+  }
+}
+.sbb-calendar__header-cell:disabled,
+.sbb-calendar__cell:disabled {
+  --sbb-calendar-cell-color: var(--sbb-calendar-cell-disabled-color);
+  cursor: unset;
+}
+.sbb-calendar__header-cell:focus-visible::before,
+.sbb-calendar__cell:focus-visible::before {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+}
+.sbb-calendar__header-cell:not(:disabled):active,
+.sbb-calendar__cell:not(:disabled):active {
+  --sbb-calendar-cell-background-color: var(--sbb-calendar-cell-background-color-active);
+}
+@media (forced-colors: active) {
+  .sbb-calendar__header-cell:not(:disabled):active::before,
+  .sbb-calendar__cell:not(:disabled):active::before {
+    outline-offset: var(--sbb-focus-outline-offset);
+    outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+    --sbb-focus-outline-style: initial;
+  }
+}
+
+.sbb-calendar__header-cell {
+  --sbb-text-font-size: var(--sbb-text-font-size-xs);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-size: var(--sbb-text-font-size);
+  color: var(--sbb-calendar-header-color);
+}
+
+.sbb-calendar__cell {
+  height: var(--sbb-calendar-cell-year-month-height);
+  width: var(--sbb-calendar-cell-year-month-width);
+}
+
+.sbb-calendar__weekday {
+  width: var(--sbb-calendar-cell-size);
+}
+
+.sbb-calendar__day-cell {
+  padding-block-end: var(--sbb-calendar-cell-padding-block-end);
+}
+
+.sbb-calendar__crossed-out::after {
+  content: "";
+  height: var(--sbb-calendar-cell-disabled-height);
+  width: var(--sbb-calendar-cell-disabled-width);
+  position: absolute;
+  background-color: var(--sbb-calendar-cell-disabled-color);
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%) rotate(-45deg);
+}
+
+.sbb-calendar__cell-current {
+  --sbb-text-font-size: var(--sbb-text-font-size-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+  font-size: var(--sbb-text-font-size);
+  font-weight: bold;
+}
+
+.sbb-calendar__selected::before {
+  border: var(--sbb-calendar-cell-selected-border);
+  border-radius: var(--sbb-calendar-cell-border-radius);
+}
+
+sbb-calendar-day {
+  --sbb-calendar-day-flex-direction: row;
+  --sbb-calendar-day-justify-content: center;
+  --sbb-calendar-day-align-items: center;
+  --sbb-calendar-day-extra-display: none;
+  --sbb-calendar-day-crossed-out-top: 50%;
+  --sbb-calendar-day-crossed-out-translate: translate(-50%, -50%) rotate(-45deg);
+  --sbb-calendar-day-height: 2.75rem;
+  --sbb-calendar-day-value-height: unset;
+}
+
+@keyframes show {
+  from {
+    opacity: 0;
+    transform: translateY(var(--sbb-calendar-table-animation-shift));
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0%);
+  }
+}
+@keyframes hide {
+  from {
+    opacity: 1;
+    transform: translateY(0%);
+  }
+  to {
+    opacity: 0;
+    transform: translateY(var(--sbb-calendar-table-animation-shift));
+  }
+}`;
+class SbbMonthChangeEvent extends Event {
+  get range() {
+    return this._range;
+  }
+  constructor(range) {
+    super("monthchange", { bubbles: true, composed: true });
+    this._range = Object.freeze(range || []);
+  }
+}
+let SbbCalendarElement = (() => {
+  var _wide_accessor_storage, _view_accessor_storage, _min_accessor_storage, _max_accessor_storage, _multiple_accessor_storage, __selected_accessor_storage, _dateFilter_accessor_storage, _orientation_accessor_storage, _weekNumbers_accessor_storage, __activeDate_accessor_storage, __calendarView_accessor_storage, __initialized_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-calendar")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbHydrationMixin(SbbElementInternalsMixin(LitElement));
+  let _instanceExtraInitializers = [];
+  let _wide_decorators;
+  let _wide_initializers = [];
+  let _wide_extraInitializers = [];
+  let _view_decorators;
+  let _view_initializers = [];
+  let _view_extraInitializers = [];
+  let _min_decorators;
+  let _min_initializers = [];
+  let _min_extraInitializers = [];
+  let _max_decorators;
+  let _max_initializers = [];
+  let _max_extraInitializers = [];
+  let _multiple_decorators;
+  let _multiple_initializers = [];
+  let _multiple_extraInitializers = [];
+  let _set_selected_decorators;
+  let __selected_decorators;
+  let __selected_initializers = [];
+  let __selected_extraInitializers = [];
+  let _dateFilter_decorators;
+  let _dateFilter_initializers = [];
+  let _dateFilter_extraInitializers = [];
+  let _orientation_decorators;
+  let _orientation_initializers = [];
+  let _orientation_extraInitializers = [];
+  let _weekNumbers_decorators;
+  let _weekNumbers_initializers = [];
+  let _weekNumbers_extraInitializers = [];
+  let __activeDate_decorators;
+  let __activeDate_initializers = [];
+  let __activeDate_extraInitializers = [];
+  let _set__wide_decorators;
+  let __calendarView_decorators;
+  let __calendarView_initializers = [];
+  let __calendarView_extraInitializers = [];
+  let __initialized_decorators;
+  let __initialized_initializers = [];
+  let __initialized_extraInitializers = [];
+  _a = class extends _classSuper {
+    constructor() {
+      super();
+      __privateAdd(this, _wide_accessor_storage);
+      __privateAdd(this, _view_accessor_storage);
+      __privateAdd(this, _min_accessor_storage);
+      __privateAdd(this, _max_accessor_storage);
+      __privateAdd(this, _multiple_accessor_storage);
+      __privateAdd(this, __selected_accessor_storage);
+      __privateAdd(this, _dateFilter_accessor_storage);
+      __privateAdd(this, _orientation_accessor_storage);
+      __privateAdd(this, _weekNumbers_accessor_storage);
+      __privateAdd(this, __activeDate_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")));
+      __privateSet(this, _min_accessor_storage, (__runInitializers(this, _view_extraInitializers), __runInitializers(this, _min_initializers, null)));
+      __privateSet(this, _max_accessor_storage, (__runInitializers(this, _min_extraInitializers), __runInitializers(this, _max_initializers, null)));
+      __privateSet(this, _multiple_accessor_storage, (__runInitializers(this, _max_extraInitializers), __runInitializers(this, _multiple_initializers, false)));
+      __privateSet(this, __selected_accessor_storage, (__runInitializers(this, _multiple_extraInitializers), __runInitializers(this, __selected_initializers, null)));
+      __privateSet(this, _dateFilter_accessor_storage, (__runInitializers(this, __selected_extraInitializers), __runInitializers(this, _dateFilter_initializers, null)));
+      __privateSet(this, _orientation_accessor_storage, (__runInitializers(this, _dateFilter_extraInitializers), __runInitializers(this, _orientation_initializers, "horizontal")));
+      __privateSet(this, _weekNumbers_accessor_storage, (__runInitializers(this, _orientation_extraInitializers), __runInitializers(this, _weekNumbers_initializers, false)));
+      this._dateAdapter = (__runInitializers(this, _weekNumbers_extraInitializers), readConfig().datetime?.dateAdapter ?? defaultDateAdapter);
+      __privateSet(this, __activeDate_accessor_storage, __runInitializers(this, __activeDate_initializers, this._dateAdapter.today()));
+      this._wideInternal = (__runInitializers(this, __activeDate_extraInitializers), false);
+      __privateSet(this, __calendarView_accessor_storage, __runInitializers(this, __calendarView_initializers, "day"));
+      this._nextCalendarView = (__runInitializers(this, __calendarView_extraInitializers), "day");
+      this._keyboardNavigationDayViewParameters = {
+        firstDayInView: null,
+        lastDayInView: null,
+        firstMonthOffset: 0,
+        firstMonthLength: 0,
+        secondMonthOffset: 0
+      };
+      this._weeks = [];
+      this._monthNames = this._dateAdapter.getMonthNames("long");
+      this._enhancedVariant = false;
+      this._resetFocus = false;
+      this._containingFocus = false;
+      __privateSet(this, __initialized_accessor_storage, __runInitializers(this, __initialized_initializers, false));
+      this._language = (__runInitializers(this, __initialized_extraInitializers), new SbbLanguageController(this).withHandler(() => {
+        this._monthNames = this._dateAdapter.getMonthNames("long");
+        this._createMonthRows();
+      }));
+      this._mediaMatcher = new SbbMediaMatcherController(this, {
+        [SbbMediaQueryBreakpointLargeAndAbove]: () => this._init()
+      });
+      this._onSlotChange = () => {
+        this._enhancedVariant = Array.from(this.children).some((c) => c.localName === "sbb-calendar-day");
+        this.toggleState("enhanced", this._enhancedVariant);
+        this._setTabIndex();
+      };
+      this._createMonthRows();
+      this._setWeekdays();
+      this.addEventListener("focusin", () => this._containingFocus = true);
+      this.addEventListener("focusout", () => this._containingFocus = false);
+      this.addEventListener("click", (e) => {
+        const day = e.target.closest("sbb-calendar-day");
+        if (day) {
+          this._selectDate(day.value);
+        }
+      });
+      this.addEventListener("keydown", (e) => {
+        if (e.target.localName === "sbb-calendar-day") {
+          this._handleKeyboardEvent(e, this._mapDateToDay(e.target.value));
+        }
+      });
+    }
+    /** If set to true, two months are displayed */
+    get wide() {
+      return __privateGet(this, _wide_accessor_storage);
+    }
+    set wide(value) {
+      __privateSet(this, _wide_accessor_storage, value);
+    }
+    /** The initial view of the calendar which should be displayed on opening. */
+    get view() {
+      return __privateGet(this, _view_accessor_storage);
+    }
+    set view(value) {
+      __privateSet(this, _view_accessor_storage, value);
+    }
+    /**
+     * The minimum valid date. Accepts a date object or null.
+     * Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.
+     */
+    get min() {
+      return __privateGet(this, _min_accessor_storage);
+    }
+    set min(value) {
+      __privateSet(this, _min_accessor_storage, value);
+    }
+    /**
+     * The maximum valid date. Accepts a date object or null.
+     * Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.
+     */
+    get max() {
+      return __privateGet(this, _max_accessor_storage);
+    }
+    set max(value) {
+      __privateSet(this, _max_accessor_storage, value);
+    }
+    /** Whether the calendar allows for multiple date selection. */
+    get multiple() {
+      return __privateGet(this, _multiple_accessor_storage);
+    }
+    set multiple(value) {
+      __privateSet(this, _multiple_accessor_storage, value);
+    }
+    /**
+     * The selected date: accepts a date object, or, if `multiple`, an array of dates.
+     */
+    set selected(value) {
+      if (Array.isArray(value)) {
+        this._selected = value.map((dateLike) => this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(dateLike))).filter((date) => date !== null).filter((date) => !this._isDayInRange(this._dateAdapter.toIso8601(date)) || this._dateFilter(date));
+      } else {
+        const selectedDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        if (!!selectedDate && (!this._isDayInRange(this._dateAdapter.toIso8601(selectedDate)) || this._dateFilter(selectedDate))) {
+          this._selected = selectedDate;
+        } else {
+          this._selected = null;
+        }
+      }
+    }
+    get selected() {
+      return this._selected;
+    }
+    get _selected() {
+      return __privateGet(this, __selected_accessor_storage);
+    }
+    set _selected(value) {
+      __privateSet(this, __selected_accessor_storage, value);
+    }
+    /** 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 orientation of days in the calendar. */
+    get orientation() {
+      return __privateGet(this, _orientation_accessor_storage);
+    }
+    set orientation(value) {
+      __privateSet(this, _orientation_accessor_storage, value);
+    }
+    /** Whether it has to display the week numbers in addition to week days. */
+    get weekNumbers() {
+      return __privateGet(this, _weekNumbers_accessor_storage);
+    }
+    set weekNumbers(value) {
+      __privateSet(this, _weekNumbers_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 current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */
+    set _wide(wide) {
+      this.toggleState("wide", wide);
+      this._wideInternal = wide;
+    }
+    get _wide() {
+      return this._wideInternal;
+    }
+    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._calendarView === "day" ? this._getRootForQuerySelector()?.querySelectorAll("sbb-calendar-day") : this.shadowRoot?.querySelectorAll(".sbb-calendar__cell")) ?? []);
+    }
+    get _initialized() {
+      return __privateGet(this, __initialized_accessor_storage);
+    }
+    set _initialized(value) {
+      __privateSet(this, __initialized_accessor_storage, value);
+    }
+    _getRootForQuerySelector() {
+      return this._enhancedVariant ? this : this.shadowRoot;
+    }
+    _dateFilter(date) {
+      return this.dateFilter?.(date) ?? true;
+    }
+    /** Resets the active month according to the new state of the calendar. */
+    resetPosition() {
+      this._resetCalendarView();
+      this._init();
+    }
+    connectedCallback() {
+      super.connectedCallback();
+      this.resetPosition();
+      this.shadowRoot?.addEventListener("slotchange", this._onSlotChange, { capture: true });
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this.shadowRoot?.removeEventListener("slotchange", this._onSlotChange, { capture: true });
+    }
+    /** @internal */
+    focus() {
+      this._resetFocus = true;
+      this._focusCell();
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (!this._initialized) {
+        return;
+      }
+      if (changedProperties.has("wide") || changedProperties.has("orientation")) {
+        this.resetPosition();
+      }
+      if (changedProperties.has("view")) {
+        this._setChosenYear();
+        this._chosenMonth = void 0;
+        this._nextCalendarView = this._calendarView = this.view;
+      }
+    }
+    updated(changedProperties) {
+      super.updated(changedProperties);
+      this._setTabIndex();
+      this._focusCell();
+    }
+    /**
+     * The `_selected` state should be adapted when the `multiple` property changes:
+     *   - if it changes to true, the '_selected' is set to an array;
+     *   - if it changes to false, the first available option is set as 'value' otherwise it's set to null.
+     */
+    _onMultipleChanged(isMultiple) {
+      if (isMultiple && !Array.isArray(this._selected)) {
+        this._selected = this._selected ? [this._selected] : [];
+      }
+      if (!isMultiple && Array.isArray(this._selected)) {
+        this._selected = this._selected.length ? this._selected[0] : null;
+      }
+    }
+    /** Initializes the component. */
+    _init(activeDate) {
+      if (isServer) {
+        return;
+      } else if (this.hydrationRequired) {
+        this.hydrationComplete.then(() => this._init());
+        return;
+      }
+      if (activeDate) {
+        this._assignActiveDate(activeDate);
+      }
+      this._wide = (this._mediaMatcher.matches(SbbMediaQueryBreakpointLargeAndAbove) ?? false) && this.wide;
+      this._weeks = this._createWeekRows(this._activeDate);
+      this._years = this._createYearRows();
+      this._weekNumbers = this._createWeekNumbers(this._activeDate);
+      this._nextMonthWeeks = [[]];
+      this._nextMonthYears = [[]];
+      if (this._wide) {
+        const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);
+        this._nextMonthWeeks = this._createWeekRows(nextMonthDate, true);
+        this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);
+        this._nextMonthWeekNumbers = this._createWeekNumbers(nextMonthDate);
+      }
+      this._initialized = true;
+    }
+    /** Focuses on a day cell prioritizing the selected day, the current day, and lastly, the first selectable day. */
+    _focusCell() {
+      if (this._resetFocus) {
+        this._getFirstFocusable()?.focus();
+        this._resetFocus = false;
+      }
+    }
+    /** Creates the array of weekdays. */
+    _setWeekdays() {
+      const narrowWeekdays = this._dateAdapter.getDayOfWeekNames("narrow");
+      const 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));
+    }
+    /**
+     * Given a date, it returns the week numbers for the month the date belongs to.
+     * TODO: check if date-fns can be replaced with custom logic.
+     *
+     * Since the calculation is not simple (see https://en.wikipedia.org/wiki/Week#Numbering),
+     * the date-fns library has been used this way:
+     * the first and the last day of the month are calculated and then passed to the `eachWeekOfInterval` function,
+     * which returns an array containing the starting day of every ISO week of the month,
+     * considering Monday as the first day.
+     * Then, this array is mapped via the `getWeek` function, which returns the ISO week number for that date.
+     */
+    _createWeekNumbers(date) {
+      return eachWeekOfInterval({ start: startOfMonth(date), end: endOfMonth(date) }, { weekStartsOn: 1 }).map((firstDayOfWeek) => getWeek(firstDayOfWeek, { weekStartsOn: 1, firstWeekContainsDate: 4 }));
+    }
+    /** Creates the rows along the horizontal direction and sets the parameters used in keyboard navigation. */
+    _createWeekRows(value, isSecondMonthInView = false) {
+      const daysInMonth = this._dateAdapter.getNumDaysInMonth(value);
+      const weekOffset = this._dateAdapter.getFirstWeekOffset(value);
+      if (!isSecondMonthInView) {
+        this._keyboardNavigationDayViewParameters.firstMonthLength = daysInMonth;
+        this._keyboardNavigationDayViewParameters.firstMonthOffset = weekOffset;
+        this._keyboardNavigationDayViewParameters.firstDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), 1));
+        this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), daysInMonth));
+      } else {
+        this._keyboardNavigationDayViewParameters.secondMonthOffset = weekOffset;
+        this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), daysInMonth));
+      }
+      return this.orientation === "horizontal" ? this._createWeekRowsHorizontal(value, daysInMonth, weekOffset) : this._createWeekRowsVertical(value, daysInMonth, weekOffset);
+    }
+    /**
+     * Creates the rows for each week in orientation='horizontal'.
+     *
+     * Iterates through the days of the months, creates a Day object for each and pushes it into and array.
+     * Each seven days (considering the offset at the beginning of the month) restarts from an empty array.
+     *
+     * The result is a matrix in which every row is a week (or part of it, considering offset).
+     */
+    _createWeekRowsHorizontal(value, daysInMonth, weekOffset) {
+      const weeks = [[]];
+      for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {
+        if (cell === DAYS_PER_ROW) {
+          weeks.push([]);
+          cell = 0;
+        }
+        const date = this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), i + 1);
+        weeks[weeks.length - 1].push(this._mapDateToDay(date));
+      }
+      return weeks;
+    }
+    /**
+     * Creates the rows for each week in orientation='vertical'.
+     *
+     * Creates a matrix with seven empty rows.
+     * Iterates through the days of the months, creates a Day object for each
+     * and pushes it into the correct array considering the offset at the beginning of the month.
+     * Each seven days (including offset) restarts from the first.
+     *
+     * The result is a matrix in which every row is a set of weekdays, so:
+     * - row 0: all the Mondays;
+     * - row 1: all the Tuesdays;
+     * - ...
+     * - row 7: all the Sundays.
+     */
+    _createWeekRowsVertical(value, daysInMonth, weekOffset) {
+      const weeks = Array.from({ length: DAYS_PER_ROW }, () => []);
+      for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {
+        if (cell === DAYS_PER_ROW) {
+          cell = 0;
+        }
+        const date = this._dateAdapter.createDate(this._dateAdapter.getYear(value), this._dateAdapter.getMonth(value), i + 1);
+        weeks[cell].push(this._mapDateToDay(date));
+      }
+      return weeks;
+    }
+    _mapDateToDay(date) {
+      const isoDate = this._dateAdapter.toIso8601(date);
+      return {
+        value: isoDate,
+        dateValue: date,
+        dayValue: String(this._dateAdapter.getDate(date)),
+        monthValue: String(this._dateAdapter.getMonth(date)),
+        yearValue: String(this._dateAdapter.getYear(date)),
+        weekValue: getWeek(isoDate, { weekStartsOn: 1, firstWeekContainsDate: 4 }),
+        weekDayValue: this._dateAdapter.getDayOfWeek(date)
+      };
+    }
+    /** Force the conversion to ISO8601 formatted string. */
+    _mapValueToISODate(value) {
+      return typeof value === "string" ? value : this._dateAdapter.toIso8601(value);
+    }
+    /** Creates the rows for the month selection view. */
+    _createMonthRows() {
+      const 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(dateString) {
+      if (!this.min && !this.max) {
+        return true;
+      }
+      const date = this._dateAdapter.deserialize(dateString);
+      return this._dateAdapter.sameDate(date, this._dateAdapter.clampDate(date, this.min, this.max));
+    }
+    /** Checks if date is within the min-max range in month view. */
+    _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);
+    }
+    /** Checks if date is within the min-max range in year view. */
+    _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);
+    }
+    // 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;
+    }
+    // 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;
+    }
+    /** Emits the selected date and sets it internally. */
+    _selectDate(day) {
+      this._chosenMonth = void 0;
+      this._setChosenYear();
+      if (this.multiple) {
+        if (this._selected && this._selected.length > 0) {
+          const indexOfSelectedDay = this._selected.findIndex((sel) => this._dateAdapter.compareDate(sel, day) === 0);
+          if (indexOfSelectedDay !== -1) {
+            this._selected = this._selected.filter((_, i) => i !== indexOfSelectedDay);
+          } else {
+            this._selected = [...this._selected, day];
+          }
+        } else {
+          this._selected = [day];
+        }
+        this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)));
+      } else {
+        if (!this._selected || this._dateAdapter.compareDate(this._selected, day) !== 0) {
+          this._selected = day;
+          this._emitDateSelectedEvent(this._dateAdapter.deserialize(day));
+        }
+      }
+    }
+    /**
+     * Handle multiple dates selection via weekNumber / weekDay buttons:
+     * - if Cmd or Ctrl are pressed, add the new date to the current ones;
+     * - if not,
+     *     - if the new dates are the same of the current ones, it means that the same button has been clicked twice, so do nothing;
+     *     - if not, the selected dates are the new ones.
+     */
+    _selectMultipleDates(days) {
+      const enabledDays = this._cells.filter((e) => !e.disabled).map((e) => this._mapValueToISODate(e.value));
+      const daysToAdd = days.map((e) => e.value).filter((isoDate) => enabledDays.includes(isoDate));
+      const daysToAddSet = new Set(daysToAdd);
+      const selectedSet = new Set(this._selected.map((s) => this._dateAdapter.toIso8601(s)));
+      const selStrings = this._updateSelectedWithMultipleDates(daysToAdd, daysToAddSet, selectedSet);
+      this._selected = selStrings.map((s) => this._dateAdapter.deserialize(s));
+      this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)));
+    }
+    /**
+     * Emits the dateselected event given the detail (as T or T[] based on the value of the multiple flag).
+     */
+    _emitDateSelectedEvent(detail) {
+      this.dispatchEvent(new CustomEvent("dateselected", {
+        detail,
+        composed: true,
+        bubbles: true
+      }));
+    }
+    _emitMonthChange() {
+      const monthchange = (this.wide ? [...this._weeks, ...this._nextMonthWeeks] : this._weeks).flat().sort((a, b) => a.value.localeCompare(b.value));
+      this.dispatchEvent(new SbbMonthChangeEvent(monthchange));
+    }
+    /**
+     * In case of multiple selection, newly added days must be added to the existing ones, without duplication.
+     * If the days to add are exactly the same as the selected ones, the set must be emptied.
+     */
+    _updateSelectedWithMultipleDates(daysToAdd, daysToAddSet, selectedSet) {
+      if (daysToAdd.every((day) => selectedSet.has(day))) {
+        daysToAddSet.forEach((day) => selectedSet.delete(day));
+      } else {
+        daysToAddSet.forEach((day) => selectedSet.add(day));
+      }
+      return Array.from(selectedSet);
+    }
+    _setChosenYear() {
+      if (this.view === "month") {
+        let selectedDate;
+        if (this.multiple) {
+          selectedDate = this.selected.at(-1);
+        } else {
+          selectedDate = this.selected;
+        }
+        this._chosenYear = this._dateAdapter.getYear(selectedDate ?? this._dateAdapter.today());
+      } else {
+        this._chosenYear = void 0;
+      }
+    }
+    _assignActiveDate(date) {
+      if (this.min && this._dateAdapter.compareDate(this.min, date) > 0) {
+        this._activeDate = this.min;
+        return;
+      }
+      if (this.max && this._dateAdapter.compareDate(this.max, date) < 0) {
+        this._activeDate = this.max;
+        return;
+      }
+      this._activeDate = date;
+    }
+    /** Goes to the month identified by the shift. */
+    _goToDifferentMonth(months) {
+      this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));
+      this._emitMonthChange();
+    }
+    _goToDifferentYear(years) {
+      this._chosenYear += years;
+      this._activeDate = this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate));
+      this._init();
+    }
+    _goToDifferentYearRange(years) {
+      this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));
+    }
+    _prevDisabled(prevDate) {
+      if (!this.min) {
+        return false;
+      }
+      return this._dateAdapter.compareDate(prevDate, this.min) < 0;
+    }
+    _nextDisabled(nextDate) {
+      if (!this.max) {
+        return false;
+      }
+      return this._dateAdapter.compareDate(nextDate, this.max) > 0;
+    }
+    /** Checks if the "previous month" button should be disabled. */
+    _previousMonthDisabled() {
+      const prevMonth = this._dateAdapter.addCalendarDays(this._activeDate, this._dateAdapter.getDate(this._activeDate) * -1);
+      return this._prevDisabled(prevMonth);
+    }
+    /** Checks if the "next month" button should be disabled. */
+    _nextMonthDisabled() {
+      let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);
+      nextMonth = this._dateAdapter.createDate(this._dateAdapter.getYear(nextMonth), this._dateAdapter.getMonth(nextMonth), 1);
+      return this._nextDisabled(nextMonth);
+    }
+    /** Checks if the "previous year" button should be disabled. */
+    _previousYearDisabled() {
+      const prevYear = this._dateAdapter.createDate(this._dateAdapter.getYear(this._activeDate) - 1, 12, 31);
+      return this._prevDisabled(prevYear);
+    }
+    /** Checks if the "next year" button should be disabled. */
+    _nextYearDisabled() {
+      const nextYear = this._dateAdapter.createDate(this._dateAdapter.getYear(this._activeDate) + (this._wide ? 2 : 1), 1, 1);
+      return this._nextDisabled(nextYear);
+    }
+    /** Checks if the "previous year" button should be disabled in year view. */
+    _previousYearRangeDisabled() {
+      const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);
+      return this._prevDisabled(prevYear);
+    }
+    /** Checks if the "next year" button should be disabled in year view. */
+    _nextYearRangeDisabled() {
+      const years = this._wide ? this._nextMonthYears : this._years;
+      const lastYearRange = years[years.length - 1];
+      const lastYear = lastYearRange[lastYearRange.length - 1];
+      const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);
+      return this._nextDisabled(nextYear);
+    }
+    _handleTableBlur(eventTarget) {
+      if (eventTarget?.localName !== "sbb-calendar-day") {
+        this._setTabIndex();
+      }
+    }
+    _setTabIndex() {
+      const query = this._calendarView === "day" ? "sbb-calendar-day" : ".sbb-calendar__cell";
+      Array.from(this._getRootForQuerySelector().querySelectorAll(`${query}[tabindex="0"]`) ?? []).forEach((day) => day.tabIndex = -1);
+      const firstFocusable = this._getFirstFocusable();
+      if (firstFocusable) {
+        firstFocusable.tabIndex = 0;
+      }
+    }
+    /** Get the element in the calendar to assign focus. */
+    _getFirstFocusable() {
+      const root = this._getRootForQuerySelector();
+      if (this._calendarView === "day") {
+        const selectedOrCurrent = root.querySelector(":is(:state(selected),[state--selected])") ?? root.querySelector(":is(:state(current),[state--current])");
+        return selectedOrCurrent && !selectedOrCurrent.disabled ? selectedOrCurrent : this._getFirstFocusableDay();
+      } else {
+        const selectedOrCurrent = this.shadowRoot?.querySelector(".sbb-calendar__cell-current");
+        return selectedOrCurrent && !selectedOrCurrent.disabled ? selectedOrCurrent : this.shadowRoot.querySelector(".sbb-calendar__cell:not([disabled])");
+      }
+    }
+    /**
+     * In `day` view in `vertical` orientation,
+     * if the first of the month is not a Monday, it is not the first rendered element in the table,
+     * so `this.shadowRoot!.querySelector('.sbb-calendar__cell:not([disabled])')` will return a wrong value.
+     *
+     * To solve this, the element with the lowest `value` is taken (ISO String are ordered).
+     */
+    _getFirstFocusableDay() {
+      const daysInView = Array.from(this._getRootForQuerySelector().querySelectorAll("sbb-calendar-day:not([disabled])"));
+      if (!daysInView || daysInView.length === 0) {
+        return null;
+      } else {
+        const firstElement = daysInView.map((e) => this._dateAdapter.toIso8601(e.value)).sort()[0];
+        return this._getRootForQuerySelector().querySelector(`sbb-calendar-day[slot="${firstElement}"]`);
+      }
+    }
+    _handleKeyboardEvent(event, day) {
+      if (isArrowKeyOrPageKeysPressed(event)) {
+        event.preventDefault();
+      }
+      const cells = this._cells;
+      const index = cells.findIndex((e) => e === event.target);
+      let nextEl;
+      if (day) {
+        nextEl = this._navigateByKeyboardDayView(event, index, cells, day);
+      } else {
+        nextEl = this._navigateByKeyboard(event, index, cells);
+      }
+      const activeEl = (this._enhancedVariant ? document : this.shadowRoot).activeElement;
+      if (nextEl !== activeEl) {
+        nextEl.tabIndex = 0;
+        nextEl?.focus();
+        activeEl.tabIndex = -1;
+      }
+    }
+    _navigateByKeyboardDayView(evt, index, cells, day) {
+      const arrowsOffset = this.orientation === "horizontal" ? { leftRight: 1, upDown: DAYS_PER_ROW } : { leftRight: DAYS_PER_ROW, upDown: 1 };
+      const offsetForVertical = index < this._keyboardNavigationDayViewParameters.firstMonthLength ? this._keyboardNavigationDayViewParameters.firstMonthOffset : this._keyboardNavigationDayViewParameters.secondMonthOffset;
+      switch (evt.key) {
+        case "ArrowUp":
+          return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.upDown);
+        case "ArrowDown":
+          return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.upDown);
+        case "ArrowLeft":
+          return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.leftRight);
+        case "ArrowRight":
+          return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.leftRight);
+        case "PageUp": {
+          if (this.orientation === "horizontal") {
+            const firstOfWeek = +day.dayValue % DAYS_PER_ROW || DAYS_PER_ROW;
+            const delta = firstOfWeek - +day.dayValue;
+            return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);
+          } else {
+            const weekNumber = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);
+            const firstOfWeek = (weekNumber - 1) * DAYS_PER_ROW - offsetForVertical + 1;
+            const delta = firstOfWeek - +day.dayValue;
+            return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);
+          }
+        }
+        case "PageDown": {
+          if (this.orientation === "horizontal") {
+            const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;
+            const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;
+            const firstNextMonth = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);
+            const lastOfMonth = this._dateAdapter.getDate(this._dateAdapter.addCalendarDays(firstNextMonth, -1));
+            const delta = Math.trunc((lastOfMonth - +day.dayValue) / DAYS_PER_ROW) * DAYS_PER_ROW;
+            return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);
+          } else {
+            const weekNumber = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);
+            const lastOfWeek = weekNumber * DAYS_PER_ROW - offsetForVertical;
+            const delta = lastOfWeek - +day.dayValue;
+            return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);
+          }
+        }
+        case "Home": {
+          return this._findDayFirst(cells, index, day, 1);
+        }
+        case "End": {
+          const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;
+          const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;
+          const firstNextMonth = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);
+          return this._findDayLast(cells, index, firstNextMonth);
+        }
+        default:
+          return cells[index];
+      }
+    }
+    _isDayOutOfView(date) {
+      return date < this._keyboardNavigationDayViewParameters.firstDayInView || date > this._keyboardNavigationDayViewParameters.lastDayInView;
+    }
+    _findDayArrows(cells, index, date, delta) {
+      const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(date, delta));
+      if (this._isDayOutOfView(newDateValue)) {
+        return cells[index];
+      }
+      const nextCell = cells.find((e) => this._mapValueToISODate(e.value) === newDateValue);
+      if (!nextCell || nextCell.disabled) {
+        return this._findDayArrows(cells, index, this._dateAdapter.deserialize(newDateValue), delta);
+      }
+      return nextCell;
+    }
+    _findDayPageUpDown(cells, index, day, delta, deltaIfDisabled) {
+      const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(day.dateValue, delta));
+      if (this._isDayOutOfView(newDateValue)) {
+        return cells[index];
+      }
+      const nextCell = cells.find((e) => this._mapValueToISODate(e.value) === newDateValue);
+      if (!nextCell || nextCell.disabled) {
+        return this._findDayPageUpDown(cells, index, day, delta + deltaIfDisabled, deltaIfDisabled);
+      }
+      return nextCell;
+    }
+    _findDayFirst(cells, index, day, date) {
+      const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.createDate(+day.yearValue, +day.monthValue, date));
+      if (this._isDayOutOfView(newDateValue)) {
+        return cells[index];
+      }
+      const nextCell = cells.find((e) => this._mapValueToISODate(e.value) === newDateValue);
+      if (!nextCell || nextCell.disabled) {
+        return this._findDayFirst(cells, index, day, date + 1);
+      }
+      return nextCell;
+    }
+    _findDayLast(cells, index, firstNextMonth) {
+      const newDateValue = this._dateAdapter.toIso8601(this._dateAdapter.addCalendarDays(firstNextMonth, -1));
+      if (this._isDayOutOfView(newDateValue)) {
+        return cells[index];
+      }
+      const nextCell = cells.find((e) => this._mapValueToISODate(e.value) === newDateValue);
+      if (!nextCell || nextCell.disabled) {
+        return this._findDayLast(cells, index, this._dateAdapter.deserialize(newDateValue));
+      }
+      return nextCell;
+    }
+    /**
+     * Gets the index of the element to move to, based on a list of elements (which can be potentially disabled),
+     * the keyboard input and the position of the current element in the list.
+     * In the day view, the `day?: Day` parameter is mandatory for calculation,
+     * while in month and year view it's not due to the fixed amount of rendered cells.
+     */
+    _navigateByKeyboard(evt, index, cells) {
+      const { elementIndexForWideMode, offsetForWideMode, lastElementIndexForWideMode, verticalOffset } = this._calculateParametersForKeyboardNavigation(index, this._calendarView === "year");
+      switch (evt.key) {
+        case "ArrowUp":
+          return this._findNext(cells, index, -verticalOffset);
+        case "ArrowDown":
+          return this._findNext(cells, index, verticalOffset);
+        case "ArrowLeft":
+          return this._findNext(cells, index, -1);
+        case "ArrowRight":
+          return this._findNext(cells, index, 1);
+        case "Home":
+          return this._findFirst(cells, offsetForWideMode);
+        case "PageUp":
+          return this._findFirstOnColumn(cells, elementIndexForWideMode, offsetForWideMode, verticalOffset);
+        case "PageDown":
+          return this._findLastOnColumn(cells, index, lastElementIndexForWideMode, verticalOffset);
+        case "End":
+          return this._findLast(cells, lastElementIndexForWideMode - 1);
+        default:
+          return cells[index];
+      }
+    }
+    /**
+     * Calculates the parameters needed in keyboard navigation in year and month view.
+     * @param index The starting element's index in the cell array.
+     * @param isYearView Whether the displayed `view` is the year one.
+     */
+    _calculateParametersForKeyboardNavigation(index, isYearView) {
+      const elementsPerPage = isYearView ? YEARS_PER_PAGE : MONTHS_PER_PAGE;
+      const offset = Math.trunc(index / elementsPerPage) * elementsPerPage;
+      const indexInView = offset === 0 ? index : index - elementsPerPage;
+      return {
+        verticalOffset: isYearView ? YEARS_PER_ROW : MONTHS_PER_ROW,
+        elementIndexForWideMode: indexInView,
+        offsetForWideMode: index - indexInView,
+        lastElementIndexForWideMode: offset === 0 ? elementsPerPage : elementsPerPage * 2
+      };
+    }
+    /**
+     * Gets the next element of the provided array starting from `index` by adding `delta`.
+     * If the found element is disabled, it continues adding `delta` until it finds an enabled one in the array bounds.
+     */
+    _findNext(days, index, delta) {
+      let nextIndex = index + delta;
+      while (nextIndex < days.length && days[nextIndex]?.disabled) {
+        nextIndex += delta;
+      }
+      return days[nextIndex] ?? days[index];
+    }
+    /** Find the first enabled element in the provided array. */
+    _findFirst(days, firstOfCurrentMonth) {
+      return !days[firstOfCurrentMonth].disabled ? days[firstOfCurrentMonth] : this._findNext(days, firstOfCurrentMonth, 1);
+    }
+    /** Find the last enabled element in the provided array. */
+    _findLast(days, lastOfCurrentMonth) {
+      return !days[lastOfCurrentMonth].disabled ? days[lastOfCurrentMonth] : this._findNext(days, lastOfCurrentMonth, -1);
+    }
+    /** Find the first enabled element in the same column of the provided array. */
+    _findFirstOnColumn(days, index, offset, verticalOffset) {
+      const nextIndex = index % verticalOffset + offset;
+      return !days[nextIndex].disabled ? days[nextIndex] : this._findNext(days, nextIndex, verticalOffset);
+    }
+    /** Find the last enabled element in the same column of the provided array. */
+    _findLastOnColumn(days, index, offset, verticalOffset) {
+      const nextIndex = index + Math.trunc((offset - index - 1) / verticalOffset) * verticalOffset;
+      return !days[nextIndex].disabled ? days[nextIndex] : this._findNext(days, nextIndex, -verticalOffset);
+    }
+    _resetCalendarViewAndEmitMonthChange(initTransition = false) {
+      this._resetCalendarView(initTransition);
+      this._emitMonthChange();
+    }
+    _resetCalendarView(initTransition = false) {
+      if (this._containingFocus) {
+        this._resetFocus = true;
+      }
+      this._activeDate = (this.multiple ? this._selected.at(-1) : this._selected) ?? this._dateAdapter.today();
+      this._setChosenYear();
+      this._chosenMonth = void 0;
+      this._init();
+      this._nextCalendarView = this._calendarView = this.view;
+      if (initTransition) {
+        this._startTableTransition();
+      }
+    }
+    /** Render the view for the day selection. */
+    _renderDayView() {
+      const nextMonthActiveDate = this._wide ? this._dateAdapter.addCalendarMonths(this._activeDate, 1) : void 0;
+      return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentMonth(-1), i18nPreviousMonth[this._language.current], this._previousMonthDisabled())}
+        <div class="sbb-calendar__controls-month">
+          ${this._createLabelForDayView(this._activeDate)}
+          ${this._wide ? this._createLabelForDayView(nextMonthActiveDate) : nothing}
+          <sbb-screen-reader-only role="status">
+            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate)}
+          </sbb-screen-reader-only>
+        </div>
+        ${this._getArrow("right", () => this._goToDifferentMonth(1), i18nNextMonth[this._language.current], this._nextMonthDisabled())}
+      </div>
+      <div class="sbb-calendar__table-overflow-break">
+        <div class="sbb-calendar__table-container sbb-calendar__table-day-view">
+          ${this.orientation === "horizontal" ? html`
+                ${this._createDayTable(this._weeks, this._weekNumbers)}
+                ${this._wide ? this._createDayTable(this._nextMonthWeeks, this._nextMonthWeekNumbers, true) : nothing}
+              ` : html`
+                ${this._createDayTableVertical(this._weeks, this._weekNumbers)}
+                ${this._wide ? this._createDayTableVertical(this._nextMonthWeeks, this._nextMonthWeekNumbers, nextMonthActiveDate) : nothing}
+              `}
+        </div>
+      </div>
+    `;
+    }
+    /** Creates the label with the month for the daily view. */
+    _createLabelForDayView(d) {
+      const monthLabel = `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)}`;
+      return html`
+      <button
+        type="button"
+        class="sbb-calendar__date-selection sbb-calendar__controls-change-date"
+        aria-label="${i18nYearMonthSelection[this._language.current]} ${monthLabel}"
+        @click=${() => {
+        this._resetFocus = true;
+        this._nextCalendarView = "year";
+        this._startTableTransition();
+      }}
+      >
+        ${monthLabel}
+        <sbb-icon name="chevron-small-down-small"></sbb-icon>
+      </button>
+    `;
+    }
+    /** Creates the aria-label for the daily view. */
+    _createAriaLabelForDayView(...dates) {
+      let monthLabel = "";
+      for (const d of dates) {
+        if (d) {
+          monthLabel += `${this._monthNames[this._dateAdapter.getMonth(d) - 1]} ${this._dateAdapter.getYear(d)} `;
+        }
+      }
+      return monthLabel;
+    }
+    /** Creates the calendar table for the daily view. */
+    _createDayTable(weeks, weekNumbers, isWideNextMonth = false) {
+      const weeksForSelectMultipleWeekNumbers = (this._wide ? [...this._weeks, ...this._nextMonthWeeks] : isWideNextMonth ? this._nextMonthWeeks : this._weeks).flat();
+      const weeksForSelectMultipleWeekDays = (isWideNextMonth ? this._nextMonthWeeks : this._weeks).flat();
+      return html`
+      <table
+        class="sbb-calendar__table"
+        @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        <thead class="sbb-calendar__table-header">
+          <tr>
+            ${this.weekNumbers ? html`<th class="sbb-calendar__table-header-cell"></th>` : nothing}
+            ${this._weekdays.map((day, index) => html`
+                <th class="sbb-calendar__table-header-cell">
+                  ${this.multiple ? html`
+                        <button
+                          class="sbb-calendar__header-cell sbb-calendar__weekday"
+                          aria-label=${day.long}
+                          @click=${() => {
+        const days = weeksForSelectMultipleWeekDays.filter((day2) => day2.weekDayValue === (index + 1) % 7);
+        this._selectMultipleDates(days);
+      }}
+                        >
+                          ${day.narrow}
+                        </button>
+                      ` : html`
+                        <sbb-screen-reader-only>${day.long}</sbb-screen-reader-only>
+                        <span aria-hidden="true">${day.narrow}</span>
+                      `}
+                </th>
+              `)}
+          </tr>
+        </thead>
+        <tbody class="sbb-calendar__table-body">
+          ${weeks.map((week, rowIndex) => {
+        const firstRowOffset = DAYS_PER_ROW - week.length;
+        if (rowIndex === 0 && firstRowOffset) {
+          return html`
+                <tr>
+                  ${this.weekNumbers ? html`
+                        <td class="sbb-calendar__table-header-cell-vertical">
+                          ${this.multiple ? html`
+                                <button
+                                  class="sbb-calendar__header-cell sbb-calendar__weekday"
+                                  aria-label=${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[0]}`}
+                                  @click=${() => {
+            const days = weeksForSelectMultipleWeekNumbers.filter((day) => day.weekValue === weekNumbers[0]);
+            this._selectMultipleDates(days);
+          }}
+                                >
+                                  ${weekNumbers[0]}
+                                </button>
+                              ` : html`
+                                <sbb-screen-reader-only
+                                  >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[0]}`}</sbb-screen-reader-only
+                                >
+                                <span aria-hidden="true">${weekNumbers[0]}</span>
+                              `}
+                        </td>
+                      ` : nothing}
+                  ${[...Array(firstRowOffset).keys()].map(() => html`<td class="sbb-calendar__table-data"></td>`)}
+                  ${this._createDayCells(week)}
+                </tr>
+              `;
+        }
+        return html`
+              <tr>
+                ${this.weekNumbers ? html`
+                      <td class="sbb-calendar__table-header-cell-vertical">
+                        ${this.multiple ? html`
+                              <button
+                                class="sbb-calendar__header-cell sbb-calendar__weekday"
+                                aria-label=${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[rowIndex]}`}
+                                @click=${() => {
+          const days = weeksForSelectMultipleWeekNumbers.filter((day) => day.weekValue === weekNumbers[rowIndex]);
+          this._selectMultipleDates(days);
+        }}
+                              >
+                                ${weekNumbers[rowIndex]}
+                              </button>
+                            ` : html`
+                              <sbb-screen-reader-only
+                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[rowIndex]}`}</sbb-screen-reader-only
+                              >
+                              <span aria-hidden="true">${weekNumbers[rowIndex]}</span>
+                            `}
+                      </td>
+                    ` : nothing}
+                ${this._createDayCells(week)}
+              </tr>
+            `;
+      })}
+        </tbody>
+      </table>
+    `;
+    }
+    /** Creates the table in orientation='vertical'. */
+    _createDayTableVertical(weeks, weekNumbers, nextMonthActiveDate) {
+      const weekOffset = this._dateAdapter.getFirstWeekOffset(nextMonthActiveDate ?? this._activeDate);
+      const weeksForSelectMultipleWeekNumbers = (this._wide ? [...this._weeks, ...this._nextMonthWeeks] : nextMonthActiveDate ? this._nextMonthWeeks : this._weeks).flat();
+      return html`
+      <table
+        class="sbb-calendar__table"
+        @focusout=${(event) => this._handleTableBlur(event.relatedTarget)}
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        ${this.weekNumbers ? html`
+              <thead class="sbb-calendar__table-header">
+                <tr>
+                  ${nextMonthActiveDate ? nothing : html`<th class="sbb-calendar__table-data"></th>`}
+                  ${weekNumbers.map((weekNumber) => html`
+                      <th class="sbb-calendar__table-header-cell">
+                        ${this.multiple ? html`
+                              <button
+                                class="sbb-calendar__header-cell sbb-calendar__weekday"
+                                aria-label=${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumber}`}
+                                @click=${() => {
+        const days = weeksForSelectMultipleWeekNumbers.filter((day) => day.weekValue === weekNumber);
+        this._selectMultipleDates(days);
+      }}
+                              >
+                                ${weekNumber}
+                              </button>
+                            ` : html`
+                              <sbb-screen-reader-only
+                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumber}`}</sbb-screen-reader-only
+                              >
+                              <span aria-hidden="true">${weekNumber}</span>
+                            `}
+                      </th>
+                    `)}
+                </tr>
+              </thead>
+            ` : nothing}
+        <tbody class="sbb-calendar__table-body">
+          ${weeks.map((week, rowIndex) => {
+        const weekday = this._weekdays[rowIndex];
+        const selectableDays = this._wide ? [...week, ...this._nextMonthWeeks[rowIndex]] : week;
+        return html`
+              <tr>
+                ${nextMonthActiveDate ? nothing : html`
+                      <td class="sbb-calendar__table-header-cell-vertical">
+                        ${this.multiple ? html`
+                              <button
+                                class="sbb-calendar__header-cell sbb-calendar__weekday"
+                                aria-label=${weekday.long}
+                                @click=${() => this._selectMultipleDates(selectableDays)}
+                              >
+                                ${weekday.narrow}
+                              </button>
+                            ` : html`
+                              <sbb-screen-reader-only>${weekday.long}</sbb-screen-reader-only>
+                              <span aria-hidden="true">${weekday.narrow}</span>
+                            `}
+                      </td>
+                    `}
+                ${rowIndex < weekOffset ? html`<td class="sbb-calendar__table-data"></td>` : nothing}
+                ${this._createDayCells(week)}
+              </tr>
+            `;
+      })}
+        </tbody>
+      </table>
+    `;
+    }
+    /** Creates the cells for the daily view. */
+    _createDayCells(week) {
+      return week.map((day) => {
+        return html`
+        <td class=" sbb-calendar__table-data sbb-calendar__day-cell">
+          <slot name=${day.value}>
+            <sbb-calendar-day
+              slot=${day.value}
+              @click=${() => this._selectDate(day.dateValue)}
+              @keydown=${(evt) => this._handleKeyboardEvent(evt, day)}
+            ></sbb-calendar-day>
+          </slot>
+        </td>
+      `;
+      });
+    }
+    /** Render the view for the month selection. */
+    _renderMonthView() {
+      return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentYear(-1), i18nPreviousYear[this._language.current], this._previousYearDisabled())}
+        <div class="sbb-calendar__controls-month">${this._createLabelForMonthView()}</div>
+        ${this._getArrow("right", () => this._goToDifferentYear(1), i18nNextYear[this._language.current], this._nextYearDisabled())}
+      </div>
+      <div class="sbb-calendar__table-overflow-break">
+        <div class="sbb-calendar__table-container sbb-calendar__table-month-view">
+          ${this._createMonthTable(this._months, this._chosenYear)}
+          ${this._wide ? this._createMonthTable(this._months, this._chosenYear + 1) : nothing}
+        </div>
+      </div>
+    `;
+    }
+    /** Creates the label with the year for the monthly view. */
+    _createLabelForMonthView() {
+      return html` <button
+        type="button"
+        id="sbb-calendar__month-selection"
+        class="sbb-calendar__controls-change-date"
+        aria-label=${`${i18nCalendarDateSelection[this._language.current]} ${this._chosenYear}`}
+        @click=${() => this._resetCalendarViewAndEmitMonthChange(true)}
+      >
+        ${this._chosenYear} ${this._wide ? ` - ${this._chosenYear + 1}` : nothing}
+        <sbb-icon name="chevron-small-up-small"></sbb-icon>
+      </button>
+      <sbb-screen-reader-only role="status"> ${this._chosenYear} </sbb-screen-reader-only>`;
+    }
+    /** Creates the table for the month selection view. */
+    _createMonthTable(months, year) {
+      return html`
+      <table
+        class="sbb-calendar__table"
+        @animationend=${(e) => this._tableAnimationEnd(e)}
+      >
+        ${this._wide ? html`<thead class="sbb-calendar__table-header" aria-hidden="true">
+              <tr>
+                <th class="sbb-calendar__table-header-cell" colspan=${MONTHS_PER_ROW}>${year}</th>
+              </tr>
+            </thead>` : nothing}
+        <tbody class="sbb-calendar__table-body">
+          ${months.map((row) => html`
+              <tr>
+                ${row.map((month) => {
+        let selected;
+        if (this.multiple) {
+          selected = this._selected.find((date) => year === this._dateAdapter.getYear(date) && month.monthValue === this._dateAdapter.getMonth(date)) !== void 0;
+        } else {
+          const selectedMonth = this._selected ? this._dateAdapter.getMonth(this._selected) : void 0;
+          const selectedYear = this._selected ? this._dateAdapter.getYear(this._selected) : void 0;
+          selected = !!this._selected && year === selectedYear && month.monthValue === selectedMonth;
+        }
+        const isOutOfRange = !this._isMonthInRange(month.monthValue, year);
+        const isFilteredOut = !this._isMonthFilteredOut(month.monthValue, year);
+        const isCurrentMonth = year === this._dateAdapter.getYear(this._dateAdapter.today()) && this._dateAdapter.getMonth(this._dateAdapter.today()) === month.monthValue;
+        return html` <td
+                    class=${classMap({
+          "sbb-calendar__table-data": true,
+          "sbb-calendar__table-month": true
+        })}
+                  >
+                    <button
+                      class=${classMap({
+          "sbb-calendar__cell": true,
+          "sbb-calendar__cell-current": isCurrentMonth,
+          "sbb-calendar__crossed-out": !isOutOfRange && isFilteredOut,
+          "sbb-calendar__selected": selected
+        })}
+                      @click=${() => this._onMonthSelection(month.monthValue, year)}
+                      ?disabled=${isOutOfRange || isFilteredOut}
+                      aria-label=${`${month.longValue} ${year}`}
+                      aria-pressed=${selected}
+                      aria-disabled=${String(isOutOfRange || isFilteredOut)}
+                      tabindex="-1"
+                      data-month=${month.monthValue || nothing}
+                      @keydown=${(evt) => this._handleKeyboardEvent(evt)}
+                    >
+                      ${month.value}
+                    </button>
+                  </td>`;
+      })}
+              </tr>
+            `)}
+        </tbody>
+      </table>
+    `;
+    }
+    /** Select the month and change the view to day selection. */
+    _onMonthSelection(month, year) {
+      this._chosenMonth = month;
+      this._nextCalendarView = "day";
+      this._init(this._dateAdapter.createDate(year, this._chosenMonth, this._dateAdapter.getDate(this._activeDate)));
+      this._startTableTransition();
+      this._emitMonthChange();
+    }
+    /** Render the view for the year selection. */
+    _renderYearView() {
+      return html`
+      <div class="sbb-calendar__controls">
+        ${this._getArrow("left", () => this._goToDifferentYearRange(-YEARS_PER_PAGE), i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current], this._previousYearRangeDisabled())}
+        <div class="sbb-calendar__controls-month">${this._createLabelForYearView()}</div>
+        ${this._getArrow("right", () => this._goToDifferentYearRange(YEARS_PER_PAGE), i18nNextYearRange(YEARS_PER_PAGE)[this._language.current], this._nextYearRangeDisabled())}
+      </div>
+      <div class="sbb-calendar__table-overflow-break">
+        <div class="sbb-calendar__table-container sbb-calendar__table-year-view">
+          ${this._createYearTable(this._years)}
+          ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}
+        </div>
+      </div>
+    `;
+    }
+    /** Creates the button arrow for all the views. */
+    _getArrow(direction, click, ariaLabel, disabled) {
+      return html`<sbb-secondary-button
+      size="m"
+      icon-name="chevron-small-${direction}-small"
+      aria-label=${ariaLabel}
+      @click=${click}
+      ?disabled=${disabled}
+      id="sbb-calendar__controls-${direction === "left" ? "previous" : "next"}"
+    ></sbb-secondary-button>`;
+    }
+    /** Creates the label with the year range for the yearly view. */
+    _createLabelForYearView() {
+      const firstYear = this._years.flat()[0];
+      const lastYearArray = (this._wide ? this._nextMonthYears : this._years).flat();
+      const lastYear = lastYearArray[lastYearArray.length - 1];
+      const yearLabel = `${firstYear} - ${lastYear}`;
+      return html`
+      <button
+        type="button"
+        id="sbb-calendar__year-selection"
+        class="sbb-calendar__controls-change-date"
+        aria-label="${i18nCalendarDateSelection[this._language.current]} ${yearLabel}"
+        @click=${() => this._resetCalendarViewAndEmitMonthChange(true)}
+      >
+        ${yearLabel}
+        <sbb-icon name="chevron-small-up-small"></sbb-icon>
+      </button>
+      <sbb-screen-reader-only role="status"> ${yearLabel} </sbb-screen-reader-only>
+    `;
+    }
+    /** Creates the table for the year selection view. */
+    _createYearTable(years, shiftRight = false) {
+      const now = this._dateAdapter.today();
+      return html` <table
+      class="sbb-calendar__table"
+      @animationend=${(e) => this._tableAnimationEnd(e)}
+    >
+      <tbody class="sbb-calendar__table-body">
+        ${years.map((row) => html` <tr>
+              ${row.map((year) => {
+        let selected;
+        if (this.multiple) {
+          selected = this._selected.find((date) => year === this._dateAdapter.getYear(date)) !== void 0;
+        } else {
+          const selectedYear = this._selected ? this._dateAdapter.getYear(this._selected) : void 0;
+          selected = !!this._selected && year === selectedYear;
+        }
+        const isOutOfRange = !this._isYearInRange(year);
+        const isFilteredOut = !this._isYearFilteredOut(year);
+        const isCurrentYear = this._dateAdapter.getYear(now) === year;
+        return html` <td class="sbb-calendar__table-data sbb-calendar__table-year">
+                  <button
+                    class=${classMap({
+          "sbb-calendar__cell": true,
+          "sbb-calendar__cell-current": isCurrentYear,
+          "sbb-calendar__crossed-out": !isOutOfRange && isFilteredOut,
+          "sbb-calendar__selected": selected
+        })}
+                    @click=${() => this._onYearSelection(year, shiftRight)}
+                    ?disabled=${isOutOfRange || isFilteredOut}
+                    aria-label=${year}
+                    aria-pressed=${selected}
+                    aria-disabled=${String(isOutOfRange || isFilteredOut)}
+                    tabindex="-1"
+                    data-year=${year || nothing}
+                    @keydown=${(evt) => this._handleKeyboardEvent(evt)}
+                  >
+                    ${year}
+                  </button>
+                </td>`;
+      })}
+            </tr>`)}
+      </tbody>
+    </table>`;
+    }
+    /** Select the year and change the view to month selection. */
+    _onYearSelection(year, rightSide) {
+      this._chosenYear = rightSide ? year - 1 : year;
+      this._nextCalendarView = "month";
+      this._assignActiveDate(this._dateAdapter.createDate(this._chosenYear, this._dateAdapter.getMonth(this._activeDate), this._dateAdapter.getDate(this._activeDate)));
+      this._startTableTransition();
+    }
+    _getView() {
+      if (isServer || this.hydrationRequired) {
+        return html`${nothing}`;
+      }
+      switch (this._calendarView) {
+        case "year":
+          return this._renderYearView();
+        case "month":
+          return this._renderMonthView();
+        case "day":
+        default:
+          return this._renderDayView();
+      }
+    }
+    _tableAnimationEnd(event) {
+      const table = event.target;
+      if (event.animationName === "hide") {
+        table.classList.remove("sbb-calendar__table-hide");
+        if (this._containingFocus) {
+          this._resetFocus = true;
+        }
+        this._calendarView = this._nextCalendarView;
+      } else if (event.animationName === "show") {
+        this.internals.states.delete("transition");
+      }
+    }
+    _startTableTransition() {
+      this.internals.states.add("transition");
+      this.shadowRoot?.querySelectorAll("table")?.forEach((e) => e.classList.toggle("sbb-calendar__table-hide"));
+    }
+    render() {
+      return html`<div class="sbb-calendar__wrapper">${this._getView()}</div>`;
+    }
+  }, _wide_accessor_storage = new WeakMap(), _view_accessor_storage = new WeakMap(), _min_accessor_storage = new WeakMap(), _max_accessor_storage = new WeakMap(), _multiple_accessor_storage = new WeakMap(), __selected_accessor_storage = new WeakMap(), _dateFilter_accessor_storage = new WeakMap(), _orientation_accessor_storage = new WeakMap(), _weekNumbers_accessor_storage = new WeakMap(), __activeDate_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()];
+    _min_decorators = [plainDate(), property()];
+    _max_decorators = [plainDate(), property()];
+    _multiple_decorators = [forceType(), handleDistinctChange((e, newValue) => e._onMultipleChanged(newValue)), property({ type: Boolean })];
+    _set_selected_decorators = [property()];
+    __selected_decorators = [state()];
+    _dateFilter_decorators = [property({ attribute: "date-filter" })];
+    _orientation_decorators = [property({ reflect: true })];
+    _weekNumbers_decorators = [forceType(), property({ attribute: "week-numbers", type: Boolean })];
+    __activeDate_decorators = [state()];
+    _set__wide_decorators = [state()];
+    __calendarView_decorators = [state()];
+    __initialized_decorators = [state()];
+    __esDecorate(_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, _min_decorators, { kind: "accessor", name: "min", static: false, private: false, access: { has: (obj) => "min" in obj, get: (obj) => obj.min, set: (obj, value) => {
+      obj.min = value;
+    } }, metadata: _metadata }, _min_initializers, _min_extraInitializers);
+    __esDecorate(_a, null, _max_decorators, { kind: "accessor", name: "max", static: false, private: false, access: { has: (obj) => "max" in obj, get: (obj) => obj.max, set: (obj, value) => {
+      obj.max = value;
+    } }, metadata: _metadata }, _max_initializers, _max_extraInitializers);
+    __esDecorate(_a, null, _multiple_decorators, { kind: "accessor", name: "multiple", static: false, private: false, access: { has: (obj) => "multiple" in obj, get: (obj) => obj.multiple, set: (obj, value) => {
+      obj.multiple = value;
+    } }, metadata: _metadata }, _multiple_initializers, _multiple_extraInitializers);
+    __esDecorate(_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, __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, _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, _orientation_decorators, { kind: "accessor", name: "orientation", static: false, private: false, access: { has: (obj) => "orientation" in obj, get: (obj) => obj.orientation, set: (obj, value) => {
+      obj.orientation = value;
+    } }, metadata: _metadata }, _orientation_initializers, _orientation_extraInitializers);
+    __esDecorate(_a, null, _weekNumbers_decorators, { kind: "accessor", name: "weekNumbers", static: false, private: false, access: { has: (obj) => "weekNumbers" in obj, get: (obj) => obj.weekNumbers, set: (obj, value) => {
+      obj.weekNumbers = value;
+    } }, metadata: _metadata }, _weekNumbers_initializers, _weekNumbers_extraInitializers);
+    __esDecorate(_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, _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);
+    _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = [boxSizingStyles, style], _a.events = {
+    dateselected: "dateselected",
+    monthchange: "monthchange"
+  }, __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbCalendarElement,
+  SbbMonthChangeEvent
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"calendar.component.js","sources":["../../../../../node_modules/date-fns/constants.js","../../../../../node_modules/date-fns/constructFrom.js","../../../../../node_modules/date-fns/toDate.js","../../../../../node_modules/date-fns/addDays.js","../../../../../node_modules/date-fns/_lib/defaultOptions.js","../../../../../node_modules/date-fns/startOfWeek.js","../../../../../node_modules/date-fns/_lib/normalizeDates.js","../../../../../node_modules/date-fns/addWeeks.js","../../../../../node_modules/date-fns/endOfMonth.js","../../../../../node_modules/date-fns/_lib/normalizeInterval.js","../../../../../node_modules/date-fns/eachWeekOfInterval.js","../../../../../node_modules/date-fns/startOfMonth.js","../../../../../node_modules/date-fns/getWeekYear.js","../../../../../node_modules/date-fns/startOfWeekYear.js","../../../../../node_modules/date-fns/getWeek.js","../../../../../src/elements/calendar/calendar/calendar.component.ts"],"sourcesContent":["/**\n * @module constants\n * @summary Useful constants\n * @description\n * Collection of useful date constants.\n *\n * The constants could be imported from `date-fns/constants`:\n *\n * ```ts\n * import { maxTime, minTime } from \"./constants/date-fns/constants\";\n *\n * function isAllowedTime(time) {\n *   return time <= maxTime && time >= minTime;\n * }\n * ```\n */\n\n/**\n * @constant\n * @name daysInWeek\n * @summary Days in 1 week.\n */\nexport const daysInWeek = 7;\n\n/**\n * @constant\n * @name daysInYear\n * @summary Days in 1 year.\n *\n * @description\n * How many days in a year.\n *\n * One years equals 365.2425 days according to the formula:\n *\n * > Leap year occurs every 4 years, except for years that are divisible by 100 and not divisible by 400.\n * > 1 mean year = (365+1/4-1/100+1/400) days = 365.2425 days\n */\nexport const daysInYear = 365.2425;\n\n/**\n * @constant\n * @name maxTime\n * @summary Maximum allowed time.\n *\n * @example\n * import { maxTime } from \"./constants/date-fns/constants\";\n *\n * const isValid = 8640000000000001 <= maxTime;\n * //=> false\n *\n * new Date(8640000000000001);\n * //=> Invalid Date\n */\nexport const maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000;\n\n/**\n * @constant\n * @name minTime\n * @summary Minimum allowed time.\n *\n * @example\n * import { minTime } from \"./constants/date-fns/constants\";\n *\n * const isValid = -8640000000000001 >= minTime;\n * //=> false\n *\n * new Date(-8640000000000001)\n * //=> Invalid Date\n */\nexport const minTime = -maxTime;\n\n/**\n * @constant\n * @name millisecondsInWeek\n * @summary Milliseconds in 1 week.\n */\nexport const millisecondsInWeek = 604800000;\n\n/**\n * @constant\n * @name millisecondsInDay\n * @summary Milliseconds in 1 day.\n */\nexport const millisecondsInDay = 86400000;\n\n/**\n * @constant\n * @name millisecondsInMinute\n * @summary Milliseconds in 1 minute\n */\nexport const millisecondsInMinute = 60000;\n\n/**\n * @constant\n * @name millisecondsInHour\n * @summary Milliseconds in 1 hour\n */\nexport const millisecondsInHour = 3600000;\n\n/**\n * @constant\n * @name millisecondsInSecond\n * @summary Milliseconds in 1 second\n */\nexport const millisecondsInSecond = 1000;\n\n/**\n * @constant\n * @name minutesInYear\n * @summary Minutes in 1 year.\n */\nexport const minutesInYear = 525600;\n\n/**\n * @constant\n * @name minutesInMonth\n * @summary Minutes in 1 month.\n */\nexport const minutesInMonth = 43200;\n\n/**\n * @constant\n * @name minutesInDay\n * @summary Minutes in 1 day.\n */\nexport const minutesInDay = 1440;\n\n/**\n * @constant\n * @name minutesInHour\n * @summary Minutes in 1 hour.\n */\nexport const minutesInHour = 60;\n\n/**\n * @constant\n * @name monthsInQuarter\n * @summary Months in 1 quarter.\n */\nexport const monthsInQuarter = 3;\n\n/**\n * @constant\n * @name monthsInYear\n * @summary Months in 1 year.\n */\nexport const monthsInYear = 12;\n\n/**\n * @constant\n * @name quartersInYear\n * @summary Quarters in 1 year\n */\nexport const quartersInYear = 4;\n\n/**\n * @constant\n * @name secondsInHour\n * @summary Seconds in 1 hour.\n */\nexport const secondsInHour = 3600;\n\n/**\n * @constant\n * @name secondsInMinute\n * @summary Seconds in 1 minute.\n */\nexport const secondsInMinute = 60;\n\n/**\n * @constant\n * @name secondsInDay\n * @summary Seconds in 1 day.\n */\nexport const secondsInDay = secondsInHour * 24;\n\n/**\n * @constant\n * @name secondsInWeek\n * @summary Seconds in 1 week.\n */\nexport const secondsInWeek = secondsInDay * 7;\n\n/**\n * @constant\n * @name secondsInYear\n * @summary Seconds in 1 year.\n */\nexport const secondsInYear = secondsInDay * daysInYear;\n\n/**\n * @constant\n * @name secondsInMonth\n * @summary Seconds in 1 month\n */\nexport const secondsInMonth = secondsInYear / 12;\n\n/**\n * @constant\n * @name secondsInQuarter\n * @summary Seconds in 1 quarter.\n */\nexport const secondsInQuarter = secondsInMonth * 3;\n\n/**\n * @constant\n * @name constructFromSymbol\n * @summary Symbol enabling Date extensions to inherit properties from the reference date.\n *\n * The symbol is used to enable the `constructFrom` function to construct a date\n * using a reference date and a value. It allows to transfer extra properties\n * from the reference date to the new date. It's useful for extensions like\n * [`TZDate`](https://github.com/date-fns/tz) that accept a time zone as\n * a constructor argument.\n */\nexport const constructFromSymbol = Symbol.for(\"constructDateFrom\");\n","import { constructFromSymbol } from \"./constants.js\";\n\n/**\n * @name constructFrom\n * @category Generic Helpers\n * @summary Constructs a date using the reference date and the value\n *\n * @description\n * The function constructs a new date using the constructor from the reference\n * date and the given value. It helps to build generic functions that accept\n * date extensions.\n *\n * It defaults to `Date` if the passed reference date is a number or a string.\n *\n * Starting from v3.7.0, it allows to construct a date using `[Symbol.for(\"constructDateFrom\")]`\n * enabling to transfer extra properties from the reference date to the new date.\n * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)\n * that accept a time zone as a constructor argument.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The reference date to take constructor from\n * @param value - The value to create the date\n *\n * @returns Date initialized using the given date and value\n *\n * @example\n * import { constructFrom } from \"./constructFrom/date-fns\";\n *\n * // A function that clones a date preserving the original type\n * function cloneDate<DateType extends Date>(date: DateType): DateType {\n *   return constructFrom(\n *     date, // Use constructor from the given date\n *     date.getTime() // Use the date value to create a new date\n *   );\n * }\n */\nexport function constructFrom(date, value) {\n  if (typeof date === \"function\") return date(value);\n\n  if (date && typeof date === \"object\" && constructFromSymbol in date)\n    return date[constructFromSymbol](value);\n\n  if (date instanceof Date) return new date.constructor(value);\n\n  return new Date(value);\n}\n\n// Fallback for modularized imports:\nexport default constructFrom;\n","import { constructFrom } from \"./constructFrom.js\";\n\n/**\n * @name toDate\n * @category Common Helpers\n * @summary Convert the given argument to an instance of Date.\n *\n * @description\n * Convert the given argument to an instance of Date.\n *\n * If the argument is an instance of Date, the function returns its clone.\n *\n * If the argument is a number, it is treated as a timestamp.\n *\n * If the argument is none of the above, the function returns Invalid Date.\n *\n * Starting from v3.7.0, it clones a date using `[Symbol.for(\"constructDateFrom\")]`\n * enabling to transfer extra properties from the reference date to the new date.\n * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)\n * that accept a time zone as a constructor argument.\n *\n * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.\n *\n * @param argument - The value to convert\n *\n * @returns The parsed date in the local time zone\n *\n * @example\n * // Clone the date:\n * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))\n * //=> Tue Feb 11 2014 11:30:30\n *\n * @example\n * // Convert the timestamp to date:\n * const result = toDate(1392098430000)\n * //=> Tue Feb 11 2014 11:30:30\n */\nexport function toDate(argument, context) {\n  // [TODO] Get rid of `toDate` or `constructFrom`?\n  return constructFrom(context || argument, argument);\n}\n\n// Fallback for modularized imports:\nexport default toDate;\n","import { constructFrom } from \"./constructFrom.js\";\nimport { toDate } from \"./toDate.js\";\n\n/**\n * The {@link addDays} function options.\n */\n\n/**\n * @name addDays\n * @category Day Helpers\n * @summary Add the specified number of days to the given date.\n *\n * @description\n * Add the specified number of days to the given date.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.\n *\n * @param date - The date to be changed\n * @param amount - The amount of days to be added.\n * @param options - An object with options\n *\n * @returns The new date with the days added\n *\n * @example\n * // Add 10 days to 1 September 2014:\n * const result = addDays(new Date(2014, 8, 1), 10)\n * //=> Thu Sep 11 2014 00:00:00\n */\nexport function addDays(date, amount, options) {\n  const _date = toDate(date, options?.in);\n  if (isNaN(amount)) return constructFrom(options?.in || date, NaN);\n\n  // If 0 days, no-op to avoid changing times in the hour before end of DST\n  if (!amount) return _date;\n\n  _date.setDate(_date.getDate() + amount);\n  return _date;\n}\n\n// Fallback for modularized imports:\nexport default addDays;\n","let defaultOptions = {};\n\nexport function getDefaultOptions() {\n  return defaultOptions;\n}\n\nexport function setDefaultOptions(newOptions) {\n  defaultOptions = newOptions;\n}\n","import { getDefaultOptions } from \"./_lib/defaultOptions.js\";\nimport { toDate } from \"./toDate.js\";\n\n/**\n * The {@link startOfWeek} function options.\n */\n\n/**\n * @name startOfWeek\n * @category Week Helpers\n * @summary Return the start of a week for the given date.\n *\n * @description\n * Return the start of a week for the given date.\n * The result will be in the local timezone.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.\n *\n * @param date - The original date\n * @param options - An object with options\n *\n * @returns The start of a week\n *\n * @example\n * // The start of a week for 2 September 2014 11:55:00:\n * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Sun Aug 31 2014 00:00:00\n *\n * @example\n * // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:\n * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })\n * //=> Mon Sep 01 2014 00:00:00\n */\nexport function startOfWeek(date, options) {\n  const defaultOptions = getDefaultOptions();\n  const weekStartsOn =\n    options?.weekStartsOn ??\n    options?.locale?.options?.weekStartsOn ??\n    defaultOptions.weekStartsOn ??\n    defaultOptions.locale?.options?.weekStartsOn ??\n    0;\n\n  const _date = toDate(date, options?.in);\n  const day = _date.getDay();\n  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;\n\n  _date.setDate(_date.getDate() - diff);\n  _date.setHours(0, 0, 0, 0);\n  return _date;\n}\n\n// Fallback for modularized imports:\nexport default startOfWeek;\n","import { constructFrom } from \"../constructFrom.js\";\n\nexport function normalizeDates(context, ...dates) {\n  const normalize = constructFrom.bind(\n    null,\n    context || dates.find((date) => typeof date === \"object\"),\n  );\n  return dates.map(normalize);\n}\n","import { addDays } from \"./addDays.js\";\n\n/**\n * The {@link addWeeks} function options.\n */\n\n/**\n * @name addWeeks\n * @category Week Helpers\n * @summary Add the specified number of weeks to the given date.\n *\n * @description\n * Add the specified number of weeks to the given date.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.\n *\n * @param date - The date to be changed\n * @param amount - The amount of weeks to be added.\n * @param options - An object with options\n *\n * @returns The new date with the weeks added\n *\n * @example\n * // Add 4 weeks to 1 September 2014:\n * const result = addWeeks(new Date(2014, 8, 1), 4)\n * //=> Mon Sep 29 2014 00:00:00\n */\nexport function addWeeks(date, amount, options) {\n  return addDays(date, amount * 7, options);\n}\n\n// Fallback for modularized imports:\nexport default addWeeks;\n","import { toDate } from \"./toDate.js\";\n\n/**\n * The {@link endOfMonth} function options.\n */\n\n/**\n * @name endOfMonth\n * @category Month Helpers\n * @summary Return the end of a month for the given date.\n *\n * @description\n * Return the end of a month for the given date.\n * The result will be in the local timezone.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.\n *\n * @param date - The original date\n * @param options - An object with options\n *\n * @returns The end of a month\n *\n * @example\n * // The end of a month for 2 September 2014 11:55:00:\n * const result = endOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Tue Sep 30 2014 23:59:59.999\n */\nexport function endOfMonth(date, options) {\n  const _date = toDate(date, options?.in);\n  const month = _date.getMonth();\n  _date.setFullYear(_date.getFullYear(), month + 1, 0);\n  _date.setHours(23, 59, 59, 999);\n  return _date;\n}\n\n// Fallback for modularized imports:\nexport default endOfMonth;\n","import { normalizeDates } from \"./normalizeDates.js\";\n\nexport function normalizeInterval(context, interval) {\n  const [start, end] = normalizeDates(context, interval.start, interval.end);\n  return { start, end };\n}\n","import { normalizeInterval } from \"./_lib/normalizeInterval.js\";\nimport { addWeeks } from \"./addWeeks.js\";\nimport { constructFrom } from \"./constructFrom.js\";\nimport { startOfWeek } from \"./startOfWeek.js\";\n\n/**\n * The {@link eachWeekOfInterval} function options.\n */\n\n/**\n * The {@link eachWeekOfInterval} function result type. It resolves the proper data type.\n * It uses the first argument date object type, starting from the interval start date,\n * then the end interval date. If a context function is passed, it uses the context function return type.\n */\n\n/**\n * @name eachWeekOfInterval\n * @category Interval Helpers\n * @summary Return the array of weeks within the specified time interval.\n *\n * @description\n * Return the array of weeks within the specified time interval.\n *\n * @param interval - The interval.\n * @param options - An object with options.\n *\n * @returns The array with starts of weeks from the week of the interval start to the week of the interval end\n *\n * @example\n * // Each week within interval 6 October 2014 - 23 November 2014:\n * const result = eachWeekOfInterval({\n *   start: new Date(2014, 9, 6),\n *   end: new Date(2014, 10, 23)\n * })\n * //=> [\n * //   Sun Oct 05 2014 00:00:00,\n * //   Sun Oct 12 2014 00:00:00,\n * //   Sun Oct 19 2014 00:00:00,\n * //   Sun Oct 26 2014 00:00:00,\n * //   Sun Nov 02 2014 00:00:00,\n * //   Sun Nov 09 2014 00:00:00,\n * //   Sun Nov 16 2014 00:00:00,\n * //   Sun Nov 23 2014 00:00:00\n * // ]\n */\nexport function eachWeekOfInterval(interval, options) {\n  const { start, end } = normalizeInterval(options?.in, interval);\n\n  let reversed = +start > +end;\n  const startDateWeek = reversed\n    ? startOfWeek(end, options)\n    : startOfWeek(start, options);\n  const endDateWeek = reversed\n    ? startOfWeek(start, options)\n    : startOfWeek(end, options);\n\n  startDateWeek.setHours(15);\n  endDateWeek.setHours(15);\n\n  const endTime = +endDateWeek.getTime();\n  let currentDate = startDateWeek;\n\n  let step = options?.step ?? 1;\n  if (!step) return [];\n  if (step < 0) {\n    step = -step;\n    reversed = !reversed;\n  }\n\n  const dates = [];\n\n  while (+currentDate <= endTime) {\n    currentDate.setHours(0);\n    dates.push(constructFrom(start, currentDate));\n    currentDate = addWeeks(currentDate, step);\n    currentDate.setHours(15);\n  }\n\n  return reversed ? dates.reverse() : dates;\n}\n\n// Fallback for modularized imports:\nexport default eachWeekOfInterval;\n","import { toDate } from \"./toDate.js\";\n\n/**\n * The {@link startOfMonth} function options.\n */\n\n/**\n * @name startOfMonth\n * @category Month Helpers\n * @summary Return the start of a month for the given date.\n *\n * @description\n * Return the start of a month for the given date. The result will be in the local timezone.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments.\n * Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed,\n * or inferred from the arguments.\n *\n * @param date - The original date\n * @param options - An object with options\n *\n * @returns The start of a month\n *\n * @example\n * // The start of a month for 2 September 2014 11:55:00:\n * const result = startOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Mon Sep 01 2014 00:00:00\n */\nexport function startOfMonth(date, options) {\n  const _date = toDate(date, options?.in);\n  _date.setDate(1);\n  _date.setHours(0, 0, 0, 0);\n  return _date;\n}\n\n// Fallback for modularized imports:\nexport default startOfMonth;\n","import { getDefaultOptions } from \"./_lib/defaultOptions.js\";\nimport { constructFrom } from \"./constructFrom.js\";\nimport { startOfWeek } from \"./startOfWeek.js\";\nimport { toDate } from \"./toDate.js\";\n\n/**\n * The {@link getWeekYear} function options.\n */\n\n/**\n * @name getWeekYear\n * @category Week-Numbering Year Helpers\n * @summary Get the local week-numbering year of the given date.\n *\n * @description\n * Get the local week-numbering year of the given date.\n * The exact calculation depends on the values of\n * `options.weekStartsOn` (which is the index of the first day of the week)\n * and `options.firstWeekContainsDate` (which is the day of January, which is always in\n * the first week of the week-numbering year)\n *\n * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system\n *\n * @param date - The given date\n * @param options - An object with options.\n *\n * @returns The local week-numbering year\n *\n * @example\n * // Which week numbering year is 26 December 2004 with the default settings?\n * const result = getWeekYear(new Date(2004, 11, 26))\n * //=> 2005\n *\n * @example\n * // Which week numbering year is 26 December 2004 if week starts on Saturday?\n * const result = getWeekYear(new Date(2004, 11, 26), { weekStartsOn: 6 })\n * //=> 2004\n *\n * @example\n * // Which week numbering year is 26 December 2004 if the first week contains 4 January?\n * const result = getWeekYear(new Date(2004, 11, 26), { firstWeekContainsDate: 4 })\n * //=> 2004\n */\nexport function getWeekYear(date, options) {\n  const _date = toDate(date, options?.in);\n  const year = _date.getFullYear();\n\n  const defaultOptions = getDefaultOptions();\n  const firstWeekContainsDate =\n    options?.firstWeekContainsDate ??\n    options?.locale?.options?.firstWeekContainsDate ??\n    defaultOptions.firstWeekContainsDate ??\n    defaultOptions.locale?.options?.firstWeekContainsDate ??\n    1;\n\n  const firstWeekOfNextYear = constructFrom(options?.in || date, 0);\n  firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);\n  firstWeekOfNextYear.setHours(0, 0, 0, 0);\n  const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);\n\n  const firstWeekOfThisYear = constructFrom(options?.in || date, 0);\n  firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);\n  firstWeekOfThisYear.setHours(0, 0, 0, 0);\n  const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);\n\n  if (+_date >= +startOfNextYear) {\n    return year + 1;\n  } else if (+_date >= +startOfThisYear) {\n    return year;\n  } else {\n    return year - 1;\n  }\n}\n\n// Fallback for modularized imports:\nexport default getWeekYear;\n","import { getDefaultOptions } from \"./_lib/defaultOptions.js\";\nimport { constructFrom } from \"./constructFrom.js\";\nimport { getWeekYear } from \"./getWeekYear.js\";\nimport { startOfWeek } from \"./startOfWeek.js\";\n\n/**\n * The {@link startOfWeekYear} function options.\n */\n\n/**\n * @name startOfWeekYear\n * @category Week-Numbering Year Helpers\n * @summary Return the start of a local week-numbering year for the given date.\n *\n * @description\n * Return the start of a local week-numbering year.\n * The exact calculation depends on the values of\n * `options.weekStartsOn` (which is the index of the first day of the week)\n * and `options.firstWeekContainsDate` (which is the day of January, which is always in\n * the first week of the week-numbering year)\n *\n * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n * @typeParam ResultDate - The result `Date` type.\n *\n * @param date - The original date\n * @param options - An object with options\n *\n * @returns The start of a week-numbering year\n *\n * @example\n * // The start of an a week-numbering year for 2 July 2005 with default settings:\n * const result = startOfWeekYear(new Date(2005, 6, 2))\n * //=> Sun Dec 26 2004 00:00:00\n *\n * @example\n * // The start of a week-numbering year for 2 July 2005\n * // if Monday is the first day of week\n * // and 4 January is always in the first week of the year:\n * const result = startOfWeekYear(new Date(2005, 6, 2), {\n *   weekStartsOn: 1,\n *   firstWeekContainsDate: 4\n * })\n * //=> Mon Jan 03 2005 00:00:00\n */\nexport function startOfWeekYear(date, options) {\n  const defaultOptions = getDefaultOptions();\n  const firstWeekContainsDate =\n    options?.firstWeekContainsDate ??\n    options?.locale?.options?.firstWeekContainsDate ??\n    defaultOptions.firstWeekContainsDate ??\n    defaultOptions.locale?.options?.firstWeekContainsDate ??\n    1;\n\n  const year = getWeekYear(date, options);\n  const firstWeek = constructFrom(options?.in || date, 0);\n  firstWeek.setFullYear(year, 0, firstWeekContainsDate);\n  firstWeek.setHours(0, 0, 0, 0);\n  const _date = startOfWeek(firstWeek, options);\n  return _date;\n}\n\n// Fallback for modularized imports:\nexport default startOfWeekYear;\n","import { millisecondsInWeek } from \"./constants.js\";\nimport { startOfWeek } from \"./startOfWeek.js\";\nimport { startOfWeekYear } from \"./startOfWeekYear.js\";\nimport { toDate } from \"./toDate.js\";\n\n/**\n * The {@link getWeek} function options.\n */\n\n/**\n * @name getWeek\n * @category Week Helpers\n * @summary Get the local week index of the given date.\n *\n * @description\n * Get the local week index of the given date.\n * The exact calculation depends on the values of\n * `options.weekStartsOn` (which is the index of the first day of the week)\n * and `options.firstWeekContainsDate` (which is the day of January, which is always in\n * the first week of the week-numbering year)\n *\n * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system\n *\n * @param date - The given date\n * @param options - An object with options\n *\n * @returns The week\n *\n * @example\n * // Which week of the local week numbering year is 2 January 2005 with default options?\n * const result = getWeek(new Date(2005, 0, 2))\n * //=> 2\n *\n * @example\n * // Which week of the local week numbering year is 2 January 2005,\n * // if Monday is the first day of the week,\n * // and the first week of the year always contains 4 January?\n * const result = getWeek(new Date(2005, 0, 2), {\n *   weekStartsOn: 1,\n *   firstWeekContainsDate: 4\n * })\n * //=> 53\n */\nexport function getWeek(date, options) {\n  const _date = toDate(date, options?.in);\n  const diff = +startOfWeek(_date, options) - +startOfWeekYear(_date, options);\n\n  // Round the number of weeks to the nearest integer because the number of\n  // milliseconds in a week is not constant (e.g. it's different in the week of\n  // the daylight saving time clock shift).\n  return Math.round(diff / millisecondsInWeek) + 1;\n}\n\n// Fallback for modularized imports:\nexport default getWeek;\n","import { eachWeekOfInterval, endOfMonth, getWeek, startOfMonth } from 'date-fns';\nimport {\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 } from '../../core/a11y.ts';\nimport { readConfig } from '../../core/config.ts';\nimport {\n  SbbLanguageController,\n  SbbMediaMatcherController,\n  SbbMediaQueryBreakpointLargeAndAbove,\n} from '../../core/controllers.ts';\nimport type { DateAdapter } from '../../core/datetime.ts';\nimport {\n  DAYS_PER_ROW,\n  defaultDateAdapter,\n  MONTHS_PER_PAGE,\n  MONTHS_PER_ROW,\n  YEARS_PER_PAGE,\n  YEARS_PER_ROW,\n} from '../../core/datetime.ts';\nimport { forceType, handleDistinctChange, plainDate } from '../../core/decorators.ts';\nimport {\n  i18nCalendarDateSelection,\n  i18nCalendarWeekNumber,\n  i18nNextMonth,\n  i18nNextYear,\n  i18nNextYearRange,\n  i18nPreviousMonth,\n  i18nPreviousYear,\n  i18nPreviousYearRange,\n  i18nYearMonthSelection,\n} from '../../core/i18n.ts';\nimport type { SbbOrientation } from '../../core/interfaces.ts';\nimport { SbbElementInternalsMixin, SbbHydrationMixin } from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport type { SbbCalendarDayElement } from '../calendar-day/calendar-day.component.ts';\n\nimport style from './calendar.scss?lit&inline';\n\nimport '../../button/secondary-button.ts';\nimport '../../icon.ts';\nimport '../../screen-reader-only.ts';\nimport '../calendar-day/calendar-day.component.ts';\n\nexport class SbbMonthChangeEvent extends Event {\n  private readonly _range: readonly Day[];\n\n  public get range(): readonly Day[] {\n    return this._range;\n  }\n\n  public constructor(range: readonly Day[]) {\n    super('monthchange', { bubbles: true, composed: true });\n    this._range = Object.freeze(range || []);\n  }\n}\n\n/**\n * Parameters needed in year and month views to correctly calculate the next element in keyboard navigation.\n *\n * The cell's index and the element's index in its month / year batch must be distinguished:\n * the first is the index of the element in the array of all the rendered cells, while the second is the index of the element relative to its table.\n * In non-wide mode, the wto are the same, while in wide mode the cell's index can go from 0 to 47 for years and from 0 to 23 for months,\n * while the element index goes from 0 to, respectively, 23 and 11.\n */\ninterface CalendarKeyboardNavigationMonthYearViewsParameters {\n  /** The element index within its year or month range. */\n  elementIndexForWideMode: number;\n  /** In wide mode, the index of the first element in the second panel, or, alternatively, the number of elements in the first panel. */\n  offsetForWideMode: number;\n  /** The index of the last element within the element's month (or year range). */\n  lastElementIndexForWideMode: number;\n  /** The number of cells displayed in a single row, depending on the rendered view. */\n  verticalOffset: number;\n}\n\n/**\n * Parameters needed in day view to correctly calculate the next element in keyboard navigation.\n *\n * In orientation='vertical', it's not possible to rely on any array/index to calculate the element to navigate to,\n * so calculations on dates must be done, which should consider view boundaries, offsets and month's length.\n */\ninterface CalendarKeyboardNavigationDayViewParameters {\n  /** The first day rendered. */\n  firstDayInView: string | null;\n  /** The last day rendered. It depends on the 'wide' value. */\n  lastDayInView: string | null;\n  /** The offset from the first day of the week (Monday) of the first rendered month. */\n  firstMonthOffset: number;\n  /** The number of days in the first rendered month. */\n  firstMonthLength: number;\n  /** The offset from the first day of the week (Monday) of the second rendered month. If wide is false, it's equal to zero. */\n  secondMonthOffset: number;\n}\n\nexport interface Day<T = Date> {\n  /** Date as ISO string. */\n  value: string;\n  dayValue: string;\n  monthValue: string;\n  yearValue: string;\n  dateValue: T;\n  weekValue: number;\n  weekDayValue: number;\n}\n\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 choosing a date.\n *\n * @slot - Use the unnamed slot to add customized `sbb-calendar-day` elements.\n */\nexport\n@customElement('sbb-calendar')\nclass SbbCalendarElement<T extends Date = Date> extends SbbHydrationMixin(\n  SbbElementInternalsMixin(LitElement),\n) {\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n  public static readonly events = {\n    dateselected: 'dateselected',\n    monthchange: 'monthchange',\n  } as const;\n\n  /** If set to true, two months are displayed */\n  @forceType()\n  @property({ type: Boolean })\n  public accessor wide: boolean = false;\n\n  /** The initial view of the calendar which should be displayed on opening. */\n  @property() public accessor view: CalendarView = 'day';\n\n  /**\n   * The minimum valid date. Accepts a date object or null.\n   * Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.\n   */\n  @plainDate()\n  @property()\n  public accessor min: T | null = null;\n\n  /**\n   * The maximum valid date. Accepts a date object or null.\n   * Accepts an ISO8601 formatted string (e.g. 2024-12-24) as attribute.\n   */\n  @plainDate()\n  @property()\n  public accessor max: T | null = null;\n\n  /** Whether the calendar allows for multiple date selection. */\n  @forceType()\n  @handleDistinctChange((e: SbbCalendarElement<T>, newValue: boolean) =>\n    e._onMultipleChanged(newValue),\n  )\n  @property({ type: Boolean })\n  public accessor multiple: boolean = false;\n\n  /**\n   * The selected date: accepts a date object, or, if `multiple`, an array of dates.\n   */\n  @property()\n  public set selected(value: T | T[] | null) {\n    if (Array.isArray(value)) {\n      this._selected = value\n        .map((dateLike: T) =>\n          this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(dateLike)),\n        )\n        .filter((date: T | null): date is T => date !== null)\n        .filter(\n          (date: T) =>\n            !this._isDayInRange(this._dateAdapter.toIso8601(date)) || this._dateFilter(date),\n        );\n    } else {\n      const selectedDate = this._dateAdapter.getValidDateOrNull(\n        this._dateAdapter.deserialize(value),\n      );\n      if (\n        !!selectedDate &&\n        (!this._isDayInRange(this._dateAdapter.toIso8601(selectedDate)) ||\n          this._dateFilter(selectedDate))\n      ) {\n        this._selected = selectedDate;\n      } else {\n        this._selected = null;\n      }\n    }\n  }\n  public get selected(): T | T[] | null {\n    return this._selected;\n  }\n  @state() private accessor _selected: T | T[] | null = null;\n\n  /** A function used to filter out dates. */\n  @property({ attribute: 'date-filter' })\n  public accessor dateFilter: ((date: T | null) => boolean) | null = null;\n\n  /** The orientation of days in the calendar. */\n  @property({ reflect: true }) public accessor orientation: SbbOrientation = 'horizontal';\n\n  /** Whether it has to display the week numbers in addition to week days. */\n  @forceType()\n  @property({ attribute: 'week-numbers', type: Boolean })\n  public accessor weekNumbers: boolean = false;\n\n  private _dateAdapter: DateAdapter<T> = readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n\n  /** The currently active date. */\n  @state() private accessor _activeDate: T = this._dateAdapter.today();\n\n  /** The current wide property considering property value and breakpoints. From zero to small `wide` has always to be false. */\n  @state()\n  private set _wide(wide: boolean) {\n    this.toggleState('wide', wide);\n    this._wideInternal = wide;\n  }\n  private get _wide(): boolean {\n    return this._wideInternal;\n  }\n  // We keep the state in a field because of the WebKit bug https://bugs.webkit.org/show_bug.cgi?id=303467.\n  // TODO: re-check whether field is needed\n  private _wideInternal: boolean = false;\n\n  @state() private accessor _calendarView: CalendarView = 'day';\n\n  private _nextCalendarView: CalendarView = 'day';\n\n  /** Information about the rendered day view; used in keyboard navigation. */\n  private _keyboardNavigationDayViewParameters: CalendarKeyboardNavigationDayViewParameters = {\n    firstDayInView: null,\n    lastDayInView: null,\n    firstMonthOffset: 0,\n    firstMonthLength: 0,\n    secondMonthOffset: 0,\n  };\n\n  /** A list of days, in two formats (long and single char). */\n  private _weekdays!: Weekday[];\n\n  /** Grid of calendar cells representing the dates of the month. */\n  private _weeks: Day<T>[][] = [];\n\n  /** Grid of calendar cells representing months. */\n  private _months!: 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<T>[][];\n\n  /** An array containing all the month names in the current language. */\n  private _monthNames: string[] = this._dateAdapter.getMonthNames('long');\n\n  /** An array containing the weeks' numbers for the current month. */\n  private _weekNumbers!: number[];\n\n  /** An array containing the weeks' numbers for the next month in wide mode. */\n  private _nextMonthWeekNumbers!: number[];\n\n  private _enhancedVariant: boolean = false;\n\n  /** A list of buttons corresponding to days, months or years depending on the view. */\n  private get _cells(): (HTMLButtonElement | SbbCalendarDayElement)[] {\n    return Array.from<HTMLButtonElement | SbbCalendarDayElement>(\n      (this._calendarView === 'day'\n        ? this._getRootForQuerySelector()?.querySelectorAll('sbb-calendar-day')\n        : this.shadowRoot?.querySelectorAll('.sbb-calendar__cell')) ?? [],\n    );\n  }\n\n  /** The chosen year in the year selection view. */\n  private _chosenYear?: number;\n\n  /** The chosen month in the year selection view. */\n  private _chosenMonth?: number;\n\n  /** Whether the focus should be reset on focusCell. */\n  private _resetFocus = false;\n\n  /** Whether an element inside the calendar is currently focused. */\n  private _containingFocus = false;\n\n  @state()\n  private accessor _initialized = false;\n\n  private _language = new SbbLanguageController(this).withHandler(() => {\n    this._monthNames = this._dateAdapter.getMonthNames('long');\n    this._createMonthRows();\n  });\n  private _mediaMatcher = new SbbMediaMatcherController(this, {\n    [SbbMediaQueryBreakpointLargeAndAbove]: () => this._init(),\n  });\n\n  public constructor() {\n    super();\n    this._createMonthRows();\n    this._setWeekdays();\n\n    // We need to track the focus as we should only take focus into the calendar, when the\n    // focus was once set into the calendar.\n    // For shadow DOM compatibility we need to track this programmatically.\n    this.addEventListener('focusin', () => (this._containingFocus = true));\n    this.addEventListener('focusout', () => (this._containingFocus = false));\n    this.addEventListener('click', (e) => {\n      const day = (e.target as HTMLElement).closest<SbbCalendarDayElement<T>>('sbb-calendar-day');\n      if (day) {\n        this._selectDate(day.value!);\n      }\n    });\n    this.addEventListener('keydown', (e) => {\n      if ((e.target as HTMLElement).localName === 'sbb-calendar-day') {\n        this._handleKeyboardEvent(\n          e,\n          this._mapDateToDay((e.target as SbbCalendarDayElement).value! as T),\n        );\n      }\n    });\n  }\n\n  private _getRootForQuerySelector(): this | ShadowRoot {\n    return this._enhancedVariant ? this : this.shadowRoot!;\n  }\n\n  private _dateFilter(date: T): boolean {\n    return this.dateFilter?.(date) ?? true;\n  }\n\n  /** Resets the active month according to the new state of the calendar. */\n  public resetPosition(): void {\n    this._resetCalendarView();\n    this._init();\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.resetPosition();\n    this.shadowRoot?.addEventListener('slotchange', this._onSlotChange, { capture: true });\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this.shadowRoot?.removeEventListener('slotchange', this._onSlotChange, { capture: true });\n  }\n\n  /** @internal */\n  public override focus(): void {\n    this._resetFocus = true;\n    this._focusCell();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (!this._initialized) {\n      return;\n    }\n\n    if (changedProperties.has('wide') || changedProperties.has('orientation')) {\n      this.resetPosition();\n    }\n\n    if (changedProperties.has('view')) {\n      this._setChosenYear();\n      this._chosenMonth = undefined;\n      this._nextCalendarView = this._calendarView = this.view;\n    }\n  }\n\n  protected override updated(changedProperties: PropertyValues<this>): void {\n    super.updated(changedProperties);\n    // The calendar needs to calculate tab-indexes on first render,\n    // and every time a date is selected or the month view changes.\n    this._setTabIndex();\n\n    // When changing view to year/month, the tabindex is changed, but the focused element is getting lost.\n    // We need to call `_focusCell()` method explicitly to correctly set the focus.\n    this._focusCell();\n  }\n\n  private _onSlotChange = (): void => {\n    this._enhancedVariant = Array.from(this.children).some(\n      (c) => c.localName === 'sbb-calendar-day',\n    );\n    this.toggleState('enhanced', this._enhancedVariant);\n    this._setTabIndex();\n  };\n\n  /**\n   * The `_selected` state should be adapted when the `multiple` property changes:\n   *   - if it changes to true, the '_selected' is set to an array;\n   *   - if it changes to false, the first available option is set as 'value' otherwise it's set to null.\n   */\n  private _onMultipleChanged(isMultiple: boolean): void {\n    if (isMultiple && !Array.isArray(this._selected)) {\n      this._selected = this._selected ? [this._selected as T] : [];\n    }\n    if (!isMultiple && Array.isArray(this._selected)) {\n      this._selected = (this._selected as T[]).length ? (this._selected as T[])[0] : null;\n    }\n  }\n\n  /** Initializes the component. */\n  private _init(activeDate?: T): void {\n    // Due to its complexity, the calendar is only initialized on client side\n    if (isServer) {\n      return;\n    } else if (this.hydrationRequired) {\n      this.hydrationComplete.then(() => this._init());\n      return;\n    }\n\n    if (activeDate) {\n      this._assignActiveDate(activeDate);\n    }\n    this._wide =\n      (this._mediaMatcher.matches(SbbMediaQueryBreakpointLargeAndAbove) ?? false) && this.wide;\n    this._weeks = this._createWeekRows(this._activeDate);\n    this._years = this._createYearRows();\n    this._weekNumbers = this._createWeekNumbers(this._activeDate);\n    this._nextMonthWeeks = [[]];\n    this._nextMonthYears = [[]];\n    if (this._wide) {\n      const nextMonthDate = this._dateAdapter.addCalendarMonths(this._activeDate, 1);\n      this._nextMonthWeeks = this._createWeekRows(nextMonthDate, true);\n      this._nextMonthYears = this._createYearRows(YEARS_PER_PAGE);\n      this._nextMonthWeekNumbers = this._createWeekNumbers(nextMonthDate);\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  /**\n   * Given a date, it returns the week numbers for the month the date belongs to.\n   * TODO: check if date-fns can be replaced with custom logic.\n   *\n   * Since the calculation is not simple (see https://en.wikipedia.org/wiki/Week#Numbering),\n   * the date-fns library has been used this way:\n   * the first and the last day of the month are calculated and then passed to the `eachWeekOfInterval` function,\n   * which returns an array containing the starting day of every ISO week of the month,\n   * considering Monday as the first day.\n   * Then, this array is mapped via the `getWeek` function, which returns the ISO week number for that date.\n   */\n  private _createWeekNumbers(date: T): number[] {\n    return eachWeekOfInterval(\n      { start: startOfMonth(date as Date), end: endOfMonth(date as Date) },\n      { weekStartsOn: 1 },\n    ).map((firstDayOfWeek: Date) =>\n      getWeek(firstDayOfWeek, { weekStartsOn: 1, firstWeekContainsDate: 4 }),\n    );\n  }\n\n  /** Creates the rows along the horizontal direction and sets the parameters used in keyboard navigation. */\n  private _createWeekRows(value: T, isSecondMonthInView = false): Day<T>[][] {\n    const daysInMonth: number = this._dateAdapter.getNumDaysInMonth(value);\n    const weekOffset: number = this._dateAdapter.getFirstWeekOffset(value);\n    if (!isSecondMonthInView) {\n      this._keyboardNavigationDayViewParameters.firstMonthLength = daysInMonth;\n      this._keyboardNavigationDayViewParameters.firstMonthOffset = weekOffset;\n      this._keyboardNavigationDayViewParameters.firstDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          1,\n        ),\n      );\n      this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          daysInMonth,\n        ),\n      );\n    } else {\n      this._keyboardNavigationDayViewParameters.secondMonthOffset = weekOffset;\n      this._keyboardNavigationDayViewParameters.lastDayInView = this._dateAdapter.toIso8601(\n        this._dateAdapter.createDate(\n          this._dateAdapter.getYear(value),\n          this._dateAdapter.getMonth(value),\n          daysInMonth,\n        ),\n      );\n    }\n    return this.orientation === 'horizontal'\n      ? this._createWeekRowsHorizontal(value, daysInMonth, weekOffset)\n      : this._createWeekRowsVertical(value, daysInMonth, weekOffset);\n  }\n\n  /**\n   * Creates the rows for each week in orientation='horizontal'.\n   *\n   * Iterates through the days of the months, creates a Day object for each and pushes it into and array.\n   * Each seven days (considering the offset at the beginning of the month) restarts from an empty array.\n   *\n   * The result is a matrix in which every row is a week (or part of it, considering offset).\n   */\n  private _createWeekRowsHorizontal(value: T, daysInMonth: number, weekOffset: number): Day<T>[][] {\n    const weeks: Day<T>[][] = [[]];\n    for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {\n      if (cell === DAYS_PER_ROW) {\n        weeks.push([]);\n        cell = 0;\n      }\n      const date = this._dateAdapter.createDate(\n        this._dateAdapter.getYear(value),\n        this._dateAdapter.getMonth(value),\n        i + 1,\n      )!;\n      weeks[weeks.length - 1].push(this._mapDateToDay(date));\n    }\n    return weeks;\n  }\n\n  /**\n   * Creates the rows for each week in orientation='vertical'.\n   *\n   * Creates a matrix with seven empty rows.\n   * Iterates through the days of the months, creates a Day object for each\n   * and pushes it into the correct array considering the offset at the beginning of the month.\n   * Each seven days (including offset) restarts from the first.\n   *\n   * The result is a matrix in which every row is a set of weekdays, so:\n   * - row 0: all the Mondays;\n   * - row 1: all the Tuesdays;\n   * - ...\n   * - row 7: all the Sundays.\n   */\n  private _createWeekRowsVertical(value: T, daysInMonth: number, weekOffset: number): Day<T>[][] {\n    const weeks: Day<T>[][] = Array.from({ length: DAYS_PER_ROW }, () => []);\n    for (let i = 0, cell = weekOffset; i < daysInMonth; i++, cell++) {\n      if (cell === DAYS_PER_ROW) {\n        cell = 0;\n      }\n      const date = this._dateAdapter.createDate(\n        this._dateAdapter.getYear(value),\n        this._dateAdapter.getMonth(value),\n        i + 1,\n      )!;\n      weeks[cell].push(this._mapDateToDay(date));\n    }\n    return weeks;\n  }\n\n  private _mapDateToDay(date: T): Day<T> {\n    const isoDate = this._dateAdapter.toIso8601(date);\n    return {\n      value: isoDate,\n      dateValue: date,\n      dayValue: String(this._dateAdapter.getDate(date)),\n      monthValue: String(this._dateAdapter.getMonth(date)),\n      yearValue: String(this._dateAdapter.getYear(date)),\n      weekValue: getWeek(isoDate, { weekStartsOn: 1, firstWeekContainsDate: 4 }),\n      weekDayValue: this._dateAdapter.getDayOfWeek(date),\n    };\n  }\n\n  /** Force the conversion to ISO8601 formatted string. */\n  private _mapValueToISODate(value: string | Date): string {\n    return typeof value === 'string' ? value : this._dateAdapter.toIso8601(value as T);\n  }\n\n  /** Creates the rows for the month selection view. */\n  private _createMonthRows(): void {\n    const 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(dateString: string): boolean {\n    if (!this.min && !this.max) {\n      return true;\n    }\n    const date = this._dateAdapter.deserialize(dateString)!;\n    return this._dateAdapter.sameDate(date, this._dateAdapter.clampDate(date, this.min, this.max));\n  }\n\n  /** Checks if date is within the min-max range in month view. */\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  /** Checks if date is within the min-max range in year view. */\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: T): void {\n    this._chosenMonth = undefined;\n    this._setChosenYear();\n    if (this.multiple) {\n      // Check if _selected has elements\n      if (this._selected && (this._selected as T[]).length > 0) {\n        const indexOfSelectedDay: number = (this._selected as T[]).findIndex(\n          (sel) => this._dateAdapter.compareDate(sel, day) === 0,\n        );\n        // If the selected date is already in the _selected array, remove it, otherwise add it\n        if (indexOfSelectedDay !== -1) {\n          this._selected = (this._selected as T[]).filter((_, i) => i !== indexOfSelectedDay);\n        } else {\n          this._selected = [...(this._selected as T[]), day];\n        }\n      } else {\n        // If _selected is empty, set it\n        this._selected = [day];\n      }\n      this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)!));\n    } else {\n      // In single selection, check if the day is already selected\n      if (!this._selected || this._dateAdapter.compareDate(this._selected as T, day) !== 0) {\n        this._selected = day;\n        this._emitDateSelectedEvent(this._dateAdapter.deserialize(day)!);\n      }\n    }\n  }\n\n  /**\n   * Handle multiple dates selection via weekNumber / weekDay buttons:\n   * - if Cmd or Ctrl are pressed, add the new date to the current ones;\n   * - if not,\n   *     - if the new dates are the same of the current ones, it means that the same button has been clicked twice, so do nothing;\n   *     - if not, the selected dates are the new ones.\n   */\n  private _selectMultipleDates(days: Day<T>[]): void {\n    // Filter disabled days by matching the provided `days` parameter against the enabled cells.\n    // Since the buttons' value is set to the Day's interface value (ISO string), there's no need to deserialize it.\n    const enabledDays: string[] = this._cells\n      .filter((e) => !e.disabled)\n      .map((e) => this._mapValueToISODate(e.value!));\n    const daysToAdd: string[] = days\n      .map((e: Day<T>) => e.value)\n      .filter((isoDate: string) => enabledDays.includes(isoDate));\n    const daysToAddSet = new Set(daysToAdd);\n    const selectedSet = new Set((this._selected as T[]).map((s) => this._dateAdapter.toIso8601(s)));\n    const selStrings = this._updateSelectedWithMultipleDates(daysToAdd, daysToAddSet, selectedSet);\n    this._selected = selStrings.map((s) => this._dateAdapter.deserialize(s)!);\n\n    this._emitDateSelectedEvent(this._selected.map((e) => this._dateAdapter.deserialize(e)!));\n  }\n\n  /**\n   * Emits the dateselected event given the detail (as T or T[] based on the value of the multiple flag).\n   */\n  private _emitDateSelectedEvent(detail: T | T[]): void {\n    /** @type {CustomEvent<T | T[]>} Event emitted on date selection. */\n    this.dispatchEvent(\n      new CustomEvent<T | T[]>('dateselected', {\n        detail,\n        composed: true,\n        bubbles: true,\n      }),\n    );\n  }\n\n  private _emitMonthChange(): void {\n    // FIXME: the name of this variable appears as event name in the readme\n    //  due to a bug in the custom-elements-manifest library.\n    //  https://github.com/open-wc/custom-elements-manifest/issues/149\n    const monthchange = (this.wide ? [...this._weeks, ...this._nextMonthWeeks] : this._weeks)\n      .flat()\n      .sort((a, b) => a.value.localeCompare(b.value));\n    /**\n     * @type {SbbMonthChangeEvent}\n     * Emits when the month changes.\n     * The `range` property contains the days array of the chosen month.\n     */\n    this.dispatchEvent(new SbbMonthChangeEvent(monthchange));\n  }\n\n  /**\n   * In case of multiple selection, newly added days must be added to the existing ones, without duplication.\n   * If the days to add are exactly the same as the selected ones, the set must be emptied.\n   */\n  private _updateSelectedWithMultipleDates(\n    daysToAdd: string[],\n    daysToAddSet: Set<string>,\n    selectedSet: Set<string>,\n  ): string[] {\n    if (daysToAdd.every((day: string) => selectedSet.has(day))) {\n      daysToAddSet.forEach((day: string) => selectedSet.delete(day));\n    } else {\n      daysToAddSet.forEach((day: string) => selectedSet.add(day));\n    }\n    return Array.from(selectedSet);\n  }\n\n  private _setChosenYear(): void {\n    if (this.view === 'month') {\n      let selectedDate: T | undefined;\n      if (this.multiple) {\n        selectedDate = (this.selected as T[]).at(-1);\n      } else {\n        selectedDate = this.selected as T;\n      }\n      this._chosenYear = this._dateAdapter.getYear(selectedDate ?? this._dateAdapter.today());\n    } else {\n      this._chosenYear = undefined;\n    }\n  }\n\n  private _assignActiveDate(date: T): void {\n    if (this.min && this._dateAdapter.compareDate(this.min, date) > 0) {\n      this._activeDate = this.min;\n      return;\n    }\n    if (this.max && this._dateAdapter.compareDate(this.max, date) < 0) {\n      this._activeDate = this.max;\n      return;\n    }\n    this._activeDate = date;\n  }\n\n  /** Goes to the month identified by the shift. */\n  private _goToDifferentMonth(months: number): void {\n    this._init(this._dateAdapter.addCalendarMonths(this._activeDate, months));\n    this._emitMonthChange();\n  }\n\n  private _goToDifferentYear(years: number): void {\n    this._chosenYear! += years;\n    // Can't use `_assignActiveDate(...)` here, because it will set it to min/max value if argument is out of range\n    this._activeDate = this._dateAdapter.createDate(\n      this._chosenYear!,\n      this._dateAdapter.getMonth(this._activeDate),\n      this._dateAdapter.getDate(this._activeDate),\n    );\n    this._init();\n  }\n\n  private _goToDifferentYearRange(years: number): void {\n    this._init(this._dateAdapter.addCalendarYears(this._activeDate, years));\n  }\n\n  private _prevDisabled(prevDate: T): boolean {\n    if (!this.min) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(prevDate, this.min) < 0;\n  }\n\n  private _nextDisabled(nextDate: T): boolean {\n    if (!this.max) {\n      return false;\n    }\n    return this._dateAdapter.compareDate(nextDate, this.max) > 0;\n  }\n\n  /** Checks if the \"previous month\" button should be disabled. */\n  private _previousMonthDisabled(): boolean {\n    const prevMonth = this._dateAdapter.addCalendarDays(\n      this._activeDate,\n      this._dateAdapter.getDate(this._activeDate) * -1,\n    );\n    return this._prevDisabled(prevMonth);\n  }\n\n  /** Checks if the \"next month\" button should be disabled. */\n  private _nextMonthDisabled(): boolean {\n    let nextMonth = this._dateAdapter.addCalendarMonths(this._activeDate, this._wide ? 2 : 1);\n    nextMonth = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(nextMonth),\n      this._dateAdapter.getMonth(nextMonth),\n      1,\n    );\n    return this._nextDisabled(nextMonth);\n  }\n\n  /** Checks if the \"previous year\" button should be disabled. */\n  private _previousYearDisabled(): boolean {\n    const prevYear = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(this._activeDate) - 1,\n      12,\n      31,\n    );\n    return this._prevDisabled(prevYear);\n  }\n\n  /** Checks if the \"next year\" button should be disabled. */\n  private _nextYearDisabled(): boolean {\n    const nextYear = this._dateAdapter.createDate(\n      this._dateAdapter.getYear(this._activeDate) + (this._wide ? 2 : 1),\n      1,\n      1,\n    );\n    return this._nextDisabled(nextYear);\n  }\n\n  /** Checks if the \"previous year\" button should be disabled in year view. */\n  private _previousYearRangeDisabled(): boolean {\n    const prevYear = this._dateAdapter.createDate(this._years[0][0] - 1, 12, 31);\n    return this._prevDisabled(prevYear);\n  }\n\n  /** Checks if the \"next year\" button should be disabled in year view. */\n  private _nextYearRangeDisabled(): boolean {\n    const years = this._wide ? this._nextMonthYears : this._years;\n    const lastYearRange = years[years.length - 1];\n    const lastYear = lastYearRange[lastYearRange.length - 1];\n    const nextYear = this._dateAdapter.createDate(lastYear + 1, 1, 1);\n    return this._nextDisabled(nextYear);\n  }\n\n  private _handleTableBlur(eventTarget: HTMLElement): void {\n    if (eventTarget?.localName !== 'sbb-calendar-day') {\n      this._setTabIndex();\n    }\n  }\n\n  private _setTabIndex(): void {\n    const query = this._calendarView === 'day' ? 'sbb-calendar-day' : '.sbb-calendar__cell';\n    Array.from(\n      this._getRootForQuerySelector().querySelectorAll(`${query}[tabindex=\"0\"]`) ?? [],\n    ).forEach((day) => ((day as HTMLButtonElement | SbbCalendarDayElement).tabIndex = -1));\n    const firstFocusable = this._getFirstFocusable();\n    if (firstFocusable) {\n      firstFocusable.tabIndex = 0;\n    }\n  }\n\n  /** Get the element in the calendar to assign focus. */\n  private _getFirstFocusable(): SbbCalendarDayElement | HTMLButtonElement | null {\n    const root = this._getRootForQuerySelector();\n    if (this._calendarView === 'day') {\n      const selectedOrCurrent =\n        root.querySelector<SbbCalendarDayElement>(':state(selected)') ??\n        root.querySelector<SbbCalendarDayElement>(':state(current)');\n      return selectedOrCurrent && !selectedOrCurrent.disabled\n        ? selectedOrCurrent\n        : this._getFirstFocusableDay();\n    } else {\n      const selectedOrCurrent = this.shadowRoot?.querySelector<HTMLButtonElement>(\n        '.sbb-calendar__cell-current',\n      );\n      return selectedOrCurrent && !selectedOrCurrent.disabled\n        ? selectedOrCurrent\n        : this.shadowRoot!.querySelector<HTMLButtonElement>('.sbb-calendar__cell:not([disabled])');\n    }\n  }\n\n  /**\n   * In `day` view in `vertical` orientation,\n   * if the first of the month is not a Monday, it is not the first rendered element in the table,\n   * so `this.shadowRoot!.querySelector('.sbb-calendar__cell:not([disabled])')` will return a wrong value.\n   *\n   * To solve this, the element with the lowest `value` is taken (ISO String are ordered).\n   */\n  private _getFirstFocusableDay(): SbbCalendarDayElement | null {\n    const daysInView: SbbCalendarDayElement[] = Array.from(\n      this._getRootForQuerySelector().querySelectorAll('sbb-calendar-day:not([disabled])'),\n    );\n    if (!daysInView || daysInView.length === 0) {\n      return null;\n    } else {\n      const firstElement = daysInView\n        .map((e: SbbCalendarDayElement): string => this._dateAdapter.toIso8601(e.value! as T))\n        .sort()[0];\n      return this._getRootForQuerySelector().querySelector(\n        `sbb-calendar-day[slot=\"${firstElement}\"]`,\n      );\n    }\n  }\n\n  private _handleKeyboardEvent(event: KeyboardEvent, day?: Day<T>): void {\n    if (isArrowKeyOrPageKeysPressed(event)) {\n      event.preventDefault();\n    }\n    // Gets the currently rendered table's cell;\n    // they could be days, months or years based on the current selection view.\n    // If `wide` is true, years are doubled in number and days are (roughly) doubled too, affecting the `index` calculation.\n    const cells = this._cells;\n    const index: number = cells.findIndex((e) => e === event.target);\n    let nextEl: HTMLButtonElement | SbbCalendarDayElement;\n    if (day) {\n      nextEl = this._navigateByKeyboardDayView(event, index, cells, day);\n    } else {\n      nextEl = this._navigateByKeyboard(event, index, cells as HTMLButtonElement[]);\n    }\n    const activeEl = (this._enhancedVariant ? document : this.shadowRoot!).activeElement as\n      | HTMLButtonElement\n      | SbbCalendarDayElement;\n    if (nextEl !== activeEl) {\n      nextEl.tabIndex = 0;\n      nextEl?.focus();\n      activeEl.tabIndex = -1;\n    }\n  }\n\n  private _navigateByKeyboardDayView(\n    evt: KeyboardEvent,\n    index: number,\n    cells: (HTMLButtonElement | SbbCalendarDayElement)[],\n    day: Day<T>,\n  ): HTMLButtonElement | SbbCalendarDayElement {\n    const arrowsOffset =\n      this.orientation === 'horizontal'\n        ? { leftRight: 1, upDown: DAYS_PER_ROW }\n        : { leftRight: DAYS_PER_ROW, upDown: 1 };\n    const offsetForVertical: number =\n      index < this._keyboardNavigationDayViewParameters.firstMonthLength\n        ? this._keyboardNavigationDayViewParameters.firstMonthOffset\n        : this._keyboardNavigationDayViewParameters.secondMonthOffset;\n\n    switch (evt.key) {\n      case 'ArrowUp':\n        return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.upDown);\n      case 'ArrowDown':\n        return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.upDown);\n      case 'ArrowLeft':\n        return this._findDayArrows(cells, index, day.dateValue, -arrowsOffset.leftRight);\n      case 'ArrowRight':\n        return this._findDayArrows(cells, index, day.dateValue, arrowsOffset.leftRight);\n      case 'PageUp': {\n        if (this.orientation === 'horizontal') {\n          const firstOfWeek: number = +day.dayValue % DAYS_PER_ROW || DAYS_PER_ROW;\n          const delta: number = firstOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);\n        } else {\n          const weekNumber: number = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);\n          const firstOfWeek: number = (weekNumber - 1) * DAYS_PER_ROW - offsetForVertical + 1;\n          const delta: number = firstOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, arrowsOffset.upDown);\n        }\n      }\n      case 'PageDown': {\n        if (this.orientation === 'horizontal') {\n          const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;\n          const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;\n          const firstNextMonth: T = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);\n          const lastOfMonth: number = this._dateAdapter.getDate(\n            this._dateAdapter.addCalendarDays(firstNextMonth, -1),\n          );\n          const delta: number =\n            Math.trunc((lastOfMonth - +day.dayValue!) / DAYS_PER_ROW) * DAYS_PER_ROW;\n          return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);\n        } else {\n          const weekNumber: number = Math.ceil((+day.dayValue + offsetForVertical) / DAYS_PER_ROW);\n          const lastOfWeek: number = weekNumber * DAYS_PER_ROW - offsetForVertical;\n          const delta: number = lastOfWeek - +day.dayValue;\n          return this._findDayPageUpDown(cells, index, day, delta, -arrowsOffset.upDown);\n        }\n      }\n      case 'Home': {\n        return this._findDayFirst(cells, index, day, 1);\n      }\n      case 'End': {\n        const monthInBounds = +day.monthValue + 1 > 12 ? 1 : +day.monthValue + 1;\n        const yearInBounds = +day.monthValue + 1 > 12 ? +day.yearValue + 1 : +day.yearValue;\n        const firstNextMonth: T = this._dateAdapter.createDate(yearInBounds, monthInBounds, 1);\n        return this._findDayLast(cells, index, firstNextMonth);\n      }\n      default:\n        return cells[index];\n    }\n  }\n\n  private _isDayOutOfView(date: string): boolean {\n    return (\n      date < this._keyboardNavigationDayViewParameters.firstDayInView! ||\n      date > this._keyboardNavigationDayViewParameters.lastDayInView!\n    );\n  }\n\n  private _findDayArrows(\n    cells: (HTMLButtonElement | SbbCalendarDayElement)[],\n    index: number,\n    date: T,\n    delta: number,\n  ): HTMLButtonElement | SbbCalendarDayElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(date, delta),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => this._mapValueToISODate(e.value!) === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayArrows(cells, index, this._dateAdapter.deserialize(newDateValue)!, delta);\n    }\n    return nextCell;\n  }\n\n  private _findDayPageUpDown(\n    cells: (HTMLButtonElement | SbbCalendarDayElement)[],\n    index: number,\n    day: Day<T>,\n    delta: number,\n    deltaIfDisabled: number,\n  ): HTMLButtonElement | SbbCalendarDayElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(day.dateValue, delta),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => this._mapValueToISODate(e.value!) === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayPageUpDown(cells, index, day, delta + deltaIfDisabled, deltaIfDisabled);\n    }\n    return nextCell;\n  }\n\n  private _findDayFirst(\n    cells: (HTMLButtonElement | SbbCalendarDayElement)[],\n    index: number,\n    day: Day<T>,\n    date: number,\n  ): HTMLButtonElement | SbbCalendarDayElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.createDate(+day.yearValue, +day.monthValue, date),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => this._mapValueToISODate(e.value!) === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayFirst(cells, index, day, date + 1);\n    }\n    return nextCell;\n  }\n\n  private _findDayLast(\n    cells: (HTMLButtonElement | SbbCalendarDayElement)[],\n    index: number,\n    firstNextMonth: T,\n  ): HTMLButtonElement | SbbCalendarDayElement {\n    const newDateValue = this._dateAdapter.toIso8601(\n      this._dateAdapter.addCalendarDays(firstNextMonth, -1),\n    );\n    if (this._isDayOutOfView(newDateValue)) {\n      return cells[index];\n    }\n    const nextCell = cells.find((e) => this._mapValueToISODate(e.value!) === newDateValue);\n    if (!nextCell || nextCell.disabled) {\n      return this._findDayLast(cells, index, this._dateAdapter.deserialize(newDateValue)!);\n    }\n    return nextCell;\n  }\n\n  /**\n   * Gets the index of the element to move to, based on a list of elements (which can be potentially disabled),\n   * the keyboard input and the position of the current element in the list.\n   * In the day view, the `day?: Day` parameter is mandatory for calculation,\n   * while in month and year view it's not due to the fixed amount of rendered cells.\n   */\n  private _navigateByKeyboard(\n    evt: KeyboardEvent,\n    index: number,\n    cells: HTMLButtonElement[],\n  ): HTMLButtonElement {\n    const {\n      elementIndexForWideMode,\n      offsetForWideMode,\n      lastElementIndexForWideMode,\n      verticalOffset,\n    }: CalendarKeyboardNavigationMonthYearViewsParameters =\n      this._calculateParametersForKeyboardNavigation(index, this._calendarView === 'year');\n\n    switch (evt.key) {\n      case 'ArrowUp':\n        return this._findNext(cells, index, -verticalOffset);\n      case 'ArrowDown':\n        return this._findNext(cells, index, verticalOffset);\n      case 'ArrowLeft':\n        return this._findNext(cells, index, -1);\n      case 'ArrowRight':\n        return this._findNext(cells, index, 1);\n      case 'Home':\n        return this._findFirst(cells, offsetForWideMode);\n      case 'PageUp':\n        return this._findFirstOnColumn(\n          cells,\n          elementIndexForWideMode,\n          offsetForWideMode,\n          verticalOffset,\n        );\n      case 'PageDown':\n        return this._findLastOnColumn(cells, index, lastElementIndexForWideMode, verticalOffset);\n      case 'End':\n        return this._findLast(cells, lastElementIndexForWideMode - 1);\n      default:\n        return cells[index];\n    }\n  }\n\n  /**\n   * Calculates the parameters needed in keyboard navigation in year and month view.\n   * @param index The starting element's index in the cell array.\n   * @param isYearView Whether the displayed `view` is the year one.\n   */\n  private _calculateParametersForKeyboardNavigation(\n    index: number,\n    isYearView: boolean,\n  ): CalendarKeyboardNavigationMonthYearViewsParameters {\n    const elementsPerPage = isYearView ? YEARS_PER_PAGE : MONTHS_PER_PAGE;\n    const offset: number = Math.trunc(index / elementsPerPage) * elementsPerPage;\n    const indexInView: number = offset === 0 ? index : index - elementsPerPage;\n    return {\n      verticalOffset: isYearView ? YEARS_PER_ROW : MONTHS_PER_ROW,\n      elementIndexForWideMode: indexInView,\n      offsetForWideMode: index - indexInView,\n      lastElementIndexForWideMode: offset === 0 ? elementsPerPage : elementsPerPage * 2,\n    };\n  }\n\n  /**\n   * Gets the next element of the provided array starting from `index` by adding `delta`.\n   * If the found element is disabled, it continues adding `delta` until it finds an enabled one in the array bounds.\n   */\n  private _findNext(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 _resetCalendarViewAndEmitMonthChange(initTransition = false): void {\n    this._resetCalendarView(initTransition);\n    this._emitMonthChange();\n  }\n\n  private _resetCalendarView(initTransition = false): void {\n    if (this._containingFocus) {\n      this._resetFocus = true;\n    }\n    this._activeDate =\n      (this.multiple ? (this._selected as T[]).at(-1) : (this._selected as T)) ??\n      this._dateAdapter.today();\n    this._setChosenYear();\n    this._chosenMonth = undefined;\n    this._init();\n    this._nextCalendarView = this._calendarView = this.view;\n\n    if (initTransition) {\n      this._startTableTransition();\n    }\n  }\n\n  /** Render the view for the day selection. */\n  private _renderDayView(): TemplateResult {\n    const nextMonthActiveDate = this._wide\n      ? this._dateAdapter.addCalendarMonths(this._activeDate, 1)\n      : undefined;\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentMonth(-1),\n          i18nPreviousMonth[this._language.current],\n          this._previousMonthDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">\n          ${this._createLabelForDayView(this._activeDate)}\n          ${this._wide ? this._createLabelForDayView(nextMonthActiveDate!) : nothing}\n          <sbb-screen-reader-only role=\"status\">\n            ${this._createAriaLabelForDayView(this._activeDate, nextMonthActiveDate!)}\n          </sbb-screen-reader-only>\n        </div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentMonth(1),\n          i18nNextMonth[this._language.current],\n          this._nextMonthDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-overflow-break\">\n        <div class=\"sbb-calendar__table-container sbb-calendar__table-day-view\">\n          ${this.orientation === 'horizontal'\n            ? html`\n                ${this._createDayTable(this._weeks, this._weekNumbers)}\n                ${this._wide\n                  ? this._createDayTable(this._nextMonthWeeks, this._nextMonthWeekNumbers, true)\n                  : nothing}\n              `\n            : html`\n                ${this._createDayTableVertical(this._weeks, this._weekNumbers)}\n                ${this._wide\n                  ? this._createDayTableVertical(\n                      this._nextMonthWeeks,\n                      this._nextMonthWeekNumbers,\n                      nextMonthActiveDate,\n                    )\n                  : nothing}\n              `}\n        </div>\n      </div>\n    `;\n  }\n\n  /** Creates the label with the month for the daily view. */\n  private _createLabelForDayView(d: T): TemplateResult {\n    const monthLabel = `${\n      this._monthNames[this._dateAdapter.getMonth(d) - 1]\n    } ${this._dateAdapter.getYear(d)}`;\n    return html`\n      <button\n        type=\"button\"\n        class=\"sbb-calendar__date-selection sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nYearMonthSelection[this._language.current]} ${monthLabel}\"\n        @click=${() => {\n          this._resetFocus = true;\n          this._nextCalendarView = 'year';\n          this._startTableTransition();\n        }}\n      >\n        ${monthLabel}\n        <sbb-icon name=\"chevron-small-down-small\"></sbb-icon>\n      </button>\n    `;\n  }\n\n  /** Creates the aria-label for the daily view. */\n  private _createAriaLabelForDayView(...dates: T[]): string {\n    let monthLabel = '';\n    for (const d of dates) {\n      if (d) {\n        monthLabel += `${\n          this._monthNames[this._dateAdapter.getMonth(d) - 1]\n        } ${this._dateAdapter.getYear(d)} `;\n      }\n    }\n    return monthLabel;\n  }\n\n  /** Creates the calendar table for the daily view. */\n  private _createDayTable(\n    weeks: Day<T>[][],\n    weekNumbers: number[],\n    isWideNextMonth: boolean = false,\n  ): TemplateResult {\n    const weeksForSelectMultipleWeekNumbers: Day<T>[] = (\n      this._wide\n        ? [...this._weeks, ...this._nextMonthWeeks]\n        : isWideNextMonth\n          ? this._nextMonthWeeks\n          : this._weeks\n    ).flat();\n    const weeksForSelectMultipleWeekDays: Day<T>[] = (\n      isWideNextMonth ? this._nextMonthWeeks : this._weeks\n    ).flat();\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @focusout=${(event: FocusEvent) =>\n          this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        <thead class=\"sbb-calendar__table-header\">\n          <tr>\n            ${this.weekNumbers ? html`<th class=\"sbb-calendar__table-header-cell\"></th>` : nothing}\n            ${this._weekdays.map(\n              (day: Weekday, index: number) => html`\n                <th class=\"sbb-calendar__table-header-cell\">\n                  ${this.multiple\n                    ? html`\n                        <button\n                          class=\"sbb-calendar__header-cell sbb-calendar__weekday\"\n                          aria-label=${day.long}\n                          @click=${() => {\n                            // NOTE: Sundays have index 7, while their weekDayValue is 0\n                            const days: Day<T>[] = weeksForSelectMultipleWeekDays.filter(\n                              (day: Day<T>) => day.weekDayValue === (index + 1) % 7,\n                            )!;\n                            this._selectMultipleDates(days);\n                          }}\n                        >\n                          ${day.narrow}\n                        </button>\n                      `\n                    : html`\n                        <sbb-screen-reader-only>${day.long}</sbb-screen-reader-only>\n                        <span aria-hidden=\"true\">${day.narrow}</span>\n                      `}\n                </th>\n              `,\n            )}\n          </tr>\n        </thead>\n        <tbody class=\"sbb-calendar__table-body\">\n          ${weeks.map((week: Day<T>[], rowIndex: number) => {\n            const firstRowOffset: number = DAYS_PER_ROW - week.length;\n            if (rowIndex === 0 && firstRowOffset) {\n              return html`\n                <tr>\n                  ${this.weekNumbers\n                    ? html`\n                        <td class=\"sbb-calendar__table-header-cell-vertical\">\n                          ${this.multiple\n                            ? html`\n                                <button\n                                  class=\"sbb-calendar__header-cell sbb-calendar__weekday\"\n                                  aria-label=${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[0]}`}\n                                  @click=${() => {\n                                    const days: Day<T>[] = weeksForSelectMultipleWeekNumbers.filter(\n                                      (day: Day<T>) => day.weekValue === weekNumbers[0],\n                                    )!;\n                                    this._selectMultipleDates(days);\n                                  }}\n                                >\n                                  ${weekNumbers[0]}\n                                </button>\n                              `\n                            : html`\n                                <sbb-screen-reader-only\n                                  >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[0]}`}</sbb-screen-reader-only\n                                >\n                                <span aria-hidden=\"true\">${weekNumbers[0]}</span>\n                              `}\n                        </td>\n                      `\n                    : nothing}\n                  ${[...Array(firstRowOffset).keys()].map(\n                    () => html`<td class=\"sbb-calendar__table-data\"></td>`,\n                  )}\n                  ${this._createDayCells(week)}\n                </tr>\n              `;\n            }\n            return html`\n              <tr>\n                ${this.weekNumbers\n                  ? html`\n                      <td class=\"sbb-calendar__table-header-cell-vertical\">\n                        ${this.multiple\n                          ? html`\n                              <button\n                                class=\"sbb-calendar__header-cell sbb-calendar__weekday\"\n                                aria-label=${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[rowIndex]}`}\n                                @click=${() => {\n                                  const days: Day<T>[] = weeksForSelectMultipleWeekNumbers.filter(\n                                    (day: Day<T>) => day.weekValue === weekNumbers[rowIndex],\n                                  )!;\n                                  this._selectMultipleDates(days);\n                                }}\n                              >\n                                ${weekNumbers[rowIndex]}\n                              </button>\n                            `\n                          : html`\n                              <sbb-screen-reader-only\n                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumbers[rowIndex]}`}</sbb-screen-reader-only\n                              >\n                              <span aria-hidden=\"true\">${weekNumbers[rowIndex]}</span>\n                            `}\n                      </td>\n                    `\n                  : nothing}\n                ${this._createDayCells(week)}\n              </tr>\n            `;\n          })}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Creates the table in orientation='vertical'. */\n  private _createDayTableVertical(\n    weeks: Day<T>[][],\n    weekNumbers: number[],\n    nextMonthActiveDate?: T,\n  ): TemplateResult {\n    const weekOffset = this._dateAdapter.getFirstWeekOffset(\n      nextMonthActiveDate ?? this._activeDate,\n    );\n    const weeksForSelectMultipleWeekNumbers: Day<T>[] = (\n      this._wide\n        ? [...this._weeks, ...this._nextMonthWeeks]\n        : nextMonthActiveDate\n          ? this._nextMonthWeeks\n          : this._weeks\n    ).flat();\n    return html`\n      <table\n        class=\"sbb-calendar__table\"\n        @focusout=${(event: FocusEvent) =>\n          this._handleTableBlur(event.relatedTarget as HTMLElement)}\n        @animationend=${(e: AnimationEvent) => this._tableAnimationEnd(e)}\n      >\n        ${this.weekNumbers\n          ? html`\n              <thead class=\"sbb-calendar__table-header\">\n                <tr>\n                  ${nextMonthActiveDate\n                    ? nothing\n                    : html`<th class=\"sbb-calendar__table-data\"></th>`}\n                  ${weekNumbers.map(\n                    (weekNumber: number) => html`\n                      <th class=\"sbb-calendar__table-header-cell\">\n                        ${this.multiple\n                          ? html`\n                              <button\n                                class=\"sbb-calendar__header-cell sbb-calendar__weekday\"\n                                aria-label=${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumber}`}\n                                @click=${() => {\n                                  const days: Day<T>[] = weeksForSelectMultipleWeekNumbers.filter(\n                                    (day: Day<T>) => day.weekValue === weekNumber,\n                                  )!;\n                                  this._selectMultipleDates(days);\n                                }}\n                              >\n                                ${weekNumber}\n                              </button>\n                            `\n                          : html`\n                              <sbb-screen-reader-only\n                                >${`${i18nCalendarWeekNumber[this._language.current]} ${weekNumber}`}</sbb-screen-reader-only\n                              >\n                              <span aria-hidden=\"true\">${weekNumber}</span>\n                            `}\n                      </th>\n                    `,\n                  )}\n                </tr>\n              </thead>\n            `\n          : nothing}\n        <tbody class=\"sbb-calendar__table-body\">\n          ${weeks.map((week: Day<T>[], rowIndex: number) => {\n            const weekday = this._weekdays[rowIndex];\n            const selectableDays = this._wide ? [...week, ...this._nextMonthWeeks[rowIndex]] : week;\n            return html`\n              <tr>\n                ${nextMonthActiveDate\n                  ? nothing\n                  : html`\n                      <td class=\"sbb-calendar__table-header-cell-vertical\">\n                        ${this.multiple\n                          ? html`\n                              <button\n                                class=\"sbb-calendar__header-cell sbb-calendar__weekday\"\n                                aria-label=${weekday.long}\n                                @click=${() => this._selectMultipleDates(selectableDays)}\n                              >\n                                ${weekday.narrow}\n                              </button>\n                            `\n                          : html`\n                              <sbb-screen-reader-only>${weekday.long}</sbb-screen-reader-only>\n                              <span aria-hidden=\"true\">${weekday.narrow}</span>\n                            `}\n                      </td>\n                    `}\n                ${rowIndex < weekOffset\n                  ? html`<td class=\"sbb-calendar__table-data\"></td>`\n                  : nothing}\n                ${this._createDayCells(week)}\n              </tr>\n            `;\n          })}\n        </tbody>\n      </table>\n    `;\n  }\n\n  /** Creates the cells for the daily view. */\n  private _createDayCells(week: Day<T>[]): TemplateResult[] {\n    return week.map((day: Day<T>) => {\n      return html`\n        <td class=\" sbb-calendar__table-data sbb-calendar__day-cell\">\n          <slot name=${day.value}>\n            <sbb-calendar-day\n              slot=${day.value}\n              @click=${() => this._selectDate(day.dateValue)}\n              @keydown=${(evt: KeyboardEvent) => this._handleKeyboardEvent(evt, day)}\n            ></sbb-calendar-day>\n          </slot>\n        </td>\n      `;\n    });\n  }\n\n  /** Render the view for the month selection. */\n  private _renderMonthView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYear(-1),\n          i18nPreviousYear[this._language.current],\n          this._previousYearDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForMonthView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYear(1),\n          i18nNextYear[this._language.current],\n          this._nextYearDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-overflow-break\">\n        <div class=\"sbb-calendar__table-container sbb-calendar__table-month-view\">\n          ${this._createMonthTable(this._months, this._chosenYear!)}\n          ${this._wide ? this._createMonthTable(this._months, this._chosenYear! + 1) : nothing}\n        </div>\n      </div>\n    `;\n  }\n\n  /** Creates the label with the year for the monthly view. */\n  private _createLabelForMonthView(): TemplateResult {\n    return html` <button\n        type=\"button\"\n        id=\"sbb-calendar__month-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=${`${i18nCalendarDateSelection[this._language.current]} ${this._chosenYear}`}\n        @click=${() => this._resetCalendarViewAndEmitMonthChange(true)}\n      >\n        ${this._chosenYear} ${this._wide ? ` - ${this._chosenYear! + 1}` : nothing}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${this._chosenYear} </sbb-screen-reader-only>`;\n  }\n\n  /** Creates the table for the month selection view. */\n  private _createMonthTable(months: 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>\n                <th class=\"sbb-calendar__table-header-cell\" colspan=${MONTHS_PER_ROW}>${year}</th>\n              </tr>\n            </thead>`\n          : nothing}\n        <tbody class=\"sbb-calendar__table-body\">\n          ${months.map(\n            (row: Month[]) => html`\n              <tr>\n                ${row.map((month: Month) => {\n                  let selected: boolean;\n                  if (this.multiple) {\n                    selected =\n                      (this._selected as T[]).find(\n                        (date: T) =>\n                          year === this._dateAdapter.getYear(date) &&\n                          month.monthValue === this._dateAdapter.getMonth(date),\n                      ) !== undefined;\n                  } else {\n                    const selectedMonth = this._selected\n                      ? this._dateAdapter.getMonth(this._selected as T)\n                      : undefined;\n                    const selectedYear = this._selected\n                      ? this._dateAdapter.getYear(this._selected as T)\n                      : undefined;\n                    selected =\n                      !!this._selected &&\n                      year === selectedYear &&\n                      month.monthValue === selectedMonth;\n                  }\n                  const isOutOfRange = !this._isMonthInRange(month.monthValue, year);\n                  const isFilteredOut = !this._isMonthFilteredOut(month.monthValue, year);\n                  const isCurrentMonth =\n                    year === this._dateAdapter.getYear(this._dateAdapter.today()) &&\n                    this._dateAdapter.getMonth(this._dateAdapter.today()) === 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__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    this._emitMonthChange();\n  }\n\n  /** Render the view for the year selection. */\n  private _renderYearView(): TemplateResult {\n    return html`\n      <div class=\"sbb-calendar__controls\">\n        ${this._getArrow(\n          'left',\n          () => this._goToDifferentYearRange(-YEARS_PER_PAGE),\n          i18nPreviousYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._previousYearRangeDisabled(),\n        )}\n        <div class=\"sbb-calendar__controls-month\">${this._createLabelForYearView()}</div>\n        ${this._getArrow(\n          'right',\n          () => this._goToDifferentYearRange(YEARS_PER_PAGE),\n          i18nNextYearRange(YEARS_PER_PAGE)[this._language.current],\n          this._nextYearRangeDisabled(),\n        )}\n      </div>\n      <div class=\"sbb-calendar__table-overflow-break\">\n        <div class=\"sbb-calendar__table-container sbb-calendar__table-year-view\">\n          ${this._createYearTable(this._years)}\n          ${this._wide ? this._createYearTable(this._nextMonthYears, true) : nothing}\n        </div>\n      </div>\n    `;\n  }\n\n  /** Creates the button arrow for all the views. */\n  private _getArrow(\n    direction: 'left' | 'right',\n    click: () => void,\n    ariaLabel: string,\n    disabled: boolean,\n  ): TemplateResult {\n    return html`<sbb-secondary-button\n      size=\"m\"\n      icon-name=\"chevron-small-${direction}-small\"\n      aria-label=${ariaLabel}\n      @click=${click}\n      ?disabled=${disabled}\n      id=\"sbb-calendar__controls-${direction === 'left' ? 'previous' : 'next'}\"\n    ></sbb-secondary-button>`;\n  }\n\n  /** Creates the label with the year range for the yearly view. */\n  private _createLabelForYearView(): TemplateResult {\n    const firstYear: number = this._years.flat()[0];\n    const lastYearArray: number[] = (this._wide ? this._nextMonthYears : this._years).flat();\n    const lastYear: number = lastYearArray[lastYearArray.length - 1];\n    const yearLabel = `${firstYear} - ${lastYear}`;\n    return html`\n      <button\n        type=\"button\"\n        id=\"sbb-calendar__year-selection\"\n        class=\"sbb-calendar__controls-change-date\"\n        aria-label=\"${i18nCalendarDateSelection[this._language.current]} ${yearLabel}\"\n        @click=${() => this._resetCalendarViewAndEmitMonthChange(true)}\n      >\n        ${yearLabel}\n        <sbb-icon name=\"chevron-small-up-small\"></sbb-icon>\n      </button>\n      <sbb-screen-reader-only role=\"status\"> ${yearLabel} </sbb-screen-reader-only>\n    `;\n  }\n\n  /** Creates the table for the year selection view. */\n  private _createYearTable(years: number[][], shiftRight = false): TemplateResult {\n    const now = this._dateAdapter.today();\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                let selected: boolean;\n                if (this.multiple) {\n                  selected =\n                    (this._selected as T[]).find(\n                      (date: T) => year === this._dateAdapter.getYear(date),\n                    ) !== undefined;\n                } else {\n                  const selectedYear = this._selected\n                    ? this._dateAdapter.getYear(this._selected as T)\n                    : undefined;\n                  selected = !!this._selected && year === selectedYear;\n                }\n                const isOutOfRange = !this._isYearInRange(year);\n                const isFilteredOut = !this._isYearFilteredOut(year);\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__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 out, if there is a way\n      // to enable it, while considering i18n and date information.\n      return html`${nothing}`;\n    }\n    switch (this._calendarView) {\n      case 'year':\n        return this._renderYearView();\n      case 'month':\n        return this._renderMonthView();\n      case 'day':\n      default:\n        return this._renderDayView();\n    }\n  }\n\n  private _tableAnimationEnd(event: AnimationEvent): void {\n    const table = event.target as HTMLElement;\n    if (event.animationName === 'hide') {\n      table.classList.remove('sbb-calendar__table-hide');\n      if (this._containingFocus) {\n        this._resetFocus = true;\n      }\n      this._calendarView = this._nextCalendarView;\n    } else if (event.animationName === 'show') {\n      this.internals.states.delete('transition');\n    }\n  }\n\n  private _startTableTransition(): void {\n    this.internals.states.add('transition');\n    this.shadowRoot\n      ?.querySelectorAll('table')\n      ?.forEach((e) => e.classList.toggle('sbb-calendar__table-hide'));\n  }\n\n  protected override render(): TemplateResult {\n    return html`<div class=\"sbb-calendar__wrapper\">${this._getView()}</div>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-calendar': SbbCalendarElement;\n  }\n  interface HTMLElementEventMap {\n    monthchange: SbbMonthChangeEvent;\n  }\n}\n"],"names":["defaultOptions","day"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]}