@sbb-esta/lyne-elements-dev 4.7.0-dev.1773648103 → 4.7.0-dev.1773648656

package/development/core/mixins/form-associated-input-mixin.js

@@ -1,320 +1,340 @@
-import { __esDecorate, __runInitializers } from "tslib";
-import { isServer, html } from "lit";
-import { property, eventOptions } from "lit/decorators.js";
-import { sbbInputModalityDetector } from "../a11y.js";
-import { SbbLanguageController, SbbMediaQueryPointerCoarse } from "../controllers.js";
-import { isWebkit, isBlink } from "../dom.js";
-import { i18nInputRequired } from "../i18n.js";
 import { SbbDisabledMixin } from "./disabled-mixin.js";
 import { SbbElementInternalsMixin } from "./element-internals-mixin.js";
 import { SbbFormAssociatedMixin } from "./form-associated-mixin.js";
-import { SbbReadonlyMixin } from "./readonly-mixin.js";
 import { SbbRequiredMixin } from "./required-mixin.js";
-const checkPlaintextOnlySupport = () => {
-  if (isServer) {
-    return false;
-  }
-  const div = document.createElement("div");
-  div.setAttribute("contenteditable", "PLAINTEXT-ONLY");
-  return div.contentEditable === "plaintext-only";
-};
-const plaintextOnlySupported = checkPlaintextOnlySupport();
-const SbbFormAssociatedInputMixin = (superClass) => {
-  const conditionalSuperClass = superClass["_$sbbElement$"] ? superClass : SbbElementInternalsMixin(superClass);
-  let SbbFormAssociatedInputElement = (() => {
-    var _a;
-    let _classSuper = SbbReadonlyMixin(SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass))));
-    let _instanceExtraInitializers = [];
-    let _set_value_decorators;
-    let _set_placeholder_decorators;
-    let __cleanChildren_decorators;
-    return _a = class extends _classSuper {
-      /**
-       * Form type of element.
-       * @default 'text'
-       */
-      get type() {
-        return "text";
-      }
-      /**
-       * The value of the input. Reflects the current text value of this input.
-       */
-      set value(value) {
-        this._value = this._cleanText(value);
-        if (this.hasUpdated) {
-          this._assignValue(this._value);
-        }
-        this.dispatchEvent(new Event("displayvaluechange", { bubbles: true, composed: true }));
-      }
-      get value() {
-        return this._value ?? "";
-      }
-      set placeholder(value) {
-        if (value) {
-          this.setAttribute("placeholder", value);
-        } else {
-          this.removeAttribute("placeholder");
-        }
-        this.internals.ariaPlaceholder = value ? value : null;
-      }
-      get placeholder() {
-        return this.getAttribute("placeholder") ?? "";
-      }
-      constructor() {
-        super();
-        this._shouldEmitChange = (__runInitializers(this, _instanceExtraInitializers), false);
-        this._shouldTriggerSubmit = false;
-        this.language = new SbbLanguageController(this);
-        this._value = "";
-        this.addEventListener?.("input", () => {
-          const oldValue = this._value;
-          this._value = this._cleanText(this.textContent ?? "");
-          this.requestUpdate("value", oldValue);
-          this.internals.states.add("interacted");
-          this._shouldEmitChange = true;
-        }, { capture: true });
-        this.addEventListener?.("change", () => this._shouldEmitChange = false, { capture: true });
-        this.addEventListener?.("keydown", (event) => {
-          if (this._requiresEmptyPatch()) {
-            this._assignValue("");
-          }
-          if ((event.key === "Enter" || event.key === "\n") && event.isTrusted) {
-            event.preventDefault();
-            event.stopImmediatePropagation();
-            this._shouldTriggerSubmit = this.dispatchEvent(new KeyboardEvent("keydown", event));
-          } else if (isWebkit && this.value && (event.key === "Backspace" || event.key === "Delete") && event.isTrusted) {
-            event.preventDefault();
-            event.stopImmediatePropagation();
-            if (!this.dispatchEvent(new KeyboardEvent("keydown", event))) {
-              return;
-            }
-            const selectedRange = window.getSelection()?.getRangeAt(0);
-            if (!selectedRange) {
-              return;
-            }
-            if (selectedRange.startOffset !== selectedRange.endOffset) {
-              selectedRange.deleteContents();
-              this._dispatchInputEvent();
-            } else if (event.key === "Backspace" && selectedRange.startOffset > 0) {
-              selectedRange.setStart(selectedRange.startContainer, selectedRange.startOffset - 1);
-              selectedRange.deleteContents();
-              this._dispatchInputEvent();
-            } else if (event.key === "Delete" && selectedRange.endOffset < this.value.length) {
-              selectedRange.setEnd(selectedRange.endContainer, selectedRange.endOffset + 1);
-              selectedRange.deleteContents();
-              this._dispatchInputEvent();
-            }
-          }
-        }, { capture: true });
-        this.addEventListener?.("keyup", (event) => {
-          if (event.key === "Enter" || event.key === "\n") {
-            this._emitChangeIfNecessary();
-            if (this._shouldTriggerSubmit) {
-              this._shouldTriggerSubmit = false;
-              this.form?.requestSubmit();
-            }
-          } else if (this._requiresEmptyPatch()) {
-            this._setCursorAt(0);
-          }
-        }, { capture: true });
-        this.addEventListener?.("paste", (e) => {
-          e.preventDefault();
-          if (this._requiresEmptyPatch()) {
-            this._assignValue("");
-          }
-          const text = this._cleanText(e.clipboardData?.getData("text/plain") ?? "");
-          const selectedRange = window.getSelection()?.getRangeAt(0);
-          if (!selectedRange || !text) {
-            return;
-          }
-          selectedRange.deleteContents();
-          selectedRange.insertNode(document.createTextNode(this.preparePastedText(text)));
-          selectedRange.setStart(selectedRange.endContainer, selectedRange.endOffset);
-          this._dispatchInputEvent();
-        });
-        this.addEventListener?.("focus", () => {
-          if (sbbInputModalityDetector.mostRecentModality === "keyboard") {
-            window.getSelection()?.selectAllChildren(this);
-          }
-        });
-        this.addEventListener?.("touchend", () => {
-          if (this._requiresEmptyPatch()) {
-            this._assignValue("&nbsp;");
-            this._setCursorAt(0);
-          }
-        });
-        this.addEventListener?.("click", () => {
-          if (this._requiresEmptyPatch() && sbbInputModalityDetector.mostRecentModality === "touch") {
-            this._setCursorAt(0);
-          }
-        });
-        this.addEventListener?.("blur", () => {
-          window.getSelection()?.removeAllRanges();
-          if (this.value === "") {
-            this._assignValue("");
-          }
-          this._emitChangeIfNecessary();
-          this.scrollLeft = 0;
-        }, { capture: true });
-      }
-      isDisabledExternally() {
-        return this.formDisabled;
-      }
-      connectedCallback() {
-        super.connectedCallback();
-        this.internals.ariaMultiLine = "false";
-        this._updateContenteditable();
-        this._assignValue(this.value);
-      }
-      focus(options) {
-        super.focus(options);
-        if (this._canSelect()) {
-          const selection = window.getSelection();
-          if (!selection) {
-            return;
-          }
-          const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
-          if (range && range.startOffset !== 0) {
-            return;
-          }
-          this._setCursorAt(this.textContent.length);
-        }
-      }
-      attributeChangedCallback(name, old, value) {
-        if (name !== "value" || !this.internals.states.has("interacted")) {
-          super.attributeChangedCallback(name, old, value);
-        }
-      }
-      /**
-       * Is called whenever the form is being reset.
-       *
-       * @internal
-       */
-      formResetCallback() {
-        this.internals.states.delete("interacted");
-        this.value = this.getAttribute("value") ?? "";
-      }
-      /**
-       *  Called when the browser is trying to restore element’s state to state in which case
-       *  reason is "restore", or when the browser is trying to fulfill autofill on behalf of
-       *  user in which case reason is "autocomplete".
-       *  In the case of "restore", state is a string, File, or FormData object
-       *  previously set as the second argument to setFormValue.
-       *
-       * @internal
-       */
-      formStateRestoreCallback(state, _reason) {
-        if (state && typeof state === "string") {
-          this.value = state;
-        }
-      }
-      /**
-       * Makes the selection equal to the current object.
-       *
-       * @link https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select
-       */
-      select() {
-        window.getSelection()?.selectAllChildren(this);
-      }
-      firstUpdated(changedProperties) {
-        super.firstUpdated(changedProperties);
-        if (this.value && !this.innerHTML.length) {
-          this._assignValue(this.value);
-        }
-      }
-      requestUpdate(name, oldValue, options) {
-        super.requestUpdate(name, oldValue, options);
-        if (this.isConnected && (name === "disabled" || name === "formDisabled" || name === "readOnly")) {
-          this._updateContenteditable();
-        }
-      }
-      shouldValidate(name) {
-        return super.shouldValidate(name) || name === "value" || name === "required";
-      }
-      validate() {
-        super.validate();
-        if (this.required && !this.value) {
-          this.setValidityFlag("valueMissing", i18nInputRequired[this.language.current]);
-        } else {
-          this.removeValidityFlag("valueMissing");
-        }
-      }
-      preparePastedText(text) {
-        return text;
-      }
-      _requiresEmptyPatch() {
-        return isServer ? false : isBlink && this.value === "" && window.matchMedia(SbbMediaQueryPointerCoarse).matches;
-      }
-      _assignValue(value) {
-        this.innerHTML = value;
-      }
-      _setCursorAt(position) {
-        const selection = window.getSelection();
-        if (!selection) {
-          return;
-        }
-        const range = document.createRange();
-        range.setStart(this.firstChild, position);
-        range.collapse(true);
-        selection.removeAllRanges();
-        selection.addRange(range);
-      }
-      _cleanText(value) {
-        return value === null ? "" : `${value}`.replace(/[\n\r]+/g, "");
-      }
-      _dispatchInputEvent() {
-        this.dispatchEvent(new InputEvent("input", { bubbles: true, composed: true }));
-      }
-      _cleanChildren() {
-        if (this.childElementCount) {
-          for (const element of this.children) {
-            element.remove();
-          }
-        }
-      }
-      _updateContenteditable() {
-        if (!isServer && this.isConnected) {
-          this.internals.ariaReadOnly = this.readOnly ? "true" : null;
-          this.internals.ariaDisabled = this.disabled ? "true" : null;
-          const value = this.disabled || this.readOnly ? "false" : plaintextOnlySupported ? "plaintext-only" : "true";
-          this.setAttribute("contenteditable", value);
-          if (this.readOnly) {
-            this.setAttribute("tabindex", "0");
-          } else {
-            this.removeAttribute("tabindex");
-          }
-        }
-      }
-      _emitChangeIfNecessary() {
-        if (this._shouldEmitChange) {
-          this._shouldEmitChange = false;
-          this.dispatchEvent(new Event("change", { bubbles: true }));
-        }
-      }
-      _canSelect() {
-        return !isServer && !this.disabled && !this.readOnly && !!this.value;
-      }
-      render() {
-        return html`<slot @slotchange=${this._cleanChildren}></slot>`;
-      }
-    }, (() => {
-      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-      _set_value_decorators = [property()];
-      _set_placeholder_decorators = [property({ attribute: false })];
-      __cleanChildren_decorators = [eventOptions({ passive: true })];
-      __esDecorate(_a, 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(_a, null, _set_placeholder_decorators, { kind: "setter", name: "placeholder", static: false, private: false, access: { has: (obj) => "placeholder" in obj, set: (obj, value) => {
-        obj.placeholder = value;
-      } }, metadata: _metadata }, null, _instanceExtraInitializers);
-      __esDecorate(_a, null, __cleanChildren_decorators, { kind: "method", name: "_cleanChildren", static: false, private: false, access: { has: (obj) => "_cleanChildren" in obj, get: (obj) => obj._cleanChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
-      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-    })(), _a.role = "textbox", _a.formFieldAssociated = true, _a;
-  })();
-  return SbbFormAssociatedInputElement;
+import { SbbReadonlyMixin } from "./readonly-mixin.js";
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, isServer } from "lit";
+import { eventOptions, property } from "lit/decorators.js";
+import { isBlink, isWebkit } from "../dom.js";
+import { SbbLanguageController, SbbMediaQueryPointerCoarse } from "../controllers.js";
+import { i18nInputRequired } from "../i18n.js";
+import { sbbInputModalityDetector } from "../a11y.js";
+//#region src/elements/core/mixins/form-associated-input-mixin.ts
+var checkPlaintextOnlySupport = () => {
+	if (isServer) return false;
+	const div = document.createElement("div");
+	div.setAttribute("contenteditable", "PLAINTEXT-ONLY");
+	return div.contentEditable === "plaintext-only";
 };
-export {
-  SbbFormAssociatedInputMixin
+var plaintextOnlySupported = checkPlaintextOnlySupport();
+/**
+* The SbbFormAssociatedInputMixin enables native form support for text input controls.
+*/
+var SbbFormAssociatedInputMixin = (superClass) => {
+	const conditionalSuperClass = superClass["_$sbbElement$"] ? superClass : SbbElementInternalsMixin(superClass);
+	return (() => {
+		let _classSuper = SbbReadonlyMixin(SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass))));
+		let _instanceExtraInitializers = [];
+		let _set_value_decorators;
+		let _set_placeholder_decorators;
+		let __cleanChildren_decorators;
+		return class SbbFormAssociatedInputElement extends _classSuper {
+			static {
+				const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+				_set_value_decorators = [property()];
+				_set_placeholder_decorators = [property({ attribute: false })];
+				__cleanChildren_decorators = [eventOptions({ passive: true })];
+				__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, _set_placeholder_decorators, {
+					kind: "setter",
+					name: "placeholder",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "placeholder" in obj,
+						set: (obj, value) => {
+							obj.placeholder = value;
+						}
+					},
+					metadata: _metadata
+				}, null, _instanceExtraInitializers);
+				__esDecorate(this, null, __cleanChildren_decorators, {
+					kind: "method",
+					name: "_cleanChildren",
+					static: false,
+					private: false,
+					access: {
+						has: (obj) => "_cleanChildren" in obj,
+						get: (obj) => obj._cleanChildren
+					},
+					metadata: _metadata
+				}, null, _instanceExtraInitializers);
+				if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+					enumerable: true,
+					configurable: true,
+					writable: true,
+					value: _metadata
+				});
+			}
+			static {
+				this.role = "textbox";
+			}
+			static {
+				this.formFieldAssociated = true;
+			}
+			/**
+			* Form type of element.
+			* @default 'text'
+			*/
+			get type() {
+				return "text";
+			}
+			/**
+			* The value of the input. Reflects the current text value of this input.
+			*/
+			set value(value) {
+				this._value = this._cleanText(value);
+				if (this.hasUpdated) this._assignValue(this._value);
+				/** @internal */
+				this.dispatchEvent(new Event("displayvaluechange", {
+					bubbles: true,
+					composed: true
+				}));
+			}
+			get value() {
+				return this._value ?? "";
+			}
+			set placeholder(value) {
+				if (value) this.setAttribute("placeholder", value);
+				else this.removeAttribute("placeholder");
+				this.internals.ariaPlaceholder = value ? value : null;
+			}
+			get placeholder() {
+				return this.getAttribute("placeholder") ?? "";
+			}
+			constructor() {
+				super();
+				/**
+				* An element with contenteditable will not emit a change event. To achieve parity
+				* with a native text input, we need to track whether a change event should be
+				* emitted.
+				*/
+				this._shouldEmitChange = (__runInitializers(this, _instanceExtraInitializers), false);
+				/**
+				* A native text input attempts to submit the form when pressing Enter.
+				* This can be prevented by calling preventDefault on the keydown event.
+				* We track whether to request submit, which should occur before the keyup
+				* event.
+				*/
+				this._shouldTriggerSubmit = false;
+				this.language = new SbbLanguageController(this);
+				this._value = "";
+				this.addEventListener?.("input", () => {
+					const oldValue = this._value;
+					this._value = this._cleanText(this.textContent ?? "");
+					this.requestUpdate("value", oldValue);
+					this.internals.states.add("interacted");
+					this._shouldEmitChange = true;
+				}, { capture: true });
+				this.addEventListener?.("change", () => this._shouldEmitChange = false, { capture: true });
+				this.addEventListener?.("keydown", (event) => {
+					if (this._requiresEmptyPatch()) this._assignValue("");
+					if ((event.key === "Enter" || event.key === "\n") && event.isTrusted) {
+						event.preventDefault();
+						event.stopImmediatePropagation();
+						this._shouldTriggerSubmit = this.dispatchEvent(new KeyboardEvent("keydown", event));
+					} else if (isWebkit && this.value && (event.key === "Backspace" || event.key === "Delete") && event.isTrusted) {
+						event.preventDefault();
+						event.stopImmediatePropagation();
+						if (!this.dispatchEvent(new KeyboardEvent("keydown", event))) return;
+						const selectedRange = window.getSelection()?.getRangeAt(0);
+						if (!selectedRange) return;
+						if (selectedRange.startOffset !== selectedRange.endOffset) {
+							selectedRange.deleteContents();
+							this._dispatchInputEvent();
+						} else if (event.key === "Backspace" && selectedRange.startOffset > 0) {
+							selectedRange.setStart(selectedRange.startContainer, selectedRange.startOffset - 1);
+							selectedRange.deleteContents();
+							this._dispatchInputEvent();
+						} else if (event.key === "Delete" && selectedRange.endOffset < this.value.length) {
+							selectedRange.setEnd(selectedRange.endContainer, selectedRange.endOffset + 1);
+							selectedRange.deleteContents();
+							this._dispatchInputEvent();
+						}
+					}
+				}, { capture: true });
+				this.addEventListener?.("keyup", (event) => {
+					if (event.key === "Enter" || event.key === "\n") {
+						this._emitChangeIfNecessary();
+						if (this._shouldTriggerSubmit) {
+							this._shouldTriggerSubmit = false;
+							this.form?.requestSubmit();
+						}
+					} else if (this._requiresEmptyPatch()) this._setCursorAt(0);
+				}, { capture: true });
+				this.addEventListener?.("paste", (e) => {
+					e.preventDefault();
+					if (this._requiresEmptyPatch()) this._assignValue("");
+					const text = this._cleanText(e.clipboardData?.getData("text/plain") ?? "");
+					const selectedRange = window.getSelection()?.getRangeAt(0);
+					if (!selectedRange || !text) return;
+					selectedRange.deleteContents();
+					selectedRange.insertNode(document.createTextNode(this.preparePastedText(text)));
+					selectedRange.setStart(selectedRange.endContainer, selectedRange.endOffset);
+					this._dispatchInputEvent();
+				});
+				this.addEventListener?.("focus", () => {
+					if (sbbInputModalityDetector.mostRecentModality === "keyboard") window.getSelection()?.selectAllChildren(this);
+				});
+				this.addEventListener?.("touchend", () => {
+					if (this._requiresEmptyPatch()) {
+						this._assignValue("&nbsp;");
+						this._setCursorAt(0);
+					}
+				});
+				this.addEventListener?.("click", () => {
+					if (this._requiresEmptyPatch() && sbbInputModalityDetector.mostRecentModality === "touch") this._setCursorAt(0);
+				});
+				this.addEventListener?.("blur", () => {
+					window.getSelection()?.removeAllRanges();
+					if (this.value === "") this._assignValue("");
+					this._emitChangeIfNecessary();
+					this.scrollLeft = 0;
+				}, { capture: true });
+			}
+			isDisabledExternally() {
+				return this.formDisabled;
+			}
+			connectedCallback() {
+				super.connectedCallback();
+				this.internals.ariaMultiLine = "false";
+				this._updateContenteditable();
+				this._assignValue(this.value);
+			}
+			focus(options) {
+				super.focus(options);
+				if (this._canSelect()) {
+					const selection = window.getSelection();
+					if (!selection) return;
+					const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
+					if (range && range.startOffset !== 0) return;
+					this._setCursorAt(this.textContent.length);
+				}
+			}
+			attributeChangedCallback(name, old, value) {
+				/**
+				* The native text input changes the value property when the value attribute is
+				* changed under the condition that no input event has occurred since creation
+				* or the last form reset.
+				*/
+				if (name !== "value" || !this.internals.states.has("interacted")) super.attributeChangedCallback(name, old, value);
+			}
+			/**
+			* Is called whenever the form is being reset.
+			*
+			* @internal
+			*/
+			formResetCallback() {
+				this.internals.states.delete("interacted");
+				this.value = this.getAttribute("value") ?? "";
+			}
+			/**
+			*  Called when the browser is trying to restore element’s state to state in which case
+			*  reason is "restore", or when the browser is trying to fulfill autofill on behalf of
+			*  user in which case reason is "autocomplete".
+			*  In the case of "restore", state is a string, File, or FormData object
+			*  previously set as the second argument to setFormValue.
+			*
+			* @internal
+			*/
+			formStateRestoreCallback(state, _reason) {
+				if (state && typeof state === "string") this.value = state;
+			}
+			/**
+			* Makes the selection equal to the current object.
+			*
+			* @link https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select
+			*/
+			select() {
+				window.getSelection()?.selectAllChildren(this);
+			}
+			firstUpdated(changedProperties) {
+				super.firstUpdated(changedProperties);
+				if (this.value && !this.innerHTML.length) this._assignValue(this.value);
+			}
+			requestUpdate(name, oldValue, options) {
+				super.requestUpdate(name, oldValue, options);
+				if (this.isConnected && (name === "disabled" || name === "formDisabled" || name === "readOnly")) this._updateContenteditable();
+			}
+			shouldValidate(name) {
+				return super.shouldValidate(name) || name === "value" || name === "required";
+			}
+			validate() {
+				super.validate();
+				if (this.required && !this.value) this.setValidityFlag("valueMissing", i18nInputRequired[this.language.current]);
+				else this.removeValidityFlag("valueMissing");
+			}
+			preparePastedText(text) {
+				return text;
+			}
+			_requiresEmptyPatch() {
+				return isServer ? false : isBlink && this.value === "" && window.matchMedia(SbbMediaQueryPointerCoarse).matches;
+			}
+			_assignValue(value) {
+				this.innerHTML = value;
+			}
+			_setCursorAt(position) {
+				const selection = window.getSelection();
+				if (!selection) return;
+				const range = document.createRange();
+				range.setStart(this.firstChild, position);
+				range.collapse(true);
+				selection.removeAllRanges();
+				selection.addRange(range);
+			}
+			_cleanText(value) {
+				return value === null ? "" : `${value}`.replace(/[\n\r]+/g, "");
+			}
+			_dispatchInputEvent() {
+				/** 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
+				}));
+			}
+			_cleanChildren() {
+				if (this.childElementCount) for (const element of this.children) element.remove();
+			}
+			_updateContenteditable() {
+				if (!isServer && this.isConnected) {
+					this.internals.ariaReadOnly = this.readOnly ? "true" : null;
+					this.internals.ariaDisabled = this.disabled ? "true" : null;
+					const value = this.disabled || this.readOnly ? "false" : plaintextOnlySupported ? "plaintext-only" : "true";
+					this.setAttribute("contenteditable", value);
+					if (this.readOnly) this.setAttribute("tabindex", "0");
+					else this.removeAttribute("tabindex");
+				}
+			}
+			_emitChangeIfNecessary() {
+				if (this._shouldEmitChange) {
+					this._shouldEmitChange = false;
+					/** 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 }));
+				}
+			}
+			_canSelect() {
+				return !isServer && !this.disabled && !this.readOnly && !!this.value;
+			}
+			render() {
+				return html`<slot @slotchange=${this._cleanChildren}></slot>`;
+			}
+		};
+	})();
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-input-mixin.js","sources":["../../../../../src/elements/core/mixins/form-associated-input-mixin.ts"],"sourcesContent":["import {\n  html,\n  isServer,\n  type LitElement,\n  type PropertyDeclaration,\n  type PropertyValues,\n} from 'lit';\nimport { eventOptions, property } from 'lit/decorators.js';\n\nimport { sbbInputModalityDetector } from '../a11y.ts';\nimport { SbbLanguageController, SbbMediaQueryPointerCoarse } from '../controllers.ts';\nimport { isBlink, isWebkit } from '../dom.ts';\nimport { i18nInputRequired } from '../i18n.ts';\n\nimport type { AbstractConstructor } from './constructor.ts';\nimport { SbbDisabledMixin } from './disabled-mixin.ts';\nimport {\n  SbbElementInternalsMixin,\n  type SbbElementInternalsMixinType,\n  type SbbElementInternalsConstructor,\n} from './element-internals-mixin.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from './form-associated-mixin.ts';\nimport { SbbReadonlyMixin } from './readonly-mixin.ts';\nimport { SbbRequiredMixin } from './required-mixin.ts';\n\nexport declare abstract class SbbFormAssociatedInputMixinType extends SbbRequiredMixin(\n  SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement)),\n) {\n  public static readonly formFieldAssociated = true;\n\n  public set value(value: string);\n  public get value(): string;\n\n  public set disabled(value: boolean);\n  public get disabled(): boolean;\n\n  public set readOnly(value: boolean);\n  public get readOnly(): boolean;\n\n  public set placeholder(value: string);\n  public get placeholder(): string;\n\n  /**\n   * Makes the selection equal to the current object.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select)\n   */\n  public select(): void;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected preparePastedText(text: string): string;\n  protected language: SbbLanguageController;\n}\n\nconst checkPlaintextOnlySupport = (): boolean => {\n  if (isServer) {\n    return false;\n  }\n\n  const div = document.createElement('div');\n  div.setAttribute('contenteditable', 'PLAINTEXT-ONLY');\n\n  // If plaintext-only is supported, the attribute value is\n  // returned as lower-case from the property access.\n  return div.contentEditable === 'plaintext-only';\n};\nconst plaintextOnlySupported = checkPlaintextOnlySupport();\n\n/**\n * The SbbFormAssociatedInputMixin enables native form support for text input controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedInputMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedInputMixinType> & T => {\n  // TODO(breaking-change): Remove SbbElementInternalsMixin and depend on SbbElement as base class instead of LitElement\n  const conditionalSuperClass = (superClass as unknown as Record<string, unknown>)['_$sbbElement$']\n    ? (superClass as unknown as AbstractConstructor<SbbElementInternalsMixinType> &\n        T &\n        SbbElementInternalsConstructor)\n    : SbbElementInternalsMixin(superClass);\n\n  abstract class SbbFormAssociatedInputElement\n    extends SbbReadonlyMixin(\n      SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass))),\n    )\n    implements Partial<SbbFormAssociatedInputMixinType>\n  {\n    public static override readonly role = 'textbox';\n    public static readonly formFieldAssociated = true;\n\n    /**\n     * An element with contenteditable will not emit a change event. To achieve parity\n     * with a native text input, we need to track whether a change event should be\n     * emitted.\n     */\n    private _shouldEmitChange = false;\n    /**\n     * A native text input attempts to submit the form when pressing Enter.\n     * This can be prevented by calling preventDefault on the keydown event.\n     * We track whether to request submit, which should occur before the keyup\n     * event.\n     */\n    private _shouldTriggerSubmit = false;\n\n    protected language = new SbbLanguageController(this);\n\n    /**\n     * Form type of element.\n     * @default 'text'\n     */\n    public override get type(): string {\n      return 'text';\n    }\n\n    /**\n     * The value of the input. Reflects the current text value of this input.\n     */\n    @property()\n    public set value(value: string) {\n      this._value = this._cleanText(value);\n      if (this.hasUpdated) {\n        this._assignValue(this._value);\n      }\n      /** @internal */\n      this.dispatchEvent(new Event('displayvaluechange', { bubbles: true, composed: true }));\n    }\n    public get value(): string {\n      return this._value ?? '';\n    }\n    private _value: string = '';\n\n    @property({ attribute: false })\n    public set placeholder(value: string) {\n      if (value) {\n        this.setAttribute('placeholder', value);\n      } else {\n        this.removeAttribute('placeholder');\n      }\n      this.internals.ariaPlaceholder = value ? value : null;\n    }\n    public get placeholder(): string {\n      return this.getAttribute('placeholder') ?? '';\n    }\n\n    protected constructor() {\n      super();\n      // We primarily use capture event listeners, as we want\n      // our listeners to occur before consumer event listeners.\n      this.addEventListener?.(\n        'input',\n        () => {\n          const oldValue = this._value;\n          this._value = this._cleanText(this.textContent ?? '');\n          this.requestUpdate('value', oldValue);\n          this.internals.states.add('interacted');\n          this._shouldEmitChange = true;\n        },\n        { capture: true },\n      );\n      this.addEventListener?.('change', () => (this._shouldEmitChange = false), { capture: true });\n      this.addEventListener?.(\n        'keydown',\n        (event) => {\n          if (this._requiresEmptyPatch()) {\n            this._assignValue('');\n          }\n          // We prevent recursive events by checking the original event for isTrusted\n          // which is false for manually dispatched events (which we dispatch below).\n          if ((event.key === 'Enter' || event.key === '\\n') && event.isTrusted) {\n            event.preventDefault();\n            event.stopImmediatePropagation();\n            this._shouldTriggerSubmit = this.dispatchEvent(new KeyboardEvent('keydown', event));\n          } else if (\n            isWebkit &&\n            this.value &&\n            (event.key === 'Backspace' || event.key === 'Delete') &&\n            event.isTrusted\n          ) {\n            // In Webkit pressing Backspace or Delete completely removes all the content\n            // if contenteditable is set on a web component host.\n            // We have to replicate the normal delete behavior.\n            event.preventDefault();\n            event.stopImmediatePropagation();\n\n            if (!this.dispatchEvent(new KeyboardEvent('keydown', event))) {\n              return;\n            }\n\n            const selectedRange = window.getSelection()?.getRangeAt(0);\n            if (!selectedRange) {\n              return;\n            }\n\n            if (selectedRange.startOffset !== selectedRange.endOffset) {\n              // If a text range is selected, then delete this range\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            } else if (event.key === 'Backspace' && selectedRange.startOffset > 0) {\n              // When pressing Backspace, we select the previous character from\n              // the current cursor position and delete it.\n              selectedRange.setStart(selectedRange.startContainer, selectedRange.startOffset - 1);\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            } else if (event.key === 'Delete' && selectedRange.endOffset < this.value.length) {\n              // When pressing Delete, we select the next character from\n              // the current cursor position and delete it.\n              selectedRange.setEnd(selectedRange.endContainer, selectedRange.endOffset + 1);\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            }\n          }\n        },\n        { capture: true },\n      );\n      this.addEventListener?.(\n        'keyup',\n        (event) => {\n          if (event.key === 'Enter' || event.key === '\\n') {\n            this._emitChangeIfNecessary();\n            if (this._shouldTriggerSubmit) {\n              this._shouldTriggerSubmit = false;\n              this.form?.requestSubmit();\n            }\n          } else if (this._requiresEmptyPatch()) {\n            this._setCursorAt(0);\n          }\n        },\n        { capture: true },\n      );\n      // contenteditable allows pasting rich content into its host.\n      // We prevent this by listening to the paste event and\n      // extracting the plain text from the pasted content\n      // and inserting it into the selected range (cursor position\n      // or selection).\n      this.addEventListener?.('paste', (e) => {\n        e.preventDefault();\n        if (this._requiresEmptyPatch()) {\n          this._assignValue('');\n        }\n\n        const text = this._cleanText(e.clipboardData?.getData('text/plain') ?? '');\n        const selectedRange = window.getSelection()?.getRangeAt(0);\n        if (!selectedRange || !text) {\n          return;\n        }\n\n        selectedRange.deleteContents();\n        selectedRange.insertNode(document.createTextNode(this.preparePastedText(text)));\n        selectedRange.setStart(selectedRange.endContainer, selectedRange.endOffset);\n        this._dispatchInputEvent();\n      });\n      // When focusing a text input via keyboard, the text content should be selected.\n      this.addEventListener?.('focus', () => {\n        if (sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n          // TODO: This does not seem to work in Firefox with readonly.\n          window.getSelection()?.selectAllChildren(this);\n        }\n      });\n      this.addEventListener?.('touchend', () => {\n        if (this._requiresEmptyPatch()) {\n          this._assignValue('&nbsp;');\n          this._setCursorAt(0);\n        }\n      });\n      this.addEventListener?.('click', () => {\n        if (this._requiresEmptyPatch() && sbbInputModalityDetector.mostRecentModality === 'touch') {\n          this._setCursorAt(0);\n        }\n      });\n\n      // On blur the native text input scrolls the text to the start of the text.\n      // We mimic that by resetting the scroll position.\n      // We also unset any selection to align with the native text input.\n      this.addEventListener?.(\n        'blur',\n        () => {\n          window.getSelection()?.removeAllRanges();\n          if (this.value === '') {\n            this._assignValue('');\n          }\n          this._emitChangeIfNecessary();\n          this.scrollLeft = 0;\n        },\n        { capture: true },\n      );\n    }\n\n    protected override isDisabledExternally(): boolean {\n      return this.formDisabled;\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this.internals.ariaMultiLine = 'false';\n      this._updateContenteditable();\n\n      // We want to replace any content by just the text content.\n      this._assignValue(this.value);\n    }\n\n    public override focus(options?: FocusOptions): void {\n      super.focus(options);\n      // By default, when calling focus on an input element, the cursor is placed\n      // at the end of the input text. However, with contenteditable, the cursor\n      // is placed at the beginning, so we move it to the end, if that is the case.\n      if (this._canSelect()) {\n        const selection = window.getSelection();\n        if (!selection) {\n          return;\n        }\n        const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;\n        if (range && range.startOffset !== 0) {\n          return;\n        }\n\n        this._setCursorAt(this.textContent!.length);\n      }\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      /**\n       * The native text input changes the value property when the value attribute is\n       * changed under the condition that no input event has occurred since creation\n       * or the last form reset.\n       */\n      if (name !== 'value' || !this.internals.states.has('interacted')) {\n        super.attributeChangedCallback(name, old, value);\n      }\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     *\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.internals.states.delete('interacted');\n      this.value = this.getAttribute('value') ?? '';\n    }\n\n    /**\n     *  Called when the browser is trying to restore element’s state to state in which case\n     *  reason is \"restore\", or when the browser is trying to fulfill autofill on behalf of\n     *  user in which case reason is \"autocomplete\".\n     *  In the case of \"restore\", state is a string, File, or FormData object\n     *  previously set as the second argument to setFormValue.\n     *\n     * @internal\n     */\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (state && typeof state === 'string') {\n        this.value = state;\n      }\n    }\n\n    /**\n     * Makes the selection equal to the current object.\n     *\n     * @link https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select\n     */\n    public select(): void {\n      window.getSelection()?.selectAllChildren(this);\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n\n      // If the value was assigned before firstUpdate, we have to\n      // write it the document to be visually seen\n      if (this.value && !this.innerHTML.length) {\n        this._assignValue(this.value);\n      }\n    }\n\n    public override requestUpdate(\n      name?: PropertyKey,\n      oldValue?: unknown,\n      options?: PropertyDeclaration,\n    ): void {\n      super.requestUpdate(name, oldValue, options);\n      if (\n        this.isConnected &&\n        (name === 'disabled' || name === 'formDisabled' || name === 'readOnly')\n      ) {\n        this._updateContenteditable();\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'value' || name === 'required';\n    }\n\n    protected override validate(): void {\n      super.validate();\n      if (this.required && !this.value) {\n        this.setValidityFlag('valueMissing', i18nInputRequired[this.language.current]);\n      } else {\n        this.removeValidityFlag('valueMissing');\n      }\n    }\n\n    protected preparePastedText(text: string): string {\n      return text;\n    }\n\n    private _requiresEmptyPatch(): boolean {\n      // In Blink, a contenteditable element with empty content will crash\n      // upon receiving focus, when in Mobile mode.\n      // To prevent this, we patch the empty state by inserting a non-breaking space.\n      return isServer\n        ? false\n        : isBlink && this.value === '' && window.matchMedia(SbbMediaQueryPointerCoarse).matches;\n    }\n\n    private _assignValue(value: string): void {\n      this.innerHTML = value;\n    }\n\n    private _setCursorAt(position: number): void {\n      const selection = window.getSelection();\n      if (!selection) {\n        return;\n      }\n\n      const range = document.createRange();\n      range.setStart(this.firstChild!, position);\n      range.collapse(true);\n      selection.removeAllRanges();\n      selection.addRange(range);\n    }\n\n    private _cleanText(value: string): string {\n      // The native text input removes all newline characters if passed to the value property\n      return value === null ? '' : `${value}`.replace(/[\\n\\r]+/g, '');\n    }\n\n    private _dispatchInputEvent(): 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    @eventOptions({ passive: true })\n    private _cleanChildren(): void {\n      if (this.childElementCount) {\n        for (const element of this.children) {\n          element.remove();\n        }\n      }\n    }\n\n    private _updateContenteditable(): void {\n      if (!isServer && this.isConnected) {\n        this.internals.ariaReadOnly = this.readOnly ? 'true' : null;\n        this.internals.ariaDisabled = this.disabled ? 'true' : null;\n        // TODO(2026): Firefox supports plaintext-only since version 136 (March 2025).\n        // Until this is part of our baseline, we should feature check to enable it.\n        const value =\n          this.disabled || this.readOnly\n            ? 'false'\n            : plaintextOnlySupported\n              ? 'plaintext-only'\n              : 'true';\n        this.setAttribute('contenteditable', value);\n        // In the readonly case, we disable contenteditable, but it still\n        // needs to be focusable. We achieve this by setting tabindex in that case.\n        if (this.readOnly) {\n          this.setAttribute('tabindex', '0');\n        } else {\n          this.removeAttribute('tabindex');\n        }\n      }\n    }\n\n    private _emitChangeIfNecessary(): void {\n      if (this._shouldEmitChange) {\n        this._shouldEmitChange = false;\n        /** 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. */\n        this.dispatchEvent(new Event('change', { bubbles: true }));\n      }\n    }\n\n    private _canSelect(): boolean {\n      return !isServer && !this.disabled && !this.readOnly && !!this.value;\n    }\n\n    protected override render(): unknown {\n      return html`<slot @slotchange=${this._cleanChildren}></slot>`;\n    }\n  }\n\n  return SbbFormAssociatedInputElement as unknown as AbstractConstructor<SbbFormAssociatedInputMixinType> &\n    T;\n};\n"],"names":[],"mappings":"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"}
+//#endregion
+export { SbbFormAssociatedInputMixin };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"form-associated-input-mixin.js","names":[],"sources":["../../../../../src/elements/core/mixins/form-associated-input-mixin.ts"],"sourcesContent":["import {\n  html,\n  isServer,\n  type LitElement,\n  type PropertyDeclaration,\n  type PropertyValues,\n} from 'lit';\nimport { eventOptions, property } from 'lit/decorators.js';\n\nimport { sbbInputModalityDetector } from '../a11y.ts';\nimport { SbbLanguageController, SbbMediaQueryPointerCoarse } from '../controllers.ts';\nimport { isBlink, isWebkit } from '../dom.ts';\nimport { i18nInputRequired } from '../i18n.ts';\n\nimport type { AbstractConstructor } from './constructor.ts';\nimport { SbbDisabledMixin } from './disabled-mixin.ts';\nimport {\n  SbbElementInternalsMixin,\n  type SbbElementInternalsMixinType,\n  type SbbElementInternalsConstructor,\n} from './element-internals-mixin.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from './form-associated-mixin.ts';\nimport { SbbReadonlyMixin } from './readonly-mixin.ts';\nimport { SbbRequiredMixin } from './required-mixin.ts';\n\nexport declare abstract class SbbFormAssociatedInputMixinType extends SbbRequiredMixin(\n  SbbFormAssociatedMixin(SbbElementInternalsMixin(LitElement)),\n) {\n  public static readonly formFieldAssociated = true;\n\n  public set value(value: string);\n  public get value(): string;\n\n  public set disabled(value: boolean);\n  public get disabled(): boolean;\n\n  public set readOnly(value: boolean);\n  public get readOnly(): boolean;\n\n  public set placeholder(value: string);\n  public get placeholder(): string;\n\n  /**\n   * Makes the selection equal to the current object.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select)\n   */\n  public select(): void;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected preparePastedText(text: string): string;\n  protected language: SbbLanguageController;\n}\n\nconst checkPlaintextOnlySupport = (): boolean => {\n  if (isServer) {\n    return false;\n  }\n\n  const div = document.createElement('div');\n  div.setAttribute('contenteditable', 'PLAINTEXT-ONLY');\n\n  // If plaintext-only is supported, the attribute value is\n  // returned as lower-case from the property access.\n  return div.contentEditable === 'plaintext-only';\n};\nconst plaintextOnlySupported = checkPlaintextOnlySupport();\n\n/**\n * The SbbFormAssociatedInputMixin enables native form support for text input controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedInputMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedInputMixinType> & T => {\n  // TODO(breaking-change): Remove SbbElementInternalsMixin and depend on SbbElement as base class instead of LitElement\n  const conditionalSuperClass = (superClass as unknown as Record<string, unknown>)['_$sbbElement$']\n    ? (superClass as unknown as AbstractConstructor<SbbElementInternalsMixinType> &\n        T &\n        SbbElementInternalsConstructor)\n    : SbbElementInternalsMixin(superClass);\n\n  abstract class SbbFormAssociatedInputElement\n    extends SbbReadonlyMixin(\n      SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(conditionalSuperClass))),\n    )\n    implements Partial<SbbFormAssociatedInputMixinType>\n  {\n    public static override readonly role = 'textbox';\n    public static readonly formFieldAssociated = true;\n\n    /**\n     * An element with contenteditable will not emit a change event. To achieve parity\n     * with a native text input, we need to track whether a change event should be\n     * emitted.\n     */\n    private _shouldEmitChange = false;\n    /**\n     * A native text input attempts to submit the form when pressing Enter.\n     * This can be prevented by calling preventDefault on the keydown event.\n     * We track whether to request submit, which should occur before the keyup\n     * event.\n     */\n    private _shouldTriggerSubmit = false;\n\n    protected language = new SbbLanguageController(this);\n\n    /**\n     * Form type of element.\n     * @default 'text'\n     */\n    public override get type(): string {\n      return 'text';\n    }\n\n    /**\n     * The value of the input. Reflects the current text value of this input.\n     */\n    @property()\n    public set value(value: string) {\n      this._value = this._cleanText(value);\n      if (this.hasUpdated) {\n        this._assignValue(this._value);\n      }\n      /** @internal */\n      this.dispatchEvent(new Event('displayvaluechange', { bubbles: true, composed: true }));\n    }\n    public get value(): string {\n      return this._value ?? '';\n    }\n    private _value: string = '';\n\n    @property({ attribute: false })\n    public set placeholder(value: string) {\n      if (value) {\n        this.setAttribute('placeholder', value);\n      } else {\n        this.removeAttribute('placeholder');\n      }\n      this.internals.ariaPlaceholder = value ? value : null;\n    }\n    public get placeholder(): string {\n      return this.getAttribute('placeholder') ?? '';\n    }\n\n    protected constructor() {\n      super();\n      // We primarily use capture event listeners, as we want\n      // our listeners to occur before consumer event listeners.\n      this.addEventListener?.(\n        'input',\n        () => {\n          const oldValue = this._value;\n          this._value = this._cleanText(this.textContent ?? '');\n          this.requestUpdate('value', oldValue);\n          this.internals.states.add('interacted');\n          this._shouldEmitChange = true;\n        },\n        { capture: true },\n      );\n      this.addEventListener?.('change', () => (this._shouldEmitChange = false), { capture: true });\n      this.addEventListener?.(\n        'keydown',\n        (event) => {\n          if (this._requiresEmptyPatch()) {\n            this._assignValue('');\n          }\n          // We prevent recursive events by checking the original event for isTrusted\n          // which is false for manually dispatched events (which we dispatch below).\n          if ((event.key === 'Enter' || event.key === '\\n') && event.isTrusted) {\n            event.preventDefault();\n            event.stopImmediatePropagation();\n            this._shouldTriggerSubmit = this.dispatchEvent(new KeyboardEvent('keydown', event));\n          } else if (\n            isWebkit &&\n            this.value &&\n            (event.key === 'Backspace' || event.key === 'Delete') &&\n            event.isTrusted\n          ) {\n            // In Webkit pressing Backspace or Delete completely removes all the content\n            // if contenteditable is set on a web component host.\n            // We have to replicate the normal delete behavior.\n            event.preventDefault();\n            event.stopImmediatePropagation();\n\n            if (!this.dispatchEvent(new KeyboardEvent('keydown', event))) {\n              return;\n            }\n\n            const selectedRange = window.getSelection()?.getRangeAt(0);\n            if (!selectedRange) {\n              return;\n            }\n\n            if (selectedRange.startOffset !== selectedRange.endOffset) {\n              // If a text range is selected, then delete this range\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            } else if (event.key === 'Backspace' && selectedRange.startOffset > 0) {\n              // When pressing Backspace, we select the previous character from\n              // the current cursor position and delete it.\n              selectedRange.setStart(selectedRange.startContainer, selectedRange.startOffset - 1);\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            } else if (event.key === 'Delete' && selectedRange.endOffset < this.value.length) {\n              // When pressing Delete, we select the next character from\n              // the current cursor position and delete it.\n              selectedRange.setEnd(selectedRange.endContainer, selectedRange.endOffset + 1);\n              selectedRange.deleteContents();\n              this._dispatchInputEvent();\n            }\n          }\n        },\n        { capture: true },\n      );\n      this.addEventListener?.(\n        'keyup',\n        (event) => {\n          if (event.key === 'Enter' || event.key === '\\n') {\n            this._emitChangeIfNecessary();\n            if (this._shouldTriggerSubmit) {\n              this._shouldTriggerSubmit = false;\n              this.form?.requestSubmit();\n            }\n          } else if (this._requiresEmptyPatch()) {\n            this._setCursorAt(0);\n          }\n        },\n        { capture: true },\n      );\n      // contenteditable allows pasting rich content into its host.\n      // We prevent this by listening to the paste event and\n      // extracting the plain text from the pasted content\n      // and inserting it into the selected range (cursor position\n      // or selection).\n      this.addEventListener?.('paste', (e) => {\n        e.preventDefault();\n        if (this._requiresEmptyPatch()) {\n          this._assignValue('');\n        }\n\n        const text = this._cleanText(e.clipboardData?.getData('text/plain') ?? '');\n        const selectedRange = window.getSelection()?.getRangeAt(0);\n        if (!selectedRange || !text) {\n          return;\n        }\n\n        selectedRange.deleteContents();\n        selectedRange.insertNode(document.createTextNode(this.preparePastedText(text)));\n        selectedRange.setStart(selectedRange.endContainer, selectedRange.endOffset);\n        this._dispatchInputEvent();\n      });\n      // When focusing a text input via keyboard, the text content should be selected.\n      this.addEventListener?.('focus', () => {\n        if (sbbInputModalityDetector.mostRecentModality === 'keyboard') {\n          // TODO: This does not seem to work in Firefox with readonly.\n          window.getSelection()?.selectAllChildren(this);\n        }\n      });\n      this.addEventListener?.('touchend', () => {\n        if (this._requiresEmptyPatch()) {\n          this._assignValue('&nbsp;');\n          this._setCursorAt(0);\n        }\n      });\n      this.addEventListener?.('click', () => {\n        if (this._requiresEmptyPatch() && sbbInputModalityDetector.mostRecentModality === 'touch') {\n          this._setCursorAt(0);\n        }\n      });\n\n      // On blur the native text input scrolls the text to the start of the text.\n      // We mimic that by resetting the scroll position.\n      // We also unset any selection to align with the native text input.\n      this.addEventListener?.(\n        'blur',\n        () => {\n          window.getSelection()?.removeAllRanges();\n          if (this.value === '') {\n            this._assignValue('');\n          }\n          this._emitChangeIfNecessary();\n          this.scrollLeft = 0;\n        },\n        { capture: true },\n      );\n    }\n\n    protected override isDisabledExternally(): boolean {\n      return this.formDisabled;\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this.internals.ariaMultiLine = 'false';\n      this._updateContenteditable();\n\n      // We want to replace any content by just the text content.\n      this._assignValue(this.value);\n    }\n\n    public override focus(options?: FocusOptions): void {\n      super.focus(options);\n      // By default, when calling focus on an input element, the cursor is placed\n      // at the end of the input text. However, with contenteditable, the cursor\n      // is placed at the beginning, so we move it to the end, if that is the case.\n      if (this._canSelect()) {\n        const selection = window.getSelection();\n        if (!selection) {\n          return;\n        }\n        const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;\n        if (range && range.startOffset !== 0) {\n          return;\n        }\n\n        this._setCursorAt(this.textContent!.length);\n      }\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      /**\n       * The native text input changes the value property when the value attribute is\n       * changed under the condition that no input event has occurred since creation\n       * or the last form reset.\n       */\n      if (name !== 'value' || !this.internals.states.has('interacted')) {\n        super.attributeChangedCallback(name, old, value);\n      }\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     *\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.internals.states.delete('interacted');\n      this.value = this.getAttribute('value') ?? '';\n    }\n\n    /**\n     *  Called when the browser is trying to restore element’s state to state in which case\n     *  reason is \"restore\", or when the browser is trying to fulfill autofill on behalf of\n     *  user in which case reason is \"autocomplete\".\n     *  In the case of \"restore\", state is a string, File, or FormData object\n     *  previously set as the second argument to setFormValue.\n     *\n     * @internal\n     */\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (state && typeof state === 'string') {\n        this.value = state;\n      }\n    }\n\n    /**\n     * Makes the selection equal to the current object.\n     *\n     * @link https://developer.mozilla.org/docs/Web/API/HTMLInputElement/select\n     */\n    public select(): void {\n      window.getSelection()?.selectAllChildren(this);\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n\n      // If the value was assigned before firstUpdate, we have to\n      // write it the document to be visually seen\n      if (this.value && !this.innerHTML.length) {\n        this._assignValue(this.value);\n      }\n    }\n\n    public override requestUpdate(\n      name?: PropertyKey,\n      oldValue?: unknown,\n      options?: PropertyDeclaration,\n    ): void {\n      super.requestUpdate(name, oldValue, options);\n      if (\n        this.isConnected &&\n        (name === 'disabled' || name === 'formDisabled' || name === 'readOnly')\n      ) {\n        this._updateContenteditable();\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'value' || name === 'required';\n    }\n\n    protected override validate(): void {\n      super.validate();\n      if (this.required && !this.value) {\n        this.setValidityFlag('valueMissing', i18nInputRequired[this.language.current]);\n      } else {\n        this.removeValidityFlag('valueMissing');\n      }\n    }\n\n    protected preparePastedText(text: string): string {\n      return text;\n    }\n\n    private _requiresEmptyPatch(): boolean {\n      // In Blink, a contenteditable element with empty content will crash\n      // upon receiving focus, when in Mobile mode.\n      // To prevent this, we patch the empty state by inserting a non-breaking space.\n      return isServer\n        ? false\n        : isBlink && this.value === '' && window.matchMedia(SbbMediaQueryPointerCoarse).matches;\n    }\n\n    private _assignValue(value: string): void {\n      this.innerHTML = value;\n    }\n\n    private _setCursorAt(position: number): void {\n      const selection = window.getSelection();\n      if (!selection) {\n        return;\n      }\n\n      const range = document.createRange();\n      range.setStart(this.firstChild!, position);\n      range.collapse(true);\n      selection.removeAllRanges();\n      selection.addRange(range);\n    }\n\n    private _cleanText(value: string): string {\n      // The native text input removes all newline characters if passed to the value property\n      return value === null ? '' : `${value}`.replace(/[\\n\\r]+/g, '');\n    }\n\n    private _dispatchInputEvent(): 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    @eventOptions({ passive: true })\n    private _cleanChildren(): void {\n      if (this.childElementCount) {\n        for (const element of this.children) {\n          element.remove();\n        }\n      }\n    }\n\n    private _updateContenteditable(): void {\n      if (!isServer && this.isConnected) {\n        this.internals.ariaReadOnly = this.readOnly ? 'true' : null;\n        this.internals.ariaDisabled = this.disabled ? 'true' : null;\n        // TODO(2026): Firefox supports plaintext-only since version 136 (March 2025).\n        // Until this is part of our baseline, we should feature check to enable it.\n        const value =\n          this.disabled || this.readOnly\n            ? 'false'\n            : plaintextOnlySupported\n              ? 'plaintext-only'\n              : 'true';\n        this.setAttribute('contenteditable', value);\n        // In the readonly case, we disable contenteditable, but it still\n        // needs to be focusable. We achieve this by setting tabindex in that case.\n        if (this.readOnly) {\n          this.setAttribute('tabindex', '0');\n        } else {\n          this.removeAttribute('tabindex');\n        }\n      }\n    }\n\n    private _emitChangeIfNecessary(): void {\n      if (this._shouldEmitChange) {\n        this._shouldEmitChange = false;\n        /** 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. */\n        this.dispatchEvent(new Event('change', { bubbles: true }));\n      }\n    }\n\n    private _canSelect(): boolean {\n      return !isServer && !this.disabled && !this.readOnly && !!this.value;\n    }\n\n    protected override render(): unknown {\n      return html`<slot @slotchange=${this._cleanChildren}></slot>`;\n    }\n  }\n\n  return SbbFormAssociatedInputElement as unknown as AbstractConstructor<SbbFormAssociatedInputMixinType> &\n    T;\n};\n"],"mappings":"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"}