@sbb-esta/lyne-elements 2.6.0 → 2.7.1

package/development/core/controllers/{id-observer-controller.d.ts → id-reference-controller.d.ts}

@@ -18,4 +18,4 @@ export declare class SbbIdReferenceController<T extends LitElement> implements R
      */
     find(): HTMLElement | null;
 }
-//# sourceMappingURL=id-observer-controller.d.ts.map
+//# sourceMappingURL=id-reference-controller.d.ts.map

package/development/core/controllers/id-reference-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-reference-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/id-reference-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,MAAM,KAAK,CAAC;AAOzE;;GAEG;AACH,qBAAa,wBAAwB,CAAC,CAAC,SAAS,UAAU,CAAE,YAAW,kBAAkB;IAIrF,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IALpB,OAAO,CAAC,SAAS,CAAsC;gBAG7C,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,MAAM,CAAC,EACf,UAAU;kBAZR,gBAAgB;qBAAe,GAAG,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC;MAY7C;IAKzB,aAAa,IAAI,IAAI;IAgDrB,gBAAgB,IAAI,IAAI;IAoB/B;;OAEG;IACI,IAAI,IAAI,WAAW,GAAG,IAAI;CAQlC"}

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

@@ -0,0 +1,84 @@
+import { isServer } from "lit";
+const observers = /* @__PURE__ */ new WeakMap();
+class SbbIdReferenceController {
+  constructor(_host, _idRef, _observers = observers) {
+    this._host = _host;
+    this._idRef = _idRef;
+    this._observers = _observers;
+    this._rootNode = null;
+    this._host.addController(this);
+  }
+  hostConnected() {
+    if (isServer) {
+      return;
+    }
+    this._rootNode = this._host.getRootNode();
+    const observerContext = this._observers.get(this._rootNode);
+    if (observerContext) {
+      observerContext.controllers.add(this);
+    } else {
+      const controllers = /* @__PURE__ */ new Set([this]);
+      const observer = new MutationObserver((mutations) => {
+        const mutatedIds = /* @__PURE__ */ new Set();
+        for (const mutation of mutations) {
+          if (mutation.type === "attributes") {
+            mutatedIds.add(mutation.oldValue);
+            mutatedIds.add(mutation.target.id);
+          } else if (mutation.type === "childList") {
+            for (const node of [...mutation.addedNodes, ...mutation.removedNodes]) {
+              if (node instanceof HTMLElement) {
+                mutatedIds.add(node.id);
+                node.querySelectorAll("[id]").forEach((e) => mutatedIds.add(e.id));
+              }
+            }
+          }
+        }
+        for (const controller of controllers) {
+          const id = controller._host[controller._idRef];
+          if (id && typeof id === "string" && mutatedIds.has(id)) {
+            controller._host.requestUpdate();
+          }
+        }
+      });
+      observer.observe(this._rootNode, {
+        attributeFilter: ["id"],
+        childList: true,
+        subtree: true,
+        attributeOldValue: true
+      });
+      this._observers.set(this._rootNode, { observer, controllers });
+    }
+  }
+  hostDisconnected() {
+    if (isServer || !this._rootNode) {
+      return;
+    }
+    const observerContext = this._observers.get(this._rootNode);
+    if (!observerContext) {
+      this._rootNode = null;
+      return;
+    }
+    observerContext.controllers.delete(this);
+    if (observerContext.controllers.size === 0) {
+      observerContext.observer.disconnect();
+      this._observers.delete(this._rootNode);
+    }
+    this._rootNode = null;
+  }
+  /**
+   * Find the element by id in the current document fragment
+   */
+  find() {
+    var _a;
+    if (isServer || !this._rootNode) {
+      return null;
+    } else {
+      const id = this._host[this._idRef];
+      return typeof id == "string" ? (_a = this._rootNode) == null ? void 0 : _a.querySelector(`#${id}`) : null;
+    }
+  }
+}
+export {
+  SbbIdReferenceController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,9 +1,11 @@
 import { ReactiveController, ReactiveControllerHost } from 'lit';
+import { SbbOpenCloseBaseElement } from '../base-elements.js';
 export declare class SbbInertController implements ReactiveController {
     private _host;
     private _inertElements;
     private _inertOverlays;
-    constructor(_host: ReactiveControllerHost & HTMLElement, _inertElements?: Set<HTMLElement>, _inertOverlays?: Set<HTMLElement>);
+    constructor(_host: ReactiveControllerHost & SbbOpenCloseBaseElement, _inertElements?: Set<HTMLElement>, _inertOverlays?: Set<HTMLElement>);
+    hostConnected(): void;
     hostDisconnected(): void;
     /** Applies inert state to every other element on the page except the overlay. */
     activate(): void;

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

@@ -1 +1 @@
-{"version":3,"file":"inert-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/inert-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAMtE,qBAAa,kBAAmB,YAAW,kBAAkB;IAEzD,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,cAAc;gBAFd,KAAK,EAAE,sBAAsB,GAAG,WAAW,EAC3C,cAAc,mBAAgB,EAC9B,cAAc,mBAAgB;IAKjC,gBAAgB,IAAI,IAAI;IAM/B,iFAAiF;IAC1E,QAAQ,IAAI,IAAI;IAUvB,2BAA2B;IACpB,UAAU,IAAI,IAAI;IAyBzB,mDAAmD;IAC5C,OAAO,IAAI,OAAO;IAIzB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,mBAAmB;CA6B5B"}
+{"version":3,"file":"inert-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/inert-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAEtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAMnE,qBAAa,kBAAmB,YAAW,kBAAkB;IAEzD,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,cAAc;gBAFd,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,EACvD,cAAc,mBAAgB,EAC9B,cAAc,mBAAgB;IAKjC,aAAa,IAAI,IAAI;IAMrB,gBAAgB,IAAI,IAAI;IAM/B,iFAAiF;IAC1E,QAAQ,IAAI,IAAI;IAUvB,2BAA2B;IACpB,UAAU,IAAI,IAAI;IAyBzB,mDAAmD;IAC5C,OAAO,IAAI,OAAO;IAIzB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,mBAAmB;CA6B5B"}

package/development/core/controllers/inert-controller.js

@@ -0,0 +1,91 @@
+const IGNORED_ELEMENTS = ["script", "head", "template", "style"];
+const inertElements = /* @__PURE__ */ new Set();
+const inertOverlays = /* @__PURE__ */ new Set();
+class SbbInertController {
+  constructor(_host, _inertElements = inertElements, _inertOverlays = inertOverlays) {
+    var _a, _b;
+    this._host = _host;
+    this._inertElements = _inertElements;
+    this._inertOverlays = _inertOverlays;
+    (_b = (_a = this._host).addController) == null ? void 0 : _b.call(_a, this);
+  }
+  hostConnected() {
+    if (this._host.isOpen) {
+      this.activate();
+    }
+  }
+  hostDisconnected() {
+    if (this.isInert()) {
+      this.deactivate();
+    }
+  }
+  /** Applies inert state to every other element on the page except the overlay. */
+  activate() {
+    if (this._inertOverlays.size) {
+      this._removeInertAttributes();
+    }
+    this._inertOverlays.add(this._host);
+    this._addInertAttributes();
+  }
+  /** Removes inert state. */
+  deactivate() {
+    if (this._currentOverlay() !== this._host) {
+      if (this._inertOverlays.has(this._host)) {
+        this._inertOverlays.delete(this._host);
+      } else {
+        console.warn("Trying to remove inert state of an overlay which never had an applied inert state.", this._host);
+      }
+      return;
+    }
+    this._removeInertAttributes();
+    this._inertOverlays.delete(this._host);
+    if (this._inertOverlays.size) {
+      this._addInertAttributes();
+    }
+  }
+  /** Whether the assigned host is currently inert */
+  isInert() {
+    return this._inertOverlays.has(this._host);
+  }
+  _currentOverlay() {
+    return [...this._inertOverlays].pop() ?? null;
+  }
+  _removeInertAttributes() {
+    this._inertElements.forEach((element) => {
+      if (!element) {
+        return;
+      }
+      if (element.hasAttribute("data-sbb-inert")) {
+        element.inert = false;
+        element.removeAttribute("data-sbb-inert");
+      }
+      if (element.hasAttribute("data-sbb-aria-hidden")) {
+        element.removeAttribute("aria-hidden");
+        element.removeAttribute("data-sbb-aria-hidden");
+      }
+    });
+    this._inertElements.clear();
+  }
+  _addInertAttributes() {
+    var _a, _b;
+    let element = this._currentOverlay();
+    while (element !== document.documentElement && element !== null) {
+      Array.from(((_a = (element == null ? void 0 : element.parentElement) ?? (element == null ? void 0 : element.getRootNode())) == null ? void 0 : _a.childNodes) ?? []).filter((child) => child !== element && child instanceof window.HTMLElement && !IGNORED_ELEMENTS.includes(child.localName)).forEach((element2) => {
+        this._inertElements.add(element2);
+        if (!element2.inert) {
+          element2.inert = true;
+          element2.toggleAttribute("data-sbb-inert", true);
+        }
+        if (!element2.hasAttribute("aria-hidden")) {
+          element2.setAttribute("aria-hidden", "true");
+          element2.toggleAttribute("data-sbb-aria-hidden", true);
+        }
+      });
+      element = (element == null ? void 0 : element.parentElement) ?? ((_b = element == null ? void 0 : element.getRootNode()) == null ? void 0 : _b.host) ?? null;
+    }
+  }
+}
+export {
+  SbbInertController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/controllers/language-controller.js

@@ -0,0 +1,69 @@
+import { isServer } from "lit";
+import { readConfig } from "../config.js";
+const _SbbLanguageController = class _SbbLanguageController {
+  /** 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;
+  }
+  constructor(_host) {
+    this._host = _host;
+    this._handlers = [];
+    this._host.addController(this);
+  }
+  /** Add a language change handler. */
+  withHandler(handler) {
+    this._handlers.unshift(handler);
+    return this;
+  }
+  hostConnected() {
+    if (isServer) {
+      return;
+    }
+    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() {
+    if (isServer) {
+      return;
+    }
+    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 = !isServer ? new MutationObserver((mutations) => {
+  if (mutations[0].oldValue !== document.documentElement.getAttribute("lang")) {
+    _SbbLanguageController._listeners.forEach((l) => l._callHandlers());
+  }
+}) : null;
+_SbbLanguageController._observerConfig = {
+  attributeFilter: ["lang"],
+  attributeOldValue: true
+};
+let SbbLanguageController = _SbbLanguageController;
+export {
+  SbbLanguageController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2UtY29udHJvbGxlci5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2NvcmUvY29udHJvbGxlcnMvbGFuZ3VhZ2UtY29udHJvbGxlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpc1NlcnZlciwgdHlwZSBSZWFjdGl2ZUNvbnRyb2xsZXIsIHR5cGUgUmVhY3RpdmVDb250cm9sbGVySG9zdCB9IGZyb20gJ2xpdCc7XG5cbmltcG9ydCB7IHJlYWRDb25maWcgfSBmcm9tICcuLi9jb25maWcuanMnO1xuXG4vKipcbiAqIFRoZSBMYW5ndWFnZUNvbnRyb2xsZXIgaXMgYSByZWFjdGl2ZSBjb250cm9sbGVyIHRoYXQgb2JzZXJ2ZXMgdGhlIFwibGFuZ1wiIGF0dHJpYnV0ZVxuICogb2YgdGhlIDxodG1sPiB0YWcuXG4gKiBPbiBjaGFuZ2Ugb2YgdGhlIFwibGFuZ1wiIGF0dHJpYnV0ZSwgaXQgd2lsbCByZXF1ZXN0IGFuIHVwZGF0ZSBvZiBjb25uZWN0ZWRcbiAqIGNvbXBvbmVudHMuXG4gKlxuICogQHNlZSBodHRwczovL2RldmVsb3Blci5tb3ppbGxhLm9yZy9lbi1VUy9kb2NzL1dlYi9IVE1ML0dsb2JhbF9hdHRyaWJ1dGVzL2xhbmdcbiAqL1xuZXhwb3J0IGNsYXNzIFNiYkxhbmd1YWdlQ29udHJvbGxlciBpbXBsZW1lbnRzIFJlYWN0aXZlQ29udHJvbGxlciB7XG4gIHByaXZhdGUgc3RhdGljIHJlYWRvbmx5IF9kZWZhdWx0TGFuZ3VhZ2UgPSAnZW4nO1xuICBwcml2YXRlIHN0YXRpYyByZWFkb25seSBfc3VwcG9ydGVkTG9jYWxlcyA9IFsnZW4nLCAnZGUnLCAnZnInLCAnaXQnXTtcblxuICAvKiogQSBzZXQgb2YgY29ubmVjdGVkIGNvbXBvbmVudHMgdGhhdCBzaG91bGQgYmUgbm90aWZpZWQgb24gbGFuZ3VhZ2UgY2hhbmdlLiAqL1xuICBwcml2YXRlIHN0YXRpYyByZWFkb25seSBfbGlzdGVuZXJzID0gbmV3IFNldDxTYmJMYW5ndWFnZUNvbnRyb2xsZXI+KCk7XG5cbiAgLyoqIE11dGF0aW9uT2JzZXJ2ZXIgdGhhdCBvYnNlcnZlcyB0aGUgXCJsYW5nXCIgYXR0cmlidXRlIG9mIHRoZSA8aHRtbD4gZWxlbWVudC4gKi9cbiAgcHJpdmF0ZSBzdGF0aWMgcmVhZG9ubHkgX29ic2VydmVyID0gIWlzU2VydmVyXG4gICAgPyBuZXcgTXV0YXRpb25PYnNlcnZlcigobXV0YXRpb25zKSA9PiB7XG4gICAgICAgIGlmIChtdXRhdGlvbnNbMF0ub2xkVmFsdWUgIT09IGRvY3VtZW50LmRvY3VtZW50RWxlbWVudC5nZXRBdHRyaWJ1dGUoJ2xhbmcnKSkge1xuICAgICAgICAgIFNiYkxhbmd1YWdlQ29udHJvbGxlci5fbGlzdGVuZXJzLmZvckVhY2goKGwpID0+IGwuX2NhbGxIYW5kbGVycygpKTtcbiAgICAgICAgfVxuICAgICAgfSlcbiAgICA6IG51bGw7XG4gIHByaXZhdGUgc3RhdGljIHJlYWRvbmx5IF9vYnNlcnZlckNvbmZpZyA9IHtcbiAgICBhdHRyaWJ1dGVGaWx0ZXI6IFsnbGFuZyddLFxuICAgIGF0dHJpYnV0ZU9sZFZhbHVlOiB0cnVlLFxuICB9O1xuXG4gIC8qKiBHZXQgdGhlIGN1cnJlbnQgbGFuZ3VhZ2UuICovXG4gIHB1YmxpYyBzdGF0aWMgZ2V0IGN1cnJlbnQoKTogc3RyaW5nIHtcbiAgICBjb25zdCBsYW5ndWFnZSA9XG4gICAgICAocmVhZENvbmZpZygpLmxhbmd1YWdlID8/XG4gICAgICAgIChpc1NlcnZlclxuICAgICAgICAgID8gU2JiTGFuZ3VhZ2VDb250cm9sbGVyLl9kZWZhdWx0TGFuZ3VhZ2VcbiAgICAgICAgICA6IGRvY3VtZW50LmRvY3VtZW50RWxlbWVudC5nZXRBdHRyaWJ1dGUoJ2xhbmcnKSkpIHx8XG4gICAgICBTYmJMYW5ndWFnZUNvbnRyb2xsZXIuX2RlZmF1bHRMYW5ndWFnZTtcblxuICAgIC8vIFN1cHBvcnQgZS5nLiBjYXNlcyBsaWtlIGBkZS1jaGAuXG4gICAgY29uc3QgbGFuZ0F0dHJpYnV0ZU5vcm1hbGl6ZWQgPSBsYW5ndWFnZS5zcGxpdCgnLScpWzBdO1xuICAgIHJldHVybiBTYmJMYW5ndWFnZUNvbnRyb2xsZXIuX3N1cHBvcnRlZExvY2FsZXMuaW5jbHVkZXMobGFuZ0F0dHJpYnV0ZU5vcm1hbGl6ZWQpXG4gICAgICA/IGxhbmdBdHRyaWJ1dGVOb3JtYWxpemVkXG4gICAgICA6IFNiYkxhbmd1YWdlQ29udHJvbGxlci5fZGVmYXVsdExhbmd1YWdlO1xuICB9XG5cbiAgLyoqIEdldCB0aGUgY3VycmVudCBsYW5ndWFnZS4gKi9cbiAgcHVibGljIGdldCBjdXJyZW50KCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIFNiYkxhbmd1YWdlQ29udHJvbGxlci5jdXJyZW50O1xuICB9XG5cbiAgcHJpdmF0ZSBfcHJldmlvdXNMYW5ndWFnZT86IHN0cmluZztcbiAgcHJpdmF0ZSBfaGFuZGxlcnM6ICgoKSA9PiB2b2lkKVtdID0gW107XG5cbiAgcHVibGljIGNvbnN0cnVjdG9yKHByaXZhdGUgX2hvc3Q6IFJlYWN0aXZlQ29udHJvbGxlckhvc3QpIHtcbiAgICB0aGlzLl9ob3N0LmFkZENvbnRyb2xsZXIodGhpcyk7XG4gIH1cblxuICAvKiogQWRkIGEgbGFuZ3VhZ2UgY2hhbmdlIGhhbmRsZXIuICovXG4gIHB1YmxpYyB3aXRoSGFuZGxlcihoYW5kbGVyOiAoKSA9PiB2b2lkKTogdGhpcyB7XG4gICAgLy8gV2UgdXNlIHVuc2hpZnQgaGVyZSwgdG8gcHJlcGVuZCBhZGRpdGlvbmFsIGhhbmRsZXJzLlxuICAgIC8vIFRoaXMgZW5zdXJlcyB0aGF0IHJlcXVlc3RVcGRhdGUgaXMgY2FsbGVkIGFmdGVyIHRoZSBvdGhlciBoYW5kbGVycy5cbiAgICB0aGlzLl9oYW5kbGVycy51bnNoaWZ0KGhhbmRsZXIpO1xuICAgIHJldHVybiB0aGlzO1xuICB9XG5cbiAgcHVibGljIGhvc3RDb25uZWN0ZWQoKTogdm9pZCB7XG4gICAgaWYgKGlzU2VydmVyKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuICAgIGlmICghU2JiTGFuZ3VhZ2VDb250cm9sbGVyLl9saXN0ZW5lcnMuc2l6ZSkge1xuICAgICAgU2JiTGFuZ3VhZ2VDb250cm9sbGVyLl9vYnNlcnZlciEub2JzZXJ2ZShcbiAgICAgICAgZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50LFxuICAgICAgICBTYmJMYW5ndWFnZUNvbnRyb2xsZXIuX29ic2VydmVyQ29uZmlnLFxuICAgICAgKTtcbiAgICB9XG5cbiAgICBTYmJMYW5ndWFnZUNvbnRyb2xsZXIuX2xpc3RlbmVycy5hZGQodGhpcyk7XG4gICAgaWYgKHRoaXMuX3ByZXZpb3VzTGFuZ3VhZ2UgIT09IHRoaXMuY3VycmVudCkge1xuICAgICAgdGhpcy5fY2FsbEhhbmRsZXJzKHRoaXMuX3ByZXZpb3VzTGFuZ3VhZ2UgIT09IHVuZGVmaW5lZCk7XG4gICAgfVxuICB9XG5cbiAgcHVibGljIGhvc3REaXNjb25uZWN0ZWQoKTogdm9pZCB7XG4gICAgaWYgKGlzU2VydmVyKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuICAgIHRoaXMuX3ByZXZpb3VzTGFuZ3VhZ2UgPSB0aGlzLmN1cnJlbnQ7XG4gICAgU2JiTGFuZ3VhZ2VDb250cm9sbGVyLl9saXN0ZW5lcnMuZGVsZXRlKHRoaXMpO1xuICAgIGlmICghU2JiTGFuZ3VhZ2VDb250cm9sbGVyLl9saXN0ZW5lcnMuc2l6ZSkge1xuICAgICAgU2JiTGFuZ3VhZ2VDb250cm9sbGVyLl9vYnNlcnZlciEuZGlzY29ubmVjdCgpO1xuICAgIH1cbiAgfVxuXG4gIHByaXZhdGUgX2NhbGxIYW5kbGVycyhyZXF1ZXN0VXBkYXRlID0gdHJ1ZSk6IHZvaWQge1xuICAgIHRoaXMuX2hhbmRsZXJzLmZvckVhY2goKGgpID0+IGgoKSk7XG4gICAgaWYgKHJlcXVlc3RVcGRhdGUpIHtcbiAgICAgIHRoaXMuX2hvc3QucmVxdWVzdFVwZGF0ZSgpO1xuICAgIH1cbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O01BWWEsK0JBQUEsdUJBQXFCO0FBQUE7QUFBQSxFQXFCekIsV0FBVyxVQUFPO0FBQ3ZCLFVBQU0sWUFDSCxXQUFhLEVBQUEsYUFDWCxXQUNHLHVCQUFzQixtQkFDdEIsU0FBUyxnQkFBZ0IsYUFBYSxNQUFNLE9BQ2xELHVCQUFzQjtBQUd4QixVQUFNLDBCQUEwQixTQUFTLE1BQU0sR0FBRyxFQUFFLENBQUM7QUFDckQsV0FBTyx1QkFBc0Isa0JBQWtCLFNBQVMsdUJBQXVCLElBQzNFLDBCQUNBLHVCQUFzQjtBQUFBLEVBQUE7QUFBQTtBQUFBLEVBSTVCLElBQVcsVUFBTztBQUNoQixXQUFPLHVCQUFzQjtBQUFBLEVBQUE7QUFBQSxFQU0vQixZQUEyQixPQUE2QjtBQUE3QixTQUFLLFFBQUw7QUFGbkIsU0FBUyxZQUFtQjtBQUc3QixTQUFBLE1BQU0sY0FBYyxJQUFJO0FBQUEsRUFBQTtBQUFBO0FBQUEsRUFJeEIsWUFBWSxTQUFtQjtBQUcvQixTQUFBLFVBQVUsUUFBUSxPQUFPO0FBQ3ZCLFdBQUE7QUFBQSxFQUFBO0FBQUEsRUFHRixnQkFBYTtBQUNsQixRQUFJLFVBQVU7QUFDWjtBQUFBLElBQUE7QUFFRSxRQUFBLENBQUMsdUJBQXNCLFdBQVcsTUFBTTtBQUMxQyw2QkFBc0IsVUFBVyxRQUMvQixTQUFTLGlCQUNULHVCQUFzQixlQUFlO0FBQUEsSUFBQTtBQUluQiwyQkFBQSxXQUFXLElBQUksSUFBSTtBQUNyQyxRQUFBLEtBQUssc0JBQXNCLEtBQUssU0FBUztBQUN0QyxXQUFBLGNBQWMsS0FBSyxzQkFBc0IsTUFBUztBQUFBLElBQUE7QUFBQSxFQUN6RDtBQUFBLEVBR0ssbUJBQWdCO0FBQ3JCLFFBQUksVUFBVTtBQUNaO0FBQUEsSUFBQTtBQUVGLFNBQUssb0JBQW9CLEtBQUs7QUFDUiwyQkFBQSxXQUFXLE9BQU8sSUFBSTtBQUN4QyxRQUFBLENBQUMsdUJBQXNCLFdBQVcsTUFBTTtBQUMxQyw2QkFBc0IsVUFBVzs7RUFDbkM7QUFBQSxFQUdNLGNBQWMsZ0JBQWdCLE1BQUk7QUFDeEMsU0FBSyxVQUFVLFFBQVEsQ0FBQyxNQUFNLEdBQUc7QUFDakMsUUFBSSxlQUFlO0FBQ2pCLFdBQUssTUFBTTs7RUFDYjs7QUF2RnNCLHVCQUFnQixtQkFBRztBQUNuQix1QkFBaUIsb0JBQUcsQ0FBQyxNQUFNLE1BQU0sTUFBTSxJQUFJO0FBRzNDLHVCQUFBLGlDQUFpQixJQUFHO0FBR3BCLHVCQUFTLFlBQUcsQ0FBQyxXQUNqQyxJQUFJLGlCQUFpQixDQUFDLGNBQWE7QUFDN0IsTUFBQSxVQUFVLENBQUMsRUFBRSxhQUFhLFNBQVMsZ0JBQWdCLGFBQWEsTUFBTSxHQUFHO0FBQzNFLDJCQUFzQixXQUFXLFFBQVEsQ0FBQyxNQUFNLEVBQUUsZUFBZTtBQUFBLEVBQUE7QUFFcEUsQ0FBQSxJQUNEO0FBQ29CLHVCQUFBLGtCQUFrQjtBQUFBLEVBQ3hDLGlCQUFpQixDQUFDLE1BQU07QUFBQSxFQUN4QixtQkFBbUI7QUFDcEI7SUFsQlU7In0=

package/development/core/controllers/media-matchers-controller.d.ts

@@ -3,6 +3,7 @@ export declare const SbbMediaQueryForcedColors = "(forced-colors: active)";
 export declare const SbbMediaQueryHover = "(any-hover: hover)";
 export declare const SbbMediaQueryPointerCoarse = "(pointer: coarse)";
 export declare const SbbMediaQueryBreakpointMediumAndAbove: string;
+export declare const SbbMediaQueryBreakpointMediumAndBelow: string;
 export declare const SbbMediaQueryBreakpointSmallAndBelow: string;
 /**
  * A callback, which is invoked when the associated media query match

package/development/core/controllers/media-matchers-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"media-matchers-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/media-matchers-controller.ts"],"names":[],"mappings":"AAKA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAKrF,eAAO,MAAM,yBAAyB,4BAA4B,CAAC;AACnE,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AACvD,eAAO,MAAM,0BAA0B,sBAAsB,CAAC;AAC9D,eAAO,MAAM,qCAAqC,QAAuD,CAAC;AAC1G,eAAO,MAAM,oCAAoC,QAAsD,CAAC;AAGxG;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAehE;;;;;;;GAOG;AACH,qBAAa,yBAA0B,YAAW,kBAAkB;IAGhE,OAAO,CAAC,QAAQ;gBADhB,IAAI,EAAE,sBAAsB,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAK1D;;;;OAIG;IACI,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI;IAMtC,aAAa,IAAI,IAAI;IAoBrB,gBAAgB,IAAI,IAAI;CAWhC"}
+{"version":3,"file":"media-matchers-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/media-matchers-controller.ts"],"names":[],"mappings":"AAMA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAKrF,eAAO,MAAM,yBAAyB,4BAA4B,CAAC;AACnE,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AACvD,eAAO,MAAM,0BAA0B,sBAAsB,CAAC;AAC9D,eAAO,MAAM,qCAAqC,QAAuD,CAAC;AAC1G,eAAO,MAAM,qCAAqC,QAAuD,CAAC;AAC1G,eAAO,MAAM,oCAAoC,QAAsD,CAAC;AAGxG;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAehE;;;;;;;GAOG;AACH,qBAAa,yBAA0B,YAAW,kBAAkB;IAGhE,OAAO,CAAC,QAAQ;gBADhB,IAAI,EAAE,sBAAsB,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAK1D;;;;OAIG;IACI,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI;IAMtC,aAAa,IAAI,IAAI;IAoBrB,gBAAgB,IAAI,IAAI;CAWhC"}

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

@@ -0,0 +1,62 @@
+import { S as SbbTypoScaleDefault, a as SbbBreakpointMediumMax, b as SbbBreakpointSmallMax, c as SbbBreakpointMediumMin } from "../../sbb-tokens-CVLcOi-S.js";
+import { isServer } from "lit";
+const pxToRem = (px) => px / SbbTypoScaleDefault;
+const SbbMediaQueryForcedColors = "(forced-colors: active)";
+const SbbMediaQueryHover = "(any-hover: hover)";
+const SbbMediaQueryPointerCoarse = "(pointer: coarse)";
+const SbbMediaQueryBreakpointMediumAndAbove = `(min-width: ${pxToRem(SbbBreakpointMediumMin)}rem)`;
+const SbbMediaQueryBreakpointMediumAndBelow = `(max-width: ${pxToRem(SbbBreakpointMediumMax)}rem)`;
+const SbbMediaQueryBreakpointSmallAndBelow = `(max-width: ${pxToRem(SbbBreakpointSmallMax)}rem)`;
+const mediaQueryRegistry = /* @__PURE__ */ new Map();
+class SbbMediaMatcherController {
+  constructor(host, _queries) {
+    this._queries = _queries;
+    host.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(query) {
+    return isServer ? null : matchMedia(query).matches;
+  }
+  hostConnected() {
+    if (isServer) {
+      return;
+    }
+    for (const [query, handler] of Object.entries(this._queries)) {
+      const mediaQuery = mediaQueryRegistry.get(query);
+      if (mediaQuery) {
+        mediaQuery.handlers.add(handler);
+      } else {
+        const mediaQueryList = matchMedia(query);
+        const handlers = /* @__PURE__ */ new Set([handler]);
+        const eventHandler = (e) => handlers.forEach((h) => h(e.matches));
+        mediaQueryList.addEventListener("change", eventHandler);
+        mediaQueryRegistry.set(query, { mediaQueryList, handlers, eventHandler });
+      }
+    }
+  }
+  hostDisconnected() {
+    for (const [query, handler] of Object.entries(this._queries)) {
+      const mediaQuery = mediaQueryRegistry.get(query);
+      if (mediaQuery) {
+        mediaQuery.handlers.delete(handler);
+        if (!mediaQuery.handlers.size) {
+          mediaQueryRegistry.delete(query);
+        }
+      }
+    }
+  }
+}
+export {
+  SbbMediaMatcherController,
+  SbbMediaQueryBreakpointMediumAndAbove,
+  SbbMediaQueryBreakpointMediumAndBelow,
+  SbbMediaQueryBreakpointSmallAndBelow,
+  SbbMediaQueryForcedColors,
+  SbbMediaQueryHover,
+  SbbMediaQueryPointerCoarse
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -22,10 +22,12 @@ export declare class SbbSlotStateController implements ReactiveController {
     private _host;
     private _onChangeCallback;
     readonly slots: Set<string>;
+    private _textObserver;
     constructor(_host: ReactiveControllerHost & HTMLElement, _onChangeCallback?: (() => void) | null);
     hostConnected(): void;
     hostDisconnected(): void;
     private _slotchangeHandler;
     private _syncSlots;
+    private _updateSlotNameAttribute;
 }
 //# sourceMappingURL=slot-state-controller.d.ts.map

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

@@ -1 +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;IAI7D,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,iBAAiB;IAJ3B,SAAgB,KAAK,cAAqB;gBAGhC,KAAK,EAAE,sBAAsB,GAAG,WAAW,EAC3C,iBAAiB,GAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAW;IAKhD,aAAa,IAAI,IAAI;IAMrB,gBAAgB,IAAI,IAAI;IAM/B,OAAO,CAAC,kBAAkB,CAExB;IAEF,OAAO,CAAC,UAAU;CAuBnB"}
+{"version":3,"file":"slot-state-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/slot-state-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAErF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IAmB7D,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,iBAAiB;IAnB3B,SAAgB,KAAK,cAAqB;IAE1C,OAAO,CAAC,aAAa,CAahB;gBAGK,KAAK,EAAE,sBAAsB,GAAG,WAAW,EAC3C,iBAAiB,GAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAW;IAKhD,aAAa,IAAI,IAAI;IAKrB,gBAAgB,IAAI,IAAI;IAO/B,OAAO,CAAC,kBAAkB,CAExB;IAEF,OAAO,CAAC,UAAU;IA2BlB,OAAO,CAAC,wBAAwB;CAajC"}

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

@@ -0,0 +1,68 @@
+import { isServer } from "lit";
+class SbbSlotStateController {
+  constructor(_host, _onChangeCallback = null) {
+    this._host = _host;
+    this._onChangeCallback = _onChangeCallback;
+    this.slots = /* @__PURE__ */ new Set();
+    this._textObserver = !isServer && new MutationObserver(() => {
+      const hasTextNodeContent = Array.from(this._host.childNodes).filter((n) => n.nodeType === n.TEXT_NODE).some((n) => {
+        var _a;
+        return (_a = n.textContent) == null ? void 0 : _a.trim();
+      });
+      if (hasTextNodeContent) {
+        this.slots.add("unnamed");
+      } else if (Array.from(this._host.children).every((e) => e.slot)) {
+        this.slots.delete("unnamed");
+      }
+      this._updateSlotNameAttribute();
+    });
+    this._slotchangeHandler = (event) => {
+      this._syncSlots(event.target);
+    };
+    this._host.addController(this);
+  }
+  hostConnected() {
+    var _a, _b, _c;
+    this._syncSlots(...((_b = (_a = this._host.shadowRoot) == null ? void 0 : _a.querySelectorAll) == null ? void 0 : _b.call(_a, "slot")) ?? []);
+    (_c = this._host.shadowRoot) == null ? void 0 : _c.addEventListener("slotchange", this._slotchangeHandler);
+  }
+  hostDisconnected() {
+    var _a;
+    (_a = this._host.shadowRoot) == null ? void 0 : _a.removeEventListener("slotchange", this._slotchangeHandler);
+    this._textObserver.disconnect();
+  }
+  _syncSlots(...slots) {
+    var _a;
+    this._textObserver.disconnect();
+    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);
+      }
+      this._updateSlotNameAttribute();
+    }
+    (_a = slots.find((s) => !s.name)) == null ? void 0 : _a.assignedNodes().filter((n) => n.nodeType === n.TEXT_NODE).forEach((node) => this._textObserver.observe(node, { characterData: true }));
+  }
+  _updateSlotNameAttribute() {
+    var _a;
+    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 {
+  SbbSlotStateController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/controllers.d.ts

@@ -1,6 +1,9 @@
+/**
+ * @entrypoint
+ */
 export * from './controllers/connected-abort-controller.js';
 export * from './controllers/escapable-overlay-controller.js';
-export * from './controllers/id-observer-controller.js';
+export * from './controllers/id-reference-controller.js';
 export * from './controllers/inert-controller.js';
 export * from './controllers/language-controller.js';
 export * from './controllers/media-matchers-controller.js';

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

@@ -1 +1 @@
-{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA,cAAc,6CAA6C,CAAC;AAC5D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,yCAAyC,CAAC;AACxD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,6CAA6C,CAAC;AAC5D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0CAA0C,CAAC;AACzD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC"}