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

package/development/header.component-FVw_5NRT.js

@@ -0,0 +1,336 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, unsafeCSS } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SbbElement, SbbFocusVisibleWithinController, forceType, idReference, queueDomContentLoaded } from "./core.js";
+//#region src/elements/header/header/header.scss?inline
+var header_default = ":host {\n  --sbb-logo-height: 1rem;\n  --sbb-signet-height: 1rem;\n  --sbb-header-transition-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n}\n@media (min-width: calc(64rem)) {\n  :host {\n    --sbb-logo-height: 1.25rem;\n    --sbb-signet-height: 1.25rem;\n  }\n}\n:host {\n  display: block;\n  height: var(--sbb-header-height);\n  line-height: var(--sbb-typo-line-height-text);\n  padding-block-start: calc(var(--sbb-header-height) + var(--sbb-header-padding-block-start));\n}\n\n:host([size=s]) {\n  --sbb-header-height: var(--sbb-header-height-s);\n}\n\n:host([size=m]) {\n  --sbb-header-height: var(--sbb-header-height-m);\n}\n\n:host([hide-on-scroll]) {\n  --sbb-header-position: absolute;\n}\n\n:host([hide-on-scroll]:is(:state(fixed),[state--fixed])) {\n  --sbb-header-position: fixed;\n  --sbb-header-animation-name: hide;\n  --sbb-header-transform: translate3d(0, -100%, 0);\n  --sbb-header-inset-inline-end: var(--sbb-scrollbar-width, 0);\n}\n\n:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(animated),[state--animated])) {\n  --sbb-header-transition-timing: cubic-bezier(0.4, 0, 1, 1);\n}\n\n:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(visible),[state--visible])) {\n  --sbb-header-animation-name: show;\n  --sbb-header-transform: translate3d(0, 0, 0);\n  --sbb-header-transition-timing: cubic-bezier(0, 0, 0.2, 1);\n}\n\n:host([hide-on-scroll]:is(:state(fixed),[state--fixed]):is(:state(has-visible-focus-within),[state--has-visible-focus-within])) {\n  --sbb-header-transition-duration: 0;\n  --sbb-header-transform: translate3d(0, 0, 0);\n}\n\n.sbb-header {\n  position: var(--sbb-header-position);\n  inset: 0 var(--sbb-header-inset-inline-end) auto 0;\n  padding-block-start: var(--sbb-header-padding-block-start);\n  background: var(--sbb-header-background);\n  z-index: var(--sbb-header-z-index, 10);\n  transform: var(--sbb-header-transform);\n  transition-property: box-shadow;\n  transition-duration: var(--sbb-header-transition-duration);\n  transition-timing-function: var(--sbb-header-transition-timing);\n  animation-name: var(--sbb-header-animation-name);\n  animation-duration: var(--sbb-header-transition-duration);\n  animation-timing-function: var(--sbb-header-transition-timing);\n}\n: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 {\n  box-shadow: var(--sbb-header-box-shadow);\n}\n@media (forced-colors: active) {\n  .sbb-header {\n    border-block-end: var(--sbb-border-width-1x) solid CanvasText;\n  }\n}\n\n.sbb-header__wrapper {\n  display: flex;\n  align-items: center;\n  justify-content: flex-start;\n  height: var(--sbb-header-height);\n}\n:host(:not([expanded])) .sbb-header__wrapper {\n  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));\n  margin-inline: auto;\n  width: 100%;\n}\n@media (min-width: calc(90rem)) {\n  :host(:not([expanded])) .sbb-header__wrapper {\n    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));\n  }\n}\n:host([expanded]) .sbb-header__wrapper {\n  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-spacing-responsive-xxs));\n}\n\n::slotted(:is(sbb-header-button, sbb-header-link):first-child) {\n  margin-inline-start: var(--sbb-header-first-item-margin-inline-start);\n}\n\n::slotted(*) {\n  flex: 0 0 auto;\n}\n\n::slotted(.sbb-header-shrinkable) {\n  flex-shrink: 1;\n  min-width: 0;\n}\n\n::slotted(.sbb-header-spacer) {\n  flex-grow: 1;\n}\n\n::slotted(.sbb-header-logo) {\n  margin-inline-start: var(--sbb-spacing-responsive-s);\n}\n\n::slotted(a.sbb-header-logo) {\n  display: block;\n  padding-block: var(--sbb-spacing-fixed-3x);\n  position: relative;\n  outline: none !important;\n}\n\n::slotted(a.sbb-header-logo)::before {\n  content: \"\";\n  display: block;\n  position: absolute;\n  inset: var(--sbb-spacing-fixed-3x) 0;\n}\n\n::slotted(a.sbb-header-logo: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  outline-offset: var(--sbb-spacing-fixed-3x);\n  border-radius: 1px;\n}\n\n@keyframes show {\n  from {\n    transform: translate3d(0, -100%, 0);\n  }\n  to {\n    transform: translate3d(0, 0, 0);\n  }\n}\n@keyframes hide {\n  from {\n    transform: translate3d(0, 0, 0);\n  }\n  to {\n    transform: translate3d(0, -100%, 0);\n  }\n}";
+//#endregion
+//#region src/elements/header/header/header.component.ts
+var IS_MENU_OPENED_QUERY = "[aria-controls][aria-expanded='true']";
+/**
+* It displays a header section for the page.
+*
+* @slot - Use the unnamed slot to add actions, content and logo to the header.
+* @cssprop [--sbb-header-z-index=10] - Can be used to modify the z-index of the header.
+* @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.
+* @cssprop [--sbb-header-padding-block-start:env(safe-area-inset-top, 0)] - Defines the header's padding-block-start. It defaults to the device's safe-area inset to prevent the header from being obscured by display cutouts or system UI elements. This variable must be set on the root document element (`<html>`) so that components relying on the header's height can calculate their layout correctly.
+* @cssprop [--sbb-header-vertical-spacing] - Readonly; sum of var(--sbb-header-height) and var(--sbb-header-padding-block-start) that can be used to manage spacing of absolute positioned elements that shouldn't overlap the header.
+*/
+var SbbHeaderElement = (() => {
+	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 class SbbHeaderElement extends _classSuper {
+		static {
+			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(this, 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(this, 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(this, 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(this, 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(this, 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(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-header";
+		}
+		static {
+			this.styles = [unsafeCSS(header_default)];
+		}
+		static {
+			this._headerScrollOrigins = /* @__PURE__ */ new Set();
+		}
+		static {
+			this._headerElements = /* @__PURE__ */ new Set();
+		}
+		static {
+			if (!isServer) queueDomContentLoaded(() => this._initializeScrollOriginObserver());
+		}
+		#expanded_accessor_storage;
+		/**
+		* Whether to allow the header content to stretch to full width.
+		* By default, the content has the appropriate page size.
+		*/
+		get expanded() {
+			return this.#expanded_accessor_storage;
+		}
+		set expanded(value) {
+			this.#expanded_accessor_storage = value;
+		}
+		#scrollOrigin_accessor_storage;
+		/**
+		* The element's id or the element on which the scroll listener is attached.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get scrollOrigin() {
+			return this.#scrollOrigin_accessor_storage;
+		}
+		set scrollOrigin(value) {
+			this.#scrollOrigin_accessor_storage = value;
+		}
+		#hideOnScroll_accessor_storage;
+		/** Whether the header should hide and show on scroll. */
+		get hideOnScroll() {
+			return this.#hideOnScroll_accessor_storage;
+		}
+		set hideOnScroll(value) {
+			this.#hideOnScroll_accessor_storage = value;
+		}
+		#size_accessor_storage;
+		/**
+		* Size of the header, either s (lean theme default) or m (standard theme default).
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		#_headerOnTop_accessor_storage;
+		get _headerOnTop() {
+			return this.#_headerOnTop_accessor_storage;
+		}
+		set _headerOnTop(value) {
+			this.#_headerOnTop_accessor_storage = value;
+		}
+		constructor() {
+			super();
+			this.#expanded_accessor_storage = __runInitializers(this, _expanded_initializers, false);
+			this.#scrollOrigin_accessor_storage = (__runInitializers(this, _expanded_extraInitializers), __runInitializers(this, _scrollOrigin_initializers, null));
+			this.#hideOnScroll_accessor_storage = (__runInitializers(this, _scrollOrigin_extraInitializers), __runInitializers(this, _hideOnScroll_initializers, false));
+			this.#size_accessor_storage = (__runInitializers(this, _hideOnScroll_extraInitializers), __runInitializers(this, _size_initializers, null));
+			this.#_headerOnTop_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, __headerOnTop_initializers, true));
+			this._scrollElement = __runInitializers(this, __headerOnTop_extraInitializers);
+			this._lastScroll = 0;
+			this._scrollOriginFromObserver = null;
+			this.addController(new SbbFocusVisibleWithinController(this));
+		}
+		static _initializeScrollOriginObserver() {
+			new MutationObserver((mutations) => {
+				for (const mutation of mutations) if (mutation.type === "attributes") this._handleScrollOriginElement(mutation.target);
+				else if (mutation.type === "childList") for (const node of [...mutation.addedNodes, ...mutation.removedNodes].filter((n) => n.nodeType === n.ELEMENT_NODE)) {
+					this._handleScrollOriginElement(node);
+					this._findAndHandleScrollOrigins(node);
+				}
+				this._updateHeaderElements();
+			}).observe(document.documentElement, {
+				attributeFilter: ["sbb-header-scroll-origin"],
+				childList: true,
+				subtree: true
+			});
+			this._findAndHandleScrollOrigins(document.body);
+			this._updateHeaderElements();
+		}
+		static _findAndHandleScrollOrigins(root) {
+			root.querySelectorAll("[sbb-header-scroll-origin]").forEach((e) => this._handleScrollOriginElement(e));
+		}
+		static _handleScrollOriginElement(element) {
+			if (element.isConnected && element.hasAttribute("sbb-header-scroll-origin")) this._headerScrollOrigins.add(element);
+			else this._headerScrollOrigins.delete(element);
+		}
+		static _updateHeaderElements() {
+			for (const header of this._headerElements) {
+				if (this._headerScrollOrigins.size === 0) header._scrollOriginFromObserver = null;
+				else if (this._headerScrollOrigins.size === 1) header._scrollOriginFromObserver = this._headerScrollOrigins.values().next().value ?? null;
+				else header._scrollOriginFromObserver = Array.from(this._headerScrollOrigins).sort((c1, c2) => c1.compareDocumentPosition(c2) & Node.DOCUMENT_POSITION_CONTAINS).at(-1) ?? null;
+				header._updateScrollListener();
+			}
+		}
+		/** If `hideOnScroll` is set, checks the element to hook the listener on, and possibly add it.*/
+		connectedCallback() {
+			super.connectedCallback();
+			SbbHeaderElement._headerElements.add(this);
+			if (this.hasUpdated) this._updateScrollListener();
+		}
+		/** Removes the scroll listener, if previously attached. */
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this._scrollElement = null;
+			this._scrollEventsController?.abort();
+			SbbHeaderElement._headerElements.delete(this);
+		}
+		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 ?? this._scrollOriginFromObserver ?? 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(property) {
+			if (this._scrollElement instanceof Document) return this._scrollElement.documentElement[property] || this._scrollElement.body[property];
+			return this._scrollElement?.[property] || 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 overlay = overlayTrigger.ariaControlsElements[0];
+				if (typeof overlay?.close === "function") overlay.close();
+			}
+		}
+		render() {
+			return html`
+      <header class="sbb-header">
+        <div class="sbb-header__wrapper">
+          <slot></slot>
+        </div>
+      </header>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbHeaderElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"header.component-FVw_5NRT.js","names":[],"sources":["../../../src/elements/header/header/header.scss?inline","../../../src/elements/header/header/header.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-logo-height: #{sbb.px-to-rem-build(16)};\n  --sbb-signet-height: #{sbb.px-to-rem-build(16)};\n  --sbb-header-transition-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n\n  @include sbb.mq($from: large) {\n    --sbb-logo-height: #{sbb.px-to-rem-build(20)};\n    --sbb-signet-height: #{sbb.px-to-rem-build(20)};\n  }\n\n  display: block;\n\n  // Setting the height here reserves the space for the header which will else be lost with fixed position.\n  height: var(--sbb-header-height);\n\n  // Set the line-height for adjacent elements in order to prevent from influence of a consumer-set line-height.\n  line-height: var(--sbb-typo-line-height-text);\n  padding-block-start: calc(var(--sbb-header-height) + var(--sbb-header-padding-block-start));\n}\n\n:host([size='s']) {\n  --sbb-header-height: var(--sbb-header-height-s);\n}\n\n:host([size='m']) {\n  --sbb-header-height: var(--sbb-header-height-m);\n}\n\n:host([hide-on-scroll]) {\n  --sbb-header-position: absolute;\n}\n\n:host([hide-on-scroll]:state(fixed)) {\n  --sbb-header-position: fixed;\n  --sbb-header-animation-name: hide;\n  --sbb-header-transform: translate3d(0, -100%, 0);\n  --sbb-header-inset-inline-end: var(--sbb-scrollbar-width, 0);\n}\n\n:host([hide-on-scroll]:state(fixed):state(animated)) {\n  // Hide transition\n  --sbb-header-transition-timing: cubic-bezier(0.4, 0, 1, 1);\n}\n\n:host([hide-on-scroll]:state(fixed):state(visible)) {\n  --sbb-header-animation-name: show;\n  --sbb-header-transform: translate3d(0, 0, 0);\n\n  // Show transition\n  --sbb-header-transition-timing: cubic-bezier(0, 0, 0.2, 1);\n}\n\n:host([hide-on-scroll]:state(fixed):state(has-visible-focus-within)) {\n  --sbb-header-transition-duration: 0;\n  --sbb-header-transform: translate3d(0, 0, 0);\n}\n\n.sbb-header {\n  position: var(--sbb-header-position);\n  inset: 0 var(--sbb-header-inset-inline-end) auto 0;\n  padding-block-start: var(--sbb-header-padding-block-start);\n  background: var(--sbb-header-background);\n  z-index: var(--sbb-header-z-index, 10);\n  transform: var(--sbb-header-transform);\n  transition: {\n    property: box-shadow;\n    duration: var(--sbb-header-transition-duration);\n    timing-function: var(--sbb-header-transition-timing);\n  }\n  animation: {\n    name: var(--sbb-header-animation-name);\n    duration: var(--sbb-header-transition-duration);\n    timing-function: var(--sbb-header-transition-timing);\n  }\n\n  :host(:is(:state(shadow), :state(has-visible-focus-within):state(fixed))) & {\n    box-shadow: var(--sbb-header-box-shadow);\n  }\n\n  @media (forced-colors: active) {\n    border-block-end: var(--sbb-border-width-1x) solid CanvasText;\n  }\n}\n\n.sbb-header__wrapper {\n  display: flex;\n  align-items: center;\n  justify-content: flex-start;\n  height: var(--sbb-header-height);\n\n  :host(:not([expanded])) & {\n    @include sbb.page-spacing;\n  }\n\n  :host([expanded]) & {\n    @include sbb.page-spacing-expanded;\n  }\n}\n\n// Fix left offset if first element of the header is a sbb-header-button/sbb-header-link.\n// The value of the offset is calculated inside sbb-header-button/sbb-header-link styles.\n::slotted(:is(sbb-header-button, sbb-header-link):first-child) {\n  margin-inline-start: var(--sbb-header-first-item-margin-inline-start);\n}\n\n::slotted(*) {\n  flex: 0 0 auto;\n}\n\n::slotted(.sbb-header-shrinkable) {\n  flex-shrink: 1;\n  min-width: 0;\n}\n\n::slotted(.sbb-header-spacer) {\n  flex-grow: 1;\n}\n\n::slotted(.sbb-header-logo) {\n  margin-inline-start: var(--sbb-spacing-responsive-s);\n}\n\n// Apply padding and outline to possible slotted link in logo slot\n::slotted(a.sbb-header-logo) {\n  display: block;\n  padding-block: var(--sbb-spacing-fixed-3x);\n  position: relative;\n\n  // Use !important here to not interfere with Firefox focus ring definition\n  // which appears in normalize CSS of several frameworks.\n  outline: none !important;\n}\n\n// To show the correct outline, we need to span a hidden element filling the link but without the outline-offset.\n::slotted(a.sbb-header-logo)::before {\n  content: '';\n  display: block;\n  position: absolute;\n  inset: var(--sbb-spacing-fixed-3x) 0;\n}\n\n::slotted(a.sbb-header-logo:focus-visible)::before {\n  @include sbb.focus-outline;\n\n  outline-offset: var(--sbb-spacing-fixed-3x);\n\n  // As if the outline has an offset, the border radius increases, we set it to the smallest possible border-radius.\n  border-radius: 1px;\n}\n\n@keyframes show {\n  from {\n    transform: translate3d(0, -100%, 0);\n  }\n\n  to {\n    transform: translate3d(0, 0, 0);\n  }\n}\n\n@keyframes hide {\n  from {\n    transform: translate3d(0, 0, 0);\n  }\n\n  to {\n    transform: translate3d(0, -100%, 0);\n  }\n}\n","import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport {\n  forceType,\n  idReference,\n  queueDomContentLoaded,\n  SbbElement,\n  SbbFocusVisibleWithinController,\n} from '../../core.ts';\n\nimport style from './header.scss?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 * @cssprop [--sbb-header-padding-block-start:env(safe-area-inset-top, 0)] - Defines the header's padding-block-start. It defaults to the device's safe-area inset to prevent the header from being obscured by display cutouts or system UI elements. This variable must be set on the root document element (`<html>`) so that components relying on the header's height can calculate their layout correctly.\n * @cssprop [--sbb-header-vertical-spacing] - Readonly; sum of var(--sbb-header-height) and var(--sbb-header-padding-block-start) that can be used to manage spacing of absolute positioned elements that shouldn't overlap the header.\n */\nexport class SbbHeaderElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-header';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n\n  private static _headerScrollOrigins = new Set<HTMLElement>();\n  private static _headerElements = new Set<SbbHeaderElement>();\n\n  static {\n    if (!isServer) {\n      // We don't want to block execution for initialization,\n      // so we defer it until the DOM content is loaded.\n      queueDomContentLoaded(() => this._initializeScrollOriginObserver());\n    }\n  }\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 s (lean theme default) or m (standard theme default).\n   */\n  @property({ reflect: true }) public accessor size: 's' | 'm' | null = null;\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  private _scrollOriginFromObserver: HTMLElement | null = null;\n\n  public constructor() {\n    super();\n    this.addController(new SbbFocusVisibleWithinController(this));\n  }\n\n  private static _initializeScrollOriginObserver(): void {\n    // We are using MutationObserver directly here, as it will only be called on client side,\n    // and we do not need to disconnect it, as we want it to work during the full lifetime\n    // of the page.\n    new MutationObserver((mutations) => {\n      for (const mutation of mutations) {\n        if (mutation.type === 'attributes') {\n          this._handleScrollOriginElement(mutation.target as HTMLElement);\n        } else if (mutation.type === 'childList') {\n          for (const node of [...mutation.addedNodes, ...mutation.removedNodes].filter(\n            (n): n is HTMLElement => n.nodeType === n.ELEMENT_NODE,\n          )) {\n            this._handleScrollOriginElement(node);\n            this._findAndHandleScrollOrigins(node);\n          }\n        }\n      }\n      this._updateHeaderElements();\n    }).observe(document.documentElement, {\n      attributeFilter: ['sbb-header-scroll-origin'],\n      childList: true,\n      subtree: true,\n    });\n    this._findAndHandleScrollOrigins(document.body);\n    this._updateHeaderElements();\n  }\n\n  private static _findAndHandleScrollOrigins(root: HTMLElement): void {\n    root\n      .querySelectorAll<HTMLElement>('[sbb-header-scroll-origin]')\n      .forEach((e) => this._handleScrollOriginElement(e));\n  }\n\n  private static _handleScrollOriginElement(element: HTMLElement): void {\n    if (element.isConnected && element.hasAttribute('sbb-header-scroll-origin')) {\n      this._headerScrollOrigins.add(element);\n    } else {\n      this._headerScrollOrigins.delete(element);\n    }\n  }\n\n  private static _updateHeaderElements(): void {\n    for (const header of this._headerElements) {\n      if (this._headerScrollOrigins.size === 0) {\n        header._scrollOriginFromObserver = null;\n      } else if (this._headerScrollOrigins.size === 1) {\n        header._scrollOriginFromObserver = this._headerScrollOrigins.values().next().value ?? null;\n      } else {\n        header._scrollOriginFromObserver =\n          Array.from(this._headerScrollOrigins)\n            .sort((c1, c2) => c1.compareDocumentPosition(c2) & Node.DOCUMENT_POSITION_CONTAINS)\n            .at(-1) ?? null;\n      }\n      header._updateScrollListener();\n    }\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    SbbHeaderElement._headerElements.add(this);\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    SbbHeaderElement._headerElements.delete(this);\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 ?? this._scrollOriginFromObserver ?? 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 overlay = overlayTrigger.ariaControlsElements![0] as HTMLElement & {\n        close: () => void;\n      };\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"],"mappings":"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"}

package/development/header.js

@@ -1,8 +1,8 @@
-import { t as SbbHeaderActionCommonElementMixin } from "./header-action-common-Be0XQge2.js";
+import { t as SbbHeaderActionCommonElementMixin } from "./header-action-common-DX2ejpAL.js";
 import { SbbHeaderButtonElement } from "./header/header-button/header-button.component.js";
-import { t as SbbHeaderEnvironmentElement } from "./header-environment.component-CIyxQwkQ.js";
+import { t as SbbHeaderEnvironmentElement } from "./header-environment.component--4YEZyKq.js";
 import { SbbHeaderLinkElement } from "./header/header-link/header-link.component.js";
-import { t as SbbHeaderElement } from "./header.component-C4e7CNql.js";
+import { t as SbbHeaderElement } from "./header.component-FVw_5NRT.js";
 import "./header.pure.js";
 //#region src/elements/header.ts
 /** @entrypoint */
@@ -13,4 +13,4 @@ SbbHeaderLinkElement.define();
 //#endregion
 export { SbbHeaderActionCommonElementMixin, SbbHeaderButtonElement, SbbHeaderElement, SbbHeaderEnvironmentElement, SbbHeaderLinkElement };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbGVtZW50cy9oZWFkZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQge1xuICBTYmJIZWFkZXJCdXR0b25FbGVtZW50LFxuICBTYmJIZWFkZXJFbGVtZW50LFxuICBTYmJIZWFkZXJFbnZpcm9ubWVudEVsZW1lbnQsXG4gIFNiYkhlYWRlckxpbmtFbGVtZW50LFxufSBmcm9tICcuL2hlYWRlci5wdXJlLnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9oZWFkZXIucHVyZS50cyc7XG5cblNiYkhlYWRlckVsZW1lbnQuZGVmaW5lKCk7XG5TYmJIZWFkZXJCdXR0b25FbGVtZW50LmRlZmluZSgpO1xuU2JiSGVhZGVyRW52aXJvbm1lbnRFbGVtZW50LmRlZmluZSgpO1xuU2JiSGVhZGVyTGlua0VsZW1lbnQuZGVmaW5lKCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBVUEsaUJBQWlCLFFBQVE7QUFDekIsdUJBQXVCLFFBQVE7QUFDL0IsNEJBQTRCLFFBQVE7QUFDcEMscUJBQXFCLFFBQVEifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbGVtZW50cy9oZWFkZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQge1xuICBTYmJIZWFkZXJCdXR0b25FbGVtZW50LFxuICBTYmJIZWFkZXJFbGVtZW50LFxuICBTYmJIZWFkZXJFbnZpcm9ubWVudEVsZW1lbnQsXG4gIFNiYkhlYWRlckxpbmtFbGVtZW50LFxufSBmcm9tICcuL2hlYWRlci5wdXJlLnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9oZWFkZXIucHVyZS50cyc7XG5cblNiYkhlYWRlckVsZW1lbnQuZGVmaW5lKCk7XG5TYmJIZWFkZXJCdXR0b25FbGVtZW50LmRlZmluZSgpO1xuU2JiSGVhZGVyRW52aXJvbm1lbnRFbGVtZW50LmRlZmluZSgpO1xuU2JiSGVhZGVyTGlua0VsZW1lbnQuZGVmaW5lKCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBVUEsaUJBQWlCLE9BQU07QUFDdkIsdUJBQXVCLE9BQU07QUFDN0IsNEJBQTRCLE9BQU07QUFDbEMscUJBQXFCLE9BQU0ifQ==

package/development/header.pure.js

@@ -1,6 +1,6 @@
-import { t as SbbHeaderActionCommonElementMixin } from "./header-action-common-Be0XQge2.js";
+import { t as SbbHeaderActionCommonElementMixin } from "./header-action-common-DX2ejpAL.js";
 import { SbbHeaderButtonElement } from "./header/header-button/header-button.component.js";
-import { t as SbbHeaderEnvironmentElement } from "./header-environment.component-CIyxQwkQ.js";
+import { t as SbbHeaderEnvironmentElement } from "./header-environment.component--4YEZyKq.js";
 import { SbbHeaderLinkElement } from "./header/header-link/header-link.component.js";
-import { t as SbbHeaderElement } from "./header.component-C4e7CNql.js";
+import { t as SbbHeaderElement } from "./header.component-FVw_5NRT.js";
 export { SbbHeaderActionCommonElementMixin, SbbHeaderButtonElement, SbbHeaderElement, SbbHeaderEnvironmentElement, SbbHeaderLinkElement };

package/development/{hint.component-BB9QLGGx.js → hint.component-CdM71SNj.js}

@@ -33,4 +33,4 @@ var SbbHintElement = class extends SbbNegativeMixin(SbbElement) {
 //#endregion
 export { SbbHintElement as t };
 
-//# 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/icon/icon-base.js

@@ -1,2 +1,2 @@
-import { t as SbbIconBase } from "../icon-base-DrBHy9BT.js";
+import { t as SbbIconBase } from "../icon-base-Cq6DxOUh.js";
 export { SbbIconBase };

package/development/icon/icon-name-mixin.js

@@ -82,4 +82,4 @@ var SbbIconNameMixin = (superClass) => {
 //#endregion
 export { SbbIconNameMixin };
 
-//# 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/icon/icon-request.js

@@ -32,4 +32,4 @@ var getSvgContent = (namespace, name, sanitize) => {
 //#endregion
 export { getSvgContent };
 
-//# 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/icon/icon-validate.js

@@ -35,4 +35,4 @@ var validateContent = (svgContent, sanitize = true, colorImmutable = false) => {
 //#endregion
 export { isValid, validateContent };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWNvbi12YWxpZGF0ZS5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvaWNvbi9pY29uLXZhbGlkYXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IGlzU3RyID0gKHZhbDogYW55KTogdmFsIGlzIHN0cmluZyA9PiB0eXBlb2YgdmFsID09PSAnc3RyaW5nJztcblxuLyoqXG4gKiBTYW5pdGl6ZXMgdGhlIFNWRyBlbGVtZW50IGFuZCBhbGwgaXRzIGNoaWxkIG5vZGVzLlxuICogRG9lcyBub3QgYWxsb3cgYDxzY3JpcHQ+YCBlbGVtZW50cywgb3IgYW55IGF0dHJpYnV0ZXMgdGhhdCBzdGFydCB3aXRoIGBvbmAsIHN1Y2ggYXMgYG9uY2xpY2tgLlxuICovXG5leHBvcnQgY29uc3QgaXNWYWxpZCA9IChlbG06IEhUTUxFbGVtZW50KTogYm9vbGVhbiA9PiB7XG4gIGlmIChlbG0ubm9kZVR5cGUgPT09IDEpIHtcbiAgICAvLyBpcyBhbiBFbGVtZW50IG5vZGUgbGlrZSA8ZGl2PiwgPHA+IG9yIDxzdmc+XG4gICAgaWYgKGVsbS5ub2RlTmFtZS50b0xvd2VyQ2FzZSgpID09PSAnc2NyaXB0Jykge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cblxuICAgIC8vIGRvIG5vdCBhbGxvdyBhdHRyaWJ1dGVzIHN0YXJ0aW5nIHdpdGggYG9uYFxuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgZWxtLmF0dHJpYnV0ZXMubGVuZ3RoOyBpKyspIHtcbiAgICAgIGNvbnN0IHZhbCA9IGVsbS5hdHRyaWJ1dGVzW2ldLm5hbWU7XG4gICAgICBpZiAoaXNTdHIodmFsKSAmJiB2YWwudG9Mb3dlckNhc2UoKS5pbmRleE9mKCdvbicpID09PSAwKSB7XG4gICAgICAgIHJldHVybiBmYWxzZTtcbiAgICAgIH1cbiAgICB9XG5cbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IGVsbS5jaGlsZE5vZGVzLmxlbmd0aDsgaSsrKSB7XG4gICAgICBpZiAoIWlzVmFsaWQoZWxtLmNoaWxkTm9kZXNbaV0gYXMgYW55KSkge1xuICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgICB9XG4gICAgfVxuICB9XG4gIHJldHVybiB0cnVlO1xufTtcblxuLyoqXG4gKiBWYWxpZGF0ZXMgdGhlIFNWRyBjb250ZW50IGJ5IGNoZWNraW5nIHRoYXQgaXQgaGFzIG9ubHkgb25lIHJvb3QgZWxlbWVudCBgPHN2Zz5gLFxuICogYWRkaW5nIHRoZSBgY29sb3ItaW1tdXRhYmxlYCBjbGFzcyBpZiB0aGUgYGNvbG9ySW1tdXRhYmxlYCBvcHRpb24gaXMgc2V0IHRvIGB0cnVlYCxcbiAqIGFuZCBzYW5pdGl6aW5nIHRoZSBwcm92aWRlZCBjb250ZW50IGFzIGxvbmcgYXMgdGhlIGBzYW5pdGl6ZWAgcHJvcGVydHkgaXMgbm90IGV4cGxpY2l0bHkgc2V0IHRvIGBmYWxzZWAuXG4gKi9cbmV4cG9ydCBjb25zdCB2YWxpZGF0ZUNvbnRlbnQgPSAoXG4gIHN2Z0NvbnRlbnQ6IHN0cmluZyxcbiAgc2FuaXRpemUgPSB0cnVlLFxuICBjb2xvckltbXV0YWJsZSA9IGZhbHNlLFxuKTogc3RyaW5nID0+IHtcbiAgY29uc3QgZGl2ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7XG4gIGRpdi5pbm5lckhUTUwgPSBzdmdDb250ZW50O1xuXG4gIGZvciAobGV0IGkgPSBkaXYuY2hpbGROb2Rlcy5sZW5ndGggLSAxOyBpID49IDA7IGktLSkge1xuICAgIGlmIChkaXYuY2hpbGROb2Rlc1tpXS5ub2RlTmFtZS50b0xvd2VyQ2FzZSgpICE9PSAnc3ZnJykge1xuICAgICAgZGl2LnJlbW92ZUNoaWxkKGRpdi5jaGlsZE5vZGVzW2ldKTtcbiAgICB9XG4gIH1cblxuICAvLyBtdXN0IG9ubHkgaGF2ZSAxIHJvb3QgZWxlbWVudFxuICBjb25zdCBzdmdFbG0gPSBkaXYuZmlyc3RFbGVtZW50Q2hpbGQ7XG5cbiAgaWYgKHN2Z0VsbSAmJiBzdmdFbG0ubm9kZU5hbWUudG9Mb3dlckNhc2UoKSA9PT0gJ3N2ZycpIHtcbiAgICBpZiAoY29sb3JJbW11dGFibGUgJiYgIXN2Z0VsbS5jbGFzc0xpc3QuY29udGFpbnMoJ2NvbG9yLWltbXV0YWJsZScpKSB7XG4gICAgICBzdmdFbG0uY2xhc3NMaXN0LmFkZCgnY29sb3ItaW1tdXRhYmxlJyk7XG4gICAgfVxuXG4gICAgLy8gZG8gbm90IHNhbml0aXplIHRoZSBzdmcgZWxlbWVudFxuICAgIGlmICghc2FuaXRpemUpIHtcbiAgICAgIHJldHVybiBkaXYuaW5uZXJIVE1MO1xuICAgIH1cblxuICAgIC8vIHNhbml0aXplIHRoZSBzdmcgZWxlbWVudFxuICAgIGlmIChpc1ZhbGlkKHN2Z0VsbSBhcyBhbnkpKSB7XG4gICAgICByZXR1cm4gZGl2LmlubmVySFRNTDtcbiAgICB9XG4gIH1cbiAgcmV0dXJuICcnO1xufTtcbiJdLCJtYXBwaW5ncyI6IjtBQUFBLElBQU0sU0FBUyxRQUE0QixPQUFPLFFBQVE7Ozs7O0FBTTFELElBQWEsV0FBVyxRQUE2QjtDQUNuRCxJQUFJLElBQUksYUFBYSxHQUFHO0VBRXRCLElBQUksSUFBSSxTQUFTLGFBQWEsS0FBSyxVQUNqQyxPQUFPO0VBSVQsS0FBSyxJQUFJLElBQUksR0FBRyxJQUFJLElBQUksV0FBVyxRQUFRLEtBQUs7R0FDOUMsTUFBTSxNQUFNLElBQUksV0FBVyxHQUFHO0dBQzlCLElBQUksTUFBTSxJQUFJLElBQUksSUFBSSxhQUFhLENBQUMsUUFBUSxLQUFLLEtBQUssR0FDcEQsT0FBTzs7RUFJWCxLQUFLLElBQUksSUFBSSxHQUFHLElBQUksSUFBSSxXQUFXLFFBQVEsS0FDekMsSUFBSSxDQUFDLFFBQVEsSUFBSSxXQUFXLEdBQVUsRUFDcEMsT0FBTzs7Q0FJYixPQUFPOzs7Ozs7O0FBUVQsSUFBYSxtQkFDWCxZQUNBLFdBQVcsTUFDWCxpQkFBaUIsVUFDUDtDQUNWLE1BQU0sTUFBTSxTQUFTLGNBQWMsTUFBTTtDQUN6QyxJQUFJLFlBQVk7Q0FFaEIsS0FBSyxJQUFJLElBQUksSUFBSSxXQUFXLFNBQVMsR0FBRyxLQUFLLEdBQUcsS0FDOUMsSUFBSSxJQUFJLFdBQVcsR0FBRyxTQUFTLGFBQWEsS0FBSyxPQUMvQyxJQUFJLFlBQVksSUFBSSxXQUFXLEdBQUc7Q0FLdEMsTUFBTSxTQUFTLElBQUk7Q0FFbkIsSUFBSSxVQUFVLE9BQU8sU0FBUyxhQUFhLEtBQUssT0FBTztFQUNyRCxJQUFJLGtCQUFrQixDQUFDLE9BQU8sVUFBVSxTQUFTLGtCQUFrQixFQUNqRSxPQUFPLFVBQVUsSUFBSSxrQkFBa0I7RUFJekMsSUFBSSxDQUFDLFVBQ0gsT0FBTyxJQUFJO0VBSWIsSUFBSSxRQUFRLE9BQWMsRUFDeEIsT0FBTyxJQUFJOztDQUdmLE9BQU8ifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/icon/icon.component.d.ts

@@ -23,7 +23,7 @@ export declare class SbbIconElement extends SbbIconBase {
      * components) we need to check whether the attribute svgicon is used.
      */
     private accessor _sbbAngularCompatibility;
-    connectedCallback(): void;
+    constructor();
     protected fetchSvgIcon(namespace: string, name: string): Promise<string>;
     protected willUpdate(changedProperties: PropertyValues<this>): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;

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

@@ -1 +1 @@
-{"version":3,"file":"icon.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/icon/icon.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAKrE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;GAEG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,gBAAgC,WAAW,EAAE,MAAM,CAAc;IACjE;;;;OAIG;IACH,WAA2B,kBAAkB,IAAI,MAAM,EAAE,CAExD;IAED;;;;OAIG;IACH,SAEgB,IAAI,EAAE,MAAM,CAAM;IAElC;;;;OAIG;IACM,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAS;IAE3C,iBAAiB,IAAI,IAAI;cAMhB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;cAKpE,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAQ5D,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,IAAI;cAQY,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,UAAU,EAAE,cAAc,CAAC;KAC5B;CACF"}
+{"version":3,"file":"icon.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/icon/icon.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAKrE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;GAEG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,gBAAgC,WAAW,EAAE,MAAM,CAAc;IACjE;;;;OAIG;IACH,WAA2B,kBAAkB,IAAI,MAAM,EAAE,CAExD;IAED;;;;OAIG;IACH,SAEgB,IAAI,EAAE,MAAM,CAAM;IAElC;;;;OAIG;IACM,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAS;;cASlC,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;cAKpE,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAQ5D,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,IAAI;cAQY,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,UAAU,EAAE,cAAc,CAAC;KAC5B;CACF"}

package/development/icon/icon.component.js

@@ -1,4 +1,4 @@
-import { t as SbbIconBase } from "../icon-base-DrBHy9BT.js";
+import { t as SbbIconBase } from "../icon-base-Cq6DxOUh.js";
 import { __esDecorate, __runInitializers } from "tslib";
 import { html } from "lit";
 import { property, state } from "lit/decorators.js";
@@ -93,8 +93,10 @@ var SbbIconElement = (() => {
 		set _sbbAngularCompatibility(value) {
 			this.#_sbbAngularCompatibility_accessor_storage = value;
 		}
-		connectedCallback() {
-			super.connectedCallback();
+		constructor() {
+			super();
+			__runInitializers(this, __sbbAngularCompatibility_extraInitializers);
+			/** @internal **/
 			this.internals.ariaHidden = "true";
 		}
 		async fetchSvgIcon(namespace, name) {
@@ -112,13 +114,9 @@ var SbbIconElement = (() => {
 		render() {
 			return this._sbbAngularCompatibility ? html`<slot></slot>` : super.render();
 		}
-		constructor() {
-			super(...arguments);
-			__runInitializers(this, __sbbAngularCompatibility_extraInitializers);
-		}
 	};
 })();
 //#endregion
 export { SbbIconElement };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWNvbi5jb21wb25lbnQuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2ljb24vaWNvbi5jb21wb25lbnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaHRtbCwgdHlwZSBQcm9wZXJ0eVZhbHVlcywgdHlwZSBUZW1wbGF0ZVJlc3VsdCB9IGZyb20gJ2xpdCc7XG5pbXBvcnQgeyBwcm9wZXJ0eSwgc3RhdGUgfSBmcm9tICdsaXQvZGVjb3JhdG9ycy5qcyc7XG5cbmltcG9ydCB7IGZvcmNlVHlwZSwgb21pdEVtcHR5Q29udmVydGVyIH0gZnJvbSAnLi4vY29yZS50cyc7XG5cbmltcG9ydCB7IFNiYkljb25CYXNlIH0gZnJvbSAnLi9pY29uLWJhc2UudHMnO1xuXG4vKipcbiAqIERpc3BsYXlzIGFuIGljb24gbG9hZGVkIGZyb20gYSByZWdpc3RlcmVkIG5hbWVzcGFjZS5cbiAqL1xuZXhwb3J0IGNsYXNzIFNiYkljb25FbGVtZW50IGV4dGVuZHMgU2JiSWNvbkJhc2Uge1xuICBwdWJsaWMgc3RhdGljIG92ZXJyaWRlIHJlYWRvbmx5IGVsZW1lbnROYW1lOiBzdHJpbmcgPSAnc2JiLWljb24nO1xuICAvKipcbiAgICogV2UgbmVlZCB0byBhZGRpdGlvbmFsbHkgb2JzZXJ2ZSB0aGUgc3ZnaWNvbiBhdHRyaWJ1dGVcbiAgICogZm9yIHNiYi1hbmd1bGFyIGNvbXBhdGliaWxpdHkuXG4gICAqIEBpbnRlcm5hbFxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBvdmVycmlkZSBnZXQgb2JzZXJ2ZWRBdHRyaWJ1dGVzKCk6IHN0cmluZ1tdIHtcbiAgICByZXR1cm4gc3VwZXIub2JzZXJ2ZWRBdHRyaWJ1dGVzLmNvbmNhdCgnc3ZnaWNvbicpO1xuICB9XG5cbiAgLyoqXG4gICAqIFRoZSBwcm92aWRlZCBuYW1lIGNvbnNpc3Rpbmcgb2YgdGhlIG5hbWVzcGFjZSBhbmQgdGhlIG5hbWUgb2YgdGhlIGljb24uXG4gICAqIElmIHRoZSBuYW1lc3BhY2UgaXMgbWlzc2luZywgdGhlIGRlZmF1bHQgbmFtZXNwYWNlIFwic2JiXCIgd2lsbCBiZSB1c2VkLlxuICAgKiBFLmcuIGBuYW1lYCAod2lsbCB1c2UgXCJzYmJcIiBhcyBuYW1lc3BhY2UpIG9yIGBuYW1lc3BhY2U6bmFtZWAuXG4gICAqL1xuICBAZm9yY2VUeXBlKClcbiAgQHByb3BlcnR5KHsgcmVmbGVjdDogdHJ1ZSwgY29udmVydGVyOiBvbWl0RW1wdHlDb252ZXJ0ZXIgfSlcbiAgcHVibGljIGFjY2Vzc29yIG5hbWU6IHN0cmluZyA9ICcnO1xuXG4gIC8qKlxuICAgKiBUaGUgc2JiLWFuZ3VsYXIgbGlicmFyeSBoYXMgYSBzYmItaWNvbiBjb21wb25lbnQgYXMgd2VsbC4gSW4gb3JkZXIgdG8gcHJvdmlkZVxuICAgKiBjb21wYXRpYmlsaXR5IHdpdGggaXQgKGFzIHNvbWUgaWNvbnMgYXJlIHVzZWQgaW50ZXJuYWxseSBpbnNpZGUgdGhlIG90aGVyIHNiYi1hbmd1bGFyXG4gICAqIGNvbXBvbmVudHMpIHdlIG5lZWQgdG8gY2hlY2sgd2hldGhlciB0aGUgYXR0cmlidXRlIHN2Z2ljb24gaXMgdXNlZC5cbiAgICovXG4gIEBzdGF0ZSgpIHByaXZhdGUgYWNjZXNzb3IgX3NiYkFuZ3VsYXJDb21wYXRpYmlsaXR5ID0gZmFsc2U7XG5cbiAgcHVibGljIG92ZXJyaWRlIGNvbm5lY3RlZENhbGxiYWNrKCk6IHZvaWQge1xuICAgIHN1cGVyLmNvbm5lY3RlZENhbGxiYWNrKCk7XG4gICAgLy8gVE9ETzogTW92ZSB0byBjb25zdHJ1Y3RvclxuICAgIHRoaXMuaW50ZXJuYWxzLmFyaWFIaWRkZW4gPSAndHJ1ZSc7XG4gIH1cblxuICBwcm90ZWN0ZWQgb3ZlcnJpZGUgYXN5bmMgZmV0Y2hTdmdJY29uKG5hbWVzcGFjZTogc3RyaW5nLCBuYW1lOiBzdHJpbmcpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIHRoaXMuaW50ZXJuYWxzLmFyaWFMYWJlbCA9IGBJY29uICR7bmFtZS5yZXBsYWNlKC8tL2csICcgJyl9YDtcbiAgICByZXR1cm4gc3VwZXIuZmV0Y2hTdmdJY29uKG5hbWVzcGFjZSwgbmFtZSk7XG4gIH1cblxuICBwcm90ZWN0ZWQgb3ZlcnJpZGUgd2lsbFVwZGF0ZShjaGFuZ2VkUHJvcGVydGllczogUHJvcGVydHlWYWx1ZXM8dGhpcz4pOiB2b2lkIHtcbiAgICBzdXBlci53aWxsVXBkYXRlKGNoYW5nZWRQcm9wZXJ0aWVzKTtcblxuICAgIGlmIChjaGFuZ2VkUHJvcGVydGllcy5oYXMoJ25hbWUnKSAmJiB0aGlzLm5hbWUpIHtcbiAgICAgIHRoaXMubG9hZFN2Z0ljb24odGhpcy5uYW1lKTtcbiAgICB9XG4gIH1cblxuICBwdWJsaWMgb3ZlcnJpZGUgYXR0cmlidXRlQ2hhbmdlZENhbGxiYWNrKFxuICAgIG5hbWU6IHN0cmluZyxcbiAgICBfb2xkOiBzdHJpbmcgfCBudWxsLFxuICAgIHZhbHVlOiBzdHJpbmcgfCBudWxsLFxuICApOiB2b2lkIHtcbiAgICBpZiAobmFtZSA9PT0gJ3N2Z2ljb24nKSB7XG4gICAgICB0aGlzLl9zYmJBbmd1bGFyQ29tcGF0aWJpbGl0eSA9ICEhdmFsdWU7XG4gICAgfSBlbHNlIHtcbiAgICAgIHN1cGVyLmF0dHJpYnV0ZUNoYW5nZWRDYWxsYmFjayhuYW1lLCBfb2xkLCB2YWx1ZSk7XG4gICAgfVxuICB9XG5cbiAgcHJvdGVjdGVkIG92ZXJyaWRlIHJlbmRlcigpOiBUZW1wbGF0ZVJlc3VsdCB7XG4gICAgcmV0dXJuIHRoaXMuX3NiYkFuZ3VsYXJDb21wYXRpYmlsaXR5ID8gaHRtbGA8c2xvdD48L3Nsb3Q+YCA6IHN1cGVyLnJlbmRlcigpO1xuICB9XG59XG5cbmRlY2xhcmUgZ2xvYmFsIHtcbiAgaW50ZXJmYWNlIEhUTUxFbGVtZW50VGFnTmFtZU1hcCB7XG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uYW1pbmctY29udmVudGlvblxuICAgICdzYmItaWNvbic6IFNiYkljb25FbGVtZW50O1xuICB9XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztJQVVhLHdCQUFjO21CQUFTOzs7Ozs7O2NBQXZCLHVCQUF1QixZQUFXOzs7dUJBZ0I1QyxXQUFXLEVBQ1gsU0FBUztJQUFFLFNBQVM7SUFBTSxXQUFXO0lBQW9CLENBQUMsQ0FBQTsyQ0FRMUQsT0FBTyxDQUFBO0dBUFIsYUFBQSxNQUFBLE1BQUEsa0JBQUE7SUFBQSxNQUFBO0lBQUEsTUFBQTtJQUFBLFFBQUE7SUFBQSxTQUFBO0lBQUEsUUFBQTtLQUFBLE1BQUEsUUFBQSxVQUFBO0tBQUEsTUFBQSxRQUFBLElBQWdCO0tBQUksTUFBQSxLQUFBLFVBQUE7TUFBQSxJQUFKLE9BQUk7O0tBQUE7SUFBQSxVQUFBO0lBQUEsRUFBQSxvQkFBQSx3QkFBQTtHQU9YLGFBQUEsTUFBQSxNQUFBLHNDQUFBO0lBQUEsTUFBQTtJQUFBLE1BQUE7SUFBQSxRQUFBO0lBQUEsU0FBQTtJQUFBLFFBQUE7S0FBQSxNQUFBLFFBQUEsOEJBQUE7S0FBQSxNQUFBLFFBQUEsSUFBaUI7S0FBd0IsTUFBQSxLQUFBLFVBQUE7TUFBQSxJQUF4QiwyQkFBd0I7O0tBQUE7SUFBQSxVQUFBO0lBQUEsRUFBQSx3Q0FBQSw0Q0FBQTs7Ozs7Ozs7O0dBeEJsQixLQUFBLGNBQXNCOzs7Ozs7O0VBTS9DLFdBQW9CLHFCQUFrQjtHQUMzQyxPQUFPLE1BQU0sbUJBQW1CLE9BQU8sVUFBVTs7RUFVbkQseUJBQUEsa0JBQUEsTUFBQSxvQkFBK0IsR0FBRTs7Ozs7O0VBQWpDLElBQWdCLE9BQUk7R0FBQSxPQUFBLEtBQUE7O0VBQXBCLElBQWdCLEtBQUksT0FBQTtHQUFBLEtBQUEseUJBQUE7O0VBT1gsOENBQUEsa0JBQUEsTUFBQSx3QkFBQSxFQUFBLGtCQUFBLE1BQUEsd0NBQTRDLE1BQUs7Ozs7OztFQUFqRCxJQUFpQiwyQkFBd0I7R0FBQSxPQUFBLEtBQUE7O0VBQXpDLElBQWlCLHlCQUF3QixPQUFBO0dBQUEsS0FBQSw2Q0FBQTs7RUFFbEMsb0JBQWlCO0dBQy9CLE1BQU0sbUJBQW1CO0dBRXpCLEtBQUssVUFBVSxhQUFhOztFQUdYLE1BQU0sYUFBYSxXQUFtQixNQUFZO0dBQ25FLEtBQUssVUFBVSxZQUFZLFFBQVEsS0FBSyxRQUFRLE1BQU0sSUFBSTtHQUMxRCxPQUFPLE1BQU0sYUFBYSxXQUFXLEtBQUs7O0VBR3pCLFdBQVcsbUJBQXVDO0dBQ25FLE1BQU0sV0FBVyxrQkFBa0I7R0FFbkMsSUFBSSxrQkFBa0IsSUFBSSxPQUFPLElBQUksS0FBSyxNQUN4QyxLQUFLLFlBQVksS0FBSyxLQUFLOztFQUlmLHlCQUNkLE1BQ0EsTUFDQSxPQUFvQjtHQUVwQixJQUFJLFNBQVMsV0FDWCxLQUFLLDJCQUEyQixDQUFDLENBQUM7UUFFbEMsTUFBTSx5QkFBeUIsTUFBTSxNQUFNLE1BQU07O0VBSWxDLFNBQU07R0FDdkIsT0FBTyxLQUFLLDJCQUEyQixJQUFJLGtCQUFrQixNQUFNLFFBQVEifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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