@sbb-esta/lyne-elements 4.6.0 → 4.8.0

package/development/core/base-elements/action-base-element.js

@@ -1,44 +1,39 @@
-import { LitElement, html } from "lit";
-import { SbbElementInternalsMixin } from "../mixins.js";
-class SbbActionBaseElement extends SbbElementInternalsMixin(LitElement) {
-  get maybeDisabled() {
-    const maybeDisabled = this;
-    return maybeDisabled.disabled || maybeDisabled.formDisabled;
-  }
-  get maybeDisabledInteractive() {
-    return this.disabledInteractive;
-  }
-  constructor() {
-    super();
-    this.internals.states.add("action");
-  }
-  connectedCallback() {
-    super.connectedCallback();
-  }
-  setupBaseEventHandlers() {
-    this.addEventListener(
-      "click",
-      (event) => {
-        if (this.maybeDisabled && !this.maybeDisabledInteractive) {
-          event.preventDefault();
-          event.stopImmediatePropagation();
-        }
-      },
-      // capture is necessary here, as this event handler needs to be executed before any other
-      // in order to stop immediate propagation in the disabled case.
-      { capture: true }
-    );
-  }
-  /** Override this method to render the component template. */
-  renderTemplate() {
-    throw new Error("Implementation needed!");
-  }
-  /** Default render method for button-like components. */
-  render() {
-    return html`<span class="sbb-action-base ${this.localName}">${this.renderTemplate()}</span>`;
-  }
-}
-export {
-  SbbActionBaseElement
+import { SbbElement } from "./element.js";
+import { html } from "lit";
+//#region src/elements/core/base-elements/action-base-element.ts
+var SbbActionBaseElement = class extends SbbElement {
+	get maybeDisabled() {
+		const maybeDisabled = this;
+		return maybeDisabled.disabled || maybeDisabled.formDisabled;
+	}
+	get maybeDisabledInteractive() {
+		return this.disabledInteractive;
+	}
+	constructor() {
+		super();
+		this.internals.states.add("action");
+	}
+	connectedCallback() {
+		super.connectedCallback();
+	}
+	setupBaseEventHandlers() {
+		this.addEventListener("click", (event) => {
+			if (this.maybeDisabled && !this.maybeDisabledInteractive) {
+				event.preventDefault();
+				event.stopImmediatePropagation();
+			}
+		}, { capture: true });
+	}
+	/** Override this method to render the component template. */
+	renderTemplate() {
+		throw new Error("Implementation needed!");
+	}
+	/** Default render method for button-like components. */
+	render() {
+		return html`<span class="sbb-action-base ${this.localName}">${this.renderTemplate()}</span>`;
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//#endregion
+export { SbbActionBaseElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLWJhc2UtZWxlbWVudC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY29yZS9iYXNlLWVsZW1lbnRzL2FjdGlvbi1iYXNlLWVsZW1lbnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaHRtbCwgdHlwZSBUZW1wbGF0ZVJlc3VsdCB9IGZyb20gJ2xpdCc7XG5cbmltcG9ydCB7IFNiYkVsZW1lbnQgfSBmcm9tICcuL2VsZW1lbnQudHMnO1xuXG4vKipcbiAqIFdoZW5ldmVyIGFuIGVsZW1lbnQgY2FuIGJlIGRpc2FibGVkIGl0IGhhcyBkaXNhYmxlZCBwcm9wZXJ0eVxuICogb3IgZm9ybURpc2FibGVkIGlmIGl0J3MgYSBmb3JtIGVsZW1lbnQuXG4gKiBCZWNhdXNlIHdlIGNhbid0IHVzZSB0eXBlcyBoZXJlIGRpcmVjdGx5IHdlIGNyZWF0ZWQgdGhpcyBoZWxwZXIgdHlwZS5cbiAqL1xuaW50ZXJmYWNlIE1heWJlRGlzYWJsZWQge1xuICBkaXNhYmxlZD86IGJvb2xlYW47XG4gIGZvcm1EaXNhYmxlZD86IGJvb2xlYW47XG4gIGRpc2FibGVkSW50ZXJhY3RpdmU/OiBib29sZWFuO1xufVxuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgU2JiQWN0aW9uQmFzZUVsZW1lbnQgZXh0ZW5kcyBTYmJFbGVtZW50IHtcbiAgcHJvdGVjdGVkIGdldCBtYXliZURpc2FibGVkKCk6IGJvb2xlYW4gfCB1bmRlZmluZWQge1xuICAgIGNvbnN0IG1heWJlRGlzYWJsZWQgPSB0aGlzIGFzIE1heWJlRGlzYWJsZWQ7XG4gICAgcmV0dXJuIG1heWJlRGlzYWJsZWQuZGlzYWJsZWQgfHwgbWF5YmVEaXNhYmxlZC5mb3JtRGlzYWJsZWQ7XG4gIH1cblxuICBwcm90ZWN0ZWQgZ2V0IG1heWJlRGlzYWJsZWRJbnRlcmFjdGl2ZSgpOiBib29sZWFuIHwgdW5kZWZpbmVkIHtcbiAgICByZXR1cm4gKHRoaXMgYXMgTWF5YmVEaXNhYmxlZCkuZGlzYWJsZWRJbnRlcmFjdGl2ZTtcbiAgfVxuXG4gIHB1YmxpYyBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcigpO1xuICAgIHRoaXMuaW50ZXJuYWxzLnN0YXRlcy5hZGQoJ2FjdGlvbicpO1xuICB9XG5cbiAgcHVibGljIG92ZXJyaWRlIGNvbm5lY3RlZENhbGxiYWNrKCk6IHZvaWQge1xuICAgIHN1cGVyLmNvbm5lY3RlZENhbGxiYWNrKCk7XG5cbiAgICBpZiAoXG4gICAgICBpbXBvcnQubWV0YS5lbnYuREVWICYmXG4gICAgICAodGhpcy5tYXRjaGVzKCc6c3RhdGUobGluayknKSB8fCB0aGlzLm1hdGNoZXMoJzpzdGF0ZShidXR0b24pJykpICYmXG4gICAgICB0aGlzLnBhcmVudEVsZW1lbnQ/LmNsb3Nlc3QoJzpzdGF0ZShsaW5rKSwgOnN0YXRlKGJ1dHRvbiksIGEsIGJ1dHRvbicpXG4gICAgKSB7XG4gICAgICBjb25zb2xlLndhcm4oXG4gICAgICAgIGBOZXN0ZWQgYWN0aW9uIGVsZW1lbnQgZGV0ZWN0ZWQgKCR7dGhpcy5sb2NhbE5hbWV9IGluc2lkZSAke3RoaXMucGFyZW50RWxlbWVudCEuY2xvc2VzdCgnOnN0YXRlKGxpbmspLCA6c3RhdGUoYnV0dG9uKSwgYSwgYnV0dG9uJykhLmxvY2FsTmFtZX0pLiBNYXliZSB1c2UgYSBzdGF0aWMgdmFyaWFudCBmb3IgdGhlIGlubmVyIGFjdGlvbiBlbGVtZW50P2AsXG4gICAgICAgIHRoaXMsXG4gICAgICApO1xuICAgIH1cbiAgfVxuXG4gIHByb3RlY3RlZCBzZXR1cEJhc2VFdmVudEhhbmRsZXJzKCk6IHZvaWQge1xuICAgIHRoaXMuYWRkRXZlbnRMaXN0ZW5lcihcbiAgICAgICdjbGljaycsXG4gICAgICAoZXZlbnQpID0+IHtcbiAgICAgICAgaWYgKHRoaXMubWF5YmVEaXNhYmxlZCAmJiAhdGhpcy5tYXliZURpc2FibGVkSW50ZXJhY3RpdmUpIHtcbiAgICAgICAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpO1xuICAgICAgICAgIGV2ZW50LnN0b3BJbW1lZGlhdGVQcm9wYWdhdGlvbigpO1xuICAgICAgICB9XG4gICAgICB9LFxuICAgICAgLy8gY2FwdHVyZSBpcyBuZWNlc3NhcnkgaGVyZSwgYXMgdGhpcyBldmVudCBoYW5kbGVyIG5lZWRzIHRvIGJlIGV4ZWN1dGVkIGJlZm9yZSBhbnkgb3RoZXJcbiAgICAgIC8vIGluIG9yZGVyIHRvIHN0b3AgaW1tZWRpYXRlIHByb3BhZ2F0aW9uIGluIHRoZSBkaXNhYmxlZCBjYXNlLlxuICAgICAgeyBjYXB0dXJlOiB0cnVlIH0sXG4gICAgKTtcbiAgfVxuXG4gIC8qKiBPdmVycmlkZSB0aGlzIG1ldGhvZCB0byByZW5kZXIgdGhlIGNvbXBvbmVudCB0ZW1wbGF0ZS4gKi9cbiAgcHJvdGVjdGVkIHJlbmRlclRlbXBsYXRlKCk6IFRlbXBsYXRlUmVzdWx0IHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ0ltcGxlbWVudGF0aW9uIG5lZWRlZCEnKTtcbiAgfVxuXG4gIC8qKiBEZWZhdWx0IHJlbmRlciBtZXRob2QgZm9yIGJ1dHRvbi1saWtlIGNvbXBvbmVudHMuICovXG4gIHByb3RlY3RlZCBvdmVycmlkZSByZW5kZXIoKTogVGVtcGxhdGVSZXN1bHQge1xuICAgIHJldHVybiBodG1sYDxzcGFuIGNsYXNzPVwic2JiLWFjdGlvbi1iYXNlICR7dGhpcy5sb2NhbE5hbWV9XCI+JHt0aGlzLnJlbmRlclRlbXBsYXRlKCl9PC9zcGFuPmA7XG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7O0FBZUEsSUFBc0IsdUJBQXRCLGNBQW1ELFdBQVU7Q0FDM0QsSUFBYyxnQkFBYTtFQUN6QixNQUFNLGdCQUFnQjtBQUN0QixTQUFPLGNBQWMsWUFBWSxjQUFjOztDQUdqRCxJQUFjLDJCQUF3QjtBQUNwQyxTQUFRLEtBQXVCOztDQUdqQyxjQUFBO0FBQ0UsU0FBTztBQUNQLE9BQUssVUFBVSxPQUFPLElBQUksU0FBUzs7Q0FHckIsb0JBQWlCO0FBQy9CLFFBQU0sbUJBQW1COztDQWNqQix5QkFBc0I7QUFDOUIsT0FBSyxpQkFDSCxVQUNDLFVBQVM7QUFDUixPQUFJLEtBQUssaUJBQWlCLENBQUMsS0FBSywwQkFBMEI7QUFDeEQsVUFBTSxnQkFBZ0I7QUFDdEIsVUFBTSwwQkFBMEI7O0tBS3BDLEVBQUUsU0FBUyxNQUFNLENBQ2xCOzs7Q0FJTyxpQkFBYztBQUN0QixRQUFNLElBQUksTUFBTSx5QkFBeUI7OztDQUl4QixTQUFNO0FBQ3ZCLFNBQU8sSUFBSSxnQ0FBZ0MsS0FBSyxVQUFTLElBQUssS0FBSyxnQkFBZ0IsQ0FBQSJ9

package/development/core/base-elements/button-base-element.js

@@ -1,212 +1,254 @@
-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 { SbbActionBaseElement } from "./action-base-element.js";
 import { __esDecorate, __runInitializers } from "tslib";
 import { isServer } from "lit";
 import { property } from "lit/decorators.js";
-import { hostAttributes, forceType } from "../decorators.js";
+import { forceType, hostAttributes } from "../decorators.js";
 import { isEventPrevented } from "../eventing.js";
 import { SbbFormAssociatedMixin } from "../mixins.js";
-import { SbbActionBaseElement } from "./action-base-element.js";
-let SbbButtonLikeBaseElement = (() => {
-  var _a;
-  let _classDecorators = [hostAttributes({
-    tabindex: "0"
-  })];
-  let _classDescriptor;
-  let _classExtraInitializers = [];
-  let _classThis;
-  let _classSuper = SbbFormAssociatedMixin(SbbActionBaseElement);
-  _a = class extends _classSuper {
-    constructor() {
-      super();
-      this._preventScrollOnSpaceKeydown = (event) => {
-        if (event.key === " ") {
-          event.preventDefault();
-          this.internals.states.add("active");
-        }
-      };
-      this._removeActiveMarker = () => {
-        this.internals.states.delete("active");
-      };
-      this._dispatchClickEventOnSpaceKeyup = (event) => {
-        if (event.key === " ") {
-          this._removeActiveMarker();
-          this._dispatchClickEvent(event);
-        }
-      };
-      this._dispatchClickEvent = (event) => {
-        const { altKey, ctrlKey, metaKey, shiftKey } = event;
-        event.target.dispatchEvent(new PointerEvent("click", {
-          bubbles: true,
-          cancelable: true,
-          composed: true,
-          pointerId: -1,
-          pointerType: "",
-          altKey,
-          ctrlKey,
-          metaKey,
-          shiftKey
-        }));
-      };
-      this.internals.states.add("button");
-      if (!isServer) {
-        this.setupBaseEventHandlers();
-        const passiveOptions = { passive: true };
-        this.addEventListener("keydown", this._preventScrollOnSpaceKeydown);
-        this.addEventListener("keyup", this._dispatchClickEventOnSpaceKeyup, passiveOptions);
-        this.addEventListener("blur", this._removeActiveMarker, passiveOptions);
-        this.addEventListener("keypress", (event) => {
-          if (event.key === "Enter" || event.key === "\n") {
-            this._dispatchClickEvent(event);
-          }
-        }, passiveOptions);
-      }
-    }
-    attributeChangedCallback(name, old, value) {
-      if (!["name", "value"].includes(name) || old !== value) {
-        super.attributeChangedCallback(name, old, value);
-      }
-    }
-  }, _classThis = _a, (() => {
-    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-    __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 });
-  })(), _a.role = "button", __runInitializers(_classThis, _classExtraInitializers), _a;
-  return _classThis;
+//#region src/elements/core/base-elements/button-base-element.ts
+/** Button base class. */
+var SbbButtonLikeBaseElement = (() => {
+	let _classDecorators = [hostAttributes({ tabindex: "0" })];
+	let _classDescriptor;
+	let _classExtraInitializers = [];
+	let _classThis;
+	let _classSuper = SbbFormAssociatedMixin(SbbActionBaseElement);
+	var SbbButtonLikeBaseElement = class extends _classSuper {
+		static {
+			_classThis = this;
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, {
+				kind: "class",
+				name: _classThis.name,
+				metadata: _metadata
+			}, null, _classExtraInitializers);
+			SbbButtonLikeBaseElement = _classThis = _classDescriptor.value;
+			if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.role = "button";
+		}
+		constructor() {
+			super();
+			/**
+			* Prevents scrolling from pressing Space, when the event target is an action element.
+			* Also sets active state.
+			* @param event The origin event.
+			*/
+			this._preventScrollOnSpaceKeydown = (event) => {
+				if (event.key === " ") {
+					event.preventDefault();
+					this.internals.states.add("active");
+				}
+			};
+			this._removeActiveMarker = () => {
+				this.internals.states.delete("active");
+			};
+			/**
+			* Dispatches a 'click' PointerEvent if the original keyboard event is a 'Space' press.
+			* As verified with the native button, when 'Space' is pressed, a 'click' event is dispatched
+			* after the 'keyup' event.
+			* @param event The origin event.
+			*/
+			this._dispatchClickEventOnSpaceKeyup = (event) => {
+				if (event.key === " ") {
+					this._removeActiveMarker();
+					this._dispatchClickEvent(event);
+				}
+			};
+			this._dispatchClickEvent = (event) => {
+				const { altKey, ctrlKey, metaKey, shiftKey } = event;
+				event.target.dispatchEvent(new PointerEvent("click", {
+					bubbles: true,
+					cancelable: true,
+					composed: true,
+					pointerId: -1,
+					pointerType: "",
+					altKey,
+					ctrlKey,
+					metaKey,
+					shiftKey
+				}));
+			};
+			this.internals.states.add("button");
+			if (!isServer) {
+				this.setupBaseEventHandlers();
+				const passiveOptions = { passive: true };
+				this.addEventListener("keydown", this._preventScrollOnSpaceKeydown);
+				this.addEventListener("keyup", this._dispatchClickEventOnSpaceKeyup, passiveOptions);
+				this.addEventListener("blur", this._removeActiveMarker, passiveOptions);
+				this.addEventListener("keypress", (event) => {
+					if (event.key === "Enter" || event.key === "\n") this._dispatchClickEvent(event);
+				}, passiveOptions);
+			}
+		}
+		attributeChangedCallback(name, old, value) {
+			if (!["name", "value"].includes(name) || old !== value) super.attributeChangedCallback(name, old, value);
+		}
+		static {
+			__runInitializers(_classThis, _classExtraInitializers);
+		}
+	};
+	return _classThis;
 })();
-let SbbButtonBaseElement = (() => {
-  var _value_accessor_storage, _a;
-  let _classSuper = SbbButtonLikeBaseElement;
-  let _instanceExtraInitializers = [];
-  let _value_decorators;
-  let _value_initializers = [];
-  let _value_extraInitializers = [];
-  let _set_type_decorators;
-  let _set_form_decorators;
-  return _a = class extends _classSuper {
-    constructor() {
-      super();
-      __privateAdd(this, _value_accessor_storage);
-      this._elementsOnWhichEnterPressTriggersSubmit = (__runInitializers(this, _instanceExtraInitializers), [
-        "input",
-        "sbb-date-input",
-        "sbb-time-input"
-      ]);
-      __privateSet(this, _value_accessor_storage, __runInitializers(this, _value_initializers, ""));
-      this._formId = (__runInitializers(this, _value_extraInitializers), "");
-      this._handleButtonClick = async (event) => {
-        if (this.type === "button" || await isEventPrevented(event)) {
-          return;
-        }
-        const form = this.form;
-        if (!form) {
-          return;
-        } else if (this.type === "submit") {
-          this._requestSubmit(form);
-        } else if (this.type === "reset") {
-          form.reset();
-        }
-      };
-      this._formKeyDown = (event) => {
-        const form = this.form;
-        if (this.type === "submit" && form && (event.key === "Enter" || event.key === "\n") && this._elementsOnWhichEnterPressTriggersSubmit.includes(event.target?.localName) && event.isTrusted) {
-          event.stopImmediatePropagation();
-          event.preventDefault();
-          const eventOrigin = event.composedPath()[0];
-          if (eventOrigin.dispatchEvent(new KeyboardEvent(event.type, event)) && !this.matches(":disabled")) {
-            this._requestSubmit(form);
-          }
-        }
-      };
-      this.addEventListener("click", this._handleButtonClick);
-    }
-    /** Value of the form element. */
-    get value() {
-      return __privateGet(this, _value_accessor_storage);
-    }
-    set value(value) {
-      __privateSet(this, _value_accessor_storage, value);
-    }
-    /**
-     * The type attribute to use for the button.
-     * @default 'button'
-     */
-    set type(name) {
-      this.setAttribute("type", `${name}`);
-    }
-    get type() {
-      return this.getAttribute("type") ?? "button";
-    }
-    /** The `<form>` element to associate the button with. */
-    set form(value) {
-      this._formId = value;
-      this.form?.addEventListener("keydown", this._formKeyDown, { capture: true });
-    }
-    get form() {
-      return this._formId ? this.getRootNode?.()?.getElementById?.(this._formId) ?? null : this.internals.form;
-    }
-    connectedCallback() {
-      super.connectedCallback();
-      this.form?.addEventListener("keydown", this._formKeyDown, { capture: true });
-    }
-    disconnectedCallback() {
-      super.disconnectedCallback();
-      this.form?.removeEventListener("keydown", this._formKeyDown, { capture: true });
-    }
-    _requestSubmit(form) {
-      const submitButtonClone = document.createElement("button");
-      submitButtonClone.inert = true;
-      submitButtonClone.hidden = true;
-      submitButtonClone.name = this.name;
-      submitButtonClone.value = this.value ?? "";
-      form.append(submitButtonClone);
-      form.requestSubmit(submitButtonClone);
-      submitButtonClone.remove();
-    }
-    /**
-     * Intentionally empty, as buttons are not targeted by form reset
-     * @internal
-     */
-    formResetCallback() {
-    }
-    /**
-     * Intentionally empty, as buttons are not targeted by form restore
-     * @internal
-     */
-    formStateRestoreCallback(_state, _reason) {
-    }
-    /**
-     * Intentionally empty, as button does not write its data in form.
-     * The data is only applied on submit button click as submitter of requestSubmit();
-     * @internal
-     */
-    updateFormValue() {
-    }
-  }, _value_accessor_storage = new WeakMap(), (() => {
-    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-    _value_decorators = [forceType(), property()];
-    _set_type_decorators = [property()];
-    _set_form_decorators = [property()];
-    __esDecorate(_a, null, _value_decorators, { kind: "accessor", name: "value", static: false, private: false, access: { has: (obj) => "value" in obj, get: (obj) => obj.value, set: (obj, value) => {
-      obj.value = value;
-    } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
-    __esDecorate(_a, null, _set_type_decorators, { kind: "setter", name: "type", static: false, private: false, access: { has: (obj) => "type" in obj, set: (obj, value) => {
-      obj.type = value;
-    } }, metadata: _metadata }, null, _instanceExtraInitializers);
-    __esDecorate(_a, null, _set_form_decorators, { kind: "setter", name: "form", static: false, private: false, access: { has: (obj) => "form" in obj, set: (obj, value) => {
-      obj.form = value;
-    } }, metadata: _metadata }, null, _instanceExtraInitializers);
-    if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-  })(), _a;
+/** Button base class. */
+var SbbButtonBaseElement = (() => {
+	let _classSuper = SbbButtonLikeBaseElement;
+	let _instanceExtraInitializers = [];
+	let _value_decorators;
+	let _value_initializers = [];
+	let _value_extraInitializers = [];
+	let _set_type_decorators;
+	let _set_form_decorators;
+	return class SbbButtonBaseElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_value_decorators = [forceType(), property()];
+			_set_type_decorators = [property()];
+			_set_form_decorators = [property()];
+			__esDecorate(this, null, _value_decorators, {
+				kind: "accessor",
+				name: "value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "value" in obj,
+					get: (obj) => obj.value,
+					set: (obj, value) => {
+						obj.value = value;
+					}
+				},
+				metadata: _metadata
+			}, _value_initializers, _value_extraInitializers);
+			__esDecorate(this, null, _set_type_decorators, {
+				kind: "setter",
+				name: "type",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "type" in obj,
+					set: (obj, value) => {
+						obj.type = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_form_decorators, {
+				kind: "setter",
+				name: "form",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "form" in obj,
+					set: (obj, value) => {
+						obj.form = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		#value_accessor_storage;
+		/** Value of the form element. */
+		get value() {
+			return this.#value_accessor_storage;
+		}
+		set value(value) {
+			this.#value_accessor_storage = value;
+		}
+		/**
+		* The type attribute to use for the button.
+		* @default 'button'
+		*/
+		set type(name) {
+			this.setAttribute("type", `${name}`);
+		}
+		get type() {
+			return this.getAttribute("type") ?? "button";
+		}
+		/** The `<form>` element to associate the button with. */
+		set form(value) {
+			this._formId = value;
+			this.form?.addEventListener("keydown", this._formKeyDown, { capture: true });
+		}
+		get form() {
+			return this._formId ? this.getRootNode?.()?.getElementById?.(this._formId) ?? null : this.internals.form;
+		}
+		constructor() {
+			super();
+			this._elementsOnWhichEnterPressTriggersSubmit = (__runInitializers(this, _instanceExtraInitializers), [
+				"input",
+				"sbb-date-input",
+				"sbb-time-input"
+			]);
+			this.#value_accessor_storage = __runInitializers(this, _value_initializers, "");
+			this._formId = (__runInitializers(this, _value_extraInitializers), "");
+			this._handleButtonClick = async (event) => {
+				if (this.type === "button" || await isEventPrevented(event)) return;
+				const form = this.form;
+				if (!form) return;
+				else if (this.type === "submit") this._requestSubmit(form);
+				else if (this.type === "reset") form.reset();
+			};
+			this._formKeyDown = (event) => {
+				const form = this.form;
+				if (this.type === "submit" && form && (event.key === "Enter" || event.key === "\n") && this._elementsOnWhichEnterPressTriggersSubmit.includes(event.target?.localName) && event.isTrusted) {
+					event.stopImmediatePropagation();
+					event.preventDefault();
+					if (event.composedPath()[0].dispatchEvent(new KeyboardEvent(event.type, event)) && !this.matches(":disabled")) this._requestSubmit(form);
+				}
+			};
+			this.addEventListener("click", this._handleButtonClick);
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.form?.addEventListener("keydown", this._formKeyDown, { capture: true });
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this.form?.removeEventListener("keydown", this._formKeyDown, { capture: true });
+		}
+		_requestSubmit(form) {
+			const submitButtonClone = document.createElement("button");
+			submitButtonClone.inert = true;
+			submitButtonClone.hidden = true;
+			submitButtonClone.name = this.name;
+			submitButtonClone.value = this.value ?? "";
+			form.append(submitButtonClone);
+			form.requestSubmit(submitButtonClone);
+			submitButtonClone.remove();
+		}
+		/**
+		* Intentionally empty, as buttons are not targeted by form reset
+		* @internal
+		*/
+		formResetCallback() {}
+		/**
+		* Intentionally empty, as buttons are not targeted by form restore
+		* @internal
+		*/
+		formStateRestoreCallback(_state, _reason) {}
+		/**
+		* Intentionally empty, as button does not write its data in form.
+		* The data is only applied on submit button click as submitter of requestSubmit();
+		* @internal
+		*/
+		updateFormValue() {}
+	};
 })();
-export {
-  SbbButtonBaseElement,
-  SbbButtonLikeBaseElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"button-base-element.js","sources":["../../../../../src/elements/core/base-elements/button-base-element.ts"],"sourcesContent":["import { isServer } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType, hostAttributes } from '../decorators.ts';\nimport { isEventPrevented } from '../eventing.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from '../mixins.ts';\n\nimport { SbbActionBaseElement } from './action-base-element.ts';\n\n/** Enumeration for type attribute in <button> HTML tag. */\nexport type SbbButtonType = 'button' | 'reset' | 'submit';\n\n/** Button base class. */\nexport\n@hostAttributes({\n  tabindex: '0',\n})\nabstract class SbbButtonLikeBaseElement extends SbbFormAssociatedMixin(SbbActionBaseElement) {\n  public static override readonly role: ElementInternals['role'] = 'button';\n\n  public constructor() {\n    super();\n    this.internals.states.add('button');\n\n    if (!isServer) {\n      this.setupBaseEventHandlers();\n\n      const passiveOptions = { passive: true };\n      this.addEventListener('keydown', this._preventScrollOnSpaceKeydown);\n      this.addEventListener('keyup', this._dispatchClickEventOnSpaceKeyup, passiveOptions);\n      this.addEventListener('blur', this._removeActiveMarker, passiveOptions);\n      this.addEventListener(\n        'keypress',\n        (event: KeyboardEvent): void => {\n          if (event.key === 'Enter' || event.key === '\\n') {\n            this._dispatchClickEvent(event);\n          }\n        },\n        passiveOptions,\n      );\n    }\n  }\n\n  /**\n   * Prevents scrolling from pressing Space, when the event target is an action element.\n   * Also sets active state.\n   * @param event The origin event.\n   */\n  private _preventScrollOnSpaceKeydown = (event: KeyboardEvent): void => {\n    if (event.key === ' ') {\n      event.preventDefault();\n      this.internals.states.add('active');\n    }\n  };\n\n  private _removeActiveMarker = (): void => {\n    this.internals.states.delete('active');\n  };\n\n  /**\n   * Dispatches a 'click' PointerEvent if the original keyboard event is a 'Space' press.\n   * As verified with the native button, when 'Space' is pressed, a 'click' event is dispatched\n   * after the 'keyup' event.\n   * @param event The origin event.\n   */\n  private _dispatchClickEventOnSpaceKeyup = (event: KeyboardEvent): void => {\n    if (event.key === ' ') {\n      this._removeActiveMarker();\n      this._dispatchClickEvent(event);\n    }\n  };\n\n  private _dispatchClickEvent = (event: KeyboardEvent): void => {\n    const { altKey, ctrlKey, metaKey, shiftKey } = event;\n    (event.target as Element).dispatchEvent(\n      new PointerEvent('click', {\n        bubbles: true,\n        cancelable: true,\n        composed: true,\n        pointerId: -1,\n        pointerType: '',\n        altKey,\n        ctrlKey,\n        metaKey,\n        shiftKey,\n      }),\n    );\n  };\n\n  public override attributeChangedCallback(\n    name: string,\n    old: string | null,\n    value: string | null,\n  ): void {\n    if (!['name', 'value'].includes(name) || old !== value) {\n      super.attributeChangedCallback(name, old, value);\n    }\n  }\n}\n\n/** Button base class. */\nexport abstract class SbbButtonBaseElement extends SbbButtonLikeBaseElement {\n  private readonly _elementsOnWhichEnterPressTriggersSubmit = [\n    'input',\n    'sbb-date-input',\n    'sbb-time-input',\n  ];\n\n  /** Value of the form element. */\n  @forceType()\n  @property()\n  public accessor value: string = '';\n\n  /**\n   * The type attribute to use for the button.\n   * @default 'button'\n   */\n  @property()\n  public override set type(name: SbbButtonType) {\n    this.setAttribute('type', `${name}`);\n  }\n  public override get type(): SbbButtonType {\n    return (this.getAttribute('type') as SbbButtonType) ?? 'button';\n  }\n\n  /** The `<form>` element to associate the button with. */\n  @property()\n  public override set form(value: string) {\n    this._formId = value;\n    this.form?.addEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n  public override get form(): HTMLFormElement | null {\n    // Use querySelector with form and id selector, as the form property must\n    // reference a valid <form> element\n    return this._formId\n      ? (((this.getRootNode?.() as DocumentFragment | null)?.getElementById?.(\n          this._formId,\n        ) as HTMLFormElement) ?? null)\n      : this.internals.form;\n  }\n  private _formId: string = '';\n\n  public constructor() {\n    super();\n\n    this.addEventListener('click', this._handleButtonClick);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this.form?.addEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n\n    this.form?.removeEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n\n  private _handleButtonClick = async (event: MouseEvent): Promise<void> => {\n    if (this.type === 'button' || (await isEventPrevented(event))) {\n      return;\n    }\n\n    const form = this.form;\n    if (!form) {\n      return;\n    } else if (this.type === 'submit') {\n      this._requestSubmit(form);\n    } else if (this.type === 'reset') {\n      form.reset();\n    }\n  };\n\n  private _requestSubmit(form: HTMLFormElement): void {\n    // `form.requestSubmit(element);` seems not to work for CustomElements, so the `element` parameter has been removed;\n    // TODO: Check if solved in any way, see https://github.com/WICG/webcomponents/issues/814#issuecomment-1218452137\n    // We use the workaround described in the github issue by cloning the submit button and pass this one as an argument.\n\n    const submitButtonClone = document.createElement('button');\n    submitButtonClone.inert = true;\n    submitButtonClone.hidden = true;\n    submitButtonClone.name = this.name;\n    submitButtonClone.value = this.value ?? '';\n\n    form.append(submitButtonClone);\n    form.requestSubmit(submitButtonClone);\n    submitButtonClone.remove();\n  }\n\n  private _formKeyDown = (event: KeyboardEvent): void => {\n    const form = this.form;\n    if (\n      this.type === 'submit' &&\n      form &&\n      (event.key === 'Enter' || event.key === '\\n') &&\n      this._elementsOnWhichEnterPressTriggersSubmit.includes(\n        (event.target as HTMLElement)?.localName,\n      ) &&\n      event.isTrusted\n    ) {\n      // In the case where there is only one form element, an enter press submits the form.\n      // In the case where we only have one input and this button as a submit button,\n      // we need to prevent the default functionality of submitting the form because\n      // while this button should be recognized as a submit element, that is not natively the case,\n      // and therefore we manually handle this case here.\n      // If this button is not disabled we will then request a submit further down below.\n      event.stopImmediatePropagation();\n      event.preventDefault();\n\n      const eventOrigin = event.composedPath()[0];\n\n      if (\n        eventOrigin.dispatchEvent(new KeyboardEvent(event.type, event)) &&\n        !this.matches(':disabled')\n      ) {\n        this._requestSubmit(form);\n      }\n    }\n  };\n\n  /**\n   * Intentionally empty, as buttons are not targeted by form reset\n   * @internal\n   */\n  public override formResetCallback(): void {}\n\n  /**\n   * Intentionally empty, as buttons are not targeted by form restore\n   * @internal\n   */\n  public override formStateRestoreCallback(\n    _state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {}\n\n  /**\n   * Intentionally empty, as button does not write its data in form.\n   * The data is only applied on submit button click as submitter of requestSubmit();\n   * @internal\n   */\n  protected override updateFormValue(): void {}\n}\n"],"names":[],"mappings":"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"}
+//#endregion
+export { SbbButtonBaseElement, SbbButtonLikeBaseElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"button-base-element.js","names":[],"sources":["../../../../../src/elements/core/base-elements/button-base-element.ts"],"sourcesContent":["import { isServer } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { forceType, hostAttributes } from '../decorators.ts';\nimport { isEventPrevented } from '../eventing.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbFormAssociatedMixin,\n} from '../mixins.ts';\n\nimport { SbbActionBaseElement } from './action-base-element.ts';\n\n/** Enumeration for type attribute in <button> HTML tag. */\nexport type SbbButtonType = 'button' | 'reset' | 'submit';\n\n/** Button base class. */\nexport\n@hostAttributes({\n  tabindex: '0',\n})\nabstract class SbbButtonLikeBaseElement extends SbbFormAssociatedMixin(SbbActionBaseElement) {\n  public static override readonly role: ElementInternals['role'] = 'button';\n\n  public constructor() {\n    super();\n    this.internals.states.add('button');\n\n    if (!isServer) {\n      this.setupBaseEventHandlers();\n\n      const passiveOptions = { passive: true };\n      this.addEventListener('keydown', this._preventScrollOnSpaceKeydown);\n      this.addEventListener('keyup', this._dispatchClickEventOnSpaceKeyup, passiveOptions);\n      this.addEventListener('blur', this._removeActiveMarker, passiveOptions);\n      this.addEventListener(\n        'keypress',\n        (event: KeyboardEvent): void => {\n          if (event.key === 'Enter' || event.key === '\\n') {\n            this._dispatchClickEvent(event);\n          }\n        },\n        passiveOptions,\n      );\n    }\n  }\n\n  /**\n   * Prevents scrolling from pressing Space, when the event target is an action element.\n   * Also sets active state.\n   * @param event The origin event.\n   */\n  private _preventScrollOnSpaceKeydown = (event: KeyboardEvent): void => {\n    if (event.key === ' ') {\n      event.preventDefault();\n      this.internals.states.add('active');\n    }\n  };\n\n  private _removeActiveMarker = (): void => {\n    this.internals.states.delete('active');\n  };\n\n  /**\n   * Dispatches a 'click' PointerEvent if the original keyboard event is a 'Space' press.\n   * As verified with the native button, when 'Space' is pressed, a 'click' event is dispatched\n   * after the 'keyup' event.\n   * @param event The origin event.\n   */\n  private _dispatchClickEventOnSpaceKeyup = (event: KeyboardEvent): void => {\n    if (event.key === ' ') {\n      this._removeActiveMarker();\n      this._dispatchClickEvent(event);\n    }\n  };\n\n  private _dispatchClickEvent = (event: KeyboardEvent): void => {\n    const { altKey, ctrlKey, metaKey, shiftKey } = event;\n    (event.target as Element).dispatchEvent(\n      new PointerEvent('click', {\n        bubbles: true,\n        cancelable: true,\n        composed: true,\n        pointerId: -1,\n        pointerType: '',\n        altKey,\n        ctrlKey,\n        metaKey,\n        shiftKey,\n      }),\n    );\n  };\n\n  public override attributeChangedCallback(\n    name: string,\n    old: string | null,\n    value: string | null,\n  ): void {\n    if (!['name', 'value'].includes(name) || old !== value) {\n      super.attributeChangedCallback(name, old, value);\n    }\n  }\n}\n\n/** Button base class. */\nexport abstract class SbbButtonBaseElement extends SbbButtonLikeBaseElement {\n  private readonly _elementsOnWhichEnterPressTriggersSubmit = [\n    'input',\n    'sbb-date-input',\n    'sbb-time-input',\n  ];\n\n  /** Value of the form element. */\n  @forceType()\n  @property()\n  public accessor value: string = '';\n\n  /**\n   * The type attribute to use for the button.\n   * @default 'button'\n   */\n  @property()\n  public override set type(name: SbbButtonType) {\n    this.setAttribute('type', `${name}`);\n  }\n  public override get type(): SbbButtonType {\n    return (this.getAttribute('type') as SbbButtonType) ?? 'button';\n  }\n\n  /** The `<form>` element to associate the button with. */\n  @property()\n  public override set form(value: string) {\n    this._formId = value;\n    this.form?.addEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n  public override get form(): HTMLFormElement | null {\n    // Use querySelector with form and id selector, as the form property must\n    // reference a valid <form> element\n    return this._formId\n      ? (((this.getRootNode?.() as DocumentFragment | null)?.getElementById?.(\n          this._formId,\n        ) as HTMLFormElement) ?? null)\n      : this.internals.form;\n  }\n  private _formId: string = '';\n\n  public constructor() {\n    super();\n\n    this.addEventListener('click', this._handleButtonClick);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this.form?.addEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n\n    this.form?.removeEventListener('keydown', this._formKeyDown, { capture: true });\n  }\n\n  private _handleButtonClick = async (event: MouseEvent): Promise<void> => {\n    if (this.type === 'button' || (await isEventPrevented(event))) {\n      return;\n    }\n\n    const form = this.form;\n    if (!form) {\n      return;\n    } else if (this.type === 'submit') {\n      this._requestSubmit(form);\n    } else if (this.type === 'reset') {\n      form.reset();\n    }\n  };\n\n  private _requestSubmit(form: HTMLFormElement): void {\n    // `form.requestSubmit(element);` seems not to work for CustomElements, so the `element` parameter has been removed;\n    // TODO: Check if solved in any way, see https://github.com/WICG/webcomponents/issues/814#issuecomment-1218452137\n    // We use the workaround described in the github issue by cloning the submit button and pass this one as an argument.\n\n    const submitButtonClone = document.createElement('button');\n    submitButtonClone.inert = true;\n    submitButtonClone.hidden = true;\n    submitButtonClone.name = this.name;\n    submitButtonClone.value = this.value ?? '';\n\n    form.append(submitButtonClone);\n    form.requestSubmit(submitButtonClone);\n    submitButtonClone.remove();\n  }\n\n  private _formKeyDown = (event: KeyboardEvent): void => {\n    const form = this.form;\n    if (\n      this.type === 'submit' &&\n      form &&\n      (event.key === 'Enter' || event.key === '\\n') &&\n      this._elementsOnWhichEnterPressTriggersSubmit.includes(\n        (event.target as HTMLElement)?.localName,\n      ) &&\n      event.isTrusted\n    ) {\n      // In the case where there is only one form element, an enter press submits the form.\n      // In the case where we only have one input and this button as a submit button,\n      // we need to prevent the default functionality of submitting the form because\n      // while this button should be recognized as a submit element, that is not natively the case,\n      // and therefore we manually handle this case here.\n      // If this button is not disabled we will then request a submit further down below.\n      event.stopImmediatePropagation();\n      event.preventDefault();\n\n      const eventOrigin = event.composedPath()[0];\n\n      if (\n        eventOrigin.dispatchEvent(new KeyboardEvent(event.type, event)) &&\n        !this.matches(':disabled')\n      ) {\n        this._requestSubmit(form);\n      }\n    }\n  };\n\n  /**\n   * Intentionally empty, as buttons are not targeted by form reset\n   * @internal\n   */\n  public override formResetCallback(): void {}\n\n  /**\n   * Intentionally empty, as buttons are not targeted by form restore\n   * @internal\n   */\n  public override formStateRestoreCallback(\n    _state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {}\n\n  /**\n   * Intentionally empty, as button does not write its data in form.\n   * The data is only applied on submit button click as submitter of requestSubmit();\n   * @internal\n   */\n  protected override updateFormValue(): void {}\n}\n"],"mappings":";;;;;;;;;IAqBe,kCAAwB;yBAHtC,eAAe,EACd,UAAU,KACX,CAAC,CAAA;;;;mBAC8C,uBAAuB,qBAAqB;8CAA5C,YAA4C;;;;;;AAA5F,gBAAA,MAAA,mBAAA,EAAA,OAAA,YAAA,EAAA,kBAAA;IAAA,MAAA;IAAA,MAAA,WAAA;IAAA,UAAA;IAAA,EAAA,MAAA,wBAAA;;;;;;;;;;AACkC,QAAA,OAAiC;;EAEjE,cAAA;AACE,UAAO;;;;;;AA2BD,QAAA,gCAAgC,UAA8B;AACpE,QAAI,MAAM,QAAQ,KAAK;AACrB,WAAM,gBAAgB;AACtB,UAAK,UAAU,OAAO,IAAI,SAAS;;;AAI/B,QAAA,4BAAiC;AACvC,SAAK,UAAU,OAAO,OAAO,SAAS;;;;;;;;AAShC,QAAA,mCAAmC,UAA8B;AACvE,QAAI,MAAM,QAAQ,KAAK;AACrB,UAAK,qBAAqB;AAC1B,UAAK,oBAAoB,MAAM;;;AAI3B,QAAA,uBAAuB,UAA8B;IAC3D,MAAM,EAAE,QAAQ,SAAS,SAAS,aAAa;AAC9C,UAAM,OAAmB,cACxB,IAAI,aAAa,SAAS;KACxB,SAAS;KACT,YAAY;KACZ,UAAU;KACV,WAAW;KACX,aAAa;KACb;KACA;KACA;KACA;KACD,CAAC,CACH;;AAhED,QAAK,UAAU,OAAO,IAAI,SAAS;AAEnC,OAAI,CAAC,UAAU;AACb,SAAK,wBAAwB;IAE7B,MAAM,iBAAiB,EAAE,SAAS,MAAM;AACxC,SAAK,iBAAiB,WAAW,KAAK,6BAA6B;AACnE,SAAK,iBAAiB,SAAS,KAAK,iCAAiC,eAAe;AACpF,SAAK,iBAAiB,QAAQ,KAAK,qBAAqB,eAAe;AACvE,SAAK,iBACH,aACC,UAA8B;AAC7B,SAAI,MAAM,QAAQ,WAAW,MAAM,QAAQ,KACzC,MAAK,oBAAoB,MAAM;OAGnC,eACD;;;EAkDW,yBACd,MACA,KACA,OAAoB;AAEpB,OAAI,CAAC,CAAC,QAAQ,QAAQ,CAAC,SAAS,KAAK,IAAI,QAAQ,MAC/C,OAAM,yBAAyB,MAAM,KAAK,MAAM;;;AA9EvC,qBAAA,YAAA,wBAAA;;;;;;IAoFO,8BAAoB;mBAAS;;;;;;;cAA7B,6BAA6B,YAAwB;;;wBAQxE,WAAW,EACX,UAAU,CAAA;2BAOV,UAAU,CAAA;2BASV,UAAU,CAAA;AAfX,gBAAA,MAAA,MAAA,mBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,WAAA;KAAA,MAAA,QAAA,IAAgB;KAAK,MAAA,KAAA,UAAA;AAAA,UAAL,QAAK;;KAAA;IAAA,UAAA;IAAA,EAAA,qBAAA,yBAAA;AAOrB,gBAAA,MAAA,MAAA,sBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,KAAA,UAAA;AAAA,UAAoB,OAAI;;KAAA;IAAA,UAAA;IAAA,EAAA,MAAA,2BAAA;AASxB,gBAAA,MAAA,MAAA,sBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,KAAA,UAAA;AAAA,UAAoB,OAAI;;KAAA;IAAA,UAAA;IAAA,EAAA,MAAA,2BAAA;;;;;;;;EAhBxB;;EAAA,IAAgB,QAAK;AAAA,UAAA,MAAA;;EAArB,IAAgB,MAAK,OAAA;AAAA,SAAA,yBAAA;;;;;;EAOrB,IAAoB,KAAK,MAAmB;AAC1C,QAAK,aAAa,QAAQ,GAAG,OAAO;;EAEtC,IAAoB,OAAI;AACtB,UAAQ,KAAK,aAAa,OAAyB,IAAI;;;EAKzD,IAAoB,KAAK,OAAa;AACpC,QAAK,UAAU;AACf,QAAK,MAAM,iBAAiB,WAAW,KAAK,cAAc,EAAE,SAAS,MAAM,CAAC;;EAE9E,IAAoB,OAAI;AAGtB,UAAO,KAAK,UACL,KAAK,eAA2C,EAAE,iBACnD,KAAK,QACc,IAAI,OACzB,KAAK,UAAU;;EAIrB,cAAA;AACE,UAAO;AAzCQ,QAAA,4CADG,kBAAA,MAAA,2BAAoB,EACoB;IAC1D;IACA;IACA;IACD;AAKe,SAAA,yBAAA,kBAAA,MAAA,qBAAgB,GAAE;AA6B1B,QAAA,WAAO,kBAAA,MAAA,yBAAA,EAAW;AAoBlB,QAAA,qBAAqB,OAAO,UAAoC;AACtE,QAAI,KAAK,SAAS,YAAa,MAAM,iBAAiB,MAAM,CAC1D;IAGF,MAAM,OAAO,KAAK;AAClB,QAAI,CAAC,KACH;aACS,KAAK,SAAS,SACvB,MAAK,eAAe,KAAK;aAChB,KAAK,SAAS,QACvB,MAAK,OAAO;;AAoBR,QAAA,gBAAgB,UAA8B;IACpD,MAAM,OAAO,KAAK;AAClB,QACE,KAAK,SAAS,YACd,SACC,MAAM,QAAQ,WAAW,MAAM,QAAQ,SACxC,KAAK,yCAAyC,SAC3C,MAAM,QAAwB,UAChC,IACD,MAAM,WACN;AAOA,WAAM,0BAA0B;AAChC,WAAM,gBAAgB;AAItB,SAFoB,MAAM,cAAc,CAAC,GAG3B,cAAc,IAAI,cAAc,MAAM,MAAM,MAAM,CAAC,IAC/D,CAAC,KAAK,QAAQ,YAAY,CAE1B,MAAK,eAAe,KAAK;;;AAxE7B,QAAK,iBAAiB,SAAS,KAAK,mBAAmB;;EAGzC,oBAAiB;AAC/B,SAAM,mBAAmB;AAEzB,QAAK,MAAM,iBAAiB,WAAW,KAAK,cAAc,EAAE,SAAS,MAAM,CAAC;;EAG9D,uBAAoB;AAClC,SAAM,sBAAsB;AAE5B,QAAK,MAAM,oBAAoB,WAAW,KAAK,cAAc,EAAE,SAAS,MAAM,CAAC;;EAkBzE,eAAe,MAAqB;GAK1C,MAAM,oBAAoB,SAAS,cAAc,SAAS;AAC1D,qBAAkB,QAAQ;AAC1B,qBAAkB,SAAS;AAC3B,qBAAkB,OAAO,KAAK;AAC9B,qBAAkB,QAAQ,KAAK,SAAS;AAExC,QAAK,OAAO,kBAAkB;AAC9B,QAAK,cAAc,kBAAkB;AACrC,qBAAkB,QAAQ;;;;;;EAsCZ,oBAAiB;;;;;EAMjB,yBACd,QACA,SAA0B;;;;;;EAQT,kBAAe"}