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

package/development/carousel-list.component-DpDh5tqB.js

@@ -0,0 +1,133 @@
+import { html, unsafeCSS } from "lit";
+import { SbbElement, SbbLanguageController, i18nCarouselItemAriaLabel, isArrowKeyPressed } from "./core.js";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { IntersectionController } from "@lit-labs/observers/intersection-controller.js";
+//#region src/elements/carousel/carousel-list/carousel-list.scss?inline
+var carousel_list_default = ":host {\n  --sbb-carousel-list-border-radius: var(--sbb-border-radius-4x);\n  display: flex;\n  height: var(--sbb-carousel-list-height);\n  width: var(--sbb-carousel-list-width, 0);\n  overflow-x: auto;\n  scroll-snap-type: x mandatory;\n  scroll-behavior: smooth;\n  scrollbar-width: none;\n  outline: none;\n  border-radius: var(--sbb-carousel-inherit-border-radius);\n}\n\n:host(:focus-visible)::before {\n  outline-offset: var(--sbb-focus-outline-offset);\n  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);\n  content: \"\";\n  position: absolute;\n  height: inherit;\n  width: inherit;\n  border-start-start-radius: var(--sbb-carousel-list-border-radius);\n  border-start-end-radius: var(--sbb-carousel-list-border-radius);\n  border-end-start-radius: var(--sbb-carousel-inherit-border-radius);\n  border-end-end-radius: var(--sbb-carousel-inherit-border-radius);\n}";
+//#endregion
+//#region src/elements/carousel/carousel-list/carousel-list.component.ts
+/**
+* It displays a list of `sbb-carousel-item` components.
+*
+* @slot - Use the unnamed slot to add `sbb-carousel-item` elements.
+*/
+var SbbCarouselListElement = class extends SbbElement {
+	static {
+		this.elementName = "sbb-carousel-list";
+	}
+	static {
+		this.styles = [unsafeCSS(carousel_list_default)];
+	}
+	constructor() {
+		super();
+		this._currentIndex = 0;
+		this._language = new SbbLanguageController(this);
+		this._observedCarouselItems = [];
+		this._beforeShowObserver = new IntersectionController(this, {
+			target: null,
+			callback: (entry) => {
+				entry.filter((e) => e.isIntersecting && e.target !== this).forEach((e) => {
+					const target = e.target;
+					target.dispatchEvent(new CustomEvent("beforeshow", {
+						detail: { index: this._carouselItems().findIndex((e) => e === target) },
+						bubbles: true,
+						composed: true
+					}));
+				});
+			},
+			config: {
+				threshold: .01,
+				root: this,
+				rootMargin: "100% 0% 100% 0%"
+			}
+		});
+		this._showObserver = new IntersectionController(this, {
+			target: null,
+			callback: (entryArr) => {
+				for (const entry of entryArr) {
+					if (entry.target === this) continue;
+					const target = entry.target;
+					if (entry.isIntersecting) {
+						target.ariaHidden = null;
+						this._currentIndex = this._carouselItems().findIndex((el) => el === target);
+						target.dispatchEvent(new CustomEvent("show", {
+							detail: { index: this._currentIndex },
+							bubbles: true,
+							composed: true
+						}));
+					} else target.ariaHidden = "true";
+				}
+			},
+			config: {
+				threshold: .99,
+				root: this,
+				rootMargin: "100% 0% 100% 0%"
+			}
+		});
+		this._resizeObserverController = new ResizeController(this, {
+			skipInitial: true,
+			callback: () => this._readDimensions()
+		});
+		this.addEventListener?.("keydown", (e) => this._onKeyDown(e));
+	}
+	/** Gets the slotted items. */
+	_carouselItems() {
+		return Array.from(this.querySelectorAll?.("sbb-carousel-item") ?? []);
+	}
+	_handleSlotchange() {
+		this._observedCarouselItems.forEach((item) => {
+			this._beforeShowObserver.unobserve(item);
+			this._showObserver.unobserve(item);
+		});
+		const carouselItems = this._carouselItems();
+		carouselItems.forEach((item, index) => {
+			item.ariaLabel ||= i18nCarouselItemAriaLabel(index + 1, carouselItems.length)[this._language.current];
+			item.ariaHidden = index === this._currentIndex ? null : "true";
+		});
+		this._readDimensions();
+	}
+	/**
+	* Reads the dimensions of the first carousel item and sets the CSS properties accordingly.
+	* Should set the dimensions only once, when the first item becomes visible and if the value is non-zero.
+	*/
+	_readDimensions() {
+		const carouselItems = this._carouselItems();
+		if (carouselItems.length === 0) return;
+		const firstItem = carouselItems[0];
+		if (firstItem.clientHeight > 0) this.style.setProperty("--sbb-carousel-list-height", `${firstItem.clientHeight}px`);
+		if (firstItem.clientWidth > 0) {
+			this.style.setProperty("--sbb-carousel-list-width", `${firstItem.clientWidth}px`);
+			carouselItems.forEach((item) => {
+				this._beforeShowObserver.observe(item);
+				this._showObserver.observe(item);
+			});
+			this._observedCarouselItems = carouselItems;
+			this._resizeObserverController.unobserve(this);
+		}
+	}
+	_onKeyDown(evt) {
+		if (!isArrowKeyPressed(evt)) return;
+		evt.preventDefault();
+		let newIndex = this._currentIndex;
+		const isPrev = evt.key === "ArrowUp" || evt.key === "ArrowLeft";
+		const isNext = evt.key === "ArrowDown" || evt.key === "ArrowRight";
+		if (isPrev) newIndex = Math.max(0, this._currentIndex - 1);
+		else if (isNext) newIndex = Math.min(this._carouselItems().length - 1, this._currentIndex + 1);
+		if (newIndex !== this._currentIndex) {
+			this._currentIndex = newIndex;
+			this.scrollTo({ left: this._carouselItems()[this._currentIndex].offsetLeft - this.offsetLeft });
+		}
+	}
+	connectedCallback() {
+		super.connectedCallback();
+		this.internals.ariaLive = "polite";
+		this.internals.ariaAtomic = "true";
+	}
+	render() {
+		return html`<slot @slotchange=${this._handleSlotchange}></slot>`;
+	}
+};
+//#endregion
+export { SbbCarouselListElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"carousel-list.component-DpDh5tqB.js","names":[],"sources":["../../../src/elements/carousel/carousel-list/carousel-list.scss?inline","../../../src/elements/carousel/carousel-list/carousel-list.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-carousel-list-border-radius: var(--sbb-border-radius-4x);\n\n  display: flex;\n  height: var(--sbb-carousel-list-height);\n\n  // Setting 0px as fallback to avoid instant scrolling on Safari when loading the page\n  width: var(--sbb-carousel-list-width, 0);\n  overflow-x: auto;\n  scroll-snap-type: x mandatory;\n  scroll-behavior: smooth;\n  scrollbar-width: none;\n  outline: none;\n  border-radius: var(--sbb-carousel-inherit-border-radius);\n}\n\n:host(:focus-visible) {\n  &::before {\n    @include sbb.focus-outline;\n\n    content: '';\n    position: absolute;\n    height: inherit;\n    width: inherit;\n    border-start-start-radius: var(--sbb-carousel-list-border-radius);\n    border-start-end-radius: var(--sbb-carousel-list-border-radius);\n    border-end-start-radius: var(--sbb-carousel-inherit-border-radius);\n    border-end-end-radius: var(--sbb-carousel-inherit-border-radius);\n  }\n}\n","import { IntersectionController } from '@lit-labs/observers/intersection-controller.js';\nimport { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport { type CSSResultGroup, html, type TemplateResult, unsafeCSS } from 'lit';\n\nimport {\n  i18nCarouselItemAriaLabel,\n  isArrowKeyPressed,\n  SbbElement,\n  SbbLanguageController,\n} from '../../core.ts';\nimport type {\n  SbbCarouselItemElement,\n  SbbCarouselItemEventDetail,\n} from '../carousel-item/carousel-item.component.ts';\n\nimport style from './carousel-list.scss?inline';\n\n/**\n * It displays a list of `sbb-carousel-item` components.\n *\n * @slot - Use the unnamed slot to add `sbb-carousel-item` elements.\n */\nexport class SbbCarouselListElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-carousel-list';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n\n  private _currentIndex = 0;\n  private _language = new SbbLanguageController(this);\n  private _observedCarouselItems: SbbCarouselItemElement[] = [];\n\n  private _beforeShowObserver = new IntersectionController(this, {\n    target: null,\n    callback: (entry) => {\n      const item = entry.filter((e) => e.isIntersecting && e.target !== this);\n      item.forEach((e) => {\n        const target = e.target as SbbCarouselItemElement;\n        target.dispatchEvent(\n          new CustomEvent<SbbCarouselItemEventDetail>('beforeshow', {\n            detail: { index: this._carouselItems().findIndex((e) => e === target) },\n            bubbles: true,\n            composed: true,\n          }),\n        );\n      });\n    },\n    config: { threshold: 0.01, root: this, rootMargin: '100% 0% 100% 0%' },\n  });\n\n  private _showObserver = new IntersectionController(this, {\n    target: null,\n    callback: (entryArr) => {\n      for (const entry of entryArr) {\n        if (entry.target === this) {\n          continue;\n        }\n        const target = entry.target as SbbCarouselItemElement;\n        if (entry.isIntersecting) {\n          target.ariaHidden = null;\n          this._currentIndex = this._carouselItems().findIndex((el) => el === target);\n          target.dispatchEvent(\n            new CustomEvent<SbbCarouselItemEventDetail>('show', {\n              detail: { index: this._currentIndex },\n              bubbles: true,\n              composed: true,\n            }),\n          );\n        } else {\n          target.ariaHidden = 'true';\n        }\n      }\n    },\n    config: { threshold: 0.99, root: this, rootMargin: '100% 0% 100% 0%' },\n  });\n\n  private _resizeObserverController = new ResizeController(this, {\n    skipInitial: true,\n    callback: () => this._readDimensions(),\n  });\n\n  public constructor() {\n    super();\n\n    this.addEventListener?.('keydown', (e) => this._onKeyDown(e));\n  }\n\n  /** Gets the slotted items. */\n  private _carouselItems(): SbbCarouselItemElement[] {\n    return Array.from(this.querySelectorAll?.('sbb-carousel-item') ?? []);\n  }\n\n  private _handleSlotchange(): void {\n    // In case of removed carousel items, we need to unobserve the current observers.\n    this._observedCarouselItems.forEach((item) => {\n      this._beforeShowObserver.unobserve(item);\n      this._showObserver.unobserve(item);\n    });\n\n    const carouselItems = this._carouselItems();\n\n    // Set the aria-label if not provided\n    carouselItems.forEach((item, index) => {\n      item.ariaLabel ||= i18nCarouselItemAriaLabel(index + 1, carouselItems.length)[\n        this._language.current\n      ];\n      item.ariaHidden = index === this._currentIndex ? null : 'true';\n    });\n\n    this._readDimensions();\n  }\n\n  /**\n   * Reads the dimensions of the first carousel item and sets the CSS properties accordingly.\n   * Should set the dimensions only once, when the first item becomes visible and if the value is non-zero.\n   */\n  private _readDimensions(): void {\n    const carouselItems = this._carouselItems();\n    if (carouselItems.length === 0) {\n      return;\n    }\n\n    const firstItem = carouselItems[0];\n\n    if (firstItem.clientHeight > 0) {\n      this.style.setProperty('--sbb-carousel-list-height', `${firstItem.clientHeight}px`);\n    }\n\n    if (firstItem.clientWidth > 0) {\n      this.style.setProperty('--sbb-carousel-list-width', `${firstItem.clientWidth}px`);\n\n      // We should only observe the items if they have a non-zero width. Otherwise, an unwanted scrolling can happen.\n      carouselItems.forEach((item) => {\n        this._beforeShowObserver.observe(item);\n        this._showObserver.observe(item);\n      });\n      this._observedCarouselItems = carouselItems;\n      this._resizeObserverController.unobserve(this);\n    }\n  }\n\n  private _onKeyDown(evt: KeyboardEvent): void {\n    if (!isArrowKeyPressed(evt)) {\n      return;\n    }\n    evt.preventDefault();\n\n    let newIndex = this._currentIndex;\n    const isPrev = evt.key === 'ArrowUp' || evt.key === 'ArrowLeft';\n    const isNext = evt.key === 'ArrowDown' || evt.key === 'ArrowRight';\n\n    if (isPrev) {\n      newIndex = Math.max(0, this._currentIndex - 1);\n    } else if (isNext) {\n      newIndex = Math.min(this._carouselItems().length - 1, this._currentIndex + 1);\n    }\n\n    if (newIndex !== this._currentIndex) {\n      this._currentIndex = newIndex;\n      this.scrollTo({\n        left: this._carouselItems()[this._currentIndex].offsetLeft - this.offsetLeft,\n      });\n    }\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this.internals.ariaLive = 'polite';\n    this.internals.ariaAtomic = 'true';\n  }\n\n  protected override render(): TemplateResult {\n    return html`<slot @slotchange=${this._handleSlotchange}></slot>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-carousel-list': SbbCarouselListElement;\n  }\n}\n"],"mappings":"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"}

package/development/carousel.component-ClWvnZ8s.js

@@ -0,0 +1,139 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement, SbbLanguageController, forceType, i18nCarouselArrowsNavigationHint, i18nNextSlide, i18nPreviousSlide, i18nSlide, screenReaderOnlyStyles } from "./core.js";
+//#region src/elements/carousel/carousel/carousel.scss?inline
+var carousel_default = ":host {\n  display: inline-block;\n  overflow: hidden;\n  border-radius: var(--sbb-carousel-border-radius) var(--sbb-carousel-border-radius) 0 0;\n}\n\n:host([shadow]) {\n  box-shadow: var(--sbb-carousel-box-shadow);\n  border-radius: var(--sbb-carousel-border-radius);\n}\n\n:host(:not([shadow])) ::slotted(sbb-carousel-list) {\n  --sbb-carousel-inherit-border-radius: var(--sbb-carousel-border-radius);\n}\n\n.sbb-carousel {\n  display: flex;\n  flex-direction: column;\n  justify-content: center;\n  align-items: center;\n  background-color: var(--sbb-carousel-background-color);\n}\n\n::slotted(sbb-compact-paginator) {\n  padding: var(--sbb-carousel-paginator-padding);\n}";
+//#endregion
+//#region src/elements/carousel/carousel/carousel.component.ts
+/**
+* It displays a carousel component.
+*
+* @slot - Use the unnamed slot to add the `sbb-carousel-list` for content and a `sbb-paginator` for controls.
+*/
+var SbbCarouselElement = (() => {
+	let _classSuper = SbbElement;
+	let _shadow_decorators;
+	let _shadow_initializers = [];
+	let _shadow_extraInitializers = [];
+	return class SbbCarouselElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_shadow_decorators = [forceType(), property({
+				reflect: true,
+				type: Boolean
+			})];
+			__esDecorate(this, null, _shadow_decorators, {
+				kind: "accessor",
+				name: "shadow",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "shadow" in obj,
+					get: (obj) => obj.shadow,
+					set: (obj, value) => {
+						obj.shadow = value;
+					}
+				},
+				metadata: _metadata
+			}, _shadow_initializers, _shadow_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-carousel";
+		}
+		static {
+			this.styles = [screenReaderOnlyStyles, unsafeCSS(carousel_default)];
+		}
+		#shadow_accessor_storage;
+		/**
+		* Used to display a box-shadow around the component.
+		*/
+		get shadow() {
+			return this.#shadow_accessor_storage;
+		}
+		set shadow(value) {
+			this.#shadow_accessor_storage = value;
+		}
+		constructor() {
+			super();
+			this.#shadow_accessor_storage = __runInitializers(this, _shadow_initializers, false);
+			this._paginator = (__runInitializers(this, _shadow_extraInitializers), null);
+			this._abortController = null;
+			this._language = new SbbLanguageController(this);
+			this._requestedPageIndexByPaginator = -1;
+			this.addEventListener?.("show", (e) => {
+				if (this._requestedPageIndexByPaginator !== -1 && this._requestedPageIndexByPaginator !== e.detail.index) return;
+				if (this._paginator) {
+					if (e.detail.index !== this._paginator.pageIndex) this._paginator.pageIndex = e.detail.index;
+				}
+				this._requestedPageIndexByPaginator = -1;
+			});
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.internals.role = "region";
+			this.internals.ariaLabel = "carousel";
+			this._setupPaginator();
+		}
+		firstUpdated(_changedProperties) {
+			super.firstUpdated(_changedProperties);
+			this.internals.ariaDescribedByElements = [this.shadowRoot.querySelector("#sbb-carousel-arrows-navigation-hint")];
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this._abortController?.abort();
+		}
+		_handleSlotchange() {
+			const paginator = Array.from(this.children).find((el) => el.localName === "sbb-compact-paginator");
+			const list = Array.from(this.children).find((el) => el.localName === "sbb-carousel-list");
+			if (!paginator || !list) return;
+			const items = list.querySelectorAll("sbb-carousel-item");
+			if (items && items.length > 0) {
+				paginator.length = items.length;
+				paginator.pageSize = 1;
+			}
+			paginator.accessibilityNextPageLabel ||= i18nNextSlide[this._language.current];
+			paginator.accessibilityPreviousPageLabel ||= i18nPreviousSlide[this._language.current];
+			paginator.accessibilityPageLabel ||= i18nSlide[this._language.current];
+			if (paginator !== this._paginator) {
+				this._paginator = paginator;
+				this._setupPaginator();
+			}
+		}
+		_setupPaginator() {
+			this._abortController?.abort();
+			if (!this._paginator) return;
+			this._abortController = new AbortController();
+			this._paginator.addEventListener("click", () => this._scrollAtPaginatorChange(), { signal: this._abortController.signal });
+		}
+		_scrollAtPaginatorChange() {
+			if (!this._paginator) return;
+			this._requestedPageIndexByPaginator = this._paginator.pageIndex;
+			const list = this.querySelector("sbb-carousel-list");
+			if (list) {
+				const offsetLeft = list.querySelectorAll("sbb-carousel-item")[this._paginator.pageIndex].offsetLeft - this.offsetLeft;
+				if (list.clientWidth <= 100 || Math.abs(list.scrollLeft - offsetLeft) > 50) list.scrollTo({ left: offsetLeft });
+			}
+		}
+		render() {
+			return html`
+      <div class="sbb-carousel">
+        <span class="sbb-screen-reader-only" id="sbb-carousel-arrows-navigation-hint"
+          >${i18nCarouselArrowsNavigationHint[this._language.current]}</span
+        >
+        <slot @slotchange=${this._handleSlotchange}></slot>
+      </div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbCarouselElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"carousel.component-ClWvnZ8s.js","names":[],"sources":["../../../src/elements/carousel/carousel/carousel.scss?inline","../../../src/elements/carousel/carousel/carousel.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  display: inline-block;\n  overflow: hidden;\n  border-radius: var(--sbb-carousel-border-radius) var(--sbb-carousel-border-radius) 0 0;\n}\n\n:host([shadow]) {\n  box-shadow: var(--sbb-carousel-box-shadow);\n  border-radius: var(--sbb-carousel-border-radius);\n}\n\n:host(:not([shadow])) ::slotted(sbb-carousel-list) {\n  --sbb-carousel-inherit-border-radius: var(--sbb-carousel-border-radius);\n}\n\n.sbb-carousel {\n  display: flex;\n  flex-direction: column;\n  justify-content: center;\n  align-items: center;\n  background-color: var(--sbb-carousel-background-color);\n}\n\n::slotted(sbb-compact-paginator) {\n  padding: var(--sbb-carousel-paginator-padding);\n}\n","import type { PropertyValues } from '@lit/reactive-element';\nimport { type CSSResultGroup, html, type TemplateResult, unsafeCSS } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport {\n  forceType,\n  i18nCarouselArrowsNavigationHint,\n  i18nNextSlide,\n  i18nPreviousSlide,\n  i18nSlide,\n  SbbElement,\n  SbbLanguageController,\n  screenReaderOnlyStyles,\n} from '../../core.ts';\nimport type { SbbCompactPaginatorElement } from '../../paginator.pure.ts';\nimport type {\n  SbbCarouselItemElement,\n  SbbCarouselItemEventDetail,\n} from '../carousel-item/carousel-item.component.ts';\nimport type { SbbCarouselListElement } from '../carousel-list/carousel-list.component.ts';\n\nimport style from './carousel.scss?inline';\n\n/**\n * It displays a carousel component.\n *\n * @slot - Use the unnamed slot to add the `sbb-carousel-list` for content and a `sbb-paginator` for controls.\n */\nexport class SbbCarouselElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-carousel';\n  public static override styles: CSSResultGroup = [screenReaderOnlyStyles, unsafeCSS(style)];\n\n  /**\n   * Used to display a box-shadow around the component.\n   */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor shadow: boolean = false;\n\n  private _paginator: SbbCompactPaginatorElement | null = null;\n  private _abortController: AbortController | null = null;\n  private _language = new SbbLanguageController(this);\n  private _requestedPageIndexByPaginator = -1;\n\n  public constructor() {\n    super();\n\n    // If the list is scrolled using mouse/keyboard, it keeps the paginator updated.\n    this.addEventListener?.('show', (e: CustomEvent<SbbCarouselItemEventDetail>) => {\n      // We have to give priority to the paginator for the case,\n      // if during an animation the next page is called from the paginator, the paginator is reset.\n      if (\n        this._requestedPageIndexByPaginator !== -1 &&\n        this._requestedPageIndexByPaginator !== e.detail.index\n      ) {\n        return;\n      }\n      if (this._paginator) {\n        if (e.detail.index !== this._paginator.pageIndex) {\n          this._paginator.pageIndex = e.detail.index;\n        }\n      }\n      this._requestedPageIndexByPaginator = -1;\n    });\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this.internals.role = 'region';\n    this.internals.ariaLabel = 'carousel';\n\n    this._setupPaginator();\n  }\n\n  public override firstUpdated(_changedProperties: PropertyValues): void {\n    super.firstUpdated(_changedProperties);\n\n    this.internals.ariaDescribedByElements = [\n      this.shadowRoot!.querySelector('#sbb-carousel-arrows-navigation-hint')!,\n    ];\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._abortController?.abort();\n  }\n\n  private _handleSlotchange(): void {\n    const paginator: SbbCompactPaginatorElement = Array.from(this.children).find(\n      (el) => el.localName === 'sbb-compact-paginator',\n    ) as SbbCompactPaginatorElement;\n    const list: SbbCarouselListElement = Array.from(this.children).find(\n      (el) => el.localName === 'sbb-carousel-list',\n    ) as SbbCarouselListElement;\n    if (!paginator || !list) {\n      return;\n    }\n    const items = list.querySelectorAll<SbbCarouselItemElement>('sbb-carousel-item');\n    if (items && items.length > 0) {\n      paginator.length = items.length;\n      paginator.pageSize = 1;\n    }\n    paginator.accessibilityNextPageLabel ||= i18nNextSlide[this._language.current];\n    paginator.accessibilityPreviousPageLabel ||= i18nPreviousSlide[this._language.current];\n    paginator.accessibilityPageLabel ||= i18nSlide[this._language.current];\n\n    if (paginator !== this._paginator) {\n      this._paginator = paginator;\n      this._setupPaginator();\n    }\n  }\n\n  private _setupPaginator(): void {\n    this._abortController?.abort();\n\n    if (!this._paginator) {\n      return;\n    }\n    this._abortController = new AbortController();\n\n    // By listening to the click event on the paginator, we can ensure that the change was user triggered.\n    // If we instead use the page event, we would also catch programmatic changes to the paginator\n    // which can cause a loop and wrong timing as we also listen to the show event.\n    this._paginator.addEventListener('click', () => this._scrollAtPaginatorChange(), {\n      signal: this._abortController.signal,\n    });\n  }\n\n  private _scrollAtPaginatorChange(): void {\n    if (!this._paginator) {\n      return;\n    }\n    this._requestedPageIndexByPaginator = this._paginator.pageIndex;\n\n    const list = this.querySelector<SbbCarouselListElement>('sbb-carousel-list');\n\n    if (list) {\n      const items = list.querySelectorAll<SbbCarouselItemElement>('sbb-carousel-item');\n\n      // As the offsetLeft is always rendered from the viewport boundaries, we need to subtract the offsetLeft\n      // from the carousel to get the offset inside the scroll area.\n      const offsetLeft = items[this._paginator.pageIndex].offsetLeft - this.offsetLeft;\n\n      // Prevents redundant scrolling when the paginator updates after a scroll event\n      // by checking the distance between the current and target scroll positions.\n      // (show event is triggered slightly before fully scrolled).\n      if (list.clientWidth <= 100 || Math.abs(list.scrollLeft - offsetLeft) > 50) {\n        list.scrollTo({ left: offsetLeft });\n      }\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-carousel\">\n        <span class=\"sbb-screen-reader-only\" id=\"sbb-carousel-arrows-navigation-hint\"\n          >${i18nCarouselArrowsNavigationHint[this._language.current]}</span\n        >\n        <slot @slotchange=${this._handleSlotchange}></slot>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-carousel': SbbCarouselElement;\n  }\n}\n"],"mappings":"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"}

package/development/carousel.js

@@ -1,6 +1,6 @@
-import { t as SbbCarouselItemElement } from "./carousel-item.component-MZIypyNR.js";
-import { t as SbbCarouselListElement } from "./carousel-list.component-z40-4ANn.js";
-import { t as SbbCarouselElement } from "./carousel.component-BHYBvOm7.js";
+import { t as SbbCarouselItemElement } from "./carousel-item.component-B_0wdIAu.js";
+import { t as SbbCarouselListElement } from "./carousel-list.component-DpDh5tqB.js";
+import { t as SbbCarouselElement } from "./carousel.component-ClWvnZ8s.js";
 import "./carousel.pure.js";
 //#region src/elements/carousel.ts
 /** @entrypoint */

package/development/carousel.pure.js

@@ -1,4 +1,4 @@
-import { t as SbbCarouselItemElement } from "./carousel-item.component-MZIypyNR.js";
-import { t as SbbCarouselListElement } from "./carousel-list.component-z40-4ANn.js";
-import { t as SbbCarouselElement } from "./carousel.component-BHYBvOm7.js";
+import { t as SbbCarouselItemElement } from "./carousel-item.component-B_0wdIAu.js";
+import { t as SbbCarouselListElement } from "./carousel-list.component-DpDh5tqB.js";
+import { t as SbbCarouselElement } from "./carousel.component-ClWvnZ8s.js";
 export { SbbCarouselElement, SbbCarouselItemElement, SbbCarouselListElement };

package/development/checkbox/checkbox.component.d.ts

@@ -1,6 +1,5 @@
 import { CSSResultGroup, TemplateResult } from 'lit';
-import { SbbElement, SbbElementType, SbbIconPlacement } from '../core.ts';
-import { SbbCheckboxSize } from './common/checkbox-common.ts';
+import { SbbElement, SbbElementType } from '../core.ts';
 declare const SbbCheckboxElement_base: import('../core.ts').AbstractConstructor<import('../icon.pure.ts').SbbIconNameMixinType> & import('../core.ts').AbstractConstructor<import('./common/checkbox-common.ts').SbbCheckboxCommonElementMixinType> & typeof SbbElement;
 /**
  * It displays a checkbox enhanced with the SBB Design.
@@ -18,12 +17,11 @@ export declare class SbbCheckboxElement<T = string> extends SbbCheckboxElement_b
     /** Value of the form element. */
     accessor value: T | null;
     /**
-     * Size variant, either xs, s or m.
-     * @default 'm' / 'xs' (lean)
+     * Size variant, either xs (lean theme default), s or m (standard theme default).
      */
-    accessor size: SbbCheckboxSize;
+    accessor size: 'xs' | 's' | 'm' | null;
     /** The label position relative to the labelIcon. Defaults to end */
-    accessor iconPlacement: SbbIconPlacement;
+    accessor iconPlacement: 'start' | 'end';
     protected render(): TemplateResult;
 }
 declare global {

package/development/checkbox/checkbox.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkbox.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/checkbox/checkbox.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAQ,KAAK,cAAc,EAAa,MAAM,KAAK,CAAC;AAGhF,OAAO,EAIL,UAAU,EACV,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAKpB,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,6BAA6B,CAAC;;AAErC;;;;;;;;GAQG;AACH,qBAAa,kBAAkB,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,uBAEnD;IACC,gBAAgC,WAAW,EAAE,MAAM,CAAkB;IACrE,OAAuB,mBAAmB,EAAE,cAAc,EAAE,CAA8B;IAC1F,OAAuB,MAAM,EAAE,cAAc,CAI3C;IAEF,iCAAiC;IACjC,SACgB,KAAK,EAAE,CAAC,GAAG,IAAI,CAAQ;IAEvC;;;OAGG;IACH,SAEgB,IAAI,EAAE,eAAe,CAAyB;IAE9D,oEAAoE;IACpE,SACgB,aAAa,EAAE,gBAAgB,CAAS;cAErC,MAAM,IAAI,cAAc;CAsB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,cAAc,EAAE,kBAAkB,CAAC;KACpC;CACF"}
+{"version":3,"file":"checkbox.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/checkbox/checkbox.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAiB,KAAK,cAAc,EAAa,MAAM,KAAK,CAAC;AAGzF,OAAO,EAAe,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;;AAO1E;;;;;;;;GAQG;AACH,qBAAa,kBAAkB,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,uBAEnD;IACC,gBAAgC,WAAW,EAAE,MAAM,CAAkB;IACrE,OAAuB,mBAAmB,EAAE,cAAc,EAAE,CAA8B;IAC1F,OAAuB,MAAM,EAAE,cAAc,CAAsB;IAEnE,iCAAiC;IACjC,SACgB,KAAK,EAAE,CAAC,GAAG,IAAI,CAAQ;IAEvC;;OAEG;IACH,SAEgB,IAAI,EAAE,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,CAAQ;IAErD,oEAAoE;IACpE,SACgB,aAAa,EAAE,OAAO,GAAG,KAAK,CAAS;cAEpC,MAAM,IAAI,cAAc;CAsB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,cAAc,EAAE,kBAAkB,CAAC;KACpC;CACF"}

package/development/checkbox/checkbox.component.js

@@ -1,2 +1,2 @@
-import { t as SbbCheckboxElement } from "../checkbox.component-DZjhQhbB.js";
+import { t as SbbCheckboxElement } from "../checkbox.component-UbxCpZmi.js";
 export { SbbCheckboxElement };

package/development/checkbox/common/checkbox-common.d.ts

@@ -1,7 +1,5 @@
 import { SbbCheckboxGroupElement } from '../../checkbox-group/checkbox-group.component.ts';
 import { AbstractConstructor, SbbElement } from '../../core.ts';
-export declare const checkboxCommonStyle: import('lit').CSSResult;
-export type SbbCheckboxSize = 'xs' | 's' | 'm';
 declare const SbbCheckboxCommonElementMixinType_base: AbstractConstructor<import('../../core.ts').SbbFormAssociatedCheckboxMixinType> & typeof SbbElement;
 export declare abstract class SbbCheckboxCommonElementMixinType extends SbbCheckboxCommonElementMixinType_base {
     accessor indeterminate: boolean;

package/development/checkbox/common/checkbox-common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkbox-common.d.ts","sourceRoot":"","sources":["../../../../../src/elements/checkbox/common/checkbox-common.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAChG,OAAO,EACL,KAAK,mBAAmB,EAExB,UAAU,EAEX,MAAM,eAAe,CAAC;AAIvB,eAAO,MAAM,mBAAmB,yBAAuC,CAAC;AAExE,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,CAAC;;AAE/C,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,iCAAkC,SAAQ,sCAEvE;IACC,SAAgB,aAAa,EAAE,OAAO,CAAC;IAEvC,IAAW,KAAK,IAAI,uBAAuB,GAAG,IAAI,CAAC;CACpD;AAGD,eAAO,MAAM,6BAA6B,GAAI,CAAC,SAAS,mBAAmB,CAAC,UAAU,CAAC,EACrF,YAAY,CAAC,KACZ,mBAAmB,CAAC,iCAAiC,CAAC,GAAG,CAgD3D,CAAC"}
+{"version":3,"file":"checkbox-common.d.ts","sourceRoot":"","sources":["../../../../../src/elements/checkbox/common/checkbox-common.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAChG,OAAO,EACL,KAAK,mBAAmB,EAExB,UAAU,EAEX,MAAM,eAAe,CAAC;;AAIvB,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,iCAAkC,SAAQ,sCAEvE;IACC,SAAgB,aAAa,EAAE,OAAO,CAAC;IAEvC,IAAW,KAAK,IAAI,uBAAuB,GAAG,IAAI,CAAC;CACpD;AAGD,eAAO,MAAM,6BAA6B,GAAI,CAAC,SAAS,mBAAmB,CAAC,UAAU,CAAC,EACrF,YAAY,CAAC,KACZ,mBAAmB,CAAC,iCAAiC,CAAC,GAAG,CAkD3D,CAAC"}

package/development/checkbox/common/checkbox-common.js

@@ -1,2 +1,2 @@
-import { n as checkboxCommonStyle, t as SbbCheckboxCommonElementMixin } from "../../checkbox-common-DOoEKgML.js";
-export { SbbCheckboxCommonElementMixin, checkboxCommonStyle };
+import { t as SbbCheckboxCommonElementMixin } from "../../checkbox-common-C3Ekixul.js";
+export { SbbCheckboxCommonElementMixin };

package/development/checkbox-common-C3Ekixul.js

@@ -0,0 +1,88 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbFormAssociatedCheckboxMixin, forceType } from "./core.js";
+//#region src/elements/checkbox/common/checkbox-common.scss?inline
+var checkbox_common_default = "@charset \"UTF-8\";\n:host([size=xs]) {\n  --sbb-checkbox-font-size: var(--sbb-text-font-size-xs);\n  --sbb-checkbox-dimension: var(--sbb-checkbox-dimension-xs);\n}\n\n:host([size=s]) {\n  --sbb-checkbox-font-size: var(--sbb-text-font-size-s);\n  --sbb-checkbox-dimension: var(--sbb-checkbox-dimension-s);\n}\n\n:host([size=m]) {\n  --sbb-checkbox-font-size: var(--sbb-text-font-size-m);\n  --sbb-checkbox-dimension: var(--sbb-checkbox-dimension-m);\n}\n\n:host(:disabled) {\n  --sbb-checkbox-cursor: var(--sbb-cursor-default);\n  --sbb-checkbox-label-color: var(--sbb-color-granite);\n  --sbb-checkbox-label-color: light-dark(var(--sbb-color-granite), var(--sbb-color-aluminium));\n}\n\n.sbb-checkbox-wrapper {\n  display: flex;\n}\n.sbb-checkbox-wrapper::before {\n  content: \"​\";\n  user-select: none;\n  width: 0;\n  height: 0;\n}\n\n.sbb-checkbox {\n  position: relative;\n  display: block;\n  width: 100%;\n  cursor: var(--sbb-checkbox-cursor);\n  user-select: none;\n  -webkit-tap-highlight-color: transparent;\n  font-size: var(--sbb-checkbox-font-size);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n.sbb-checkbox__inner {\n  display: flex;\n  align-items: start;\n  gap: var(--sbb-spacing-fixed-2x);\n}\n\n.sbb-checkbox__label {\n  display: flex;\n  flex-grow: 1;\n  color: var(--sbb-checkbox-label-color);\n  line-height: max(1em * var(--sbb-typo-line-height-text), var(--sbb-checkbox-dimension));\n}\n\n.sbb-checkbox__aligner {\n  display: flex;\n  align-items: center;\n  height: calc(1em * var(--sbb-typo-line-height-text));\n}";
+//#endregion
+//#region src/elements/checkbox/common/checkbox-common.ts
+var SbbCheckboxCommonElementMixin = (superClass) => {
+	return (() => {
+		let _classSuper = SbbFormAssociatedCheckboxMixin(superClass);
+		let _indeterminate_decorators;
+		let _indeterminate_initializers = [];
+		let _indeterminate_extraInitializers = [];
+		return class SbbCheckboxCommonElement extends _classSuper {
+			constructor() {
+				super(...arguments);
+				this.#indeterminate_accessor_storage = __runInitializers(this, _indeterminate_initializers, false);
+				this._group = (__runInitializers(this, _indeterminate_extraInitializers), null);
+			}
+			static {
+				const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+				_indeterminate_decorators = [forceType(), property({ type: Boolean })];
+				__esDecorate(this, null, _indeterminate_decorators, {
+					kind: "accessor",
+					name: "indeterminate",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "indeterminate" in obj,
+						get: (obj) => obj.indeterminate,
+						set: (obj, value) => {
+							obj.indeterminate = value;
+						}
+					},
+					metadata: _metadata
+				}, _indeterminate_initializers, _indeterminate_extraInitializers);
+				if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+					enumerable: true,
+					configurable: true,
+					writable: true,
+					value: _metadata
+				});
+			}
+			static {
+				this.styles = [unsafeCSS(checkbox_common_default)];
+			}
+			#indeterminate_accessor_storage;
+			/** Whether the checkbox is indeterminate. */
+			get indeterminate() {
+				return this.#indeterminate_accessor_storage;
+			}
+			set indeterminate(value) {
+				this.#indeterminate_accessor_storage = value;
+			}
+			/** Reference to the connected checkbox group. */
+			get group() {
+				return this._group;
+			}
+			connectedCallback() {
+				super.connectedCallback();
+				this._group = this.closest("sbb-checkbox-group");
+				[
+					"disabled",
+					"required",
+					"size"
+				].forEach((p) => this.requestUpdate(p));
+			}
+			willUpdate(changedProperties) {
+				super.willUpdate(changedProperties);
+				if (changedProperties.has("checked") || changedProperties.has("indeterminate")) this.internals.ariaChecked = this.indeterminate ? "mixed" : `${this.checked}`;
+			}
+			isDisabledExternally() {
+				return this.group?.disabled ?? false;
+			}
+			isRequiredExternally() {
+				return this.group?.required ?? false;
+			}
+			withUserInteraction() {
+				if (this.indeterminate) this.indeterminate = false;
+			}
+		};
+	})();
+};
+//#endregion
+export { SbbCheckboxCommonElementMixin as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/checkbox-group/checkbox-group.component.js

@@ -30,4 +30,4 @@ var SbbCheckboxGroupElement = class extends SbbSelectionGroupBaseElement {
 //#endregion
 export { SbbCheckboxGroupElement };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/checkbox-panel/checkbox-panel.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkbox-panel.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/checkbox-panel/checkbox-panel.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAOb,OAAO,EAGL,UAAU,EACV,KAAK,cAAc,EAIpB,MAAM,YAAY,CAAC;;AAGpB;;;;;;;;;;GAUG;AACH,qBAAa,uBAAuB,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,4BAExD;IACC,gBAAgC,WAAW,EAAE,MAAM,CAAwB;IAC3E,OAAuB,mBAAmB,EAAE,cAAc,EAAE,CAG1D;IACF,OAAuB,MAAM,EAAE,cAAc,CAI3C;IAEF,iCAAiC;IACjC,SACgB,KAAK,EAAE,CAAC,GAAG,IAAI,CAAQ;IAEvB,aAAa,CAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI;cASY,MAAM,IAAI,cAAc;CA+B5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,oBAAoB,EAAE,uBAAuB,CAAC;KAC/C;CACF"}
+{"version":3,"file":"checkbox-panel.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/checkbox-panel/checkbox-panel.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAIb,OAAO,EACL,UAAU,EACV,KAAK,cAAc,EAIpB,MAAM,YAAY,CAAC;;AAGpB;;;;;;;;;;GAUG;AACH,qBAAa,uBAAuB,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,4BAExD;IACC,gBAAgC,WAAW,EAAE,MAAM,CAAwB;IAC3E,OAAuB,mBAAmB,EAAE,cAAc,EAAE,CAA8B;IAC1F,OAAuB,MAAM,EAAE,cAAc,CAA4B;IAEzE,iCAAiC;IACjC,SACgB,KAAK,EAAE,CAAC,GAAG,IAAI,CAAQ;IAEvB,aAAa,CAC3B,IAAI,CAAC,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI;cASY,MAAM,IAAI,cAAc;CA+B5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,oBAAoB,EAAE,uBAAuB,CAAC;KAC/C;CACF"}

package/development/checkbox-panel/checkbox-panel.component.js

@@ -1,8 +1,8 @@
 import { __esDecorate, __runInitializers } from "tslib";
 import { html, nothing } from "lit";
 import { property } from "lit/decorators.js";
-import { SbbElement, SbbPanelMixin, SbbScreenReaderOnlyElement, SbbUpdateSchedulerMixin, boxSizingStyles, panelCommonStyle } from "../core.js";
-import { SbbCheckboxCommonElementMixin, checkboxCommonStyle } from "../checkbox/common/checkbox-common.js";
+import { SbbElement, SbbPanelMixin, SbbUpdateSchedulerMixin, screenReaderOnlyStyles } from "../core.js";
+import { SbbCheckboxCommonElementMixin } from "../checkbox/common/checkbox-common.js";
 import { SbbVisualCheckboxElement } from "../visual-checkbox.pure.js";
 //#region src/elements/checkbox-panel/checkbox-panel.component.ts
 /**
@@ -50,14 +50,10 @@ var SbbCheckboxPanelElement = (() => {
 			this.elementName = "sbb-checkbox-panel";
 		}
 		static {
-			this.elementDependencies = [SbbScreenReaderOnlyElement, SbbVisualCheckboxElement];
+			this.elementDependencies = [SbbVisualCheckboxElement];
 		}
 		static {
-			this.styles = [
-				boxSizingStyles,
-				checkboxCommonStyle,
-				panelCommonStyle
-			];
+			this.styles = [screenReaderOnlyStyles];
 		}
 		#value_accessor_storage = __runInitializers(this, _value_initializers, null);
 		/** Value of the form element. */
@@ -88,7 +84,7 @@ var SbbCheckboxPanelElement = (() => {
                   ?checked=${this.checked}
                   ?indeterminate=${this.indeterminate}
                   ?disabled=${this.disabled || this.formDisabled}
-                  .size=${this.size}
+                  size=${this.size || nothing}
                 ></sbb-visual-checkbox>
               </span>
               <span class="sbb-checkbox__label">
@@ -97,7 +93,7 @@ var SbbCheckboxPanelElement = (() => {
               </span>
             </span>
             <slot name="subtext"></slot>
-            ${this.expansionState ? html`<sbb-screen-reader-only>${this.expansionState}</sbb-screen-reader-only>` : nothing}
+            ${this.expansionState ? html`<span class="sbb-screen-reader-only">${this.expansionState}</span>` : nothing}
           </span>
         </span>
       </span>
@@ -112,4 +108,4 @@ var SbbCheckboxPanelElement = (() => {
 //#endregion
 export { SbbCheckboxPanelElement };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtcGFuZWwuY29tcG9uZW50LmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jaGVja2JveC1wYW5lbC9jaGVja2JveC1wYW5lbC5jb21wb25lbnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgdHlwZSBDU1NSZXN1bHRHcm91cCxcbiAgaHRtbCxcbiAgbm90aGluZyxcbiAgdHlwZSBQcm9wZXJ0eURlY2xhcmF0aW9uLFxuICB0eXBlIFRlbXBsYXRlUmVzdWx0LFxufSBmcm9tICdsaXQnO1xuaW1wb3J0IHsgcHJvcGVydHkgfSBmcm9tICdsaXQvZGVjb3JhdG9ycy5qcyc7XG5cbmltcG9ydCB7XG4gIGNoZWNrYm94Q29tbW9uU3R5bGUsXG4gIFNiYkNoZWNrYm94Q29tbW9uRWxlbWVudE1peGluLFxufSBmcm9tICcuLi9jaGVja2JveC9jb21tb24vY2hlY2tib3gtY29tbW9uLnRzJztcbmltcG9ydCB7XG4gIGJveFNpemluZ1N0eWxlcyxcbiAgcGFuZWxDb21tb25TdHlsZSxcbiAgU2JiRWxlbWVudCxcbiAgdHlwZSBTYmJFbGVtZW50VHlwZSxcbiAgU2JiUGFuZWxNaXhpbixcbiAgU2JiU2NyZWVuUmVhZGVyT25seUVsZW1lbnQsXG4gIFNiYlVwZGF0ZVNjaGVkdWxlck1peGluLFxufSBmcm9tICcuLi9jb3JlLnRzJztcbmltcG9ydCB7IFNiYlZpc3VhbENoZWNrYm94RWxlbWVudCB9IGZyb20gJy4uL3Zpc3VhbC1jaGVja2JveC5wdXJlLnRzJztcblxuLyoqXG4gKiBJdCBkaXNwbGF5cyBhIGNoZWNrYm94IGVuaGFuY2VkIHdpdGggc2VsZWN0aW9uIHBhbmVsIGRlc2lnbi5cbiAqXG4gKiBAc2xvdCAtIFVzZSB0aGUgdW5uYW1lZCBzbG90IHRvIGFkZCBjb250ZW50IHRvIHRoZSBgc2JiLWNoZWNrYm94YC5cbiAqIEBzbG90IHN1YnRleHQgLSBTbG90IHVzZWQgdG8gcmVuZGVyIGEgc3VidGV4dCB1bmRlciB0aGUgbGFiZWwgKG9ubHkgdmlzaWJsZSB3aXRoaW4gYSBzZWxlY3Rpb24gcGFuZWwpLlxuICogQHNsb3Qgc3VmZml4IC0gU2xvdCB1c2VkIHRvIHJlbmRlciBhZGRpdGlvbmFsIGNvbnRlbnQgYWZ0ZXIgdGhlIGxhYmVsIChvbmx5IHZpc2libGUgd2l0aGluIGEgc2VsZWN0aW9uIHBhbmVsKS5cbiAqIEBzbG90IGJhZGdlIC0gVXNlIHRoaXMgc2xvdCB0byBwcm92aWRlIGEgYHNiYi1jYXJkLWJhZGdlYCAob3B0aW9uYWwpLlxuICogQGV2ZW50IHtFdmVudH0gY2hhbmdlIC0gVGhlIGNoYW5nZSBldmVudCBpcyBmaXJlZCB3aGVuIHRoZSB1c2VyIG1vZGlmaWVzIHRoZSBlbGVtZW50J3MgdmFsdWUuIFVubGlrZSB0aGUgaW5wdXQgZXZlbnQsIHRoZSBjaGFuZ2UgZXZlbnQgaXMgbm90IG5lY2Vzc2FyaWx5IGZpcmVkIGZvciBlYWNoIGFsdGVyYXRpb24gdG8gYW4gZWxlbWVudCdzIHZhbHVlLlxuICogQGV2ZW50IHtJbnB1dEV2ZW50fSBpbnB1dCAtIFRoZSBpbnB1dCBldmVudCBmaXJlcyB3aGVuIHRoZSB2YWx1ZSBoYXMgYmVlbiBjaGFuZ2VkIGFzIGEgZGlyZWN0IHJlc3VsdCBvZiBhIHVzZXIgYWN0aW9uLlxuICogQG92ZXJyaWRlVHlwZSB2YWx1ZSAtIChUID0gc3RyaW5nKSB8IG51bGxcbiAqL1xuZXhwb3J0IGNsYXNzIFNiYkNoZWNrYm94UGFuZWxFbGVtZW50PFQgPSBzdHJpbmc+IGV4dGVuZHMgU2JiUGFuZWxNaXhpbihcbiAgU2JiQ2hlY2tib3hDb21tb25FbGVtZW50TWl4aW4oU2JiVXBkYXRlU2NoZWR1bGVyTWl4aW4oU2JiRWxlbWVudCkpLFxuKSB7XG4gIHB1YmxpYyBzdGF0aWMgb3ZlcnJpZGUgcmVhZG9ubHkgZWxlbWVudE5hbWU6IHN0cmluZyA9ICdzYmItY2hlY2tib3gtcGFuZWwnO1xuICBwdWJsaWMgc3RhdGljIG92ZXJyaWRlIGVsZW1lbnREZXBlbmRlbmNpZXM6IFNiYkVsZW1lbnRUeXBlW10gPSBbXG4gICAgU2JiU2NyZWVuUmVhZGVyT25seUVsZW1lbnQsXG4gICAgU2JiVmlzdWFsQ2hlY2tib3hFbGVtZW50LFxuICBdO1xuICBwdWJsaWMgc3RhdGljIG92ZXJyaWRlIHN0eWxlczogQ1NTUmVzdWx0R3JvdXAgPSBbXG4gICAgYm94U2l6aW5nU3R5bGVzLFxuICAgIGNoZWNrYm94Q29tbW9uU3R5bGUsXG4gICAgcGFuZWxDb21tb25TdHlsZSxcbiAgXTtcblxuICAvKiogVmFsdWUgb2YgdGhlIGZvcm0gZWxlbWVudC4gKi9cbiAgQHByb3BlcnR5KClcbiAgcHVibGljIGFjY2Vzc29yIHZhbHVlOiBUIHwgbnVsbCA9IG51bGw7XG5cbiAgcHVibGljIG92ZXJyaWRlIHJlcXVlc3RVcGRhdGUoXG4gICAgbmFtZT86IFByb3BlcnR5S2V5LFxuICAgIG9sZFZhbHVlPzogdW5rbm93bixcbiAgICBvcHRpb25zPzogUHJvcGVydHlEZWNsYXJhdGlvbixcbiAgKTogdm9pZCB7XG4gICAgc3VwZXIucmVxdWVzdFVwZGF0ZShuYW1lLCBvbGRWYWx1ZSwgb3B0aW9ucyk7XG4gICAgaWYgKG5hbWUgPT09ICdjaGVja2VkJykge1xuICAgICAgdGhpcy5pbnRlcm5hbHMuYXJpYUNoZWNrZWQgPSBgJHt0aGlzLmNoZWNrZWR9YDtcbiAgICAgIC8vIEFzIFNiYkZvcm1Bc3NvY2lhdGVkQ2hlY2tib3hNaXhpbiBkb2VzIG5vdCByZWZsZWN0IGNoZWNrZWQgcHJvcGVydHksIHdlIGFkZCBhIGNoZWNrZWQgQ1NTIHN0YXRlLlxuICAgICAgdGhpcy50b2dnbGVTdGF0ZSgnY2hlY2tlZCcsIHRoaXMuY2hlY2tlZCk7XG4gICAgfVxuICB9XG5cbiAgcHJvdGVjdGVkIG92ZXJyaWRlIHJlbmRlcigpOiBUZW1wbGF0ZVJlc3VsdCB7XG4gICAgcmV0dXJuIGh0bWxgXG4gICAgICA8c3BhbiBjbGFzcz1cInNiYi1zZWxlY3Rpb24tcGFuZWxcIj5cbiAgICAgICAgPGRpdiBjbGFzcz1cInNiYi1zZWxlY3Rpb24tcGFuZWxfX2JhZGdlXCI+XG4gICAgICAgICAgPHNsb3QgbmFtZT1cImJhZGdlXCI+PC9zbG90PlxuICAgICAgICA8L2Rpdj5cbiAgICAgICAgPHNwYW4gY2xhc3M9XCJzYmItY2hlY2tib3gtd3JhcHBlclwiPlxuICAgICAgICAgIDxzcGFuIGNsYXNzPVwic2JiLWNoZWNrYm94XCI+XG4gICAgICAgICAgICA8c3BhbiBjbGFzcz1cInNiYi1jaGVja2JveF9faW5uZXJcIj5cbiAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9XCJzYmItY2hlY2tib3hfX2FsaWduZXJcIj5cbiAgICAgICAgICAgICAgICA8c2JiLXZpc3VhbC1jaGVja2JveFxuICAgICAgICAgICAgICAgICAgP2NoZWNrZWQ9JHt0aGlzLmNoZWNrZWR9XG4gICAgICAgICAgICAgICAgICA/aW5kZXRlcm1pbmF0ZT0ke3RoaXMuaW5kZXRlcm1pbmF0ZX1cbiAgICAgICAgICAgICAgICAgID9kaXNhYmxlZD0ke3RoaXMuZGlzYWJsZWQgfHwgdGhpcy5mb3JtRGlzYWJsZWR9XG4gICAgICAgICAgICAgICAgICAuc2l6ZT0ke3RoaXMuc2l6ZX1cbiAgICAgICAgICAgICAgICA+PC9zYmItdmlzdWFsLWNoZWNrYm94PlxuICAgICAgICAgICAgICA8L3NwYW4+XG4gICAgICAgICAgICAgIDxzcGFuIGNsYXNzPVwic2JiLWNoZWNrYm94X19sYWJlbFwiPlxuICAgICAgICAgICAgICAgIDxzbG90Pjwvc2xvdD5cbiAgICAgICAgICAgICAgICA8c2xvdCBuYW1lPVwic3VmZml4XCI+PC9zbG90PlxuICAgICAgICAgICAgICA8L3NwYW4+XG4gICAgICAgICAgICA8L3NwYW4+XG4gICAgICAgICAgICA8c2xvdCBuYW1lPVwic3VidGV4dFwiPjwvc2xvdD5cbiAgICAgICAgICAgICR7dGhpcy5leHBhbnNpb25TdGF0ZVxuICAgICAgICAgICAgICA/IGh0bWxgPHNiYi1zY3JlZW4tcmVhZGVyLW9ubHk+JHt0aGlzLmV4cGFuc2lvblN0YXRlfTwvc2JiLXNjcmVlbi1yZWFkZXItb25seT5gXG4gICAgICAgICAgICAgIDogbm90aGluZ31cbiAgICAgICAgICA8L3NwYW4+XG4gICAgICAgIDwvc3Bhbj5cbiAgICAgIDwvc3Bhbj5cbiAgICBgO1xuICB9XG59XG5cbmRlY2xhcmUgZ2xvYmFsIHtcbiAgaW50ZXJmYWNlIEhUTUxFbGVtZW50VGFnTmFtZU1hcCB7XG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uYW1pbmctY29udmVudGlvblxuICAgICdzYmItY2hlY2tib3gtcGFuZWwnOiBTYmJDaGVja2JveFBhbmVsRWxlbWVudDtcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7SUFtQ2EsaUNBQXVCO21CQUFxQixjQUN2RCw4QkFBOEIsd0JBQXdCLFdBQVcsQ0FBQyxDQUNuRTs7OztjQUZZLGdDQUE0QyxZQUV4RDs7O3dCQWFFLFVBQVUsQ0FBQTtBQUNYLGdCQUFBLE1BQUEsTUFBQSxtQkFBQTtJQUFBLE1BQUE7SUFBQSxNQUFBO0lBQUEsUUFBQTtJQUFBLFNBQUE7SUFBQSxRQUFBO0tBQUEsTUFBQSxRQUFBLFdBQUE7S0FBQSxNQUFBLFFBQUEsSUFBZ0I7S0FBSyxNQUFBLEtBQUEsVUFBQTtBQUFBLFVBQUwsUUFBSzs7S0FBQTtJQUFBLFVBQUE7SUFBQSxFQUFBLHFCQUFBLHlCQUFBOzs7Ozs7Ozs7QUFiVyxRQUFBLGNBQXNCOzs7QUFDL0IsUUFBQSxzQkFBd0MsQ0FDN0QsNEJBQ0EseUJBQ0Q7OztBQUNzQixRQUFBLFNBQXlCO0lBQzlDO0lBQ0E7SUFDQTtJQUNEOztFQUlELDBCQUFBLGtCQUFBLE1BQUEscUJBQWtDLEtBQUk7O0VBQXRDLElBQWdCLFFBQUs7QUFBQSxVQUFBLE1BQUE7O0VBQXJCLElBQWdCLE1BQUssT0FBQTtBQUFBLFNBQUEseUJBQUE7O0VBRUwsY0FDZCxNQUNBLFVBQ0EsU0FBNkI7QUFFN0IsU0FBTSxjQUFjLE1BQU0sVUFBVSxRQUFRO0FBQzVDLE9BQUksU0FBUyxXQUFXO0FBQ3RCLFNBQUssVUFBVSxjQUFjLEdBQUcsS0FBSztBQUVyQyxTQUFLLFlBQVksV0FBVyxLQUFLLFFBQVE7OztFQUkxQixTQUFNO0FBQ3ZCLFVBQU8sSUFBSTs7Ozs7Ozs7Ozs2QkFVYyxLQUFLLFFBQUE7bUNBQ0MsS0FBSyxjQUFBOzhCQUNWLEtBQUssWUFBWSxLQUFLLGFBQUE7MEJBQzFCLEtBQUssS0FBQTs7Ozs7Ozs7O2NBU2pCLEtBQUssaUJBQ0gsSUFBSSwyQkFBMkIsS0FBSyxlQUFjLDZCQUNsRCxRQUFBIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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