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

package/core/controllers/id-reference-controller.js

@@ -0,0 +1,60 @@
+import { isServer as d } from "lit";
+const h = /* @__PURE__ */ new WeakMap();
+class _ {
+  constructor(t, r, i = h) {
+    this._host = t, this._idRef = r, this._observers = i, this._rootNode = null, this._host.addController(this);
+  }
+  hostConnected() {
+    if (d)
+      return;
+    this._rootNode = this._host.getRootNode();
+    const t = this._observers.get(this._rootNode);
+    if (t)
+      t.controllers.add(this);
+    else {
+      const r = /* @__PURE__ */ new Set([this]), i = new MutationObserver((n) => {
+        const s = /* @__PURE__ */ new Set();
+        for (const e of n)
+          if (e.type === "attributes")
+            s.add(e.oldValue), s.add(e.target.id);
+          else if (e.type === "childList")
+            for (const o of [...e.addedNodes, ...e.removedNodes])
+              o instanceof HTMLElement && (s.add(o.id), o.querySelectorAll("[id]").forEach((l) => s.add(l.id)));
+        for (const e of r) {
+          const o = e._host[e._idRef];
+          o && typeof o == "string" && s.has(o) && e._host.requestUpdate();
+        }
+      });
+      i.observe(this._rootNode, {
+        attributeFilter: ["id"],
+        childList: !0,
+        subtree: !0,
+        attributeOldValue: !0
+      }), this._observers.set(this._rootNode, { observer: i, controllers: r });
+    }
+  }
+  hostDisconnected() {
+    if (d || !this._rootNode)
+      return;
+    const t = this._observers.get(this._rootNode);
+    if (!t) {
+      this._rootNode = null;
+      return;
+    }
+    t.controllers.delete(this), t.controllers.size === 0 && (t.observer.disconnect(), this._observers.delete(this._rootNode)), this._rootNode = null;
+  }
+  /**
+   * Find the element by id in the current document fragment
+   */
+  find() {
+    if (d || !this._rootNode)
+      return null;
+    {
+      const t = this._host[this._idRef];
+      return typeof t == "string" ? this._rootNode?.getElementById(t) : null;
+    }
+  }
+}
+export {
+  _ as SbbIdReferenceController
+};

package/core/controllers/inert-controller.js

@@ -0,0 +1,58 @@
+const r = ["script", "head", "template", "style"], n = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Set();
+class l {
+  constructor(t, e = n, s = h, i = a) {
+    this._host = t, this._inertElements = e, this._inertOverlays = s, this._exemptedElements = i, this._host.addController?.(this);
+  }
+  hostConnected() {
+    this._host.isOpen && this.activate();
+  }
+  hostDisconnected() {
+    this.isInert() && this.deactivate();
+  }
+  /** Applies inert state to every other element on the page except the overlay. */
+  activate() {
+    this._inertOverlays.size && this._removeAllInertAttributes(), this._inertOverlays.add(this._host), this._addAllInertAttributes();
+  }
+  /** Removes inert state. */
+  deactivate() {
+    if (this._currentOverlay() !== this._host) {
+      this._inertOverlays.has(this._host) && this._inertOverlays.delete(this._host);
+      return;
+    }
+    this._removeAllInertAttributes(), this._inertOverlays.delete(this._host), this._inertOverlays.size && this._addAllInertAttributes();
+  }
+  /** Whether the assigned host is currently inert */
+  isInert() {
+    return this._inertOverlays.has(this._host);
+  }
+  /** Temporarily removes all inert attributes from a given element. */
+  exempt(t) {
+    this._inertElements.has(t) && !this._exemptedElements.has(t) && (this._removeInertAttributes(t), this._inertElements.delete(t), this._exemptedElements.add(t));
+  }
+  /** Inerts an element currently exempted from inert. */
+  restoreAllExempted() {
+    this._exemptedElements.forEach((t) => this._addInertAttributes(t)), this._exemptedElements.clear();
+  }
+  _currentOverlay() {
+    return [...this._inertOverlays].pop() ?? null;
+  }
+  _removeAllInertAttributes() {
+    this._inertElements.forEach((t) => this._removeInertAttributes(t)), this._inertElements.clear();
+  }
+  _removeInertAttributes(t) {
+    t && (t.hasAttribute("data-sbb-inert") && (t.inert = !1, t.removeAttribute("data-sbb-inert")), t.hasAttribute("data-sbb-aria-hidden") && (t.removeAttribute("aria-hidden"), t.removeAttribute("data-sbb-aria-hidden")));
+  }
+  _addAllInertAttributes() {
+    let t = this._currentOverlay();
+    for (; t !== document.documentElement && t !== null; )
+      Array.from((t?.parentElement ?? t?.getRootNode())?.childNodes ?? []).filter((e) => e !== t && e instanceof window.HTMLElement && !r.includes(e.localName) && !e.classList.contains("sbb-live-announcer-element")).forEach((e) => {
+        this._addInertAttributes(e);
+      }), t = t?.parentElement ?? t?.getRootNode()?.host ?? null;
+  }
+  _addInertAttributes(t) {
+    this._inertElements.add(t), t.inert || (t.inert = !0, t.toggleAttribute("data-sbb-inert", !0)), t.hasAttribute("aria-hidden") || (t.setAttribute("aria-hidden", "true"), t.toggleAttribute("data-sbb-aria-hidden", !0));
+  }
+}
+export {
+  l as SbbInertController
+};

package/core/controllers/language-controller.js

@@ -0,0 +1,39 @@
+import { isServer as i } from "lit";
+import { readConfig as n } from "../config.js";
+const t = class t {
+  /** Get the current language. */
+  static get current() {
+    const s = ((n().language ?? (i ? t._defaultLanguage : document.documentElement.getAttribute("lang"))) || t._defaultLanguage).split("-")[0];
+    return t._supportedLocales.includes(s) ? s : t._defaultLanguage;
+  }
+  /** Get the current language. */
+  get current() {
+    return t.current;
+  }
+  constructor(e) {
+    this._host = e, this._handlers = [], this._host.addController(this);
+  }
+  /** Add a language change handler. */
+  withHandler(e) {
+    return this._handlers.unshift(e), this;
+  }
+  hostConnected() {
+    i || (t._listeners.size || t._observer.observe(document.documentElement, t._observerConfig), t._listeners.add(this), this._previousLanguage !== this.current && this._callHandlers(this._previousLanguage !== void 0));
+  }
+  hostDisconnected() {
+    i || (this._previousLanguage = this.current, t._listeners.delete(this), t._listeners.size || t._observer.disconnect());
+  }
+  _callHandlers(e = !0) {
+    this._handlers.forEach((s) => s()), e && this._host.requestUpdate();
+  }
+};
+t._defaultLanguage = "en", t._supportedLocales = ["en", "de", "fr", "it"], t._listeners = /* @__PURE__ */ new Set(), t._observer = i ? null : new MutationObserver((e) => {
+  e[0].oldValue !== document.documentElement.getAttribute("lang") && t._listeners.forEach((s) => s._callHandlers());
+}), t._observerConfig = {
+  attributeFilter: ["lang"],
+  attributeOldValue: !0
+};
+let r = t;
+export {
+  r as SbbLanguageController
+};

package/core/controllers/media-matchers-controller.js

@@ -0,0 +1,97 @@
+import { S as m, a as b, b as p, c as f, d as g, e as y } from "../../sbb-tokens-HiNSQasB.js";
+import { isServer as i } from "lit";
+import { ɵstateController as M } from "../mixins/element-internals-mixin.js";
+const L = "(forced-colors: active)", n = "(prefers-color-scheme: dark)", w = "(any-hover: hover)", A = "(pointer: coarse)", C = `(min-width: ${y})`, _ = `(min-width: ${p})`, q = `(min-width: ${m})`, U = `(min-width: ${g})`, x = `(max-width: ${f})`, E = `(max-width: ${b})`, a = /* @__PURE__ */ new Map();
+class S {
+  constructor(e, t) {
+    this._queries = t, e.addController(this);
+  }
+  /**
+   * Returns whether the given query matches. Returns null with SSR.
+   * @param query The query to check against.
+   * @returns Whether the query matches or null with SSR.
+   */
+  matches(e) {
+    return i ? null : matchMedia(e).matches;
+  }
+  hostConnected() {
+    if (!i)
+      for (const [e, t] of Object.entries(this._queries)) {
+        const r = a.get(e);
+        if (r)
+          r.handlers.add(t);
+        else {
+          const o = matchMedia(e), c = /* @__PURE__ */ new Set([t]), d = (l) => c.forEach((u) => u(l.matches));
+          o.addEventListener("change", d), a.set(e, { mediaQueryList: o, handlers: c, eventHandler: d });
+        }
+      }
+  }
+  hostDisconnected() {
+    for (const [e, t] of Object.entries(this._queries)) {
+      const r = a.get(e);
+      r && (r.handlers.delete(t), r.handlers.size || a.delete(e));
+    }
+  }
+}
+const s = class s extends S {
+  constructor(e, t) {
+    const r = () => {
+      t(this.matches()), M(this._host).toggle("dark", this.matches());
+    };
+    super(e, {
+      [n]: r
+    }), this._host = e, this._onChangeWithStateUpdater = r;
+  }
+  static _readLightDarkClass() {
+    if (i)
+      return null;
+    const e = document.documentElement.classList;
+    return ["sbb-light-dark", "sbb-dark", "sbb-light"].find((t) => e.contains(t)) ?? null;
+  }
+  /**
+   * Requests an update of the dark mode state. This is needed when the color-scheme
+   * CSS property changes, as the media query does not pick this up automatically.
+   */
+  // eslint-disable-next-line lyne/needs-super-call-rule
+  static requestUpdate() {
+    const e = a.get(n);
+    e && e.handlers.forEach((t) => t(e.mediaQueryList.matches));
+  }
+  hostConnected() {
+    const e = (a.get(n)?.handlers.size ?? 0) === 0;
+    super.hostConnected(), e && s._observer.observe(document.documentElement, s._observerConfig), this._onChangeWithStateUpdater();
+  }
+  hostDisconnected() {
+    super.hostDisconnected(), (a.get(n)?.handlers.size ?? 0) === 0 && s._observer.disconnect();
+  }
+  matches() {
+    if (i)
+      return !1;
+    const e = getComputedStyle(this._host).getPropertyValue("color-scheme"), t = e.includes("dark"), r = e.trim() === "dark";
+    return super.matches(n) && t || r;
+  }
+};
+s._currentMode = s._readLightDarkClass(), s._observer = i ? null : new MutationObserver((e) => {
+  if (e[0].oldValue !== document.documentElement.getAttribute("class")) {
+    const t = s._readLightDarkClass();
+    s._currentMode !== t && (s.requestUpdate(), s._currentMode = t);
+  }
+}), s._observerConfig = {
+  attributeFilter: ["class"],
+  attributeOldValue: !0
+};
+let h = s;
+export {
+  h as SbbDarkModeController,
+  S as SbbMediaMatcherController,
+  q as SbbMediaQueryBreakpointLargeAndAbove,
+  E as SbbMediaQueryBreakpointLargeAndBelow,
+  _ as SbbMediaQueryBreakpointSmallAndAbove,
+  x as SbbMediaQueryBreakpointSmallAndBelow,
+  U as SbbMediaQueryBreakpointUltraAndAbove,
+  C as SbbMediaQueryBreakpointZeroAndAbove,
+  n as SbbMediaQueryDarkMode,
+  L as SbbMediaQueryForcedColors,
+  w as SbbMediaQueryHover,
+  A as SbbMediaQueryPointerCoarse
+};

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

@@ -0,0 +1,224 @@
+import { isServer as k } from "lit";
+const m = !k && CSS.supports("anchor-name", "--test"), C = [
+  "block-start",
+  "block-end",
+  "inline-start",
+  "inline-end",
+  "block-start span-inline-start",
+  "block-start span-inline-end",
+  "block-end span-inline-start",
+  "block-end span-inline-end",
+  "inline-start span-block-start",
+  "inline-start span-block-end",
+  "inline-end span-block-start",
+  "inline-end span-block-end"
+], S = {
+  "block-start": "block-start",
+  "block-end": "block-end",
+  "inline-start": "inline-end",
+  "inline-end": "inline-start",
+  "block-start span-inline-start": "block-start span-inline-end",
+  "block-start span-inline-end": "block-start span-inline-start",
+  "block-end span-inline-start": "block-end span-inline-end",
+  "block-end span-inline-end": "block-end span-inline-start",
+  "inline-start span-block-start": "inline-end span-block-start",
+  "inline-start span-block-end": "inline-end span-block-end",
+  "inline-end span-block-start": "inline-start span-block-start",
+  "inline-end span-block-end": "inline-start span-block-end"
+};
+let O = 0;
+class W {
+  /** Get the current position. (e.g. block-end, block-start, etc.) */
+  get currentPosition() {
+    return this._usePolyfill ? this._lastPosition ?? this._positions[0] ?? "" : (this._overlayStyles ??= getComputedStyle(this._overlay), this._overlayStyles.getPropertyValue("position-area"));
+  }
+  constructor(e, t = !m) {
+    this._usePolyfill = t, this._resizeObserver = k ? null : new ResizeObserver(() => this._requestCalculatePosition()), this._anchorName = `--sbb-overlay-anchor-${++O}`, this._positions = [], e.addController(this), this._overlay = e;
+  }
+  hostConnected() {
+    this._usePolyfill ? this._overlay.style.setProperty("position-area", "initial") : this._overlay.style.setProperty("position-anchor", this._anchorName);
+  }
+  hostUpdate() {
+    k || this._readPositionsFromCss();
+  }
+  /**
+   * Connects the overlay to the given trigger element and determines the optimal position.
+   * Usually, this is called when the overlay is opened.
+   * @param anchor The anchor element.
+   */
+  connect(e) {
+    k || (this._anchor && this.disconnect(), this._anchor = e, this._usePolyfill || this._anchor.style.setProperty("anchor-name", this._anchorName), this._readPositionsFromCss(), this._calculatePosition(), this._abortController?.abort(), this._abortController = new AbortController(), document.addEventListener("scroll", () => this._requestCalculatePosition(), {
+      capture: !0,
+      passive: !0,
+      signal: this._abortController.signal
+    }), window.addEventListener("resize", () => this._requestCalculatePosition(), {
+      passive: !0,
+      signal: this._abortController.signal
+    }), this._resizeObserver.observe(e, { box: "border-box" }), this._resizeObserver.observe(this._overlay, { box: "border-box" }));
+  }
+  disconnect() {
+    this._anchor?.style.removeProperty("anchor-name"), this._anchor = void 0, this._abortController?.abort(), this._resizeObserver.disconnect();
+  }
+  _requestCalculatePosition() {
+    this._frame ??= requestAnimationFrame(() => {
+      this._calculatePosition(), this._frame = void 0;
+    });
+  }
+  _calculatePosition() {
+    if (this._anchor) {
+      if (this._usePolyfill) {
+        const e = this._getOptimalPosition(this._positions);
+        this._applyOverlayPosition(e.position, e.left, e.top);
+      }
+      this._overlay.setAttribute("data-position", this.currentPosition);
+    }
+  }
+  /**
+   * Calculates the optimal position that fits the overlay.
+   * @param positions The list of positions to check.
+   * @private
+   */
+  _getOptimalPosition(e) {
+    const { offsetHeight: t, offsetWidth: r } = this._overlay, { innerHeight: u, innerWidth: g } = window, { top: o, left: n, height: l, width: d } = this._anchor.getBoundingClientRect(), P = this._overlay.matches(":dir(rtl)"), a = o, c = u - l - o, p = n, h = g - d - n, b = r - d, y = t - l, f = b / 2, _ = y / 2;
+    this._overlay.style.setProperty("--sbb-overlay-controller-trigger-height", `${l}px`), this._overlay.style.setProperty("--sbb-overlay-controller-trigger-width", `${d}px`);
+    let s = { left: 0, top: 0, position: "" }, v;
+    for (const i of e) {
+      switch (P && C.includes(i) ? S[i] : i) {
+        default:
+        case "bottom":
+        case "block-end":
+          s = {
+            position: i,
+            left: n - f,
+            top: o + l,
+            fits: t <= c && f <= p && f <= h
+          };
+          break;
+        case "top":
+        case "block-start":
+          s = {
+            position: i,
+            left: n - f,
+            top: o - t,
+            fits: t <= a && f <= p && f <= h
+          };
+          break;
+        case "right":
+        case "inline-end":
+          s = {
+            position: i,
+            left: n + d,
+            top: o - _,
+            fits: r <= h && _ <= a && _ <= c
+          };
+          break;
+        case "left":
+        case "inline-start":
+          s = {
+            position: i,
+            left: n - r,
+            top: o - _,
+            fits: r <= p && _ <= a && _ <= c
+          };
+          break;
+        case "top span-left":
+        case "block-start span-inline-start":
+          s = {
+            position: i,
+            left: n - b,
+            top: o - t,
+            fits: t <= a && b <= p
+          };
+          break;
+        case "top span-right":
+        case "block-start span-inline-end":
+          s = {
+            position: i,
+            left: n,
+            top: o - t,
+            fits: t <= a && b <= h
+          };
+          break;
+        case "bottom span-left":
+        case "block-end span-inline-start":
+          s = {
+            position: i,
+            left: n - b,
+            top: o + l,
+            fits: t <= c && b <= p
+          };
+          break;
+        case "bottom span-right":
+        case "block-end span-inline-end":
+          s = {
+            position: i,
+            left: n,
+            top: o + l,
+            fits: t <= c && b <= h
+          };
+          break;
+        case "left span-top":
+        case "inline-start span-block-start":
+          s = {
+            position: i,
+            left: n - r,
+            top: o + l - t,
+            fits: r <= p && y <= a
+          };
+          break;
+        case "left span-bottom":
+        case "inline-start span-block-end":
+          s = {
+            position: i,
+            left: n - r,
+            top: o,
+            fits: r <= p && y <= c
+          };
+          break;
+        case "right span-top":
+        case "inline-end span-block-start":
+          s = {
+            position: i,
+            left: n + d,
+            top: o + l - t,
+            fits: r <= h && y <= a
+          };
+          break;
+        case "right span-bottom":
+        case "inline-end span-block-end":
+          s = {
+            position: i,
+            left: n + d,
+            top: o,
+            fits: r <= h && y <= c
+          };
+          break;
+      }
+      if (s.fits)
+        return s;
+      v ??= s;
+    }
+    return v;
+  }
+  _applyOverlayPosition(e, t, r) {
+    this._lastPosition = e, this._overlay.style.left = `${t}px`, this._overlay.style.top = `${r}px`;
+  }
+  /**
+   * Only used in polyfill mode.
+   * Reads the list of the configured positions from the CSS variables.
+   * @private
+   */
+  _readPositionsFromCss() {
+    if (!this._usePolyfill)
+      return;
+    this._overlayStyles ??= getComputedStyle(this._overlay);
+    const e = [
+      this._overlayStyles.getPropertyValue("--sbb-overlay-position-area") || "block-end",
+      ...this._overlayStyles.getPropertyValue("--sbb-overlay-position-try-fallbacks").split(",").map((t) => t.trim()).filter((t) => !!t)
+    ];
+    this._positions = e, this._lastPosition && !this._positions.includes(this._lastPosition) && (this._lastPosition = void 0);
+  }
+}
+export {
+  W as SbbOverlayPositionController
+};

package/core/controllers/property-watcher-controller.js

@@ -0,0 +1,60 @@
+import { isServer as n } from "lit";
+class l {
+  get size() {
+    return this._handlers.size;
+  }
+  constructor(e, t) {
+    this._host = e, this._property = t, this._handlers = /* @__PURE__ */ new Set(), this._hostDefinedPromise = null, n || (customElements.get(this._host.localName) ? customElements.upgrade(this._host) : this._hostDefinedPromise = customElements.whenDefined(this._host.localName).then(() => {
+      customElements.upgrade(this._host), this._hostDefinedPromise = null;
+    })), this._value = this._host[this._property];
+  }
+  addHandler(e) {
+    this._handlers.size || (this._host.addController ? this._host.addController(this) : this._hostDefinedPromise && this._hostDefinedPromise.then(() => this._host.addController(this))), this._handlers.add(e), this._hostDefinedPromise ? this._hostDefinedPromise.then(() => e(this._host)) : e(this._host);
+  }
+  removeHandler(e) {
+    this._handlers.delete(e), this._handlers.size || (this._host.removeController ? this._host.removeController(this) : this._hostDefinedPromise && this._hostDefinedPromise.then(() => this._host.removeController(this)));
+  }
+  hostUpdate() {
+    const e = this._host[this._property];
+    if (this._value !== e) {
+      this._value = e;
+      for (const t of this._handlers)
+        t(this._host);
+    }
+  }
+}
+const h = /* @__PURE__ */ new WeakMap();
+class c {
+  constructor(e, t, s) {
+    this._host = e, this._referenceResolver = t, this._handlers = s, this._host.addController(this);
+  }
+  hostConnected() {
+    this.connect();
+  }
+  hostDisconnected() {
+    this._reference !== this._referenceResolver() && this.disconnect();
+  }
+  connect() {
+    const e = this._referenceResolver();
+    if (this._reference === e || (this.disconnect(), this._reference = e, !this._reference))
+      return;
+    let t = h.get(this._reference);
+    t || (t = /* @__PURE__ */ new Map(), h.set(this._reference, t)), this._watchers = t;
+    for (const [s, o] of Object.entries(this._handlers)) {
+      let r = this._watchers.get(s);
+      r || (r = new l(this._reference, s), this._watchers.set(s, r)), r.addHandler(o);
+    }
+  }
+  disconnect() {
+    if (this._reference) {
+      for (const [e, t] of Object.entries(this._handlers)) {
+        const s = this._watchers?.get(e);
+        s && (s.removeHandler(t), s.size || (this._watchers.delete(e), !this._watchers.size && this._reference && h.delete(this._reference)));
+      }
+      this._reference = null;
+    }
+  }
+}
+export {
+  c as SbbPropertyWatcherController
+};

package/core/controllers/slot-state-controller.js

@@ -0,0 +1,37 @@
+import { isServer as h } from "lit";
+class n extends Event {
+  constructor(e) {
+    super("slottedchange", { composed: !0 }), this.slot = e;
+  }
+}
+class r {
+  constructor(e, t) {
+    this._host = e, this._internals = t, this._textObserver = !h && new MutationObserver(() => {
+      const s = this._host.shadowRoot.querySelector("slot:not([name])");
+      s ? this._updateSlottedState(s) : this._textObserver.disconnect();
+    }), this.hostConnected = () => {
+      this._host.shadowRoot?.addEventListener("slotchange", (s) => this._slotchangeHandler(s, s.target)), this._host.shadowRoot?.addEventListener("slottedchange", (s) => this._slotchangeHandler(s, s.slot), { capture: !0 }), this._internals.shadowRoot?.querySelectorAll("slot").forEach((s) => this._handleSlotChange(s)), this.hostConnected = void 0;
+    }, this._host.addController(this);
+  }
+  _slotchangeHandler(e, t) {
+    const s = this._host.shadowRoot.contains(t) ? t : e.composedPath().find((o) => o instanceof HTMLSlotElement && this._host.shadowRoot.contains(o));
+    s && this._handleSlotChange(s);
+  }
+  _handleSlotChange(e) {
+    this._updateSlottedState(e), e.name || this._observeTextNodesInSlot(e);
+  }
+  _updateSlottedState(e) {
+    const t = e.name ? `slotted-${e.name}` : "slotted", s = this._hasSlottedContent(e);
+    s && !this._internals.states.has(t) ? (this._internals.states.add(t), this._host.dispatchEvent(new n(e))) : !s && this._internals.states.has(t) && (this._internals.states.delete(t), this._host.dispatchEvent(new n(e)));
+  }
+  _observeTextNodesInSlot(e) {
+    this._textObserver.disconnect(), e.assignedNodes().filter((t) => t.nodeType === t.TEXT_NODE).forEach((t) => this._textObserver.observe(t, { characterData: !0 }));
+  }
+  _hasSlottedContent(e) {
+    return e.name ? e.assignedElements().some((t) => !(t instanceof HTMLSlotElement) || this._hasSlottedContent(t)) : e.assignedNodes().some((t) => t instanceof HTMLSlotElement ? this._hasSlottedContent(t) : t.nodeType !== t.TEXT_NODE || !!t.textContent?.trim());
+  }
+}
+export {
+  r as SbbSlotStateController,
+  n as SbbSlottedChangeEvent
+};

package/core/controllers.js

@@ -0,0 +1,30 @@
+import { SbbPropertyWatcherController as o } from "./controllers/property-watcher-controller.js";
+import { SbbEscapableOverlayController as t } from "./controllers/escapable-overlay-controller.js";
+import { SbbIdReferenceController as l } from "./controllers/id-reference-controller.js";
+import { SbbInertController as S } from "./controllers/inert-controller.js";
+import { SbbLanguageController as i } from "./controllers/language-controller.js";
+import { SbbDarkModeController as M, SbbMediaMatcherController as y, SbbMediaQueryBreakpointLargeAndAbove as C, SbbMediaQueryBreakpointLargeAndBelow as u, SbbMediaQueryBreakpointSmallAndAbove as m, SbbMediaQueryBreakpointSmallAndBelow as A, SbbMediaQueryBreakpointUltraAndAbove as Q, SbbMediaQueryBreakpointZeroAndAbove as f, SbbMediaQueryDarkMode as k, SbbMediaQueryForcedColors as v, SbbMediaQueryHover as x, SbbMediaQueryPointerCoarse as B } from "./controllers/media-matchers-controller.js";
+import { SbbSlotStateController as g, SbbSlottedChangeEvent as s } from "./controllers/slot-state-controller.js";
+import { SbbOverlayPositionController as L } from "./controllers/overlay-position-controller.js";
+export {
+  M as SbbDarkModeController,
+  t as SbbEscapableOverlayController,
+  l as SbbIdReferenceController,
+  S as SbbInertController,
+  i as SbbLanguageController,
+  y as SbbMediaMatcherController,
+  C as SbbMediaQueryBreakpointLargeAndAbove,
+  u as SbbMediaQueryBreakpointLargeAndBelow,
+  m as SbbMediaQueryBreakpointSmallAndAbove,
+  A as SbbMediaQueryBreakpointSmallAndBelow,
+  Q as SbbMediaQueryBreakpointUltraAndAbove,
+  f as SbbMediaQueryBreakpointZeroAndAbove,
+  k as SbbMediaQueryDarkMode,
+  v as SbbMediaQueryForcedColors,
+  x as SbbMediaQueryHover,
+  B as SbbMediaQueryPointerCoarse,
+  L as SbbOverlayPositionController,
+  o as SbbPropertyWatcherController,
+  g as SbbSlotStateController,
+  s as SbbSlottedChangeEvent
+};