@sbb-esta/lyne-elements 2.4.1 → 2.5.1

package/development/core/mixins.js

@@ -15,6 +15,54 @@ import { i18nCheckboxRequired, i18nInputRequired, i18nSelectionRequired } from "
 import { isWebkit, isFirefox } from "./dom.js";
 import { sbbInputModalityDetector, interactivityChecker, isArrowKeyPressed, getNextElementIndex } from "./a11y.js";
 import "../screen-reader-only.js";
+const SbbAnimationCompleteMixin = (superClass) => {
+  class SbbAnimationCompleteElement extends superClass {
+    constructor() {
+      super(...arguments);
+      this.isAnimating = false;
+      this._animationPromise = Promise.resolve();
+    }
+    /**
+     * Returns a promise which completes whenever an animation ends.
+     * When a new animation starts, a new Promise is returned.
+     */
+    get animationComplete() {
+      return this._animationPromise;
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this.stopAnimation();
+    }
+    startAnimation() {
+      if (!this.isAnimating) {
+        this._animationPromise = this._enqueueAnimation();
+      }
+    }
+    /**
+     * Overriding stopAnimation() breaks functionality.
+     */
+    stopAnimation() {
+    }
+    async _enqueueAnimation() {
+      this.isAnimating = true;
+      const stopAnimation = this.stopAnimation;
+      const result = new Promise((r) => {
+        this.stopAnimation = () => {
+          stopAnimation();
+          this.isAnimating = false;
+          r();
+        };
+      });
+      try {
+        await this._animationPromise;
+      } catch (e) {
+        Promise.reject(e);
+      }
+      return result;
+    }
+  }
+  return SbbAnimationCompleteElement;
+};
 const SbbDisabledMixin = (superClass) => {
   let SbbDisabledElement = (() => {
     var _disabled_accessor_storage, _a;
@@ -731,6 +779,12 @@ const SbbFormAssociatedInputMixin = (superClass) => {
           this.value = state2;
         }
       }
+      async firstUpdated(changedProperties) {
+        super.firstUpdated(changedProperties);
+        if (this.value && !this.innerHTML.length) {
+          this.innerHTML = this.value;
+        }
+      }
       updateFormValue() {
         this.internals.setFormValue(this.value, this.value);
       }
@@ -841,7 +895,6 @@ const SbbFormAssociatedRadioButtonMixin = (superClass) => {
         super();
         this._checked = (__runInitializers(this, _instanceExtraInitializers), false);
         this.abort = new SbbConnectedAbortController(this);
-        this._didLoad = false;
         this._languageController = new SbbLanguageController(this);
         this.internals.role = "radio";
         (_a2 = this.addEventListener) == null ? void 0 : _a2.call(this, "keydown", (e) => this._handleArrowKeyDown(e));
@@ -881,7 +934,6 @@ const SbbFormAssociatedRadioButtonMixin = (superClass) => {
       }
       firstUpdated(changedProperties) {
         super.firstUpdated(changedProperties);
-        this._didLoad = true;
         this.updateFocusableRadios();
       }
       /**
@@ -925,7 +977,7 @@ const SbbFormAssociatedRadioButtonMixin = (superClass) => {
        * - the first non-disabled radio in DOM order;
        */
       updateFocusableRadios() {
-        if (!this._didLoad) {
+        if (!this.hasUpdated) {
           return;
         }
         const radios = this._interactableGroupedRadios();
@@ -1432,6 +1484,7 @@ slot[name=subtext] {
   display: none;
 }`;
 export {
+  SbbAnimationCompleteMixin,
   SbbDisabledInteractiveMixin,
   SbbDisabledMixin,
   SbbDisabledTabIndexActionMixin,
@@ -1448,4 +1501,4 @@ export {
   panelCommon as panelCommonStyle,
   radioButtonRegistry
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mixins.js","sources":["../../../../src/elements/core/mixins/disabled-mixin.ts","../../../../src/elements/core/mixins/form-associated-mixin.ts","../../../../src/elements/core/mixins/required-mixin.ts","../../../../src/elements/core/mixins/form-associated-checkbox-mixin.ts","../../../../src/elements/core/mixins/form-associated-input-mixin.ts","../../../../src/elements/core/mixins/form-associated-radio-button-mixin.ts","../../../../src/elements/core/mixins/hydration-mixin.ts","../../../../src/elements/core/mixins/named-slot-list-mixin.ts","../../../../src/elements/core/mixins/negative-mixin.ts","../../../../src/elements/core/mixins/panel-mixin.ts","../../../../src/elements/core/mixins/update-scheduler-mixin.ts"],"sourcesContent":["import type { LitElement, PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType, getOverride } from '../decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\nimport type { SbbFormAssociatedMixinType } from './form-associated-mixin.js';\n\nexport declare class SbbDisabledMixinType {\n  public accessor disabled: boolean;\n  protected isDisabledExternally(): boolean;\n}\n\nexport declare class SbbDisabledInteractiveMixinType {\n  public accessor disabledInteractive: boolean;\n}\n\n/**\n * Enhance your component with a disabled property.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbDisabledMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbDisabledMixinType> & T => {\n  abstract class SbbDisabledElement extends superClass implements Partial<SbbDisabledMixinType> {\n    /** Whether the component is disabled. */\n    @forceType()\n    @property({ reflect: true, type: Boolean })\n    @getOverride((e: SbbDisabledElement, v: boolean): boolean => v || e.isDisabledExternally())\n    public accessor disabled: boolean = false;\n\n    /**\n     * Will be used as 'or' check to the current disabled state.\n     * Can e.g. be used to read disabled state of a group.\n     */\n    protected isDisabledExternally(): boolean {\n      return false;\n    }\n  }\n\n  return SbbDisabledElement as unknown as AbstractConstructor<SbbDisabledMixinType> & T;\n};\n\n/**\n * Enhance your component with a disabled interactive property.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbDisabledInteractiveMixin = <\n  T extends AbstractConstructor<LitElement & SbbDisabledMixinType>,\n>(\n  superClass: T,\n): AbstractConstructor<SbbDisabledInteractiveMixinType> & T => {\n  abstract class SbbDisabledInteractiveElement\n    extends superClass\n    implements Partial<SbbDisabledInteractiveMixinType>\n  {\n    /** Whether the button should be aria-disabled but stay interactive. */\n    @forceType()\n    @property({ attribute: 'disabled-interactive', type: Boolean, reflect: true })\n    public accessor disabledInteractive: boolean = false;\n  }\n\n  return SbbDisabledInteractiveElement as unknown as AbstractConstructor<SbbDisabledInteractiveMixinType> &\n    T;\n};\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbDisabledTabIndexActionMixin = <\n  T extends AbstractConstructor<LitElement & SbbFormAssociatedMixinType>,\n>(\n  superClass: T,\n): AbstractConstructor<SbbDisabledMixinType & SbbDisabledInteractiveMixinType> & T => {\n  abstract class SbbDisabledTabIndexAction\n    extends SbbDisabledInteractiveMixin(SbbDisabledMixin(superClass))\n    implements SbbDisabledMixinType, SbbDisabledInteractiveMixinType\n  {\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('disabledInteractive')) {\n        this.internals.ariaDisabled = this.disabledInteractive ? 'true' : null;\n      }\n\n      if (!changedProperties.has('disabled')) {\n        return;\n      }\n\n      if (!this.disabled) {\n        this.setAttribute('tabindex', '0');\n      } else {\n        this.removeAttribute('tabindex');\n      }\n    }\n  }\n  return SbbDisabledTabIndexAction as AbstractConstructor<\n    SbbDisabledMixinType & SbbDisabledInteractiveMixinType\n  > &\n    T;\n};\n","/* eslint-disable @typescript-eslint/no-empty-object-type */\nimport type { LitElement, PropertyDeclaration, PropertyValues } from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport { isWebkit } from '../dom.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\ndeclare global {\n  /**\n   * Defines custom valididty state properties.\n   */\n  interface CustomValidityState {}\n  interface ValidityState extends CustomValidityState {}\n  interface ValidityStateFlags extends Partial<CustomValidityState> {}\n}\n\nconst validityKeys: Required<Omit<ValidityStateFlags, keyof CustomValidityState>> = {\n  badInput: false,\n  customError: false,\n  patternMismatch: false,\n  rangeOverflow: false,\n  rangeUnderflow: false,\n  stepMismatch: false,\n  tooLong: false,\n  tooShort: false,\n  typeMismatch: false,\n  valueMissing: false,\n};\n// We need ValidityState in the global context, as we check the prototype for\n// extensions. In environments where that is not the case (e.g. Node.js) we\n// patch it with a minimal shim.\nif (typeof ValidityState === 'undefined') {\n  const validityClass = class ValidityState {\n    public get valid(): boolean {\n      return true;\n    }\n    private constructor() {\n      throw new TypeError('Illegal constructor');\n    }\n  };\n  Object.entries(validityKeys).forEach(([key, value]) =>\n    Object.assign(validityClass.prototype, {\n      get [key](): boolean {\n        return value;\n      },\n    }),\n  );\n  globalThis.ValidityState = validityClass as unknown as typeof ValidityState;\n}\n\nexport declare abstract class SbbFormAssociatedMixinType<V = string> {\n  public get form(): HTMLFormElement | null;\n  public accessor name: string;\n  public get type(): string;\n  public accessor value: V | null;\n\n  public get validity(): ValidityState;\n  public get validationMessage(): string;\n  public get willValidate(): boolean;\n\n  protected formDisabled: boolean;\n  protected readonly internals: ElementInternals;\n\n  public checkValidity(): boolean;\n  public reportValidity(): boolean;\n  public setCustomValidity(message: string): void;\n\n  public formAssociatedCallback?(form: HTMLFormElement | null): void;\n  public formDisabledCallback(disabled: boolean): void;\n  public abstract formResetCallback(): void;\n  public abstract formStateRestoreCallback(\n    state: FormRestoreState | null,\n    reason: FormRestoreReason,\n  ): void;\n\n  protected abstract updateFormValue(): void;\n  protected setValidityFlag<T extends keyof ValidityStateFlags>(\n    flag: T,\n    message: string,\n    flagValue?: ValidityStateFlags[T],\n  ): void;\n  protected removeValidityFlag<T extends keyof ValidityStateFlags>(flag: T): void;\n  protected validate(): void;\n  protected shouldValidate(name: PropertyKey | undefined): boolean;\n}\n\n/**\n * The FormAssociatedMixin enables native form support for custom controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedMixin = <T extends AbstractConstructor<LitElement>, V = string>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedMixinType<V>> & T => {\n  abstract class SbbFormAssociatedElement\n    extends superClass\n    implements Partial<SbbFormAssociatedMixinType<V>>\n  {\n    public static formAssociated = true;\n\n    /**\n     * Returns the form owner of this element.\n     */\n    public get form(): HTMLFormElement | null {\n      return this.internals.form;\n    }\n\n    /**\n     * Name of the form element. Will be read from name attribute.\n     *\n     * @description Developer note: In this case updating the attribute must be synchronous.\n     * Due to this it is implemented as a getter/setter and the attributeChangedCallback() handles the diff check.\n     */\n    @property()\n    public set name(name: string) {\n      this.setAttribute('name', `${name}`);\n\n      // For `FormData` values, we have to manually update the fieldName key\n      this.updateFormValue();\n    }\n    public get name(): string {\n      return this.getAttribute('name') ?? '';\n    }\n\n    /** @internal */\n    public get type(): string {\n      return this.localName;\n    }\n\n    /** Value of the form element. */\n    @property()\n    public set value(value: V | null) {\n      this._value = value;\n      this.updateFormValue();\n    }\n    public get value(): V | null {\n      return this._value;\n    }\n    private _value: V | null = null;\n\n    /**\n     * Returns the ValidityState object for this element.\n     */\n    public get validity(): ValidityState {\n      return this.internals.validity;\n    }\n\n    /**\n     * Returns the current error message, if available, which corresponds\n     * to the current validation state.\n     * Please note that only one message is returned at a time (e.g. if\n     * multiple validity states are invalid, only the chronologically first one\n     * is returned until it is fixed, at which point the next message might be\n     * returned, if it is still applicable). Also a custom validity message\n     * (see below) has precedence over native validation messages.\n     */\n    public get validationMessage(): string {\n      return this.internals.validationMessage;\n    }\n\n    /**\n     * Returns true if this element will be validated\n     * when the form is submitted; false otherwise.\n     */\n    public get willValidate(): boolean {\n      return this.internals.willValidate;\n    }\n\n    /** @internal */\n    protected readonly internals: ElementInternals = this.attachInternals();\n\n    private _validityStates = new Map<\n      keyof ValidityStateFlags,\n      { flagValue: unknown; message: string }\n    >();\n\n    /** Whenever a surrounding form or fieldset is changing its disabled state. */\n    @state() protected accessor formDisabled: boolean = false;\n\n    public constructor(...args: any[]) {\n      super(...args);\n      // We want to prevent the native browser validation message popover\n      // to be shown. This also prevents a bug in WebKit, which would not\n      // allow host as the validity anchor: https://bugs.webkit.org/show_bug.cgi?id=269832\n      this.addEventListener?.('invalid', (e) => e.preventDefault());\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      if (name !== 'name' || old !== value) {\n        super.attributeChangedCallback(name, old, value);\n      }\n    }\n\n    /**\n     * Returns true if this element has no validity problems; false otherwise.\n     * Fires an invalid event at the element in the latter case.\n     */\n    public checkValidity(): boolean {\n      return this.internals.checkValidity();\n    }\n\n    /**\n     * Returns true if this element has no validity problems; otherwise,\n     * returns false, fires an invalid event at the element,\n     * and (if the event isn't canceled) reports the problem to the user.\n     */\n    public reportValidity(): boolean {\n      return this.internals.reportValidity();\n    }\n\n    /**\n     * Sets the custom validity message for this element. Use the empty string\n     * to indicate that the element does not have a custom validity error.\n     */\n    public setCustomValidity(message: string): void {\n      if (message) {\n        this.setValidityFlag('customError', message);\n      } else {\n        this.removeValidityFlag('customError');\n      }\n    }\n\n    /**\n     * Called when the associated form element changes.\n     * ElementInternals.form returns the associated from element.\n     *\n     * @internal\n     */\n    public formAssociatedCallback?(form: HTMLFormElement | null): void;\n\n    /**\n     * Is called whenever a surrounding form / fieldset changes disabled state.\n     * @param disabled\n     *\n     * @internal\n     */\n    public formDisabledCallback(disabled: boolean): void {\n      // This callback is triggered if the disabled property changes or the disabled attribute of a fieldset or form changes.\n      // We need to postpone the assignment, otherwise it interferes with disabled status setting\n      // and leads to a wrong state (e.g. embedded sbb-visual-checkbox).\n      Promise.resolve().then(() => {\n        this.formDisabled = disabled;\n      });\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     *\n     * @internal\n     */\n    public abstract formResetCallback(): void;\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 abstract formStateRestoreCallback(\n      state: FormRestoreState | null,\n      reason: FormRestoreReason,\n    ): void;\n\n    public override requestUpdate(\n      name?: PropertyKey,\n      oldValue?: unknown,\n      options?: PropertyDeclaration,\n    ): void {\n      super.requestUpdate(name, oldValue, options);\n      if (this.hasUpdated && this.shouldValidate(name)) {\n        this.validate();\n      }\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n      this.validate();\n    }\n\n    /**\n     * Should be called when form value is changed.\n     * Adapts and sets the formValue in the supported format (string | FormData | File | null)\n     * https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals/setFormValue\n     */\n    protected abstract updateFormValue(): void;\n\n    /**\n     * Marks this element as suffering from the constraint indicated by the\n     * flag argument and associates the given message to it.\n     * Note that only one message is displayed at a time and custom messages by\n     * consumers are always displayed before internal messages and internal\n     * messages are displayed in the order they were added.\n     * To set/define custom validity state flags, you need to extend the\n     * ValidityState prototype (and the CustomValidityState interface).\n     *\n     * @example\n     *\n     *   // The type of the custom validity state does not need to be boolean.\n     *   Object.assign(ValidityState.prototype, {\n     *     get myError(): boolean {\n     *       return false;\n     *     },\n     *   });\n     *\n     *   declare global {\n     *     interface CustomValidityState {\n     *       myError: boolean;\n     *     }\n     *   }\n     */\n    protected setValidityFlag<T extends keyof ValidityStateFlags>(\n      flag: T,\n      message: string,\n      flagValue?: ValidityStateFlags[T],\n    ): void {\n      flagValue ??= true;\n      const validityState = this._validityStates.get(flag);\n      if (\n        !validityState ||\n        validityState.message !== message ||\n        validityState.flagValue !== flagValue\n      ) {\n        this._validityStates.set(flag, { flagValue, message });\n        this._setInternalValidity();\n      }\n    }\n\n    /** Removes the validity state flag entry and updates validity state. */\n    protected removeValidityFlag<T extends keyof ValidityStateFlags>(flag: T): void {\n      if (this._validityStates.has(flag)) {\n        this._validityStates.delete(flag);\n        this._setInternalValidity();\n      }\n    }\n\n    /** To be called whenever the current element needs to be validated. */\n    protected validate(): void {}\n\n    /** Whether validation should be run on a property change with the given name. */\n    protected shouldValidate(name: PropertyKey | undefined): boolean {\n      return !name;\n    }\n\n    private _setInternalValidity(): void {\n      let outputMessage = this._validityStates.get('customError')?.message;\n      const flags: ValidityStateFlags = {};\n      this._validityStates.forEach(({ flagValue, message }, flag) => {\n        flags[flag] = flagValue as any;\n        outputMessage ||= message;\n      });\n\n      const customFlags = Object.keys(ValidityState.prototype).filter(\n        (f) => !(f in validityKeys) && f !== 'valid',\n      );\n      for (const flag of customFlags) {\n        const value = flag in flags ? flags[flag as keyof ValidityStateFlags] : false;\n        Object.defineProperty(this.internals.validity, flag, { value, configurable: true });\n        if (value) {\n          // If any custom errors are provided, we need to set customError to true,\n          // as this is the only custom error property browsers accept.\n          flags.customError = true;\n        }\n      }\n\n      this.internals.setValidity(flags, outputMessage);\n\n      // WebKit seems to always set customError to true, if any error is active.\n      // Due to this we patch the customError value manually.\n      if (isWebkit) {\n        Object.defineProperty(this.internals.validity, 'customError', {\n          value: this._validityStates.has('customError') || !!flags.customError,\n          configurable: true,\n        });\n      }\n    }\n  }\n  return SbbFormAssociatedElement as unknown as AbstractConstructor<SbbFormAssociatedMixinType<V>> &\n    T;\n};\n\n/**\n * A value to be restored for a component's form value. If a component's form\n * state is a `FormData` object, its entry list of name and values will be\n * provided.\n */\nexport type FormRestoreState = File | string | [string, FormDataEntryValue][];\n\n/**\n * The reason a form component is being restored for, either `'restore'` for\n * browser restoration or `'autocomplete'` for restoring user values.\n */\nexport type FormRestoreReason = 'restore' | 'autocomplete';\n","import type { LitElement, PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\nimport type { SbbFormAssociatedMixinType } from './form-associated-mixin.js';\n\nexport declare class SbbRequiredMixinType {\n  public accessor required: boolean;\n  protected isRequiredExternally(): boolean;\n}\n\n/**\n * Enhance your component with a required property.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbRequiredMixin = <\n  T extends AbstractConstructor<LitElement & SbbFormAssociatedMixinType<V>>,\n  V,\n>(\n  superClass: T,\n): AbstractConstructor<SbbRequiredMixinType> & T => {\n  abstract class SbbRequiredElement extends superClass implements Partial<SbbRequiredMixinType> {\n    /** Whether the component is required. */\n    @property({ reflect: true, type: Boolean })\n    public set required(value: boolean) {\n      // To provide the same behavior as the native required state,\n      // any value is converted to a boolean.\n      this._required = Boolean(value);\n    }\n    public get required(): boolean {\n      return this._required || this.isRequiredExternally();\n    }\n    private _required: boolean = false;\n\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('required')) {\n        // Firefox needs explicitly set aria-required value.\n        this.internals.ariaRequired = `${this.required}`;\n      }\n    }\n\n    /**\n     * Will be used as 'or' check to the current required state.\n     * Can e.g. be used to read required state of a group.\n     */\n    protected isRequiredExternally(): boolean {\n      return false;\n    }\n  }\n\n  return SbbRequiredElement as unknown as AbstractConstructor<SbbRequiredMixinType> & T;\n};\n","import { defaultConverter, type LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbLanguageController } from '../controllers.js';\nimport { hostAttributes } from '../decorators.js';\nimport { preventScrollOnSpacebarPress } from '../eventing.js';\nimport { i18nCheckboxRequired } from '../i18n.js';\n\nimport type { Constructor } from './constructor.js';\nimport { SbbDisabledMixin, type SbbDisabledMixinType } from './disabled-mixin.js';\nimport {\n  SbbFormAssociatedMixin,\n  type FormRestoreReason,\n  type FormRestoreState,\n  type SbbFormAssociatedMixinType,\n} from './form-associated-mixin.js';\nimport { SbbRequiredMixin, type SbbRequiredMixinType } from './required-mixin.js';\n\ntype CheckedSetterValue = { value: boolean; attribute: boolean };\n\nexport declare abstract class SbbFormAssociatedCheckboxMixinType\n  extends SbbFormAssociatedMixinType\n  implements Partial<SbbDisabledMixinType>, Partial<SbbRequiredMixinType>\n{\n  public get checked(): boolean;\n  public set checked(value: boolean);\n\n  public set disabled(value: boolean);\n  public get disabled(): boolean;\n\n  public set required(value: boolean);\n  public get required(): boolean;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected isDisabledExternally(): boolean;\n  protected isRequiredExternally(): boolean;\n  protected withUserInteraction?(): void;\n  protected updateFormValue(): void;\n}\n\n/**\n * The FormAssociatedCheckboxMixin enables native form support for checkbox controls.\n *\n * Inherited classes MUST implement the ariaChecked state (ElementInternals) themselves.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedCheckboxMixin = <T extends Constructor<LitElement>>(\n  superClass: T,\n): Constructor<SbbFormAssociatedCheckboxMixinType> & T => {\n  @hostAttributes({\n    tabindex: '0',\n  })\n  abstract class SbbFormAssociatedCheckboxElement\n    extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(superClass)))\n    implements Partial<SbbFormAssociatedCheckboxMixinType>\n  {\n    private _attributeMutationBlocked = false;\n    private _languageController = new SbbLanguageController(this);\n\n    /** Whether the checkbox is checked. */\n    @property({\n      type: Boolean,\n      converter: {\n        ...defaultConverter,\n        // We need to pass information to the setter so that we know it was called by attribute change.\n        fromAttribute: (value: string | null, type?: unknown): CheckedSetterValue => {\n          const result = defaultConverter.fromAttribute?.(value, type);\n          return { value: result, attribute: true } as CheckedSetterValue;\n        },\n      },\n    })\n    public set checked(value: boolean) {\n      const attributeSetter =\n        typeof value === 'object' ? (value as unknown as CheckedSetterValue).attribute : false;\n      if (attributeSetter) {\n        value = (value as unknown as CheckedSetterValue).value;\n      }\n\n      // As soon as mutation was done not by setting attribute,\n      // we need to block syncing attribute.\n      if (this.hasUpdated && !attributeSetter) {\n        this._attributeMutationBlocked = true;\n      }\n      this._checked = Boolean(value);\n      this.updateFormValue();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    /**\n     * Form type of element.\n     * @default 'checkbox'\n     */\n    public override get type(): string {\n      return 'checkbox';\n    }\n\n    protected constructor() {\n      super();\n      /** @internal */\n      this.internals.role = 'checkbox';\n\n      this.addEventListener?.('click', this._handleUserInteraction);\n      this.addEventListener?.('keydown', preventScrollOnSpacebarPress);\n      this.addEventListener?.('keyup', this._handleKeyboardInteraction);\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      // Attribute should not be interpreted after programmatic or manual state change.\n      if (name !== 'checked' || !this._attributeMutationBlocked) {\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.checked = this.hasAttribute('checked');\n      this._attributeMutationBlocked = false;\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) {\n        this.checked = state === 'true';\n      }\n    }\n\n    /**\n     * Additional logic which is being executed when user\n     * interaction happens and state is not disabled.\n     */\n    protected withUserInteraction?(): void;\n\n    protected override updateFormValue(): void {\n      if (this.checked) {\n        this.internals.setFormValue(this.value, `${this.checked}`);\n      } else {\n        this.internals.setFormValue(null);\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    protected override validate(): void {\n      super.validate();\n      if (this.required && !this.checked) {\n        this.setValidityFlag(\n          'valueMissing',\n          i18nCheckboxRequired[this._languageController.current],\n        );\n      } else {\n        this.removeValidityFlag('valueMissing');\n      }\n    }\n\n    /** Method triggered on keyboard user interaction with checkbox. */\n    private _handleKeyboardInteraction = (event: KeyboardEvent): void => {\n      if (event.key === ' ') {\n        this._handleUserInteraction();\n      }\n    };\n\n    /** Method triggered on user interaction with checkbox. */\n    private _handleUserInteraction = (): void => {\n      if (this.disabled) {\n        return;\n      }\n      this.withUserInteraction?.();\n      this.checked = !this.checked;\n      this._attributeMutationBlocked = true;\n\n      this.dispatchEvent(new InputEvent('input', { composed: true, bubbles: true }));\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    };\n  }\n\n  return SbbFormAssociatedCheckboxElement as unknown as Constructor<SbbFormAssociatedCheckboxMixinType> &\n    T;\n};\n","import { html, isServer, type LitElement } from 'lit';\nimport { eventOptions, property } from 'lit/decorators.js';\n\nimport { sbbInputModalityDetector } from '../a11y.js';\nimport { SbbLanguageController } from '../controllers.js';\nimport { isFirefox, isWebkit } from '../dom.js';\nimport { i18nInputRequired } from '../i18n.js';\n\nimport type { Constructor } from './constructor.js';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n  type SbbFormAssociatedMixinType,\n} from './form-associated-mixin.js';\nimport { SbbRequiredMixin, type SbbRequiredMixinType } from './required-mixin.js';\n\nexport declare abstract class SbbFormAssociatedInputMixinType\n  extends SbbFormAssociatedMixinType\n  implements Partial<SbbRequiredMixinType>\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 required(value: boolean);\n  public get required(): boolean;\n\n  public set placeholder(value: string);\n  public get placeholder(): string;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected withUserInteraction?(): void;\n  protected updateFormValue(): void;\n  protected language: SbbLanguageController;\n}\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 Constructor<LitElement>>(\n  superClass: T,\n): Constructor<SbbFormAssociatedInputMixinType> & T => {\n  abstract class SbbFormAssociatedInputElement\n    extends SbbRequiredMixin(SbbFormAssociatedMixin(superClass))\n    implements Partial<SbbFormAssociatedInputMixinType>\n  {\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 occured since creation\n     * or the last form reset.\n     */\n    private _interacted = false;\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 text value of the input element.\n     */\n    public override set value(value: string) {\n      super.value = this._cleanText(value);\n      if (this.hasUpdated) {\n        this.innerHTML = super.value;\n      }\n    }\n    public override get value(): string {\n      return super.value ?? '';\n    }\n\n    /**\n     * Whether the component is readonly.\n     * @attr readonly\n     * @default false\n     */\n    @property({ type: Boolean })\n    public set readOnly(value: boolean) {\n      this.toggleAttribute('readonly', !!value);\n      this.internals.ariaReadOnly = value ? 'true' : null;\n      this._updateContenteditable();\n    }\n    public get readOnly(): boolean {\n      return this.hasAttribute('readonly');\n    }\n\n    /**\n     * Whether the component is disabled.\n     * @attr disabled\n     * @default false\n     */\n    @property({ type: Boolean })\n    public set disabled(value: boolean) {\n      this.toggleAttribute('disabled', !!value);\n      this.internals.ariaDisabled = value ? 'true' : null;\n      this._updateContenteditable();\n    }\n    public get disabled(): boolean {\n      return this.hasAttribute('disabled');\n    }\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      /** @internal */\n      this.internals.role = 'textbox';\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          super.value = this._cleanText(this.textContent ?? '');\n          this._interacted = true;\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          // 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          }\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        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(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          window.getSelection()?.selectAllChildren(this);\n        }\n      });\n      // On blur the native text input scrolls the text to the start of the text.\n      // We mimick 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          this._emitChangeIfNecessary();\n          this.scrollLeft = 0;\n        },\n        { capture: true },\n      );\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.innerHTML = 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 (!isServer && !this.disabled && !this.readOnly && this.value) {\n        const selection = window.getSelection();\n        if (!selection) {\n          return;\n        }\n        let range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;\n        if (range && range.startOffset !== 0) {\n          return;\n        }\n\n        range = document.createRange();\n        range.setStart(this.firstChild!, this.textContent!.length);\n        range.collapse(true);\n        selection.removeAllRanges();\n        selection.addRange(range);\n      }\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      if (name !== 'value' || !this._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._interacted = false;\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    protected override updateFormValue(): void {\n      this.internals.setFormValue(this.value, this.value);\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    private _cleanText(value: string): string {\n      // The native text input removes all newline characters if passed to the value property\n      return `${value}`.replace(/[\\n\\r]+/g, '');\n    }\n\n    private _dispatchInputEvent(): void {\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        // Firefox does not yet support plaintext-only. Once this is available\n        // for our supported browser range, we can switch to it fully.\n        const value =\n          this.disabled || this.readOnly ? 'false' : isFirefox ? 'true' : 'plaintext-only';\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        this.dispatchEvent(new Event('change', { bubbles: true }));\n      }\n    }\n\n    protected override render(): unknown {\n      return html`<slot @slotchange=${this._cleanChildren}></slot>`;\n    }\n  }\n\n  return SbbFormAssociatedInputElement as unknown as Constructor<SbbFormAssociatedInputMixinType> &\n    T;\n};\n","import { isServer, type LitElement, type PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { getNextElementIndex, interactivityChecker, isArrowKeyPressed } from '../a11y.js';\nimport { SbbConnectedAbortController, SbbLanguageController } from '../controllers.js';\nimport { i18nSelectionRequired } from '../i18n.js';\n\nimport type { Constructor } from './constructor.js';\nimport { SbbDisabledMixin, type SbbDisabledMixinType } from './disabled-mixin.js';\nimport {\n  SbbFormAssociatedMixin,\n  type FormRestoreReason,\n  type FormRestoreState,\n  type SbbFormAssociatedMixinType,\n} from './form-associated-mixin.js';\nimport { SbbRequiredMixin, type SbbRequiredMixinType } from './required-mixin.js';\n\n/**\n * A static registry that holds a collection of grouped `radio-buttons`.\n * Groups of radio buttons are local to the form they belong (or the `renderRoot` if they're not part of any form)\n * Multiple groups of radio with the same name can coexist (as long as they belong to a different form / renderRoot)\n * It is mainly used to support the standalone groups of radios.\n * @internal\n */\nexport const radioButtonRegistry = new WeakMap<\n  Node,\n  Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>\n>();\n\nexport declare class SbbFormAssociatedRadioButtonMixinType\n  extends SbbFormAssociatedMixinType\n  implements Partial<SbbDisabledMixinType>, Partial<SbbRequiredMixinType>\n{\n  public accessor checked: boolean;\n  public accessor disabled: boolean;\n  public accessor required: boolean;\n\n  protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonMixinType>;\n  /** @deprecated No longer used internally. */\n  protected abort: SbbConnectedAbortController;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected isDisabledExternally(): boolean;\n  protected isRequiredExternally(): boolean;\n  protected withUserInteraction?(): void;\n  protected updateFormValue(): void;\n  protected updateFocusableRadios(): void;\n  protected emitChangeEvents(): void;\n  protected navigateByKeyboard(radio: SbbFormAssociatedRadioButtonMixinType): Promise<void>;\n}\n\n/**\n * The SbbFormAssociatedRadioButtonMixin enables native form support for radio controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedRadioButtonMixin = <T extends Constructor<LitElement>>(\n  superClass: T,\n): Constructor<SbbFormAssociatedRadioButtonMixinType> & T => {\n  class SbbFormAssociatedRadioButtonElement\n    extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(superClass)))\n    implements Partial<SbbFormAssociatedRadioButtonMixinType>\n  {\n    /**\n     * Whether the radio button is checked.\n     */\n    @property({ type: Boolean })\n    public set checked(value: boolean) {\n      this._checked = !!value;\n\n      this.toggleAttribute('data-checked', this.checked);\n      this.internals.ariaChecked = this.checked.toString();\n      this.updateFormValue();\n      this._synchronizeGroupState();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    public override set name(value: string) {\n      super.name = value;\n\n      this._disconnectFromRegistry();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n    public override get name(): string {\n      return super.name;\n    }\n\n    /**\n     * Form type of element.\n     * @default 'radio'\n     */\n    public override get type(): string {\n      return 'radio';\n    }\n\n    /** @deprecated No longer used internally. */\n    protected abort = new SbbConnectedAbortController(this);\n\n    /**\n     * Set of radio buttons that belongs to the same group of `this`.\n     * Assume them ordered in DOM order\n     */\n    protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonElement>;\n    private _radioButtonGroupsMap?: Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>;\n    private _didLoad: boolean = false;\n    private _languageController = new SbbLanguageController(this);\n\n    protected constructor() {\n      super();\n      /** @internal */\n      this.internals.role = 'radio';\n      this.addEventListener?.('keydown', (e) => this._handleArrowKeyDown(e));\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this._disconnectFromRegistry();\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.checked = this.hasAttribute('checked');\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     * @internal\n     */\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (state) {\n        this.checked = state === this.value;\n      }\n    }\n\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('disabled')) {\n        this.updateFocusableRadios();\n      }\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n      this._didLoad = true;\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Called on `value` change\n     * If 'checked', update the value. Otherwise, do nothing.\n     */\n    protected override updateFormValue(): void {\n      if (this.checked) {\n        this.internals.setFormValue(this.value, this.value);\n      } else {\n        this.internals.setFormValue(null);\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    /**\n     * Sets the validity of all associated radio buttons.\n     * If any radio button is required, all associated are required as well.\n     */\n    protected override validate(): void {\n      super.validate();\n      if (!this.associatedRadioButtons) {\n        return;\n      }\n\n      let required = false;\n      let checked = false;\n      for (const radio of this.associatedRadioButtons) {\n        required ||= radio.required;\n        checked ||= radio.checked;\n      }\n\n      if (required && !checked) {\n        this.associatedRadioButtons.forEach((r) =>\n          r.setValidityFlag(\n            'valueMissing',\n            i18nSelectionRequired[this._languageController.current],\n          ),\n        );\n      } else {\n        this.associatedRadioButtons.forEach((r) => r.removeValidityFlag('valueMissing'));\n      }\n    }\n\n    /**\n     * Only a single radio should be focusable in the group. Defined as:\n     * - the checked radio;\n     * - the first non-disabled radio in DOM order;\n     */\n    protected updateFocusableRadios(): void {\n      if (!this._didLoad) {\n        return;\n      }\n      const radios = this._interactableGroupedRadios();\n      const checkedIndex = radios.findIndex((r) => r.checked && !r.disabled && !r.formDisabled);\n      const focusableIndex =\n        checkedIndex !== -1\n          ? checkedIndex\n          : radios.findIndex((r) => !r.disabled && !r.formDisabled); // Get the first focusable radio\n\n      if (focusableIndex !== -1) {\n        radios[focusableIndex].tabIndex = 0;\n        radios.splice(focusableIndex, 1);\n      }\n\n      // Reset tabIndex on other radios\n      radios.forEach((r) => r.removeAttribute('tabindex'));\n    }\n\n    protected async navigateByKeyboard(next: SbbFormAssociatedRadioButtonElement): Promise<void> {\n      next.checked = true;\n      this.emitChangeEvents();\n\n      await next.updateComplete;\n      next.focus();\n    }\n\n    protected emitChangeEvents(): void {\n      // Manually dispatch events to simulate a user interaction\n      this.dispatchEvent(\n        new InputEvent('input', { bubbles: true, cancelable: true, composed: true }),\n      );\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    }\n\n    private _synchronizeGroupState(): void {\n      if (this.checked) {\n        this._deselectGroupedRadios();\n      }\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Add `this` to the radioButton registry\n     */\n    private _connectToRegistry(): void {\n      if (!this.name || isServer) {\n        return;\n      }\n\n      const root = this.form ?? this.getRootNode();\n      this._radioButtonGroupsMap = radioButtonRegistry.get(root);\n\n      // Initialize the 'root' map entry\n      if (!this._radioButtonGroupsMap) {\n        this._radioButtonGroupsMap = new Map();\n        radioButtonRegistry.set(root, this._radioButtonGroupsMap);\n      }\n\n      this.associatedRadioButtons = this._radioButtonGroupsMap.get(\n        this.name,\n      ) as unknown as Set<SbbFormAssociatedRadioButtonElement>;\n\n      // Initialize the group set\n      if (!this.associatedRadioButtons) {\n        this.associatedRadioButtons = new Set();\n        this._radioButtonGroupsMap.set(\n          this.name,\n          this.associatedRadioButtons as unknown as Set<SbbFormAssociatedRadioButtonMixinType>,\n        );\n      }\n\n      // Insert the new radio into the set and sort following the DOM order.\n      // Since the order of a 'Set' is the insert order, we have to empty it and re-insert radios in order\n      const entries = Array.from(this.associatedRadioButtons);\n      this.associatedRadioButtons.clear();\n\n      // Find `this` position and insert it\n      const index = entries.findIndex(\n        (r) => this.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_FOLLOWING,\n      );\n      if (index !== -1) {\n        entries.splice(index, 0, this);\n      } else {\n        entries.push(this);\n      }\n\n      // Repopulate the Set\n      entries.forEach((r) => this.associatedRadioButtons!.add(r));\n\n      this.validate();\n    }\n\n    /**\n     * Remove `this` from the radioButton registry and, if the group is empty, delete the entry from the groups Map\n     */\n    private _disconnectFromRegistry(): void {\n      this.associatedRadioButtons?.delete(this);\n\n      if (this.associatedRadioButtons?.size === 0) {\n        this._radioButtonGroupsMap?.delete(this.name);\n      } else {\n        this.validate();\n      }\n\n      this.associatedRadioButtons = undefined;\n      this._radioButtonGroupsMap = undefined;\n    }\n\n    /**\n     * Return a list of 'interactable' grouped radios, ordered in DOM order\n     */\n    private _interactableGroupedRadios(): SbbFormAssociatedRadioButtonElement[] {\n      return Array.from(this.associatedRadioButtons ?? []).filter((el) =>\n        interactivityChecker.isVisible(el),\n      );\n    }\n\n    /**\n     * Deselect other radio of the same group\n     */\n    private _deselectGroupedRadios(): void {\n      Array.from(this.associatedRadioButtons ?? [])\n        .filter((r) => r !== this)\n        .forEach((r) => (r.checked = false));\n    }\n\n    private async _handleArrowKeyDown(evt: KeyboardEvent): Promise<void> {\n      if (!isArrowKeyPressed(evt)) {\n        return;\n      }\n      evt.preventDefault();\n\n      const enabledRadios = this._interactableGroupedRadios().filter(\n        (r) => !r.disabled && !r.formDisabled,\n      );\n      const current: number = enabledRadios.indexOf(this);\n      const nextIndex: number = getNextElementIndex(evt, current, enabledRadios.length);\n\n      await this.navigateByKeyboard(enabledRadios[nextIndex]);\n    }\n  }\n\n  return SbbFormAssociatedRadioButtonElement as unknown as Constructor<SbbFormAssociatedRadioButtonMixinType> &\n    T;\n};\n","import type { LitElement, PropertyValues } from 'lit';\n\nimport type { AbstractConstructor } from './constructor.js';\n\n// Define the interface for the mixin\nexport declare abstract class SbbHydrationMixinType {\n  /**\n   * Returns a Promise that resolves when the element has completed hydration.\n   * The Promise value is a boolean that is `true` if the element required hydration\n   * and `false` if not.\n   *\n   * @return A promise of a boolean that resolves to true once the hydration completed.\n   */\n  public get hydrationComplete(): Promise<boolean>;\n\n  /** Returns whether hydration is required and not completed. */\n  protected get hydrationRequired(): boolean;\n}\n\n/**\n * This mixin extends a base class with functionality to check if hydration is completed.\n * It also delays slotchange events until hydration is complete.\n *\n * @param base The class to extend.\n * @returns A class extended with the hydration check functionality.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbHydrationMixin = <T extends AbstractConstructor<LitElement>>(\n  base: T,\n): AbstractConstructor<SbbHydrationMixinType> & T => {\n  abstract class SbbHydrationMixinClass extends base implements Partial<SbbHydrationMixinType> {\n    private _hydrationRequired: boolean;\n    private _hydrationComplete = new Promise<boolean>(\n      (resolve) => (this._resolveHydration = resolve),\n    );\n    private _resolveHydration!: (hydrationRequired: boolean) => void;\n\n    /**\n     * Returns a Promise that resolves when the element has completed hydration.\n     * The Promise value is a boolean that is `true` if the element required hydration\n     * and `false` if not.\n     *\n     * @return A promise of a boolean that resolves to true once the hydration completed.\n     * @internal\n     */\n    public get hydrationComplete(): Promise<boolean> {\n      return this._hydrationComplete;\n    }\n\n    /** Returns whether hydration is required and not completed. */\n    protected get hydrationRequired(): boolean {\n      return this._hydrationRequired;\n    }\n\n    public constructor(...args: any[]) {\n      super(...args);\n      // Check whether hydration is needed by checking whether the shadow root\n      // is available during construction/upgrade phase.\n      this._hydrationRequired = !!this.shadowRoot;\n      if (!this._hydrationRequired) {\n        this._resolveHydration(false);\n      } else {\n        // During hydration phase, we want to suppress slotchange events as they\n        // can cause render differences, which would break hydration. After\n        // hydration is complete, we dispatch a manual slotchange event, if there\n        // are elements assigned to a slot.\n        const suppressSlotchangeEvent = (event: Event): void => {\n          if (this._hydrationRequired) {\n            event.stopImmediatePropagation();\n          }\n        };\n        const eventOptions: EventListenerOptions = { capture: true };\n        const slots = this.shadowRoot?.querySelectorAll('slot');\n        if (slots?.length) {\n          slots.forEach((slot) =>\n            slot.addEventListener('slotchange', suppressSlotchangeEvent, eventOptions),\n          );\n          this.hydrationComplete.then(() =>\n            slots.forEach((slot) => {\n              slot.removeEventListener('slotchange', suppressSlotchangeEvent, eventOptions);\n              if (slot.assignedNodes().length) {\n                slot.dispatchEvent(new Event('slotchange', { bubbles: true }));\n              }\n            }),\n          );\n        }\n      }\n    }\n\n    protected override update(changedProperties: PropertyValues<this>): void {\n      // When hydration is needed, we wait the hydration process to finish, which is patched\n      // into the update method of the LitElement base class.\n      super.update(changedProperties);\n\n      if (this._hydrationRequired) {\n        this._hydrationRequired = false;\n        this._resolveHydration(true);\n      }\n    }\n  }\n  return SbbHydrationMixinClass as unknown as AbstractConstructor<SbbHydrationMixinType> & T;\n};\n","import { html, type LitElement, nothing, type TemplateResult } from 'lit';\nimport { state } from 'lit/decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\nimport { SbbHydrationMixin, type SbbHydrationMixinType } from './hydration-mixin.js';\n\nimport '../../screen-reader-only.js';\n\nconst SSR_CHILD_COUNT_ATTRIBUTE = 'data-ssr-child-count';\nconst SLOTNAME_PREFIX = 'li';\n\nexport type SbbNamedSlotProperties = {\n  name: string;\n  ariaHidden: boolean;\n};\n\n/**\n * Helper type for willUpdate or similar checks.\n * Allows the usage of the string literal 'listChildren'.\n *\n * @example\n * protected override willUpdate(changedProperties: PropertyValues<WithListChildren<this>>): void {\n *   if (changedProperties.has('listChildren')) {\n *     ...\n *   }\n * }\n */\nexport type WithListChildren<\n  T extends SbbNamedSlotListMixinType<C>,\n  C extends HTMLElement = HTMLElement,\n> = T & { listChildren: C[] };\n\nexport declare abstract class SbbNamedSlotListMixinType<\n  C extends HTMLElement,\n> extends SbbHydrationMixinType {\n  protected abstract readonly listChildLocalNames: string[];\n  protected accessor listChildren: C[];\n  protected renderList(\n    attributes?: {\n      class?: string;\n      ariaLabel?: string;\n      ariaLabelledby?: string;\n    },\n    listItemAttributes?: {\n      localNameVisualOnly?: string[];\n    },\n  ): TemplateResult;\n  protected listSlotEntries(): SbbNamedSlotProperties[];\n  protected renderHiddenSlot(): TemplateResult;\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbNamedSlotListMixin = <\n  C extends HTMLElement,\n  T extends AbstractConstructor<LitElement>,\n>(\n  superClass: T,\n): AbstractConstructor<SbbNamedSlotListMixinType<C>> & T => {\n  /**\n   * This base class provides named slot list observer functionality.\n   * This allows using the pattern of rendering a named slot for each child, which allows\n   * wrapping children in an ul/li list.\n   */\n  abstract class NamedSlotListElement<C extends HTMLElement = HTMLElement>\n    extends SbbHydrationMixin(superClass)\n    implements Partial<SbbNamedSlotListMixinType<C>>\n  {\n    /** A list of lower-cased tag names to match against. (e.g. `sbb-link`) */\n    protected abstract readonly listChildLocalNames: string[];\n\n    /**\n     * A list of children with the defined tag names.\n     * This array is only updated if there is an actual change\n     * to the child elements.\n     */\n    @state() protected accessor listChildren: C[] = [];\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this.shadowRoot?.addEventListener('slotchange', this._handleSlotchange, { passive: true });\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this.shadowRoot?.removeEventListener('slotchange', this._handleSlotchange);\n    }\n\n    private _handleSlotchange = (): void => {\n      const listChildren = Array.from(this.children ?? []).filter((e): e is C =>\n        this.listChildLocalNames.includes(e.localName),\n      );\n      // If the slotted child instances have not changed, we can skip syncing and updating\n      // the link reference list.\n      if (\n        listChildren.length === this.listChildren.length &&\n        this.listChildren.every((e, i) => listChildren[i] === e)\n      ) {\n        return;\n      }\n\n      this.listChildren\n        .filter((c) => !listChildren.includes(c))\n        .forEach((c) => c.removeAttribute('slot'));\n      this.listChildren = listChildren;\n      this.listChildren.forEach((c, index) =>\n        c.setAttribute('slot', `${SLOTNAME_PREFIX}-${index}`),\n      );\n\n      // Remove the ssr attribute, once we have actually initialized the children elements.\n      this.removeAttribute(SSR_CHILD_COUNT_ATTRIBUTE);\n    };\n\n    /**\n     * Renders list and list slots for slotted children or a number of list slots\n     * corresponding to the `data-ssr-child-count` attribute value.\n     *\n     * This is a possible optimization for SSR, as in an SSR Lit environment\n     * other elements are not available, but might be available in the meta\n     * framework wrapper (like e.g. React). This allows to provide the number of\n     * children to be passed via the `data-ssr-child-count` attribute value.\n     */\n    protected renderList(\n      attributes: { class?: string; ariaLabel?: string; ariaLabelledby?: string } = {},\n      listItemAttributes: { localNameVisualOnly?: string[] } = {},\n    ): TemplateResult {\n      const listSlotNames: SbbNamedSlotProperties[] = this.listSlotEntries(listItemAttributes);\n\n      if (listSlotNames.length >= 2) {\n        return html`\n          <ul\n            class=${attributes.class || this.localName}\n            aria-label=${attributes.ariaLabel || nothing}\n            aria-labelledby=${attributes.ariaLabelledby || nothing}\n          >\n            ${listSlotNames.map(\n              (slot) => html`\n                <li aria-hidden=${slot.ariaHidden || nothing}>\n                  <slot name=${slot.name}></slot>\n                </li>\n              `,\n            )}\n          </ul>\n          ${this.renderHiddenSlot()}\n        `;\n      } else if (listSlotNames.length === 1) {\n        return html`<sbb-screen-reader-only>${attributes.ariaLabel}</sbb-screen-reader-only>\n          <span class=${attributes.class || this.localName}>\n            <span><slot name=${listSlotNames[0].name}></slot></span>\n          </span>\n          ${this.renderHiddenSlot()} `;\n      } else {\n        return this.renderHiddenSlot();\n      }\n    }\n\n    /**\n     * Returns an array of SbbNamedSlotProperties, which holds the list slot names and the hidden property;\n     * its length corresponds to the number of matched children or the `data-ssr-child-count` attribute value.\n     *\n     * This is a possible optimization for SSR, as in an SSR Lit environment\n     * other elements are not available, but might be available in the meta\n     * framework wrapper (like e.g. React). This allows to provide the number of\n     * children to be passed via the `data-ssr-child-count` attribute value.\n     */\n    protected listSlotEntries(listItemAttributes: {\n      localNameVisualOnly?: string[];\n    }): SbbNamedSlotProperties[] {\n      const listChildren = this.listChildren.length\n        ? this.listChildren\n        : Array.from({ length: +(this.getAttribute(SSR_CHILD_COUNT_ATTRIBUTE) ?? 0) });\n      return listChildren.map((e, i) => {\n        return {\n          name: `${SLOTNAME_PREFIX}-${i}`,\n          ariaHidden:\n            listItemAttributes?.localNameVisualOnly?.includes((e as HTMLElement).localName) ??\n            false,\n        };\n      });\n    }\n\n    /**\n     * Returns a hidden slot, which is intended as the children change detection.\n     * When an element without a slot attribute is slotted to the element, it triggers\n     * the slotchange event, which can be used to assign it to the appropriate named slot.\n     */\n    protected renderHiddenSlot(): TemplateResult {\n      return html`<span hidden><slot></slot></span>`;\n    }\n  }\n\n  return NamedSlotListElement as unknown as AbstractConstructor<SbbNamedSlotListMixinType<C>> & T;\n};\n","import type { LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType } from '../decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\nexport declare class SbbNegativeMixinType {\n  public accessor negative: boolean;\n}\n\n/**\n * Enhance your component with a negative property.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbNegativeMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbNegativeMixinType> & T => {\n  abstract class SbbNegativeElement extends superClass implements SbbNegativeMixinType {\n    /** Negative coloring variant flag. */\n    @forceType()\n    @property({ reflect: true, type: Boolean })\n    public accessor negative: boolean = false;\n  }\n\n  return SbbNegativeElement as AbstractConstructor<SbbNegativeMixinType> & T;\n};\n","import type { LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType } from '../decorators.js';\nimport { EventEmitter } from '../eventing.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\nexport declare class SbbPanelMixinType {\n  public accessor color: 'white' | 'milk';\n  public accessor borderless: boolean;\n  public accessor expansionState: string;\n}\n\nexport type SbbPanelSize = 's' | 'm';\n\n/**\n * Mixin for common panel behaviors\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbPanelMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbPanelMixinType> & T => {\n  abstract class SbbPanelElement extends superClass implements SbbPanelMixinType {\n    public static readonly events = {\n      panelConnected: 'panelConnected',\n    } as const;\n\n    /** The background color of the panel. */\n    @property({ reflect: true }) public accessor color: 'white' | 'milk' = 'white';\n\n    /** Whether the unselected panel has a border. */\n    @forceType()\n    @property({ reflect: true, type: Boolean })\n    public accessor borderless: boolean = false;\n\n    /** @internal used for accessibility label when in expansion panel */\n    @forceType()\n    @property()\n    public accessor expansionState: string = '';\n\n    /**\n     * @internal\n     * Internal event that emits when the checkbox is loaded.\n     */\n    private _panelConnected: EventEmitter<void> = new EventEmitter(\n      this,\n      SbbPanelElement.events.panelConnected,\n      { bubbles: true },\n    );\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n\n      this._panelConnected.emit();\n\n      this.closest?.('sbb-radio-button-group, sbb-checkbox-group')?.toggleAttribute(\n        'data-has-panel',\n        true,\n      );\n    }\n  }\n\n  return SbbPanelElement as AbstractConstructor<SbbPanelMixinType> & T;\n};\n","import type { LitElement } from 'lit';\n\nimport type { AbstractConstructor } from './constructor.js';\n\n// Define the interface for the mixin\nexport declare class SbbUpdateSchedulerMixinType {\n  protected startUpdate(): void;\n  protected completeUpdate(): void;\n}\n\n/**\n * This mixin allows scheduling manual updates, which affect updateComplete.\n * @param base The class to extend.\n * @returns A class extended with the slot child observer functionality.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbUpdateSchedulerMixin = <T extends AbstractConstructor<LitElement>>(\n  base: T,\n): AbstractConstructor<SbbUpdateSchedulerMixinType> & T => {\n  abstract class SbbUpdateSchedulerElement\n    extends base\n    implements Partial<SbbUpdateSchedulerMixinType>\n  {\n    private _updatePromise = Promise.resolve();\n    private _updateResolve = (): void => {};\n\n    protected startUpdate(): void {\n      this._updatePromise = new Promise<void>((r) => (this._updateResolve = r));\n    }\n\n    protected completeUpdate(): void {\n      this._updateResolve();\n    }\n\n    protected override async getUpdateComplete(): Promise<boolean> {\n      const result = await super.getUpdateComplete();\n      await this._updatePromise;\n      return result;\n    }\n  }\n  return SbbUpdateSchedulerElement as unknown as AbstractConstructor<SbbUpdateSchedulerMixinType> &\n    T;\n};\n"],"names":["_a","state","_b","eventOptions","SbbPanelElement"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mixins.js","sources":["../../../../src/elements/core/mixins/animation-complete-mixin.ts","../../../../src/elements/core/mixins/disabled-mixin.ts","../../../../src/elements/core/mixins/form-associated-mixin.ts","../../../../src/elements/core/mixins/required-mixin.ts","../../../../src/elements/core/mixins/form-associated-checkbox-mixin.ts","../../../../src/elements/core/mixins/form-associated-input-mixin.ts","../../../../src/elements/core/mixins/form-associated-radio-button-mixin.ts","../../../../src/elements/core/mixins/hydration-mixin.ts","../../../../src/elements/core/mixins/named-slot-list-mixin.ts","../../../../src/elements/core/mixins/negative-mixin.ts","../../../../src/elements/core/mixins/panel-mixin.ts","../../../../src/elements/core/mixins/update-scheduler-mixin.ts"],"sourcesContent":["import type { LitElement } from 'lit';\n\nimport type { AbstractConstructor } from './constructor.js';\n\nexport declare class SbbAnimationCompleteMixinType {\n  public isAnimating: boolean;\n  public get animationComplete(): Promise<void> | null;\n  protected startAnimation(): void;\n  protected stopAnimation(): void;\n}\n\n/**\n * Enhances the component with a Promise which resolves whenever an animation ends.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbAnimationCompleteMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbAnimationCompleteMixinType> & T => {\n  abstract class SbbAnimationCompleteElement\n    extends superClass\n    implements Partial<SbbAnimationCompleteMixinType>\n  {\n    /**\n     * Whether the component is currently animating.\n     */\n    public isAnimating = false;\n\n    /**\n     * Returns a promise which completes whenever an animation ends.\n     * When a new animation starts, a new Promise is returned.\n     */\n    public get animationComplete(): Promise<void> {\n      return this._animationPromise;\n    }\n    private _animationPromise: Promise<void> = Promise.resolve();\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this.stopAnimation();\n    }\n\n    protected startAnimation(): void {\n      if (!this.isAnimating) {\n        this._animationPromise = this._enqueueAnimation();\n      }\n    }\n\n    /**\n     * Overriding stopAnimation() breaks functionality.\n     */\n    protected stopAnimation(): void {}\n\n    private async _enqueueAnimation(): Promise<void> {\n      this.isAnimating = true;\n      const stopAnimation = this.stopAnimation;\n\n      const result = new Promise<void>((r) => {\n        this.stopAnimation = () => {\n          stopAnimation();\n          this.isAnimating = false;\n          r();\n        };\n      });\n      try {\n        // Ensure any previous update has resolved before updating.\n        await this._animationPromise;\n      } catch (e) {\n        // Refire any previous errors async so they do not disrupt the update\n        // cycle. Errors are re-fired so developers have a chance to observe\n        // them, and this can be done by implementing\n        // `window.onunhandledrejection`.\n        Promise.reject(e);\n      }\n      return result;\n    }\n  }\n\n  return SbbAnimationCompleteElement as unknown as AbstractConstructor<SbbAnimationCompleteMixinType> &\n    T;\n};\n","import type { LitElement, PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType, getOverride } from '../decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\nimport type { SbbFormAssociatedMixinType } from './form-associated-mixin.js';\n\nexport declare class SbbDisabledMixinType {\n  public accessor disabled: boolean;\n  protected isDisabledExternally(): boolean;\n}\n\nexport declare class SbbDisabledInteractiveMixinType {\n  public accessor disabledInteractive: boolean;\n}\n\n/**\n * Enhance your component with a disabled property.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbDisabledMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbDisabledMixinType> & T => {\n  abstract class SbbDisabledElement extends superClass implements Partial<SbbDisabledMixinType> {\n    /** Whether the component is disabled. */\n    @forceType()\n    @property({ reflect: true, type: Boolean })\n    @getOverride((e: SbbDisabledElement, v: boolean): boolean => v || e.isDisabledExternally())\n    public accessor disabled: boolean = false;\n\n    /**\n     * Will be used as 'or' check to the current disabled state.\n     * Can e.g. be used to read disabled state of a group.\n     */\n    protected isDisabledExternally(): boolean {\n      return false;\n    }\n  }\n\n  return SbbDisabledElement as unknown as AbstractConstructor<SbbDisabledMixinType> & T;\n};\n\n/**\n * Enhance your component with a disabled interactive property.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbDisabledInteractiveMixin = <\n  T extends AbstractConstructor<LitElement & SbbDisabledMixinType>,\n>(\n  superClass: T,\n): AbstractConstructor<SbbDisabledInteractiveMixinType> & T => {\n  abstract class SbbDisabledInteractiveElement\n    extends superClass\n    implements Partial<SbbDisabledInteractiveMixinType>\n  {\n    /** Whether the button should be aria-disabled but stay interactive. */\n    @forceType()\n    @property({ attribute: 'disabled-interactive', type: Boolean, reflect: true })\n    public accessor disabledInteractive: boolean = false;\n  }\n\n  return SbbDisabledInteractiveElement as unknown as AbstractConstructor<SbbDisabledInteractiveMixinType> &\n    T;\n};\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbDisabledTabIndexActionMixin = <\n  T extends AbstractConstructor<LitElement & SbbFormAssociatedMixinType>,\n>(\n  superClass: T,\n): AbstractConstructor<SbbDisabledMixinType & SbbDisabledInteractiveMixinType> & T => {\n  abstract class SbbDisabledTabIndexAction\n    extends SbbDisabledInteractiveMixin(SbbDisabledMixin(superClass))\n    implements SbbDisabledMixinType, SbbDisabledInteractiveMixinType\n  {\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('disabledInteractive')) {\n        this.internals.ariaDisabled = this.disabledInteractive ? 'true' : null;\n      }\n\n      if (!changedProperties.has('disabled')) {\n        return;\n      }\n\n      if (!this.disabled) {\n        this.setAttribute('tabindex', '0');\n      } else {\n        this.removeAttribute('tabindex');\n      }\n    }\n  }\n  return SbbDisabledTabIndexAction as AbstractConstructor<\n    SbbDisabledMixinType & SbbDisabledInteractiveMixinType\n  > &\n    T;\n};\n","/* eslint-disable @typescript-eslint/no-empty-object-type */\nimport type { LitElement, PropertyDeclaration, PropertyValues } from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport { isWebkit } from '../dom.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\ndeclare global {\n  /**\n   * Defines custom valididty state properties.\n   */\n  interface CustomValidityState {}\n  interface ValidityState extends CustomValidityState {}\n  interface ValidityStateFlags extends Partial<CustomValidityState> {}\n}\n\nconst validityKeys: Required<Omit<ValidityStateFlags, keyof CustomValidityState>> = {\n  badInput: false,\n  customError: false,\n  patternMismatch: false,\n  rangeOverflow: false,\n  rangeUnderflow: false,\n  stepMismatch: false,\n  tooLong: false,\n  tooShort: false,\n  typeMismatch: false,\n  valueMissing: false,\n};\n// We need ValidityState in the global context, as we check the prototype for\n// extensions. In environments where that is not the case (e.g. Node.js) we\n// patch it with a minimal shim.\nif (typeof ValidityState === 'undefined') {\n  const validityClass = class ValidityState {\n    public get valid(): boolean {\n      return true;\n    }\n    private constructor() {\n      throw new TypeError('Illegal constructor');\n    }\n  };\n  Object.entries(validityKeys).forEach(([key, value]) =>\n    Object.assign(validityClass.prototype, {\n      get [key](): boolean {\n        return value;\n      },\n    }),\n  );\n  globalThis.ValidityState = validityClass as unknown as typeof ValidityState;\n}\n\nexport declare abstract class SbbFormAssociatedMixinType<V = string> {\n  public get form(): HTMLFormElement | null;\n  public accessor name: string;\n  public get type(): string;\n  public accessor value: V | null;\n\n  public get validity(): ValidityState;\n  public get validationMessage(): string;\n  public get willValidate(): boolean;\n\n  protected formDisabled: boolean;\n  protected readonly internals: ElementInternals;\n\n  public checkValidity(): boolean;\n  public reportValidity(): boolean;\n  public setCustomValidity(message: string): void;\n\n  public formAssociatedCallback?(form: HTMLFormElement | null): void;\n  public formDisabledCallback(disabled: boolean): void;\n  public abstract formResetCallback(): void;\n  public abstract formStateRestoreCallback(\n    state: FormRestoreState | null,\n    reason: FormRestoreReason,\n  ): void;\n\n  protected abstract updateFormValue(): void;\n  protected setValidityFlag<T extends keyof ValidityStateFlags>(\n    flag: T,\n    message: string,\n    flagValue?: ValidityStateFlags[T],\n  ): void;\n  protected removeValidityFlag<T extends keyof ValidityStateFlags>(flag: T): void;\n  protected validate(): void;\n  protected shouldValidate(name: PropertyKey | undefined): boolean;\n}\n\n/**\n * The FormAssociatedMixin enables native form support for custom controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedMixin = <T extends AbstractConstructor<LitElement>, V = string>(\n  superClass: T,\n): AbstractConstructor<SbbFormAssociatedMixinType<V>> & T => {\n  abstract class SbbFormAssociatedElement\n    extends superClass\n    implements Partial<SbbFormAssociatedMixinType<V>>\n  {\n    public static formAssociated = true;\n\n    /**\n     * Returns the form owner of this element.\n     */\n    public get form(): HTMLFormElement | null {\n      return this.internals.form;\n    }\n\n    /**\n     * Name of the form element. Will be read from name attribute.\n     *\n     * @description Developer note: In this case updating the attribute must be synchronous.\n     * Due to this it is implemented as a getter/setter and the attributeChangedCallback() handles the diff check.\n     */\n    @property()\n    public set name(name: string) {\n      this.setAttribute('name', `${name}`);\n\n      // For `FormData` values, we have to manually update the fieldName key\n      this.updateFormValue();\n    }\n    public get name(): string {\n      return this.getAttribute('name') ?? '';\n    }\n\n    /** @internal */\n    public get type(): string {\n      return this.localName;\n    }\n\n    /** Value of the form element. */\n    @property()\n    public set value(value: V | null) {\n      this._value = value;\n      this.updateFormValue();\n    }\n    public get value(): V | null {\n      return this._value;\n    }\n    private _value: V | null = null;\n\n    /**\n     * Returns the ValidityState object for this element.\n     */\n    public get validity(): ValidityState {\n      return this.internals.validity;\n    }\n\n    /**\n     * Returns the current error message, if available, which corresponds\n     * to the current validation state.\n     * Please note that only one message is returned at a time (e.g. if\n     * multiple validity states are invalid, only the chronologically first one\n     * is returned until it is fixed, at which point the next message might be\n     * returned, if it is still applicable). Also a custom validity message\n     * (see below) has precedence over native validation messages.\n     */\n    public get validationMessage(): string {\n      return this.internals.validationMessage;\n    }\n\n    /**\n     * Returns true if this element will be validated\n     * when the form is submitted; false otherwise.\n     */\n    public get willValidate(): boolean {\n      return this.internals.willValidate;\n    }\n\n    /** @internal */\n    protected readonly internals: ElementInternals = this.attachInternals();\n\n    private _validityStates = new Map<\n      keyof ValidityStateFlags,\n      { flagValue: unknown; message: string }\n    >();\n\n    /** Whenever a surrounding form or fieldset is changing its disabled state. */\n    @state() protected accessor formDisabled: boolean = false;\n\n    public constructor(...args: any[]) {\n      super(...args);\n      // We want to prevent the native browser validation message popover\n      // to be shown. This also prevents a bug in WebKit, which would not\n      // allow host as the validity anchor: https://bugs.webkit.org/show_bug.cgi?id=269832\n      this.addEventListener?.('invalid', (e) => e.preventDefault());\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      if (name !== 'name' || old !== value) {\n        super.attributeChangedCallback(name, old, value);\n      }\n    }\n\n    /**\n     * Returns true if this element has no validity problems; false otherwise.\n     * Fires an invalid event at the element in the latter case.\n     */\n    public checkValidity(): boolean {\n      return this.internals.checkValidity();\n    }\n\n    /**\n     * Returns true if this element has no validity problems; otherwise,\n     * returns false, fires an invalid event at the element,\n     * and (if the event isn't canceled) reports the problem to the user.\n     */\n    public reportValidity(): boolean {\n      return this.internals.reportValidity();\n    }\n\n    /**\n     * Sets the custom validity message for this element. Use the empty string\n     * to indicate that the element does not have a custom validity error.\n     */\n    public setCustomValidity(message: string): void {\n      if (message) {\n        this.setValidityFlag('customError', message);\n      } else {\n        this.removeValidityFlag('customError');\n      }\n    }\n\n    /**\n     * Called when the associated form element changes.\n     * ElementInternals.form returns the associated from element.\n     *\n     * @internal\n     */\n    public formAssociatedCallback?(form: HTMLFormElement | null): void;\n\n    /**\n     * Is called whenever a surrounding form / fieldset changes disabled state.\n     * @param disabled\n     *\n     * @internal\n     */\n    public formDisabledCallback(disabled: boolean): void {\n      // This callback is triggered if the disabled property changes or the disabled attribute of a fieldset or form changes.\n      // We need to postpone the assignment, otherwise it interferes with disabled status setting\n      // and leads to a wrong state (e.g. embedded sbb-visual-checkbox).\n      Promise.resolve().then(() => {\n        this.formDisabled = disabled;\n      });\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     *\n     * @internal\n     */\n    public abstract formResetCallback(): void;\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 abstract formStateRestoreCallback(\n      state: FormRestoreState | null,\n      reason: FormRestoreReason,\n    ): void;\n\n    public override requestUpdate(\n      name?: PropertyKey,\n      oldValue?: unknown,\n      options?: PropertyDeclaration,\n    ): void {\n      super.requestUpdate(name, oldValue, options);\n      if (this.hasUpdated && this.shouldValidate(name)) {\n        this.validate();\n      }\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n      this.validate();\n    }\n\n    /**\n     * Should be called when form value is changed.\n     * Adapts and sets the formValue in the supported format (string | FormData | File | null)\n     * https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals/setFormValue\n     */\n    protected abstract updateFormValue(): void;\n\n    /**\n     * Marks this element as suffering from the constraint indicated by the\n     * flag argument and associates the given message to it.\n     * Note that only one message is displayed at a time and custom messages by\n     * consumers are always displayed before internal messages and internal\n     * messages are displayed in the order they were added.\n     * To set/define custom validity state flags, you need to extend the\n     * ValidityState prototype (and the CustomValidityState interface).\n     *\n     * @example\n     *\n     *   // The type of the custom validity state does not need to be boolean.\n     *   Object.assign(ValidityState.prototype, {\n     *     get myError(): boolean {\n     *       return false;\n     *     },\n     *   });\n     *\n     *   declare global {\n     *     interface CustomValidityState {\n     *       myError: boolean;\n     *     }\n     *   }\n     */\n    protected setValidityFlag<T extends keyof ValidityStateFlags>(\n      flag: T,\n      message: string,\n      flagValue?: ValidityStateFlags[T],\n    ): void {\n      flagValue ??= true;\n      const validityState = this._validityStates.get(flag);\n      if (\n        !validityState ||\n        validityState.message !== message ||\n        validityState.flagValue !== flagValue\n      ) {\n        this._validityStates.set(flag, { flagValue, message });\n        this._setInternalValidity();\n      }\n    }\n\n    /** Removes the validity state flag entry and updates validity state. */\n    protected removeValidityFlag<T extends keyof ValidityStateFlags>(flag: T): void {\n      if (this._validityStates.has(flag)) {\n        this._validityStates.delete(flag);\n        this._setInternalValidity();\n      }\n    }\n\n    /** To be called whenever the current element needs to be validated. */\n    protected validate(): void {}\n\n    /** Whether validation should be run on a property change with the given name. */\n    protected shouldValidate(name: PropertyKey | undefined): boolean {\n      return !name;\n    }\n\n    private _setInternalValidity(): void {\n      let outputMessage = this._validityStates.get('customError')?.message;\n      const flags: ValidityStateFlags = {};\n      this._validityStates.forEach(({ flagValue, message }, flag) => {\n        flags[flag] = flagValue as any;\n        outputMessage ||= message;\n      });\n\n      const customFlags = Object.keys(ValidityState.prototype).filter(\n        (f) => !(f in validityKeys) && f !== 'valid',\n      );\n      for (const flag of customFlags) {\n        const value = flag in flags ? flags[flag as keyof ValidityStateFlags] : false;\n        Object.defineProperty(this.internals.validity, flag, { value, configurable: true });\n        if (value) {\n          // If any custom errors are provided, we need to set customError to true,\n          // as this is the only custom error property browsers accept.\n          flags.customError = true;\n        }\n      }\n\n      this.internals.setValidity(flags, outputMessage);\n\n      // WebKit seems to always set customError to true, if any error is active.\n      // Due to this we patch the customError value manually.\n      if (isWebkit) {\n        Object.defineProperty(this.internals.validity, 'customError', {\n          value: this._validityStates.has('customError') || !!flags.customError,\n          configurable: true,\n        });\n      }\n    }\n  }\n  return SbbFormAssociatedElement as unknown as AbstractConstructor<SbbFormAssociatedMixinType<V>> &\n    T;\n};\n\n/**\n * A value to be restored for a component's form value. If a component's form\n * state is a `FormData` object, its entry list of name and values will be\n * provided.\n */\nexport type FormRestoreState = File | string | [string, FormDataEntryValue][];\n\n/**\n * The reason a form component is being restored for, either `'restore'` for\n * browser restoration or `'autocomplete'` for restoring user values.\n */\nexport type FormRestoreReason = 'restore' | 'autocomplete';\n","import type { LitElement, PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\nimport type { SbbFormAssociatedMixinType } from './form-associated-mixin.js';\n\nexport declare class SbbRequiredMixinType {\n  public accessor required: boolean;\n  protected isRequiredExternally(): boolean;\n}\n\n/**\n * Enhance your component with a required property.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbRequiredMixin = <\n  T extends AbstractConstructor<LitElement & SbbFormAssociatedMixinType<V>>,\n  V,\n>(\n  superClass: T,\n): AbstractConstructor<SbbRequiredMixinType> & T => {\n  abstract class SbbRequiredElement extends superClass implements Partial<SbbRequiredMixinType> {\n    /** Whether the component is required. */\n    @property({ reflect: true, type: Boolean })\n    public set required(value: boolean) {\n      // To provide the same behavior as the native required state,\n      // any value is converted to a boolean.\n      this._required = Boolean(value);\n    }\n    public get required(): boolean {\n      return this._required || this.isRequiredExternally();\n    }\n    private _required: boolean = false;\n\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('required')) {\n        // Firefox needs explicitly set aria-required value.\n        this.internals.ariaRequired = `${this.required}`;\n      }\n    }\n\n    /**\n     * Will be used as 'or' check to the current required state.\n     * Can e.g. be used to read required state of a group.\n     */\n    protected isRequiredExternally(): boolean {\n      return false;\n    }\n  }\n\n  return SbbRequiredElement as unknown as AbstractConstructor<SbbRequiredMixinType> & T;\n};\n","import { defaultConverter, type LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbLanguageController } from '../controllers.js';\nimport { hostAttributes } from '../decorators.js';\nimport { preventScrollOnSpacebarPress } from '../eventing.js';\nimport { i18nCheckboxRequired } from '../i18n.js';\n\nimport type { Constructor } from './constructor.js';\nimport { SbbDisabledMixin, type SbbDisabledMixinType } from './disabled-mixin.js';\nimport {\n  SbbFormAssociatedMixin,\n  type FormRestoreReason,\n  type FormRestoreState,\n  type SbbFormAssociatedMixinType,\n} from './form-associated-mixin.js';\nimport { SbbRequiredMixin, type SbbRequiredMixinType } from './required-mixin.js';\n\ntype CheckedSetterValue = { value: boolean; attribute: boolean };\n\nexport declare abstract class SbbFormAssociatedCheckboxMixinType\n  extends SbbFormAssociatedMixinType\n  implements Partial<SbbDisabledMixinType>, Partial<SbbRequiredMixinType>\n{\n  public get checked(): boolean;\n  public set checked(value: boolean);\n\n  public set disabled(value: boolean);\n  public get disabled(): boolean;\n\n  public set required(value: boolean);\n  public get required(): boolean;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected isDisabledExternally(): boolean;\n  protected isRequiredExternally(): boolean;\n  protected withUserInteraction?(): void;\n  protected updateFormValue(): void;\n}\n\n/**\n * The FormAssociatedCheckboxMixin enables native form support for checkbox controls.\n *\n * Inherited classes MUST implement the ariaChecked state (ElementInternals) themselves.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedCheckboxMixin = <T extends Constructor<LitElement>>(\n  superClass: T,\n): Constructor<SbbFormAssociatedCheckboxMixinType> & T => {\n  @hostAttributes({\n    tabindex: '0',\n  })\n  abstract class SbbFormAssociatedCheckboxElement\n    extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(superClass)))\n    implements Partial<SbbFormAssociatedCheckboxMixinType>\n  {\n    private _attributeMutationBlocked = false;\n    private _languageController = new SbbLanguageController(this);\n\n    /** Whether the checkbox is checked. */\n    @property({\n      type: Boolean,\n      converter: {\n        ...defaultConverter,\n        // We need to pass information to the setter so that we know it was called by attribute change.\n        fromAttribute: (value: string | null, type?: unknown): CheckedSetterValue => {\n          const result = defaultConverter.fromAttribute?.(value, type);\n          return { value: result, attribute: true } as CheckedSetterValue;\n        },\n      },\n    })\n    public set checked(value: boolean) {\n      const attributeSetter =\n        typeof value === 'object' ? (value as unknown as CheckedSetterValue).attribute : false;\n      if (attributeSetter) {\n        value = (value as unknown as CheckedSetterValue).value;\n      }\n\n      // As soon as mutation was done not by setting attribute,\n      // we need to block syncing attribute.\n      if (this.hasUpdated && !attributeSetter) {\n        this._attributeMutationBlocked = true;\n      }\n      this._checked = Boolean(value);\n      this.updateFormValue();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    /**\n     * Form type of element.\n     * @default 'checkbox'\n     */\n    public override get type(): string {\n      return 'checkbox';\n    }\n\n    protected constructor() {\n      super();\n      /** @internal */\n      this.internals.role = 'checkbox';\n\n      this.addEventListener?.('click', this._handleUserInteraction);\n      this.addEventListener?.('keydown', preventScrollOnSpacebarPress);\n      this.addEventListener?.('keyup', this._handleKeyboardInteraction);\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      // Attribute should not be interpreted after programmatic or manual state change.\n      if (name !== 'checked' || !this._attributeMutationBlocked) {\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.checked = this.hasAttribute('checked');\n      this._attributeMutationBlocked = false;\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) {\n        this.checked = state === 'true';\n      }\n    }\n\n    /**\n     * Additional logic which is being executed when user\n     * interaction happens and state is not disabled.\n     */\n    protected withUserInteraction?(): void;\n\n    protected override updateFormValue(): void {\n      if (this.checked) {\n        this.internals.setFormValue(this.value, `${this.checked}`);\n      } else {\n        this.internals.setFormValue(null);\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    protected override validate(): void {\n      super.validate();\n      if (this.required && !this.checked) {\n        this.setValidityFlag(\n          'valueMissing',\n          i18nCheckboxRequired[this._languageController.current],\n        );\n      } else {\n        this.removeValidityFlag('valueMissing');\n      }\n    }\n\n    /** Method triggered on keyboard user interaction with checkbox. */\n    private _handleKeyboardInteraction = (event: KeyboardEvent): void => {\n      if (event.key === ' ') {\n        this._handleUserInteraction();\n      }\n    };\n\n    /** Method triggered on user interaction with checkbox. */\n    private _handleUserInteraction = (): void => {\n      if (this.disabled) {\n        return;\n      }\n      this.withUserInteraction?.();\n      this.checked = !this.checked;\n      this._attributeMutationBlocked = true;\n\n      this.dispatchEvent(new InputEvent('input', { composed: true, bubbles: true }));\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    };\n  }\n\n  return SbbFormAssociatedCheckboxElement as unknown as Constructor<SbbFormAssociatedCheckboxMixinType> &\n    T;\n};\n","import { html, isServer, type LitElement, type PropertyValues } from 'lit';\nimport { eventOptions, property } from 'lit/decorators.js';\n\nimport { sbbInputModalityDetector } from '../a11y.js';\nimport { SbbLanguageController } from '../controllers.js';\nimport { isFirefox, isWebkit } from '../dom.js';\nimport { i18nInputRequired } from '../i18n.js';\n\nimport type { Constructor } from './constructor.js';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n  type SbbFormAssociatedMixinType,\n} from './form-associated-mixin.js';\nimport { SbbRequiredMixin, type SbbRequiredMixinType } from './required-mixin.js';\n\nexport declare abstract class SbbFormAssociatedInputMixinType\n  extends SbbFormAssociatedMixinType\n  implements Partial<SbbRequiredMixinType>\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 required(value: boolean);\n  public get required(): boolean;\n\n  public set placeholder(value: string);\n  public get placeholder(): string;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected withUserInteraction?(): void;\n  protected updateFormValue(): void;\n  protected language: SbbLanguageController;\n}\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 Constructor<LitElement>>(\n  superClass: T,\n): Constructor<SbbFormAssociatedInputMixinType> & T => {\n  abstract class SbbFormAssociatedInputElement\n    extends SbbRequiredMixin(SbbFormAssociatedMixin(superClass))\n    implements Partial<SbbFormAssociatedInputMixinType>\n  {\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 occured since creation\n     * or the last form reset.\n     */\n    private _interacted = false;\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 text value of the input element.\n     */\n    public override set value(value: string) {\n      super.value = this._cleanText(value);\n      if (this.hasUpdated) {\n        this.innerHTML = super.value;\n      }\n    }\n    public override get value(): string {\n      return super.value ?? '';\n    }\n\n    /**\n     * Whether the component is readonly.\n     * @attr readonly\n     * @default false\n     */\n    @property({ type: Boolean })\n    public set readOnly(value: boolean) {\n      this.toggleAttribute('readonly', !!value);\n      this.internals.ariaReadOnly = value ? 'true' : null;\n      this._updateContenteditable();\n    }\n    public get readOnly(): boolean {\n      return this.hasAttribute('readonly');\n    }\n\n    /**\n     * Whether the component is disabled.\n     * @attr disabled\n     * @default false\n     */\n    @property({ type: Boolean })\n    public set disabled(value: boolean) {\n      this.toggleAttribute('disabled', !!value);\n      this.internals.ariaDisabled = value ? 'true' : null;\n      this._updateContenteditable();\n    }\n    public get disabled(): boolean {\n      return this.hasAttribute('disabled');\n    }\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      /** @internal */\n      this.internals.role = 'textbox';\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          super.value = this._cleanText(this.textContent ?? '');\n          this._interacted = true;\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          // 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          }\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        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(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          window.getSelection()?.selectAllChildren(this);\n        }\n      });\n      // On blur the native text input scrolls the text to the start of the text.\n      // We mimick 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          this._emitChangeIfNecessary();\n          this.scrollLeft = 0;\n        },\n        { capture: true },\n      );\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.innerHTML = 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 (!isServer && !this.disabled && !this.readOnly && this.value) {\n        const selection = window.getSelection();\n        if (!selection) {\n          return;\n        }\n        let range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;\n        if (range && range.startOffset !== 0) {\n          return;\n        }\n\n        range = document.createRange();\n        range.setStart(this.firstChild!, this.textContent!.length);\n        range.collapse(true);\n        selection.removeAllRanges();\n        selection.addRange(range);\n      }\n    }\n\n    public override attributeChangedCallback(\n      name: string,\n      old: string | null,\n      value: string | null,\n    ): void {\n      if (name !== 'value' || !this._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._interacted = false;\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    protected override async firstUpdated(changedProperties: PropertyValues<this>): Promise<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.innerHTML = this.value;\n      }\n    }\n\n    protected override updateFormValue(): void {\n      this.internals.setFormValue(this.value, this.value);\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    private _cleanText(value: string): string {\n      // The native text input removes all newline characters if passed to the value property\n      return `${value}`.replace(/[\\n\\r]+/g, '');\n    }\n\n    private _dispatchInputEvent(): void {\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        // Firefox does not yet support plaintext-only. Once this is available\n        // for our supported browser range, we can switch to it fully.\n        const value =\n          this.disabled || this.readOnly ? 'false' : isFirefox ? 'true' : 'plaintext-only';\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        this.dispatchEvent(new Event('change', { bubbles: true }));\n      }\n    }\n\n    protected override render(): unknown {\n      return html`<slot @slotchange=${this._cleanChildren}></slot>`;\n    }\n  }\n\n  return SbbFormAssociatedInputElement as unknown as Constructor<SbbFormAssociatedInputMixinType> &\n    T;\n};\n","import { isServer, type LitElement, type PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { getNextElementIndex, interactivityChecker, isArrowKeyPressed } from '../a11y.js';\nimport { SbbConnectedAbortController, SbbLanguageController } from '../controllers.js';\nimport { i18nSelectionRequired } from '../i18n.js';\n\nimport type { Constructor } from './constructor.js';\nimport { SbbDisabledMixin, type SbbDisabledMixinType } from './disabled-mixin.js';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n  type SbbFormAssociatedMixinType,\n} from './form-associated-mixin.js';\nimport { SbbRequiredMixin, type SbbRequiredMixinType } from './required-mixin.js';\n\n/**\n * A static registry that holds a collection of grouped `radio-buttons`.\n * Groups of radio buttons are local to the form they belong (or the `renderRoot` if they're not part of any form)\n * Multiple groups of radio with the same name can coexist (as long as they belong to a different form / renderRoot)\n * It is mainly used to support the standalone groups of radios.\n * @internal\n */\nexport const radioButtonRegistry = new WeakMap<\n  Node,\n  Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>\n>();\n\nexport declare class SbbFormAssociatedRadioButtonMixinType\n  extends SbbFormAssociatedMixinType\n  implements Partial<SbbDisabledMixinType>, Partial<SbbRequiredMixinType>\n{\n  public accessor checked: boolean;\n  public accessor disabled: boolean;\n  public accessor required: boolean;\n\n  protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonMixinType>;\n  /** @deprecated No longer used internally. */\n  protected abort: SbbConnectedAbortController;\n\n  public formResetCallback(): void;\n  public formStateRestoreCallback(state: FormRestoreState | null, reason: FormRestoreReason): void;\n\n  protected isDisabledExternally(): boolean;\n  protected isRequiredExternally(): boolean;\n  protected withUserInteraction?(): void;\n  protected updateFormValue(): void;\n  protected updateFocusableRadios(): void;\n  protected emitChangeEvents(): void;\n  protected navigateByKeyboard(radio: SbbFormAssociatedRadioButtonMixinType): Promise<void>;\n}\n\n/**\n * The SbbFormAssociatedRadioButtonMixin enables native form support for radio controls.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFormAssociatedRadioButtonMixin = <T extends Constructor<LitElement>>(\n  superClass: T,\n): Constructor<SbbFormAssociatedRadioButtonMixinType> & T => {\n  class SbbFormAssociatedRadioButtonElement\n    extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(superClass)))\n    implements Partial<SbbFormAssociatedRadioButtonMixinType>\n  {\n    /**\n     * Whether the radio button is checked.\n     */\n    @property({ type: Boolean })\n    public set checked(value: boolean) {\n      this._checked = !!value;\n\n      this.toggleAttribute('data-checked', this.checked);\n      this.internals.ariaChecked = this.checked.toString();\n      this.updateFormValue();\n      this._synchronizeGroupState();\n    }\n    public get checked(): boolean {\n      return this._checked;\n    }\n    private _checked: boolean = false;\n\n    public override set name(value: string) {\n      super.name = value;\n\n      this._disconnectFromRegistry();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n    public override get name(): string {\n      return super.name;\n    }\n\n    /**\n     * Form type of element.\n     * @default 'radio'\n     */\n    public override get type(): string {\n      return 'radio';\n    }\n\n    /** @deprecated No longer used internally. */\n    protected abort = new SbbConnectedAbortController(this);\n\n    /**\n     * Set of radio buttons that belongs to the same group of `this`.\n     * Assume them ordered in DOM order\n     */\n    protected associatedRadioButtons?: Set<SbbFormAssociatedRadioButtonElement>;\n    private _radioButtonGroupsMap?: Map<string, Set<SbbFormAssociatedRadioButtonMixinType>>;\n    private _languageController = new SbbLanguageController(this);\n\n    protected constructor() {\n      super();\n      /** @internal */\n      this.internals.role = 'radio';\n      this.addEventListener?.('keydown', (e) => this._handleArrowKeyDown(e));\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this._connectToRegistry();\n      this._synchronizeGroupState();\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this._disconnectFromRegistry();\n    }\n\n    /**\n     * Is called whenever the form is being reset.\n     * @internal\n     */\n    public override formResetCallback(): void {\n      this.checked = this.hasAttribute('checked');\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     * @internal\n     */\n    public override formStateRestoreCallback(\n      state: FormRestoreState | null,\n      _reason: FormRestoreReason,\n    ): void {\n      if (state) {\n        this.checked = state === this.value;\n      }\n    }\n\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (changedProperties.has('disabled')) {\n        this.updateFocusableRadios();\n      }\n    }\n\n    protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n      super.firstUpdated(changedProperties);\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Called on `value` change\n     * If 'checked', update the value. Otherwise, do nothing.\n     */\n    protected override updateFormValue(): void {\n      if (this.checked) {\n        this.internals.setFormValue(this.value, this.value);\n      } else {\n        this.internals.setFormValue(null);\n      }\n    }\n\n    protected override shouldValidate(name: PropertyKey | undefined): boolean {\n      return super.shouldValidate(name) || name === 'checked' || name === 'required';\n    }\n\n    /**\n     * Sets the validity of all associated radio buttons.\n     * If any radio button is required, all associated are required as well.\n     */\n    protected override validate(): void {\n      super.validate();\n      if (!this.associatedRadioButtons) {\n        return;\n      }\n\n      let required = false;\n      let checked = false;\n      for (const radio of this.associatedRadioButtons) {\n        required ||= radio.required;\n        checked ||= radio.checked;\n      }\n\n      if (required && !checked) {\n        this.associatedRadioButtons.forEach((r) =>\n          r.setValidityFlag(\n            'valueMissing',\n            i18nSelectionRequired[this._languageController.current],\n          ),\n        );\n      } else {\n        this.associatedRadioButtons.forEach((r) => r.removeValidityFlag('valueMissing'));\n      }\n    }\n\n    /**\n     * Only a single radio should be focusable in the group. Defined as:\n     * - the checked radio;\n     * - the first non-disabled radio in DOM order;\n     */\n    protected updateFocusableRadios(): void {\n      if (!this.hasUpdated) {\n        return;\n      }\n      const radios = this._interactableGroupedRadios();\n      const checkedIndex = radios.findIndex((r) => r.checked && !r.disabled && !r.formDisabled);\n      const focusableIndex =\n        checkedIndex !== -1\n          ? checkedIndex\n          : radios.findIndex((r) => !r.disabled && !r.formDisabled); // Get the first focusable radio\n\n      if (focusableIndex !== -1) {\n        radios[focusableIndex].tabIndex = 0;\n        radios.splice(focusableIndex, 1);\n      }\n\n      // Reset tabIndex on other radios\n      radios.forEach((r) => r.removeAttribute('tabindex'));\n    }\n\n    protected async navigateByKeyboard(next: SbbFormAssociatedRadioButtonElement): Promise<void> {\n      next.checked = true;\n      this.emitChangeEvents();\n\n      await next.updateComplete;\n      next.focus();\n    }\n\n    protected emitChangeEvents(): void {\n      // Manually dispatch events to simulate a user interaction\n      this.dispatchEvent(\n        new InputEvent('input', { bubbles: true, cancelable: true, composed: true }),\n      );\n      this.dispatchEvent(new Event('change', { bubbles: true }));\n    }\n\n    private _synchronizeGroupState(): void {\n      if (this.checked) {\n        this._deselectGroupedRadios();\n      }\n      this.updateFocusableRadios();\n    }\n\n    /**\n     * Add `this` to the radioButton registry\n     */\n    private _connectToRegistry(): void {\n      if (!this.name || isServer) {\n        return;\n      }\n\n      const root = this.form ?? this.getRootNode();\n      this._radioButtonGroupsMap = radioButtonRegistry.get(root);\n\n      // Initialize the 'root' map entry\n      if (!this._radioButtonGroupsMap) {\n        this._radioButtonGroupsMap = new Map();\n        radioButtonRegistry.set(root, this._radioButtonGroupsMap);\n      }\n\n      this.associatedRadioButtons = this._radioButtonGroupsMap.get(\n        this.name,\n      ) as unknown as Set<SbbFormAssociatedRadioButtonElement>;\n\n      // Initialize the group set\n      if (!this.associatedRadioButtons) {\n        this.associatedRadioButtons = new Set();\n        this._radioButtonGroupsMap.set(\n          this.name,\n          this.associatedRadioButtons as unknown as Set<SbbFormAssociatedRadioButtonMixinType>,\n        );\n      }\n\n      // Insert the new radio into the set and sort following the DOM order.\n      // Since the order of a 'Set' is the insert order, we have to empty it and re-insert radios in order\n      const entries = Array.from(this.associatedRadioButtons);\n      this.associatedRadioButtons.clear();\n\n      // Find `this` position and insert it\n      const index = entries.findIndex(\n        (r) => this.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_FOLLOWING,\n      );\n      if (index !== -1) {\n        entries.splice(index, 0, this);\n      } else {\n        entries.push(this);\n      }\n\n      // Repopulate the Set\n      entries.forEach((r) => this.associatedRadioButtons!.add(r));\n\n      this.validate();\n    }\n\n    /**\n     * Remove `this` from the radioButton registry and, if the group is empty, delete the entry from the groups Map\n     */\n    private _disconnectFromRegistry(): void {\n      this.associatedRadioButtons?.delete(this);\n\n      if (this.associatedRadioButtons?.size === 0) {\n        this._radioButtonGroupsMap?.delete(this.name);\n      } else {\n        this.validate();\n      }\n\n      this.associatedRadioButtons = undefined;\n      this._radioButtonGroupsMap = undefined;\n    }\n\n    /**\n     * Return a list of 'interactable' grouped radios, ordered in DOM order\n     */\n    private _interactableGroupedRadios(): SbbFormAssociatedRadioButtonElement[] {\n      return Array.from(this.associatedRadioButtons ?? []).filter((el) =>\n        interactivityChecker.isVisible(el),\n      );\n    }\n\n    /**\n     * Deselect other radio of the same group\n     */\n    private _deselectGroupedRadios(): void {\n      Array.from(this.associatedRadioButtons ?? [])\n        .filter((r) => r !== this)\n        .forEach((r) => (r.checked = false));\n    }\n\n    private async _handleArrowKeyDown(evt: KeyboardEvent): Promise<void> {\n      if (!isArrowKeyPressed(evt)) {\n        return;\n      }\n      evt.preventDefault();\n\n      const enabledRadios = this._interactableGroupedRadios().filter(\n        (r) => !r.disabled && !r.formDisabled,\n      );\n      const current: number = enabledRadios.indexOf(this);\n      const nextIndex: number = getNextElementIndex(evt, current, enabledRadios.length);\n\n      await this.navigateByKeyboard(enabledRadios[nextIndex]);\n    }\n  }\n\n  return SbbFormAssociatedRadioButtonElement as unknown as Constructor<SbbFormAssociatedRadioButtonMixinType> &\n    T;\n};\n","import type { LitElement, PropertyValues } from 'lit';\n\nimport type { AbstractConstructor } from './constructor.js';\n\n// Define the interface for the mixin\nexport declare abstract class SbbHydrationMixinType {\n  /**\n   * Returns a Promise that resolves when the element has completed hydration.\n   * The Promise value is a boolean that is `true` if the element required hydration\n   * and `false` if not.\n   *\n   * @return A promise of a boolean that resolves to true once the hydration completed.\n   */\n  public get hydrationComplete(): Promise<boolean>;\n\n  /** Returns whether hydration is required and not completed. */\n  protected get hydrationRequired(): boolean;\n}\n\n/**\n * This mixin extends a base class with functionality to check if hydration is completed.\n * It also delays slotchange events until hydration is complete.\n *\n * @param base The class to extend.\n * @returns A class extended with the hydration check functionality.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbHydrationMixin = <T extends AbstractConstructor<LitElement>>(\n  base: T,\n): AbstractConstructor<SbbHydrationMixinType> & T => {\n  abstract class SbbHydrationMixinClass extends base implements Partial<SbbHydrationMixinType> {\n    private _hydrationRequired: boolean;\n    private _hydrationComplete = new Promise<boolean>(\n      (resolve) => (this._resolveHydration = resolve),\n    );\n    private _resolveHydration!: (hydrationRequired: boolean) => void;\n\n    /**\n     * Returns a Promise that resolves when the element has completed hydration.\n     * The Promise value is a boolean that is `true` if the element required hydration\n     * and `false` if not.\n     *\n     * @return A promise of a boolean that resolves to true once the hydration completed.\n     * @internal\n     */\n    public get hydrationComplete(): Promise<boolean> {\n      return this._hydrationComplete;\n    }\n\n    /** Returns whether hydration is required and not completed. */\n    protected get hydrationRequired(): boolean {\n      return this._hydrationRequired;\n    }\n\n    public constructor(...args: any[]) {\n      super(...args);\n      // Check whether hydration is needed by checking whether the shadow root\n      // is available during construction/upgrade phase.\n      this._hydrationRequired = !!this.shadowRoot;\n      if (!this._hydrationRequired) {\n        this._resolveHydration(false);\n      } else {\n        // During hydration phase, we want to suppress slotchange events as they\n        // can cause render differences, which would break hydration. After\n        // hydration is complete, we dispatch a manual slotchange event, if there\n        // are elements assigned to a slot.\n        const suppressSlotchangeEvent = (event: Event): void => {\n          if (this._hydrationRequired) {\n            event.stopImmediatePropagation();\n          }\n        };\n        const eventOptions: EventListenerOptions = { capture: true };\n        const slots = this.shadowRoot?.querySelectorAll('slot');\n        if (slots?.length) {\n          slots.forEach((slot) =>\n            slot.addEventListener('slotchange', suppressSlotchangeEvent, eventOptions),\n          );\n          this.hydrationComplete.then(() =>\n            slots.forEach((slot) => {\n              slot.removeEventListener('slotchange', suppressSlotchangeEvent, eventOptions);\n              if (slot.assignedNodes().length) {\n                slot.dispatchEvent(new Event('slotchange', { bubbles: true }));\n              }\n            }),\n          );\n        }\n      }\n    }\n\n    protected override update(changedProperties: PropertyValues<this>): void {\n      // When hydration is needed, we wait the hydration process to finish, which is patched\n      // into the update method of the LitElement base class.\n      super.update(changedProperties);\n\n      if (this._hydrationRequired) {\n        this._hydrationRequired = false;\n        this._resolveHydration(true);\n      }\n    }\n  }\n  return SbbHydrationMixinClass as unknown as AbstractConstructor<SbbHydrationMixinType> & T;\n};\n","import { html, type LitElement, nothing, type TemplateResult } from 'lit';\nimport { state } from 'lit/decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\nimport { SbbHydrationMixin, type SbbHydrationMixinType } from './hydration-mixin.js';\n\nimport '../../screen-reader-only.js';\n\nconst SSR_CHILD_COUNT_ATTRIBUTE = 'data-ssr-child-count';\nconst SLOTNAME_PREFIX = 'li';\n\nexport type SbbNamedSlotProperties = {\n  name: string;\n  ariaHidden: boolean;\n};\n\n/**\n * Helper type for willUpdate or similar checks.\n * Allows the usage of the string literal 'listChildren'.\n *\n * @example\n * protected override willUpdate(changedProperties: PropertyValues<WithListChildren<this>>): void {\n *   if (changedProperties.has('listChildren')) {\n *     ...\n *   }\n * }\n */\nexport type WithListChildren<\n  T extends SbbNamedSlotListMixinType<C>,\n  C extends HTMLElement = HTMLElement,\n> = T & { listChildren: C[] };\n\nexport declare abstract class SbbNamedSlotListMixinType<\n  C extends HTMLElement,\n> extends SbbHydrationMixinType {\n  protected abstract readonly listChildLocalNames: string[];\n  protected accessor listChildren: C[];\n  protected renderList(\n    attributes?: {\n      class?: string;\n      ariaLabel?: string;\n      ariaLabelledby?: string;\n    },\n    listItemAttributes?: {\n      localNameVisualOnly?: string[];\n    },\n  ): TemplateResult;\n  protected listSlotEntries(): SbbNamedSlotProperties[];\n  protected renderHiddenSlot(): TemplateResult;\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbNamedSlotListMixin = <\n  C extends HTMLElement,\n  T extends AbstractConstructor<LitElement>,\n>(\n  superClass: T,\n): AbstractConstructor<SbbNamedSlotListMixinType<C>> & T => {\n  /**\n   * This base class provides named slot list observer functionality.\n   * This allows using the pattern of rendering a named slot for each child, which allows\n   * wrapping children in an ul/li list.\n   */\n  abstract class NamedSlotListElement<C extends HTMLElement = HTMLElement>\n    extends SbbHydrationMixin(superClass)\n    implements Partial<SbbNamedSlotListMixinType<C>>\n  {\n    /** A list of lower-cased tag names to match against. (e.g. `sbb-link`) */\n    protected abstract readonly listChildLocalNames: string[];\n\n    /**\n     * A list of children with the defined tag names.\n     * This array is only updated if there is an actual change\n     * to the child elements.\n     */\n    @state() protected accessor listChildren: C[] = [];\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n      this.shadowRoot?.addEventListener('slotchange', this._handleSlotchange, { passive: true });\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this.shadowRoot?.removeEventListener('slotchange', this._handleSlotchange);\n    }\n\n    private _handleSlotchange = (): void => {\n      const listChildren = Array.from(this.children ?? []).filter((e): e is C =>\n        this.listChildLocalNames.includes(e.localName),\n      );\n      // If the slotted child instances have not changed, we can skip syncing and updating\n      // the link reference list.\n      if (\n        listChildren.length === this.listChildren.length &&\n        this.listChildren.every((e, i) => listChildren[i] === e)\n      ) {\n        return;\n      }\n\n      this.listChildren\n        .filter((c) => !listChildren.includes(c))\n        .forEach((c) => c.removeAttribute('slot'));\n      this.listChildren = listChildren;\n      this.listChildren.forEach((c, index) =>\n        c.setAttribute('slot', `${SLOTNAME_PREFIX}-${index}`),\n      );\n\n      // Remove the ssr attribute, once we have actually initialized the children elements.\n      this.removeAttribute(SSR_CHILD_COUNT_ATTRIBUTE);\n    };\n\n    /**\n     * Renders list and list slots for slotted children or a number of list slots\n     * corresponding to the `data-ssr-child-count` attribute value.\n     *\n     * This is a possible optimization for SSR, as in an SSR Lit environment\n     * other elements are not available, but might be available in the meta\n     * framework wrapper (like e.g. React). This allows to provide the number of\n     * children to be passed via the `data-ssr-child-count` attribute value.\n     */\n    protected renderList(\n      attributes: { class?: string; ariaLabel?: string; ariaLabelledby?: string } = {},\n      listItemAttributes: { localNameVisualOnly?: string[] } = {},\n    ): TemplateResult {\n      const listSlotNames: SbbNamedSlotProperties[] = this.listSlotEntries(listItemAttributes);\n\n      if (listSlotNames.length >= 2) {\n        return html`\n          <ul\n            class=${attributes.class || this.localName}\n            aria-label=${attributes.ariaLabel || nothing}\n            aria-labelledby=${attributes.ariaLabelledby || nothing}\n          >\n            ${listSlotNames.map(\n              (slot) => html`\n                <li aria-hidden=${slot.ariaHidden || nothing}>\n                  <slot name=${slot.name}></slot>\n                </li>\n              `,\n            )}\n          </ul>\n          ${this.renderHiddenSlot()}\n        `;\n      } else if (listSlotNames.length === 1) {\n        return html`<sbb-screen-reader-only>${attributes.ariaLabel}</sbb-screen-reader-only>\n          <span class=${attributes.class || this.localName}>\n            <span><slot name=${listSlotNames[0].name}></slot></span>\n          </span>\n          ${this.renderHiddenSlot()} `;\n      } else {\n        return this.renderHiddenSlot();\n      }\n    }\n\n    /**\n     * Returns an array of SbbNamedSlotProperties, which holds the list slot names and the hidden property;\n     * its length corresponds to the number of matched children or the `data-ssr-child-count` attribute value.\n     *\n     * This is a possible optimization for SSR, as in an SSR Lit environment\n     * other elements are not available, but might be available in the meta\n     * framework wrapper (like e.g. React). This allows to provide the number of\n     * children to be passed via the `data-ssr-child-count` attribute value.\n     */\n    protected listSlotEntries(listItemAttributes: {\n      localNameVisualOnly?: string[];\n    }): SbbNamedSlotProperties[] {\n      const listChildren = this.listChildren.length\n        ? this.listChildren\n        : Array.from({ length: +(this.getAttribute(SSR_CHILD_COUNT_ATTRIBUTE) ?? 0) });\n      return listChildren.map((e, i) => {\n        return {\n          name: `${SLOTNAME_PREFIX}-${i}`,\n          ariaHidden:\n            listItemAttributes?.localNameVisualOnly?.includes((e as HTMLElement).localName) ??\n            false,\n        };\n      });\n    }\n\n    /**\n     * Returns a hidden slot, which is intended as the children change detection.\n     * When an element without a slot attribute is slotted to the element, it triggers\n     * the slotchange event, which can be used to assign it to the appropriate named slot.\n     */\n    protected renderHiddenSlot(): TemplateResult {\n      return html`<span hidden><slot></slot></span>`;\n    }\n  }\n\n  return NamedSlotListElement as unknown as AbstractConstructor<SbbNamedSlotListMixinType<C>> & T;\n};\n","import type { LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType } from '../decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\nexport declare class SbbNegativeMixinType {\n  public accessor negative: boolean;\n}\n\n/**\n * Enhance your component with a negative property.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbNegativeMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbNegativeMixinType> & T => {\n  abstract class SbbNegativeElement extends superClass implements SbbNegativeMixinType {\n    /** Negative coloring variant flag. */\n    @forceType()\n    @property({ reflect: true, type: Boolean })\n    public accessor negative: boolean = false;\n  }\n\n  return SbbNegativeElement as AbstractConstructor<SbbNegativeMixinType> & T;\n};\n","import type { LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType } from '../decorators.js';\nimport { EventEmitter } from '../eventing.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\nexport declare class SbbPanelMixinType {\n  public accessor color: 'white' | 'milk';\n  public accessor borderless: boolean;\n  public accessor expansionState: string;\n}\n\nexport type SbbPanelSize = 's' | 'm';\n\n/**\n * Mixin for common panel behaviors\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbPanelMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbPanelMixinType> & T => {\n  abstract class SbbPanelElement extends superClass implements SbbPanelMixinType {\n    public static readonly events = {\n      panelConnected: 'panelConnected',\n    } as const;\n\n    /** The background color of the panel. */\n    @property({ reflect: true }) public accessor color: 'white' | 'milk' = 'white';\n\n    /** Whether the unselected panel has a border. */\n    @forceType()\n    @property({ reflect: true, type: Boolean })\n    public accessor borderless: boolean = false;\n\n    /** @internal used for accessibility label when in expansion panel */\n    @forceType()\n    @property()\n    public accessor expansionState: string = '';\n\n    /**\n     * @internal\n     * Internal event that emits when the checkbox is loaded.\n     */\n    private _panelConnected: EventEmitter<void> = new EventEmitter(\n      this,\n      SbbPanelElement.events.panelConnected,\n      { bubbles: true },\n    );\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n\n      this._panelConnected.emit();\n\n      this.closest?.('sbb-radio-button-group, sbb-checkbox-group')?.toggleAttribute(\n        'data-has-panel',\n        true,\n      );\n    }\n  }\n\n  return SbbPanelElement as AbstractConstructor<SbbPanelMixinType> & T;\n};\n","import type { LitElement } from 'lit';\n\nimport type { AbstractConstructor } from './constructor.js';\n\n// Define the interface for the mixin\nexport declare class SbbUpdateSchedulerMixinType {\n  protected startUpdate(): void;\n  protected completeUpdate(): void;\n}\n\n/**\n * This mixin allows scheduling manual updates, which affect updateComplete.\n * @param base The class to extend.\n * @returns A class extended with the slot child observer functionality.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbUpdateSchedulerMixin = <T extends AbstractConstructor<LitElement>>(\n  base: T,\n): AbstractConstructor<SbbUpdateSchedulerMixinType> & T => {\n  abstract class SbbUpdateSchedulerElement\n    extends base\n    implements Partial<SbbUpdateSchedulerMixinType>\n  {\n    private _updatePromise = Promise.resolve();\n    private _updateResolve = (): void => {};\n\n    protected startUpdate(): void {\n      this._updatePromise = new Promise<void>((r) => (this._updateResolve = r));\n    }\n\n    protected completeUpdate(): void {\n      this._updateResolve();\n    }\n\n    protected override async getUpdateComplete(): Promise<boolean> {\n      const result = await super.getUpdateComplete();\n      await this._updatePromise;\n      return result;\n    }\n  }\n  return SbbUpdateSchedulerElement as unknown as AbstractConstructor<SbbUpdateSchedulerMixinType> &\n    T;\n};\n"],"names":["_a","state","_b","eventOptions","SbbPanelElement"],"mappings":"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"}