@sbb-esta/lyne-elements 1.13.0 → 1.14.0

package/development/core/mixins.js

@@ -1,53 +1,83 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __esDecorate, __runInitializers } from "tslib";
 import { property, state } from "lit/decorators.js";
+import { forceType, getOverride, hostAttributes } from "./decorators.js";
 import { defaultConverter, html, nothing, css } from "lit";
-import { hostAttributes } from "./decorators.js";
 import { preventScrollOnSpacebarPress, EventEmitter } from "./eventing.js";
 import "../screen-reader-only.js";
-var __defProp$6 = Object.defineProperty;
-var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
-var __decorateClass$6 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp$6(target, key, result);
-  return result;
-};
 const SbbDisabledMixin = (superClass) => {
-  class SbbDisabledElement extends superClass {
-    constructor() {
-      super(...arguments);
-      this._disabled = false;
-    }
-    set disabled(value) {
-      this._disabled = Boolean(value);
-    }
-    get disabled() {
-      return this._disabled || this.isDisabledExternally();
-    }
-    /**
-     * Will be used as 'or' check to the current disabled state.
-     * Can e.g. be used to read disabled state of a group.
-     */
-    isDisabledExternally() {
-      return false;
-    }
-  }
-  __decorateClass$6([
-    property({ reflect: true, type: Boolean })
-  ], SbbDisabledElement.prototype, "disabled", 1);
+  let SbbDisabledElement = (() => {
+    var _disabled_accessor_storage, _a;
+    let _classSuper = superClass;
+    let _disabled_decorators;
+    let _disabled_initializers = [];
+    let _disabled_extraInitializers = [];
+    return _a = class extends _classSuper {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _disabled_accessor_storage, __runInitializers(this, _disabled_initializers, false));
+        __runInitializers(this, _disabled_extraInitializers);
+      }
+      /** Whether the component is disabled. */
+      get disabled() {
+        return __privateGet(this, _disabled_accessor_storage);
+      }
+      set disabled(value) {
+        __privateSet(this, _disabled_accessor_storage, value);
+      }
+      /**
+       * Will be used as 'or' check to the current disabled state.
+       * Can e.g. be used to read disabled state of a group.
+       */
+      isDisabledExternally() {
+        return false;
+      }
+    }, _disabled_accessor_storage = new WeakMap(), (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _disabled_decorators = [forceType(), property({ reflect: true, type: Boolean }), getOverride((e, v) => v || e.isDisabledExternally())];
+      __esDecorate(_a, null, _disabled_decorators, { kind: "accessor", name: "disabled", static: false, private: false, access: { has: (obj) => "disabled" in obj, get: (obj) => obj.disabled, set: (obj, value) => {
+        obj.disabled = value;
+      } }, metadata: _metadata }, _disabled_initializers, _disabled_extraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a;
+  })();
   return SbbDisabledElement;
 };
 const SbbDisabledInteractiveMixin = (superClass) => {
-  class SbbDisabledInteractiveElement extends superClass {
-    constructor() {
-      super(...arguments);
-      this.disabledInteractive = false;
-    }
-  }
-  __decorateClass$6([
-    property({ attribute: "disabled-interactive", type: Boolean })
-  ], SbbDisabledInteractiveElement.prototype, "disabledInteractive", 2);
+  let SbbDisabledInteractiveElement = (() => {
+    var _disabledInteractive_accessor_storage, _a;
+    let _classSuper = superClass;
+    let _disabledInteractive_decorators;
+    let _disabledInteractive_initializers = [];
+    let _disabledInteractive_extraInitializers = [];
+    return _a = class extends _classSuper {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _disabledInteractive_accessor_storage, __runInitializers(this, _disabledInteractive_initializers, false));
+        __runInitializers(this, _disabledInteractive_extraInitializers);
+      }
+      /** Whether disabled buttons should be interactive. */
+      get disabledInteractive() {
+        return __privateGet(this, _disabledInteractive_accessor_storage);
+      }
+      set disabledInteractive(value) {
+        __privateSet(this, _disabledInteractive_accessor_storage, value);
+      }
+    }, _disabledInteractive_accessor_storage = new WeakMap(), (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _disabledInteractive_decorators = [forceType(), property({ attribute: "disabled-interactive", type: Boolean })];
+      __esDecorate(_a, null, _disabledInteractive_decorators, { kind: "accessor", name: "disabledInteractive", static: false, private: false, access: { has: (obj) => "disabledInteractive" in obj, get: (obj) => obj.disabledInteractive, set: (obj, value) => {
+        obj.disabledInteractive = value;
+      } }, metadata: _metadata }, _disabledInteractive_initializers, _disabledInteractive_extraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a;
+  })();
   return SbbDisabledInteractiveElement;
 };
 const SbbDisabledTabIndexActionMixin = (superClass) => {
@@ -87,290 +117,330 @@ const SbbFocusableDisabledActionMixin = (superClass) => {
   }
   return SbbFocusableDisabledAction;
 };
-var __defProp$5 = Object.defineProperty;
-var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
-var __decorateClass$5 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp$5(target, key, result);
-  return result;
-};
 const SbbFormAssociatedMixin = (superClass) => {
-  const _SbbFormAssociatedElement = class _SbbFormAssociatedElement extends superClass {
-    constructor() {
-      super(...arguments);
-      this._value = null;
-      this.internals = this.attachInternals();
-      this.formDisabled = false;
-    }
-    /**
-     * Returns the form owner of the internals of the target element.
-     */
-    get form() {
-      return this.internals.form;
-    }
-    set name(name) {
-      this.setAttribute("name", `${name}`);
-      this.updateFormValue();
-    }
-    get name() {
-      return this.getAttribute("name") ?? "";
-    }
-    /** @internal */
-    get type() {
-      return this.localName;
-    }
-    set value(value) {
-      this._value = value;
-      this.updateFormValue();
-    }
-    get value() {
-      return this._value;
-    }
-    /**
-     * Returns the ValidityState object for internals target element.
-     *
-     * @internal
-     */
-    get validity() {
-      return this.internals.validity;
-    }
-    /**
-     * Returns the error message that would be shown to the user
-     * if internals target element was to be checked for validity.
-     *
-     * @internal
-     */
-    get validationMessage() {
-      return this.internals.validationMessage;
-    }
-    /**
-     * Returns true if internals target element will be validated
-     * when the form is submitted; false otherwise.
-     *
-     * @internal
-     */
-    get willValidate() {
-      return this.internals.willValidate;
-    }
-    attributeChangedCallback(name, old, value) {
-      if (name !== "name" || old !== value) {
-        super.attributeChangedCallback(name, old, value);
+  let SbbFormAssociatedElement = (() => {
+    var _formDisabled_accessor_storage, _a;
+    let _classSuper = superClass;
+    let _instanceExtraInitializers = [];
+    let _set_name_decorators;
+    let _set_value_decorators;
+    let _formDisabled_decorators;
+    let _formDisabled_initializers = [];
+    let _formDisabled_extraInitializers = [];
+    return _a = class extends _classSuper {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _formDisabled_accessor_storage);
+        this._value = (__runInitializers(this, _instanceExtraInitializers), null);
+        this.internals = this.attachInternals();
+        __privateSet(this, _formDisabled_accessor_storage, __runInitializers(this, _formDisabled_initializers, false));
+        __runInitializers(this, _formDisabled_extraInitializers);
       }
-    }
-    /**
-     * Returns true if internals target element has no validity problems; false otherwise.
-     * Fires an invalid event at the element in the latter case.
-     *
-     * @internal
-     */
-    checkValidity() {
-      return this.internals.checkValidity();
-    }
-    /**
-     * Returns true if internals target element has no validity problems; otherwise,
-     * returns false, fires an invalid event at the element,
-     * and (if the event isn't canceled) reports the problem to the user.
-     *
-     * @internal
-     */
-    reportValidity() {
-      return this.internals.reportValidity();
-    }
-    /**
-     * Is called whenever a surrounding form / fieldset changes disabled state.
-     * @param disabled
-     *
-     * @internal
-     */
-    formDisabledCallback(disabled) {
-      Promise.resolve().then(() => {
-        this.formDisabled = disabled;
-      });
-    }
-  };
-  _SbbFormAssociatedElement.formAssociated = true;
-  let SbbFormAssociatedElement = _SbbFormAssociatedElement;
-  __decorateClass$5([
-    property()
-  ], SbbFormAssociatedElement.prototype, "name", 1);
-  __decorateClass$5([
-    property()
-  ], SbbFormAssociatedElement.prototype, "value", 1);
-  __decorateClass$5([
-    state()
-  ], SbbFormAssociatedElement.prototype, "formDisabled", 2);
+      /**
+       * Returns the form owner of the internals of the target element.
+       */
+      get form() {
+        return this.internals.form;
+      }
+      /**
+       * Name of the form element. Will be read from name attribute.
+       *
+       * @description Developer note: In this case updating the attribute must be synchronous.
+       * Due to this it is implemented as a getter/setter and the attributeChangedCallback() handles the diff check.
+       */
+      set name(name) {
+        this.setAttribute("name", `${name}`);
+        this.updateFormValue();
+      }
+      get name() {
+        return this.getAttribute("name") ?? "";
+      }
+      /** @internal */
+      get type() {
+        return this.localName;
+      }
+      /** Value of the form element. */
+      set value(value) {
+        this._value = value;
+        this.updateFormValue();
+      }
+      get value() {
+        return this._value;
+      }
+      /**
+       * Returns the ValidityState object for internals target element.
+       *
+       * @internal
+       */
+      get validity() {
+        return this.internals.validity;
+      }
+      /**
+       * Returns the error message that would be shown to the user
+       * if internals target element was to be checked for validity.
+       *
+       * @internal
+       */
+      get validationMessage() {
+        return this.internals.validationMessage;
+      }
+      /**
+       * Returns true if internals target element will be validated
+       * when the form is submitted; false otherwise.
+       *
+       * @internal
+       */
+      get willValidate() {
+        return this.internals.willValidate;
+      }
+      /** Whenever a surrounding form or fieldset is changing its disabled state. */
+      get formDisabled() {
+        return __privateGet(this, _formDisabled_accessor_storage);
+      }
+      set formDisabled(value) {
+        __privateSet(this, _formDisabled_accessor_storage, value);
+      }
+      attributeChangedCallback(name, old, value) {
+        if (name !== "name" || old !== value) {
+          super.attributeChangedCallback(name, old, value);
+        }
+      }
+      /**
+       * Returns true if internals target element has no validity problems; false otherwise.
+       * Fires an invalid event at the element in the latter case.
+       *
+       * @internal
+       */
+      checkValidity() {
+        return this.internals.checkValidity();
+      }
+      /**
+       * Returns true if internals target element has no validity problems; otherwise,
+       * returns false, fires an invalid event at the element,
+       * and (if the event isn't canceled) reports the problem to the user.
+       *
+       * @internal
+       */
+      reportValidity() {
+        return this.internals.reportValidity();
+      }
+      /**
+       * Is called whenever a surrounding form / fieldset changes disabled state.
+       * @param disabled
+       *
+       * @internal
+       */
+      formDisabledCallback(disabled) {
+        Promise.resolve().then(() => {
+          this.formDisabled = disabled;
+        });
+      }
+    }, _formDisabled_accessor_storage = new WeakMap(), (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _set_name_decorators = [property()];
+      _set_value_decorators = [property()];
+      _formDisabled_decorators = [state()];
+      __esDecorate(_a, null, _set_name_decorators, { kind: "setter", name: "name", static: false, private: false, access: { has: (obj) => "name" in obj, set: (obj, value) => {
+        obj.name = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(_a, null, _set_value_decorators, { kind: "setter", name: "value", static: false, private: false, access: { has: (obj) => "value" in obj, set: (obj, value) => {
+        obj.value = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(_a, null, _formDisabled_decorators, { kind: "accessor", name: "formDisabled", static: false, private: false, access: { has: (obj) => "formDisabled" in obj, get: (obj) => obj.formDisabled, set: (obj, value) => {
+        obj.formDisabled = value;
+      } }, metadata: _metadata }, _formDisabled_initializers, _formDisabled_extraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a.formAssociated = true, _a;
+  })();
   return SbbFormAssociatedElement;
 };
-var __defProp$4 = Object.defineProperty;
-var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
-var __decorateClass$4 = (decorators, target, key, kind) => {
-  var result = __getOwnPropDesc$1(target, key);
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(target, key, result) || result;
-  if (result) __defProp$4(target, key, result);
-  return result;
-};
 const SbbRequiredMixin = (superClass) => {
-  class SbbRequiredElement extends superClass {
-    constructor() {
-      super(...arguments);
-      this._required = false;
-    }
-    set required(value) {
-      this._required = Boolean(value);
-    }
-    get required() {
-      return this._required || this.isRequiredExternally();
-    }
-    async willUpdate(changedProperties) {
-      super.willUpdate(changedProperties);
-      if (changedProperties.has("required")) {
-        this.internals.ariaRequired = `${this.required}`;
+  let SbbRequiredElement = (() => {
+    var _a;
+    let _classSuper = superClass;
+    let _instanceExtraInitializers = [];
+    let _set_required_decorators;
+    return _a = class extends _classSuper {
+      constructor() {
+        super(...arguments);
+        this._required = (__runInitializers(this, _instanceExtraInitializers), false);
       }
-    }
-    /**
-     * Will be used as 'or' check to the current required state.
-     * Can e.g. be used to read required state of a group.
-     */
-    isRequiredExternally() {
-      return false;
-    }
-  }
-  __decorateClass$4([
-    property({ reflect: true, type: Boolean })
-  ], SbbRequiredElement.prototype, "required");
+      /** Whether the component is required. */
+      set required(value) {
+        this._required = Boolean(value);
+      }
+      get required() {
+        return this._required || this.isRequiredExternally();
+      }
+      async willUpdate(changedProperties) {
+        super.willUpdate(changedProperties);
+        if (changedProperties.has("required")) {
+          this.internals.ariaRequired = `${this.required}`;
+        }
+      }
+      /**
+       * Will be used as 'or' check to the current required state.
+       * Can e.g. be used to read required state of a group.
+       */
+      isRequiredExternally() {
+        return false;
+      }
+    }, (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _set_required_decorators = [property({ reflect: true, type: Boolean })];
+      __esDecorate(_a, null, _set_required_decorators, { kind: "setter", name: "required", static: false, private: false, access: { has: (obj) => "required" in obj, set: (obj, value) => {
+        obj.required = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a;
+  })();
   return SbbRequiredElement;
 };
-var __defProp$3 = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass$3 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp$3(target, key, result);
-  return result;
-};
 const SbbFormAssociatedCheckboxMixin = (superClass) => {
-  let SbbFormAssociatedCheckboxElement = class extends SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(superClass))) {
-    constructor() {
-      super();
-      this._attributeMutationBlocked = false;
-      this._checked = false;
-      this._handleKeyboardInteraction = (event) => {
-        if (event.key === " ") {
-          this._handleUserInteraction();
+  let SbbFormAssociatedCheckboxElement = (() => {
+    var _a;
+    let _classDecorators = [hostAttributes({
+      tabindex: "0"
+    })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SbbDisabledMixin(SbbRequiredMixin(SbbFormAssociatedMixin(superClass)));
+    let _instanceExtraInitializers = [];
+    let _set_checked_decorators;
+    _a = class extends _classSuper {
+      /** Whether the checkbox is checked. */
+      set checked(value) {
+        const attributeSetter = typeof value === "object" ? value.attribute : false;
+        if (attributeSetter) {
+          value = value.value;
         }
-      };
-      this._handleUserInteraction = () => {
-        var _a;
-        if (this.disabled) {
-          return;
+        if (this.hasUpdated && !attributeSetter) {
+          this._attributeMutationBlocked = true;
         }
-        (_a = this.withUserInteraction) == null ? void 0 : _a.call(this);
-        this.checked = !this.checked;
-        this._attributeMutationBlocked = true;
-        this.dispatchEvent(new InputEvent("input", { composed: true, bubbles: true }));
-        this.dispatchEvent(new Event("change", { bubbles: true }));
-        this.dispatchEvent(new CustomEvent("didChange", { bubbles: true }));
-      };
-      this.internals.role = "checkbox";
-    }
-    set checked(value) {
-      const attributeSetter = typeof value === "object" ? value.attribute : false;
-      if (attributeSetter) {
-        value = value.value;
+        this._checked = Boolean(value);
+        this.updateFormValue();
       }
-      if (this.hasUpdated && !attributeSetter) {
-        this._attributeMutationBlocked = true;
+      get checked() {
+        return this._checked;
       }
-      this._checked = Boolean(value);
-      this.updateFormValue();
-    }
-    get checked() {
-      return this._checked;
-    }
-    connectedCallback() {
-      super.connectedCallback();
-      this.addEventListener("click", this._handleUserInteraction);
-      this.addEventListener("keydown", preventScrollOnSpacebarPress);
-      this.addEventListener("keyup", this._handleKeyboardInteraction);
-    }
-    disconnectedCallback() {
-      super.disconnectedCallback();
-      this.removeEventListener("click", this._handleUserInteraction);
-      this.removeEventListener("keydown", preventScrollOnSpacebarPress);
-      this.removeEventListener("keyup", this._handleKeyboardInteraction);
-    }
-    attributeChangedCallback(name, old, value) {
-      if (name !== "checked" || !this._attributeMutationBlocked) {
-        super.attributeChangedCallback(name, old, value);
+      constructor() {
+        super();
+        this._attributeMutationBlocked = (__runInitializers(this, _instanceExtraInitializers), false);
+        this._checked = false;
+        this._handleKeyboardInteraction = (event) => {
+          if (event.key === " ") {
+            this._handleUserInteraction();
+          }
+        };
+        this._handleUserInteraction = () => {
+          var _a2;
+          if (this.disabled) {
+            return;
+          }
+          (_a2 = this.withUserInteraction) == null ? void 0 : _a2.call(this);
+          this.checked = !this.checked;
+          this._attributeMutationBlocked = true;
+          this.dispatchEvent(new InputEvent("input", { composed: true, bubbles: true }));
+          this.dispatchEvent(new Event("change", { bubbles: true }));
+          this.dispatchEvent(new CustomEvent("didChange", { bubbles: true }));
+        };
+        this.internals.role = "checkbox";
       }
-    }
-    /**
-     * Is called whenever the form is being reset.
-     *
-     * @internal
-     */
-    formResetCallback() {
-      this.checked = this.hasAttribute("checked");
-      this._attributeMutationBlocked = false;
-    }
-    /**
-     *  Called when the browser is trying to restore element’s state to state in which case
-     *  reason is “restore”, or when the browser is trying to fulfill autofill on behalf of
-     *  user in which case reason is “autocomplete”.
-     *  In the case of “restore”, state is a string, File, or FormData object
-     *  previously set as the second argument to setFormValue.
-     *
-     * @internal
-     */
-    formStateRestoreCallback(state2, _reason) {
-      if (state2) {
-        this.checked = state2 === "true";
+      connectedCallback() {
+        super.connectedCallback();
+        this.addEventListener("click", this._handleUserInteraction);
+        this.addEventListener("keydown", preventScrollOnSpacebarPress);
+        this.addEventListener("keyup", this._handleKeyboardInteraction);
       }
-    }
-    updateFormValue() {
-      if (this.checked) {
-        this.internals.setFormValue(this.value, `${this.checked}`);
-      } else {
-        this.internals.setFormValue(null);
+      disconnectedCallback() {
+        super.disconnectedCallback();
+        this.removeEventListener("click", this._handleUserInteraction);
+        this.removeEventListener("keydown", preventScrollOnSpacebarPress);
+        this.removeEventListener("keyup", this._handleKeyboardInteraction);
       }
-    }
-  };
-  __decorateClass$3([
-    property({
-      type: Boolean,
-      converter: {
-        ...defaultConverter,
-        // We need to pass information to the setter so that we know it was called by attribute change.
-        fromAttribute: (value, type) => {
-          var _a, _b;
-          const result = (_b = (_a = defaultConverter).fromAttribute) == null ? void 0 : _b.call(_a, value, type);
-          return { value: result, attribute: true };
+      attributeChangedCallback(name, old, value) {
+        if (name !== "checked" || !this._attributeMutationBlocked) {
+          super.attributeChangedCallback(name, old, value);
         }
       }
-    })
-  ], SbbFormAssociatedCheckboxElement.prototype, "checked", 1);
-  SbbFormAssociatedCheckboxElement = __decorateClass$3([
-    hostAttributes({
-      tabindex: "0"
-    })
-  ], SbbFormAssociatedCheckboxElement);
+      /**
+       * Is called whenever the form is being reset.
+       *
+       * @internal
+       */
+      formResetCallback() {
+        this.checked = this.hasAttribute("checked");
+        this._attributeMutationBlocked = false;
+      }
+      /**
+       *  Called when the browser is trying to restore element’s state to state in which case
+       *  reason is “restore”, or when the browser is trying to fulfill autofill on behalf of
+       *  user in which case reason is “autocomplete”.
+       *  In the case of “restore”, state is a string, File, or FormData object
+       *  previously set as the second argument to setFormValue.
+       *
+       * @internal
+       */
+      formStateRestoreCallback(state2, _reason) {
+        if (state2) {
+          this.checked = state2 === "true";
+        }
+      }
+      updateFormValue() {
+        if (this.checked) {
+          this.internals.setFormValue(this.value, `${this.checked}`);
+        } else {
+          this.internals.setFormValue(null);
+        }
+      }
+    }, _classThis = _a, (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _set_checked_decorators = [property({
+        type: Boolean,
+        converter: {
+          ...defaultConverter,
+          // We need to pass information to the setter so that we know it was called by attribute change.
+          fromAttribute: (value, type) => {
+            var _a2, _b;
+            const result = (_b = (_a2 = defaultConverter).fromAttribute) == null ? void 0 : _b.call(_a2, value, type);
+            return { value: result, attribute: true };
+          }
+        }
+      })];
+      __esDecorate(_a, null, _set_checked_decorators, { kind: "setter", name: "checked", static: false, private: false, access: { has: (obj) => "checked" in obj, set: (obj, value) => {
+        obj.checked = value;
+      } }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    })(), _a;
+    return _classThis;
+  })();
   return SbbFormAssociatedCheckboxElement;
 };
 const SbbHydrationMixin = (base) => {
   class SbbHydrationMixinClass extends base {
+    /**
+     * Returns a Promise that resolves when the element has completed hydration.
+     * The Promise value is a boolean that is `true` if the element required hydration
+     * and `false` if not.
+     *
+     * @return A promise of a boolean that resolves to true once the hydration completed.
+     * @internal
+     */
+    get hydrationComplete() {
+      return this._hydrationComplete;
+    }
+    /** Returns whether hydration is required and not completed. */
+    get hydrationRequired() {
+      return this._hydrationRequired;
+    }
     constructor(...args) {
       var _a;
       super(...args);
-      this._hydrationComplete = new Promise(
-        (resolve) => this._resolveHydration = resolve
-      );
+      this._hydrationComplete = new Promise((resolve) => this._resolveHydration = resolve);
       this._hydrationRequired = !!this.shadowRoot;
       if (!this._hydrationRequired) {
         this._resolveHydration(false);
@@ -383,35 +453,16 @@ const SbbHydrationMixin = (base) => {
         const eventOptions = { capture: true };
         const slots = (_a = this.shadowRoot) == null ? void 0 : _a.querySelectorAll("slot");
         if (slots == null ? void 0 : slots.length) {
-          slots.forEach(
-            (slot) => slot.addEventListener("slotchange", suppressSlotchangeEvent, eventOptions)
-          );
-          this.hydrationComplete.then(
-            () => slots.forEach((slot) => {
-              slot.removeEventListener("slotchange", suppressSlotchangeEvent, eventOptions);
-              if (slot.assignedNodes().length) {
-                slot.dispatchEvent(new Event("slotchange", { bubbles: true }));
-              }
-            })
-          );
+          slots.forEach((slot) => slot.addEventListener("slotchange", suppressSlotchangeEvent, eventOptions));
+          this.hydrationComplete.then(() => slots.forEach((slot) => {
+            slot.removeEventListener("slotchange", suppressSlotchangeEvent, eventOptions);
+            if (slot.assignedNodes().length) {
+              slot.dispatchEvent(new Event("slotchange", { bubbles: true }));
+            }
+          }));
         }
       }
     }
-    /**
-     * Returns a Promise that resolves when the element has completed hydration.
-     * The Promise value is a boolean that is `true` if the element required hydration
-     * and `false` if not.
-     *
-     * @return A promise of a boolean that resolves to true once the hydration completed.
-     * @internal
-     */
-    get hydrationComplete() {
-      return this._hydrationComplete;
-    }
-    /** Returns whether hydration is required and not completed. */
-    get hydrationRequired() {
-      return this._hydrationRequired;
-    }
     update(changedProperties) {
       super.update(changedProperties);
       if (this._hydrationRequired) {
@@ -422,178 +473,225 @@ const SbbHydrationMixin = (base) => {
   }
   return SbbHydrationMixinClass;
 };
-var __defProp$2 = Object.defineProperty;
-var __decorateClass$2 = (decorators, target, key, kind) => {
-  var result = void 0;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(target, key, result) || result;
-  if (result) __defProp$2(target, key, result);
-  return result;
-};
 const SSR_CHILD_COUNT_ATTRIBUTE = "data-ssr-child-count";
 const SLOTNAME_PREFIX = "li";
 const SbbNamedSlotListMixin = (superClass) => {
-  class NamedSlotListElement extends SbbHydrationMixin(superClass) {
-    constructor() {
-      super(...arguments);
-      this.listChildren = [];
-      this._handleSlotchange = () => {
-        const listChildren = Array.from(this.children ?? []).filter(
-          (e) => this.listChildLocalNames.includes(e.localName)
-        );
-        if (listChildren.length === this.listChildren.length && this.listChildren.every((e, i) => listChildren[i] === e)) {
-          return;
-        }
-        this.listChildren.filter((c) => !listChildren.includes(c)).forEach((c) => c.removeAttribute("slot"));
-        this.listChildren = listChildren;
-        this.listChildren.forEach(
-          (c, index) => c.setAttribute("slot", `${SLOTNAME_PREFIX}-${index}`)
-        );
-        this.removeAttribute(SSR_CHILD_COUNT_ATTRIBUTE);
-      };
-    }
-    connectedCallback() {
-      var _a;
-      super.connectedCallback();
-      (_a = this.shadowRoot) == null ? void 0 : _a.addEventListener("slotchange", this._handleSlotchange, { passive: true });
-    }
-    disconnectedCallback() {
-      var _a;
-      super.disconnectedCallback();
-      (_a = this.shadowRoot) == null ? void 0 : _a.removeEventListener("slotchange", this._handleSlotchange);
-    }
-    /**
-     * Renders list and list slots for slotted children or a number of list slots
-     * corresponding to the `data-ssr-child-count` attribute value.
-     *
-     * This is a possible optimization for SSR, as in an SSR Lit environment
-     * other elements are not available, but might be available in the meta
-     * framework wrapper (like e.g. React). This allows to provide the number of
-     * children to be passed via the `data-ssr-child-count` attribute value.
-     */
-    renderList(attributes = {}, listItemAttributes = {}) {
-      const listSlotNames = this.listSlotEntries(listItemAttributes);
-      if (listSlotNames.length >= 2) {
-        return html`
+  let NamedSlotListElement = (() => {
+    var _listChildren_accessor_storage, _a;
+    let _classSuper = SbbHydrationMixin(superClass);
+    let _listChildren_decorators;
+    let _listChildren_initializers = [];
+    let _listChildren_extraInitializers = [];
+    return _a = class extends _classSuper {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _listChildren_accessor_storage);
+        __privateSet(this, _listChildren_accessor_storage, __runInitializers(this, _listChildren_initializers, []));
+        this._handleSlotchange = (__runInitializers(this, _listChildren_extraInitializers), () => {
+          const listChildren = Array.from(this.children ?? []).filter((e) => this.listChildLocalNames.includes(e.localName));
+          if (listChildren.length === this.listChildren.length && this.listChildren.every((e, i) => listChildren[i] === e)) {
+            return;
+          }
+          this.listChildren.filter((c) => !listChildren.includes(c)).forEach((c) => c.removeAttribute("slot"));
+          this.listChildren = listChildren;
+          this.listChildren.forEach((c, index) => c.setAttribute("slot", `${SLOTNAME_PREFIX}-${index}`));
+          this.removeAttribute(SSR_CHILD_COUNT_ATTRIBUTE);
+        });
+      }
+      /**
+       * A list of children with the defined tag names.
+       * This array is only updated if there is an actual change
+       * to the child elements.
+       */
+      get listChildren() {
+        return __privateGet(this, _listChildren_accessor_storage);
+      }
+      set listChildren(value) {
+        __privateSet(this, _listChildren_accessor_storage, value);
+      }
+      connectedCallback() {
+        var _a2;
+        super.connectedCallback();
+        (_a2 = this.shadowRoot) == null ? void 0 : _a2.addEventListener("slotchange", this._handleSlotchange, { passive: true });
+      }
+      disconnectedCallback() {
+        var _a2;
+        super.disconnectedCallback();
+        (_a2 = this.shadowRoot) == null ? void 0 : _a2.removeEventListener("slotchange", this._handleSlotchange);
+      }
+      /**
+       * Renders list and list slots for slotted children or a number of list slots
+       * corresponding to the `data-ssr-child-count` attribute value.
+       *
+       * This is a possible optimization for SSR, as in an SSR Lit environment
+       * other elements are not available, but might be available in the meta
+       * framework wrapper (like e.g. React). This allows to provide the number of
+       * children to be passed via the `data-ssr-child-count` attribute value.
+       */
+      renderList(attributes = {}, listItemAttributes = {}) {
+        const listSlotNames = this.listSlotEntries(listItemAttributes);
+        if (listSlotNames.length >= 2) {
+          return html`
           <ul
             class=${attributes.class || this.localName}
             aria-label=${attributes.ariaLabel || nothing}
             aria-labelledby=${attributes.ariaLabelledby || nothing}
           >
-            ${listSlotNames.map(
-          (slot) => html`
+            ${listSlotNames.map((slot) => html`
                 <li aria-hidden=${slot.ariaHidden || nothing}>
                   <slot name=${slot.name}></slot>
                 </li>
-              `
-        )}
+              `)}
           </ul>
           ${this.renderHiddenSlot()}
         `;
-      } else if (listSlotNames.length === 1) {
-        return html`<sbb-screen-reader-only>${attributes.ariaLabel}</sbb-screen-reader-only>
+        } else if (listSlotNames.length === 1) {
+          return html`<sbb-screen-reader-only>${attributes.ariaLabel}</sbb-screen-reader-only>
           <span class=${attributes.class || this.localName}>
             <span><slot name=${listSlotNames[0].name}></slot></span>
           </span>
           ${this.renderHiddenSlot()} `;
-      } else {
-        return this.renderHiddenSlot();
+        } else {
+          return this.renderHiddenSlot();
+        }
       }
-    }
-    /**
-     * Returns an array of SbbNamedSlotProperties, which holds the list slot names and the hidden property;
-     * its length corresponds to the number of matched children or the `data-ssr-child-count` attribute value.
-     *
-     * This is a possible optimization for SSR, as in an SSR Lit environment
-     * other elements are not available, but might be available in the meta
-     * framework wrapper (like e.g. React). This allows to provide the number of
-     * children to be passed via the `data-ssr-child-count` attribute value.
-     */
-    listSlotEntries(listItemAttributes) {
-      const listChildren = this.listChildren.length ? this.listChildren : Array.from({ length: +(this.getAttribute(SSR_CHILD_COUNT_ATTRIBUTE) ?? 0) });
-      return listChildren.map((e, i) => {
-        var _a;
-        return {
-          name: `${SLOTNAME_PREFIX}-${i}`,
-          ariaHidden: ((_a = listItemAttributes == null ? void 0 : listItemAttributes.localNameVisualOnly) == null ? void 0 : _a.includes(e.localName)) ?? false
-        };
-      });
-    }
-    /**
-     * Returns a hidden slot, which is intended as the children change detection.
-     * When an element without a slot attribute is slotted to the element, it triggers
-     * the slotchange event, which can be used to assign it to the appropriate named slot.
-     */
-    renderHiddenSlot() {
-      return html`<span hidden><slot></slot></span>`;
-    }
-  }
-  __decorateClass$2([
-    state()
-  ], NamedSlotListElement.prototype, "listChildren");
+      /**
+       * Returns an array of SbbNamedSlotProperties, which holds the list slot names and the hidden property;
+       * its length corresponds to the number of matched children or the `data-ssr-child-count` attribute value.
+       *
+       * This is a possible optimization for SSR, as in an SSR Lit environment
+       * other elements are not available, but might be available in the meta
+       * framework wrapper (like e.g. React). This allows to provide the number of
+       * children to be passed via the `data-ssr-child-count` attribute value.
+       */
+      listSlotEntries(listItemAttributes) {
+        const listChildren = this.listChildren.length ? this.listChildren : Array.from({ length: +(this.getAttribute(SSR_CHILD_COUNT_ATTRIBUTE) ?? 0) });
+        return listChildren.map((e, i) => {
+          var _a2;
+          return {
+            name: `${SLOTNAME_PREFIX}-${i}`,
+            ariaHidden: ((_a2 = listItemAttributes == null ? void 0 : listItemAttributes.localNameVisualOnly) == null ? void 0 : _a2.includes(e.localName)) ?? false
+          };
+        });
+      }
+      /**
+       * Returns a hidden slot, which is intended as the children change detection.
+       * When an element without a slot attribute is slotted to the element, it triggers
+       * the slotchange event, which can be used to assign it to the appropriate named slot.
+       */
+      renderHiddenSlot() {
+        return html`<span hidden><slot></slot></span>`;
+      }
+    }, _listChildren_accessor_storage = new WeakMap(), (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _listChildren_decorators = [state()];
+      __esDecorate(_a, null, _listChildren_decorators, { kind: "accessor", name: "listChildren", static: false, private: false, access: { has: (obj) => "listChildren" in obj, get: (obj) => obj.listChildren, set: (obj, value) => {
+        obj.listChildren = value;
+      } }, metadata: _metadata }, _listChildren_initializers, _listChildren_extraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a;
+  })();
   return NamedSlotListElement;
 };
-var __defProp$1 = Object.defineProperty;
-var __decorateClass$1 = (decorators, target, key, kind) => {
-  var result = void 0;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(target, key, result) || result;
-  if (result) __defProp$1(target, key, result);
-  return result;
-};
 const SbbNegativeMixin = (superClass) => {
-  class SbbNegativeElement extends superClass {
-    constructor() {
-      super(...arguments);
-      this.negative = false;
-    }
-  }
-  __decorateClass$1([
-    property({ reflect: true, type: Boolean })
-  ], SbbNegativeElement.prototype, "negative");
+  let SbbNegativeElement = (() => {
+    var _negative_accessor_storage, _a;
+    let _classSuper = superClass;
+    let _negative_decorators;
+    let _negative_initializers = [];
+    let _negative_extraInitializers = [];
+    return _a = class extends _classSuper {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _negative_accessor_storage, __runInitializers(this, _negative_initializers, false));
+        __runInitializers(this, _negative_extraInitializers);
+      }
+      /** Negative coloring variant flag. */
+      get negative() {
+        return __privateGet(this, _negative_accessor_storage);
+      }
+      set negative(value) {
+        __privateSet(this, _negative_accessor_storage, value);
+      }
+    }, _negative_accessor_storage = new WeakMap(), (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _negative_decorators = [forceType(), property({ reflect: true, type: Boolean })];
+      __esDecorate(_a, null, _negative_decorators, { kind: "accessor", name: "negative", static: false, private: false, access: { has: (obj) => "negative" in obj, get: (obj) => obj.negative, set: (obj, value) => {
+        obj.negative = value;
+      } }, metadata: _metadata }, _negative_initializers, _negative_extraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a;
+  })();
   return SbbNegativeElement;
 };
-var __defProp = Object.defineProperty;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = void 0;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(target, key, result) || result;
-  if (result) __defProp(target, key, result);
-  return result;
-};
 const SbbPanelMixin = (superClass) => {
-  var _a;
-  const _SbbPanelElement = (_a = class extends superClass {
-    constructor() {
-      super(...arguments);
-      this.color = "white";
-      this.borderless = false;
-      this._panelConnected = new EventEmitter(
-        this,
-        _a.events.panelConnected,
-        { bubbles: true }
-      );
-    }
-    connectedCallback() {
-      super.connectedCallback();
-      this._panelConnected.emit();
-    }
-  }, _a.events = {
-    panelConnected: "panelConnected"
-  }, _a);
-  __decorateClass([
-    property()
-  ], _SbbPanelElement.prototype, "color");
-  __decorateClass([
-    property({ reflect: true, type: Boolean })
-  ], _SbbPanelElement.prototype, "borderless");
-  __decorateClass([
-    property()
-  ], _SbbPanelElement.prototype, "expansionState");
-  let SbbPanelElement = _SbbPanelElement;
+  let SbbPanelElement = (() => {
+    var _color_accessor_storage, _borderless_accessor_storage, _expansionState_accessor_storage, _a;
+    let _classSuper = superClass;
+    let _color_decorators;
+    let _color_initializers = [];
+    let _color_extraInitializers = [];
+    let _borderless_decorators;
+    let _borderless_initializers = [];
+    let _borderless_extraInitializers = [];
+    let _expansionState_decorators;
+    let _expansionState_initializers = [];
+    let _expansionState_extraInitializers = [];
+    return _a = class extends _classSuper {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _color_accessor_storage);
+        __privateAdd(this, _borderless_accessor_storage);
+        __privateAdd(this, _expansionState_accessor_storage);
+        __privateSet(this, _color_accessor_storage, __runInitializers(this, _color_initializers, "white"));
+        __privateSet(this, _borderless_accessor_storage, (__runInitializers(this, _color_extraInitializers), __runInitializers(this, _borderless_initializers, false)));
+        __privateSet(this, _expansionState_accessor_storage, (__runInitializers(this, _borderless_extraInitializers), __runInitializers(this, _expansionState_initializers, "")));
+        this._panelConnected = (__runInitializers(this, _expansionState_extraInitializers), new EventEmitter(this, _a.events.panelConnected, { bubbles: true }));
+      }
+      /** The background color of the panel. */
+      get color() {
+        return __privateGet(this, _color_accessor_storage);
+      }
+      set color(value) {
+        __privateSet(this, _color_accessor_storage, value);
+      }
+      /** Whether the unselected panel has a border. */
+      get borderless() {
+        return __privateGet(this, _borderless_accessor_storage);
+      }
+      set borderless(value) {
+        __privateSet(this, _borderless_accessor_storage, value);
+      }
+      /** @internal used for accessibility label when in expansion panel */
+      get expansionState() {
+        return __privateGet(this, _expansionState_accessor_storage);
+      }
+      set expansionState(value) {
+        __privateSet(this, _expansionState_accessor_storage, value);
+      }
+      connectedCallback() {
+        super.connectedCallback();
+        this._panelConnected.emit();
+      }
+    }, _color_accessor_storage = new WeakMap(), _borderless_accessor_storage = new WeakMap(), _expansionState_accessor_storage = new WeakMap(), (() => {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _color_decorators = [property()];
+      _borderless_decorators = [forceType(), property({ reflect: true, type: Boolean })];
+      _expansionState_decorators = [forceType(), property()];
+      __esDecorate(_a, null, _color_decorators, { kind: "accessor", name: "color", static: false, private: false, access: { has: (obj) => "color" in obj, get: (obj) => obj.color, set: (obj, value) => {
+        obj.color = value;
+      } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
+      __esDecorate(_a, null, _borderless_decorators, { kind: "accessor", name: "borderless", static: false, private: false, access: { has: (obj) => "borderless" in obj, get: (obj) => obj.borderless, set: (obj, value) => {
+        obj.borderless = value;
+      } }, metadata: _metadata }, _borderless_initializers, _borderless_extraInitializers);
+      __esDecorate(_a, null, _expansionState_decorators, { kind: "accessor", name: "expansionState", static: false, private: false, access: { has: (obj) => "expansionState" in obj, get: (obj) => obj.expansionState, set: (obj, value) => {
+        obj.expansionState = value;
+      } }, metadata: _metadata }, _expansionState_initializers, _expansionState_extraInitializers);
+      if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })(), _a.events = {
+      panelConnected: "panelConnected"
+    }, _a;
+  })();
   return SbbPanelElement;
 };
 const SbbUpdateSchedulerMixin = (base) => {
@@ -737,4 +835,4 @@ export {
   SbbUpdateSchedulerMixin,
   panelCommon as panelCommonStyle
 };
-//# 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/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 type { AbstractConstructor } from './constructor.js';\n\nexport declare class SbbDisabledMixinType {\n  public set disabled(value: boolean);\n  public get disabled(): boolean;\n  protected isDisabledExternally(): boolean;\n}\n\nexport declare class SbbDisabledInteractiveMixinType {\n  public 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    @property({ reflect: true, type: Boolean })\n    public set disabled(value: boolean) {\n      // To provide the same behavior as the native disabled state,\n      // any value is converted to a boolean.\n      this._disabled = Boolean(value);\n    }\n    public get disabled(): boolean {\n      return this._disabled || this.isDisabledExternally();\n    }\n    private _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 disabled buttons should be interactive. */\n    @property({ attribute: 'disabled-interactive', type: Boolean }) public disabledInteractive =\n      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 = <T extends AbstractConstructor<LitElement>>(\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('disabled') && !changedProperties.has('disabledInteractive')) {\n        return;\n      }\n\n      if (!this.disabled || this.disabledInteractive) {\n        this.setAttribute('tabindex', '0');\n      } else {\n        this.removeAttribute('tabindex');\n      }\n\n      if (this.disabled) {\n        this.setAttribute('aria-disabled', 'true');\n      } else {\n        this.removeAttribute('aria-disabled');\n      }\n    }\n  }\n  return SbbDisabledTabIndexAction as AbstractConstructor<\n    SbbDisabledMixinType & SbbDisabledInteractiveMixinType\n  > &\n    T;\n};\n\n/**\n * Extends `SbbDisabledMixin` with the `aria-disabled` attribute.\n * For a11y purposes, keeps the element focusable even when disabled.\n * @deprecated Will be removed with next major version\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFocusableDisabledActionMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbDisabledMixinType> & T => {\n  abstract class SbbFocusableDisabledAction\n    extends SbbDisabledMixin(superClass)\n    implements SbbDisabledMixinType\n  {\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (!changedProperties.has('disabled')) {\n        return;\n      }\n\n      if (this.disabled) {\n        this.setAttribute('aria-disabled', 'true');\n      } else {\n        this.removeAttribute('aria-disabled');\n      }\n    }\n  }\n  return SbbFocusableDisabledAction as AbstractConstructor<SbbDisabledMixinType> & T;\n};\n","import type { LitElement } from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\nexport declare abstract class SbbFormAssociatedMixinType<V = string> {\n  public get form(): HTMLFormElement | null;\n  public get name(): string;\n  public set name(value: string);\n  public get type(): string;\n  public get value(): V | null;\n  public set value(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\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}\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 the internals of the target 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 internals target element.\n     *\n     * @internal\n     */\n    public get validity(): ValidityState {\n      return this.internals.validity;\n    }\n\n    /**\n     * Returns the error message that would be shown to the user\n     * if internals target element was to be checked for validity.\n     *\n     * @internal\n     */\n    public get validationMessage(): string {\n      return this.internals.validationMessage;\n    }\n\n    /**\n     * Returns true if internals target element will be validated\n     * when the form is submitted; false otherwise.\n     *\n     * @internal\n     */\n    public get willValidate(): boolean {\n      return this.internals.willValidate;\n    }\n\n    /** @internal */\n    protected readonly internals: ElementInternals = this.attachInternals();\n\n    /** Whenever a surrounding form or fieldset is changing its disabled state. */\n    @state() protected formDisabled: boolean = false;\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 internals target element has no validity problems; false otherwise.\n     * Fires an invalid event at the element in the latter case.\n     *\n     * @internal\n     */\n    public checkValidity(): boolean {\n      return this.internals.checkValidity();\n    }\n\n    /**\n     * Returns true if internals target 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     * @internal\n     */\n    public reportValidity(): boolean {\n      return this.internals.reportValidity();\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    /**\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  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 set required(value: boolean);\n  public get 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 async willUpdate(changedProperties: PropertyValues<this>): Promise<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 { hostAttributes } from '../decorators.js';\nimport { preventScrollOnSpacebarPress } from '../eventing.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\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\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 = false;\n\n    protected constructor() {\n      super();\n      /** @internal */\n      this.internals.role = 'checkbox';\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n\n      this.addEventListener('click', this._handleUserInteraction);\n      this.addEventListener('keydown', preventScrollOnSpacebarPress);\n      this.addEventListener('keyup', this._handleKeyboardInteraction);\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n\n      this.removeEventListener('click', this._handleUserInteraction);\n      this.removeEventListener('keydown', preventScrollOnSpacebarPress);\n      this.removeEventListener('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    /** 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      this.dispatchEvent(new CustomEvent('didChange', { bubbles: true }));\n    };\n  }\n\n  return SbbFormAssociatedCheckboxElement as unknown as Constructor<SbbFormAssociatedCheckboxMixinType> &\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  @state() protected 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 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 type { AbstractConstructor } from './constructor.js';\n\nexport declare class SbbNegativeMixinType {\n  public 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    @property({ reflect: true, type: Boolean }) public 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 { EventEmitter } from '../eventing.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\nexport declare class SbbPanelMixinType {\n  public color: 'white' | 'milk';\n  public borderless: boolean;\n  public 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() public color: 'white' | 'milk' = 'white';\n\n    /** Whether the unselected panel has a border. */\n    @property({ reflect: true, type: Boolean }) public borderless = false;\n\n    /** @internal used for accessibility label when in expansion panel */\n    @property() public 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  }\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":["__decorateClass","state"],"mappings":"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"}
+//# 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/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';\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, v) => 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 disabled buttons should be interactive. */\n    @forceType()\n    @property({ attribute: 'disabled-interactive', type: Boolean })\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 = <T extends AbstractConstructor<LitElement>>(\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('disabled') && !changedProperties.has('disabledInteractive')) {\n        return;\n      }\n\n      if (!this.disabled || this.disabledInteractive) {\n        this.setAttribute('tabindex', '0');\n      } else {\n        this.removeAttribute('tabindex');\n      }\n\n      if (this.disabled) {\n        this.setAttribute('aria-disabled', 'true');\n      } else {\n        this.removeAttribute('aria-disabled');\n      }\n    }\n  }\n  return SbbDisabledTabIndexAction as AbstractConstructor<\n    SbbDisabledMixinType & SbbDisabledInteractiveMixinType\n  > &\n    T;\n};\n\n/**\n * Extends `SbbDisabledMixin` with the `aria-disabled` attribute.\n * For a11y purposes, keeps the element focusable even when disabled.\n * @deprecated Will be removed with next major version\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const SbbFocusableDisabledActionMixin = <T extends AbstractConstructor<LitElement>>(\n  superClass: T,\n): AbstractConstructor<SbbDisabledMixinType> & T => {\n  abstract class SbbFocusableDisabledAction\n    extends SbbDisabledMixin(superClass)\n    implements SbbDisabledMixinType\n  {\n    protected override willUpdate(changedProperties: PropertyValues<this>): void {\n      super.willUpdate(changedProperties);\n\n      if (!changedProperties.has('disabled')) {\n        return;\n      }\n\n      if (this.disabled) {\n        this.setAttribute('aria-disabled', 'true');\n      } else {\n        this.removeAttribute('aria-disabled');\n      }\n    }\n  }\n  return SbbFocusableDisabledAction as AbstractConstructor<SbbDisabledMixinType> & T;\n};\n","import type { LitElement } from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport type { AbstractConstructor } from './constructor.js';\n\nexport declare abstract class SbbFormAssociatedMixinType<V = string> {\n  public get form(): HTMLFormElement | null;\n  public get name(): string;\n  public set name(value: string);\n  public get type(): string;\n  public get value(): V | null;\n  public set value(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\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}\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 the internals of the target 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 internals target element.\n     *\n     * @internal\n     */\n    public get validity(): ValidityState {\n      return this.internals.validity;\n    }\n\n    /**\n     * Returns the error message that would be shown to the user\n     * if internals target element was to be checked for validity.\n     *\n     * @internal\n     */\n    public get validationMessage(): string {\n      return this.internals.validationMessage;\n    }\n\n    /**\n     * Returns true if internals target element will be validated\n     * when the form is submitted; false otherwise.\n     *\n     * @internal\n     */\n    public get willValidate(): boolean {\n      return this.internals.willValidate;\n    }\n\n    /** @internal */\n    protected readonly internals: ElementInternals = this.attachInternals();\n\n    /** Whenever a surrounding form or fieldset is changing its disabled state. */\n    @state() protected accessor formDisabled: boolean = false;\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 internals target element has no validity problems; false otherwise.\n     * Fires an invalid event at the element in the latter case.\n     *\n     * @internal\n     */\n    public checkValidity(): boolean {\n      return this.internals.checkValidity();\n    }\n\n    /**\n     * Returns true if internals target 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     * @internal\n     */\n    public reportValidity(): boolean {\n      return this.internals.reportValidity();\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    /**\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  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 async willUpdate(changedProperties: PropertyValues<this>): Promise<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 { hostAttributes } from '../decorators.js';\nimport { preventScrollOnSpacebarPress } from '../eventing.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\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\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    protected constructor() {\n      super();\n      /** @internal */\n      this.internals.role = 'checkbox';\n    }\n\n    public override connectedCallback(): void {\n      super.connectedCallback();\n\n      this.addEventListener('click', this._handleUserInteraction);\n      this.addEventListener('keydown', preventScrollOnSpacebarPress);\n      this.addEventListener('keyup', this._handleKeyboardInteraction);\n    }\n\n    public override disconnectedCallback(): void {\n      super.disconnectedCallback();\n\n      this.removeEventListener('click', this._handleUserInteraction);\n      this.removeEventListener('keydown', preventScrollOnSpacebarPress);\n      this.removeEventListener('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    /** 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      this.dispatchEvent(new CustomEvent('didChange', { bubbles: true }));\n    };\n  }\n\n  return SbbFormAssociatedCheckboxElement as unknown as Constructor<SbbFormAssociatedCheckboxMixinType> &\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() 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  }\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","SbbPanelElement"],"mappings":"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"}