@sbb-esta/lyne-elements-dev 4.13.1-dev.1781017607 → 5.0.0-dev.1781076451

package/development/element-BS28ba7w.js

@@ -0,0 +1,394 @@
+import { LitElement, isServer, unsafeCSS } from "lit";
+//#region src/elements/core/base-elements/element.scss?inline
+var element_default = "*,\n::before,\n::after {\n  box-sizing: border-box;\n}";
+//#endregion
+//#region src/elements/core/base-elements/element.ts
+var CustomStateSetPolyfill = isServer || !CSS.supports("selector(:state(loading))") ? class CustomStateSet extends Set {
+	constructor(_host) {
+		super();
+		this._host = _host;
+		this._applied = isServer;
+		this._host.addController(this);
+		if (!isServer) Promise.resolve().then(() => this._applyStates());
+	}
+	add(state) {
+		if (this._applied) this._toggleState(state, true);
+		return super.add(state);
+	}
+	delete(state) {
+		this._toggleState(state, false);
+		return super.delete(state);
+	}
+	clear() {
+		this.forEach((state) => this.delete(state));
+	}
+	hostConnected() {
+		this._applyStates();
+	}
+	_toggleState(state, enabled) {
+		this._host.toggleAttribute(`state--${state}`, enabled);
+	}
+	_applyStates() {
+		if (this._applied) return;
+		this._applied = true;
+		this.forEach((state) => this._toggleState(state, true));
+	}
+} : null;
+if (!isServer) {
+	let nextId = 0;
+	const resolveHost = (origin) => origin.shadowRoot?.host ?? (origin instanceof Element ? origin : (() => {
+		throw new Error("Unable to resolve related element! This should never happen.");
+	})());
+	const observerOptions = {
+		attributes: true,
+		attributeFilter: ["id"]
+	};
+	const assignElement = (host, attribute, elements) => {
+		const activeElement = elements[Element.name] ?? elements[ElementInternals.name];
+		host.setAttribute(attribute, activeElement.id ||= `aria-ref-${nextId++}`);
+	};
+	const assignElements = (host, attribute, elements) => {
+		host.setAttribute(attribute, Object.values(elements).reduce((current, next) => current.concat(next)).filter((v, i, a) => a.indexOf(v) === i).map((e) => e.id || (e.id = `aria-ref-${nextId++}`)).join(" "));
+	};
+	for (const type of [ElementInternals, Element]) {
+		const prototype = type.prototype;
+		if (!("ariaActiveDescendantElement" in prototype)) {
+			const attribute = "aria-activedescendant";
+			const storage = /* @__PURE__ */ new WeakMap();
+			Object.defineProperty(prototype, "ariaActiveDescendantElement", {
+				enumerable: true,
+				configurable: true,
+				get() {
+					const host = resolveHost(this);
+					const id = host.getAttribute(attribute)?.split(/\s+/)[0] ?? null;
+					return id ? host.getRootNode().getElementById?.(id) ?? null : null;
+				},
+				set(value) {
+					if (value !== null && !(value instanceof Element)) throw new TypeError(`Failed to set the 'ariaActiveDescendantElement' property on '${type.name}': Failed to convert value to 'Element'.`);
+					const host = resolveHost(this);
+					const entry = storage.get(host);
+					entry?.observer?.disconnect();
+					if (value === null) {
+						if (entry) {
+							delete entry.elements[type.name];
+							if (!Object.keys(entry).length) {
+								storage.delete(host);
+								host.removeAttribute(attribute);
+							} else entry.observer.observe(Object.values(entry.elements)[0], observerOptions);
+						}
+					} else if (!entry) {
+						const elements = { [type.name]: value };
+						assignElement(host, attribute, elements);
+						const observer = new MutationObserver(() => assignElement(host, attribute, elements));
+						observer.observe(value, observerOptions);
+						storage.set(host, {
+							elements,
+							observer
+						});
+					} else {
+						entry.elements[type.name] = value;
+						assignElement(host, attribute, entry.elements);
+						Object.values(entry.elements).forEach((e) => entry.observer.observe(e, observerOptions));
+					}
+				}
+			});
+		}
+		for (const property of [
+			"ariaControlsElements",
+			"ariaDescribedByElements",
+			"ariaDetailsElements",
+			"ariaErrorMessageElements",
+			"ariaLabelledByElements",
+			"ariaOwnsElements"
+		]) if (!(property in prototype)) {
+			const storage = /* @__PURE__ */ new WeakMap();
+			const attribute = `aria-${property.slice(4, -8).toLowerCase()}`;
+			Object.defineProperty(prototype, property, {
+				enumerable: true,
+				configurable: true,
+				get() {
+					const host = resolveHost(this);
+					const elements = host.getAttribute(attribute)?.split(/\s+/).filter((v, i, a) => a.indexOf(v) === i).map((id) => host.getRootNode().getElementById?.(id)).filter((e) => e instanceof Element);
+					return elements?.length ? Object.freeze(elements) : null;
+				},
+				set(value) {
+					if (value !== null && (!Array.isArray(value) || value.some((element) => !(element instanceof Element)))) throw new TypeError(`Failed to set the '${property}' property on '${type.name}': Failed to convert value to 'Element'.`);
+					const host = resolveHost(this);
+					value = value?.filter((v, i, a) => a.indexOf(v) === i) ?? null;
+					const entry = storage.get(host);
+					entry?.observer?.disconnect();
+					if (value === null) {
+						if (entry) {
+							delete entry.elements[type.name];
+							if (!Object.keys(entry.elements).length) storage.delete(host);
+							else Object.values(entry.elements).reduce((current, next) => current.concat(next)).forEach((e) => entry.observer.observe(e, observerOptions));
+						}
+					} else if (!entry) {
+						const elements = { [type.name]: value };
+						assignElements(host, attribute, elements);
+						const observer = new MutationObserver(() => assignElements(host, attribute, elements));
+						value.forEach((element) => observer.observe(element, observerOptions));
+						storage.set(host, {
+							elements,
+							observer
+						});
+					} else {
+						entry.elements[type.name] = value;
+						assignElements(host, attribute, entry.elements);
+						Object.values(entry.elements).reduce((current, next) => current.concat(next)).forEach((e) => entry.observer.observe(e, observerOptions));
+					}
+				}
+			});
+		}
+	}
+}
+var attachedElementInternals = /* @__PURE__ */ new WeakMap();
+function ɵstateController(element) {
+	if (!element) return null;
+	const states = attachedElementInternals.get(element)?.states;
+	const toggle = function(value, force) {
+		if (force || force !== false && !this.has(value)) this.add(value);
+		else this.delete(value);
+	};
+	if (states) return {
+		add(value) {
+			states.add(value);
+			return this;
+		},
+		delete: (value) => states.delete(value),
+		has: (value) => states.has(value),
+		toggle
+	};
+	else return {
+		add(value) {
+			element.toggleAttribute(`state--${value}`, true);
+			return this;
+		},
+		delete: (value) => element.toggleAttribute(`state--${value}`, false),
+		has: (value) => element.hasAttribute(`state--${value}`),
+		toggle
+	};
+}
+var SbbSlottedChangeEvent = class extends Event {
+	constructor(slot) {
+		super("slottedchange", { composed: true });
+		this.slot = slot;
+	}
+};
+/**
+* Appends the given elements to the given aria value and returns the
+* combined value as a new array or null, if both values were empty.
+*/
+var appendAriaElements = (ariaValue, ...newElements) => {
+	const elements = newElements.filter((v) => !!v);
+	return ariaValue?.length ? ariaValue.concat(elements) : newElements.length ? elements : null;
+};
+/**
+* Removes the given elements from the given aria value and returns
+* the remaining elements as a new array or null, if the result is empty.
+*/
+var removeAriaElements = (ariaValue, ...removableElements) => {
+	removableElements = removableElements.filter((v) => !!v);
+	const elements = ariaValue?.filter((v) => !removableElements.includes(v)) ?? null;
+	return elements?.length ? elements : null;
+};
+/**
+* A base class for all SBB elements.
+* Includes attaching ElementInternals, handling hydration, and managing state.
+*/
+var SbbElement = class extends LitElement {
+	static {
+		this["_$sbbElement$"] = true;
+	}
+	static {
+		this.styles = [unsafeCSS(element_default)];
+	}
+	/**
+	* Returns a Promise that resolves when the element has completed hydration.
+	* The Promise value is a boolean that is `true` if the element required hydration
+	* and `false` if not.
+	*
+	* @return A promise of a boolean that resolves to true once the hydration completed.
+	* @internal
+	*/
+	get hydrationComplete() {
+		return this._hydrationComplete;
+	}
+	/** Returns whether hydration is required and not completed. */
+	get hydrationRequired() {
+		return this._hydrationRequired;
+	}
+	constructor() {
+		super();
+		/** @internal */
+		this.internals = this.attachInternals();
+		this._hydrationComplete = new Promise((resolve) => this._resolveHydration = resolve);
+		attachedElementInternals.set(this, this.internals);
+		if (CustomStateSetPolyfill) Object.defineProperty(this.internals, "states", {
+			value: new CustomStateSetPolyfill(this),
+			writable: false,
+			configurable: false,
+			enumerable: false
+		});
+		else for (const name of this.getAttributeNames().filter((n) => n.startsWith("state--"))) {
+			this.internals.states.add(name.slice(7));
+			this.removeAttribute(name);
+		}
+		const role = this.constructor.role;
+		if (role) this.internals.role = role;
+		this._hydrationRequired = !!this.shadowRoot;
+		if (!this._hydrationRequired) this._resolveHydration(false);
+		else {
+			const suppressSlotchangeEvent = (event) => {
+				if (this._hydrationRequired) event.stopImmediatePropagation();
+			};
+			const eventOptions = { capture: true };
+			const slots = this.shadowRoot?.querySelectorAll("slot");
+			if (slots?.length) {
+				slots.forEach((slot) => slot.addEventListener("slotchange", suppressSlotchangeEvent, eventOptions));
+				this.hydrationComplete.then(() => slots.forEach((slot) => {
+					slot.removeEventListener("slotchange", suppressSlotchangeEvent, eventOptions);
+					if (slot.assignedNodes().length)
+ /** @internal */
+					slot.dispatchEvent(new Event("slotchange", { bubbles: true }));
+				}));
+			}
+		}
+	}
+	/** Register the custom element in the global CustomElementRegistry. */
+	static define() {
+		if (!this.elementName) throw new Error(`The static property "elementName" is not defined on ${this.name}. Please define it to register the custom element.`);
+		if (!customElements.get(this.elementName)) {
+			customElements.define(this.elementName, this);
+			const elementDependencies = [];
+			let ctor = this;
+			while (ctor["_$sbbElement$"]) {
+				if (Array.isArray(ctor.elementDependencies)) elementDependencies.push(...ctor.elementDependencies);
+				ctor = Object.getPrototypeOf(ctor);
+			}
+			new Set(elementDependencies).forEach((dependency) => dependency.define());
+		}
+	}
+	/**
+	* Collects `styles` from every class in the prototype chain (using `Object.hasOwn`)
+	* and merges them in top-down order. This means each class/mixin only needs to declare
+	* its **own** styles — there is no need to reference `super.styles`.
+	*
+	* Lit's default behaviour already walks the chain, but fails for mixins where
+	* `super.styles` resolves to the wrong class. This override fixes that.
+	*/
+	static finalizeStyles(_styles) {
+		const collected = [];
+		let ctor = this;
+		while (ctor && ctor !== LitElement) {
+			if (Object.hasOwn(ctor, "styles") && ctor.styles) collected.unshift(ctor.styles);
+			ctor = Object.getPrototypeOf(ctor);
+		}
+		return super.finalizeStyles(collected);
+	}
+	createRenderRoot() {
+		const root = super.createRenderRoot();
+		this.shadowRoot?.addEventListener("slotchange", (e) => this._slotchangeHandler(e, e.target));
+		this.shadowRoot?.addEventListener("slottedchange", (e) => this._slotchangeHandler(e, e.slot), { capture: true });
+		this.shadowRoot?.querySelectorAll?.("slot").forEach((slot) => this._handleSlotChangeForSlottedState(slot));
+		return root;
+	}
+	/**
+	* Registers a `ReactiveController` to participate in the element's reactive
+	* update cycle. The element automatically calls into any registered
+	* controllers during its lifecycle callbacks.
+	*
+	* If the element is connected when `addController()` is called, the
+	* controller's `hostConnected()` callback will be immediately called.
+	*/
+	addController(controller) {
+		super.addController(controller);
+		(this._controllers ??= /* @__PURE__ */ new Set()).add(controller);
+	}
+	/**
+	* Removes a `ReactiveController` from the element.
+	*/
+	removeController(controller) {
+		super.removeController(controller);
+		this._controllers?.delete(controller);
+	}
+	/**
+	* Requests an update which is processed asynchronously. This should be called
+	* when an element should update based on some state not triggered by setting
+	* a reactive property. In this case, pass no arguments. It should also be
+	* called when manually implementing a property setter. In this case, pass the
+	* property `name` and `oldValue` to ensure that any configured property
+	* options are honored.
+	*
+	* @param name name of requesting property
+	* @param oldValue old value of requesting property
+	* @param options property options to use instead of the previously
+	*     configured options
+	* @param useNewValue if true, the newValue argument is used instead of
+	*     reading the property value. This is important to use if the reactive
+	*     property is a standard private accessor, as opposed to a plain
+	*     property, since private members can't be dynamically read by name.
+	* @param newValue the new value of the property. This is only used if
+	*     `useNewValue` is true.
+	*/
+	requestUpdate(name, oldValue, options, useNewValue, newValue) {
+		super.requestUpdate(name, oldValue, options, useNewValue, newValue);
+		if (name) {
+			const values = {
+				oldValue,
+				value: useNewValue ? newValue : this[name]
+			};
+			this._controllers?.forEach((controller) => controller.hostPropertyUpdate?.(name, values, options));
+		}
+	}
+	update(changedProperties) {
+		super.update(changedProperties);
+		if (this._hydrationRequired) {
+			this._hydrationRequired = false;
+			this._resolveHydration(true);
+		}
+	}
+	toggleState(value, force) {
+		if (force || force !== false && !this.internals.states.has(value)) this.internals.states.add(value);
+		else this.internals.states.delete(value);
+	}
+	_slotchangeHandler(event, slot) {
+		const resolvedSlot = this.shadowRoot.contains(slot) ? slot : event.composedPath().find((el) => el instanceof HTMLSlotElement && this.shadowRoot.contains(el));
+		if (resolvedSlot) this._handleSlotChangeForSlottedState(resolvedSlot);
+	}
+	_handleSlotChangeForSlottedState(slot) {
+		this._updateSlottedState(slot);
+		if (!slot.name) this._observeTextNodesInSlot(slot);
+	}
+	_updateSlottedState(slot) {
+		const stateName = slot.name ? `slotted-${slot.name}` : "slotted";
+		const hasSlottedContent = this._hasSlottedContent(slot);
+		if (hasSlottedContent && !this.internals.states.has(stateName)) {
+			this.internals.states.add(stateName);
+			/** @internal */
+			this.dispatchEvent(new SbbSlottedChangeEvent(slot));
+		} else if (!hasSlottedContent && this.internals.states.has(stateName)) {
+			this.internals.states.delete(stateName);
+			/** @internal */
+			this.dispatchEvent(new SbbSlottedChangeEvent(slot));
+		}
+	}
+	_observeTextNodesInSlot(slot) {
+		this._textObserver?.disconnect();
+		this._textObserver ??= new MutationObserver(() => {
+			const slot = this.shadowRoot.querySelector("slot:not([name])");
+			if (slot) this._updateSlottedState(slot);
+			else this._textObserver.disconnect();
+		});
+		slot.assignedNodes().filter((n) => n.nodeType === n.TEXT_NODE).forEach((node) => this._textObserver.observe(node, { characterData: true }));
+	}
+	_hasSlottedContent(slot) {
+		return slot.name ? slot.assignedElements().some((node) => !(node instanceof HTMLSlotElement) || this._hasSlottedContent(node)) : slot.assignedNodes().some((node) => {
+			return node instanceof HTMLSlotElement ? this._hasSlottedContent(node) : node.nodeType !== node.TEXT_NODE || !!node.textContent?.trim();
+		});
+	}
+};
+//#endregion
+export { ɵstateController as a, removeAriaElements as i, SbbSlottedChangeEvent as n, appendAriaElements as r, SbbElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"element-BS28ba7w.js","names":[],"sources":["../../../src/elements/core/base-elements/element.scss?inline","../../../src/elements/core/base-elements/element.ts"],"sourcesContent":["@use '../styles/mixins/helpers';\n\n@include helpers.box-sizing;\n","import {\n  type CSSResultGroup,\n  type CSSResultOrNative,\n  isServer,\n  LitElement,\n  type PropertyDeclaration,\n  type PropertyValues,\n  type ReactiveController,\n  unsafeCSS,\n} from 'lit';\n\nimport style from './element.scss?inline';\n\n// Most of our target browsers support the :state() pseudo class, but not all of them.\n// We patch the states property of the element internals to use attributes instead,\n// if :state() is not supported.\n// Note that for SSR, the states property is a simple Set, implemented in Lit SSR.\ntype CustomStateSetInterface = CustomStateSet;\n// eslint-disable-next-line @typescript-eslint/naming-convention\nconst CustomStateSetPolyfill: (new (host: LitElement) => CustomStateSetInterface) | null =\n  isServer || !CSS.supports('selector(:state(loading))')\n    ? class CustomStateSet\n        extends Set<string>\n        implements CustomStateSetInterface, ReactiveController\n      {\n        private _applied = isServer;\n\n        public constructor(private _host: LitElement) {\n          super();\n          this._host.addController(this);\n          if (!isServer) {\n            // We want to apply the attributes as early as possible which can\n            // either be via this Promise.resolve() or the connectedCallback().\n            Promise.resolve().then(() => this._applyStates());\n          }\n        }\n\n        public override add(state: string): this {\n          if (this._applied) {\n            this._toggleState(state, true);\n          }\n          return super.add(state);\n        }\n\n        public override delete(state: string): boolean {\n          this._toggleState(state, false);\n          return super.delete(state);\n        }\n\n        public override clear(): void {\n          this.forEach((state) => this.delete(state));\n        }\n\n        public hostConnected(): void {\n          this._applyStates();\n        }\n\n        private _toggleState(state: string, enabled: boolean): void {\n          this._host.toggleAttribute(`state--${state}`, enabled);\n        }\n\n        private _applyStates(): void {\n          if (this._applied) {\n            return;\n          }\n          this._applied = true;\n          this.forEach((state) => this._toggleState(state, true));\n        }\n      }\n    : null;\n\nif (!isServer) {\n  // This is a polyfill for the aria elements properties on ElementInternals and Element.\n  let nextId = 0;\n  const resolveHost = (origin: ElementInternals | Element): Element =>\n    origin.shadowRoot?.host ??\n    (origin instanceof Element\n      ? origin\n      : (() => {\n          throw new Error('Unable to resolve related element! This should never happen.');\n        })());\n  const observerOptions: MutationObserverInit = { attributes: true, attributeFilter: ['id'] };\n  const assignElement = (\n    host: Element,\n    attribute: string,\n    elements: Record<string, Element>,\n  ): void => {\n    // In case both Element and ElementInternals properties are set,\n    // the element reference from Element has priority.\n    const activeElement = elements[Element.name] ?? elements[ElementInternals.name];\n    host.setAttribute(attribute, (activeElement.id ||= `aria-ref-${nextId++}`));\n  };\n  const assignElements = (\n    host: Element,\n    attribute: string,\n    elements: Record<string, Element[]>,\n  ): void => {\n    // In case both Element and ElementInternals properties are set,\n    // we combine the element references.\n    host.setAttribute(\n      attribute,\n      Object.values(elements)\n        .reduce((current, next) => current.concat(next))\n        .filter((v, i, a) => a.indexOf(v) === i)\n        .map((e) => e.id || (e.id = `aria-ref-${nextId++}`))\n        .join(' '),\n    );\n  };\n\n  for (const type of [ElementInternals, Element]) {\n    const prototype = type.prototype;\n    if (!('ariaActiveDescendantElement' in prototype)) {\n      const attribute = 'aria-activedescendant';\n      const storage = new WeakMap<\n        Element,\n        { elements: Record<string, Element>; observer: MutationObserver }\n      >();\n      Object.defineProperty(prototype, 'ariaActiveDescendantElement', {\n        enumerable: true,\n        configurable: true,\n        get(this: ElementInternals | Element): Element | null {\n          const host = resolveHost(this);\n          const id = host.getAttribute(attribute)?.split(/\\s+/)[0] ?? null;\n          return id\n            ? ((host.getRootNode() as Document | ShadowRoot).getElementById?.(id) ?? null)\n            : null;\n        },\n        set(this: ElementInternals | Element, value: Element | null) {\n          if (value !== null && !(value instanceof Element)) {\n            throw new TypeError(\n              `Failed to set the 'ariaActiveDescendantElement' property on '${type.name}': Failed to convert value to 'Element'.`,\n            );\n          }\n\n          const host = resolveHost(this);\n          const entry = storage.get(host);\n          entry?.observer?.disconnect();\n          if (value === null) {\n            if (entry) {\n              delete entry.elements[type.name];\n              if (!Object.keys(entry).length) {\n                storage.delete(host);\n                host.removeAttribute(attribute);\n              } else {\n                entry.observer.observe(Object.values(entry.elements)[0], observerOptions);\n              }\n            }\n          } else if (!entry) {\n            const elements: Record<string, Element> = { [type.name]: value };\n            assignElement(host, attribute, elements);\n            const observer = new MutationObserver(() => assignElement(host, attribute, elements));\n            observer.observe(value, observerOptions);\n            storage.set(host, { elements, observer });\n          } else {\n            entry.elements[type.name] = value;\n            assignElement(host, attribute, entry.elements);\n            Object.values(entry.elements).forEach((e) =>\n              entry.observer.observe(e, observerOptions),\n            );\n          }\n        },\n      });\n    }\n\n    for (const property of [\n      'ariaControlsElements',\n      'ariaDescribedByElements',\n      'ariaDetailsElements',\n      'ariaErrorMessageElements',\n      'ariaLabelledByElements',\n      'ariaOwnsElements',\n    ]) {\n      if (!(property in prototype)) {\n        const storage = new WeakMap<\n          Element,\n          { elements: Record<string, Element[]>; observer: MutationObserver }\n        >();\n        const attribute = `aria-${property.slice(4, -8).toLowerCase()}`;\n        Object.defineProperty(prototype, property, {\n          enumerable: true,\n          configurable: true,\n          get(this: ElementInternals | Element): readonly Element[] | null {\n            const host = resolveHost(this);\n            const elements = host\n              .getAttribute(attribute)\n              ?.split(/\\s+/)\n              .filter((v, i, a) => a.indexOf(v) === i)\n              .map((id) => (host.getRootNode() as Document | ShadowRoot).getElementById?.(id))\n              .filter((e) => e instanceof Element);\n            return elements?.length ? Object.freeze(elements) : null;\n          },\n          set(this: ElementInternals | Element, value: Element[]) {\n            if (\n              value !== null &&\n              (!Array.isArray(value) || value.some((element) => !(element instanceof Element)))\n            ) {\n              throw new TypeError(\n                `Failed to set the '${property}' property on '${type.name}': Failed to convert value to 'Element'.`,\n              );\n            }\n\n            const host = resolveHost(this);\n            value = value?.filter((v, i, a) => a.indexOf(v) === i) ?? null;\n            const entry = storage.get(host);\n            entry?.observer?.disconnect();\n            if (value === null) {\n              if (entry) {\n                delete entry.elements[type.name];\n                if (!Object.keys(entry.elements).length) {\n                  storage.delete(host);\n                } else {\n                  Object.values(entry.elements)\n                    .reduce((current, next) => current.concat(next))\n                    .forEach((e) => entry.observer.observe(e, observerOptions));\n                }\n              }\n            } else if (!entry) {\n              const elements: Record<string, Element[]> = { [type.name]: value };\n              assignElements(host, attribute, elements);\n              const observer = new MutationObserver(() =>\n                assignElements(host, attribute, elements),\n              );\n              value.forEach((element) => observer.observe(element, observerOptions));\n              storage.set(host, { elements, observer });\n            } else {\n              entry.elements[type.name] = value;\n              assignElements(host, attribute, entry.elements);\n              Object.values(entry.elements)\n                .reduce((current, next) => current.concat(next))\n                .forEach((e) => entry.observer.observe(e, observerOptions));\n            }\n          },\n        });\n      }\n    }\n  }\n}\n\nconst attachedElementInternals = new WeakMap<Element, ElementInternals>();\n\nexport interface SbbStateController {\n  add(value: string): this;\n  delete(value: string): boolean;\n  has(value: string): boolean;\n  toggle(value: string, force?: boolean): void;\n}\n\n/**\n * Creates a state controller for the given element.\n * NOT INTENDED TO BE USED BY CONSUMERS!\n * @internal\n */\nexport function ɵstateController(element: Element): SbbStateController;\nexport function ɵstateController(element: Element | undefined | null): SbbStateController | null;\nexport function ɵstateController(element: Element | undefined | null): SbbStateController | null {\n  if (!element) {\n    return null;\n  }\n  const states = attachedElementInternals.get(element)?.states;\n  const toggle: SbbStateController['toggle'] = function (this: SbbStateController, value, force) {\n    if (force || (force !== false && !this.has(value))) {\n      this.add(value);\n    } else {\n      this.delete(value);\n    }\n  };\n  if (states) {\n    return {\n      add(value) {\n        states.add(value);\n        return this;\n      },\n      delete: (value) => states.delete(value),\n      has: (value) => states.has(value),\n      toggle,\n    };\n  } else {\n    // If no ElementInternals is attached, we fall back to using attributes. E.g. for triggers.\n    return {\n      add(value) {\n        element.toggleAttribute(`state--${value}`, true);\n        return this;\n      },\n      delete: (value) => element.toggleAttribute(`state--${value}`, false),\n      has: (value) => element.hasAttribute(`state--${value}`),\n      toggle,\n    };\n  }\n}\n\nexport class SbbSlottedChangeEvent extends Event {\n  public constructor(public readonly slot: HTMLSlotElement) {\n    super('slottedchange', { composed: true });\n  }\n}\n\nexport interface SbbPropertyValues {\n  oldValue?: unknown;\n  value?: unknown;\n}\n\nexport interface SbbReactiveController extends ReactiveController {\n  hostPropertyUpdate?(\n    name: PropertyKey,\n    values?: SbbPropertyValues,\n    options?: PropertyDeclaration,\n  ): void;\n}\n\n/**\n * Appends the given elements to the given aria value and returns the\n * combined value as a new array or null, if both values were empty.\n */\nexport const appendAriaElements = (\n  ariaValue: readonly Element[] | null,\n  ...newElements: (Element | null)[]\n): Element[] | null => {\n  const elements = newElements.filter((v): v is Element => !!v);\n  return ariaValue?.length ? ariaValue.concat(elements) : newElements.length ? elements : null;\n};\n\n/**\n * Removes the given elements from the given aria value and returns\n * the remaining elements as a new array or null, if the result is empty.\n */\nexport const removeAriaElements = (\n  ariaValue: readonly Element[] | null,\n  ...removableElements: (Element | null)[]\n): Element[] | null => {\n  removableElements = removableElements.filter((v) => !!v);\n  const elements = ariaValue?.filter((v) => !removableElements.includes(v)) ?? null;\n  return elements?.length ? elements : null;\n};\n\nexport type SbbElementType = typeof SbbElement;\n\nexport interface SbbElementConstructor {\n  elementDependencies?: SbbElementType[];\n  role?: ElementInternals['role'];\n}\n\n/**\n * A base class for all SBB elements.\n * Includes attaching ElementInternals, handling hydration, and managing state.\n */\nexport class SbbElement extends LitElement {\n  public static ['_$sbbElement$'] = true;\n  public static readonly elementName: string;\n  public static elementDependencies?: SbbElementType[];\n  public static role?: ElementInternals['role'];\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n\n  /** @internal */\n  protected readonly internals: ElementInternals = this.attachInternals();\n\n  private _controllers?: Set<SbbReactiveController>;\n  private _hydrationRequired: boolean;\n  private _hydrationComplete = new Promise<boolean>(\n    (resolve) => (this._resolveHydration = resolve),\n  );\n  private _resolveHydration!: (hydrationRequired: boolean) => void;\n  private _textObserver?: MutationObserver;\n\n  /**\n   * Returns a Promise that resolves when the element has completed hydration.\n   * The Promise value is a boolean that is `true` if the element required hydration\n   * and `false` if not.\n   *\n   * @return A promise of a boolean that resolves to true once the hydration completed.\n   * @internal\n   */\n  public get hydrationComplete(): Promise<boolean> {\n    return this._hydrationComplete;\n  }\n\n  /** Returns whether hydration is required and not completed. */\n  protected get hydrationRequired(): boolean {\n    return this._hydrationRequired;\n  }\n\n  public constructor() {\n    super();\n    attachedElementInternals.set(this, this.internals);\n    if (CustomStateSetPolyfill) {\n      Object.defineProperty(this.internals, 'states', {\n        value: new CustomStateSetPolyfill(this),\n        writable: false,\n        configurable: false,\n        enumerable: false,\n      });\n    } else {\n      // We use the CustomStateSet polyfill in SSR, which renders the state as attributes\n      // which can be transferred to client side, where we can then convert [state--*]\n      // attributes to internal state.\n      for (const name of this.getAttributeNames().filter((n) => n.startsWith('state--'))) {\n        this.internals.states.add(name.slice(7));\n        this.removeAttribute(name);\n      }\n    }\n    const role = (this.constructor as SbbElementConstructor).role;\n    if (role) {\n      this.internals.role = role;\n    }\n\n    // Check whether hydration is needed by checking whether the shadow root\n    // is available during construction/upgrade phase.\n    this._hydrationRequired = !!this.shadowRoot;\n    if (!this._hydrationRequired) {\n      this._resolveHydration(false);\n    } else {\n      // During hydration phase, we want to suppress slotchange events as they\n      // can cause render differences, which would break hydration. After\n      // hydration is complete, we dispatch a manual slotchange event, if there\n      // are elements assigned to a slot.\n      const suppressSlotchangeEvent = (event: Event): void => {\n        if (this._hydrationRequired) {\n          event.stopImmediatePropagation();\n        }\n      };\n      const eventOptions: EventListenerOptions = { capture: true };\n      const slots = this.shadowRoot?.querySelectorAll('slot');\n      if (slots?.length) {\n        slots.forEach((slot) =>\n          slot.addEventListener('slotchange', suppressSlotchangeEvent, eventOptions),\n        );\n        this.hydrationComplete.then(() =>\n          slots.forEach((slot) => {\n            slot.removeEventListener('slotchange', suppressSlotchangeEvent, eventOptions);\n            if (slot.assignedNodes().length) {\n              /** @internal */\n              slot.dispatchEvent(new Event('slotchange', { bubbles: true }));\n            }\n          }),\n        );\n      }\n    }\n  }\n\n  /** Register the custom element in the global CustomElementRegistry. */\n  public static define(): void {\n    if (!this.elementName) {\n      throw new Error(\n        `The static property \"elementName\" is not defined on ${this.name}. Please define it to register the custom element.`,\n      );\n    }\n\n    const elementClass = customElements.get(this.elementName);\n    if (!elementClass) {\n      customElements.define(this.elementName, this as unknown as CustomElementConstructor);\n\n      const elementDependencies: SbbElementType[] = [];\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      let ctor: SbbElementType = this;\n      while (ctor['_$sbbElement$']) {\n        if (Array.isArray(ctor.elementDependencies)) {\n          elementDependencies.push(...ctor.elementDependencies);\n        }\n        ctor = Object.getPrototypeOf(ctor);\n      }\n      new Set(elementDependencies).forEach((dependency) => dependency.define());\n    } else if (import.meta.env.DEV && elementClass !== this) {\n      console.warn(\n        `The custom element with name \"${this.elementName}\" is already defined. Skipping.`,\n      );\n    }\n  }\n\n  /**\n   * Collects `styles` from every class in the prototype chain (using `Object.hasOwn`)\n   * and merges them in top-down order. This means each class/mixin only needs to declare\n   * its **own** styles — there is no need to reference `super.styles`.\n   *\n   * Lit's default behaviour already walks the chain, but fails for mixins where\n   * `super.styles` resolves to the wrong class. This override fixes that.\n   */\n  protected static override finalizeStyles(_styles: CSSResultGroup): CSSResultOrNative[] {\n    const collected: CSSResultGroup[] = [];\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    let ctor: typeof SbbElement | null = this;\n    while (ctor && ctor !== LitElement) {\n      if (Object.hasOwn(ctor, 'styles') && ctor.styles) {\n        collected.unshift(ctor.styles);\n      }\n      ctor = Object.getPrototypeOf(ctor) as typeof SbbElement | null;\n    }\n    // Call LitElement.finalizeStyles which handles dedup & adoption\n    return super.finalizeStyles(collected);\n  }\n\n  protected override createRenderRoot(): HTMLElement | DocumentFragment {\n    const root = super.createRenderRoot();\n    this.shadowRoot?.addEventListener('slotchange', (e) =>\n      this._slotchangeHandler(e, e.target as HTMLSlotElement),\n    );\n    this.shadowRoot?.addEventListener('slottedchange', (e) => this._slotchangeHandler(e, e.slot), {\n      capture: true,\n    });\n    this.shadowRoot\n      ?.querySelectorAll?.('slot')\n      .forEach((slot) => this._handleSlotChangeForSlottedState(slot));\n\n    return root;\n  }\n\n  /**\n   * Registers a `ReactiveController` to participate in the element's reactive\n   * update cycle. The element automatically calls into any registered\n   * controllers during its lifecycle callbacks.\n   *\n   * If the element is connected when `addController()` is called, the\n   * controller's `hostConnected()` callback will be immediately called.\n   */\n  public override addController(controller: SbbReactiveController): void {\n    super.addController(controller);\n    (this._controllers ??= new Set()).add(controller);\n  }\n\n  /**\n   * Removes a `ReactiveController` from the element.\n   */\n  public override removeController(controller: SbbReactiveController): void {\n    super.removeController(controller);\n    this._controllers?.delete(controller);\n  }\n\n  /**\n   * Requests an update which is processed asynchronously. This should be called\n   * when an element should update based on some state not triggered by setting\n   * a reactive property. In this case, pass no arguments. It should also be\n   * called when manually implementing a property setter. In this case, pass the\n   * property `name` and `oldValue` to ensure that any configured property\n   * options are honored.\n   *\n   * @param name name of requesting property\n   * @param oldValue old value of requesting property\n   * @param options property options to use instead of the previously\n   *     configured options\n   * @param useNewValue if true, the newValue argument is used instead of\n   *     reading the property value. This is important to use if the reactive\n   *     property is a standard private accessor, as opposed to a plain\n   *     property, since private members can't be dynamically read by name.\n   * @param newValue the new value of the property. This is only used if\n   *     `useNewValue` is true.\n   */\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n    useNewValue?: boolean,\n    newValue?: unknown,\n  ): void {\n    super.requestUpdate(name, oldValue, options, useNewValue, newValue);\n    if (name) {\n      const values: SbbPropertyValues = {\n        oldValue,\n        value: useNewValue ? newValue : this[name as keyof this],\n      };\n      this._controllers?.forEach((controller) =>\n        controller.hostPropertyUpdate?.(name, values, options),\n      );\n    }\n  }\n\n  protected override update(changedProperties: PropertyValues<this>): void {\n    // When hydration is needed, we wait the hydration process to finish, which is patched\n    // into the update method of the LitElement base class.\n    super.update(changedProperties);\n\n    if (this._hydrationRequired) {\n      this._hydrationRequired = false;\n      this._resolveHydration(true);\n    }\n  }\n\n  protected toggleState(value: string, force?: boolean): void {\n    if (force || (force !== false && !this.internals.states.has(value))) {\n      this.internals.states.add(value);\n    } else {\n      this.internals.states.delete(value);\n    }\n  }\n\n  private _slotchangeHandler(event: Event, slot: HTMLSlotElement): void {\n    const resolvedSlot = this.shadowRoot!.contains(slot)\n      ? slot\n      : event\n          .composedPath()\n          .find(\n            (el): el is HTMLSlotElement =>\n              el instanceof HTMLSlotElement && this.shadowRoot!.contains(el),\n          );\n    if (resolvedSlot) {\n      this._handleSlotChangeForSlottedState(resolvedSlot);\n    }\n  }\n\n  private _handleSlotChangeForSlottedState(slot: HTMLSlotElement): void {\n    this._updateSlottedState(slot);\n    if (!slot.name) {\n      this._observeTextNodesInSlot(slot);\n    }\n  }\n\n  private _updateSlottedState(slot: HTMLSlotElement): void {\n    const stateName = slot.name ? `slotted-${slot.name}` : 'slotted';\n    const hasSlottedContent = this._hasSlottedContent(slot);\n    if (hasSlottedContent && !this.internals.states.has(stateName)) {\n      this.internals.states.add(stateName);\n      /** @internal */\n      this.dispatchEvent(new SbbSlottedChangeEvent(slot));\n    } else if (!hasSlottedContent && this.internals.states.has(stateName)) {\n      this.internals.states.delete(stateName);\n      /** @internal */\n      this.dispatchEvent(new SbbSlottedChangeEvent(slot));\n    }\n  }\n\n  private _observeTextNodesInSlot(slot: HTMLSlotElement): void {\n    this._textObserver?.disconnect();\n    // Only create the MutationObserver when it is actually needed to optimize performance.\n    this._textObserver ??= new MutationObserver(() => {\n      const slot = this.shadowRoot!.querySelector<HTMLSlotElement>('slot:not([name])');\n      if (slot) {\n        this._updateSlottedState(slot);\n      } else {\n        this._textObserver!.disconnect();\n      }\n    });\n    // Text nodes can be empty and filled later (or vice versa).\n    // Filling an existing node later would not trigger another slotchange event.\n    // Therefore, we need to observe text nodes and check if they become filled or empty.\n    // This is only needed for the unnamed slot as for every other there would\n    // be a tag which triggers the slot change event.\n    // The main reason is that Angular creates empty text nodes and fills them later.\n    slot\n      .assignedNodes()\n      .filter((n) => n.nodeType === n.TEXT_NODE)\n      .forEach((node) => this._textObserver!.observe(node, { characterData: true }));\n  }\n\n  private _hasSlottedContent(slot: HTMLSlotElement): boolean {\n    return slot.name\n      ? slot\n          .assignedElements()\n          .some((node) => !(node instanceof HTMLSlotElement) || this._hasSlottedContent(node))\n      : slot.assignedNodes().some((node) => {\n          return node instanceof HTMLSlotElement\n            ? this._hasSlottedContent(node)\n            : node.nodeType !== node.TEXT_NODE || !!node.textContent?.trim();\n        });\n  }\n}\n\ndeclare global {\n  interface HTMLElementEventMap {\n    slottedchange: SbbSlottedChangeEvent;\n  }\n  interface ShadowRootEventMap {\n    slottedchange: SbbSlottedChangeEvent;\n  }\n}\n"],"mappings":"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"}

package/development/error.component-Bp7ztvQB.js

@@ -0,0 +1,53 @@
+import { html, unsafeCSS } from "lit";
+import { SbbElement, SbbNegativeMixin } from "./core.js";
+//#region src/elements/form-field/error/error.scss?inline
+var error_default = ":host {\n  --_sbb-error-height: calc(var(--sbb-typo-line-height-text) * 1em);\n  --sbb-icon-svg-width: var(--sbb-error-icon-size);\n  --sbb-icon-svg-height: var(--sbb-error-icon-size);\n  display: flex;\n  align-items: flex-start;\n  color: var(--sbb-error-color);\n  min-height: var(--_sbb-error-height);\n  font-size: var(--sbb-error-font-size);\n  line-height: var(--sbb-typo-line-height-text);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n}\n@media (forced-colors: active) {\n  :host {\n    --sbb-error-color: LinkText !important;\n  }\n}\n\n:host([negative]) {\n  --sbb-error-color: var(--sbb-color-red85);\n}\n\n.error__icon {\n  display: flex;\n  align-items: center;\n  height: var(--_sbb-error-height);\n  margin-inline-end: var(--sbb-spacing-fixed-1x);\n}\n\n.error-content {\n  line-height: var(--sbb-typo-line-height-text);\n  vertical-align: text-top;\n}\n\n.error__icon-svg {\n  stroke: currentcolor;\n  height: var(--_sbb-error-height);\n}";
+//#endregion
+//#region src/elements/form-field/error/error.component.ts
+/**
+* It displays an error message in the `sbb-form-field`.
+*
+* @slot - Use this slot to display the error message.
+* @slot icon - Use this slot to override the default error icon.
+*/
+var SbbErrorElement = class extends SbbNegativeMixin(SbbElement) {
+	static {
+		this.elementName = "sbb-error";
+	}
+	static {
+		this.styles = [unsafeCSS(error_default)];
+	}
+	connectedCallback() {
+		super.connectedCallback();
+		const formField = this.closest?.("sbb-form-field");
+		if (formField) this.negative = formField.hasAttribute("negative");
+	}
+	render() {
+		return html`
+      <span class="error__icon">
+        <slot name="icon">
+          <svg
+            class="error__icon-svg"
+            aria-hidden="true"
+            width="14"
+            height="14"
+            viewBox="0 0 14 14"
+            fill="none"
+            xmlns="http://www.w3.org/2000/svg"
+          >
+            <line x1="7" y1="3" x2="7" y2="8.5" />
+            <line x1="7" y1="10" x2="7" y2="11" />
+            <circle cx="7" cy="7" r="6.5" />
+          </svg>
+        </slot>
+      </span>
+      <span class="error-content">
+        <slot></slot>
+      </span>
+    `;
+	}
+};
+//#endregion
+export { SbbErrorElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/expansion-panel/expansion-panel/expansion-panel.component.d.ts

@@ -1,6 +1,5 @@
 import { CSSResultGroup, TemplateResult } from 'lit';
-import { SbbElement } from '../../core/base-elements.ts';
-import { SbbTitleLevel } from '../../title.ts';
+import { SbbElement, SbbHeadingLevel } from '../../core.ts';
 /**
  * It displays an expandable summary-details widget.
  *
@@ -16,7 +15,7 @@ export declare class SbbExpansionPanelElement extends SbbElement {
         readonly close: "close";
     };
     /** Heading level; if unset, a `div` will be rendered. */
-    accessor titleLevel: SbbTitleLevel | null;
+    accessor titleLevel: SbbHeadingLevel | null;
     /** The background color of the panel. */
     accessor color: 'white' | 'milk';
     /** Whether the panel is expanded. */
@@ -30,10 +29,9 @@ export declare class SbbExpansionPanelElement extends SbbElement {
     /** Whether the panel has no border. */
     accessor borderless: boolean;
     /**
-     * Size variant, either l or s.
-     * @default 'l' / 's' (lean)
+     * Size variant, either s (lean theme default) or l (standard theme default).
      */
-    accessor size: 's' | 'l';
+    accessor size: 's' | 'l' | null;
     /** The state of the component. */
     private set _state(value);
     private get _state();

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

@@ -1 +1 @@
-{"version":3,"file":"expansion-panel.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/expansion-panel/expansion-panel/expansion-panel.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAiB,KAAK,cAAc,EAAa,MAAM,KAAK,CAAC;AAGzF,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAMzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAQpD;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,UAAU;IACtD,gBAAgC,WAAW,EAAE,MAAM,CAAyB;IAC5E,OAAuB,MAAM,EAAE,cAAc,CAAuC;IACpF,gBAAuB,MAAM;;;;;MAKlB;IAEX,yDAAyD;IACzD,SAAwD,UAAU,EAAE,aAAa,GAAG,IAAI,CAAQ;IAEhG,yCAAyC;IACzC,SAA6C,KAAK,EAAE,OAAO,GAAG,MAAM,CAAW;IAE/E,qCAAqC;IACrC,IACW,QAAQ,CAAC,KAAK,EAAE,OAAO,EAGjC;IACD,IAAW,QAAQ,IAAI,OAAO,CAE7B;IACD,OAAO,CAAC,SAAS,CAAkB;IAEnC,6EAA6E;IAC7E,IACW,QAAQ,CAAC,KAAK,EAAE,OAAO,EAGjC;IACD,IAAW,QAAQ,IAAI,OAAO,CAE7B;IACD,OAAO,CAAC,SAAS,CAAkB;IAEnC,uCAAuC;IACvC,SAEgB,UAAU,EAAE,OAAO,CAAS;IAE5C;;;OAGG;IACH,SAA6C,IAAI,EAAE,GAAG,GAAG,GAAG,CAAwB;IAEpF,kCAAkC;IAClC,OAAO,KAAK,MAAM,QAQjB;IACD,OAAO,KAAK,MAAM,GAEjB;IACD,OAAO,CAAC,cAAc,CAAwB;IAE9C,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,UAAU,CAAC,CAAiC;IACpD,OAAO,CAAC,WAAW,CAAC,CAAkC;;IAatC,iBAAiB,IAAI,IAAI;IAKzB,oBAAoB,IAAI,IAAI;IAK5C,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,KAAK;IAYb,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,wBAAwB;IAIhC,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,uBAAuB;IAM/B,OAAO,CAAC,iBAAiB;IAiCzB,OAAO,CAAC,eAAe;cAQJ,MAAM,IAAI,cAAc;CAiB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,qBAAqB,EAAE,wBAAwB,CAAC;KACjD;CACF"}
+{"version":3,"file":"expansion-panel.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/expansion-panel/expansion-panel/expansion-panel.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAiB,KAAK,cAAc,EAAa,MAAM,KAAK,CAAC;AAGzF,OAAO,EAGL,UAAU,EACV,KAAK,eAAe,EAGrB,MAAM,eAAe,CAAC;AAQvB;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,UAAU;IACtD,gBAAgC,WAAW,EAAE,MAAM,CAAyB;IAC5E,OAAuB,MAAM,EAAE,cAAc,CAAsB;IACnE,gBAAuB,MAAM;;;;;MAKlB;IAEX,yDAAyD;IACzD,SAAwD,UAAU,EAAE,eAAe,GAAG,IAAI,CAAQ;IAElG,yCAAyC;IACzC,SAA6C,KAAK,EAAE,OAAO,GAAG,MAAM,CAAW;IAE/E,qCAAqC;IACrC,IACW,QAAQ,CAAC,KAAK,EAAE,OAAO,EAGjC;IACD,IAAW,QAAQ,IAAI,OAAO,CAE7B;IACD,OAAO,CAAC,SAAS,CAAkB;IAEnC,6EAA6E;IAC7E,IACW,QAAQ,CAAC,KAAK,EAAE,OAAO,EAGjC;IACD,IAAW,QAAQ,IAAI,OAAO,CAE7B;IACD,OAAO,CAAC,SAAS,CAAkB;IAEnC,uCAAuC;IACvC,SAEgB,UAAU,EAAE,OAAO,CAAS;IAE5C;;OAEG;IACH,SAA6C,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAQ;IAE3E,kCAAkC;IAClC,OAAO,KAAK,MAAM,QAQjB;IACD,OAAO,KAAK,MAAM,GAEjB;IACD,OAAO,CAAC,cAAc,CAAwB;IAE9C,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,UAAU,CAAC,CAAiC;IACpD,OAAO,CAAC,WAAW,CAAC,CAAkC;;IAatC,iBAAiB,IAAI,IAAI;IAKzB,oBAAoB,IAAI,IAAI;IAK5C,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,KAAK;IAYb,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,wBAAwB;IAIhC,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,uBAAuB;IAM/B,OAAO,CAAC,iBAAiB;IAiCzB,OAAO,CAAC,eAAe;cAQJ,MAAM,IAAI,cAAc;CAiB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,qBAAqB,EAAE,wBAAwB,CAAC;KACjD;CACF"}

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

@@ -1,2 +1,2 @@
-import { t as SbbExpansionPanelElement } from "../../expansion-panel.component-DUMM_Qhi.js";
+import { t as SbbExpansionPanelElement } from "../../expansion-panel.component-BnbRiLrk.js";
 export { SbbExpansionPanelElement };

package/development/expansion-panel/expansion-panel-content/expansion-panel-content.component.d.ts

@@ -1,5 +1,5 @@
 import { CSSResultGroup, TemplateResult } from 'lit';
-import { SbbElement } from '../../core/base-elements.ts';
+import { SbbElement } from '../../core.ts';
 /**
  * It can be used as a container for the content of the `sbb-expansion-panel` component.
  *
@@ -9,7 +9,7 @@ export declare class SbbExpansionPanelContentElement extends SbbElement {
     static readonly elementName: string;
     static readonly role = "region";
     static styles: CSSResultGroup;
-    private _previousSize?;
+    private _previousSize;
     constructor();
     connectedCallback(): void;
     protected render(): TemplateResult;

package/development/expansion-panel/expansion-panel-content/expansion-panel-content.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expansion-panel-content.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/expansion-panel/expansion-panel-content/expansion-panel-content.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAEhF,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAMzD;;;;GAIG;AACH,qBAAa,+BAAgC,SAAQ,UAAU;IAC7D,gBAAgC,WAAW,EAAE,MAAM,CAAiC;IACpF,gBAAgC,IAAI,YAAY;IAChD,OAAuB,MAAM,EAAE,cAAc,CAAuC;IAEpF,OAAO,CAAC,aAAa,CAAC,CAAS;;IAmBf,iBAAiB,IAAI,IAAI;cAKtB,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,6BAA6B,EAAE,+BAA+B,CAAC;KAChE;CACF"}
+{"version":3,"file":"expansion-panel-content.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/expansion-panel/expansion-panel-content/expansion-panel-content.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAQ,KAAK,cAAc,EAAa,MAAM,KAAK,CAAC;AAEhF,OAAO,EAAE,UAAU,EAAgC,MAAM,eAAe,CAAC;AAKzE;;;;GAIG;AACH,qBAAa,+BAAgC,SAAQ,UAAU;IAC7D,gBAAgC,WAAW,EAAE,MAAM,CAAiC;IACpF,gBAAgC,IAAI,YAAY;IAChD,OAAuB,MAAM,EAAE,cAAc,CAAsB;IAEnE,OAAO,CAAC,aAAa,CAA0C;;IAmB/C,iBAAiB,IAAI,IAAI;cAKtB,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,6BAA6B,EAAE,+BAA+B,CAAC;KAChE;CACF"}

package/development/expansion-panel/expansion-panel-content/expansion-panel-content.component.js

@@ -1,2 +1,2 @@
-import { t as SbbExpansionPanelContentElement } from "../../expansion-panel-content.component-aD0sErUh.js";
+import { t as SbbExpansionPanelContentElement } from "../../expansion-panel-content.component-CKhGtjji.js";
 export { SbbExpansionPanelContentElement };

package/development/expansion-panel/expansion-panel-header/expansion-panel-header.component.d.ts

@@ -1,6 +1,6 @@
 import { CSSResultGroup, TemplateResult } from 'lit';
-import { SbbButtonBaseElement } from '../../core/base-elements.ts';
-declare const SbbExpansionPanelHeaderElement_base: import('../../core/mixins.ts').AbstractConstructor<import('../../core/mixins.ts').SbbDisabledMixinType & import('../../core/mixins.ts').SbbDisabledInteractiveMixinType> & import('../../core/mixins.ts').AbstractConstructor<import('../../icon.ts').SbbIconNameMixinType> & typeof SbbButtonBaseElement;
+import { SbbButtonBaseElement } from '../../core.ts';
+declare const SbbExpansionPanelHeaderElement_base: import('../../core.ts').AbstractConstructor<import('../../core.ts').SbbDisabledMixinType & import('../../core.ts').SbbDisabledInteractiveMixinType> & import('../../core.ts').AbstractConstructor<import('../../icon.pure.ts').SbbIconNameMixinType> & typeof SbbButtonBaseElement;
 /**
  * It acts as a native `summary` tag for the `sbb-expansion-panel` component.
  *
@@ -15,7 +15,7 @@ export declare class SbbExpansionPanelHeaderElement extends SbbExpansionPanelHea
     };
     private _mediaMatcher;
     private _isHover;
-    private _previousSize?;
+    private _previousSize;
     constructor();
     connectedCallback(): void;
     private _emitExpandedEvent;