@sbb-esta/lyne-elements-dev 4.7.0-dev.1773388991 → 4.7.0-dev.1773393164

package/development/carousel/carousel/carousel.component.js

@@ -1,2 +1,160 @@
-import { t as SbbCarouselElement } from "../../carousel.component-b4C-hxkj.js";
-export { SbbCarouselElement };
+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, html } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement } from "../../core/base-elements.js";
+import { SbbLanguageController } from "../../core/controllers/language-controller.js";
+import { forceType } from "../../core/decorators.js";
+import { i18nNextSlide, i18nPreviousSlide, i18nSlide, i18nCarouselArrowsNavigationHint } from "../../core/i18n/i18n.js";
+import { boxSizingStyles } from "../../core/styles.js";
+import "../../screen-reader-only.js";
+const style = css`:host {
+  display: inline-block;
+  overflow: hidden;
+  border-radius: var(--sbb-carousel-border-radius) var(--sbb-carousel-border-radius) 0 0;
+}
+
+:host([shadow]) {
+  box-shadow: var(--sbb-carousel-box-shadow);
+  border-radius: var(--sbb-carousel-border-radius);
+}
+
+:host(:not([shadow])) ::slotted(sbb-carousel-list) {
+  --sbb-carousel-inherit-border-radius: var(--sbb-carousel-border-radius);
+}
+
+.sbb-carousel {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  background-color: var(--sbb-carousel-background-color);
+}
+
+::slotted(sbb-compact-paginator) {
+  padding: var(--sbb-carousel-paginator-padding);
+}`;
+let SbbCarouselElement = (() => {
+  var _shadow_accessor_storage, _a;
+  let _classSuper = SbbElement;
+  let _shadow_decorators;
+  let _shadow_initializers = [];
+  let _shadow_extraInitializers = [];
+  return _a = class extends _classSuper {
+    constructor() {
+      super();
+      __privateAdd(this, _shadow_accessor_storage);
+      __privateSet(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;
+      });
+    }
+    /**
+     * Used to display a box-shadow around the component.
+     */
+    get shadow() {
+      return __privateGet(this, _shadow_accessor_storage);
+    }
+    set shadow(value) {
+      __privateSet(this, _shadow_accessor_storage, value);
+    }
+    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 items = list.querySelectorAll("sbb-carousel-item");
+        const offsetLeft = items[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">
+        <sbb-screen-reader-only id="sbb-carousel-arrows-navigation-hint"
+          >${i18nCarouselArrowsNavigationHint[this._language.current]}</sbb-screen-reader-only
+        >
+        <slot @slotchange=${this._handleSlotchange}></slot>
+      </div>
+    `;
+    }
+  }, _shadow_accessor_storage = new WeakMap(), (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _shadow_decorators = [forceType(), property({ reflect: true, type: Boolean })];
+    __esDecorate(_a, 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(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.elementName = "sbb-carousel", _a.styles = [boxSizingStyles, style], _a;
+})();
+export {
+  SbbCarouselElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"carousel.component.js","sources":["../../../../../src/elements/carousel/carousel/carousel.component.ts"],"sourcesContent":["import type { PropertyValues } from '@lit/reactive-element';\nimport type { CSSResultGroup, TemplateResult } from 'lit';\nimport { html } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { SbbLanguageController } from '../../core/controllers/language-controller.ts';\nimport { forceType } from '../../core/decorators.ts';\nimport {\n  i18nCarouselArrowsNavigationHint,\n  i18nNextSlide,\n  i18nPreviousSlide,\n  i18nSlide,\n} from '../../core/i18n/i18n.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport type { SbbCompactPaginatorElement } from '../../paginator/compact-paginator/compact-paginator.component.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 '../../screen-reader-only.ts';\n\nimport style from './carousel.scss?lit&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 = [boxSizingStyles, 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        <sbb-screen-reader-only id=\"sbb-carousel-arrows-navigation-hint\"\n          >${i18nCarouselArrowsNavigationHint[this._language.current]}</sbb-screen-reader-only\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"],"names":[],"mappings":"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"}

package/development/carousel/carousel-item/carousel-item.component.js

@@ -1,2 +1,32 @@
-import { t as SbbCarouselItemElement } from "../../carousel-item.component-DOIXA2QK.js";
-export { SbbCarouselItemElement };
+import { css, html } from "lit";
+import { SbbElement } from "../../core/base-elements.js";
+const style = css`:host {
+  display: flex;
+  scroll-snap-align: start;
+  flex-shrink: 0;
+}
+
+::slotted(sbb-image) {
+  border-radius: unset;
+}`;
+const _SbbCarouselItemElement = class _SbbCarouselItemElement extends SbbElement {
+  connectedCallback() {
+    super.connectedCallback();
+    this.internals.role = "group";
+    this.internals.ariaRoleDescription = "slide";
+  }
+  render() {
+    return html`<slot></slot>`;
+  }
+};
+_SbbCarouselItemElement.elementName = "sbb-carousel-item";
+_SbbCarouselItemElement.styles = style;
+_SbbCarouselItemElement.events = {
+  beforeshow: "beforeshow",
+  show: "show"
+};
+let SbbCarouselItemElement = _SbbCarouselItemElement;
+export {
+  SbbCarouselItemElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/carousel/carousel-item.js

@@ -1,10 +1,8 @@
-import { t as SbbCarouselItemElement } from "../carousel-item.component-DOIXA2QK.js";
-//#region src/elements/carousel/carousel-item.ts
-/** @entrypoint */
+import { SbbCarouselItemElement } from "./carousel-item/carousel-item.component.js";
 SbbCarouselItemElement.define();
 console.warn(`The entrypoint '@sbb-esta/elements/carousel/carousel-item.js' has been deprecated.
 Use either '@sbb-esta/elements/carousel.js' or '@sbb-esta/elements/carousel.pure.js' instead.`);
-//#endregion
-export { SbbCarouselItemElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwtaXRlbS5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY2Fyb3VzZWwvY2Fyb3VzZWwtaXRlbS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNhcm91c2VsSXRlbUVsZW1lbnQgfSBmcm9tICcuL2Nhcm91c2VsLWl0ZW0vY2Fyb3VzZWwtaXRlbS5jb21wb25lbnQudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2Nhcm91c2VsLWl0ZW0vY2Fyb3VzZWwtaXRlbS5jb21wb25lbnQudHMnO1xuXG5TYmJDYXJvdXNlbEl0ZW1FbGVtZW50LmRlZmluZSgpO1xuXG5jb25zb2xlLndhcm4oYFRoZSBlbnRyeXBvaW50ICdAc2JiLWVzdGEvZWxlbWVudHMvY2Fyb3VzZWwvY2Fyb3VzZWwtaXRlbS5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy9jYXJvdXNlbC5qcycgb3IgJ0BzYmItZXN0YS9lbGVtZW50cy9jYXJvdXNlbC5wdXJlLmpzJyBpbnN0ZWFkLmApO1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFLQSx1QkFBdUIsUUFBUTtBQUUvQixRQUFRLEtBQUs7K0ZBQ2tGIn0=
+export {
+  SbbCarouselItemElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwtaXRlbS5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2Nhcm91c2VsL2Nhcm91c2VsLWl0ZW0udHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQgeyBTYmJDYXJvdXNlbEl0ZW1FbGVtZW50IH0gZnJvbSAnLi9jYXJvdXNlbC1pdGVtL2Nhcm91c2VsLWl0ZW0uY29tcG9uZW50LnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9jYXJvdXNlbC1pdGVtL2Nhcm91c2VsLWl0ZW0uY29tcG9uZW50LnRzJztcblxuU2JiQ2Fyb3VzZWxJdGVtRWxlbWVudC5kZWZpbmUoKTtcblxuY29uc29sZS53YXJuKGBUaGUgZW50cnlwb2ludCAnQHNiYi1lc3RhL2VsZW1lbnRzL2Nhcm91c2VsL2Nhcm91c2VsLWl0ZW0uanMnIGhhcyBiZWVuIGRlcHJlY2F0ZWQuXG5Vc2UgZWl0aGVyICdAc2JiLWVzdGEvZWxlbWVudHMvY2Fyb3VzZWwuanMnIG9yICdAc2JiLWVzdGEvZWxlbWVudHMvY2Fyb3VzZWwucHVyZS5qcycgaW5zdGVhZC5gKTtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBS0EsdUJBQXVCLE9BQUE7QUFFdkIsUUFBUSxLQUFLO0FBQUEsOEZBQ2lGOyJ9

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

@@ -1,2 +1,157 @@
-import { t as SbbCarouselListElement } from "../../carousel-list.component-7Z3dYtAF.js";
-export { SbbCarouselListElement };
+import { IntersectionController } from "@lit-labs/observers/intersection-controller.js";
+import { ResizeController } from "@lit-labs/observers/resize-controller.js";
+import { css, html } from "lit";
+import { isArrowKeyPressed } from "../../core/a11y.js";
+import { SbbElement } from "../../core/base-elements.js";
+import { SbbLanguageController } from "../../core/controllers.js";
+import { i18nCarouselItemAriaLabel } from "../../core/i18n.js";
+const style = css`:host {
+  --sbb-carousel-list-border-radius: var(--sbb-border-radius-4x);
+  display: flex;
+  height: var(--sbb-carousel-list-height);
+  width: var(--sbb-carousel-list-width, 0);
+  overflow-x: auto;
+  scroll-snap-type: x mandatory;
+  scroll-behavior: smooth;
+  scrollbar-width: none;
+  outline: none;
+  border-radius: var(--sbb-carousel-inherit-border-radius);
+}
+
+:host(: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);
+  content: "";
+  position: absolute;
+  height: inherit;
+  width: inherit;
+  border-start-start-radius: var(--sbb-carousel-list-border-radius);
+  border-start-end-radius: var(--sbb-carousel-list-border-radius);
+  border-end-start-radius: var(--sbb-carousel-inherit-border-radius);
+  border-end-end-radius: var(--sbb-carousel-inherit-border-radius);
+}`;
+const _SbbCarouselListElement = class _SbbCarouselListElement extends SbbElement {
+  constructor() {
+    super();
+    this._currentIndex = 0;
+    this._language = new SbbLanguageController(this);
+    this._observedCarouselItems = [];
+    this._beforeShowObserver = new IntersectionController(this, {
+      target: null,
+      callback: (entry) => {
+        const item = entry.filter((e) => e.isIntersecting && e.target !== this);
+        item.forEach((e) => {
+          const target = e.target;
+          target.dispatchEvent(new CustomEvent("beforeshow", {
+            detail: { index: this._carouselItems().findIndex((e2) => e2 === target) },
+            bubbles: true,
+            composed: true
+          }));
+        });
+      },
+      config: { threshold: 0.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: 0.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>`;
+  }
+};
+_SbbCarouselListElement.elementName = "sbb-carousel-list";
+_SbbCarouselListElement.styles = style;
+let SbbCarouselListElement = _SbbCarouselListElement;
+export {
+  SbbCarouselListElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"carousel-list.component.js","sources":["../../../../../src/elements/carousel/carousel-list/carousel-list.component.ts"],"sourcesContent":["import { IntersectionController } from '@lit-labs/observers/intersection-controller.js';\nimport { ResizeController } from '@lit-labs/observers/resize-controller.js';\nimport { type CSSResultGroup, html, type TemplateResult } from 'lit';\n\nimport { isArrowKeyPressed } from '../../core/a11y.ts';\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { SbbLanguageController } from '../../core/controllers.ts';\nimport { i18nCarouselItemAriaLabel } from '../../core/i18n.ts';\nimport type {\n  SbbCarouselItemElement,\n  SbbCarouselItemEventDetail,\n} from '../carousel-item/carousel-item.component.ts';\n\nimport style from './carousel-list.scss?lit&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 = 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"],"names":["e"],"mappings":"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"}

package/development/carousel/carousel-list.js

@@ -1,10 +1,8 @@
-import { t as SbbCarouselListElement } from "../carousel-list.component-7Z3dYtAF.js";
-//#region src/elements/carousel/carousel-list.ts
-/** @entrypoint */
+import { SbbCarouselListElement } from "./carousel-list/carousel-list.component.js";
 SbbCarouselListElement.define();
 console.warn(`The entrypoint '@sbb-esta/elements/carousel/carousel-list.js' has been deprecated.
 Use either '@sbb-esta/elements/carousel.js' or '@sbb-esta/elements/carousel.pure.js' instead.`);
-//#endregion
-export { SbbCarouselListElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwtbGlzdC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY2Fyb3VzZWwvY2Fyb3VzZWwtbGlzdC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNhcm91c2VsTGlzdEVsZW1lbnQgfSBmcm9tICcuL2Nhcm91c2VsLWxpc3QvY2Fyb3VzZWwtbGlzdC5jb21wb25lbnQudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2Nhcm91c2VsLWxpc3QvY2Fyb3VzZWwtbGlzdC5jb21wb25lbnQudHMnO1xuXG5TYmJDYXJvdXNlbExpc3RFbGVtZW50LmRlZmluZSgpO1xuXG5jb25zb2xlLndhcm4oYFRoZSBlbnRyeXBvaW50ICdAc2JiLWVzdGEvZWxlbWVudHMvY2Fyb3VzZWwvY2Fyb3VzZWwtbGlzdC5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy9jYXJvdXNlbC5qcycgb3IgJ0BzYmItZXN0YS9lbGVtZW50cy9jYXJvdXNlbC5wdXJlLmpzJyBpbnN0ZWFkLmApO1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFLQSx1QkFBdUIsUUFBUTtBQUUvQixRQUFRLEtBQUs7K0ZBQ2tGIn0=
+export {
+  SbbCarouselListElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwtbGlzdC5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2Nhcm91c2VsL2Nhcm91c2VsLWxpc3QudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQgeyBTYmJDYXJvdXNlbExpc3RFbGVtZW50IH0gZnJvbSAnLi9jYXJvdXNlbC1saXN0L2Nhcm91c2VsLWxpc3QuY29tcG9uZW50LnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9jYXJvdXNlbC1saXN0L2Nhcm91c2VsLWxpc3QuY29tcG9uZW50LnRzJztcblxuU2JiQ2Fyb3VzZWxMaXN0RWxlbWVudC5kZWZpbmUoKTtcblxuY29uc29sZS53YXJuKGBUaGUgZW50cnlwb2ludCAnQHNiYi1lc3RhL2VsZW1lbnRzL2Nhcm91c2VsL2Nhcm91c2VsLWxpc3QuanMnIGhhcyBiZWVuIGRlcHJlY2F0ZWQuXG5Vc2UgZWl0aGVyICdAc2JiLWVzdGEvZWxlbWVudHMvY2Fyb3VzZWwuanMnIG9yICdAc2JiLWVzdGEvZWxlbWVudHMvY2Fyb3VzZWwucHVyZS5qcycgaW5zdGVhZC5gKTtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBS0EsdUJBQXVCLE9BQUE7QUFFdkIsUUFBUSxLQUFLO0FBQUEsOEZBQ2lGOyJ9

package/development/carousel/carousel.js

@@ -1,10 +1,8 @@
-import { t as SbbCarouselElement } from "../carousel.component-b4C-hxkj.js";
-//#region src/elements/carousel/carousel.ts
-/** @entrypoint */
+import { SbbCarouselElement } from "./carousel/carousel.component.js";
 SbbCarouselElement.define();
 console.warn(`The entrypoint '@sbb-esta/elements/carousel/carousel.js' has been deprecated.
 Use either '@sbb-esta/elements/carousel.js' or '@sbb-esta/elements/carousel.pure.js' instead.`);
-//#endregion
-export { SbbCarouselElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2Nhcm91c2VsL2Nhcm91c2VsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiQ2Fyb3VzZWxFbGVtZW50IH0gZnJvbSAnLi9jYXJvdXNlbC9jYXJvdXNlbC5jb21wb25lbnQudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2Nhcm91c2VsL2Nhcm91c2VsLmNvbXBvbmVudC50cyc7XG5cblNiYkNhcm91c2VsRWxlbWVudC5kZWZpbmUoKTtcblxuY29uc29sZS53YXJuKGBUaGUgZW50cnlwb2ludCAnQHNiYi1lc3RhL2VsZW1lbnRzL2Nhcm91c2VsL2Nhcm91c2VsLmpzJyBoYXMgYmVlbiBkZXByZWNhdGVkLlxuVXNlIGVpdGhlciAnQHNiYi1lc3RhL2VsZW1lbnRzL2Nhcm91c2VsLmpzJyBvciAnQHNiYi1lc3RhL2VsZW1lbnRzL2Nhcm91c2VsLnB1cmUuanMnIGluc3RlYWQuYCk7XG4iXSwibWFwcGluZ3MiOiI7OztBQUtBLG1CQUFtQixRQUFRO0FBRTNCLFFBQVEsS0FBSzsrRkFDa0YifQ==
+export {
+  SbbCarouselElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jYXJvdXNlbC9jYXJvdXNlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNhcm91c2VsRWxlbWVudCB9IGZyb20gJy4vY2Fyb3VzZWwvY2Fyb3VzZWwuY29tcG9uZW50LnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9jYXJvdXNlbC9jYXJvdXNlbC5jb21wb25lbnQudHMnO1xuXG5TYmJDYXJvdXNlbEVsZW1lbnQuZGVmaW5lKCk7XG5cbmNvbnNvbGUud2FybihgVGhlIGVudHJ5cG9pbnQgJ0BzYmItZXN0YS9lbGVtZW50cy9jYXJvdXNlbC9jYXJvdXNlbC5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy9jYXJvdXNlbC5qcycgb3IgJ0BzYmItZXN0YS9lbGVtZW50cy9jYXJvdXNlbC5wdXJlLmpzJyBpbnN0ZWFkLmApO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFLQSxtQkFBbUIsT0FBQTtBQUVuQixRQUFRLEtBQUs7QUFBQSw4RkFDaUY7In0=

package/development/carousel.js

@@ -1,13 +1,12 @@
-import { t as SbbCarouselItemElement } from "./carousel-item.component-DOIXA2QK.js";
-import { t as SbbCarouselListElement } from "./carousel-list.component-7Z3dYtAF.js";
-import { t as SbbCarouselElement } from "./carousel.component-b4C-hxkj.js";
-import "./carousel.pure.js";
-//#region src/elements/carousel.ts
-/** @entrypoint */
+import { SbbCarouselItemElement } from "./carousel/carousel-item/carousel-item.component.js";
+import { SbbCarouselListElement } from "./carousel/carousel-list/carousel-list.component.js";
+import { SbbCarouselElement } from "./carousel/carousel/carousel.component.js";
 SbbCarouselElement.define();
 SbbCarouselItemElement.define();
 SbbCarouselListElement.define();
-//#endregion
-export { SbbCarouselElement, SbbCarouselItemElement, SbbCarouselListElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2Nhcm91c2VsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHtcbiAgU2JiQ2Fyb3VzZWxFbGVtZW50LFxuICBTYmJDYXJvdXNlbEl0ZW1FbGVtZW50LFxuICBTYmJDYXJvdXNlbExpc3RFbGVtZW50LFxufSBmcm9tICcuL2Nhcm91c2VsLnB1cmUudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2Nhcm91c2VsLnB1cmUudHMnO1xuXG5TYmJDYXJvdXNlbEVsZW1lbnQuZGVmaW5lKCk7XG5TYmJDYXJvdXNlbEl0ZW1FbGVtZW50LmRlZmluZSgpO1xuU2JiQ2Fyb3VzZWxMaXN0RWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBU0EsbUJBQW1CLFFBQVE7QUFDM0IsdUJBQXVCLFFBQVE7QUFDL0IsdUJBQXVCLFFBQVEifQ==
+export {
+  SbbCarouselElement,
+  SbbCarouselItemElement,
+  SbbCarouselListElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbGVtZW50cy9jYXJvdXNlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7XG4gIFNiYkNhcm91c2VsRWxlbWVudCxcbiAgU2JiQ2Fyb3VzZWxJdGVtRWxlbWVudCxcbiAgU2JiQ2Fyb3VzZWxMaXN0RWxlbWVudCxcbn0gZnJvbSAnLi9jYXJvdXNlbC5wdXJlLnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9jYXJvdXNlbC5wdXJlLnRzJztcblxuU2JiQ2Fyb3VzZWxFbGVtZW50LmRlZmluZSgpO1xuU2JiQ2Fyb3VzZWxJdGVtRWxlbWVudC5kZWZpbmUoKTtcblNiYkNhcm91c2VsTGlzdEVsZW1lbnQuZGVmaW5lKCk7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBU0EsbUJBQW1CLE9BQUE7QUFDbkIsdUJBQXVCLE9BQUE7QUFDdkIsdUJBQXVCLE9BQUE7In0=

package/development/carousel.pure.js

@@ -1,4 +1,9 @@
-import { t as SbbCarouselItemElement } from "./carousel-item.component-DOIXA2QK.js";
-import { t as SbbCarouselListElement } from "./carousel-list.component-7Z3dYtAF.js";
-import { t as SbbCarouselElement } from "./carousel.component-b4C-hxkj.js";
-export { SbbCarouselElement, SbbCarouselItemElement, SbbCarouselListElement };
+import { SbbCarouselItemElement } from "./carousel/carousel-item/carousel-item.component.js";
+import { SbbCarouselListElement } from "./carousel/carousel-list/carousel-list.component.js";
+import { SbbCarouselElement } from "./carousel/carousel/carousel.component.js";
+export {
+  SbbCarouselElement,
+  SbbCarouselItemElement,
+  SbbCarouselListElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwucHVyZS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OzsifQ==

package/development/checkbox/checkbox-group.js

@@ -1,10 +1,6 @@
 import { SbbCheckboxGroupElement } from "../checkbox-group/checkbox-group.component.js";
 export * from "../checkbox-group/checkbox-group.component.js";
-//#region src/elements/checkbox/checkbox-group.ts
-/** @entrypoint */
 SbbCheckboxGroupElement.define();
 console.warn(`The entrypoint '@sbb-esta/elements/checkbox/checkbox-group.js' has been deprecated.
 Use either '@sbb-esta/elements/checkbox.js' or '@sbb-esta/elements/checkbox.pure.js' instead.`);
-//#endregion
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtZ3JvdXAuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2NoZWNrYm94L2NoZWNrYm94LWdyb3VwLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiQ2hlY2tib3hHcm91cEVsZW1lbnQgfSBmcm9tICcuLi9jaGVja2JveC1ncm91cC9jaGVja2JveC1ncm91cC5jb21wb25lbnQudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuLi9jaGVja2JveC1ncm91cC9jaGVja2JveC1ncm91cC5jb21wb25lbnQudHMnO1xuXG5TYmJDaGVja2JveEdyb3VwRWxlbWVudC5kZWZpbmUoKTtcblxuY29uc29sZS53YXJuKGBUaGUgZW50cnlwb2ludCAnQHNiYi1lc3RhL2VsZW1lbnRzL2NoZWNrYm94L2NoZWNrYm94LWdyb3VwLmpzJyBoYXMgYmVlbiBkZXByZWNhdGVkLlxuVXNlIGVpdGhlciAnQHNiYi1lc3RhL2VsZW1lbnRzL2NoZWNrYm94LmpzJyBvciAnQHNiYi1lc3RhL2VsZW1lbnRzL2NoZWNrYm94LnB1cmUuanMnIGluc3RlYWQuYCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFLQSx3QkFBd0IsUUFBUTtBQUVoQyxRQUFRLEtBQUs7K0ZBQ2tGIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtZ3JvdXAuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jaGVja2JveC9jaGVja2JveC1ncm91cC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNoZWNrYm94R3JvdXBFbGVtZW50IH0gZnJvbSAnLi4vY2hlY2tib3gtZ3JvdXAvY2hlY2tib3gtZ3JvdXAuY29tcG9uZW50LnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi4vY2hlY2tib3gtZ3JvdXAvY2hlY2tib3gtZ3JvdXAuY29tcG9uZW50LnRzJztcblxuU2JiQ2hlY2tib3hHcm91cEVsZW1lbnQuZGVmaW5lKCk7XG5cbmNvbnNvbGUud2FybihgVGhlIGVudHJ5cG9pbnQgJ0BzYmItZXN0YS9lbGVtZW50cy9jaGVja2JveC9jaGVja2JveC1ncm91cC5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy9jaGVja2JveC5qcycgb3IgJ0BzYmItZXN0YS9lbGVtZW50cy9jaGVja2JveC5wdXJlLmpzJyBpbnN0ZWFkLmApO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBS0Esd0JBQXdCLE9BQUE7QUFFeEIsUUFBUSxLQUFLO0FBQUEsOEZBQ2lGOyJ9

package/development/checkbox/checkbox-panel.js

@@ -1,10 +1,6 @@
 import { SbbCheckboxPanelElement } from "../checkbox-panel/checkbox-panel.component.js";
 export * from "../checkbox-panel/checkbox-panel.component.js";
-//#region src/elements/checkbox/checkbox-panel.ts
-/** @entrypoint */
 SbbCheckboxPanelElement.define();
 console.warn(`The entrypoint '@sbb-esta/elements/checkbox/checkbox-panel.js' has been deprecated.
 Use either '@sbb-esta/elements/checkbox.js' or '@sbb-esta/elements/checkbox.pure.js' instead.`);
-//#endregion
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtcGFuZWwuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2NoZWNrYm94L2NoZWNrYm94LXBhbmVsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiQ2hlY2tib3hQYW5lbEVsZW1lbnQgfSBmcm9tICcuLi9jaGVja2JveC1wYW5lbC9jaGVja2JveC1wYW5lbC5jb21wb25lbnQudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuLi9jaGVja2JveC1wYW5lbC9jaGVja2JveC1wYW5lbC5jb21wb25lbnQudHMnO1xuXG5TYmJDaGVja2JveFBhbmVsRWxlbWVudC5kZWZpbmUoKTtcblxuY29uc29sZS53YXJuKGBUaGUgZW50cnlwb2ludCAnQHNiYi1lc3RhL2VsZW1lbnRzL2NoZWNrYm94L2NoZWNrYm94LXBhbmVsLmpzJyBoYXMgYmVlbiBkZXByZWNhdGVkLlxuVXNlIGVpdGhlciAnQHNiYi1lc3RhL2VsZW1lbnRzL2NoZWNrYm94LmpzJyBvciAnQHNiYi1lc3RhL2VsZW1lbnRzL2NoZWNrYm94LnB1cmUuanMnIGluc3RlYWQuYCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFLQSx3QkFBd0IsUUFBUTtBQUVoQyxRQUFRLEtBQUs7K0ZBQ2tGIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtcGFuZWwuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jaGVja2JveC9jaGVja2JveC1wYW5lbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNoZWNrYm94UGFuZWxFbGVtZW50IH0gZnJvbSAnLi4vY2hlY2tib3gtcGFuZWwvY2hlY2tib3gtcGFuZWwuY29tcG9uZW50LnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi4vY2hlY2tib3gtcGFuZWwvY2hlY2tib3gtcGFuZWwuY29tcG9uZW50LnRzJztcblxuU2JiQ2hlY2tib3hQYW5lbEVsZW1lbnQuZGVmaW5lKCk7XG5cbmNvbnNvbGUud2FybihgVGhlIGVudHJ5cG9pbnQgJ0BzYmItZXN0YS9lbGVtZW50cy9jaGVja2JveC9jaGVja2JveC1wYW5lbC5qcycgaGFzIGJlZW4gZGVwcmVjYXRlZC5cblVzZSBlaXRoZXIgJ0BzYmItZXN0YS9lbGVtZW50cy9jaGVja2JveC5qcycgb3IgJ0BzYmItZXN0YS9lbGVtZW50cy9jaGVja2JveC5wdXJlLmpzJyBpbnN0ZWFkLmApO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBS0Esd0JBQXdCLE9BQUE7QUFFeEIsUUFBUSxLQUFLO0FBQUEsOEZBQ2lGOyJ9