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

package/development/chip-group.component-BY025VTb.js

@@ -0,0 +1,395 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbDisabledMixin, SbbElement, SbbFormAssociatedMixin, SbbLanguageController, SbbNegativeMixin, SbbPropertyWatcherController, SbbRequiredMixin, forceType, getNextElementIndex, i18nChipGroupInputDescription, i18nSelectionRequired, isArrowKeyPressed } from "./core.js";
+import { SbbChipElement } from "./chip/chip/chip.component.js";
+//#region src/elements/chip/chip-group/chip-group.scss?inline
+var chip_group_default = ":host {\n  width: 100%;\n  display: flex;\n  flex-wrap: wrap;\n  gap: var(--sbb-chip-group-gap);\n  align-items: center;\n  margin-block: var(--sbb-chip-group-margin-block);\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n:host(:is(:is(:state(size-s),[state--size-s]), :is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: 0;\n}\n\n:host(:is(:state(size-s),[state--size-s]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-s);\n}\n\n:host(:is(:state(without-label),[state--without-label]):is(:state(size-s),[state--size-s]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-s);\n}\n\n:host(:is(:is(:state(size-l),[state--size-l]), :is(:state(size-m),[state--size-m]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-base-lm);\n}\n\n:host(:is(:state(without-label),[state--without-label]):is(:state(size-m),[state--size-m]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-m);\n}\n\n:host(:is(:state(without-label),[state--without-label]):not(:is(:state(empty),[state--empty]), :is(:state(size-s),[state--size-s]), :is(:state(size-m),[state--size-m]), :is(:state(size-l),[state--size-l]))) {\n  --sbb-chip-group-margin-block: var(--sbb-chip-group-margin-block-no-label-not-empty);\n}\n\n:host(:not(:is(:state(without-label),[state--without-label])):is(:state(size-m),[state--size-m]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-m);\n}\n\n:host(:not(:is(:state(without-label),[state--without-label]), :is(:state(empty),[state--empty]), :is(:state(size-s),[state--size-s]), :is(:state(size-m),[state--size-m]), :is(:state(size-l),[state--size-l]))) {\n  --sbb-chip-group-margin-block: var(--sbb-chip-group-margin-block-with-label-not-empty);\n}\n\n:host(:is(:state(without-label),[state--without-label]):is(:state(size-l),[state--size-l]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-l);\n}\n\n:host(:not(:is(:state(without-label),[state--without-label])):is(:state(size-l),[state--size-l]):not(:is(:state(empty),[state--empty]))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-l);\n}\n\n::slotted(input) {\n  flex: 1 1 var(--sbb-chip-group-input-min-width);\n  max-height: 1.5rem;\n}\n\n::slotted(sbb-chip) {\n  max-width: 100%;\n}";
+//#endregion
+//#region src/elements/chip/chip-group/chip-group.component.ts
+var SbbChipInputTokenEndEvent = class extends Event {
+	constructor(options) {
+		super("chipinputtokenend", {
+			cancelable: true,
+			bubbles: true,
+			composed: true
+		});
+		this.origin = options.origin;
+		this.value = options.value;
+		this.label = options.label;
+	}
+	/** Set a new value for the chip that will be created */
+	setValue(value) {
+		this.value = value;
+	}
+	/** Set a label for the chip that will be created */
+	setLabel(label) {
+		this.label = label;
+	}
+};
+/**
+* The `sbb-chip-group` component is used as a container for one or multiple `sbb-chip`.
+*
+* @slot - Use the unnamed slot to add `sbb-chip` elements.
+* @event {SbbChipInputTokenEndEvent<T>} chipinputtokenend - Notifies that a chip is about to be created. Can be prevented.
+* @overrideType value - (T = string[]) | null
+*/
+var SbbChipGroupElement = (() => {
+	let _classSuper = SbbRequiredMixin(SbbDisabledMixin(SbbNegativeMixin(SbbFormAssociatedMixin(SbbElement))));
+	let _instanceExtraInitializers = [];
+	let _set_value_decorators;
+	let _displayWith_decorators;
+	let _displayWith_initializers = [];
+	let _displayWith_extraInitializers = [];
+	let _separatorKeys_decorators;
+	let _separatorKeys_initializers = [];
+	let _separatorKeys_extraInitializers = [];
+	let _addOnBlur_decorators;
+	let _addOnBlur_initializers = [];
+	let _addOnBlur_extraInitializers = [];
+	return class SbbChipGroupElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_set_value_decorators = [property({ type: Array })];
+			_displayWith_decorators = [property({ attribute: false })];
+			_separatorKeys_decorators = [property({
+				attribute: "separator-keys",
+				type: Array
+			})];
+			_addOnBlur_decorators = [forceType(), property({
+				attribute: "add-on-blur",
+				type: Boolean
+			})];
+			__esDecorate(this, null, _set_value_decorators, {
+				kind: "setter",
+				name: "value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "value" in obj,
+					set: (obj, value) => {
+						obj.value = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _displayWith_decorators, {
+				kind: "accessor",
+				name: "displayWith",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "displayWith" in obj,
+					get: (obj) => obj.displayWith,
+					set: (obj, value) => {
+						obj.displayWith = value;
+					}
+				},
+				metadata: _metadata
+			}, _displayWith_initializers, _displayWith_extraInitializers);
+			__esDecorate(this, null, _separatorKeys_decorators, {
+				kind: "accessor",
+				name: "separatorKeys",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "separatorKeys" in obj,
+					get: (obj) => obj.separatorKeys,
+					set: (obj, value) => {
+						obj.separatorKeys = value;
+					}
+				},
+				metadata: _metadata
+			}, _separatorKeys_initializers, _separatorKeys_extraInitializers);
+			__esDecorate(this, null, _addOnBlur_decorators, {
+				kind: "accessor",
+				name: "addOnBlur",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "addOnBlur" in obj,
+					get: (obj) => obj.addOnBlur,
+					set: (obj, value) => {
+						obj.addOnBlur = value;
+					}
+				},
+				metadata: _metadata
+			}, _addOnBlur_initializers, _addOnBlur_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-chip-group";
+		}
+		static {
+			this.role = "listbox";
+		}
+		static {
+			this.styles = [unsafeCSS(chip_group_default)];
+		}
+		static {
+			this.events = {
+				input: "input",
+				change: "change",
+				chipinputtokenend: "chipinputtokenend"
+			};
+		}
+		/** Value of the form element. */
+		set value(value) {
+			value = value ?? [];
+			const oldValue = this.value;
+			const toRemove = [...oldValue];
+			for (const c of value) if (toRemove.includes(c)) toRemove.splice(toRemove.indexOf(c), 1);
+			toRemove.forEach((value) => this._chipElements().find((c) => c.value === value)?.remove());
+			const toAdd = [...value];
+			for (const c of oldValue) if (toAdd.includes(c)) toAdd.splice(toAdd.indexOf(c), 1);
+			toAdd.forEach((c) => this._createChipElement(c));
+		}
+		get value() {
+			return this._chipElements().map((c) => c.value);
+		}
+		#displayWith_accessor_storage;
+		/** Function that maps a chip's value to its display value. */
+		get displayWith() {
+			return this.#displayWith_accessor_storage;
+		}
+		set displayWith(value) {
+			this.#displayWith_accessor_storage = value;
+		}
+		#separatorKeys_accessor_storage;
+		/** The array of keys that will trigger a `chipinputtokenend` event. Default `['Enter']` */
+		get separatorKeys() {
+			return this.#separatorKeys_accessor_storage;
+		}
+		set separatorKeys(value) {
+			this.#separatorKeys_accessor_storage = value;
+		}
+		#addOnBlur_accessor_storage;
+		/** Whether to automatically add a chip when the input loses focus if there's a value. */
+		get addOnBlur() {
+			return this.#addOnBlur_accessor_storage;
+		}
+		set addOnBlur(value) {
+			this.#addOnBlur_accessor_storage = value;
+		}
+		constructor() {
+			super();
+			this.#displayWith_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _displayWith_initializers, null));
+			this.#separatorKeys_accessor_storage = (__runInitializers(this, _displayWith_extraInitializers), __runInitializers(this, _separatorKeys_initializers, ["Enter"]));
+			this.#addOnBlur_accessor_storage = (__runInitializers(this, _separatorKeys_extraInitializers), __runInitializers(this, _addOnBlur_initializers, false));
+			/**
+			* Listens to the changes on `readonly` and `disabled` attributes of `<input>`.
+			*/
+			this._inputAttributeObserver = (__runInitializers(this, _addOnBlur_extraInitializers), !isServer ? new MutationObserver(() => this._reactToInputChanges()) : null);
+			this._language = new SbbLanguageController(this);
+			this._previousSize = null;
+			this.addEventListener?.(SbbChipElement.events.requestdelete, (ev) => this._deleteChip(ev.target));
+			this.addEventListener?.("keydown", (ev) => this._onChipKeyDown(ev));
+			this.addController(new SbbPropertyWatcherController(this, () => this.closest("sbb-form-field"), {
+				size: (formField) => this._updateSize(formField.size),
+				label: (formField) => this._updateLabelState(formField),
+				hiddenLabel: (formField) => this._updateLabelState(formField)
+			}));
+		}
+		_updateLabelState(formField) {
+			this.toggleState("without-label", !formField.label || formField.hiddenLabel);
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this._setupComponent();
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("disabled") || changedProperties.has("formDisabled") || changedProperties.has("negative")) this._proxyStateToChips();
+		}
+		/** @internal */
+		formResetCallback() {
+			this.value = null;
+		}
+		/** @internal */
+		formStateRestoreCallback(state, _reason) {
+			if (!state) {
+				this.value = null;
+				return;
+			}
+			this._readFormData(state).then((array) => this.value = array);
+		}
+		async _readFormData(formData) {
+			return Promise.all(formData.getAll(this.name).map(async (entry) => entry instanceof Blob ? JSON.parse(await entry.text()) : entry));
+		}
+		shouldValidate(name) {
+			return super.shouldValidate(name) || name === "required" || name === "value";
+		}
+		validate() {
+			super.validate();
+			if (this.required && this.value.length === 0) this.setValidityFlag("valueMissing", i18nSelectionRequired[this._language.current]);
+			else this.removeValidityFlag("valueMissing");
+		}
+		/** Return the list of chip elements **/
+		_chipElements() {
+			return Array.from(this.querySelectorAll?.("sbb-chip") ?? []);
+		}
+		/** Return the list of enabled chip elements **/
+		_enabledChipElements() {
+			return Array.from(this.querySelectorAll?.("sbb-chip:not([disabled])") ?? []);
+		}
+		_setupComponent() {
+			const input = this.querySelector("input");
+			if (input && input !== this._inputElement) {
+				this._inputAbortController?.abort();
+				this._inputAttributeObserver?.disconnect();
+				this._inputElement = input;
+				this._inputAbortController = new AbortController();
+				this._inputElement.addEventListener("keydown", (ev) => this._onInputKeyDown(ev), { signal: this._inputAbortController.signal });
+				this._inputElement.addEventListener("blur", () => this._onInputBlur(), {
+					signal: this._inputAbortController.signal,
+					capture: true
+				});
+				this._inputElement.addEventListener("inputAutocomplete", (event) => this._createChipFromInput("autocomplete", event.option.value), { signal: this._inputAbortController.signal });
+				this._inputAttributeObserver?.observe(this._inputElement, {
+					attributes: true,
+					attributeFilter: ["readonly", "disabled"]
+				});
+			}
+			if (!this.closest("sbb-form-field")) this._updateSize(null);
+			this.toggleState("empty", this.value.length === 0);
+			this._reactToInputChanges();
+			this._updateInputDescription();
+			this.updateFormValue();
+		}
+		/**
+		* Listen for keyboard events on the chip elements
+		**/
+		_onChipKeyDown(event) {
+			const eventTarget = event.target;
+			if (eventTarget.localName !== "sbb-chip") return;
+			if (isArrowKeyPressed(event)) {
+				const focusSteps = this._enabledChipElements();
+				focusSteps[getNextElementIndex(event, focusSteps.indexOf(eventTarget), focusSteps.length)].focus();
+				return;
+			}
+			switch (event.key) {
+				case "Backspace":
+				case "Delete":
+					if (!eventTarget.readOnly && !eventTarget.disabled) {
+						event.preventDefault();
+						this._deleteChip(eventTarget);
+					}
+					break;
+			}
+		}
+		/**
+		* Listen for keyboard events on the input
+		**/
+		_onInputKeyDown(event) {
+			switch (event.key) {
+				case "Backspace":
+				case "ArrowLeft":
+					if (!this._inputElement.value) this._focusChip();
+					break;
+				case "Enter":
+					event.preventDefault();
+					break;
+			}
+			if (this.separatorKeys.includes(event.key)) {
+				event.preventDefault();
+				this._createChipFromInput("input");
+			}
+		}
+		/**
+		* Handle blur event on the input
+		**/
+		_onInputBlur() {
+			if (this.addOnBlur) this._createChipFromInput("input");
+		}
+		/**
+		* If the input is not empty, create a chip with its value
+		*/
+		_createChipFromInput(origin = "input", value) {
+			const inputValue = value ?? this._inputElement.value.trim();
+			if (!inputValue) return;
+			const event = new SbbChipInputTokenEndEvent({
+				origin,
+				value: inputValue,
+				label: (value ? this.displayWith?.(value) : null) ?? void 0
+			});
+			if (!this.dispatchEvent(event)) return;
+			this._createChipElement(event.value, event.label);
+			this._inputElement.value = "";
+			this._emitInputEvents();
+		}
+		_deleteChip(chip) {
+			const chips = this._enabledChipElements();
+			chip.remove();
+			this._emitInputEvents();
+			this._focusChip(chips.indexOf(chip));
+		}
+		/**
+		* Focus an enabled chip. If none are present, focus the input
+		* @param index The index of the enabled chip. If null, focus the last one.
+		*/
+		_focusChip(index) {
+			const enabledChips = this._enabledChipElements();
+			if (index !== void 0 && enabledChips[index]) {
+				enabledChips[index].focus();
+				return;
+			}
+			if (enabledChips.length > 0) {
+				enabledChips[enabledChips.length - 1].focus();
+				return;
+			}
+			this._inputElement?.focus();
+		}
+		_emitInputEvents() {
+			/** The input event fires when the value has been changed as a direct result of a user action. */
+			this.dispatchEvent(new InputEvent("input", {
+				bubbles: true,
+				composed: true
+			}));
+			/**
+			* The change event is fired when the user modifies the element's value.
+			* Unlike the input event, the change event is not necessarily fired
+			* for each alteration to an element's value.
+			*/
+			this.dispatchEvent(new Event("change", { bubbles: true }));
+		}
+		_createChipElement(value, label) {
+			if (isServer) return;
+			const newChip = document.createElement("sbb-chip");
+			newChip.value = value;
+			newChip.innerText = label ?? (value ? this.displayWith?.(value) : null) ?? "";
+			this.insertBefore(newChip, this._inputElement ?? this.querySelector("input"));
+		}
+		_reactToInputChanges() {
+			this.disabled = this._inputElement?.disabled ?? false;
+			this._proxyStateToChips();
+		}
+		_proxyStateToChips() {
+			this._chipElements().forEach((c) => {
+				c.disabled = this.disabled || this.formDisabled;
+				c.readOnly = this._inputElement?.hasAttribute("readonly") ?? false;
+				c.negative = this.negative;
+			});
+		}
+		_updateSize(size) {
+			if (this._previousSize) this.internals.states.delete(`size-${this._previousSize}`);
+			this._previousSize = size;
+			if (this._previousSize) this.internals.states.add(`size-${this._previousSize}`);
+		}
+		_updateInputDescription() {
+			if (!this._inputElement) return;
+			this._inputElement.setAttribute("aria-description", `${i18nChipGroupInputDescription[this._language.current]} ${this.value.length}`);
+		}
+		render() {
+			return html`<slot @slotchange=${this._setupComponent}></slot>`;
+		}
+	};
+})();
+//#endregion
+export { SbbChipInputTokenEndEvent as n, SbbChipGroupElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chip-group.component-BY025VTb.js","names":[],"sources":["../../../src/elements/chip/chip-group/chip-group.scss?inline","../../../src/elements/chip/chip-group/chip-group.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  width: 100%;\n  display: flex;\n  flex-wrap: wrap;\n  gap: var(--sbb-chip-group-gap);\n  align-items: center;\n  margin-block: var(--sbb-chip-group-margin-block);\n\n  // Set the line-height for adjacent elements in order to prevent from influence of a consumer-set line-height.\n  line-height: var(--sbb-typo-line-height-text);\n}\n\n:host(:is(:state(size-s), :state(empty))) {\n  --sbb-chip-group-margin-block: 0;\n}\n\n:host(:state(size-s):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-s);\n}\n\n:host(:state(without-label):state(size-s):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-s);\n}\n\n:host(:is(:state(size-l), :state(size-m))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-base-lm);\n}\n\n:host(:state(without-label):state(size-m):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-m);\n}\n\n:host(:state(without-label):not(:state(empty), :state(size-s), :state(size-m), :state(size-l))) {\n  --sbb-chip-group-margin-block: var(--sbb-chip-group-margin-block-no-label-not-empty);\n}\n\n:host(:not(:state(without-label)):state(size-m):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-m);\n}\n\n:host(:not(:state(without-label), :state(empty), :state(size-s), :state(size-m), :state(size-l))) {\n  --sbb-chip-group-margin-block: var(--sbb-chip-group-margin-block-with-label-not-empty);\n}\n\n:host(:state(without-label):state(size-l):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-without-label-l);\n}\n\n:host(:not(:state(without-label)):state(size-l):not(:state(empty))) {\n  --sbb-chip-group-margin-block: var(--_sbb-chip-group-margin-block-with-label-l);\n}\n\n::slotted(input) {\n  flex: 1 1 var(--sbb-chip-group-input-min-width);\n  max-height: #{sbb.px-to-rem-build(24)};\n}\n\n::slotted(sbb-chip) {\n  max-width: 100%;\n}\n","import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport type { SbbInputAutocompleteEvent } from '../../autocomplete/autocomplete-base-element.ts';\nimport {\n  forceType,\n  type FormRestoreReason,\n  type FormRestoreState,\n  getNextElementIndex,\n  i18nChipGroupInputDescription,\n  i18nSelectionRequired,\n  isArrowKeyPressed,\n  SbbDisabledMixin,\n  SbbElement,\n  SbbFormAssociatedMixin,\n  SbbLanguageController,\n  SbbNegativeMixin,\n  SbbPropertyWatcherController,\n  SbbRequiredMixin,\n} from '../../core.ts';\nimport type { SbbFormFieldElement } from '../../form-field/form-field/form-field.component.ts';\nimport { SbbChipElement } from '../chip/chip.component.ts';\n\nimport style from './chip-group.scss?inline';\n\nlet displayWithWarningLogged = false;\n\nexport class SbbChipInputTokenEndEvent<T = string> extends Event {\n  /** The element that triggered the chip creation */\n  public origin: 'input' | 'autocomplete';\n  /**\n   * The value of the new chip. Either the input or the option value depending on the origin.\n   * Either the value from the input which is always `string` or the value from the selected option\n   * from an autocomplete, which can be either a string or any other type.\n   */\n  public value: T | string;\n  public label?: string;\n\n  public constructor(options: Pick<SbbChipInputTokenEndEvent, 'origin' | 'value' | 'label'>) {\n    super('chipinputtokenend', {\n      cancelable: true,\n      bubbles: true,\n      composed: true,\n    });\n    this.origin = options.origin;\n    this.value = options.value;\n    this.label = options.label;\n  }\n\n  /** Set a new value for the chip that will be created */\n  public setValue(value: T): void {\n    this.value = value;\n  }\n  /** Set a label for the chip that will be created */\n  public setLabel(label: string): void {\n    this.label = label;\n  }\n}\n\n/**\n * The `sbb-chip-group` component is used as a container for one or multiple `sbb-chip`.\n *\n * @slot - Use the unnamed slot to add `sbb-chip` elements.\n * @event {SbbChipInputTokenEndEvent<T>} chipinputtokenend - Notifies that a chip is about to be created. Can be prevented.\n * @overrideType value - (T = string[]) | null\n */\nexport class SbbChipGroupElement<T = string> extends SbbRequiredMixin(\n  SbbDisabledMixin(SbbNegativeMixin(SbbFormAssociatedMixin(SbbElement))),\n) {\n  public static override readonly elementName: string = 'sbb-chip-group';\n  public static override readonly role = 'listbox';\n  public static override styles: CSSResultGroup = [unsafeCSS(style)];\n  public static readonly events = {\n    input: 'input',\n    change: 'change',\n    chipinputtokenend: 'chipinputtokenend',\n  } as const;\n\n  /** Value of the form element. */\n  @property({ type: Array })\n  public set value(value: (T | null)[] | null) {\n    value = value ?? [];\n    const oldValue = this.value;\n\n    // Subtract from 'oldValue' the new 'value'\n    // The result are the chips to remove (handle duplicates)\n    const toRemove = [...oldValue];\n    for (const c of value) {\n      if (toRemove.includes(c)) {\n        toRemove.splice(toRemove.indexOf(c), 1);\n      }\n    }\n    toRemove.forEach((value) =>\n      this._chipElements()\n        .find((c) => c.value === value)\n        ?.remove(),\n    );\n\n    // Subtract from the new 'value' what was already present\n    // The result are the new chips to add (handle duplicates)\n    const toAdd = [...value];\n    for (const c of oldValue) {\n      if (toAdd.includes(c)) {\n        toAdd.splice(toAdd.indexOf(c), 1);\n      }\n    }\n    toAdd.forEach((c) => this._createChipElement(c));\n  }\n  public get value(): (T | null)[] {\n    return this._chipElements().map((c) => c.value);\n  }\n\n  /** Function that maps a chip's value to its display value. */\n  @property({ attribute: false })\n  public accessor displayWith: ((value: T) => string) | null = null;\n\n  /** The array of keys that will trigger a `chipinputtokenend` event. Default `['Enter']` */\n  @property({ attribute: 'separator-keys', type: Array })\n  public accessor separatorKeys: string[] = ['Enter'];\n\n  /** Whether to automatically add a chip when the input loses focus if there's a value. */\n  @forceType()\n  @property({ attribute: 'add-on-blur', type: Boolean })\n  public accessor addOnBlur: boolean = false;\n\n  /**\n   * Listens to the changes on `readonly` and `disabled` attributes of `<input>`.\n   */\n  private _inputAttributeObserver = !isServer\n    ? new MutationObserver(() => this._reactToInputChanges())\n    : null;\n\n  private _inputElement: HTMLInputElement | undefined;\n  private _inputAbortController: AbortController | undefined;\n  private _language = new SbbLanguageController(this);\n  private _previousSize: SbbFormFieldElement['size'] = null;\n\n  public constructor() {\n    super();\n\n    this.addEventListener?.(SbbChipElement.events.requestdelete, (ev) =>\n      this._deleteChip(ev.target as SbbChipElement<T>),\n    );\n\n    this.addEventListener?.('keydown', (ev) => this._onChipKeyDown(ev));\n\n    this.addController(\n      new SbbPropertyWatcherController(this, () => this.closest('sbb-form-field'), {\n        size: (formField) => this._updateSize(formField.size),\n        label: (formField) => this._updateLabelState(formField),\n        hiddenLabel: (formField) => this._updateLabelState(formField),\n      }),\n    );\n  }\n\n  private _updateLabelState(formField: SbbFormFieldElement): void {\n    this.toggleState('without-label', !formField.label || formField.hiddenLabel);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this._setupComponent();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues): void {\n    super.willUpdate(changedProperties);\n\n    if (\n      changedProperties.has('disabled') ||\n      changedProperties.has('formDisabled') ||\n      changedProperties.has('negative')\n    ) {\n      this._proxyStateToChips();\n    }\n  }\n\n  /** @internal */\n  public formResetCallback(): void {\n    this.value = null;\n  }\n\n  /** @internal */\n  public formStateRestoreCallback(\n    state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {\n    if (!state) {\n      this.value = null;\n      return;\n    }\n\n    this._readFormData(state as FormData).then((array) => (this.value = array));\n  }\n\n  private async _readFormData(formData: FormData): Promise<T[]> {\n    return Promise.all(\n      formData\n        .getAll(this.name)\n        .map(async (entry) =>\n          entry instanceof Blob ? JSON.parse(await entry.text()) : (entry as T),\n        ),\n    );\n  }\n\n  protected override shouldValidate(name: PropertyKey | undefined): boolean {\n    return super.shouldValidate(name) || name === 'required' || name === 'value';\n  }\n\n  protected override validate(): void {\n    super.validate();\n    if (this.required && this.value.length === 0) {\n      this.setValidityFlag('valueMissing', i18nSelectionRequired[this._language.current]);\n    } else {\n      this.removeValidityFlag('valueMissing');\n    }\n  }\n\n  /** Return the list of chip elements **/\n  private _chipElements(): SbbChipElement<T>[] {\n    return Array.from(this.querySelectorAll?.<SbbChipElement<T>>('sbb-chip') ?? []);\n  }\n\n  /** Return the list of enabled chip elements **/\n  private _enabledChipElements(): SbbChipElement<T>[] {\n    return Array.from(this.querySelectorAll?.('sbb-chip:not([disabled])') ?? []);\n  }\n\n  private _setupComponent(): void {\n    const input = this.querySelector('input');\n\n    // Connect to the input\n    if (input && input !== this._inputElement) {\n      this._inputAbortController?.abort();\n      this._inputAttributeObserver?.disconnect();\n      this._inputElement = input;\n\n      this._inputAbortController = new AbortController();\n      this._inputElement.addEventListener('keydown', (ev) => this._onInputKeyDown(ev), {\n        signal: this._inputAbortController.signal,\n      });\n      this._inputElement.addEventListener('blur', () => this._onInputBlur(), {\n        signal: this._inputAbortController.signal,\n        capture: true,\n      });\n      this._inputElement.addEventListener(\n        'inputAutocomplete',\n        (event: SbbInputAutocompleteEvent<T>) =>\n          this._createChipFromInput('autocomplete', event.option.value),\n        {\n          signal: this._inputAbortController.signal,\n        },\n      );\n\n      this._inputAttributeObserver?.observe(this._inputElement, {\n        attributes: true,\n        attributeFilter: ['readonly', 'disabled'],\n      });\n    }\n\n    // If there is no form-field, reset size\n    if (!this.closest('sbb-form-field')) {\n      this._updateSize(null);\n    }\n\n    this.toggleState('empty', this.value.length === 0);\n    this._reactToInputChanges();\n    this._updateInputDescription();\n    this.updateFormValue();\n  }\n\n  /**\n   * Listen for keyboard events on the chip elements\n   **/\n  private _onChipKeyDown(event: KeyboardEvent): void {\n    const eventTarget = event.target as SbbChipElement<T>;\n    if (eventTarget.localName !== 'sbb-chip') {\n      return;\n    }\n\n    // Arrow keys allow navigation between chips focus steps\n    if (isArrowKeyPressed(event)) {\n      const focusSteps = this._enabledChipElements();\n      const next = getNextElementIndex(event, focusSteps.indexOf(eventTarget), focusSteps.length);\n      focusSteps[next].focus();\n      return;\n    }\n\n    switch (event.key) {\n      case 'Backspace':\n      case 'Delete':\n        if (!eventTarget.readOnly && !eventTarget.disabled) {\n          event.preventDefault();\n          this._deleteChip(eventTarget);\n        }\n        break;\n    }\n  }\n\n  /**\n   * Listen for keyboard events on the input\n   **/\n  private _onInputKeyDown(event: KeyboardEvent): void {\n    switch (event.key) {\n      case 'Backspace':\n      case 'ArrowLeft':\n        if (!this._inputElement!.value) {\n          this._focusChip();\n        }\n        break;\n      case 'Enter':\n        event.preventDefault(); // Prevents the form submit\n        break;\n    }\n\n    // if the user typed one of the separator keys, trigger a 'chipinputtokenend' event\n    if (this.separatorKeys.includes(event.key)) {\n      event.preventDefault(); // prevent typing the separator key into the input\n      this._createChipFromInput('input');\n    }\n  }\n\n  /**\n   * Handle blur event on the input\n   **/\n  private _onInputBlur(): void {\n    if (this.addOnBlur) {\n      this._createChipFromInput('input');\n    }\n  }\n\n  /**\n   * If the input is not empty, create a chip with its value\n   */\n  private _createChipFromInput(origin: 'input' | 'autocomplete' = 'input', value?: T): void {\n    const inputValue = value ?? this._inputElement!.value.trim();\n    if (!inputValue) {\n      return;\n    }\n\n    const event = new SbbChipInputTokenEndEvent<T>({\n      origin,\n      value: inputValue as string,\n      label: (value ? this.displayWith?.(value) : null) ?? undefined,\n    });\n    if (!this.dispatchEvent(event)) {\n      return; // event prevented; do nothing (the consumer has to create the chip)\n    }\n\n    this._createChipElement(event.value as T, event.label);\n    this._inputElement!.value = ''; // Empty the input\n    this._emitInputEvents();\n  }\n\n  private _deleteChip(chip: SbbChipElement<T>): void {\n    const chips = this._enabledChipElements();\n    chip.remove();\n    this._emitInputEvents();\n    this._focusChip(chips.indexOf(chip)); // Focus the next chip\n  }\n\n  /**\n   * Focus an enabled chip. If none are present, focus the input\n   * @param index The index of the enabled chip. If null, focus the last one.\n   */\n  private _focusChip(index?: number): void {\n    const enabledChips = this._enabledChipElements();\n\n    if (index !== undefined && enabledChips[index]) {\n      enabledChips[index].focus();\n      return;\n    }\n\n    if (enabledChips.length > 0) {\n      enabledChips[enabledChips.length - 1].focus();\n      return;\n    }\n\n    this._inputElement?.focus();\n  }\n\n  private _emitInputEvents(): void {\n    /** The input event fires when the value has been changed as a direct result of a user action. */\n    this.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n\n    /**\n     * The change event is fired when the user modifies the element's value.\n     * Unlike the input event, the change event is not necessarily fired\n     * for each alteration to an element's value.\n     */\n    this.dispatchEvent(new Event('change', { bubbles: true }));\n  }\n\n  private _createChipElement(value: T | null, label?: string): void {\n    if (isServer) {\n      return;\n    }\n    const newChip = document.createElement('sbb-chip') as SbbChipElement<T>;\n    newChip.value = value;\n    newChip.innerText = label ?? (value ? this.displayWith?.(value) : null) ?? '';\n    if (\n      import.meta.env.DEV &&\n      !displayWithWarningLogged &&\n      !label &&\n      typeof value === 'object' &&\n      !this.displayWith\n    ) {\n      console.warn(\n        `displayWith has not been set yet for sbb-chip-group and value is an object.\n         If you are using object values, you need to provide displayWidth before\n         setting or selecting any value.`,\n      );\n      displayWithWarningLogged = true;\n    }\n    this.insertBefore(newChip, this._inputElement ?? this.querySelector('input'));\n  }\n\n  private _reactToInputChanges(): void {\n    this.disabled = this._inputElement?.disabled ?? false;\n    this._proxyStateToChips();\n  }\n\n  private _proxyStateToChips(): void {\n    this._chipElements().forEach((c) => {\n      c.disabled = this.disabled || this.formDisabled;\n      c.readOnly = this._inputElement?.hasAttribute('readonly') ?? false;\n      c.negative = this.negative;\n    });\n  }\n\n  private _updateSize(size: SbbFormFieldElement['size']): void {\n    if (this._previousSize) {\n      this.internals.states.delete(`size-${this._previousSize}`);\n    }\n    this._previousSize = size;\n    if (this._previousSize) {\n      this.internals.states.add(`size-${this._previousSize}`);\n    }\n  }\n\n  private _updateInputDescription(): void {\n    if (!this._inputElement) {\n      return;\n    }\n    this._inputElement.setAttribute(\n      'aria-description',\n      `${i18nChipGroupInputDescription[this._language.current]} ${this.value.length}`,\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`<slot @slotchange=${this._setupComponent}></slot>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-chip-group': SbbChipGroupElement;\n  }\n\n  interface HTMLElementEventMap {\n    chipinputtokenend: SbbChipInputTokenEndEvent<any>;\n  }\n}\n"],"mappings":";;;;;;;;;ACkCA,IAAa,4BAAb,cAA2D,MAAK;CAW9D,YAAmB,SAAsE;EACvF,MAAM,qBAAqB;GACzB,YAAY;GACZ,SAAS;GACT,UAAU;GACX;EACD,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,QAAQ,QAAQ;CACvB;;CAGO,SAAS,OAAQ;EACtB,KAAK,QAAQ;CACf;;CAEO,SAAS,OAAa;EAC3B,KAAK,QAAQ;CACf;;;;;;;;;IAUW,6BAAmB;mBAAqB,iBACnD,iBAAiB,iBAAiB,uBAAuB,UAAU,CAAC,CAAC,CAAC;;;;;;;;;;;;cAD3D,4BAAwC,YAEpD;;;4BAWE,SAAS,EAAE,MAAM,MAAK,CAAE,CAAC;8BAkCzB,SAAS,EAAE,WAAW,MAAK,CAAE,CAAC;gCAI9B,SAAS;IAAE,WAAW;IAAkB,MAAM;GAAK,CAAE,CAAC;4BAItD,UAAS,GACT,SAAS;IAAE,WAAW;IAAe,MAAM;GAAO,CAAE,CAAC;GA1CtD,aAAA,MAAA,MAAA,uBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,WAAA;KAAA,MAAA,KAAA,UAAA;MAAA,IAAW,QAAK;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,MAAA,0BAAA;GAkChB,aAAA,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;MAAA,IAAX,cAAW;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,2BAAA,8BAAA;GAI3B,aAAA,MAAA,MAAA,2BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,mBAAA;KAAA,MAAA,QAAA,IAAgB;KAAa,MAAA,KAAA,UAAA;MAAA,IAAb,gBAAa;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,6BAAA,gCAAA;GAK7B,aAAA,MAAA,MAAA,uBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,eAAA;KAAA,MAAA,QAAA,IAAgB;KAAS,MAAA,KAAA,UAAA;MAAA,IAAT,YAAS;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,yBAAA,4BAAA;;;;;;;;;GAtDO,KAAA,cAAsB;EAAiB;;GACvC,KAAA,OAAO;EAAU;;GAC1B,KAAA,SAAyB,CAAC,UAAU,kBAAK,CAAC;EAAE;;GAC5C,KAAA,SAAS;IAC9B,OAAO;IACP,QAAQ;IACR,mBAAmB;;EACV;;EAIX,IAAW,MAAM,OAA0B;GACzC,QAAQ,SAAS,CAAA;GACjB,MAAM,WAAW,KAAK;GAItB,MAAM,WAAW,CAAC,GAAG,QAAQ;GAC7B,KAAK,MAAM,KAAK,OACd,IAAI,SAAS,SAAS,CAAC,GACrB,SAAS,OAAO,SAAS,QAAQ,CAAC,GAAG,CAAC;GAG1C,SAAS,SAAS,UAChB,KAAK,cAAa,EACf,MAAM,MAAM,EAAE,UAAU,KAAK,GAC5B,OAAM,CAAE;GAKd,MAAM,QAAQ,CAAC,GAAG,KAAK;GACvB,KAAK,MAAM,KAAK,UACd,IAAI,MAAM,SAAS,CAAC,GAClB,MAAM,OAAO,MAAM,QAAQ,CAAC,GAAG,CAAC;GAGpC,MAAM,SAAS,MAAM,KAAK,mBAAmB,CAAC,CAAC;EACjD;EACA,IAAW,QAAK;GACd,OAAO,KAAK,cAAa,EAAG,KAAK,MAAM,EAAE,KAAK;EAChD;EAIA;;EAAA,IAAgB,cAAW;GAAA,OAAA,KAAA;EAAA;EAA3B,IAAgB,YAAW,OAAA;GAAA,KAAA,gCAAA;EAAA;EAI3B;;EAAA,IAAgB,gBAAa;GAAA,OAAA,KAAA;EAAA;EAA7B,IAAgB,cAAa,OAAA;GAAA,KAAA,kCAAA;EAAA;EAK7B;;EAAA,IAAgB,YAAS;GAAA,OAAA,KAAA;EAAA;EAAzB,IAAgB,UAAS,OAAA;GAAA,KAAA,8BAAA;EAAA;EAczB,cAAA;GACE,MAAK;GAxBS,KAAA,iCAhDL,kBAAA,MAAA,0BAAA,GAAmB,kBAAA,MAAA,2BAgD+B,IAAI;GAIjD,KAAA,mCAAA,kBAAA,MAAA,8BAAA,GAAA,kBAAA,MAAA,6BAA0B,CAAC,OAAO,CAAC;GAKnC,KAAA,+BAAA,kBAAA,MAAA,gCAAA,GAAA,kBAAA,MAAA,yBAAqB,KAAK;;;;GAKlC,KAAA,2BAAuB,kBAAA,MAAA,4BAAA,GAAG,CAAC,WAC/B,IAAI,uBAAuB,KAAK,qBAAoB,CAAE,IACtD;GAII,KAAA,YAAY,IAAI,sBAAsB,IAAI;GAC1C,KAAA,gBAA6C;GAKnD,KAAK,mBAAmB,eAAe,OAAO,gBAAgB,OAC5D,KAAK,YAAY,GAAG,MAA2B,CAAC;GAGlD,KAAK,mBAAmB,YAAY,OAAO,KAAK,eAAe,EAAE,CAAC;GAElE,KAAK,cACH,IAAI,6BAA6B,YAAY,KAAK,QAAQ,gBAAgB,GAAG;IAC3E,OAAO,cAAc,KAAK,YAAY,UAAU,IAAI;IACpD,QAAQ,cAAc,KAAK,kBAAkB,SAAS;IACtD,cAAc,cAAc,KAAK,kBAAkB,SAAS;IAC7D,CAAC;EAEN;EAEQ,kBAAkB,WAA8B;GACtD,KAAK,YAAY,iBAAiB,CAAC,UAAU,SAAS,UAAU,WAAW;EAC7E;EAEgB,oBAAiB;GAC/B,MAAM,kBAAiB;GACvB,KAAK,gBAAe;EACtB;EAEmB,WAAW,mBAAiC;GAC7D,MAAM,WAAW,iBAAiB;GAElC,IACE,kBAAkB,IAAI,UAAU,KAChC,kBAAkB,IAAI,cAAc,KACpC,kBAAkB,IAAI,UAAU,GAEhC,KAAK,mBAAkB;EAE3B;;EAGO,oBAAiB;GACtB,KAAK,QAAQ;EACf;;EAGO,yBACL,OACA,SAA0B;GAE1B,IAAI,CAAC,OAAO;IACV,KAAK,QAAQ;IACb;GACF;GAEA,KAAK,cAAc,KAAiB,EAAE,MAAM,UAAW,KAAK,QAAQ,KAAM;EAC5E;EAEQ,MAAM,cAAc,UAAkB;GAC5C,OAAO,QAAQ,IACb,SACG,OAAO,KAAK,IAAI,EAChB,IAAI,OAAO,UACV,iBAAiB,OAAO,KAAK,MAAM,MAAM,MAAM,KAAI,CAAE,IAAK,KAAW,CACtE;EAEP;EAEmB,eAAe,MAA6B;GAC7D,OAAO,MAAM,eAAe,IAAI,KAAK,SAAS,cAAc,SAAS;EACvE;EAEmB,WAAQ;GACzB,MAAM,SAAQ;GACd,IAAI,KAAK,YAAY,KAAK,MAAM,WAAW,GACzC,KAAK,gBAAgB,gBAAgB,sBAAsB,KAAK,UAAU,QAAQ;QAElF,KAAK,mBAAmB,cAAc;EAE1C;;EAGQ,gBAAa;GACnB,OAAO,MAAM,KAAK,KAAK,mBAAsC,UAAU,KAAK,CAAA,CAAE;EAChF;;EAGQ,uBAAoB;GAC1B,OAAO,MAAM,KAAK,KAAK,mBAAmB,0BAA0B,KAAK,CAAA,CAAE;EAC7E;EAEQ,kBAAe;GACrB,MAAM,QAAQ,KAAK,cAAc,OAAO;GAGxC,IAAI,SAAS,UAAU,KAAK,eAAe;IACzC,KAAK,uBAAuB,MAAK;IACjC,KAAK,yBAAyB,WAAU;IACxC,KAAK,gBAAgB;IAErB,KAAK,wBAAwB,IAAI,gBAAe;IAChD,KAAK,cAAc,iBAAiB,YAAY,OAAO,KAAK,gBAAgB,EAAE,GAAG,EAC/E,QAAQ,KAAK,sBAAsB,OAAA,CACpC;IACD,KAAK,cAAc,iBAAiB,cAAc,KAAK,aAAY,GAAI;KACrE,QAAQ,KAAK,sBAAsB;KACnC,SAAS;KACV;IACD,KAAK,cAAc,iBACjB,sBACC,UACC,KAAK,qBAAqB,gBAAgB,MAAM,OAAO,KAAK,GAC9D,EACE,QAAQ,KAAK,sBAAsB,OAAA,CACpC;IAGH,KAAK,yBAAyB,QAAQ,KAAK,eAAe;KACxD,YAAY;KACZ,iBAAiB,CAAC,YAAY,UAAU;KACzC;GACH;GAGA,IAAI,CAAC,KAAK,QAAQ,gBAAgB,GAChC,KAAK,YAAY,IAAI;GAGvB,KAAK,YAAY,SAAS,KAAK,MAAM,WAAW,CAAC;GACjD,KAAK,qBAAoB;GACzB,KAAK,wBAAuB;GAC5B,KAAK,gBAAe;EACtB;;;;EAKQ,eAAe,OAAoB;GACzC,MAAM,cAAc,MAAM;GAC1B,IAAI,YAAY,cAAc,YAC5B;GAIF,IAAI,kBAAkB,KAAK,GAAG;IAC5B,MAAM,aAAa,KAAK,qBAAoB;IAE5C,WADa,oBAAoB,OAAO,WAAW,QAAQ,WAAW,GAAG,WAAW,MACzE,GAAM,MAAK;IACtB;GACF;GAEA,QAAQ,MAAM,KAAd;IACE,KAAK;IACL,KAAK;KACH,IAAI,CAAC,YAAY,YAAY,CAAC,YAAY,UAAU;MAClD,MAAM,eAAc;MACpB,KAAK,YAAY,WAAW;KAC9B;KACA;GACJ;EACF;;;;EAKQ,gBAAgB,OAAoB;GAC1C,QAAQ,MAAM,KAAd;IACE,KAAK;IACL,KAAK;KACH,IAAI,CAAC,KAAK,cAAe,OACvB,KAAK,WAAU;KAEjB;IACF,KAAK;KACH,MAAM,eAAc;KACpB;GACJ;GAGA,IAAI,KAAK,cAAc,SAAS,MAAM,GAAG,GAAG;IAC1C,MAAM,eAAc;IACpB,KAAK,qBAAqB,OAAO;GACnC;EACF;;;;EAKQ,eAAY;GAClB,IAAI,KAAK,WACP,KAAK,qBAAqB,OAAO;EAErC;;;;EAKQ,qBAAqB,SAAmC,SAAS,OAAS;GAChF,MAAM,aAAa,SAAS,KAAK,cAAe,MAAM,KAAI;GAC1D,IAAI,CAAC,YACH;GAGF,MAAM,QAAQ,IAAI,0BAA6B;IAC7C;IACA,OAAO;IACP,QAAQ,QAAQ,KAAK,cAAc,KAAK,IAAI,SAAS,KAAA;IACtD;GACD,IAAI,CAAC,KAAK,cAAc,KAAK,GAC3B;GAGF,KAAK,mBAAmB,MAAM,OAAY,MAAM,KAAK;GACrD,KAAK,cAAe,QAAQ;GAC5B,KAAK,iBAAgB;EACvB;EAEQ,YAAY,MAAuB;GACzC,MAAM,QAAQ,KAAK,qBAAoB;GACvC,KAAK,OAAM;GACX,KAAK,iBAAgB;GACrB,KAAK,WAAW,MAAM,QAAQ,IAAI,CAAC;EACrC;;;;;EAMQ,WAAW,OAAc;GAC/B,MAAM,eAAe,KAAK,qBAAoB;GAE9C,IAAI,UAAU,KAAA,KAAa,aAAa,QAAQ;IAC9C,aAAa,OAAO,MAAK;IACzB;GACF;GAEA,IAAI,aAAa,SAAS,GAAG;IAC3B,aAAa,aAAa,SAAS,GAAG,MAAK;IAC3C;GACF;GAEA,KAAK,eAAe,MAAK;EAC3B;EAEQ,mBAAgB;;GAEtB,KAAK,cAAc,IAAI,WAAW,SAAS;IAAE,SAAS;IAAM,UAAU;GAAI,CAAE,CAAC;;;;;;GAO7E,KAAK,cAAc,IAAI,MAAM,UAAU,EAAE,SAAS,KAAI,CAAE,CAAC;EAC3D;EAEQ,mBAAmB,OAAiB,OAAc;GACxD,IAAI,UACF;GAEF,MAAM,UAAU,SAAS,cAAc,UAAU;GACjD,QAAQ,QAAQ;GAChB,QAAQ,YAAY,UAAU,QAAQ,KAAK,cAAc,KAAK,IAAI,SAAS;GAe3E,KAAK,aAAa,SAAS,KAAK,iBAAiB,KAAK,cAAc,OAAO,CAAC;EAC9E;EAEQ,uBAAoB;GAC1B,KAAK,WAAW,KAAK,eAAe,YAAY;GAChD,KAAK,mBAAkB;EACzB;EAEQ,qBAAkB;GACxB,KAAK,cAAa,EAAG,SAAS,MAAK;IACjC,EAAE,WAAW,KAAK,YAAY,KAAK;IACnC,EAAE,WAAW,KAAK,eAAe,aAAa,UAAU,KAAK;IAC7D,EAAE,WAAW,KAAK;GACpB,CAAC;EACH;EAEQ,YAAY,MAAiC;GACnD,IAAI,KAAK,eACP,KAAK,UAAU,OAAO,OAAO,QAAQ,KAAK,eAAe;GAE3D,KAAK,gBAAgB;GACrB,IAAI,KAAK,eACP,KAAK,UAAU,OAAO,IAAI,QAAQ,KAAK,eAAe;EAE1D;EAEQ,0BAAuB;GAC7B,IAAI,CAAC,KAAK,eACR;GAEF,KAAK,cAAc,aACjB,oBACA,GAAG,8BAA8B,KAAK,UAAU,SAAQ,GAAI,KAAK,MAAM,QAAQ;EAEnF;EAEmB,SAAM;GACvB,OAAO,IAAI,qBAAqB,KAAK,gBAAe;EACtD"}

package/development/chip-label/chip-label.component.js

@@ -1,2 +1,2 @@
-import { t as SbbChipLabelElement } from "../chip-label.component-DHHNtvTt.js";
+import { t as SbbChipLabelElement } from "../chip-label.component-D8Il3pvk.js";
 export { SbbChipLabelElement };

package/development/{chip-label.component-DHHNtvTt.js → chip-label.component-D8Il3pvk.js}

@@ -97,4 +97,4 @@ var SbbChipLabelElement = (() => {
 //#endregion
 export { SbbChipLabelElement as t };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/chip-label.js

@@ -1,4 +1,4 @@
-import { t as SbbChipLabelElement } from "./chip-label.component-DHHNtvTt.js";
+import { t as SbbChipLabelElement } from "./chip-label.component-D8Il3pvk.js";
 import "./chip-label.pure.js";
 //#region src/elements/chip-label.ts
 /** @entrypoint */
@@ -6,4 +6,4 @@ SbbChipLabelElement.define();
 //#endregion
 export { SbbChipLabelElement };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hpcC1sYWJlbC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvY2hpcC1sYWJlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNoaXBMYWJlbEVsZW1lbnQgfSBmcm9tICcuL2NoaXAtbGFiZWwucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vY2hpcC1sYWJlbC5wdXJlLnRzJztcblxuU2JiQ2hpcExhYmVsRWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7OztBQUtBLG9CQUFvQixRQUFRIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hpcC1sYWJlbC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvY2hpcC1sYWJlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNoaXBMYWJlbEVsZW1lbnQgfSBmcm9tICcuL2NoaXAtbGFiZWwucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vY2hpcC1sYWJlbC5wdXJlLnRzJztcblxuU2JiQ2hpcExhYmVsRWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7OztBQUtBLG9CQUFvQixPQUFNIn0=

package/development/chip-label.pure.js

@@ -1,2 +1,2 @@
-import { t as SbbChipLabelElement } from "./chip-label.component-DHHNtvTt.js";
+import { t as SbbChipLabelElement } from "./chip-label.component-D8Il3pvk.js";
 export { SbbChipLabelElement };

package/development/{chip.component-Uuf3tGFz.js → chip.component-C2VmHfZa.js}

@@ -112,4 +112,4 @@ var SbbChipElement = (() => {
 //#endregion
 export { SbbChipElement as t };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chip.component-Uuf3tGFz.js","names":[],"sources":["../../../src/elements/chip/chip/chip.scss?inline","../../../src/elements/chip/chip/chip.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-chip-border: var(--sbb-border-width-1x) solid var(--sbb-chip-border-color);\n  --sbb-chip-transition-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-2x)\n  );\n\n  display: inline-flex;\n  align-items: stretch;\n  background-color: var(--sbb-chip-background-color);\n  border-radius: var(--sbb-chip-border-radius);\n  color: var(--sbb-chip-color);\n  height: var(--sbb-chip-height);\n}\n\n:host(:focus) {\n  @include sbb.focus-outline;\n\n  // Outline overlaps the border\n  --sbb-focus-outline-offset: #{sbb.px-to-rem-build(-1)};\n\n  // Basically the focus-outline mixin is made for use with focus-visible.\n  // As we use it here with :focus, we have to ensure that the outline is not overridden when mouse or touch is in use.\n  --sbb-focus-outline-style: initial;\n}\n\n:host([negative]) {\n  --sbb-chip-border-color: var(--sbb-border-color-4-negative-inverted);\n  --sbb-chip-background-color: var(--sbb-background-color-3-negative);\n  --sbb-chip-color: var(--sbb-color-4-negative);\n  --sbb-chip-color-hover: var(--sbb-color-2-negative);\n  --sbb-chip-background-color-active: var(--sbb-background-color-1-negative);\n  --sbb-chip-background-color-hover: var(--sbb-background-color-1-negative);\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\n}\n\n.sbb-chip__label-wrapper {\n  border: var(--sbb-chip-border);\n  border-inline-end: none;\n  border-radius: var(--sbb-chip-border-radius) 0 0 var(--sbb-chip-border-radius);\n  display: flex;\n  align-items: center;\n  padding-inline: var(--sbb-chip-label-padding-inline);\n  outline: none;\n  overflow: hidden;\n\n  :host(:is([disabled], [readonly])) & {\n    border: var(--sbb-chip-border);\n    border-radius: var(--sbb-chip-border-radius);\n  }\n}\n\n.sbb-chip__label {\n  @include sbb.ellipsis;\n\n  display: inline-block;\n  font-size: var(--sbb-chip-font-size);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  transition: transform var(--sbb-chip-transition-duration) var(--sbb-animation-easing);\n}\n\n.sbb-chip__delete {\n  --sbb-mini-button-border-radius: 0 var(--sbb-chip-border-radius) var(--sbb-chip-border-radius) 0;\n  --sbb-mini-button-color-text: var(--sbb-chip-color);\n  --sbb-mini-button-color-active-background: var(--sbb-chip-background-color-active);\n  --sbb-mini-button-color-hover-background: var(--sbb-chip-background-color-hover);\n  --sbb-icon-svg-width: calc(var(--sbb-size-icon-ui-small) - var(--sbb-border-width-1x) * 2);\n  --sbb-icon-svg-height: calc(var(--sbb-size-icon-ui-small) - var(--sbb-border-width-1x) * 2);\n\n  // Invalidate minimum icon size as in the chip context, the icon has to be smaller than usual.\n  --_sbb-mini-button-image-size: ;\n\n  border: var(--sbb-chip-border);\n  border-radius: 0 var(--sbb-chip-border-radius) var(--sbb-chip-border-radius) 0;\n\n  :host(:is([disabled], [readonly])) & {\n    display: none;\n  }\n\n  @include sbb.hover-mq($hover: true) {\n    :host(:not([disabled])) & {\n      &:hover {\n        --sbb-mini-button-color-text: var(--sbb-chip-color-hover);\n      }\n    }\n  }\n}\n","import {\n  type CSSResultGroup,\n  html,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbMiniButtonElement } from '../../button.pure.ts';\nimport {\n  i18nChipDelete,\n  SbbDisabledMixin,\n  SbbElement,\n  type SbbElementType,\n  SbbLanguageController,\n  SbbNegativeMixin,\n  SbbReadonlyMixin,\n  screenReaderOnlyStyles,\n} from '../../core.ts';\n\nimport style from './chip.scss?inline';\n\n/**\n * It displays a chip. Usually used in combination with `sbb-chip-group`.\n *\n * @slot - Use the unnamed slot to add the display value. If not provided, the 'value' will be used.\n * @overrideType value - (T = string) | null\n */\nexport class SbbChipElement<T = string> extends SbbNegativeMixin(\n  SbbDisabledMixin(SbbReadonlyMixin(SbbElement)),\n) {\n  public static override readonly elementName: string = 'sbb-chip';\n  public static override elementDependencies: SbbElementType[] = [SbbMiniButtonElement];\n  public static override readonly role = 'option';\n  public static override styles: CSSResultGroup = [screenReaderOnlyStyles, unsafeCSS(style)];\n  public static readonly events = {\n    requestdelete: 'requestdelete',\n  } as const;\n\n  /** The value of chip. Will be used as label if nothing is slotted. */\n  @property() public accessor value: T | null = null;\n\n  private _language = new SbbLanguageController(this);\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('disabled')) {\n      if (this.disabled) {\n        this.removeAttribute('tabindex');\n      } else {\n        this.setAttribute('tabindex', '-1');\n      }\n    }\n  }\n\n  protected override firstUpdated(_changedProperties: PropertyValues): void {\n    super.firstUpdated(_changedProperties);\n\n    // Remove the delete button from the tab order.\n    // SetTimeout is needed to override the button tabindex initialization\n    setTimeout(() => this._deleteButton().removeAttribute('tabindex'));\n  }\n\n  private _deleteButton(): HTMLElement {\n    return this.shadowRoot!.querySelector('sbb-mini-button')!;\n  }\n\n  private _handleDeleteButtonClick(): void {\n    /** @internal */\n    this.dispatchEvent(new Event('requestdelete', { bubbles: true, composed: true }));\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-chip__label-wrapper\">\n        <span class=\"sbb-chip__label\">\n          <slot>${this.value ?? ''}</slot>\n        </span>\n      </div>\n      <sbb-mini-button\n        aria-hidden=\"true\"\n        class=\"sbb-chip__delete\"\n        icon-name=\"cross-tiny-small\"\n        @click=${this._handleDeleteButtonClick}\n      >\n      </sbb-mini-button>\n      <span class=\"sbb-screen-reader-only\">, ${i18nChipDelete[this._language.current]}</span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-chip': SbbChipElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;IC6Ba,wBAAc;mBAAqB,iBAC9C,iBAAiB,iBAAiB,WAAW,CAAC,CAC/C;;;;cAFY,uBAAmC,YAE/C;;;AAU6B,SAAA,yBAAA,kBAAA,MAAA,qBAAkB,KAAI;AAE1C,QAAA,aAAS,kBAAA,MAAA,yBAAA,EAAG,IAAI,sBAAsB,KAAK;;;;wBAFlD,UAAU,CAAA;AAAC,gBAAA,MAAA,MAAA,mBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,WAAA;KAAA,MAAA,QAAA,IAAgB;KAAK,MAAA,KAAA,UAAA;AAAA,UAAL,QAAK;;KAAA;IAAA,UAAA;IAAA,EAAA,qBAAA,yBAAA;;;;;;;;;AATD,QAAA,cAAsB;;;AAC/B,QAAA,sBAAwC,CAAC,qBAAqB;;;AACrD,QAAA,OAAO;;;AAChB,QAAA,SAAyB,CAAC,wBAAwB,UAAU,aAAM,CAAC;;;AACnE,QAAA,SAAS,EAC9B,eAAe,iBACP;;EAGE;;EAAA,IAAgB,QAAK;AAAA,UAAA,MAAA;;EAArB,IAAgB,MAAK,OAAA;AAAA,SAAA,yBAAA;;EAId,WAAW,mBAAuC;AACnE,SAAM,WAAW,kBAAkB;AAEnC,OAAI,kBAAkB,IAAI,WAAW,CACnC,KAAI,KAAK,SACP,MAAK,gBAAgB,WAAW;OAEhC,MAAK,aAAa,YAAY,KAAK;;EAKtB,aAAa,oBAAkC;AAChE,SAAM,aAAa,mBAAmB;AAItC,oBAAiB,KAAK,eAAe,CAAC,gBAAgB,WAAW,CAAC;;EAG5D,gBAAa;AACnB,UAAO,KAAK,WAAY,cAAc,kBAAmB;;EAGnD,2BAAwB;;AAE9B,QAAK,cAAc,IAAI,MAAM,iBAAiB;IAAE,SAAS;IAAM,UAAU;IAAM,CAAC,CAAC;;EAGhE,SAAM;AACvB,UAAO,IAAI;;;kBAGG,KAAK,SAAS,GAAE;;;;;;;iBAOjB,KAAK,yBAAA;;;+CAGyB,eAAe,KAAK,UAAU,SAAQ"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chip.component-C2VmHfZa.js","names":[],"sources":["../../../src/elements/chip/chip/chip.scss?inline","../../../src/elements/chip/chip/chip.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  --sbb-chip-border: var(--sbb-border-width-1x) solid var(--sbb-chip-border-color);\n  --sbb-chip-transition-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-2x)\n  );\n\n  display: inline-flex;\n  align-items: stretch;\n  background-color: var(--sbb-chip-background-color);\n  border-radius: var(--sbb-chip-border-radius);\n  color: var(--sbb-chip-color);\n  height: var(--sbb-chip-height);\n}\n\n:host(:focus) {\n  @include sbb.focus-outline;\n\n  // Outline overlaps the border\n  --sbb-focus-outline-offset: #{sbb.px-to-rem-build(-1)};\n\n  // Basically the focus-outline mixin is made for use with focus-visible.\n  // As we use it here with :focus, we have to ensure that the outline is not overridden when mouse or touch is in use.\n  --sbb-focus-outline-style: initial;\n}\n\n:host([negative]) {\n  --sbb-chip-border-color: var(--sbb-border-color-4-negative-inverted);\n  --sbb-chip-background-color: var(--sbb-background-color-3-negative);\n  --sbb-chip-color: var(--sbb-color-4-negative);\n  --sbb-chip-color-hover: var(--sbb-color-2-negative);\n  --sbb-chip-background-color-active: var(--sbb-background-color-1-negative);\n  --sbb-chip-background-color-hover: var(--sbb-background-color-1-negative);\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\n}\n\n.sbb-chip__label-wrapper {\n  border: var(--sbb-chip-border);\n  border-inline-end: none;\n  border-radius: var(--sbb-chip-border-radius) 0 0 var(--sbb-chip-border-radius);\n  display: flex;\n  align-items: center;\n  padding-inline: var(--sbb-chip-label-padding-inline);\n  outline: none;\n  overflow: hidden;\n\n  :host(:is([disabled], [readonly])) & {\n    border: var(--sbb-chip-border);\n    border-radius: var(--sbb-chip-border-radius);\n  }\n}\n\n.sbb-chip__label {\n  @include sbb.ellipsis;\n\n  display: inline-block;\n  font-size: var(--sbb-chip-font-size);\n  letter-spacing: var(--sbb-typo-letter-spacing-text);\n  transition: transform var(--sbb-chip-transition-duration) var(--sbb-animation-easing);\n}\n\n.sbb-chip__delete {\n  --sbb-mini-button-border-radius: 0 var(--sbb-chip-border-radius) var(--sbb-chip-border-radius) 0;\n  --sbb-mini-button-color-text: var(--sbb-chip-color);\n  --sbb-mini-button-color-active-background: var(--sbb-chip-background-color-active);\n  --sbb-mini-button-color-hover-background: var(--sbb-chip-background-color-hover);\n  --sbb-icon-svg-width: calc(var(--sbb-size-icon-ui-small) - var(--sbb-border-width-1x) * 2);\n  --sbb-icon-svg-height: calc(var(--sbb-size-icon-ui-small) - var(--sbb-border-width-1x) * 2);\n\n  // Invalidate minimum icon size as in the chip context, the icon has to be smaller than usual.\n  --_sbb-mini-button-image-size: ;\n\n  border: var(--sbb-chip-border);\n  border-radius: 0 var(--sbb-chip-border-radius) var(--sbb-chip-border-radius) 0;\n\n  :host(:is([disabled], [readonly])) & {\n    display: none;\n  }\n\n  @include sbb.hover-mq($hover: true) {\n    :host(:not([disabled])) & {\n      &:hover {\n        --sbb-mini-button-color-text: var(--sbb-chip-color-hover);\n      }\n    }\n  }\n}\n","import {\n  type CSSResultGroup,\n  html,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbMiniButtonElement } from '../../button.pure.ts';\nimport {\n  i18nChipDelete,\n  SbbDisabledMixin,\n  SbbElement,\n  type SbbElementType,\n  SbbLanguageController,\n  SbbNegativeMixin,\n  SbbReadonlyMixin,\n  screenReaderOnlyStyles,\n} from '../../core.ts';\n\nimport style from './chip.scss?inline';\n\n/**\n * It displays a chip. Usually used in combination with `sbb-chip-group`.\n *\n * @slot - Use the unnamed slot to add the display value. If not provided, the 'value' will be used.\n * @overrideType value - (T = string) | null\n */\nexport class SbbChipElement<T = string> extends SbbNegativeMixin(\n  SbbDisabledMixin(SbbReadonlyMixin(SbbElement)),\n) {\n  public static override readonly elementName: string = 'sbb-chip';\n  public static override elementDependencies: SbbElementType[] = [SbbMiniButtonElement];\n  public static override readonly role = 'option';\n  public static override styles: CSSResultGroup = [screenReaderOnlyStyles, unsafeCSS(style)];\n  public static readonly events = {\n    requestdelete: 'requestdelete',\n  } as const;\n\n  /** The value of chip. Will be used as label if nothing is slotted. */\n  @property() public accessor value: T | null = null;\n\n  private _language = new SbbLanguageController(this);\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('disabled')) {\n      if (this.disabled) {\n        this.removeAttribute('tabindex');\n      } else {\n        this.setAttribute('tabindex', '-1');\n      }\n    }\n  }\n\n  protected override firstUpdated(_changedProperties: PropertyValues): void {\n    super.firstUpdated(_changedProperties);\n\n    // Remove the delete button from the tab order.\n    // SetTimeout is needed to override the button tabindex initialization\n    setTimeout(() => this._deleteButton().removeAttribute('tabindex'));\n  }\n\n  private _deleteButton(): HTMLElement {\n    return this.shadowRoot!.querySelector('sbb-mini-button')!;\n  }\n\n  private _handleDeleteButtonClick(): void {\n    /** @internal */\n    this.dispatchEvent(new Event('requestdelete', { bubbles: true, composed: true }));\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-chip__label-wrapper\">\n        <span class=\"sbb-chip__label\">\n          <slot>${this.value ?? ''}</slot>\n        </span>\n      </div>\n      <sbb-mini-button\n        aria-hidden=\"true\"\n        class=\"sbb-chip__delete\"\n        icon-name=\"cross-tiny-small\"\n        @click=${this._handleDeleteButtonClick}\n      >\n      </sbb-mini-button>\n      <span class=\"sbb-screen-reader-only\">, ${i18nChipDelete[this._language.current]}</span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-chip': SbbChipElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;IC6Ba,wBAAc;mBAAqB,iBAC9C,iBAAiB,iBAAiB,UAAU,CAAC,CAAC;;;;cADnC,uBAAmC,YAE/C;;;GAU6B,KAAA,0BAAA,kBAAA,MAAA,qBAAkB,IAAI;GAE1C,KAAA,aAAS,kBAAA,MAAA,wBAAA,GAAG,IAAI,sBAAsB,IAAI;EAgDpD;;;wBAlDG,SAAQ,CAAE;GAAC,aAAA,MAAA,MAAA,mBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,WAAA;KAAA,MAAA,QAAA,IAAgB;KAAK,MAAA,KAAA,UAAA;MAAA,IAAL,QAAK;KAAA;IAAA;IAAA,UAAA;GAAA,GAAA,qBAAA,wBAAA;;;;;;;;;GATD,KAAA,cAAsB;EAAW;;GAC1C,KAAA,sBAAwC,CAAC,oBAAoB;EAAE;;GACtD,KAAA,OAAO;EAAS;;GACzB,KAAA,SAAyB,CAAC,wBAAwB,UAAU,YAAK,CAAC;EAAE;;GACpE,KAAA,SAAS,EAC9B,eAAe,gBAAA;EACN;EAGC;;EAAA,IAAgB,QAAK;GAAA,OAAA,KAAA;EAAA;EAArB,IAAgB,MAAK,OAAA;GAAA,KAAA,0BAAA;EAAA;EAId,WAAW,mBAAuC;GACnE,MAAM,WAAW,iBAAiB;GAElC,IAAI,kBAAkB,IAAI,UAAU,GAClC,IAAI,KAAK,UACP,KAAK,gBAAgB,UAAU;QAE/B,KAAK,aAAa,YAAY,IAAI;EAGxC;EAEmB,aAAa,oBAAkC;GAChE,MAAM,aAAa,kBAAkB;GAIrC,iBAAiB,KAAK,cAAa,EAAG,gBAAgB,UAAU,CAAC;EACnE;EAEQ,gBAAa;GACnB,OAAO,KAAK,WAAY,cAAc,iBAAiB;EACzD;EAEQ,2BAAwB;;GAE9B,KAAK,cAAc,IAAI,MAAM,iBAAiB;IAAE,SAAS;IAAM,UAAU;GAAI,CAAE,CAAC;EAClF;EAEmB,SAAM;GACvB,OAAO,IAAI;;;kBAGG,KAAK,SAAS,GAAE;;;;;;;iBAOjB,KAAK,yBAAA;;;+CAGyB,eAAe,KAAK,UAAU,SAAQ;;EAEnF"}

package/development/chip.js

@@ -1,5 +1,5 @@
-import { n as SbbChipInputTokenEndEvent, t as SbbChipGroupElement } from "./chip-group.component-DThvmmnh.js";
-import { t as SbbChipElement } from "./chip.component-Uuf3tGFz.js";
+import { n as SbbChipInputTokenEndEvent, t as SbbChipGroupElement } from "./chip-group.component-BY025VTb.js";
+import { t as SbbChipElement } from "./chip.component-C2VmHfZa.js";
 import "./chip.pure.js";
 //#region src/elements/chip.ts
 /** @entrypoint */
@@ -8,4 +8,4 @@ SbbChipGroupElement.define();
 //#endregion
 export { SbbChipElement, SbbChipGroupElement, SbbChipInputTokenEndEvent };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hpcC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvY2hpcC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNoaXBFbGVtZW50LCBTYmJDaGlwR3JvdXBFbGVtZW50IH0gZnJvbSAnLi9jaGlwLnB1cmUudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2NoaXAucHVyZS50cyc7XG5cblNiYkNoaXBFbGVtZW50LmRlZmluZSgpO1xuU2JiQ2hpcEdyb3VwRWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFLQSxlQUFlLFFBQVE7QUFDdkIsb0JBQW9CLFFBQVEifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hpcC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvY2hpcC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYkNoaXBFbGVtZW50LCBTYmJDaGlwR3JvdXBFbGVtZW50IH0gZnJvbSAnLi9jaGlwLnB1cmUudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2NoaXAucHVyZS50cyc7XG5cblNiYkNoaXBFbGVtZW50LmRlZmluZSgpO1xuU2JiQ2hpcEdyb3VwRWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFLQSxlQUFlLE9BQU07QUFDckIsb0JBQW9CLE9BQU0ifQ==

package/development/chip.pure.js

@@ -1,3 +1,3 @@
-import { n as SbbChipInputTokenEndEvent, t as SbbChipGroupElement } from "./chip-group.component-DThvmmnh.js";
-import { t as SbbChipElement } from "./chip.component-Uuf3tGFz.js";
+import { n as SbbChipInputTokenEndEvent, t as SbbChipGroupElement } from "./chip-group.component-BY025VTb.js";
+import { t as SbbChipElement } from "./chip.component-C2VmHfZa.js";
 export { SbbChipElement, SbbChipGroupElement, SbbChipInputTokenEndEvent };

package/development/clock/clock.component.d.ts

@@ -1,5 +1,5 @@
 import { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
-import { SbbTime, SbbElement } from '../core.ts';
+import { SbbElement } from '../core.ts';
 /**
  * It displays an analog clock with the classic SBB face.
  */
@@ -10,7 +10,7 @@ export declare class SbbClockElement extends SbbElement {
      * Define a specific time which the clock should show statically.
      * @param value HH:MM:ss
      */
-    accessor now: SbbTime | null;
+    accessor now: `${number}:${number}:${number}` | null;
     /** Whether the clock is ticking or not */
     private _state;
     /** Reference to the hour hand. */

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

@@ -1 +1 @@
-{"version":3,"file":"clock.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/clock/clock.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAIb,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA8CxC;;GAEG;AACH,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,gBAAgC,WAAW,EAAE,MAAM,CAAe;IAClE,OAAuB,MAAM,EAAE,cAAc,CAAsB;IAEnE;;;OAGG;IACH,SAA4B,GAAG,EAAE,OAAO,GAAG,IAAI,CAAQ;IAEvD,0CAA0C;IAC1C,OAAO,CAAC,MAAM,CAAkC;IAEhD,kCAAkC;IAClC,OAAO,CAAC,eAAe,CAAe;IAEtC,oCAAoC;IACpC,OAAO,CAAC,iBAAiB,CAAe;IAExC,oCAAoC;IACpC,OAAO,CAAC,iBAAiB,CAAe;IAExC,wCAAwC;IACxC,OAAO,CAAC,MAAM,CAAU;IAExB,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAU;IAE1B,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAU;IAE1B,0CAA0C;IAC1C,OAAO,CAAC,aAAa,CAAC,CAAiC;IAEvD,OAAO,CAAC,gBAAgB,CAAC,CAAiC;IAE1D,wCAAwC;IACxC,OAAO,CAAC,gBAAgB,CAAqC;IAE7D,0CAA0C;IAC1C,OAAO,CAAC,kBAAkB,CAAuC;IAEjD,iBAAiB,IAAI,IAAI;cAMtB,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;cAQzD,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAS9D,oBAAoB,IAAI,IAAI;IAM5C,OAAO,CAAC,2BAA2B,CAUjC;YAEY,sBAAsB;IAUpC,6FAA6F;YAC/E,WAAW;IAuBzB,sDAAsD;YACxC,UAAU;IAexB;;OAEG;YACW,WAAW;IAQzB,uEAAuE;IACvE,OAAO,CAAC,yBAAyB;IA4CjC,yGAAyG;IACzG,OAAO,CAAC,kBAAkB;IAW1B,sDAAsD;IACtD,OAAO,CAAC,eAAe;IAOvB,6CAA6C;IAC7C,OAAO,CAAC,cAAc;IAYtB,+CAA+C;IAC/C,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,sBAAsB;IAK9B;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAWlC,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,2BAA2B;IAMnC,OAAO,CAAC,6BAA6B;cAOlB,MAAM,IAAI,cAAc;CA0B5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,WAAW,EAAE,eAAe,CAAC;KAC9B;CACF"}
+{"version":3,"file":"clock.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/clock/clock.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAIb,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA8CxC;;GAEG;AACH,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,gBAAgC,WAAW,EAAE,MAAM,CAAe;IAClE,OAAuB,MAAM,EAAE,cAAc,CAAsB;IAEnE;;;OAGG;IACH,SAA4B,GAAG,EAAE,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,GAAG,IAAI,CAAQ;IAE/E,0CAA0C;IAC1C,OAAO,CAAC,MAAM,CAAkC;IAEhD,kCAAkC;IAClC,OAAO,CAAC,eAAe,CAAe;IAEtC,oCAAoC;IACpC,OAAO,CAAC,iBAAiB,CAAe;IAExC,oCAAoC;IACpC,OAAO,CAAC,iBAAiB,CAAe;IAExC,wCAAwC;IACxC,OAAO,CAAC,MAAM,CAAU;IAExB,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAU;IAE1B,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAU;IAE1B,0CAA0C;IAC1C,OAAO,CAAC,aAAa,CAAC,CAAiC;IAEvD,OAAO,CAAC,gBAAgB,CAAC,CAAiC;IAE1D,wCAAwC;IACxC,OAAO,CAAC,gBAAgB,CAAqC;IAE7D,0CAA0C;IAC1C,OAAO,CAAC,kBAAkB,CAAuC;IAEjD,iBAAiB,IAAI,IAAI;cAMtB,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;cAQzD,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAS9D,oBAAoB,IAAI,IAAI;IAM5C,OAAO,CAAC,2BAA2B,CAUjC;YAEY,sBAAsB;IAUpC,6FAA6F;YAC/E,WAAW;IAuBzB,sDAAsD;YACxC,UAAU;IAexB;;OAEG;YACW,WAAW;IAQzB,uEAAuE;IACvE,OAAO,CAAC,yBAAyB;IA4CjC,yGAAyG;IACzG,OAAO,CAAC,kBAAkB;IAW1B,sDAAsD;IACtD,OAAO,CAAC,eAAe;IAOvB,6CAA6C;IAC7C,OAAO,CAAC,cAAc;IAYtB,+CAA+C;IAC/C,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,sBAAsB;IAK9B;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAWlC,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,2BAA2B;IAMnC,OAAO,CAAC,6BAA6B;cAOlB,MAAM,IAAI,cAAc;CA0B5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,WAAW,EAAE,eAAe,CAAC;KAC9B;CACF"}

package/development/clock/clock.component.js

@@ -1,2 +1,2 @@
-import { t as SbbClockElement } from "../clock.component-DcM1WFTN.js";
+import { t as SbbClockElement } from "../clock.component-CyCPrufS.js";
 export { SbbClockElement };