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

package/development/header/header/header.component.js

@@ -1,2 +1,385 @@
-import { t as SbbHeaderElement } from "../../header.component-DYls7wGO.js";
-export { SbbHeaderElement };
+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, isServer, html } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SbbFocusVisibleWithinController } from "../../core/a11y.js";
+import { SbbElement } from "../../core/base-elements.js";
+import { forceType, idReference } from "../../core/decorators.js";
+import { isLean } from "../../core/dom.js";
+import { boxSizingStyles } from "../../core/styles.js";
+const style = css`:host {
+  --sbb-logo-height: 1rem;
+  --sbb-signet-height: 1rem;
+  --sbb-header-transition-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-6x)
+  );
+}
+@media (min-width: calc(64rem)) {
+  :host {
+    --sbb-logo-height: 1.25rem;
+    --sbb-signet-height: 1.25rem;
+  }
+}
+:host {
+  display: block;
+  height: var(--sbb-header-height);
+}
+
+:host([size=s]) ::slotted(:is(sbb-header-button, sbb-header-link)) {
+  --sbb-header-action-min-height: var(--sbb-size-element-xs);
+  --sbb-header-action-padding-inline: var(--sbb-spacing-fixed-4x);
+}
+
+:host([hide-on-scroll]) {
+  --sbb-header-position: absolute;
+}
+
+:host([hide-on-scroll]:is(:state(fixed),[state--fixed])) {
+  --sbb-header-position: fixed;
+  --sbb-header-animation-name: hide;
+  --sbb-header-transform: translate3d(0, -100%, 0);
+  --sbb-header-inset-inline-end: var(--sbb-scrollbar-width, 0);
+}
+
+:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(animated),[state--animated])) {
+  --sbb-header-transition-timing: cubic-bezier(0.4, 0, 1, 1);
+}
+
+:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(visible),[state--visible])) {
+  --sbb-header-animation-name: show;
+  --sbb-header-transform: translate3d(0, 0, 0);
+  --sbb-header-transition-timing: cubic-bezier(0, 0, 0.2, 1);
+}
+
+:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(has-visible-focus-within),[state--has-visible-focus-within])) {
+  --sbb-header-transition-duration: 0;
+  --sbb-header-transform: translate3d(0, 0, 0);
+}
+
+.sbb-header {
+  position: var(--sbb-header-position);
+  inset: 0 var(--sbb-header-inset-inline-end) auto 0;
+  background: var(--sbb-header-background);
+  z-index: var(--sbb-header-z-index, 10);
+  transform: var(--sbb-header-transform);
+  transition-property: box-shadow;
+  transition-duration: var(--sbb-header-transition-duration);
+  transition-timing-function: var(--sbb-header-transition-timing);
+  animation-name: var(--sbb-header-animation-name);
+  animation-duration: var(--sbb-header-transition-duration);
+  animation-timing-function: var(--sbb-header-transition-timing);
+}
+:host(:is(:is(:state(shadow),[state--shadow]), :is(:state(has-visible-focus-within),[state--has-visible-focus-within]):is(:state(fixed),[state--fixed]))) .sbb-header {
+  box-shadow: var(--sbb-header-box-shadow);
+}
+@media (forced-colors: active) {
+  .sbb-header {
+    border-block-end: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+
+.sbb-header__wrapper {
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+  height: var(--sbb-header-height);
+}
+:host(:not([expanded])) .sbb-header__wrapper {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));
+  margin-inline: auto;
+  width: 100%;
+}
+@media (min-width: calc(90rem)) {
+  :host(:not([expanded])) .sbb-header__wrapper {
+    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));
+  }
+}
+:host([expanded]) .sbb-header__wrapper {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-spacing-responsive-xxs));
+}
+
+::slotted(:is(sbb-header-button, sbb-header-link):first-child) {
+  margin-inline-start: var(--sbb-header-first-item-margin-inline-start);
+}
+
+::slotted(*) {
+  flex: 0 0 auto;
+}
+
+::slotted(.sbb-header-shrinkable) {
+  flex-shrink: 1;
+  min-width: 0;
+}
+
+::slotted(.sbb-header-spacer) {
+  flex-grow: 1;
+}
+
+::slotted(.sbb-header-logo) {
+  margin-inline-start: var(--sbb-spacing-responsive-s);
+}
+
+::slotted(a.sbb-header-logo) {
+  display: block;
+  padding-block: var(--sbb-spacing-fixed-3x);
+  position: relative;
+  outline: none !important;
+}
+
+::slotted(a.sbb-header-logo)::before {
+  content: "";
+  display: block;
+  position: absolute;
+  inset: var(--sbb-spacing-fixed-3x) 0;
+}
+
+::slotted(a.sbb-header-logo: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);
+  outline-offset: var(--sbb-spacing-fixed-3x);
+  border-radius: 1px;
+}
+
+@keyframes show {
+  from {
+    transform: translate3d(0, -100%, 0);
+  }
+  to {
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes hide {
+  from {
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    transform: translate3d(0, -100%, 0);
+  }
+}`;
+const IS_MENU_OPENED_QUERY = "[aria-controls][aria-expanded='true']";
+let SbbHeaderElement = (() => {
+  var _expanded_accessor_storage, _scrollOrigin_accessor_storage, _hideOnScroll_accessor_storage, _size_accessor_storage, __headerOnTop_accessor_storage, _a;
+  let _classSuper = SbbElement;
+  let _expanded_decorators;
+  let _expanded_initializers = [];
+  let _expanded_extraInitializers = [];
+  let _scrollOrigin_decorators;
+  let _scrollOrigin_initializers = [];
+  let _scrollOrigin_extraInitializers = [];
+  let _hideOnScroll_decorators;
+  let _hideOnScroll_initializers = [];
+  let _hideOnScroll_extraInitializers = [];
+  let _size_decorators;
+  let _size_initializers = [];
+  let _size_extraInitializers = [];
+  let __headerOnTop_decorators;
+  let __headerOnTop_initializers = [];
+  let __headerOnTop_extraInitializers = [];
+  return _a = class extends _classSuper {
+    constructor() {
+      super();
+      __privateAdd(this, _expanded_accessor_storage);
+      __privateAdd(this, _scrollOrigin_accessor_storage);
+      __privateAdd(this, _hideOnScroll_accessor_storage);
+      __privateAdd(this, _size_accessor_storage);
+      __privateAdd(this, __headerOnTop_accessor_storage);
+      __privateSet(this, _expanded_accessor_storage, __runInitializers(this, _expanded_initializers, false));
+      __privateSet(this, _scrollOrigin_accessor_storage, (__runInitializers(this, _expanded_extraInitializers), __runInitializers(this, _scrollOrigin_initializers, null)));
+      __privateSet(this, _hideOnScroll_accessor_storage, (__runInitializers(this, _scrollOrigin_extraInitializers), __runInitializers(this, _hideOnScroll_initializers, false)));
+      __privateSet(this, _size_accessor_storage, (__runInitializers(this, _hideOnScroll_extraInitializers), __runInitializers(this, _size_initializers, isLean() ? "s" : "m")));
+      __privateSet(this, __headerOnTop_accessor_storage, (__runInitializers(this, _size_extraInitializers), __runInitializers(this, __headerOnTop_initializers, true)));
+      this._scrollElement = __runInitializers(this, __headerOnTop_extraInitializers);
+      this._lastScroll = 0;
+      this.addController(new SbbFocusVisibleWithinController(this));
+    }
+    /**
+     * Whether to allow the header content to stretch to full width.
+     * By default, the content has the appropriate page size.
+     */
+    get expanded() {
+      return __privateGet(this, _expanded_accessor_storage);
+    }
+    set expanded(value) {
+      __privateSet(this, _expanded_accessor_storage, value);
+    }
+    /**
+     * The element's id or the element on which the scroll listener is attached.
+     *
+     * For attribute usage, provide an id reference.
+     */
+    get scrollOrigin() {
+      return __privateGet(this, _scrollOrigin_accessor_storage);
+    }
+    set scrollOrigin(value) {
+      __privateSet(this, _scrollOrigin_accessor_storage, value);
+    }
+    /** Whether the header should hide and show on scroll. */
+    get hideOnScroll() {
+      return __privateGet(this, _hideOnScroll_accessor_storage);
+    }
+    set hideOnScroll(value) {
+      __privateSet(this, _hideOnScroll_accessor_storage, value);
+    }
+    /**
+     * Size of the header, either m or s.
+     * @default 'm' / 's' (lean)
+     */
+    get size() {
+      return __privateGet(this, _size_accessor_storage);
+    }
+    set size(value) {
+      __privateSet(this, _size_accessor_storage, value);
+    }
+    get _headerOnTop() {
+      return __privateGet(this, __headerOnTop_accessor_storage);
+    }
+    set _headerOnTop(value) {
+      __privateSet(this, __headerOnTop_accessor_storage, value);
+    }
+    /** If `hideOnScroll` is set, checks the element to hook the listener on, and possibly add it.*/
+    connectedCallback() {
+      super.connectedCallback();
+      if (this.hasUpdated) {
+        this._updateScrollListener();
+      }
+    }
+    /** Removes the scroll listener, if previously attached. */
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this._scrollElement = null;
+      this._scrollEventsController?.abort();
+    }
+    requestUpdate(name, oldValue, options) {
+      super.requestUpdate(name, oldValue, options);
+      if (!isServer && (!name || name === "scrollOrigin") && this.hasUpdated) {
+        this._updateScrollListener();
+      }
+    }
+    firstUpdated(changedProperties) {
+      super.firstUpdated(changedProperties);
+      this._updateScrollListener();
+    }
+    _updateScrollListener() {
+      const scrollElement = this.scrollOrigin ?? document;
+      if (scrollElement === this._scrollElement) {
+        return;
+      }
+      this._scrollEventsController?.abort();
+      this._scrollElement = scrollElement;
+      if (!this._scrollElement) {
+        return;
+      }
+      this._scrollEventsController = new AbortController();
+      this._scrollFunction = this._getScrollFunction.bind(this);
+      this._scrollElement.addEventListener("scroll", this._scrollFunction, {
+        passive: true,
+        signal: this._scrollEventsController.signal
+      });
+      const currentScroll = this._getCurrentScrollProperty("scrollTop");
+      this._lastScroll = currentScroll <= 0 ? 0 : currentScroll;
+    }
+    /** Returns the correct function to attach on scroll. */
+    _getScrollFunction() {
+      return this.hideOnScroll ? this._scrollListener() : this._scrollShadowListener();
+    }
+    /** Returns the requested property of the scrollContext. */
+    _getCurrentScrollProperty(property2) {
+      if (this._scrollElement instanceof Document) {
+        return this._scrollElement.documentElement[property2] || this._scrollElement.body[property2];
+      }
+      return this._scrollElement?.[property2] || 0;
+    }
+    /**
+     * Sets the correct value for `scrollTop`, then:
+     * - apply the shadow if the element/document has been scrolled down;
+     * - hides the header, remove the shadow and possibly close any open menu on the header if it is not visible anymore;
+     * - shows the header and re-apply the shadow if the element/document has been scrolled up.
+     */
+    _scrollListener() {
+      const currentScroll = this._getCurrentScrollProperty("scrollTop");
+      if (this._getCurrentScrollProperty("scrollHeight") - window.innerHeight - currentScroll <= 0) {
+        return;
+      }
+      this.toggleState("shadow", currentScroll !== 0);
+      if (currentScroll > this.offsetHeight && currentScroll > 0 && this._lastScroll < currentScroll) {
+        this._closeOpenOverlays();
+      }
+      if (currentScroll > this.offsetHeight * 2) {
+        this._headerOnTop = false;
+        if (currentScroll > 0 && this._lastScroll < currentScroll) {
+          ["shadow", "visible"].forEach((name) => this.internals.states.delete(name));
+        } else {
+          ["fixed", "shadow", "animated", "visible"].forEach((name) => this.internals.states.add(name));
+        }
+      } else {
+        if (currentScroll === 0) {
+          this._headerOnTop = true;
+        }
+        if (this._headerOnTop) {
+          ["shadow", "animated", "fixed", "visible"].forEach((name) => this.internals.states.delete(name));
+        }
+      }
+      this._lastScroll = currentScroll <= 0 ? 0 : currentScroll;
+    }
+    /** Apply the shadow if the element/document has been scrolled down. */
+    _scrollShadowListener() {
+      this.toggleState("shadow", this._getCurrentScrollProperty("scrollTop") !== 0);
+    }
+    _closeOpenOverlays() {
+      if (this.matches(":is(:state(has-visible-focus-within),[state--has-visible-focus-within])")) {
+        return;
+      }
+      const overlayTriggers = Array.from(this.querySelectorAll(IS_MENU_OPENED_QUERY));
+      for (const overlayTrigger of overlayTriggers) {
+        const overlayId = overlayTrigger.getAttribute("aria-controls");
+        const overlay = document.getElementById(overlayId);
+        if (typeof overlay?.close === "function") {
+          overlay.close();
+        }
+      }
+    }
+    render() {
+      return html`
+      <header class="sbb-header">
+        <div class="sbb-header__wrapper">
+          <slot></slot>
+        </div>
+      </header>
+    `;
+    }
+  }, _expanded_accessor_storage = new WeakMap(), _scrollOrigin_accessor_storage = new WeakMap(), _hideOnScroll_accessor_storage = new WeakMap(), _size_accessor_storage = new WeakMap(), __headerOnTop_accessor_storage = new WeakMap(), (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _expanded_decorators = [forceType(), property({ reflect: true, type: Boolean })];
+    _scrollOrigin_decorators = [idReference(), property({ attribute: "scroll-origin" })];
+    _hideOnScroll_decorators = [forceType(), property({ attribute: "hide-on-scroll", reflect: true, type: Boolean })];
+    _size_decorators = [property({ reflect: true })];
+    __headerOnTop_decorators = [state()];
+    __esDecorate(_a, null, _expanded_decorators, { kind: "accessor", name: "expanded", static: false, private: false, access: { has: (obj) => "expanded" in obj, get: (obj) => obj.expanded, set: (obj, value) => {
+      obj.expanded = value;
+    } }, metadata: _metadata }, _expanded_initializers, _expanded_extraInitializers);
+    __esDecorate(_a, null, _scrollOrigin_decorators, { kind: "accessor", name: "scrollOrigin", static: false, private: false, access: { has: (obj) => "scrollOrigin" in obj, get: (obj) => obj.scrollOrigin, set: (obj, value) => {
+      obj.scrollOrigin = value;
+    } }, metadata: _metadata }, _scrollOrigin_initializers, _scrollOrigin_extraInitializers);
+    __esDecorate(_a, null, _hideOnScroll_decorators, { kind: "accessor", name: "hideOnScroll", static: false, private: false, access: { has: (obj) => "hideOnScroll" in obj, get: (obj) => obj.hideOnScroll, set: (obj, value) => {
+      obj.hideOnScroll = value;
+    } }, metadata: _metadata }, _hideOnScroll_initializers, _hideOnScroll_extraInitializers);
+    __esDecorate(_a, null, _size_decorators, { kind: "accessor", name: "size", static: false, private: false, access: { has: (obj) => "size" in obj, get: (obj) => obj.size, set: (obj, value) => {
+      obj.size = value;
+    } }, metadata: _metadata }, _size_initializers, _size_extraInitializers);
+    __esDecorate(_a, null, __headerOnTop_decorators, { kind: "accessor", name: "_headerOnTop", static: false, private: false, access: { has: (obj) => "_headerOnTop" in obj, get: (obj) => obj._headerOnTop, set: (obj, value) => {
+      obj._headerOnTop = value;
+    } }, metadata: _metadata }, __headerOnTop_initializers, __headerOnTop_extraInitializers);
+    if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.elementName = "sbb-header", _a.styles = [boxSizingStyles, style], _a;
+})();
+export {
+  SbbHeaderElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"header.component.js","sources":["../../../../../src/elements/header/header/header.component.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport { SbbFocusVisibleWithinController } from '../../core/a11y.ts';\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { forceType, idReference } from '../../core/decorators.ts';\nimport { isLean } from '../../core/dom.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\n\nimport style from './header.scss?lit&inline';\n\nconst IS_MENU_OPENED_QUERY = \"[aria-controls][aria-expanded='true']\";\n\n/**\n * It displays a header section for the page.\n *\n * @slot - Use the unnamed slot to add actions, content and logo to the header.\n * @cssprop [--sbb-header-z-index=10] - Can be used to modify the z-index of the header.\n * @cssprop [--sbb-header-height=zero-small:var(--sbb-spacing-fixed-14x);large-ultra:var(--sbb-spacing-fixed-24x)] - Can be used to modify height of the header.\n */\nexport class SbbHeaderElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-header';\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  /**\n   * Whether to allow the header content to stretch to full width.\n   * By default, the content has the appropriate page size.\n   */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor expanded: boolean = false;\n\n  /**\n   * The element's id or the element on which the scroll listener is attached.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property({ attribute: 'scroll-origin' })\n  public accessor scrollOrigin: HTMLElement | null = null;\n\n  /** Whether the header should hide and show on scroll. */\n  @forceType()\n  @property({ attribute: 'hide-on-scroll', reflect: true, type: Boolean })\n  public accessor hideOnScroll: boolean = false;\n\n  /**\n   * Size of the header, either m or s.\n   * @default 'm' / 's' (lean)\n   */\n  @property({ reflect: true }) public accessor size: 'm' | 's' = isLean() ? 's' : 'm';\n\n  @state() private accessor _headerOnTop = true;\n\n  private _scrollElement: HTMLElement | Document | null | undefined;\n  private _scrollEventsController!: AbortController;\n  private _scrollFunction: (() => void) | undefined;\n  private _lastScroll = 0;\n\n  public constructor() {\n    super();\n    this.addController(new SbbFocusVisibleWithinController(this));\n  }\n\n  /** If `hideOnScroll` is set, checks the element to hook the listener on, and possibly add it.*/\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    if (this.hasUpdated) {\n      this._updateScrollListener();\n    }\n  }\n\n  /** Removes the scroll listener, if previously attached. */\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._scrollElement = null;\n    this._scrollEventsController?.abort();\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n\n    if (!isServer && (!name || name === 'scrollOrigin') && this.hasUpdated) {\n      this._updateScrollListener();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._updateScrollListener();\n  }\n\n  private _updateScrollListener(): void {\n    const scrollElement = this.scrollOrigin ?? document;\n    if (scrollElement === this._scrollElement) {\n      return;\n    }\n\n    this._scrollEventsController?.abort();\n    this._scrollElement = scrollElement;\n    if (!this._scrollElement) {\n      return;\n    }\n    this._scrollEventsController = new AbortController();\n    this._scrollFunction = this._getScrollFunction.bind(this);\n    this._scrollElement.addEventListener('scroll', this._scrollFunction, {\n      passive: true,\n      signal: this._scrollEventsController.signal,\n    });\n\n    const currentScroll = this._getCurrentScrollProperty('scrollTop');\n    // `currentScroll` can be negative, e.g. on mobile; this is not allowed.\n    this._lastScroll = currentScroll <= 0 ? 0 : currentScroll;\n  }\n\n  /** Returns the correct function to attach on scroll. */\n  private _getScrollFunction(): void {\n    return this.hideOnScroll ? this._scrollListener() : this._scrollShadowListener();\n  }\n\n  /** Returns the requested property of the scrollContext. */\n  private _getCurrentScrollProperty(property: 'scrollTop' | 'scrollHeight'): number {\n    if (this._scrollElement instanceof Document) {\n      return this._scrollElement.documentElement[property] || this._scrollElement.body[property];\n    }\n    return this._scrollElement?.[property] || 0;\n  }\n\n  /**\n   * Sets the correct value for `scrollTop`, then:\n   * - apply the shadow if the element/document has been scrolled down;\n   * - hides the header, remove the shadow and possibly close any open menu on the header if it is not visible anymore;\n   * - shows the header and re-apply the shadow if the element/document has been scrolled up.\n   */\n  private _scrollListener(): void {\n    const currentScroll = this._getCurrentScrollProperty('scrollTop');\n\n    // Whether the scroll view is bouncing past the edge of content and back again.\n    if (this._getCurrentScrollProperty('scrollHeight') - window.innerHeight - currentScroll <= 0) {\n      return;\n    }\n\n    this.toggleState('shadow', currentScroll !== 0);\n\n    // Close open overlays when scrolling down if the header is scrolled out of sight.\n    if (\n      currentScroll > this.offsetHeight &&\n      currentScroll > 0 &&\n      this._lastScroll < currentScroll\n    ) {\n      this._closeOpenOverlays();\n    }\n    // Check if the header is scrolled out of sight, scroll position > header height * 2.\n    if (currentScroll > this.offsetHeight * 2) {\n      this._headerOnTop = false;\n      if (currentScroll > 0 && this._lastScroll < currentScroll) {\n        // Scrolling down\n        ['shadow', 'visible'].forEach((name) => this.internals.states.delete(name));\n      } else {\n        // Scrolling up\n        ['fixed', 'shadow', 'animated', 'visible'].forEach((name) =>\n          this.internals.states.add(name),\n        );\n      }\n    } else {\n      // Check if header in its original position, scroll position < header height.\n      // Reset header behavior when scroll hits top of the page, on scroll position = 0.\n      if (currentScroll === 0) {\n        this._headerOnTop = true;\n      }\n      if (this._headerOnTop) {\n        ['shadow', 'animated', 'fixed', 'visible'].forEach((name) =>\n          this.internals.states.delete(name),\n        );\n      }\n    }\n    // `currentScroll` can be negative, e.g. on mobile; this is not allowed.\n    this._lastScroll = currentScroll <= 0 ? 0 : currentScroll;\n  }\n\n  /** Apply the shadow if the element/document has been scrolled down. */\n  private _scrollShadowListener(): void {\n    this.toggleState('shadow', this._getCurrentScrollProperty('scrollTop') !== 0);\n  }\n\n  private _closeOpenOverlays(): void {\n    if (this.matches(':state(has-visible-focus-within)')) {\n      return;\n    }\n    const overlayTriggers: HTMLElement[] = Array.from(\n      this.querySelectorAll(IS_MENU_OPENED_QUERY) as NodeListOf<HTMLElement>,\n    );\n    for (const overlayTrigger of overlayTriggers) {\n      const overlayId: string = overlayTrigger.getAttribute('aria-controls')!;\n      const overlay = document.getElementById(overlayId) as HTMLElement & { close: () => void };\n      if (typeof overlay?.close === 'function') {\n        overlay.close();\n      }\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <header class=\"sbb-header\">\n        <div class=\"sbb-header__wrapper\">\n          <slot></slot>\n        </div>\n      </header>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-header': SbbHeaderElement;\n  }\n}\n"],"names":["property"],"mappings":"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"}

package/development/header/header-button/header-button.component.js

@@ -1,18 +1,10 @@
 import { SbbButtonBaseElement } from "../../core/base-elements.js";
 import { SbbHeaderActionCommonElementMixin } from "../common/header-action-common.js";
-//#region src/elements/header/header-button/header-button.component.ts
-/**
-* It displays a button element that can be used in the `sbb-header` component.
-*
-* @slot icon - Slot used to render the button icon.
-* @slot - Use the unnamed slot to add content to the `sbb-header-button`.
-*/
-var SbbHeaderButtonElement = class extends SbbHeaderActionCommonElementMixin(SbbButtonBaseElement) {
-	static {
-		this.elementName = "sbb-header-button";
-	}
+const _SbbHeaderButtonElement = class _SbbHeaderButtonElement extends SbbHeaderActionCommonElementMixin(SbbButtonBaseElement) {
 };
-//#endregion
-export { SbbHeaderButtonElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLWJ1dHRvbi5jb21wb25lbnQuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2hlYWRlci9oZWFkZXItYnV0dG9uL2hlYWRlci1idXR0b24uY29tcG9uZW50LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNiYkJ1dHRvbkJhc2VFbGVtZW50IH0gZnJvbSAnLi4vLi4vY29yZS9iYXNlLWVsZW1lbnRzLnRzJztcbmltcG9ydCB7IFNiYkhlYWRlckFjdGlvbkNvbW1vbkVsZW1lbnRNaXhpbiB9IGZyb20gJy4uL2NvbW1vbi9oZWFkZXItYWN0aW9uLWNvbW1vbi50cyc7XG5cbi8qKlxuICogSXQgZGlzcGxheXMgYSBidXR0b24gZWxlbWVudCB0aGF0IGNhbiBiZSB1c2VkIGluIHRoZSBgc2JiLWhlYWRlcmAgY29tcG9uZW50LlxuICpcbiAqIEBzbG90IGljb24gLSBTbG90IHVzZWQgdG8gcmVuZGVyIHRoZSBidXR0b24gaWNvbi5cbiAqIEBzbG90IC0gVXNlIHRoZSB1bm5hbWVkIHNsb3QgdG8gYWRkIGNvbnRlbnQgdG8gdGhlIGBzYmItaGVhZGVyLWJ1dHRvbmAuXG4gKi9cbmV4cG9ydCBjbGFzcyBTYmJIZWFkZXJCdXR0b25FbGVtZW50IGV4dGVuZHMgU2JiSGVhZGVyQWN0aW9uQ29tbW9uRWxlbWVudE1peGluKFxuICBTYmJCdXR0b25CYXNlRWxlbWVudCxcbikge1xuICBwdWJsaWMgc3RhdGljIG92ZXJyaWRlIHJlYWRvbmx5IGVsZW1lbnROYW1lOiBzdHJpbmcgPSAnc2JiLWhlYWRlci1idXR0b24nO1xufVxuXG5kZWNsYXJlIGdsb2JhbCB7XG4gIGludGVyZmFjZSBIVE1MRWxlbWVudFRhZ05hbWVNYXAge1xuICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbmFtaW5nLWNvbnZlbnRpb25cbiAgICAnc2JiLWhlYWRlci1idXR0b24nOiBTYmJIZWFkZXJCdXR0b25FbGVtZW50O1xuICB9XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQVNBLElBQWEseUJBQWIsY0FBNEMsa0NBQzFDLHFCQUNELENBQUE7O0FBQ2lDLE9BQUEsY0FBc0IifQ==
+_SbbHeaderButtonElement.elementName = "sbb-header-button";
+let SbbHeaderButtonElement = _SbbHeaderButtonElement;
+export {
+  SbbHeaderButtonElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLWJ1dHRvbi5jb21wb25lbnQuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9oZWFkZXIvaGVhZGVyLWJ1dHRvbi9oZWFkZXItYnV0dG9uLmNvbXBvbmVudC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTYmJCdXR0b25CYXNlRWxlbWVudCB9IGZyb20gJy4uLy4uL2NvcmUvYmFzZS1lbGVtZW50cy50cyc7XG5pbXBvcnQgeyBTYmJIZWFkZXJBY3Rpb25Db21tb25FbGVtZW50TWl4aW4gfSBmcm9tICcuLi9jb21tb24vaGVhZGVyLWFjdGlvbi1jb21tb24udHMnO1xuXG4vKipcbiAqIEl0IGRpc3BsYXlzIGEgYnV0dG9uIGVsZW1lbnQgdGhhdCBjYW4gYmUgdXNlZCBpbiB0aGUgYHNiYi1oZWFkZXJgIGNvbXBvbmVudC5cbiAqXG4gKiBAc2xvdCBpY29uIC0gU2xvdCB1c2VkIHRvIHJlbmRlciB0aGUgYnV0dG9uIGljb24uXG4gKiBAc2xvdCAtIFVzZSB0aGUgdW5uYW1lZCBzbG90IHRvIGFkZCBjb250ZW50IHRvIHRoZSBgc2JiLWhlYWRlci1idXR0b25gLlxuICovXG5leHBvcnQgY2xhc3MgU2JiSGVhZGVyQnV0dG9uRWxlbWVudCBleHRlbmRzIFNiYkhlYWRlckFjdGlvbkNvbW1vbkVsZW1lbnRNaXhpbihcbiAgU2JiQnV0dG9uQmFzZUVsZW1lbnQsXG4pIHtcbiAgcHVibGljIHN0YXRpYyBvdmVycmlkZSByZWFkb25seSBlbGVtZW50TmFtZTogc3RyaW5nID0gJ3NiYi1oZWFkZXItYnV0dG9uJztcbn1cblxuZGVjbGFyZSBnbG9iYWwge1xuICBpbnRlcmZhY2UgSFRNTEVsZW1lbnRUYWdOYW1lTWFwIHtcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25hbWluZy1jb252ZW50aW9uXG4gICAgJ3NiYi1oZWFkZXItYnV0dG9uJzogU2JiSGVhZGVyQnV0dG9uRWxlbWVudDtcbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O01BU2EsZ0NBQUEsZ0NBQStCLGtDQUMxQyxvQkFBb0IsRUFDckI7O0FBQ2lDLHdCQUFBLGNBQXNCO0lBSDNDOyJ9

package/development/header/header-button.js

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

package/development/header/header-environment/header-environment.component.js

@@ -1,2 +1,88 @@
-import { t as SbbHeaderEnvironmentElement } from "../../header-environment.component-DYnJkxCZ.js";
-export { SbbHeaderEnvironmentElement };
+import { MutationController } from "@lit-labs/observers/mutation-controller.js";
+import { css, html } from "lit";
+import { SbbElement } from "../../core/base-elements.js";
+import { boxSizingStyles } from "../../core/styles.js";
+const style = css`:host {
+  position: absolute;
+  inset-inline-end: 0;
+  inset-block-start: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: var(--sbb-text-font-size-xxs);
+  font-weight: bold;
+  letter-spacing: var(--sbb-typo-letter-spacing-text);
+}
+
+:host(:dir(rtl)) {
+  --sbb-header-environment-rotate: -45deg;
+}
+
+:host(:is(:state(env-dev),[state--env-dev])) {
+  --sbb-header-environment-background-color: var(--sbb-color-orange);
+}
+
+:host(:is(:state(env-edu),[state--env-edu])) {
+  --sbb-header-environment-background-color: var(--sbb-color-green);
+}
+
+:host(:is(:state(env-int),[state--env-int])),
+:host(:is(:state(env-inte),[state--env-inte])) {
+  --sbb-header-environment-background-color: var(--sbb-color-granite);
+}
+
+:host(:is(:state(env-loc),[state--env-loc])) {
+  --sbb-header-environment-background-color: var(--sbb-color-pink);
+}
+
+:host(:is(:state(env-test),[state--env-test])) {
+  --sbb-header-environment-background-color: var(--sbb-color-sky);
+}
+
+:host::before {
+  content: "";
+  border-block-start: var(--sbb-header-environment-size) solid var(--sbb-header-environment-background-color);
+  border-inline-start: var(--sbb-header-environment-size) solid transparent;
+}
+
+.sbb-header-environment__text {
+  position: absolute;
+  color: var(--sbb-header-environment-color);
+  rotate: var(--sbb-header-environment-rotate);
+  padding-block-end: var(--sbb-spacing-fixed-4x);
+}`;
+const _SbbHeaderEnvironmentElement = class _SbbHeaderEnvironmentElement extends SbbElement {
+  constructor() {
+    super();
+    this._env = null;
+    this.addController(new MutationController(this, {
+      config: { characterData: true, subtree: true },
+      callback: () => {
+        this._slottedTextChange();
+      }
+    }));
+  }
+  _slottedTextChange() {
+    if (this._env) {
+      this.internals.states.delete(`env-${this._env}`);
+    }
+    this._env = this.textContent?.trim() ?? "";
+    if (this._env) {
+      this.internals.states.add(`env-${this._env}`);
+    }
+  }
+  render() {
+    return html`
+      <span class="sbb-header-environment__text">
+        <slot></slot>
+      </span>
+    `;
+  }
+};
+_SbbHeaderEnvironmentElement.elementName = "sbb-header-environment";
+_SbbHeaderEnvironmentElement.styles = [boxSizingStyles, style];
+let SbbHeaderEnvironmentElement = _SbbHeaderEnvironmentElement;
+export {
+  SbbHeaderEnvironmentElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/header/header-environment.js

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

package/development/header/header-link/header-link.component.js

@@ -1,18 +1,10 @@
 import { SbbLinkBaseElement } from "../../core/base-elements.js";
 import { SbbHeaderActionCommonElementMixin } from "../common/header-action-common.js";
-//#region src/elements/header/header-link/header-link.component.ts
-/**
-* It displays a link element that can be used in the `sbb-header` component.
-*
-* @slot icon - Slot used to render the link icon.
-* @slot - Use the unnamed slot to add content to the `sbb-header-link`.
-*/
-var SbbHeaderLinkElement = class extends SbbHeaderActionCommonElementMixin(SbbLinkBaseElement) {
-	static {
-		this.elementName = "sbb-header-link";
-	}
+const _SbbHeaderLinkElement = class _SbbHeaderLinkElement extends SbbHeaderActionCommonElementMixin(SbbLinkBaseElement) {
 };
-//#endregion
-export { SbbHeaderLinkElement };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLWxpbmsuY29tcG9uZW50LmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9oZWFkZXIvaGVhZGVyLWxpbmsvaGVhZGVyLWxpbmsuY29tcG9uZW50LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNiYkxpbmtCYXNlRWxlbWVudCB9IGZyb20gJy4uLy4uL2NvcmUvYmFzZS1lbGVtZW50cy50cyc7XG5pbXBvcnQgeyBTYmJIZWFkZXJBY3Rpb25Db21tb25FbGVtZW50TWl4aW4gfSBmcm9tICcuLi9jb21tb24vaGVhZGVyLWFjdGlvbi1jb21tb24udHMnO1xuXG4vKipcbiAqIEl0IGRpc3BsYXlzIGEgbGluayBlbGVtZW50IHRoYXQgY2FuIGJlIHVzZWQgaW4gdGhlIGBzYmItaGVhZGVyYCBjb21wb25lbnQuXG4gKlxuICogQHNsb3QgaWNvbiAtIFNsb3QgdXNlZCB0byByZW5kZXIgdGhlIGxpbmsgaWNvbi5cbiAqIEBzbG90IC0gVXNlIHRoZSB1bm5hbWVkIHNsb3QgdG8gYWRkIGNvbnRlbnQgdG8gdGhlIGBzYmItaGVhZGVyLWxpbmtgLlxuICovXG5leHBvcnQgY2xhc3MgU2JiSGVhZGVyTGlua0VsZW1lbnQgZXh0ZW5kcyBTYmJIZWFkZXJBY3Rpb25Db21tb25FbGVtZW50TWl4aW4oU2JiTGlua0Jhc2VFbGVtZW50KSB7XG4gIHB1YmxpYyBzdGF0aWMgb3ZlcnJpZGUgcmVhZG9ubHkgZWxlbWVudE5hbWU6IHN0cmluZyA9ICdzYmItaGVhZGVyLWxpbmsnO1xufVxuXG5kZWNsYXJlIGdsb2JhbCB7XG4gIGludGVyZmFjZSBIVE1MRWxlbWVudFRhZ05hbWVNYXAge1xuICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbmFtaW5nLWNvbnZlbnRpb25cbiAgICAnc2JiLWhlYWRlci1saW5rJzogU2JiSGVhZGVyTGlua0VsZW1lbnQ7XG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBU0EsSUFBYSx1QkFBYixjQUEwQyxrQ0FBa0MsbUJBQW1CLENBQUE7O0FBQzdELE9BQUEsY0FBc0IifQ==
+_SbbHeaderLinkElement.elementName = "sbb-header-link";
+let SbbHeaderLinkElement = _SbbHeaderLinkElement;
+export {
+  SbbHeaderLinkElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLWxpbmsuY29tcG9uZW50LmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvaGVhZGVyL2hlYWRlci1saW5rL2hlYWRlci1saW5rLmNvbXBvbmVudC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTYmJMaW5rQmFzZUVsZW1lbnQgfSBmcm9tICcuLi8uLi9jb3JlL2Jhc2UtZWxlbWVudHMudHMnO1xuaW1wb3J0IHsgU2JiSGVhZGVyQWN0aW9uQ29tbW9uRWxlbWVudE1peGluIH0gZnJvbSAnLi4vY29tbW9uL2hlYWRlci1hY3Rpb24tY29tbW9uLnRzJztcblxuLyoqXG4gKiBJdCBkaXNwbGF5cyBhIGxpbmsgZWxlbWVudCB0aGF0IGNhbiBiZSB1c2VkIGluIHRoZSBgc2JiLWhlYWRlcmAgY29tcG9uZW50LlxuICpcbiAqIEBzbG90IGljb24gLSBTbG90IHVzZWQgdG8gcmVuZGVyIHRoZSBsaW5rIGljb24uXG4gKiBAc2xvdCAtIFVzZSB0aGUgdW5uYW1lZCBzbG90IHRvIGFkZCBjb250ZW50IHRvIHRoZSBgc2JiLWhlYWRlci1saW5rYC5cbiAqL1xuZXhwb3J0IGNsYXNzIFNiYkhlYWRlckxpbmtFbGVtZW50IGV4dGVuZHMgU2JiSGVhZGVyQWN0aW9uQ29tbW9uRWxlbWVudE1peGluKFNiYkxpbmtCYXNlRWxlbWVudCkge1xuICBwdWJsaWMgc3RhdGljIG92ZXJyaWRlIHJlYWRvbmx5IGVsZW1lbnROYW1lOiBzdHJpbmcgPSAnc2JiLWhlYWRlci1saW5rJztcbn1cblxuZGVjbGFyZSBnbG9iYWwge1xuICBpbnRlcmZhY2UgSFRNTEVsZW1lbnRUYWdOYW1lTWFwIHtcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25hbWluZy1jb252ZW50aW9uXG4gICAgJ3NiYi1oZWFkZXItbGluayc6IFNiYkhlYWRlckxpbmtFbGVtZW50O1xuICB9XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7TUFTYSw4QkFBQSw4QkFBNkIsa0NBQWtDLGtCQUFrQixFQUFDOztBQUM3RCxzQkFBQSxjQUFzQjtJQUQzQzsifQ==

package/development/header/header-link.js

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

package/development/header/header.js

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