@sbb-esta/lyne-elements-dev 4.9.0-dev.1775049532 → 4.9.0-dev.1775054429

package/development/stepper.component-BAuHFBuI.js

@@ -0,0 +1,428 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement } from "./core/base-elements.js";
+import { forceType } from "./core/decorators.js";
+import { isLean } from "./core/dom.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { getNextElementIndex, isArrowKeyPressed } from "./core/a11y.js";
+import { IntersectionController } from "@lit-labs/observers/intersection-controller.js";
+import { SbbMediaMatcherController, SbbMediaQueryBreakpointLargeAndAbove, SbbMediaQueryBreakpointSmallAndAbove, SbbMediaQueryBreakpointUltraAndAbove, SbbMediaQueryBreakpointZeroAndAbove } from "./core/controllers/media-matchers-controller.js";
+//#region src/elements/stepper/stepper/stepper.scss?inline
+var stepper_default = ":host {\n  --sbb-stepper-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n  display: block;\n  position: relative;\n  counter-reset: step-label;\n}\n@media (forced-colors: active) {\n  :host {\n    --sbb-stepper-marker-color: ButtonText;\n  }\n}\n\n:host(:is(:state(disable-animation),[state--disable-animation])) {\n  --sbb-disable-animation-duration: 0s;\n}\n\n:host([orientation=vertical]) {\n  --sbb-stepper-orientation: column;\n}\n\n.sbb-stepper__labels {\n  display: flex;\n  flex-direction: var(--sbb-stepper-orientation);\n  position: relative;\n  justify-content: start;\n  margin-block-end: var(--sbb-spacing-responsive-m);\n}\n.sbb-stepper__labels::before {\n  content: \"\";\n  position: absolute;\n  inset-inline-start: calc(var(--sbb-stepper-border-width) * -1);\n  background-color: var(--sbb-stepper-marker-color);\n}\n:host([orientation=horizontal]) .sbb-stepper__labels {\n  gap: var(--sbb-spacing-responsive-m);\n  padding-block-end: var(--sbb-spacing-fixed-4x);\n  border-block-end: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);\n}\n:host([orientation=horizontal]) .sbb-stepper__labels::before {\n  inset-block-end: calc(var(--sbb-stepper-border-width) * -1);\n  height: var(--sbb-stepper-marker-width);\n  width: var(--sbb-stepper-marker-size, 0);\n  transition: width var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n}\n:host([orientation=vertical]) .sbb-stepper__labels {\n  padding-inline-start: var(--sbb-spacing-fixed-4x);\n  border-inline-start: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);\n}\n:host([orientation=vertical]) .sbb-stepper__labels::before {\n  inset-block-start: 0;\n  width: var(--sbb-stepper-marker-width);\n  height: var(--sbb-stepper-marker-size, 0);\n  transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n}\n\n.sbb-stepper__steps {\n  position: relative;\n}\n:host([orientation=horizontal]) .sbb-stepper__steps {\n  height: var(--sbb-stepper-content-height);\n  transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n}\n\n::slotted(sbb-step-label)::before {\n  content: counter(step-label);\n  counter-increment: step-label;\n}";
+//#endregion
+//#region src/elements/stepper/stepper/stepper.component.ts
+var DEBOUNCE_TIME = 150;
+var breakpointMap = {
+	zero: SbbMediaQueryBreakpointZeroAndAbove,
+	small: SbbMediaQueryBreakpointSmallAndAbove,
+	large: SbbMediaQueryBreakpointLargeAndAbove,
+	ultra: SbbMediaQueryBreakpointUltraAndAbove
+};
+var SbbStepChangeEvent = class extends Event {
+	constructor(selectedIndex, previousIndex, selectedStep, previousStep) {
+		super("stepchange", {
+			bubbles: true,
+			composed: true
+		});
+		this.selectedIndex = selectedIndex;
+		this.previousIndex = previousIndex;
+		this.selectedStep = selectedStep;
+		this.previousStep = previousStep;
+	}
+};
+/**
+* Provides a structured, step-by-step workflow for user interactions.
+* @slot - Provide a `sbb-expansion-panel-header` and a `sbb-expansion-panel-content` to the stepper.
+* @slot step-label - Use this slot to provide an `sbb-step-label`.
+* @slot step - Use this slot to provide an `sbb-step`.
+* @event {SbbStepChangeEvent} stepchange - Emits whenever a step was changed.
+*/
+var SbbStepperElement = (() => {
+	let _classSuper = SbbElement;
+	let _instanceExtraInitializers = [];
+	let _linear_decorators;
+	let _linear_initializers = [];
+	let _linear_extraInitializers = [];
+	let _set_horizontalFrom_decorators;
+	let _orientation_decorators;
+	let _orientation_initializers = [];
+	let _orientation_extraInitializers = [];
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let _set_selected_decorators;
+	let _set_selectedIndex_decorators;
+	return class SbbStepperElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_linear_decorators = [forceType(), property({ type: Boolean })];
+			_set_horizontalFrom_decorators = [property({
+				attribute: "horizontal-from",
+				reflect: true
+			})];
+			_orientation_decorators = [property({ reflect: true })];
+			_size_decorators = [property({ reflect: true })];
+			_set_selected_decorators = [property({ attribute: false })];
+			_set_selectedIndex_decorators = [property({
+				attribute: "selected-index",
+				type: Number
+			})];
+			__esDecorate(this, null, _linear_decorators, {
+				kind: "accessor",
+				name: "linear",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "linear" in obj,
+					get: (obj) => obj.linear,
+					set: (obj, value) => {
+						obj.linear = value;
+					}
+				},
+				metadata: _metadata
+			}, _linear_initializers, _linear_extraInitializers);
+			__esDecorate(this, null, _set_horizontalFrom_decorators, {
+				kind: "setter",
+				name: "horizontalFrom",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "horizontalFrom" in obj,
+					set: (obj, value) => {
+						obj.horizontalFrom = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _orientation_decorators, {
+				kind: "accessor",
+				name: "orientation",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "orientation" in obj,
+					get: (obj) => obj.orientation,
+					set: (obj, value) => {
+						obj.orientation = value;
+					}
+				},
+				metadata: _metadata
+			}, _orientation_initializers, _orientation_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, _set_selected_decorators, {
+				kind: "setter",
+				name: "selected",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "selected" in obj,
+					set: (obj, value) => {
+						obj.selected = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_selectedIndex_decorators, {
+				kind: "setter",
+				name: "selectedIndex",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "selectedIndex" in obj,
+					set: (obj, value) => {
+						obj.selectedIndex = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-stepper";
+		}
+		static {
+			this.styles = [boxSizingStyles, unsafeCSS(stepper_default)];
+		}
+		static {
+			this.events = { stepchange: "stepchange" };
+		}
+		#linear_accessor_storage;
+		/** If set to true, only the current and previous labels can be clicked and selected. */
+		get linear() {
+			return this.#linear_accessor_storage;
+		}
+		set linear(value) {
+			this.#linear_accessor_storage = value;
+		}
+		/** Overrides the behavior of `orientation` property. */
+		set horizontalFrom(value) {
+			this._horizontalFrom = value && breakpointMap[value] ? value : null;
+			if (this._horizontalFrom && this._loaded) this._checkOrientation();
+		}
+		get horizontalFrom() {
+			return this._horizontalFrom;
+		}
+		#orientation_accessor_storage;
+		/** Steps orientation, either horizontal or vertical. */
+		get orientation() {
+			return this.#orientation_accessor_storage;
+		}
+		set orientation(value) {
+			this.#orientation_accessor_storage = value;
+		}
+		#size_accessor_storage;
+		/**
+		* Size variant, either s or m.
+		* @default 'm' / 's' (lean)
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		/** The currently selected step. */
+		set selected(step) {
+			if (this._loaded) this._select(step);
+			this._requestedSelected = step;
+		}
+		get selected() {
+			return this.querySelector?.("sbb-step:is(:state(selected),[state--selected])") ?? null;
+		}
+		/** The currently selected step index. */
+		set selectedIndex(index) {
+			if (this._loaded && index !== null) this._select(this.steps[index]);
+			this._requestedSelectedIndex = index;
+		}
+		get selectedIndex() {
+			return this.selected ? this.steps.indexOf(this.selected) : null;
+		}
+		/** The steps of the stepper. */
+		get steps() {
+			const steps = [];
+			this.querySelectorAll?.("sbb-step").forEach((step) => {
+				customElements.upgrade(step);
+				steps.push(step);
+			});
+			return steps;
+		}
+		get _enabledSteps() {
+			return this.steps.filter((s) => {
+				if (s.label) {
+					customElements.upgrade(s.label);
+					return !s.label.disabled;
+				}
+				return false;
+			});
+		}
+		constructor() {
+			super();
+			/**
+			* If the sbb-stepper is used in a sbb-dialog, the marker on the selected element will not appear,
+			* because the calculations are done when the dialog is closed, so the marker has a width of 0;
+			* the same happens for the stepper height.
+			* We need to recalculate it when the element becomes visible.
+			*/
+			this._observer = (__runInitializers(this, _instanceExtraInitializers), new IntersectionController(this, {
+				target: null,
+				callback: (entries) => {
+					entries.forEach((e) => {
+						if (e.intersectionRatio > 0) {
+							this._setStepperHeight(this.selected);
+							this._setMarkerSize();
+						}
+					});
+				}
+			}));
+			this.#linear_accessor_storage = __runInitializers(this, _linear_initializers, false);
+			this._horizontalFrom = (__runInitializers(this, _linear_extraInitializers), null);
+			this.#orientation_accessor_storage = __runInitializers(this, _orientation_initializers, "horizontal");
+			this.#size_accessor_storage = (__runInitializers(this, _orientation_extraInitializers), __runInitializers(this, _size_initializers, isLean() ? "s" : "m"));
+			this._requestedSelected = (__runInitializers(this, _size_extraInitializers), null);
+			this._requestedSelectedIndex = null;
+			this._loaded = false;
+			this._resizeObserverTimeout = null;
+			this._mediaMatcher = new SbbMediaMatcherController(this, {});
+			this._onStepperResize = () => {
+				this._checkOrientation();
+				this._setStepperHeight(this.selected);
+				clearTimeout(this._resizeObserverTimeout);
+				this.internals.states.add("disable-animation");
+				this._resizeObserverTimeout = setTimeout(() => this.internals.states.delete("disable-animation"), DEBOUNCE_TIME);
+			};
+			this.addEventListener?.("keydown", (e) => this._handleKeyDown(e));
+			this.addEventListener?.("resizechange", (e) => this._onSelectedStepResize(e));
+		}
+		/** Selects the next step. */
+		next() {
+			if (this.selectedIndex !== null) this._select(this.steps[this.selectedIndex + 1]);
+		}
+		/** Selects the previous step. */
+		previous() {
+			if (this.selectedIndex !== null) this._select(this.steps[this.selectedIndex - 1]);
+		}
+		/** Resets the form in which the stepper is nested or every form of each step, if any. */
+		reset() {
+			const closestForm = this.closest("form");
+			if (closestForm) closestForm.reset();
+			else this.querySelectorAll("form").forEach((form) => form.reset());
+			this.selectedIndex = 0;
+			if (document.activeElement?.closest("sbb-stepper") === this) this.selected?.label?.focus();
+		}
+		_isSelectable(step) {
+			if (step) {
+				customElements.upgrade(step);
+				if (step.label) {
+					customElements.upgrade(step.label);
+					if (!this.linear && step.label.disabled) return false;
+				}
+				return true;
+			} else return false;
+		}
+		_select(step) {
+			if (!this._isSelectable(step) || step === this.selected) return;
+			const currentIndex = this.selectedIndex;
+			const currentStep = this.selected;
+			const validatePayload = {
+				currentIndex,
+				currentStep,
+				nextIndex: this.selectedIndex !== null ? this.selectedIndex + 1 : null,
+				nextStep: this.selectedIndex !== null ? this.steps[this.selectedIndex + 1] : null
+			};
+			if (this.selected && !this.selected.validate(validatePayload)) return;
+			this.selected?.deselect();
+			step.select();
+			/** @internal only to provide double entry in docs. It is a public event! */
+			this.dispatchEvent(new SbbStepChangeEvent(this.selectedIndex, currentIndex, this.selected, currentStep));
+			this._setMarkerSize();
+			this._setStepperHeight(step);
+			this._configureLinearMode();
+			if (document.activeElement?.closest("sbb-stepper") === this) this.selected?.label?.focus();
+		}
+		_setMarkerSize() {
+			if (!this._loaded || !this.selected || this.selectedIndex === void 0 || !this.selected.label) return;
+			const offset = this.orientation === "horizontal" ? this.selected.label.offsetLeft + this.selected.label.offsetWidth : this._calculateLabelOffsetTop();
+			this.style.setProperty("--sbb-stepper-marker-size", `${offset}px`);
+		}
+		/**
+		* Sets the stepper height based on the height of the provided step.
+		*/
+		_setStepperHeight(step) {
+			if (step && step.shadowRoot) {
+				const innerElement = step.shadowRoot.querySelector(".sbb-step");
+				if (innerElement) this.style?.setProperty("--sbb-stepper-content-height", `${innerElement.offsetHeight}px`);
+			}
+		}
+		_calculateLabelOffsetTop() {
+			if (this.selectedIndex === null) return;
+			let offset = 0;
+			for (const step of this.steps) {
+				if (step === this.selected) break;
+				offset = step.label.offsetHeight + offset;
+			}
+			return offset + this.selected.label.offsetHeight + parseFloat(getComputedStyle(this).getPropertyValue("--sbb-spacing-fixed-6x")) * 16 * this.selectedIndex;
+		}
+		_onSelectedStepResize(e) {
+			this._setStepperHeight(e.target);
+		}
+		_configure() {
+			this.steps.forEach((step, i, array) => {
+				step.configure(this._loaded);
+				step.label?.configure(i + 1, array.length, this._loaded);
+			});
+			this._select(this.selected || this._enabledSteps[0]);
+		}
+		_updateLabels() {
+			this.steps.forEach((step) => {
+				step.slot = this.orientation === "horizontal" ? "step" : "step-label";
+			});
+		}
+		_checkOrientation() {
+			if (this.horizontalFrom) {
+				this.orientation = this._mediaMatcher.matches(breakpointMap[this.horizontalFrom]) ? "horizontal" : "vertical";
+				this._updateLabels();
+			}
+			setTimeout(() => this._setMarkerSize(), 0);
+		}
+		_configureLinearMode() {
+			this.steps.forEach((step, index) => {
+				if (!step.label) return;
+				customElements.upgrade(step.label);
+				step.label.disable(this.linear && index > this.selectedIndex || !this.linear && step.label.matches(":is(:state(user-disabled),[state--user-disabled])"));
+			});
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			window.addEventListener("resize", this._onStepperResize, { passive: true });
+			this.toggleState("disable-animation", !this._loaded);
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			window.removeEventListener("resize", this._onStepperResize);
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this.updateComplete.then(() => {
+				this._loaded = true;
+				this._configure();
+				if (this._requestedSelected && this.steps.indexOf(this._requestedSelected) !== -1) this.selectedIndex = this.steps.indexOf(this._requestedSelected);
+				else if (this._requestedSelectedIndex) this.selectedIndex = this._requestedSelectedIndex;
+				else this.selectedIndex = 0;
+				this._observer.observe(this);
+				this._checkOrientation();
+				setTimeout(() => this.internals.states.delete("disable-animation"), DEBOUNCE_TIME);
+			});
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("orientation") && !this.horizontalFrom) {
+				this._updateLabels();
+				this._setMarkerSize();
+			}
+			if (changedProperties.has("linear") && this._loaded) this._configureLinearMode();
+			if (changedProperties.has("size")) this._setMarkerSize();
+		}
+		_handleKeyDown(evt) {
+			const enabledSteps = this._enabledSteps;
+			if (!enabledSteps || evt.target !== this && evt.target.parentElement !== this) return;
+			if (isArrowKeyPressed(evt)) {
+				const nextIndex = getNextElementIndex(evt, enabledSteps.indexOf(this.selected), enabledSteps.length);
+				this._select(enabledSteps[nextIndex]);
+				evt.preventDefault();
+			}
+		}
+		render() {
+			return html`
+      <div class="sbb-stepper__labels" role="tablist">
+        <slot name="step-label" @slotchange=${this._configure}></slot>
+      </div>
+      <div class="sbb-stepper__steps">
+        <slot name="step" @slotchange=${this._configure}></slot>
+      </div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbStepperElement as n, SbbStepChangeEvent as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"stepper.component-BAuHFBuI.js","names":[],"sources":["../../../src/elements/stepper/stepper/stepper.scss?inline","../../../src/elements/stepper/stepper/stepper.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-stepper-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n\n  display: block;\n  position: relative;\n  counter-reset: step-label;\n\n  @include sbb.if-forced-colors {\n    --sbb-stepper-marker-color: ButtonText;\n  }\n}\n\n:host(:state(disable-animation)) {\n  @include sbb.disable-animation;\n}\n\n:host([orientation='vertical']) {\n  --sbb-stepper-orientation: column;\n}\n\n.sbb-stepper__labels {\n  display: flex;\n  flex-direction: var(--sbb-stepper-orientation);\n  position: relative;\n  justify-content: start;\n  margin-block-end: var(--sbb-spacing-responsive-m);\n\n  &::before {\n    content: '';\n    position: absolute;\n    inset-inline-start: calc(var(--sbb-stepper-border-width) * -1);\n    background-color: var(--sbb-stepper-marker-color);\n  }\n\n  :host([orientation='horizontal']) & {\n    gap: var(--sbb-spacing-responsive-m);\n    padding-block-end: var(--sbb-spacing-fixed-4x);\n    border-block-end: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);\n\n    &::before {\n      inset-block-end: calc(var(--sbb-stepper-border-width) * -1);\n      height: var(--sbb-stepper-marker-width);\n      width: var(--sbb-stepper-marker-size, 0);\n      transition: width var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n    }\n  }\n\n  :host([orientation='vertical']) & {\n    padding-inline-start: var(--sbb-spacing-fixed-4x);\n    border-inline-start: var(--sbb-stepper-border-width) solid var(--sbb-border-color-4-inverted);\n\n    &::before {\n      inset-block-start: 0;\n      width: var(--sbb-stepper-marker-width);\n      height: var(--sbb-stepper-marker-size, 0);\n      transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n    }\n  }\n}\n\n.sbb-stepper__steps {\n  position: relative;\n\n  :host([orientation='horizontal']) & {\n    height: var(--sbb-stepper-content-height);\n    transition: height var(--sbb-stepper-animation-duration) var(--sbb-animation-easing);\n  }\n}\n\n::slotted(sbb-step-label)::before {\n  content: counter(step-label);\n  counter-increment: step-label;\n}\n","import { IntersectionController } from '@lit-labs/observers/intersection-controller.js';\nimport {\n  type CSSResultGroup,\n  html,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { getNextElementIndex, isArrowKeyPressed } from '../../core/a11y.ts';\nimport { SbbElement } from '../../core/base-elements.ts';\nimport {\n  SbbMediaMatcherController,\n  SbbMediaQueryBreakpointLargeAndAbove,\n  SbbMediaQueryBreakpointSmallAndAbove,\n  SbbMediaQueryBreakpointUltraAndAbove,\n  SbbMediaQueryBreakpointZeroAndAbove,\n} from '../../core/controllers/media-matchers-controller.ts';\nimport { forceType } from '../../core/decorators.ts';\nimport { isLean } from '../../core/dom.ts';\nimport type { SbbHorizontalFrom, SbbOrientation } from '../../core/interfaces.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\nimport type { SbbStepElement, SbbStepValidateEventDetails } from '../step/step.component.ts';\n\nimport style from './stepper.scss?inline';\n\nconst DEBOUNCE_TIME = 150;\n\nconst breakpointMap: Record<string, string> = {\n  zero: SbbMediaQueryBreakpointZeroAndAbove,\n  small: SbbMediaQueryBreakpointSmallAndAbove,\n  large: SbbMediaQueryBreakpointLargeAndAbove,\n  ultra: SbbMediaQueryBreakpointUltraAndAbove,\n};\n\nexport class SbbStepChangeEvent extends Event {\n  /** The index of the newly selected step. */\n  public readonly selectedIndex: number | null;\n\n  /** The index of the previously selected step. */\n  public readonly previousIndex: number | null;\n\n  /** The newly selected step element. */\n  public readonly selectedStep: SbbStepElement | null;\n\n  /** The previously selected step element. */\n  public readonly previousStep: SbbStepElement | null;\n\n  public constructor(\n    selectedIndex: number | null,\n    previousIndex: number | null,\n    selectedStep: SbbStepElement | null,\n    previousStep: SbbStepElement | null,\n  ) {\n    super('stepchange', { bubbles: true, composed: true });\n    this.selectedIndex = selectedIndex;\n    this.previousIndex = previousIndex;\n    this.selectedStep = selectedStep;\n    this.previousStep = previousStep;\n  }\n}\n/**\n * Provides a structured, step-by-step workflow for user interactions.\n * @slot - Provide a `sbb-expansion-panel-header` and a `sbb-expansion-panel-content` to the stepper.\n * @slot step-label - Use this slot to provide an `sbb-step-label`.\n * @slot step - Use this slot to provide an `sbb-step`.\n * @event {SbbStepChangeEvent} stepchange - Emits whenever a step was changed.\n */\nexport class SbbStepperElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-stepper';\n  public static override styles: CSSResultGroup = [boxSizingStyles, unsafeCSS(style)];\n  public static readonly events = {\n    stepchange: 'stepchange',\n  } as const;\n\n  /**\n   * If the sbb-stepper is used in a sbb-dialog, the marker on the selected element will not appear,\n   * because the calculations are done when the dialog is closed, so the marker has a width of 0;\n   * the same happens for the stepper height.\n   * We need to recalculate it when the element becomes visible.\n   */\n  private _observer = new IntersectionController(this, {\n    target: null,\n    callback: (entries) => {\n      entries.forEach((e) => {\n        if (e.intersectionRatio > 0) {\n          this._setStepperHeight(this.selected);\n          this._setMarkerSize();\n        }\n      });\n    },\n  });\n\n  /** If set to true, only the current and previous labels can be clicked and selected. */\n  @forceType()\n  @property({ type: Boolean })\n  public accessor linear: boolean = false;\n\n  /** Overrides the behavior of `orientation` property. */\n  @property({ attribute: 'horizontal-from', reflect: true })\n  public set horizontalFrom(value: SbbHorizontalFrom | null) {\n    this._horizontalFrom = value && breakpointMap[value] ? value : null;\n    if (this._horizontalFrom && this._loaded) {\n      this._checkOrientation();\n    }\n  }\n  public get horizontalFrom(): SbbHorizontalFrom | null {\n    return this._horizontalFrom;\n  }\n  private _horizontalFrom: SbbHorizontalFrom | null = null;\n\n  /** Steps orientation, either horizontal or vertical. */\n  @property({ reflect: true })\n  public accessor orientation: SbbOrientation = 'horizontal';\n\n  /**\n   * Size variant, either s or m.\n   * @default 'm' / 's' (lean)\n   */\n  @property({ reflect: true }) public accessor size: 's' | 'm' = isLean() ? 's' : 'm';\n\n  /** The currently selected step. */\n  @property({ attribute: false })\n  public set selected(step: SbbStepElement | null) {\n    if (this._loaded) {\n      this._select(step);\n    }\n    this._requestedSelected = step;\n  }\n  public get selected(): SbbStepElement | null {\n    return this.querySelector?.<SbbStepElement>('sbb-step:state(selected)') ?? null;\n  }\n  private _requestedSelected: SbbStepElement | null = null;\n\n  /** The currently selected step index. */\n  @property({ attribute: 'selected-index', type: Number })\n  public set selectedIndex(index: number | null) {\n    if (this._loaded && index !== null) {\n      this._select(this.steps[index]);\n    }\n    this._requestedSelectedIndex = index;\n  }\n  public get selectedIndex(): number | null {\n    return this.selected ? this.steps.indexOf(this.selected) : null;\n  }\n  private _requestedSelectedIndex: number | null = null;\n\n  /** The steps of the stepper. */\n  public get steps(): SbbStepElement[] {\n    const steps: SbbStepElement[] = [];\n    this.querySelectorAll?.('sbb-step').forEach((step) => {\n      customElements.upgrade(step);\n      steps.push(step);\n    });\n    return steps;\n  }\n\n  private get _enabledSteps(): SbbStepElement[] {\n    return this.steps.filter((s) => {\n      if (s.label) {\n        customElements.upgrade(s.label);\n        return !s.label.disabled;\n      }\n      return false;\n    });\n  }\n\n  private _loaded: boolean = false;\n  private _resizeObserverTimeout: ReturnType<typeof setTimeout> | null = null;\n  private _mediaMatcher = new SbbMediaMatcherController(this, {});\n\n  public constructor() {\n    super();\n    this.addEventListener?.('keydown', (e) => this._handleKeyDown(e));\n    this.addEventListener?.('resizechange', (e: Event) => this._onSelectedStepResize(e));\n  }\n\n  /** Selects the next step. */\n  public next(): void {\n    if (this.selectedIndex !== null) {\n      this._select(this.steps[this.selectedIndex + 1]);\n    }\n  }\n\n  /** Selects the previous step. */\n  public previous(): void {\n    if (this.selectedIndex !== null) {\n      this._select(this.steps[this.selectedIndex - 1]);\n    }\n  }\n\n  /** Resets the form in which the stepper is nested or every form of each step, if any. */\n  public reset(): void {\n    const closestForm = this.closest('form');\n    if (closestForm) {\n      closestForm.reset();\n    } else {\n      this.querySelectorAll('form').forEach((form) => form.reset());\n    }\n    this.selectedIndex = 0;\n    // In case the focus is currently inside the stepper, we reset the focus to the first/selected step label.\n    if (document.activeElement?.closest('sbb-stepper') === this) {\n      this.selected?.label?.focus();\n    }\n  }\n\n  private _isSelectable(step: SbbStepElement | null): step is SbbStepElement {\n    if (step) {\n      customElements.upgrade(step);\n      if (step.label) {\n        customElements.upgrade(step.label);\n        if (!this.linear && step.label.disabled) {\n          return false;\n        }\n      }\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  private _select(step: SbbStepElement | null): void {\n    if (!this._isSelectable(step) || step === this.selected) {\n      return;\n    }\n    const currentIndex = this.selectedIndex;\n    const currentStep = this.selected;\n    const validatePayload: SbbStepValidateEventDetails = {\n      currentIndex,\n      currentStep,\n      nextIndex: this.selectedIndex !== null ? this.selectedIndex + 1 : null,\n      nextStep: this.selectedIndex !== null ? this.steps[this.selectedIndex + 1] : null,\n    };\n\n    if (this.selected && !this.selected.validate(validatePayload)) {\n      return;\n    }\n\n    const current = this.selected;\n    current?.deselect();\n    step.select();\n\n    /** @internal only to provide double entry in docs. It is a public event! */\n    this.dispatchEvent(\n      new SbbStepChangeEvent(this.selectedIndex, currentIndex, this.selected, currentStep),\n    );\n\n    this._setMarkerSize();\n    this._setStepperHeight(step);\n    this._configureLinearMode();\n    // In case the focus is currently inside the stepper, we focus the selected step label.\n    if (document.activeElement?.closest('sbb-stepper') === this) {\n      this.selected?.label?.focus();\n    }\n  }\n\n  private _setMarkerSize(): void {\n    if (\n      !this._loaded ||\n      !this.selected ||\n      this.selectedIndex === undefined ||\n      !this.selected.label\n    ) {\n      return;\n    }\n    const offset =\n      this.orientation === 'horizontal'\n        ? this.selected.label.offsetLeft + this.selected.label.offsetWidth\n        : this._calculateLabelOffsetTop();\n\n    this.style.setProperty('--sbb-stepper-marker-size', `${offset}px`);\n  }\n\n  /**\n   * Sets the stepper height based on the height of the provided step.\n   */\n  private _setStepperHeight(step: SbbStepElement | null): void {\n    if (step && step.shadowRoot) {\n      const innerElement: SbbStepElement | null = step.shadowRoot.querySelector('.sbb-step');\n      if (innerElement) {\n        this.style?.setProperty('--sbb-stepper-content-height', `${innerElement.offsetHeight}px`);\n      }\n    }\n  }\n\n  private _calculateLabelOffsetTop(): number | undefined {\n    if (this.selectedIndex === null) {\n      return;\n    }\n    let offset = 0;\n    for (const step of this.steps) {\n      if (step === this.selected) {\n        break;\n      }\n      offset = step.label!.offsetHeight + offset;\n    }\n    return (\n      offset +\n      this.selected!.label!.offsetHeight! +\n      parseFloat(getComputedStyle(this).getPropertyValue('--sbb-spacing-fixed-6x')) *\n        16 *\n        this.selectedIndex\n    );\n  }\n\n  private _onSelectedStepResize(e: Event): void {\n    this._setStepperHeight(e.target as SbbStepElement);\n  }\n\n  private _configure(): void {\n    this.steps.forEach((step, i, array) => {\n      step.configure(this._loaded);\n      step.label?.configure(i + 1, array.length, this._loaded);\n    });\n    this._select(this.selected || this._enabledSteps[0]);\n  }\n\n  private _updateLabels(): void {\n    this.steps.forEach((step) => {\n      step.slot = this.orientation === 'horizontal' ? 'step' : 'step-label';\n    });\n  }\n\n  private _checkOrientation(): void {\n    if (this.horizontalFrom) {\n      this.orientation = this._mediaMatcher.matches(breakpointMap[this.horizontalFrom])\n        ? 'horizontal'\n        : 'vertical';\n      this._updateLabels();\n    }\n    // The timeout is needed to make sure that the marker takes the correct step-label size.\n    setTimeout(() => this._setMarkerSize(), 0);\n  }\n\n  private _onStepperResize = (): void => {\n    this._checkOrientation();\n    this._setStepperHeight(this.selected);\n    clearTimeout(this._resizeObserverTimeout!);\n    this.internals.states.add('disable-animation');\n\n    // Disable the animation when resizing to avoid strange transition effects.\n    this._resizeObserverTimeout = setTimeout(\n      () => this.internals.states.delete('disable-animation'),\n      DEBOUNCE_TIME,\n    );\n  };\n\n  private _configureLinearMode(): void {\n    this.steps.forEach((step, index) => {\n      if (!step.label) {\n        return;\n      }\n      customElements.upgrade(step.label);\n\n      step.label.disable(\n        (this.linear && index > this.selectedIndex!) ||\n          (!this.linear && step.label.matches(':state(user-disabled)')),\n      );\n    });\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    window.addEventListener('resize', this._onStepperResize, {\n      passive: true,\n    });\n    this.toggleState('disable-animation', !this._loaded);\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    window.removeEventListener('resize', this._onStepperResize);\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this.updateComplete.then(() => {\n      this._loaded = true;\n      this._configure();\n\n      if (this._requestedSelected && this.steps.indexOf(this._requestedSelected) !== -1) {\n        this.selectedIndex = this.steps.indexOf(this._requestedSelected);\n      } else if (this._requestedSelectedIndex) {\n        this.selectedIndex = this._requestedSelectedIndex;\n      } else {\n        this.selectedIndex = 0;\n      }\n\n      this._observer.observe(this);\n      this._checkOrientation();\n      // Remove disable-animation state after component init\n      setTimeout(() => this.internals.states.delete('disable-animation'), DEBOUNCE_TIME);\n    });\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n    if (changedProperties.has('orientation') && !this.horizontalFrom) {\n      this._updateLabels();\n      this._setMarkerSize();\n    }\n    if (changedProperties.has('linear') && this._loaded) {\n      this._configureLinearMode();\n    }\n\n    if (changedProperties.has('size')) {\n      this._setMarkerSize();\n    }\n  }\n\n  private _handleKeyDown(evt: KeyboardEvent): void {\n    const enabledSteps: SbbStepElement[] = this._enabledSteps;\n\n    if (\n      !enabledSteps ||\n      // don't trap nested handling\n      ((evt.target as HTMLElement) !== this && (evt.target as HTMLElement).parentElement !== this)\n    ) {\n      return;\n    }\n\n    if (isArrowKeyPressed(evt)) {\n      const current: number = enabledSteps.indexOf(this.selected!);\n      const nextIndex: number = getNextElementIndex(evt, current, enabledSteps.length);\n      this._select(enabledSteps[nextIndex]);\n      evt.preventDefault();\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-stepper__labels\" role=\"tablist\">\n        <slot name=\"step-label\" @slotchange=${this._configure}></slot>\n      </div>\n      <div class=\"sbb-stepper__steps\">\n        <slot name=\"step\" @slotchange=${this._configure}></slot>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-stepper': SbbStepperElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AC2BA,IAAM,gBAAgB;AAEtB,IAAM,gBAAwC;CAC5C,MAAM;CACN,OAAO;CACP,OAAO;CACP,OAAO;CACR;AAED,IAAa,qBAAb,cAAwC,MAAK;CAa3C,YACE,eACA,eACA,cACA,cAAmC;AAEnC,QAAM,cAAc;GAAE,SAAS;GAAM,UAAU;GAAM,CAAC;AACtD,OAAK,gBAAgB;AACrB,OAAK,gBAAgB;AACrB,OAAK,eAAe;AACpB,OAAK,eAAe;;;;;;;;;;IAUX,2BAAiB;mBAAS;;;;;;;;;;;;;;cAA1B,0BAA0B,YAAU;;;yBA0B9C,WAAW,EACX,SAAS,EAAE,MAAM,SAAS,CAAC,CAAA;qCAI3B,SAAS;IAAE,WAAW;IAAmB,SAAS;IAAM,CAAC,CAAA;8BAazD,SAAS,EAAE,SAAS,MAAM,CAAC,CAAA;uBAO3B,SAAS,EAAE,SAAS,MAAM,CAAC,CAAA;+BAG3B,SAAS,EAAE,WAAW,OAAO,CAAC,CAAA;oCAa9B,SAAS;IAAE,WAAW;IAAkB,MAAM;IAAQ,CAAC,CAAA;AAvCxD,gBAAA,MAAA,MAAA,oBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,YAAA;KAAA,MAAA,QAAA,IAAgB;KAAM,MAAA,KAAA,UAAA;AAAA,UAAN,SAAM;;KAAA;IAAA,UAAA;IAAA,EAAA,sBAAA,0BAAA;AAItB,gBAAA,MAAA,MAAA,gCAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,oBAAA;KAAA,MAAA,KAAA,UAAA;AAAA,UAAW,iBAAc;;KAAA;IAAA,UAAA;IAAA,EAAA,MAAA,2BAAA;AAazB,gBAAA,MAAA,MAAA,yBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,iBAAA;KAAA,MAAA,QAAA,IAAgB;KAAW,MAAA,KAAA,UAAA;AAAA,UAAX,cAAW;;KAAA;IAAA,UAAA;IAAA,EAAA,2BAAA,+BAAA;AAME,gBAAA,MAAA,MAAA,kBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,QAAA,IAAgB;KAAI,MAAA,KAAA,UAAA;AAAA,UAAJ,OAAI;;KAAA;IAAA,UAAA;IAAA,EAAA,oBAAA,wBAAA;AAIjD,gBAAA,MAAA,MAAA,0BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,cAAA;KAAA,MAAA,KAAA,UAAA;AAAA,UAAW,WAAQ;;KAAA;IAAA,UAAA;IAAA,EAAA,MAAA,2BAAA;AAanB,gBAAA,MAAA,MAAA,+BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,mBAAA;KAAA,MAAA,KAAA,UAAA;AAAA,UAAW,gBAAa;;KAAA;IAAA,UAAA;IAAA,EAAA,MAAA,2BAAA;;;;;;;;;AAnEQ,QAAA,cAAsB;;;AAC/B,QAAA,SAAyB,CAAC,iBAAiB,UAAU,gBAAM,CAAC;;;AAC5D,QAAA,SAAS,EAC9B,YAAY,cACJ;;EAuBV;;EAAA,IAAgB,SAAM;AAAA,UAAA,MAAA;;EAAtB,IAAgB,OAAM,OAAA;AAAA,SAAA,0BAAA;;;EAItB,IAAW,eAAe,OAA+B;AACvD,QAAK,kBAAkB,SAAS,cAAc,SAAS,QAAQ;AAC/D,OAAI,KAAK,mBAAmB,KAAK,QAC/B,MAAK,mBAAmB;;EAG5B,IAAW,iBAAc;AACvB,UAAO,KAAK;;EAMd;;EAAA,IAAgB,cAAW;AAAA,UAAA,MAAA;;EAA3B,IAAgB,YAAW,OAAA;AAAA,SAAA,+BAAA;;EAME;;;;;EAAA,IAAgB,OAAI;AAAA,UAAA,MAAA;;EAApB,IAAgB,KAAI,OAAA;AAAA,SAAA,wBAAA;;;EAIjD,IAAW,SAAS,MAA2B;AAC7C,OAAI,KAAK,QACP,MAAK,QAAQ,KAAK;AAEpB,QAAK,qBAAqB;;EAE5B,IAAW,WAAQ;AACjB,UAAO,KAAK,gBAAgC,kDAA2B,IAAI;;;EAM7E,IAAW,cAAc,OAAoB;AAC3C,OAAI,KAAK,WAAW,UAAU,KAC5B,MAAK,QAAQ,KAAK,MAAM,OAAO;AAEjC,QAAK,0BAA0B;;EAEjC,IAAW,gBAAa;AACtB,UAAO,KAAK,WAAW,KAAK,MAAM,QAAQ,KAAK,SAAS,GAAG;;;EAK7D,IAAW,QAAK;GACd,MAAM,QAA0B,EAAE;AAClC,QAAK,mBAAmB,WAAW,CAAC,SAAS,SAAQ;AACnD,mBAAe,QAAQ,KAAK;AAC5B,UAAM,KAAK,KAAK;KAChB;AACF,UAAO;;EAGT,IAAY,gBAAa;AACvB,UAAO,KAAK,MAAM,QAAQ,MAAK;AAC7B,QAAI,EAAE,OAAO;AACX,oBAAe,QAAQ,EAAE,MAAM;AAC/B,YAAO,CAAC,EAAE,MAAM;;AAElB,WAAO;KACP;;EAOJ,cAAA;AACE,UAAO;;;;;;;AA3FD,QAAA,aAbG,kBAAA,MAAA,2BAAiB,EAaR,IAAI,uBAAuB,MAAM;IACnD,QAAQ;IACR,WAAW,YAAW;AACpB,aAAQ,SAAS,MAAK;AACpB,UAAI,EAAE,oBAAoB,GAAG;AAC3B,YAAK,kBAAkB,KAAK,SAAS;AACrC,YAAK,gBAAgB;;OAEvB;;IAEL,CAAC;AAKc,SAAA,0BAAA,kBAAA,MAAA,sBAAkB,MAAK;AAa/B,QAAA,mBAAe,kBAAA,MAAA,0BAAA,EAA6B;AAIpC,SAAA,+BAAA,kBAAA,MAAA,2BAA8B,aAAY;AAMb,SAAA,yBAAA,kBAAA,MAAA,+BAAA,EAAA,kBAAA,MAAA,oBAAkB,QAAQ,GAAG,MAAM,IAAG;AAa3E,QAAA,sBAAkB,kBAAA,MAAA,wBAAA,EAA0B;AAa5C,QAAA,0BAAyC;AAsBzC,QAAA,UAAmB;AACnB,QAAA,yBAA+D;AAC/D,QAAA,gBAAgB,IAAI,0BAA0B,MAAM,EAAE,CAAC;AAqKvD,QAAA,yBAA8B;AACpC,SAAK,mBAAmB;AACxB,SAAK,kBAAkB,KAAK,SAAS;AACrC,iBAAa,KAAK,uBAAwB;AAC1C,SAAK,UAAU,OAAO,IAAI,oBAAoB;AAG9C,SAAK,yBAAyB,iBACtB,KAAK,UAAU,OAAO,OAAO,oBAAoB,EACvD,cACD;;AA3KD,QAAK,mBAAmB,YAAY,MAAM,KAAK,eAAe,EAAE,CAAC;AACjE,QAAK,mBAAmB,iBAAiB,MAAa,KAAK,sBAAsB,EAAE,CAAC;;;EAI/E,OAAI;AACT,OAAI,KAAK,kBAAkB,KACzB,MAAK,QAAQ,KAAK,MAAM,KAAK,gBAAgB,GAAG;;;EAK7C,WAAQ;AACb,OAAI,KAAK,kBAAkB,KACzB,MAAK,QAAQ,KAAK,MAAM,KAAK,gBAAgB,GAAG;;;EAK7C,QAAK;GACV,MAAM,cAAc,KAAK,QAAQ,OAAO;AACxC,OAAI,YACF,aAAY,OAAO;OAEnB,MAAK,iBAAiB,OAAO,CAAC,SAAS,SAAS,KAAK,OAAO,CAAC;AAE/D,QAAK,gBAAgB;AAErB,OAAI,SAAS,eAAe,QAAQ,cAAc,KAAK,KACrD,MAAK,UAAU,OAAO,OAAO;;EAIzB,cAAc,MAA2B;AAC/C,OAAI,MAAM;AACR,mBAAe,QAAQ,KAAK;AAC5B,QAAI,KAAK,OAAO;AACd,oBAAe,QAAQ,KAAK,MAAM;AAClC,SAAI,CAAC,KAAK,UAAU,KAAK,MAAM,SAC7B,QAAO;;AAGX,WAAO;SAEP,QAAO;;EAIH,QAAQ,MAA2B;AACzC,OAAI,CAAC,KAAK,cAAc,KAAK,IAAI,SAAS,KAAK,SAC7C;GAEF,MAAM,eAAe,KAAK;GAC1B,MAAM,cAAc,KAAK;GACzB,MAAM,kBAA+C;IACnD;IACA;IACA,WAAW,KAAK,kBAAkB,OAAO,KAAK,gBAAgB,IAAI;IAClE,UAAU,KAAK,kBAAkB,OAAO,KAAK,MAAM,KAAK,gBAAgB,KAAK;IAC9E;AAED,OAAI,KAAK,YAAY,CAAC,KAAK,SAAS,SAAS,gBAAgB,CAC3D;AAGc,QAAK,UACZ,UAAU;AACnB,QAAK,QAAQ;;AAGb,QAAK,cACH,IAAI,mBAAmB,KAAK,eAAe,cAAc,KAAK,UAAU,YAAY,CACrF;AAED,QAAK,gBAAgB;AACrB,QAAK,kBAAkB,KAAK;AAC5B,QAAK,sBAAsB;AAE3B,OAAI,SAAS,eAAe,QAAQ,cAAc,KAAK,KACrD,MAAK,UAAU,OAAO,OAAO;;EAIzB,iBAAc;AACpB,OACE,CAAC,KAAK,WACN,CAAC,KAAK,YACN,KAAK,kBAAkB,KAAA,KACvB,CAAC,KAAK,SAAS,MAEf;GAEF,MAAM,SACJ,KAAK,gBAAgB,eACjB,KAAK,SAAS,MAAM,aAAa,KAAK,SAAS,MAAM,cACrD,KAAK,0BAA0B;AAErC,QAAK,MAAM,YAAY,6BAA6B,GAAG,OAAM,IAAK;;;;;EAM5D,kBAAkB,MAA2B;AACnD,OAAI,QAAQ,KAAK,YAAY;IAC3B,MAAM,eAAsC,KAAK,WAAW,cAAc,YAAY;AACtF,QAAI,aACF,MAAK,OAAO,YAAY,gCAAgC,GAAG,aAAa,aAAY,IAAK;;;EAKvF,2BAAwB;AAC9B,OAAI,KAAK,kBAAkB,KACzB;GAEF,IAAI,SAAS;AACb,QAAK,MAAM,QAAQ,KAAK,OAAO;AAC7B,QAAI,SAAS,KAAK,SAChB;AAEF,aAAS,KAAK,MAAO,eAAe;;AAEtC,UACE,SACA,KAAK,SAAU,MAAO,eACtB,WAAW,iBAAiB,KAAK,CAAC,iBAAiB,yBAAyB,CAAC,GAC3E,KACA,KAAK;;EAIH,sBAAsB,GAAQ;AACpC,QAAK,kBAAkB,EAAE,OAAyB;;EAG5C,aAAU;AAChB,QAAK,MAAM,SAAS,MAAM,GAAG,UAAS;AACpC,SAAK,UAAU,KAAK,QAAQ;AAC5B,SAAK,OAAO,UAAU,IAAI,GAAG,MAAM,QAAQ,KAAK,QAAQ;KACxD;AACF,QAAK,QAAQ,KAAK,YAAY,KAAK,cAAc,GAAG;;EAG9C,gBAAa;AACnB,QAAK,MAAM,SAAS,SAAQ;AAC1B,SAAK,OAAO,KAAK,gBAAgB,eAAe,SAAS;KACzD;;EAGI,oBAAiB;AACvB,OAAI,KAAK,gBAAgB;AACvB,SAAK,cAAc,KAAK,cAAc,QAAQ,cAAc,KAAK,gBAAgB,GAC7E,eACA;AACJ,SAAK,eAAe;;AAGtB,oBAAiB,KAAK,gBAAgB,EAAE,EAAE;;EAgBpC,uBAAoB;AAC1B,QAAK,MAAM,SAAS,MAAM,UAAS;AACjC,QAAI,CAAC,KAAK,MACR;AAEF,mBAAe,QAAQ,KAAK,MAAM;AAElC,SAAK,MAAM,QACR,KAAK,UAAU,QAAQ,KAAK,iBAC1B,CAAC,KAAK,UAAU,KAAK,MAAM,QAAQ,oDAAwB,CAC/D;KACD;;EAGY,oBAAiB;AAC/B,SAAM,mBAAmB;AACzB,UAAO,iBAAiB,UAAU,KAAK,kBAAkB,EACvD,SAAS,MACV,CAAC;AACF,QAAK,YAAY,qBAAqB,CAAC,KAAK,QAAQ;;EAGtC,uBAAoB;AAClC,SAAM,sBAAsB;AAC5B,UAAO,oBAAoB,UAAU,KAAK,iBAAiB;;EAG1C,aAAa,mBAAuC;AACrE,SAAM,aAAa,kBAAkB;AACrC,QAAK,eAAe,WAAU;AAC5B,SAAK,UAAU;AACf,SAAK,YAAY;AAEjB,QAAI,KAAK,sBAAsB,KAAK,MAAM,QAAQ,KAAK,mBAAmB,KAAK,GAC7E,MAAK,gBAAgB,KAAK,MAAM,QAAQ,KAAK,mBAAmB;aACvD,KAAK,wBACd,MAAK,gBAAgB,KAAK;QAE1B,MAAK,gBAAgB;AAGvB,SAAK,UAAU,QAAQ,KAAK;AAC5B,SAAK,mBAAmB;AAExB,qBAAiB,KAAK,UAAU,OAAO,OAAO,oBAAoB,EAAE,cAAc;KAClF;;EAGe,WAAW,mBAAuC;AACnE,SAAM,WAAW,kBAAkB;AACnC,OAAI,kBAAkB,IAAI,cAAc,IAAI,CAAC,KAAK,gBAAgB;AAChE,SAAK,eAAe;AACpB,SAAK,gBAAgB;;AAEvB,OAAI,kBAAkB,IAAI,SAAS,IAAI,KAAK,QAC1C,MAAK,sBAAsB;AAG7B,OAAI,kBAAkB,IAAI,OAAO,CAC/B,MAAK,gBAAgB;;EAIjB,eAAe,KAAkB;GACvC,MAAM,eAAiC,KAAK;AAE5C,OACE,CAAC,gBAEC,IAAI,WAA2B,QAAS,IAAI,OAAuB,kBAAkB,KAEvF;AAGF,OAAI,kBAAkB,IAAI,EAAE;IAE1B,MAAM,YAAoB,oBAAoB,KADtB,aAAa,QAAQ,KAAK,SAAU,EACA,aAAa,OAAO;AAChF,SAAK,QAAQ,aAAa,WAAW;AACrC,QAAI,gBAAgB;;;EAIL,SAAM;AACvB,UAAO,IAAI;;8CAE+B,KAAK,WAAU;;;wCAGrB,KAAK,WAAU"}

package/development/stepper.js

@@ -1,6 +1,6 @@
-import { t as SbbStepLabelElement } from "./step-label.component-D3wrRPQ7.js";
-import { t as SbbStepElement } from "./step.component-ewujsOVD.js";
-import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-BJC_4cep.js";
+import { t as SbbStepLabelElement } from "./step-label.component--mgZ4YOV.js";
+import { t as SbbStepElement } from "./step.component-CxNwo99y.js";
+import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-BAuHFBuI.js";
 import "./stepper.pure.js";
 //#region src/elements/stepper.ts
 /** @entrypoint */

package/development/stepper.pure.js

@@ -1,4 +1,4 @@
-import { t as SbbStepLabelElement } from "./step-label.component-D3wrRPQ7.js";
-import { t as SbbStepElement } from "./step.component-ewujsOVD.js";
-import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-BJC_4cep.js";
+import { t as SbbStepLabelElement } from "./step-label.component--mgZ4YOV.js";
+import { t as SbbStepElement } from "./step.component-CxNwo99y.js";
+import { n as SbbStepperElement, t as SbbStepChangeEvent } from "./stepper.component-BAuHFBuI.js";
 export { SbbStepChangeEvent, SbbStepElement, SbbStepLabelElement, SbbStepperElement };