@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/core/base-elements.js

@@ -0,0 +1,292 @@
+import { LitElement, html, isServer, nothing } from "lit";
+import { hostAttributes } from "./decorators.js";
+import { getDocumentWritingMode, getLocalName } from "./dom.js";
+import { property } from "lit/decorators.js";
+import { isEventPrevented, EventEmitter } from "./eventing.js";
+import { SbbLanguageController } from "./controllers.js";
+import { i18nTargetOpensInNewWindow } from "./i18n.js";
+import "../screen-reader-only.js";
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (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$2(target, key, result);
+  return result;
+};
+let SbbActionBaseElement = class extends LitElement {
+  get maybeDisabled() {
+    const maybeDisabled = this;
+    return maybeDisabled.disabled || maybeDisabled.formDisabled;
+  }
+  setupBaseEventHandlers() {
+    this.addEventListener(
+      "click",
+      (event) => {
+        if (this.maybeDisabled) {
+          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 ?? getLocalName(this)}">
+        ${this.renderTemplate()}
+      </span>
+    `;
+  }
+};
+SbbActionBaseElement = __decorateClass$2([
+  hostAttributes({
+    dir: getDocumentWritingMode(),
+    "data-action": ""
+  })
+], SbbActionBaseElement);
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(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$1(target, key, result);
+  return result;
+};
+let SbbButtonBaseElement = class extends SbbActionBaseElement {
+  constructor() {
+    super();
+    this.type = "button";
+    this._handleButtonClick = async (event) => {
+      if (this.type === "button" || await isEventPrevented(event)) {
+        return;
+      }
+      const form = this.form ? this.ownerDocument.querySelector(`form#${this.form}`) : this.closest("form");
+      if (!form) {
+        return;
+      } else if (this.type === "submit") {
+        form.requestSubmit();
+      } else if (this.type === "reset") {
+        form.reset();
+      }
+    };
+    this._preventScrollOnSpaceKeydown = (event) => {
+      if (event.key === " ") {
+        event.preventDefault();
+        event.target.toggleAttribute("data-active", true);
+      }
+    };
+    this._removeActiveMarker = (event) => {
+      event.target.removeAttribute("data-active");
+    };
+    this._dispatchClickEventOnSpaceKeyup = (event) => {
+      if (event.key === " ") {
+        this._removeActiveMarker(event);
+        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
+        })
+      );
+    };
+    if (!isServer) {
+      this.setupBaseEventHandlers();
+      const passiveOptions = { passive: true };
+      this.addEventListener("click", this._handleButtonClick);
+      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
+      );
+    }
+  }
+  set name(name) {
+    this.setAttribute("name", `${name}`);
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set value(value) {
+    this.setAttribute("value", `${value}`);
+  }
+  get value() {
+    return this.getAttribute("value") ?? "";
+  }
+  attributeChangedCallback(name, old, value) {
+    if (!["name", "value"].includes(name) || old !== value) {
+      super.attributeChangedCallback(name, old, value);
+    }
+  }
+};
+__decorateClass$1([
+  property()
+], SbbButtonBaseElement.prototype, "type", 2);
+__decorateClass$1([
+  property()
+], SbbButtonBaseElement.prototype, "name", 1);
+__decorateClass$1([
+  property()
+], SbbButtonBaseElement.prototype, "value", 1);
+__decorateClass$1([
+  property()
+], SbbButtonBaseElement.prototype, "form", 2);
+SbbButtonBaseElement = __decorateClass$1([
+  hostAttributes({
+    role: "button",
+    tabindex: "0",
+    "data-button": ""
+  })
+], SbbButtonBaseElement);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (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(target, key, result);
+  return result;
+};
+let SbbLinkBaseElement = class extends SbbActionBaseElement {
+  constructor() {
+    super();
+    this.language = new SbbLanguageController(this);
+    this._evaluateRelAttribute = () => {
+      return this.rel ? this.rel : this.target === "_blank" ? "external noopener nofollow" : nothing;
+    };
+    if (!isServer) {
+      this.setupBaseEventHandlers();
+    }
+  }
+  /** @internal */
+  focus(options) {
+    var _a;
+    (_a = this.shadowRoot.querySelector("a")) == null ? void 0 : _a.focus(options);
+  }
+  /** @internal */
+  blur() {
+    var _a;
+    (_a = this.shadowRoot.querySelector("a")) == null ? void 0 : _a.blur();
+  }
+  /** @internal */
+  click() {
+    var _a;
+    (_a = this.shadowRoot.querySelector("a")) == null ? void 0 : _a.click();
+  }
+  /** Default render method for link-like components. Can be overridden if the LinkRenderVariables are not needed. */
+  render() {
+    return html`
+      <a
+        class="sbb-action-base ${this.localName ?? getLocalName(this)}"
+        href=${this.href || nothing}
+        ?download=${this.download}
+        target=${this.target || nothing}
+        rel=${this._evaluateRelAttribute()}
+        aria-label=${this.accessibilityLabel || nothing}
+        tabindex=${this.maybeDisabled ? "-1" : nothing}
+        aria-disabled=${this.maybeDisabled ? "true" : nothing}
+      >
+        ${this.renderTemplate()}
+        ${!!this.href && this.target === "_blank" ? html`<sbb-screen-reader-only
+              >. ${i18nTargetOpensInNewWindow[this.language.current]}</sbb-screen-reader-only
+            >` : nothing}
+      </a>
+    `;
+  }
+};
+__decorateClass([
+  property()
+], SbbLinkBaseElement.prototype, "href", 2);
+__decorateClass([
+  property()
+], SbbLinkBaseElement.prototype, "target", 2);
+__decorateClass([
+  property()
+], SbbLinkBaseElement.prototype, "rel", 2);
+__decorateClass([
+  property({ type: Boolean })
+], SbbLinkBaseElement.prototype, "download", 2);
+__decorateClass([
+  property({ attribute: "accessibility-label" })
+], SbbLinkBaseElement.prototype, "accessibilityLabel", 2);
+SbbLinkBaseElement = __decorateClass([
+  hostAttributes({
+    "data-link": ""
+  })
+], SbbLinkBaseElement);
+const _SbbOpenCloseBaseElement = class _SbbOpenCloseBaseElement extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.willOpen = new EventEmitter(
+      this,
+      _SbbOpenCloseBaseElement.events.willOpen
+    );
+    this.didOpen = new EventEmitter(this, _SbbOpenCloseBaseElement.events.didOpen);
+    this.willClose = new EventEmitter(
+      this,
+      _SbbOpenCloseBaseElement.events.willClose
+    );
+    this.didClose = new EventEmitter(
+      this,
+      _SbbOpenCloseBaseElement.events.didClose
+    );
+  }
+  /** The state of the component. */
+  set state(state) {
+    this.setAttribute("data-state", state);
+  }
+  get state() {
+    return this.getAttribute("data-state");
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.state || (this.state = "closed");
+  }
+};
+_SbbOpenCloseBaseElement.events = {
+  willOpen: "willOpen",
+  didOpen: "didOpen",
+  willClose: "willClose",
+  didClose: "didClose"
+};
+let SbbOpenCloseBaseElement = _SbbOpenCloseBaseElement;
+export {
+  SbbActionBaseElement,
+  SbbButtonBaseElement,
+  SbbLinkBaseElement,
+  SbbOpenCloseBaseElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"base-elements.js","sources":["../../../../src/elements/core/base-elements/action-base-element.ts","../../../../src/elements/core/base-elements/button-base-element.ts","../../../../src/elements/core/base-elements/link-base-element.ts","../../../../src/elements/core/base-elements/open-close-base-element.ts"],"sourcesContent":["import { html, LitElement, type TemplateResult } from 'lit';\n\nimport { hostAttributes } from '../decorators.js';\nimport { getDocumentWritingMode, getLocalName } from '../dom.js';\n\n/**\n * Whenever an element can be disabled it has disabled property\n * or formDisabled if it's a form element.\n * Because we can't use types here directly we created this helper type.\n */\ntype MaybeDisabled = {\n  disabled?: boolean;\n  formDisabled?: boolean;\n};\n\n@hostAttributes({\n  dir: getDocumentWritingMode(),\n  'data-action': '',\n})\nexport abstract class SbbActionBaseElement extends LitElement {\n  protected get maybeDisabled(): boolean | undefined {\n    const maybeDisabled = this as MaybeDisabled;\n    return maybeDisabled.disabled || maybeDisabled.formDisabled;\n  }\n\n  protected setupBaseEventHandlers(): void {\n    this.addEventListener(\n      'click',\n      (event) => {\n        if (this.maybeDisabled) {\n          event.preventDefault();\n          event.stopImmediatePropagation();\n        }\n      },\n      // capture is necessary here, as this event handler needs to be executed before any other\n      // in order to stop immediate propagation in the disabled case.\n      { capture: true },\n    );\n  }\n\n  /** Override this method to render the component template. */\n  protected renderTemplate(): TemplateResult {\n    throw new Error('Implementation needed!');\n  }\n\n  /** Default render method for button-like components. */\n  protected override render(): TemplateResult {\n    return html`\n      <span class=\"sbb-action-base ${this.localName ?? getLocalName(this)}\">\n        ${this.renderTemplate()}\n      </span>\n    `;\n  }\n}\n","import { isServer } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { hostAttributes } from '../decorators.js';\nimport { isEventPrevented } from '../eventing.js';\n\nimport { SbbActionBaseElement } from './action-base-element.js';\n\n/** Enumeration for type attribute in <button> HTML tag. */\nexport type SbbButtonType = 'button' | 'reset' | 'submit';\n\n/** Button base class. */\n@hostAttributes({\n  role: 'button',\n  tabindex: '0',\n  'data-button': '',\n})\nexport abstract class SbbButtonBaseElement extends SbbActionBaseElement {\n  /** The type attribute to use for the button. */\n  @property() public type: SbbButtonType = 'button';\n\n  /**\n   * The name of the button element.\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  public get name(): string {\n    return this.getAttribute('name') ?? '';\n  }\n\n  /**\n   * The value of the button element.\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 value(value: string) {\n    this.setAttribute('value', `${value}`);\n  }\n  public get value(): string {\n    return this.getAttribute('value') ?? '';\n  }\n\n  /** The <form> element to associate the button with. */\n  @property() public form?: string;\n\n  private _handleButtonClick = async (event: MouseEvent): Promise<void> => {\n    if (this.type === 'button' || (await isEventPrevented(event))) {\n      return;\n    }\n\n    // Use querySelector with form and id selector, as the form property must\n    // reference a valid <form> element\n    const form = this.form\n      ? (this.ownerDocument.querySelector(`form#${this.form}`) as HTMLFormElement)\n      : this.closest('form');\n    if (!form) {\n      return;\n    } else if (this.type === 'submit') {\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      form.requestSubmit();\n    } else if (this.type === 'reset') {\n      form.reset();\n    }\n  };\n\n  /**\n   * Prevents scrolling from pressing Space, when the event target is an action element.\n   * Also sets data-active attribute.\n   * @param event The origin event.\n   */\n  private _preventScrollOnSpaceKeydown = (event: KeyboardEvent): void => {\n    if (event.key === ' ') {\n      event.preventDefault();\n      (event.target as HTMLElement).toggleAttribute('data-active', true);\n    }\n  };\n\n  private _removeActiveMarker = (event: Event): void => {\n    (event.target as HTMLElement).removeAttribute('data-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(event);\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 constructor() {\n    super();\n    if (!isServer) {\n      this.setupBaseEventHandlers();\n\n      const passiveOptions = { passive: true };\n      this.addEventListener('click', this._handleButtonClick);\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  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","import { html, isServer, nothing, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbLanguageController } from '../controllers.js';\nimport { hostAttributes } from '../decorators.js';\nimport { getLocalName } from '../dom.js';\nimport { i18nTargetOpensInNewWindow } from '../i18n.js';\n\nimport { SbbActionBaseElement } from './action-base-element.js';\n\nimport '../../screen-reader-only.js';\n\n/** Enumeration for 'target' attribute in <a> HTML tag. */\nexport type LinkTargetType = '_blank' | '_self' | '_parent' | '_top';\n\n/** Link base class. */\n@hostAttributes({\n  'data-link': '',\n})\nexport abstract class SbbLinkBaseElement extends SbbActionBaseElement {\n  /** The href value you want to link to. */\n  @property() public href?: string;\n\n  /** Where to display the linked URL. */\n  @property() public target?: LinkTargetType | string;\n\n  /** The relationship of the linked URL as space-separated link types. */\n  @property() public rel?: string;\n\n  /** Whether the browser will show the download dialog on click. */\n  @property({ type: Boolean }) public download?: boolean;\n\n  /** This will be forwarded as aria-label to the inner anchor element. */\n  @property({ attribute: 'accessibility-label' }) public accessibilityLabel: string | undefined;\n\n  protected language = new SbbLanguageController(this);\n\n  public constructor() {\n    super();\n    if (!isServer) {\n      this.setupBaseEventHandlers();\n    }\n  }\n\n  /** @internal */\n  public override focus(options?: FocusOptions | undefined): void {\n    this.shadowRoot!.querySelector<HTMLAnchorElement>('a')?.focus(options);\n  }\n\n  /** @internal */\n  public override blur(): void {\n    this.shadowRoot!.querySelector<HTMLAnchorElement>('a')?.blur();\n  }\n\n  /** @internal */\n  public override click(): void {\n    this.shadowRoot!.querySelector<HTMLAnchorElement>('a')?.click();\n  }\n\n  private _evaluateRelAttribute = (): string | typeof nothing => {\n    return this.rel ? this.rel : this.target === '_blank' ? 'external noopener nofollow' : nothing;\n  };\n\n  /** Default render method for link-like components. Can be overridden if the LinkRenderVariables are not needed. */\n  protected override render(): TemplateResult {\n    return html`\n      <a\n        class=\"sbb-action-base ${this.localName ?? getLocalName(this)}\"\n        href=${this.href || nothing}\n        ?download=${this.download}\n        target=${this.target || nothing}\n        rel=${this._evaluateRelAttribute()}\n        aria-label=${this.accessibilityLabel || nothing}\n        tabindex=${this.maybeDisabled ? '-1' : nothing}\n        aria-disabled=${this.maybeDisabled ? 'true' : nothing}\n      >\n        ${this.renderTemplate()}\n        ${!!this.href && this.target === '_blank'\n          ? html`<sbb-screen-reader-only\n              >. ${i18nTargetOpensInNewWindow[this.language.current]}</sbb-screen-reader-only\n            >`\n          : nothing}\n      </a>\n    `;\n  }\n}\n","import { LitElement } from 'lit';\n\nimport { EventEmitter } from '../eventing.js';\nimport type { SbbOpenedClosedState } from '../interfaces.js';\n\n/**\n * Base class for overlay components.\n *\n * @event willOpen - Emits whenever the component starts the opening transition. Can be canceled.\n * @event didOpen - Emits whenever the component is opened.\n * @event willClose - Emits whenever the component begins the closing transition. Can be canceled.\n * @event didClose - Emits whenever the component is closed.\n */\nexport abstract class SbbOpenCloseBaseElement extends LitElement {\n  public static readonly events = {\n    willOpen: 'willOpen',\n    didOpen: 'didOpen',\n    willClose: 'willClose',\n    didClose: 'didClose',\n  } as const;\n\n  /** The state of the component. */\n  protected set state(state: SbbOpenedClosedState) {\n    this.setAttribute('data-state', state);\n  }\n  protected get state(): SbbOpenedClosedState {\n    return this.getAttribute('data-state') as SbbOpenedClosedState;\n  }\n\n  /** Emits whenever the component starts the opening transition. */\n  protected willOpen: EventEmitter = new EventEmitter(\n    this,\n    SbbOpenCloseBaseElement.events.willOpen,\n  );\n\n  /** Emits whenever the component is opened. */\n  protected didOpen: EventEmitter = new EventEmitter(this, SbbOpenCloseBaseElement.events.didOpen);\n\n  /** Emits whenever the component begins the closing transition. */\n  protected willClose: EventEmitter = new EventEmitter(\n    this,\n    SbbOpenCloseBaseElement.events.willClose,\n  );\n\n  /** Emits whenever the component is closed. */\n  protected didClose: EventEmitter = new EventEmitter(\n    this,\n    SbbOpenCloseBaseElement.events.didClose,\n  );\n\n  /** Opens the component. */\n  public abstract open(): void;\n  /** Closes the component. */\n  public abstract close(): void;\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    this.state ||= 'closed';\n  }\n}\n"],"names":["__decorateClass"],"mappings":"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"}

package/development/core/config/config.d.ts

@@ -0,0 +1,22 @@
+import { DateAdapter } from '../datetime.js';
+
+export interface SbbIconConfig {
+    interceptor?: (parameters: {
+        namespace: string;
+        name: string;
+        url: string;
+        request: () => Promise<string>;
+    }) => Promise<string>;
+    namespaces?: Map<string, string>;
+}
+export interface SbbDatetimeConfig {
+    dateAdapter?: DateAdapter;
+}
+export interface SbbConfig {
+    language?: string;
+    icon?: SbbIconConfig;
+    datetime?: SbbDatetimeConfig;
+}
+export declare function readConfig(): SbbConfig;
+export declare function mergeConfig(config: Partial<SbbConfig>): void;
+//# sourceMappingURL=config.d.ts.map

package/development/core/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/config/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE;QACzB,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,GAAG,EAAE,MAAM,CAAC;QACZ,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;KAChC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACtB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CAC9B;AAED,wBAAgB,UAAU,IAAI,SAAS,CAKtC;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAG5D"}

package/development/core/config.d.ts

@@ -0,0 +1,2 @@
+export * from './config/config.js';
+//# sourceMappingURL=config.d.ts.map

package/development/core/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/config.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/development/core/config.js

@@ -0,0 +1,15 @@
+function readConfig() {
+  if (!("sbbConfig" in globalThis)) {
+    globalThis.sbbConfig = {};
+  }
+  return globalThis.sbbConfig;
+}
+function mergeConfig(config) {
+  const oldConfig = readConfig();
+  Object.assign(oldConfig, config);
+}
+export {
+  mergeConfig,
+  readConfig
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY29yZS9jb25maWcvY29uZmlnLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRGF0ZUFkYXB0ZXIgfSBmcm9tICcuLi9kYXRldGltZS5qcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2JiSWNvbkNvbmZpZyB7XG4gIGludGVyY2VwdG9yPzogKHBhcmFtZXRlcnM6IHtcbiAgICBuYW1lc3BhY2U6IHN0cmluZztcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgdXJsOiBzdHJpbmc7XG4gICAgcmVxdWVzdDogKCkgPT4gUHJvbWlzZTxzdHJpbmc+O1xuICB9KSA9PiBQcm9taXNlPHN0cmluZz47XG4gIG5hbWVzcGFjZXM/OiBNYXA8c3RyaW5nLCBzdHJpbmc+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNiYkRhdGV0aW1lQ29uZmlnIHtcbiAgZGF0ZUFkYXB0ZXI/OiBEYXRlQWRhcHRlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTYmJDb25maWcge1xuICBsYW5ndWFnZT86IHN0cmluZztcbiAgaWNvbj86IFNiYkljb25Db25maWc7XG4gIGRhdGV0aW1lPzogU2JiRGF0ZXRpbWVDb25maWc7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiByZWFkQ29uZmlnKCk6IFNiYkNvbmZpZyB7XG4gIGlmICghKCdzYmJDb25maWcnIGluIGdsb2JhbFRoaXMpKSB7XG4gICAgKGdsb2JhbFRoaXMgYXMgYW55KS5zYmJDb25maWcgPSB7fTsgLy8gRklYTUUgYW55IHR5cGVcbiAgfVxuICByZXR1cm4gKGdsb2JhbFRoaXMgYXMgYW55KS5zYmJDb25maWcgYXMgU2JiQ29uZmlnOyAvLyBGSVhNRSBhbnkgdHlwZVxufVxuXG5leHBvcnQgZnVuY3Rpb24gbWVyZ2VDb25maWcoY29uZmlnOiBQYXJ0aWFsPFNiYkNvbmZpZz4pOiB2b2lkIHtcbiAgY29uc3Qgb2xkQ29uZmlnID0gcmVhZENvbmZpZygpO1xuICBPYmplY3QuYXNzaWduKG9sZENvbmZpZywgY29uZmlnKTtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQk8sU0FBUyxhQUF3QjtBQUNsQyxNQUFBLEVBQUUsZUFBZSxhQUFhO0FBQy9CLGVBQW1CLFlBQVk7RUFDbEM7QUFDQSxTQUFRLFdBQW1CO0FBQzdCO0FBRU8sU0FBUyxZQUFZLFFBQWtDO0FBQzVELFFBQU0sWUFBWTtBQUNYLFNBQUEsT0FBTyxXQUFXLE1BQU07QUFDakM7In0=

package/development/core/controllers/connected-abort-controller.d.ts

@@ -0,0 +1,11 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+
+export declare class SbbConnectedAbortController implements ReactiveController {
+    private _host;
+    private _abortController?;
+    get signal(): AbortSignal | undefined;
+    constructor(_host: ReactiveControllerHost);
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+//# sourceMappingURL=connected-abort-controller.d.ts.map

package/development/core/controllers/connected-abort-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connected-abort-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/connected-abort-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAEtE,qBAAa,2BAA4B,YAAW,kBAAkB;IAOjD,OAAO,CAAC,KAAK;IANhC,OAAO,CAAC,gBAAgB,CAAC,CAA0C;IAEnE,IAAW,MAAM,IAAI,WAAW,GAAG,SAAS,CAE3C;gBAE0B,KAAK,EAAE,sBAAsB;IAIjD,aAAa,IAAI,IAAI;IAMrB,gBAAgB,IAAI,IAAI;CAIhC"}

package/development/core/controllers/language-controller.d.ts

@@ -0,0 +1,33 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+
+/**
+ * The LanguageController is a reactive controller that observes the "lang" attribute
+ * of the <html> tag.
+ * On change of the "lang" attribute, it will request an update of connected
+ * components.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang
+ */
+export declare class SbbLanguageController implements ReactiveController {
+    private _host;
+    private static readonly _defaultLanguage;
+    private static readonly _supportedLocales;
+    /** A set of connected components that should be notified on language change. */
+    private static readonly _listeners;
+    /** MutationObserver that observes the "lang" attribute of the <html> element. */
+    private static readonly _observer;
+    private static readonly _observerConfig;
+    /** Get the current language. */
+    static get current(): string;
+    /** Get the current language. */
+    get current(): string;
+    private _previousLanguage?;
+    private _handlers;
+    constructor(_host: ReactiveControllerHost);
+    /** Add a language change handler. */
+    withHandler(handler: () => void): this;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private _callHandlers;
+}
+//# sourceMappingURL=language-controller.d.ts.map

package/development/core/controllers/language-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/language-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAKrF;;;;;;;GAOG;AACH,qBAAa,qBAAsB,YAAW,kBAAkB;IA0C3C,OAAO,CAAC,KAAK;IAzChC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IAChD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAA4B;IAErE,gFAAgF;IAChF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAoC;IAEtE,iFAAiF;IACjF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAI9B;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAGrC;IAEF,gCAAgC;IAChC,WAAkB,OAAO,IAAI,MAAM,CAalC;IAED,gCAAgC;IAChC,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,OAAO,CAAC,iBAAiB,CAAC,CAAS;IACnC,OAAO,CAAC,SAAS,CAAsB;gBAEZ,KAAK,EAAE,sBAAsB;IAIxD,qCAAqC;IAC9B,WAAW,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI;IAOtC,aAAa,IAAI,IAAI;IAcrB,gBAAgB,IAAI,IAAI;IAQ/B,OAAO,CAAC,aAAa;CAMtB"}

package/development/core/controllers/slot-state-controller.d.ts

@@ -0,0 +1,32 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+
+/**
+ * This controller checks for slotted children. From these it generates
+ * a list of used slot names (`unnamed` for children without a slot attribute)
+ * and adds this to the `data-slot-names` attribute, as a space separated list.
+ *
+ * This allows CSS attribute selector to display/hide/configure a section
+ * of the component as required (see [attr~=value] selector specifically).
+ *
+ * @example
+ * .example {
+ *   display: none;
+ *
+ *   :host([data-slot-names~="icon"]) & {
+ *     display: inline;
+ *   }
+ * }
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors
+ */
+export declare class SbbSlotStateController implements ReactiveController {
+    private _host;
+    private _onChangeCallback;
+    readonly slots: Set<string>;
+    private _slotchangeHandler;
+    constructor(_host: ReactiveControllerHost & HTMLElement, _onChangeCallback?: (() => void) | null);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private _syncSlots;
+}
+//# sourceMappingURL=slot-state-controller.d.ts.map

package/development/core/controllers/slot-state-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-state-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/slot-state-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAEtE;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IAU7D,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,iBAAiB;IAV3B,SAAgB,KAAK,cAAqB;IAI1C,OAAO,CAAC,kBAAkB,CAExB;gBAGQ,KAAK,EAAE,sBAAsB,GAAG,WAAW,EAC3C,iBAAiB,GAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAW;IAKhD,aAAa,IAAI,IAAI;IAMrB,gBAAgB,IAAI,IAAI;IAI/B,OAAO,CAAC,UAAU;CAuBnB"}

package/development/core/controllers.d.ts

@@ -0,0 +1,4 @@
+export * from './controllers/connected-abort-controller.js';
+export * from './controllers/language-controller.js';
+export * from './controllers/slot-state-controller.js';
+//# sourceMappingURL=controllers.d.ts.map

package/development/core/controllers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA,cAAc,6CAA6C,CAAC;AAC5D,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC"}

package/development/core/controllers.js

@@ -0,0 +1,134 @@
+import { isServer } from "lit";
+import { readConfig } from "./config.js";
+import { AgnosticMutationObserver } from "./observers.js";
+class SbbConnectedAbortController {
+  constructor(_host) {
+    this._host = _host;
+    this._abortController = new AbortController();
+    this._host.addController(this);
+  }
+  get signal() {
+    var _a;
+    return (_a = this._abortController) == null ? void 0 : _a.signal;
+  }
+  hostConnected() {
+    if (!this._abortController) {
+      this._abortController = new AbortController();
+    }
+  }
+  hostDisconnected() {
+    var _a;
+    (_a = this._abortController) == null ? void 0 : _a.abort();
+    this._abortController = void 0;
+  }
+}
+const _SbbLanguageController = class _SbbLanguageController {
+  constructor(_host) {
+    this._host = _host;
+    this._handlers = [];
+    this._host.addController(this);
+  }
+  /** Get the current language. */
+  static get current() {
+    const language = (readConfig().language ?? (isServer ? _SbbLanguageController._defaultLanguage : document.documentElement.getAttribute("lang"))) || _SbbLanguageController._defaultLanguage;
+    const langAttributeNormalized = language.split("-")[0];
+    return _SbbLanguageController._supportedLocales.includes(langAttributeNormalized) ? langAttributeNormalized : _SbbLanguageController._defaultLanguage;
+  }
+  /** Get the current language. */
+  get current() {
+    return _SbbLanguageController.current;
+  }
+  /** Add a language change handler. */
+  withHandler(handler) {
+    this._handlers.unshift(handler);
+    return this;
+  }
+  hostConnected() {
+    if (!_SbbLanguageController._listeners.size) {
+      _SbbLanguageController._observer.observe(
+        document.documentElement,
+        _SbbLanguageController._observerConfig
+      );
+    }
+    _SbbLanguageController._listeners.add(this);
+    if (this._previousLanguage !== this.current) {
+      this._callHandlers(this._previousLanguage !== void 0);
+    }
+  }
+  hostDisconnected() {
+    this._previousLanguage = this.current;
+    _SbbLanguageController._listeners.delete(this);
+    if (!_SbbLanguageController._listeners.size) {
+      _SbbLanguageController._observer.disconnect();
+    }
+  }
+  _callHandlers(requestUpdate = true) {
+    this._handlers.forEach((h) => h());
+    if (requestUpdate) {
+      this._host.requestUpdate();
+    }
+  }
+};
+_SbbLanguageController._defaultLanguage = "en";
+_SbbLanguageController._supportedLocales = ["en", "de", "fr", "it"];
+_SbbLanguageController._listeners = /* @__PURE__ */ new Set();
+_SbbLanguageController._observer = new AgnosticMutationObserver((mutations) => {
+  if (mutations[0].oldValue !== document.documentElement.getAttribute("lang")) {
+    _SbbLanguageController._listeners.forEach((l) => l._callHandlers());
+  }
+});
+_SbbLanguageController._observerConfig = {
+  attributeFilter: ["lang"],
+  attributeOldValue: true
+};
+let SbbLanguageController = _SbbLanguageController;
+class SbbSlotStateController {
+  constructor(_host, _onChangeCallback = null) {
+    this._host = _host;
+    this._onChangeCallback = _onChangeCallback;
+    this.slots = /* @__PURE__ */ new Set();
+    this._slotchangeHandler = (event) => {
+      this._syncSlots(event.target);
+    };
+    this._host.addController(this);
+  }
+  hostConnected() {
+    var _a;
+    this._syncSlots(...this._host.querySelectorAll("slot"));
+    (_a = this._host.shadowRoot) == null ? void 0 : _a.addEventListener("slotchange", this._slotchangeHandler);
+  }
+  hostDisconnected() {
+    var _a;
+    (_a = this._host.shadowRoot) == null ? void 0 : _a.removeEventListener("slotchange", this._slotchangeHandler);
+  }
+  _syncSlots(...slots) {
+    var _a;
+    for (const slot of slots) {
+      const slotName = slot.name || "unnamed";
+      if (slot.assignedNodes().some((n) => {
+        var _a2;
+        return "tagName" in n || ((_a2 = n.textContent) == null ? void 0 : _a2.trim());
+      })) {
+        this.slots.add(slotName);
+      } else {
+        this.slots.delete(slotName);
+      }
+    }
+    const oldValue = this._host.getAttribute("data-slot-names");
+    const joinedSlotNames = [...this.slots].sort().join(" ");
+    if (!joinedSlotNames) {
+      this._host.removeAttribute("data-slot-names");
+    } else if (this._host.getAttribute("data-slot-names") !== joinedSlotNames) {
+      this._host.setAttribute("data-slot-names", joinedSlotNames);
+    }
+    if (joinedSlotNames !== oldValue) {
+      (_a = this._onChangeCallback) == null ? void 0 : _a.call(this);
+    }
+  }
+}
+export {
+  SbbConnectedAbortController,
+  SbbLanguageController,
+  SbbSlotStateController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"controllers.js","sources":["../../../../src/elements/core/controllers/connected-abort-controller.ts","../../../../src/elements/core/controllers/language-controller.ts","../../../../src/elements/core/controllers/slot-state-controller.ts"],"sourcesContent":["import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nexport class SbbConnectedAbortController implements ReactiveController {\n  private _abortController?: AbortController = new AbortController();\n\n  public get signal(): AbortSignal | undefined {\n    return this._abortController?.signal;\n  }\n\n  public constructor(private _host: ReactiveControllerHost) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    if (!this._abortController) {\n      this._abortController = new AbortController();\n    }\n  }\n\n  public hostDisconnected(): void {\n    this._abortController?.abort();\n    this._abortController = undefined;\n  }\n}\n","import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nimport { readConfig } from '../config.js';\nimport { AgnosticMutationObserver } from '../observers.js';\n\n/**\n * The LanguageController is a reactive controller that observes the \"lang\" attribute\n * of the <html> tag.\n * On change of the \"lang\" attribute, it will request an update of connected\n * components.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang\n */\nexport class SbbLanguageController implements ReactiveController {\n  private static readonly _defaultLanguage = 'en';\n  private static readonly _supportedLocales = ['en', 'de', 'fr', 'it'];\n\n  /** A set of connected components that should be notified on language change. */\n  private static readonly _listeners = new Set<SbbLanguageController>();\n\n  /** MutationObserver that observes the \"lang\" attribute of the <html> element. */\n  private static readonly _observer = new AgnosticMutationObserver((mutations) => {\n    if (mutations[0].oldValue !== document.documentElement.getAttribute('lang')) {\n      SbbLanguageController._listeners.forEach((l) => l._callHandlers());\n    }\n  });\n  private static readonly _observerConfig = {\n    attributeFilter: ['lang'],\n    attributeOldValue: true,\n  };\n\n  /** Get the current language. */\n  public static get current(): string {\n    const language =\n      (readConfig().language ??\n        (isServer\n          ? SbbLanguageController._defaultLanguage\n          : document.documentElement.getAttribute('lang'))) ||\n      SbbLanguageController._defaultLanguage;\n\n    // Support e.g. cases like `de-ch`.\n    const langAttributeNormalized = language.split('-')[0];\n    return SbbLanguageController._supportedLocales.includes(langAttributeNormalized)\n      ? langAttributeNormalized\n      : SbbLanguageController._defaultLanguage;\n  }\n\n  /** Get the current language. */\n  public get current(): string {\n    return SbbLanguageController.current;\n  }\n\n  private _previousLanguage?: string;\n  private _handlers: (() => void)[] = [];\n\n  public constructor(private _host: ReactiveControllerHost) {\n    this._host.addController(this);\n  }\n\n  /** Add a language change handler. */\n  public withHandler(handler: () => void): this {\n    // We use unshift here, to prepend additional handlers.\n    // This ensures that requestUpdate is called after the other handlers.\n    this._handlers.unshift(handler);\n    return this;\n  }\n\n  public hostConnected(): void {\n    if (!SbbLanguageController._listeners.size) {\n      SbbLanguageController._observer.observe(\n        document.documentElement,\n        SbbLanguageController._observerConfig,\n      );\n    }\n\n    SbbLanguageController._listeners.add(this);\n    if (this._previousLanguage !== this.current) {\n      this._callHandlers(this._previousLanguage !== undefined);\n    }\n  }\n\n  public hostDisconnected(): void {\n    this._previousLanguage = this.current;\n    SbbLanguageController._listeners.delete(this);\n    if (!SbbLanguageController._listeners.size) {\n      SbbLanguageController._observer.disconnect();\n    }\n  }\n\n  private _callHandlers(requestUpdate = true): void {\n    this._handlers.forEach((h) => h());\n    if (requestUpdate) {\n      this._host.requestUpdate();\n    }\n  }\n}\n","import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\n/**\n * This controller checks for slotted children. From these it generates\n * a list of used slot names (`unnamed` for children without a slot attribute)\n * and adds this to the `data-slot-names` attribute, as a space separated list.\n *\n * This allows CSS attribute selector to display/hide/configure a section\n * of the component as required (see [attr~=value] selector specifically).\n *\n * @example\n * .example {\n *   display: none;\n *\n *   :host([data-slot-names~=\"icon\"]) & {\n *     display: inline;\n *   }\n * }\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors\n */\nexport class SbbSlotStateController implements ReactiveController {\n  public readonly slots = new Set<string>();\n\n  // We avoid using AbortController here, as it would mean creating\n  // a new instance for every NamedSlotStateController instance.\n  private _slotchangeHandler = (event: Event): void => {\n    this._syncSlots(event.target as HTMLSlotElement);\n  };\n\n  public constructor(\n    private _host: ReactiveControllerHost & HTMLElement,\n    private _onChangeCallback: (() => void) | null = null,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    // TODO: Check if this is really needed with SSR.\n    this._syncSlots(...this._host.querySelectorAll!('slot'));\n    this._host.shadowRoot?.addEventListener('slotchange', this._slotchangeHandler);\n  }\n\n  public hostDisconnected(): void {\n    this._host.shadowRoot?.removeEventListener('slotchange', this._slotchangeHandler);\n  }\n\n  private _syncSlots(...slots: HTMLSlotElement[]): void {\n    for (const slot of slots) {\n      const slotName = slot.name || 'unnamed';\n      // We want to check, whether an element is slotted or a text node with actual content.\n      if (slot.assignedNodes().some((n) => 'tagName' in n || n.textContent?.trim())) {\n        this.slots.add(slotName);\n      } else {\n        this.slots.delete(slotName);\n      }\n    }\n\n    const oldValue = this._host.getAttribute('data-slot-names');\n    const joinedSlotNames = [...this.slots].sort().join(' ');\n    if (!joinedSlotNames) {\n      this._host.removeAttribute('data-slot-names');\n    } else if (this._host.getAttribute('data-slot-names') !== joinedSlotNames) {\n      this._host.setAttribute('data-slot-names', joinedSlotNames);\n    }\n\n    if (joinedSlotNames !== oldValue) {\n      this._onChangeCallback?.();\n    }\n  }\n}\n"],"names":["_a"],"mappings":";;;AAEO,MAAM,4BAA0D;AAAA,EAO9D,YAAoB,OAA+B;AAA/B,SAAA,QAAA;AANnB,SAAA,mBAAqC,IAAI;AAO1C,SAAA,MAAM,cAAc,IAAI;AAAA,EAC/B;AAAA,EANA,IAAW,SAAkC;;AAC3C,YAAO,UAAK,qBAAL,mBAAuB;AAAA,EAChC;AAAA,EAMO,gBAAsB;AACvB,QAAA,CAAC,KAAK,kBAAkB;AACrB,WAAA,mBAAmB,IAAI;IAC9B;AAAA,EACF;AAAA,EAEO,mBAAyB;;AAC9B,eAAK,qBAAL,mBAAuB;AACvB,SAAK,mBAAmB;AAAA,EAC1B;AACF;ACVO,MAAM,yBAAN,MAAM,uBAAoD;AAAA,EA0CxD,YAAoB,OAA+B;AAA/B,SAAA,QAAA;AAF3B,SAAQ,YAA4B;AAG7B,SAAA,MAAM,cAAc,IAAI;AAAA,EAC/B;AAAA;AAAA,EAzBA,WAAkB,UAAkB;AAClC,UAAM,YACH,WAAA,EAAa,aACX,WACG,uBAAsB,mBACtB,SAAS,gBAAgB,aAAa,MAAM,OAClD,uBAAsB;AAGxB,UAAM,0BAA0B,SAAS,MAAM,GAAG,EAAE,CAAC;AACrD,WAAO,uBAAsB,kBAAkB,SAAS,uBAAuB,IAC3E,0BACA,uBAAsB;AAAA,EAC5B;AAAA;AAAA,EAGA,IAAW,UAAkB;AAC3B,WAAO,uBAAsB;AAAA,EAC/B;AAAA;AAAA,EAUO,YAAY,SAA2B;AAGvC,SAAA,UAAU,QAAQ,OAAO;AACvB,WAAA;AAAA,EACT;AAAA,EAEO,gBAAsB;AACvB,QAAA,CAAC,uBAAsB,WAAW,MAAM;AAC1C,6BAAsB,UAAU;AAAA,QAC9B,SAAS;AAAA,QACT,uBAAsB;AAAA,MAAA;AAAA,IAE1B;AAEsB,2BAAA,WAAW,IAAI,IAAI;AACrC,QAAA,KAAK,sBAAsB,KAAK,SAAS;AACtC,WAAA,cAAc,KAAK,sBAAsB,MAAS;AAAA,IACzD;AAAA,EACF;AAAA,EAEO,mBAAyB;AAC9B,SAAK,oBAAoB,KAAK;AACR,2BAAA,WAAW,OAAO,IAAI;AACxC,QAAA,CAAC,uBAAsB,WAAW,MAAM;AAC1C,6BAAsB,UAAU;IAClC;AAAA,EACF;AAAA,EAEQ,cAAc,gBAAgB,MAAY;AAChD,SAAK,UAAU,QAAQ,CAAC,MAAM,EAAG,CAAA;AACjC,QAAI,eAAe;AACjB,WAAK,MAAM;IACb;AAAA,EACF;AACF;AAjFE,uBAAwB,mBAAmB;AAC3C,uBAAwB,oBAAoB,CAAC,MAAM,MAAM,MAAM,IAAI;AAG3C,uBAAA,iCAAiB;AAGzC,uBAAwB,YAAY,IAAI,yBAAyB,CAAC,cAAc;AAC1E,MAAA,UAAU,CAAC,EAAE,aAAa,SAAS,gBAAgB,aAAa,MAAM,GAAG;AAC3E,2BAAsB,WAAW,QAAQ,CAAC,MAAM,EAAE,eAAe;AAAA,EACnE;AAAA,CACD;AACD,uBAAwB,kBAAkB;AAAA,EACxC,iBAAiB,CAAC,MAAM;AAAA,EACxB,mBAAmB;AAAA;AAfhB,IAAM,wBAAN;ACQA,MAAM,uBAAqD;AAAA,EASzD,YACG,OACA,oBAAyC,MACjD;AAFQ,SAAA,QAAA;AACA,SAAA,oBAAA;AAVM,SAAA,4BAAY;AAIpB,SAAA,qBAAqB,CAAC,UAAuB;AAC9C,WAAA,WAAW,MAAM,MAAyB;AAAA,IAAA;AAO1C,SAAA,MAAM,cAAc,IAAI;AAAA,EAC/B;AAAA,EAEO,gBAAsB;;AAE3B,SAAK,WAAW,GAAG,KAAK,MAAM,iBAAkB,MAAM,CAAC;AACvD,eAAK,MAAM,eAAX,mBAAuB,iBAAiB,cAAc,KAAK;AAAA,EAC7D;AAAA,EAEO,mBAAyB;;AAC9B,eAAK,MAAM,eAAX,mBAAuB,oBAAoB,cAAc,KAAK;AAAA,EAChE;AAAA,EAEQ,cAAc,OAAgC;;AACpD,eAAW,QAAQ,OAAO;AAClB,YAAA,WAAW,KAAK,QAAQ;AAE9B,UAAI,KAAK,gBAAgB,KAAK,CAAC,MAAA;;AAAM,4BAAa,OAAKA,MAAA,EAAE,gBAAF,gBAAAA,IAAe;AAAA,OAAM,GAAG;AACxE,aAAA,MAAM,IAAI,QAAQ;AAAA,MAAA,OAClB;AACA,aAAA,MAAM,OAAO,QAAQ;AAAA,MAC5B;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,MAAM,aAAa,iBAAiB;AACpD,UAAA,kBAAkB,CAAC,GAAG,KAAK,KAAK,EAAE,KAAO,EAAA,KAAK,GAAG;AACvD,QAAI,CAAC,iBAAiB;AACf,WAAA,MAAM,gBAAgB,iBAAiB;AAAA,IAAA,WACnC,KAAK,MAAM,aAAa,iBAAiB,MAAM,iBAAiB;AACpE,WAAA,MAAM,aAAa,mBAAmB,eAAe;AAAA,IAC5D;AAEA,QAAI,oBAAoB,UAAU;AAChC,iBAAK,sBAAL;AAAA,IACF;AAAA,EACF;AACF;"}