@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771859294

package/core/a11y/input-modality-detector.js

@@ -0,0 +1,47 @@
+import { isServer as s } from "lit";
+import { getEventTarget as n } from "../eventing.js";
+import { isFakeMousedownFromScreenReader as i, isFakeTouchstartFromScreenReader as a } from "./fake-event-detection.js";
+const r = 16, c = 17, u = 18, d = 91, m = 224, h = {
+  ignoreKeys: [u, c, m, d, r]
+}, l = 650, o = {
+  passive: !0,
+  capture: !0
+};
+class _ {
+  /** The most recently detected input modality. */
+  get mostRecentModality() {
+    return this._mostRecentModality;
+  }
+  /**
+   * The most recently detected input modality event target. Is null if no input modality has been
+   * detected or if the associated event target is null for some unknown reason.
+   */
+  get mostRecentTarget() {
+    return this._mostRecentTarget;
+  }
+  constructor() {
+    this._mostRecentModality = "mouse", this._mostRecentTarget = null, this._options = {
+      ...h
+    }, this._lastTouchMs = 0, this._onKeydown = (t) => {
+      this._options?.ignoreKeys?.some((e) => e === t.keyCode) || this._updateState("keyboard", t);
+    }, this._onMousedown = (t) => {
+      Date.now() - this._lastTouchMs < l || this._updateState(i(t) ? "keyboard" : "mouse", t);
+    }, this._onTouchstart = (t) => {
+      if (a(t)) {
+        this._updateState("keyboard", t);
+        return;
+      }
+      this._lastTouchMs = Date.now(), this._updateState("touch", t);
+    }, s || (document.addEventListener("keydown", this._onKeydown, o), document.addEventListener("mousedown", this._onMousedown, o), document.addEventListener("touchstart", this._onTouchstart, o));
+  }
+  reset() {
+    this._updateState("mouse", null), this._lastTouchMs = 0;
+  }
+  _updateState(t, e) {
+    this._mostRecentModality && document.documentElement.classList.remove(`sbb-focus-modality-${this._mostRecentModality}`), this._mostRecentModality = t, this._mostRecentTarget = e ? n(e) : null, document.documentElement.classList.add(`sbb-focus-modality-${this._mostRecentModality}`);
+  }
+}
+const R = new _();
+export {
+  R as sbbInputModalityDetector
+};

package/core/a11y/interactivity-checker.js

@@ -0,0 +1,96 @@
+import { isServer as s } from "lit";
+import { isWebkit as a, isIOS as o, isFirefox as u } from "../dom/platform.js";
+class A {
+  constructor() {
+    this.ignoreVisibility = !1;
+  }
+}
+class b {
+  /**
+   * Gets whether an element is disabled.
+   *
+   * @param element Element to be checked.
+   * @returns Whether the element is disabled.
+   */
+  isDisabled(i) {
+    return i.hasAttribute("disabled") || i.matches(":disabled");
+  }
+  /**
+   * Gets whether an element is visible for the purposes of interactivity.
+   *
+   * This will capture states like `display: none` and `visibility: hidden`, but not things like
+   * being clipped by an `overflow: hidden` parent or being outside the viewport.
+   *
+   * @returns Whether the element is visible.
+   */
+  isVisible(i) {
+    return f(i) && getComputedStyle(i).visibility === "visible";
+  }
+  /**
+   * Gets whether an element can be reached via Tab key.
+   * Assumes that the element has already been checked with isFocusable.
+   *
+   * @param element Element to be checked.
+   * @returns Whether the element is tabbable.
+   */
+  isTabbable(i) {
+    if (s)
+      return !1;
+    const r = i.nodeName.toLowerCase(), e = x(i);
+    return i.hasAttribute("contenteditable") ? e !== -1 : r === "iframe" || r === "object" || a && o && !I(i) ? !1 : r === "audio" ? i.hasAttribute("controls") ? e !== -1 : !1 : r === "video" ? e === -1 ? !1 : e !== null ? !0 : u || i.hasAttribute("controls") : i.tabIndex >= 0;
+  }
+  /**
+   * Gets whether an element can be focused by the user.
+   *
+   * @param element Element to be checked.
+   * @param config The config object with options to customize this method's behavior
+   * @returns Whether the element is focusable.
+   */
+  isFocusable(i, r) {
+    return y(i) && !i.inert && !this.isDisabled(i) && (r?.ignoreVisibility || this.isVisible(i));
+  }
+}
+const C = new b();
+function f(t) {
+  return !!(t.offsetWidth || t.offsetHeight || typeof t.getClientRects == "function" && t.getClientRects().length);
+}
+function c(t) {
+  const i = t.nodeName.toLowerCase();
+  return i === "input" || i === "select" || i === "button" || i === "textarea";
+}
+function d(t) {
+  return h(t) && t.type == "hidden";
+}
+function l(t) {
+  return p(t) && t.hasAttribute("href");
+}
+function h(t) {
+  return t.nodeName.toLowerCase() == "input";
+}
+function p(t) {
+  return t.nodeName.toLowerCase() == "a";
+}
+function n(t) {
+  if (!t.hasAttribute("tabindex") || t.tabIndex === void 0)
+    return !1;
+  const i = t.getAttribute("tabindex");
+  return !!(i && !isNaN(parseInt(i, 10)));
+}
+function x(t) {
+  if (!n(t))
+    return null;
+  const i = parseInt(t.getAttribute("tabindex") || "", 10);
+  return isNaN(i) ? -1 : i;
+}
+function I(t) {
+  const i = t.nodeName.toLowerCase(), r = i === "input" && t.type;
+  return r === "text" || r === "password" || i === "select" || i === "textarea";
+}
+function y(t) {
+  return d(t) ? !1 : c(t) || l(t) || t.hasAttribute("contenteditable") || n(t);
+}
+export {
+  b as InteractivityChecker,
+  A as IsFocusableConfig,
+  C as interactivityChecker
+};

package/core/a11y/live-announcer.js

@@ -0,0 +1,40 @@
+import { isServer as o } from "lit";
+let l = 0;
+class u {
+  constructor() {
+    o || (document.body ? this._liveElement = this._createLiveElement() : document.addEventListener("DOMContentLoaded", () => {
+      this._liveElement = this._createLiveElement();
+    }));
+  }
+  announce(n, ...t) {
+    if (!this._liveElement)
+      return Promise.resolve();
+    const e = {};
+    let i, s;
+    return t.length === 1 && typeof t[0] == "number" ? s = t[0] : [i, s] = t, this.clear(), clearTimeout(this._previousTimeout), i ??= e?.politeness ?? "polite", s ??= e?.duration, this._liveElement.setAttribute("aria-live", i), this._currentPromise ??= new Promise((r) => this._currentResolve = r), clearTimeout(this._previousTimeout), this._previousTimeout = setTimeout(() => {
+      this._liveElement.textContent = n, typeof s == "number" && (this._previousTimeout = setTimeout(() => this.clear(), s)), this._currentResolve?.(), this._currentPromise = this._currentResolve = void 0;
+    }, 100), this._currentPromise;
+  }
+  /**
+   * Clears the current text from the announcer element. Can be used to prevent
+   * screen readers from reading the text out again while the user is going
+   * through the page landmarks.
+   */
+  clear() {
+    this._liveElement && (this._liveElement.textContent = "");
+  }
+  destroy() {
+    clearTimeout(this._previousTimeout), this._liveElement?.remove(), this._liveElement = null, this._currentResolve?.(), this._currentPromise = this._currentResolve = void 0;
+  }
+  _createLiveElement() {
+    const n = "sbb-live-announcer-element", t = document.getElementsByClassName(n), e = document.createElement("div");
+    for (let i = 0; i < t.length; i++)
+      t[i].remove();
+    return e.classList.add(n), e.classList.add("sbb-screen-reader-only"), e.setAttribute("aria-atomic", "true"), e.setAttribute("aria-live", "polite"), e.id = `sbb-live-announcer-${l++}`, document.body.appendChild(e), e;
+  }
+}
+const v = new u();
+export {
+  u as SbbLiveAnnouncer,
+  v as sbbLiveAnnouncer
+};

package/core/a11y.js

@@ -0,0 +1,26 @@
+import { getNextElementIndex as o, isArrowKeyOrPageKeysPressed as t, isArrowKeyPressed as s, isNextArrowKeyPressed as i, isPreviousArrowKeyPressed as n } from "./a11y/arrow-navigation.js";
+import { isFakeMousedownFromScreenReader as b, isFakeTouchstartFromScreenReader as a } from "./a11y/fake-event-detection.js";
+import { SbbFocusVisibleWithinController as x } from "./a11y/focus-visible-within-controller.js";
+import { IS_FOCUSABLE_QUERY as d } from "./a11y/focus.js";
+import { SbbFocusTrapController as u } from "./a11y/focus-trap-controller.js";
+import { InteractivityChecker as y, IsFocusableConfig as F, interactivityChecker as A } from "./a11y/interactivity-checker.js";
+import { sbbInputModalityDetector as C } from "./a11y/input-modality-detector.js";
+import { SbbLiveAnnouncer as v, sbbLiveAnnouncer as w } from "./a11y/live-announcer.js";
+export {
+  d as IS_FOCUSABLE_QUERY,
+  y as InteractivityChecker,
+  F as IsFocusableConfig,
+  u as SbbFocusTrapController,
+  x as SbbFocusVisibleWithinController,
+  v as SbbLiveAnnouncer,
+  o as getNextElementIndex,
+  A as interactivityChecker,
+  t as isArrowKeyOrPageKeysPressed,
+  s as isArrowKeyPressed,
+  b as isFakeMousedownFromScreenReader,
+  a as isFakeTouchstartFromScreenReader,
+  i as isNextArrowKeyPressed,
+  n as isPreviousArrowKeyPressed,
+  C as sbbInputModalityDetector,
+  w as sbbLiveAnnouncer
+};

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

@@ -0,0 +1,39 @@
+import { LitElement as t, html as a } from "lit";
+import { SbbElementInternalsMixin as s } from "../mixins.js";
+class l extends s(t) {
+  get maybeDisabled() {
+    const e = this;
+    return e.disabled || e.formDisabled;
+  }
+  get maybeDisabledInteractive() {
+    return this.disabledInteractive;
+  }
+  constructor() {
+    super(), this.internals.states.add("action");
+  }
+  connectedCallback() {
+    super.connectedCallback();
+  }
+  setupBaseEventHandlers() {
+    this.addEventListener(
+      "click",
+      (e) => {
+        this.maybeDisabled && !this.maybeDisabledInteractive && (e.preventDefault(), e.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: !0 }
+    );
+  }
+  /** Override this method to render the component template. */
+  renderTemplate() {
+    throw new Error("Implementation needed!");
+  }
+  /** Default render method for button-like components. */
+  render() {
+    return a`<span class="sbb-action-base ${this.localName}">${this.renderTemplate()}</span>`;
+  }
+}
+export {
+  l as SbbActionBaseElement
+};

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

@@ -0,0 +1,146 @@
+var _ = (i) => {
+  throw TypeError(i);
+};
+var v = (i, a, n) => a.has(i) || _("Cannot " + n);
+var k = (i, a, n) => (v(i, a, "read from private field"), n ? n.call(i) : a.get(i)), E = (i, a, n) => a.has(i) ? _("Cannot add the same private member more than once") : a instanceof WeakSet ? a.add(i) : a.set(i, n), p = (i, a, n, l) => (v(i, a, "write to private field"), l ? l.call(i, n) : a.set(i, n), n);
+import { __esDecorate as d, __runInitializers as h } from "tslib";
+import { isServer as S } from "lit";
+import { property as f } from "lit/decorators.js";
+import { hostAttributes as g, forceType as C } from "../decorators.js";
+import { isEventPrevented as w } from "../eventing.js";
+import { SbbFormAssociatedMixin as K } from "../mixins.js";
+import { SbbActionBaseElement as O } from "./action-base-element.js";
+let I = (() => {
+  var o;
+  let i = [g({
+    tabindex: "0"
+  })], a, n = [], l, u = K(O);
+  return o = class extends u {
+    constructor() {
+      if (super(), this._preventScrollOnSpaceKeydown = (s) => {
+        s.key === " " && (s.preventDefault(), this.internals.states.add("active"));
+      }, this._removeActiveMarker = () => {
+        this.internals.states.delete("active");
+      }, this._dispatchClickEventOnSpaceKeyup = (s) => {
+        s.key === " " && (this._removeActiveMarker(), this._dispatchClickEvent(s));
+      }, this._dispatchClickEvent = (s) => {
+        const { altKey: r, ctrlKey: m, metaKey: y, shiftKey: t } = s;
+        s.target.dispatchEvent(new PointerEvent("click", {
+          bubbles: !0,
+          cancelable: !0,
+          composed: !0,
+          pointerId: -1,
+          pointerType: "",
+          altKey: r,
+          ctrlKey: m,
+          metaKey: y,
+          shiftKey: t
+        }));
+      }, this.internals.states.add("button"), !S) {
+        this.setupBaseEventHandlers();
+        const s = { passive: !0 };
+        this.addEventListener("keydown", this._preventScrollOnSpaceKeydown), this.addEventListener("keyup", this._dispatchClickEventOnSpaceKeyup, s), this.addEventListener("blur", this._removeActiveMarker, s), this.addEventListener("keypress", (r) => {
+          (r.key === "Enter" || r.key === `
+`) && this._dispatchClickEvent(r);
+        }, s);
+      }
+    }
+    attributeChangedCallback(s, r, m) {
+      (!["name", "value"].includes(s) || r !== m) && super.attributeChangedCallback(s, r, m);
+    }
+  }, l = o, (() => {
+    const s = typeof Symbol == "function" && Symbol.metadata ? Object.create(u[Symbol.metadata] ?? null) : void 0;
+    d(null, a = { value: l }, i, { kind: "class", name: l.name, metadata: s }, null, n), l = a.value, s && Object.defineProperty(l, Symbol.metadata, { enumerable: !0, configurable: !0, writable: !0, value: s });
+  })(), o.role = "button", h(l, n), l;
+})(), q = (() => {
+  var s, r;
+  let i = I, a = [], n, l = [], u = [], o, b;
+  return r = class extends i {
+    constructor() {
+      super();
+      E(this, s);
+      this._elementsOnWhichEnterPressTriggersSubmit = (h(this, a), [
+        "input",
+        "sbb-date-input",
+        "sbb-time-input"
+      ]), p(this, s, h(this, l, "")), this._formId = (h(this, u), ""), this._handleButtonClick = async (t) => {
+        if (this.type === "button" || await w(t))
+          return;
+        const e = this.form;
+        if (e)
+          this.type === "submit" ? this._requestSubmit(e) : this.type === "reset" && e.reset();
+        else return;
+      }, this._formKeyDown = (t) => {
+        const e = this.form;
+        this.type === "submit" && e && (t.key === "Enter" || t.key === `
+`) && this._elementsOnWhichEnterPressTriggersSubmit.includes(t.target?.localName) && t.isTrusted && (t.stopImmediatePropagation(), t.preventDefault(), t.composedPath()[0].dispatchEvent(new KeyboardEvent(t.type, t)) && !this.matches(":disabled") && this._requestSubmit(e));
+      }, this.addEventListener("click", this._handleButtonClick);
+    }
+    /** Value of the form element. */
+    get value() {
+      return k(this, s);
+    }
+    set value(t) {
+      p(this, s, t);
+    }
+    /**
+     * The type attribute to use for the button.
+     * @default 'button'
+     */
+    set type(t) {
+      this.setAttribute("type", `${t}`);
+    }
+    get type() {
+      return this.getAttribute("type") ?? "button";
+    }
+    /** The `<form>` element to associate the button with. */
+    set form(t) {
+      this._formId = t, this.form?.addEventListener("keydown", this._formKeyDown, { capture: !0 });
+    }
+    get form() {
+      return this._formId ? this.getRootNode?.()?.getElementById?.(this._formId) ?? null : this.internals.form;
+    }
+    connectedCallback() {
+      super.connectedCallback(), this.form?.addEventListener("keydown", this._formKeyDown, { capture: !0 });
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback(), this.form?.removeEventListener("keydown", this._formKeyDown, { capture: !0 });
+    }
+    _requestSubmit(t) {
+      const e = document.createElement("button");
+      e.inert = !0, e.hidden = !0, e.name = this.name, e.value = this.value ?? "", t.append(e), t.requestSubmit(e), e.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(t, e) {
+    }
+    /**
+     * 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() {
+    }
+  }, s = new WeakMap(), (() => {
+    const t = typeof Symbol == "function" && Symbol.metadata ? Object.create(i[Symbol.metadata] ?? null) : void 0;
+    n = [C(), f()], o = [f()], b = [f()], d(r, null, n, { kind: "accessor", name: "value", static: !1, private: !1, access: { has: (e) => "value" in e, get: (e) => e.value, set: (e, c) => {
+      e.value = c;
+    } }, metadata: t }, l, u), d(r, null, o, { kind: "setter", name: "type", static: !1, private: !1, access: { has: (e) => "type" in e, set: (e, c) => {
+      e.type = c;
+    } }, metadata: t }, null, a), d(r, null, b, { kind: "setter", name: "form", static: !1, private: !1, access: { has: (e) => "form" in e, set: (e, c) => {
+      e.form = c;
+    } }, metadata: t }, null, a), t && Object.defineProperty(r, Symbol.metadata, { enumerable: !0, configurable: !0, writable: !0, value: t });
+  })(), r;
+})();
+export {
+  q as SbbButtonBaseElement,
+  I as SbbButtonLikeBaseElement
+};

package/core/base-elements/link-base-element.js

@@ -0,0 +1,126 @@
+var H = (i) => {
+  throw TypeError(i);
+};
+var P = (i, s, a) => s.has(i) || H("Cannot " + a);
+var h = (i, s, a) => (P(i, s, "read from private field"), a ? a.call(i) : s.get(i)), d = (i, s, a) => s.has(i) ? H("Cannot add the same private member more than once") : s instanceof WeakSet ? s.add(i) : s.set(i, a), r = (i, s, a, v) => (P(i, s, "write to private field"), v ? v.call(i, a) : s.set(i, a), a);
+import { __esDecorate as m, __runInitializers as c } from "tslib";
+import { nothing as n, isServer as F, html as W } from "lit";
+import { property as p } from "lit/decorators.js";
+import { SbbLanguageController as G } from "../controllers.js";
+import { forceType as w, omitEmptyConverter as z } from "../decorators.js";
+import { i18nTargetOpensInNewWindow as J } from "../i18n.js";
+import { SbbActionBaseElement as K } from "./action-base-element.js";
+import "../../screen-reader-only.js";
+let te = (() => {
+  var u, b, _, f, y, g, l;
+  let i = K, s, a = [], v = [], C, $ = [], x = [], I, L = [], k = [], R, S = [], D = [], q, A = [], O = [], T, j = [], N = [];
+  return l = class extends i {
+    constructor() {
+      super();
+      d(this, u);
+      d(this, b);
+      d(this, _);
+      d(this, f);
+      d(this, y);
+      d(this, g);
+      r(this, u, c(this, a, "")), r(this, b, (c(this, v), c(this, $, ""))), r(this, _, (c(this, x), c(this, L, ""))), r(this, f, (c(this, k), c(this, S, !1))), r(this, y, (c(this, D), c(this, A, ""))), r(this, g, (c(this, O), c(this, j, ""))), this.language = (c(this, N), new G(this)), this.anchorRole = null, this._evaluateRelAttribute = () => this.rel ? this.rel : this.target === "_blank" ? "external noopener nofollow" : n, this.internals.states.add("link"), F || this.setupBaseEventHandlers();
+    }
+    /** The href value you want to link to. */
+    get href() {
+      return h(this, u);
+    }
+    set href(t) {
+      r(this, u, t);
+    }
+    /** Where to display the linked URL. */
+    get target() {
+      return h(this, b);
+    }
+    set target(t) {
+      r(this, b, t);
+    }
+    /** The relationship of the linked URL as space-separated link types. */
+    get rel() {
+      return h(this, _);
+    }
+    set rel(t) {
+      r(this, _, t);
+    }
+    /** Whether the browser will show the download dialog on click. */
+    get download() {
+      return h(this, f);
+    }
+    set download(t) {
+      r(this, f, t);
+    }
+    /** This will be forwarded as aria-label to the inner anchor element. */
+    get accessibilityLabel() {
+      return h(this, y);
+    }
+    set accessibilityLabel(t) {
+      r(this, y, t);
+    }
+    /** This will be forwarded as aria-current to the inner anchor element. */
+    get accessibilityCurrent() {
+      return h(this, g);
+    }
+    set accessibilityCurrent(t) {
+      r(this, g, t);
+    }
+    /** @internal */
+    focus(t) {
+      this.shadowRoot.querySelector("a")?.focus(t);
+    }
+    /** @internal */
+    blur() {
+      this.shadowRoot.querySelector("a")?.blur();
+    }
+    /** @internal */
+    click() {
+      this.shadowRoot.querySelector("a")?.click();
+    }
+    /** Default render method for link-like components. Can be overridden if the LinkRenderVariables are not needed. */
+    render() {
+      return this.renderLink(this.renderTemplate());
+    }
+    renderLink(t) {
+      return W`
+      <a
+        class="sbb-action-base ${this.localName}"
+        href=${this.href || n}
+        ?download=${this.download}
+        target=${this.target || n}
+        rel=${this._evaluateRelAttribute()}
+        role=${this.anchorRole || n}
+        aria-label=${this.accessibilityLabel || n}
+        aria-current=${this.accessibilityCurrent || n}
+        tabindex=${this.maybeDisabled && !this.maybeDisabledInteractive ? "-1" : n}
+        aria-disabled=${this.maybeDisabled ? "true" : n}
+      >
+        ${t}
+        ${this.href && this.target === "_blank" ? W`<sbb-screen-reader-only
+              >. ${J[this.language.current]}</sbb-screen-reader-only
+            >` : n}
+      </a>
+    `;
+    }
+  }, u = new WeakMap(), b = new WeakMap(), _ = new WeakMap(), f = new WeakMap(), y = new WeakMap(), g = new WeakMap(), (() => {
+    const t = typeof Symbol == "function" && Symbol.metadata ? Object.create(i[Symbol.metadata] ?? null) : void 0;
+    s = [w(), p({ reflect: !0, converter: z })], C = [w(), p({ reflect: !0, converter: z })], I = [w(), p({ reflect: !0, converter: z })], R = [w(), p({ type: Boolean, reflect: !0 })], q = [w(), p({ attribute: "accessibility-label" })], T = [w(), p({ attribute: "accessibility-current" })], m(l, null, s, { kind: "accessor", name: "href", static: !1, private: !1, access: { has: (e) => "href" in e, get: (e) => e.href, set: (e, o) => {
+      e.href = o;
+    } }, metadata: t }, a, v), m(l, null, C, { kind: "accessor", name: "target", static: !1, private: !1, access: { has: (e) => "target" in e, get: (e) => e.target, set: (e, o) => {
+      e.target = o;
+    } }, metadata: t }, $, x), m(l, null, I, { kind: "accessor", name: "rel", static: !1, private: !1, access: { has: (e) => "rel" in e, get: (e) => e.rel, set: (e, o) => {
+      e.rel = o;
+    } }, metadata: t }, L, k), m(l, null, R, { kind: "accessor", name: "download", static: !1, private: !1, access: { has: (e) => "download" in e, get: (e) => e.download, set: (e, o) => {
+      e.download = o;
+    } }, metadata: t }, S, D), m(l, null, q, { kind: "accessor", name: "accessibilityLabel", static: !1, private: !1, access: { has: (e) => "accessibilityLabel" in e, get: (e) => e.accessibilityLabel, set: (e, o) => {
+      e.accessibilityLabel = o;
+    } }, metadata: t }, A, O), m(l, null, T, { kind: "accessor", name: "accessibilityCurrent", static: !1, private: !1, access: { has: (e) => "accessibilityCurrent" in e, get: (e) => e.accessibilityCurrent, set: (e, o) => {
+      e.accessibilityCurrent = o;
+    } }, metadata: t }, j, N), t && Object.defineProperty(l, Symbol.metadata, { enumerable: !0, configurable: !0, writable: !0, value: t });
+  })(), l;
+})();
+export {
+  te as SbbLinkBaseElement
+};

package/core/base-elements/open-close-base-element.js

@@ -0,0 +1,44 @@
+import { LitElement as n } from "lit";
+import { SbbElementInternalsMixin as i } from "../mixins.js";
+const e = class e extends i(n) {
+  /** The state of the component. */
+  set state(s) {
+    this._state && this.internals.states.delete(`state-${this._state}`), this._state = s, this._state && this.internals.states.add(`state-${this._state}`);
+  }
+  get state() {
+    return this._state;
+  }
+  /** Whether the element is open. */
+  get isOpen() {
+    return this.state === "opened";
+  }
+  constructor() {
+    super(), this.state = "closed";
+  }
+  /** The method which is called on escape key press. Defaults to calling close() */
+  escapeStrategy() {
+    this.close();
+  }
+  dispatchBeforeOpenEvent() {
+    return this.dispatchEvent(new Event("beforeopen", { cancelable: !0 }));
+  }
+  dispatchOpenEvent() {
+    return this.dispatchEvent(new Event("open"));
+  }
+  dispatchBeforeCloseEvent() {
+    return this.dispatchEvent(new Event("beforeclose", { cancelable: !0 }));
+  }
+  dispatchCloseEvent() {
+    return this.dispatchEvent(new Event("close"));
+  }
+};
+e.events = {
+  beforeopen: "beforeopen",
+  open: "open",
+  beforeclose: "beforeclose",
+  close: "close"
+};
+let t = e;
+export {
+  t as SbbOpenCloseBaseElement
+};

package/core/base-elements.js

@@ -0,0 +1,11 @@
+import { SbbActionBaseElement as o } from "./base-elements/action-base-element.js";
+import { SbbButtonBaseElement as n, SbbButtonLikeBaseElement as m } from "./base-elements/button-base-element.js";
+import { SbbLinkBaseElement as B } from "./base-elements/link-base-element.js";
+import { SbbOpenCloseBaseElement as s } from "./base-elements/open-close-base-element.js";
+export {
+  o as SbbActionBaseElement,
+  n as SbbButtonBaseElement,
+  m as SbbButtonLikeBaseElement,
+  B as SbbLinkBaseElement,
+  s as SbbOpenCloseBaseElement
+};

package/core/config/config.js

@@ -0,0 +1,11 @@
+function o() {
+  return "sbbConfig" in globalThis || (globalThis.sbbConfig = {}), globalThis.sbbConfig;
+}
+function g(i) {
+  const n = o();
+  Object.assign(n, i);
+}
+export {
+  g as mergeConfig,
+  o as readConfig
+};

package/core/config.js

@@ -0,0 +1,5 @@
+import { mergeConfig as r, readConfig as f } from "./config/config.js";
+export {
+  r as mergeConfig,
+  f as readConfig
+};

package/core/controllers/escapable-overlay-controller.js

@@ -0,0 +1,27 @@
+import { isServer as i } from "lit";
+const o = new Array();
+i || window.addEventListener("keydown", (t) => {
+  t.key === "Escape" && !t.defaultPrevented && (t.preventDefault(), o.at(-1)?.escapeStrategy());
+});
+class c {
+  constructor(e, s = o) {
+    this._host = e, this._overlayStack = s, this._host.addController?.(this);
+  }
+  hostDisconnected() {
+    this.disconnect();
+  }
+  // This must be called when the overlay is opened
+  connect() {
+    this.disconnect(), this._overlayStack.push(this._host);
+  }
+  // This must be called when the overlay is closed
+  disconnect() {
+    if (this._overlayStack.length) {
+      const e = this._overlayStack.findIndex((s) => s === this._host);
+      e !== -1 && this._overlayStack.splice(e, 1);
+    }
+  }
+}
+export {
+  c as SbbEscapableOverlayController
+};