@sbb-esta/lyne-elements-dev 4.7.0-dev.1773388991 → 4.7.0-dev.1773396165

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

@@ -1,96 +1,121 @@
 import { isServer } from "lit";
-//#region src/elements/core/controllers/property-watcher-controller.ts
-var PropertyWatcher = class {
-	get size() {
-		return this._handlers.size;
-	}
-	constructor(_host, _property) {
-		this._host = _host;
-		this._property = _property;
-		this._handlers = /* @__PURE__ */ new Set();
-		this._hostDefinedPromise = null;
-		if (!isServer) if (customElements.get(this._host.localName)) customElements.upgrade(this._host);
-		else this._hostDefinedPromise = customElements.whenDefined(this._host.localName).then(() => {
-			customElements.upgrade(this._host);
-			this._hostDefinedPromise = null;
-		});
-		this._value = this._host[this._property];
-	}
-	addHandler(handler) {
-		if (!this._handlers.size) {
-			if (this._host.addController) this._host.addController(this);
-			else if (this._hostDefinedPromise) this._hostDefinedPromise.then(() => this._host.addController(this));
-		}
-		this._handlers.add(handler);
-		if (!this._hostDefinedPromise) handler(this._host);
-		else this._hostDefinedPromise.then(() => handler(this._host));
-	}
-	removeHandler(handler) {
-		this._handlers.delete(handler);
-		if (!this._handlers.size) {
-			if (this._host.removeController) this._host.removeController(this);
-			else if (this._hostDefinedPromise) this._hostDefinedPromise.then(() => this._host.removeController(this));
-		}
-	}
-	hostUpdate() {
-		const currentValue = this._host[this._property];
-		if (this._value !== currentValue) {
-			this._value = currentValue;
-			for (const handler of this._handlers) handler(this._host);
-		}
-	}
+class PropertyWatcher {
+  get size() {
+    return this._handlers.size;
+  }
+  constructor(_host, _property) {
+    this._host = _host;
+    this._property = _property;
+    this._handlers = /* @__PURE__ */ new Set();
+    this._hostDefinedPromise = null;
+    if (!isServer) {
+      if (customElements.get(this._host.localName)) {
+        customElements.upgrade(this._host);
+      } else {
+        this._hostDefinedPromise = customElements.whenDefined(this._host.localName).then(() => {
+          customElements.upgrade(this._host);
+          this._hostDefinedPromise = null;
+        });
+      }
+    }
+    this._value = this._host[this._property];
+  }
+  addHandler(handler) {
+    if (!this._handlers.size) {
+      if (this._host.addController) {
+        this._host.addController(this);
+      } else if (this._hostDefinedPromise) {
+        this._hostDefinedPromise.then(() => this._host.addController(this));
+      }
+    }
+    this._handlers.add(handler);
+    if (!this._hostDefinedPromise) {
+      handler(this._host);
+    } else {
+      this._hostDefinedPromise.then(() => handler(this._host));
+    }
+  }
+  removeHandler(handler) {
+    this._handlers.delete(handler);
+    if (!this._handlers.size) {
+      if (this._host.removeController) {
+        this._host.removeController(this);
+      } else if (this._hostDefinedPromise) {
+        this._hostDefinedPromise.then(() => this._host.removeController(this));
+      }
+    }
+  }
+  hostUpdate() {
+    const currentValue = this._host[this._property];
+    if (this._value !== currentValue) {
+      this._value = currentValue;
+      for (const handler of this._handlers) {
+        handler(this._host);
+      }
+    }
+  }
+}
+const propertyWatchers = /* @__PURE__ */ new WeakMap();
+class SbbPropertyWatcherController {
+  constructor(_host, _referenceResolver, _handlers) {
+    this._host = _host;
+    this._referenceResolver = _referenceResolver;
+    this._handlers = _handlers;
+    this._host.addController(this);
+  }
+  hostConnected() {
+    this.connect();
+  }
+  hostDisconnected() {
+    if (this._reference !== this._referenceResolver()) {
+      this.disconnect();
+    }
+  }
+  connect() {
+    const reference = this._referenceResolver();
+    if (this._reference === reference) {
+      return;
+    }
+    this.disconnect();
+    this._reference = reference;
+    if (!this._reference) {
+      return;
+    }
+    let watchers = propertyWatchers.get(this._reference);
+    if (!watchers) {
+      watchers = /* @__PURE__ */ new Map();
+      propertyWatchers.set(this._reference, watchers);
+    }
+    this._watchers = watchers;
+    for (const [property, handler] of Object.entries(this._handlers)) {
+      let watcher = this._watchers.get(property);
+      if (!watcher) {
+        watcher = new PropertyWatcher(this._reference, property);
+        this._watchers.set(property, watcher);
+      }
+      watcher.addHandler(handler);
+    }
+  }
+  disconnect() {
+    if (!this._reference) {
+      return;
+    }
+    for (const [property, handler] of Object.entries(this._handlers)) {
+      const watcher = this._watchers?.get(property);
+      if (watcher) {
+        watcher.removeHandler(handler);
+        if (!watcher.size) {
+          this._watchers.delete(property);
+          if (!this._watchers.size && this._reference) {
+            propertyWatchers.delete(this._reference);
+          }
+        }
+      }
+    }
+    this._reference = null;
+  }
+}
+export {
+  SbbPropertyWatcherController
 };
-var propertyWatchers = /* @__PURE__ */ new WeakMap();
-var SbbPropertyWatcherController = class {
-	constructor(_host, _referenceResolver, _handlers) {
-		this._host = _host;
-		this._referenceResolver = _referenceResolver;
-		this._handlers = _handlers;
-		this._host.addController(this);
-	}
-	hostConnected() {
-		this.connect();
-	}
-	hostDisconnected() {
-		if (this._reference !== this._referenceResolver()) this.disconnect();
-	}
-	connect() {
-		const reference = this._referenceResolver();
-		if (this._reference === reference) return;
-		this.disconnect();
-		this._reference = reference;
-		if (!this._reference) return;
-		let watchers = propertyWatchers.get(this._reference);
-		if (!watchers) {
-			watchers = /* @__PURE__ */ new Map();
-			propertyWatchers.set(this._reference, watchers);
-		}
-		this._watchers = watchers;
-		for (const [property, handler] of Object.entries(this._handlers)) {
-			let watcher = this._watchers.get(property);
-			if (!watcher) {
-				watcher = new PropertyWatcher(this._reference, property);
-				this._watchers.set(property, watcher);
-			}
-			watcher.addHandler(handler);
-		}
-	}
-	disconnect() {
-		if (!this._reference) return;
-		for (const [property, handler] of Object.entries(this._handlers)) {
-			const watcher = this._watchers?.get(property);
-			if (watcher) {
-				watcher.removeHandler(handler);
-				if (!watcher.size) {
-					this._watchers.delete(property);
-					if (!this._watchers.size && this._reference) propertyWatchers.delete(this._reference);
-				}
-			}
-		}
-		this._reference = null;
-	}
-};
-//#endregion
-export { SbbPropertyWatcherController };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"property-watcher-controller.js","names":[],"sources":["../../../../../src/elements/core/controllers/property-watcher-controller.ts"],"sourcesContent":["import {\n  type ReactiveControllerHost,\n  type LitElement,\n  type ReactiveController,\n  isServer,\n} from 'lit';\n\ntype PropertyWatcherHandler<T extends LitElement> = (reference: T) => void;\n\nclass PropertyWatcher<T extends LitElement> implements ReactiveController {\n  private _value: unknown;\n  private _handlers = new Set<PropertyWatcherHandler<T>>();\n  private _hostDefinedPromise: Promise<void> | null = null;\n\n  public get size(): number {\n    return this._handlers.size;\n  }\n\n  public constructor(\n    private readonly _host: T,\n    private readonly _property: string,\n  ) {\n    if (!isServer) {\n      if (customElements.get(this._host.localName)) {\n        customElements.upgrade(this._host);\n      } else {\n        // The host element is not yet defined, wait for its definition before upgrading\n        this._hostDefinedPromise = customElements.whenDefined(this._host.localName).then(() => {\n          customElements.upgrade(this._host);\n          this._hostDefinedPromise = null;\n        });\n      }\n    }\n    this._value = (this._host as unknown as Record<string, unknown>)[this._property];\n  }\n\n  public addHandler(handler: PropertyWatcherHandler<T>): void {\n    if (!this._handlers.size) {\n      // We check if the addController method is available (element was defined && upgraded), otherwise we wait for the host to be defined\n      if (this._host.addController) {\n        this._host.addController(this);\n      } else if (this._hostDefinedPromise) {\n        this._hostDefinedPromise.then(() => this._host.addController(this));\n      }\n    }\n    this._handlers.add(handler);\n\n    if (!this._hostDefinedPromise) {\n      handler(this._host);\n    } else {\n      this._hostDefinedPromise.then(() => handler(this._host));\n    }\n  }\n\n  public removeHandler(handler: PropertyWatcherHandler<T>): void {\n    this._handlers.delete(handler);\n    if (!this._handlers.size) {\n      // We check if the removeController method is available (element was defined && upgraded), otherwise we wait for the host to be defined\n      if (this._host.removeController) {\n        this._host.removeController(this);\n      } else if (this._hostDefinedPromise) {\n        this._hostDefinedPromise.then(() => this._host.removeController(this));\n      }\n    }\n  }\n\n  public hostUpdate(): void {\n    const currentValue = (this._host as unknown as Record<string, unknown>)[this._property];\n    if (this._value !== currentValue) {\n      this._value = currentValue;\n      for (const handler of this._handlers) {\n        handler(this._host);\n      }\n    }\n  }\n}\n\nconst propertyWatchers = new WeakMap<LitElement, Map<string, PropertyWatcher<any>>>();\n\nexport class SbbPropertyWatcherController<T extends LitElement> implements ReactiveController {\n  private _reference?: T | null;\n  private _watchers?: Map<string, PropertyWatcher<T>>;\n\n  public constructor(\n    private readonly _host: ReactiveControllerHost & HTMLElement,\n    private readonly _referenceResolver: () => T | null,\n    private readonly _handlers: Partial<Record<keyof T, PropertyWatcherHandler<T>>>,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    this.connect();\n  }\n\n  public hostDisconnected(): void {\n    if (this._reference !== this._referenceResolver()) {\n      this.disconnect();\n    }\n  }\n\n  public connect(): void {\n    const reference = this._referenceResolver();\n    if (this._reference === reference) {\n      return;\n    }\n    this.disconnect();\n    this._reference = reference;\n    if (!this._reference) {\n      return;\n    }\n    let watchers = propertyWatchers.get(this._reference) as\n      | Map<string, PropertyWatcher<T>>\n      | undefined;\n    if (!watchers) {\n      watchers = new Map();\n      propertyWatchers.set(this._reference, watchers);\n    }\n    this._watchers = watchers;\n\n    for (const [property, handler] of Object.entries(this._handlers)) {\n      let watcher = this._watchers.get(property);\n      if (!watcher) {\n        watcher = new PropertyWatcher<T>(this._reference, property);\n        this._watchers.set(property, watcher);\n      }\n      watcher.addHandler(handler);\n    }\n  }\n\n  public disconnect(): void {\n    if (!this._reference) {\n      return;\n    }\n\n    for (const [property, handler] of Object.entries(this._handlers)) {\n      const watcher = this._watchers?.get(property);\n      if (watcher) {\n        watcher.removeHandler(handler);\n        if (!watcher.size) {\n          this._watchers!.delete(property);\n          if (!this._watchers!.size && this._reference) {\n            propertyWatchers.delete(this._reference);\n          }\n        }\n      }\n    }\n    this._reference = null;\n  }\n}\n"],"mappings":";;AASA,IAAM,kBAAN,MAAqB;CAKnB,IAAW,OAAI;AACb,SAAO,KAAK,UAAU;;CAGxB,YACmB,OACA,WAAiB;AADjB,OAAA,QAAA;AACA,OAAA,YAAA;AATX,OAAA,4BAAY,IAAI,KAAgC;AAChD,OAAA,sBAA4C;AAUlD,MAAI,CAAC,SACH,KAAI,eAAe,IAAI,KAAK,MAAM,UAAU,CAC1C,gBAAe,QAAQ,KAAK,MAAM;MAGlC,MAAK,sBAAsB,eAAe,YAAY,KAAK,MAAM,UAAU,CAAC,WAAU;AACpF,kBAAe,QAAQ,KAAK,MAAM;AAClC,QAAK,sBAAsB;IAC3B;AAGN,OAAK,SAAU,KAAK,MAA6C,KAAK;;CAGjE,WAAW,SAAkC;AAClD,MAAI,CAAC,KAAK,UAAU;OAEd,KAAK,MAAM,cACb,MAAK,MAAM,cAAc,KAAK;YACrB,KAAK,oBACd,MAAK,oBAAoB,WAAW,KAAK,MAAM,cAAc,KAAK,CAAC;;AAGvE,OAAK,UAAU,IAAI,QAAQ;AAE3B,MAAI,CAAC,KAAK,oBACR,SAAQ,KAAK,MAAM;MAEnB,MAAK,oBAAoB,WAAW,QAAQ,KAAK,MAAM,CAAC;;CAIrD,cAAc,SAAkC;AACrD,OAAK,UAAU,OAAO,QAAQ;AAC9B,MAAI,CAAC,KAAK,UAAU;OAEd,KAAK,MAAM,iBACb,MAAK,MAAM,iBAAiB,KAAK;YACxB,KAAK,oBACd,MAAK,oBAAoB,WAAW,KAAK,MAAM,iBAAiB,KAAK,CAAC;;;CAKrE,aAAU;EACf,MAAM,eAAgB,KAAK,MAA6C,KAAK;AAC7E,MAAI,KAAK,WAAW,cAAc;AAChC,QAAK,SAAS;AACd,QAAK,MAAM,WAAW,KAAK,UACzB,SAAQ,KAAK,MAAM;;;;AAM3B,IAAM,mCAAmB,IAAI,SAAwD;AAErF,IAAa,+BAAb,MAAyC;CAIvC,YACmB,OACA,oBACA,WAA8D;AAF9D,OAAA,QAAA;AACA,OAAA,qBAAA;AACA,OAAA,YAAA;AAEjB,OAAK,MAAM,cAAc,KAAK;;CAGzB,gBAAa;AAClB,OAAK,SAAS;;CAGT,mBAAgB;AACrB,MAAI,KAAK,eAAe,KAAK,oBAAoB,CAC/C,MAAK,YAAY;;CAId,UAAO;EACZ,MAAM,YAAY,KAAK,oBAAoB;AAC3C,MAAI,KAAK,eAAe,UACtB;AAEF,OAAK,YAAY;AACjB,OAAK,aAAa;AAClB,MAAI,CAAC,KAAK,WACR;EAEF,IAAI,WAAW,iBAAiB,IAAI,KAAK,WAE5B;AACb,MAAI,CAAC,UAAU;AACb,8BAAW,IAAI,KAAK;AACpB,oBAAiB,IAAI,KAAK,YAAY,SAAS;;AAEjD,OAAK,YAAY;AAEjB,OAAK,MAAM,CAAC,UAAU,YAAY,OAAO,QAAQ,KAAK,UAAU,EAAE;GAChE,IAAI,UAAU,KAAK,UAAU,IAAI,SAAS;AAC1C,OAAI,CAAC,SAAS;AACZ,cAAU,IAAI,gBAAmB,KAAK,YAAY,SAAS;AAC3D,SAAK,UAAU,IAAI,UAAU,QAAQ;;AAEvC,WAAQ,WAAW,QAAQ;;;CAIxB,aAAU;AACf,MAAI,CAAC,KAAK,WACR;AAGF,OAAK,MAAM,CAAC,UAAU,YAAY,OAAO,QAAQ,KAAK,UAAU,EAAE;GAChE,MAAM,UAAU,KAAK,WAAW,IAAI,SAAS;AAC7C,OAAI,SAAS;AACX,YAAQ,cAAc,QAAQ;AAC9B,QAAI,CAAC,QAAQ,MAAM;AACjB,UAAK,UAAW,OAAO,SAAS;AAChC,SAAI,CAAC,KAAK,UAAW,QAAQ,KAAK,WAChC,kBAAiB,OAAO,KAAK,WAAW;;;;AAKhD,OAAK,aAAa"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"property-watcher-controller.js","sources":["../../../../../src/elements/core/controllers/property-watcher-controller.ts"],"sourcesContent":["import {\n  type ReactiveControllerHost,\n  type LitElement,\n  type ReactiveController,\n  isServer,\n} from 'lit';\n\ntype PropertyWatcherHandler<T extends LitElement> = (reference: T) => void;\n\nclass PropertyWatcher<T extends LitElement> implements ReactiveController {\n  private _value: unknown;\n  private _handlers = new Set<PropertyWatcherHandler<T>>();\n  private _hostDefinedPromise: Promise<void> | null = null;\n\n  public get size(): number {\n    return this._handlers.size;\n  }\n\n  public constructor(\n    private readonly _host: T,\n    private readonly _property: string,\n  ) {\n    if (!isServer) {\n      if (customElements.get(this._host.localName)) {\n        customElements.upgrade(this._host);\n      } else {\n        // The host element is not yet defined, wait for its definition before upgrading\n        this._hostDefinedPromise = customElements.whenDefined(this._host.localName).then(() => {\n          customElements.upgrade(this._host);\n          this._hostDefinedPromise = null;\n        });\n      }\n    }\n    this._value = (this._host as unknown as Record<string, unknown>)[this._property];\n  }\n\n  public addHandler(handler: PropertyWatcherHandler<T>): void {\n    if (!this._handlers.size) {\n      // We check if the addController method is available (element was defined && upgraded), otherwise we wait for the host to be defined\n      if (this._host.addController) {\n        this._host.addController(this);\n      } else if (this._hostDefinedPromise) {\n        this._hostDefinedPromise.then(() => this._host.addController(this));\n      }\n    }\n    this._handlers.add(handler);\n\n    if (!this._hostDefinedPromise) {\n      handler(this._host);\n    } else {\n      this._hostDefinedPromise.then(() => handler(this._host));\n    }\n  }\n\n  public removeHandler(handler: PropertyWatcherHandler<T>): void {\n    this._handlers.delete(handler);\n    if (!this._handlers.size) {\n      // We check if the removeController method is available (element was defined && upgraded), otherwise we wait for the host to be defined\n      if (this._host.removeController) {\n        this._host.removeController(this);\n      } else if (this._hostDefinedPromise) {\n        this._hostDefinedPromise.then(() => this._host.removeController(this));\n      }\n    }\n  }\n\n  public hostUpdate(): void {\n    const currentValue = (this._host as unknown as Record<string, unknown>)[this._property];\n    if (this._value !== currentValue) {\n      this._value = currentValue;\n      for (const handler of this._handlers) {\n        handler(this._host);\n      }\n    }\n  }\n}\n\nconst propertyWatchers = new WeakMap<LitElement, Map<string, PropertyWatcher<any>>>();\n\nexport class SbbPropertyWatcherController<T extends LitElement> implements ReactiveController {\n  private _reference?: T | null;\n  private _watchers?: Map<string, PropertyWatcher<T>>;\n\n  public constructor(\n    private readonly _host: ReactiveControllerHost & HTMLElement,\n    private readonly _referenceResolver: () => T | null,\n    private readonly _handlers: Partial<Record<keyof T, PropertyWatcherHandler<T>>>,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    this.connect();\n  }\n\n  public hostDisconnected(): void {\n    if (this._reference !== this._referenceResolver()) {\n      this.disconnect();\n    }\n  }\n\n  public connect(): void {\n    const reference = this._referenceResolver();\n    if (this._reference === reference) {\n      return;\n    }\n    this.disconnect();\n    this._reference = reference;\n    if (!this._reference) {\n      return;\n    }\n    let watchers = propertyWatchers.get(this._reference) as\n      | Map<string, PropertyWatcher<T>>\n      | undefined;\n    if (!watchers) {\n      watchers = new Map();\n      propertyWatchers.set(this._reference, watchers);\n    }\n    this._watchers = watchers;\n\n    for (const [property, handler] of Object.entries(this._handlers)) {\n      let watcher = this._watchers.get(property);\n      if (!watcher) {\n        watcher = new PropertyWatcher<T>(this._reference, property);\n        this._watchers.set(property, watcher);\n      }\n      watcher.addHandler(handler);\n    }\n  }\n\n  public disconnect(): void {\n    if (!this._reference) {\n      return;\n    }\n\n    for (const [property, handler] of Object.entries(this._handlers)) {\n      const watcher = this._watchers?.get(property);\n      if (watcher) {\n        watcher.removeHandler(handler);\n        if (!watcher.size) {\n          this._watchers!.delete(property);\n          if (!this._watchers!.size && this._reference) {\n            propertyWatchers.delete(this._reference);\n          }\n        }\n      }\n    }\n    this._reference = null;\n  }\n}\n"],"names":[],"mappings":";AASA,MAAM,gBAAe;AAAA,EAKnB,IAAW,OAAI;AACb,WAAO,KAAK,UAAU;AAAA,EACxB;AAAA,EAEA,YACmB,OACA,WAAiB;AADjB,SAAA,QAAA;AACA,SAAA,YAAA;AATX,SAAA,gCAAgB,IAAA;AAChB,SAAA,sBAA4C;AAUlD,QAAI,CAAC,UAAU;AACb,UAAI,eAAe,IAAI,KAAK,MAAM,SAAS,GAAG;AAC5C,uBAAe,QAAQ,KAAK,KAAK;AAAA,MACnC,OAAO;AAEL,aAAK,sBAAsB,eAAe,YAAY,KAAK,MAAM,SAAS,EAAE,KAAK,MAAK;AACpF,yBAAe,QAAQ,KAAK,KAAK;AACjC,eAAK,sBAAsB;AAAA,QAC7B,CAAC;AAAA,MACH;AAAA,IACF;AACA,SAAK,SAAU,KAAK,MAA6C,KAAK,SAAS;AAAA,EACjF;AAAA,EAEO,WAAW,SAAkC;AAClD,QAAI,CAAC,KAAK,UAAU,MAAM;AAExB,UAAI,KAAK,MAAM,eAAe;AAC5B,aAAK,MAAM,cAAc,IAAI;AAAA,MAC/B,WAAW,KAAK,qBAAqB;AACnC,aAAK,oBAAoB,KAAK,MAAM,KAAK,MAAM,cAAc,IAAI,CAAC;AAAA,MACpE;AAAA,IACF;AACA,SAAK,UAAU,IAAI,OAAO;AAE1B,QAAI,CAAC,KAAK,qBAAqB;AAC7B,cAAQ,KAAK,KAAK;AAAA,IACpB,OAAO;AACL,WAAK,oBAAoB,KAAK,MAAM,QAAQ,KAAK,KAAK,CAAC;AAAA,IACzD;AAAA,EACF;AAAA,EAEO,cAAc,SAAkC;AACrD,SAAK,UAAU,OAAO,OAAO;AAC7B,QAAI,CAAC,KAAK,UAAU,MAAM;AAExB,UAAI,KAAK,MAAM,kBAAkB;AAC/B,aAAK,MAAM,iBAAiB,IAAI;AAAA,MAClC,WAAW,KAAK,qBAAqB;AACnC,aAAK,oBAAoB,KAAK,MAAM,KAAK,MAAM,iBAAiB,IAAI,CAAC;AAAA,MACvE;AAAA,IACF;AAAA,EACF;AAAA,EAEO,aAAU;AACf,UAAM,eAAgB,KAAK,MAA6C,KAAK,SAAS;AACtF,QAAI,KAAK,WAAW,cAAc;AAChC,WAAK,SAAS;AACd,iBAAW,WAAW,KAAK,WAAW;AACpC,gBAAQ,KAAK,KAAK;AAAA,MACpB;AAAA,IACF;AAAA,EACF;AACD;AAED,MAAM,uCAAuB,QAAA;MAEhB,6BAA4B;AAAA,EAIvC,YACmB,OACA,oBACA,WAA8D;AAF9D,SAAA,QAAA;AACA,SAAA,qBAAA;AACA,SAAA,YAAA;AAEjB,SAAK,MAAM,cAAc,IAAI;AAAA,EAC/B;AAAA,EAEO,gBAAa;AAClB,SAAK,QAAA;AAAA,EACP;AAAA,EAEO,mBAAgB;AACrB,QAAI,KAAK,eAAe,KAAK,mBAAA,GAAsB;AACjD,WAAK,WAAA;AAAA,IACP;AAAA,EACF;AAAA,EAEO,UAAO;AACZ,UAAM,YAAY,KAAK,mBAAA;AACvB,QAAI,KAAK,eAAe,WAAW;AACjC;AAAA,IACF;AACA,SAAK,WAAA;AACL,SAAK,aAAa;AAClB,QAAI,CAAC,KAAK,YAAY;AACpB;AAAA,IACF;AACA,QAAI,WAAW,iBAAiB,IAAI,KAAK,UAAU;AAGnD,QAAI,CAAC,UAAU;AACb,qCAAe,IAAA;AACf,uBAAiB,IAAI,KAAK,YAAY,QAAQ;AAAA,IAChD;AACA,SAAK,YAAY;AAEjB,eAAW,CAAC,UAAU,OAAO,KAAK,OAAO,QAAQ,KAAK,SAAS,GAAG;AAChE,UAAI,UAAU,KAAK,UAAU,IAAI,QAAQ;AACzC,UAAI,CAAC,SAAS;AACZ,kBAAU,IAAI,gBAAmB,KAAK,YAAY,QAAQ;AAC1D,aAAK,UAAU,IAAI,UAAU,OAAO;AAAA,MACtC;AACA,cAAQ,WAAW,OAAO;AAAA,IAC5B;AAAA,EACF;AAAA,EAEO,aAAU;AACf,QAAI,CAAC,KAAK,YAAY;AACpB;AAAA,IACF;AAEA,eAAW,CAAC,UAAU,OAAO,KAAK,OAAO,QAAQ,KAAK,SAAS,GAAG;AAChE,YAAM,UAAU,KAAK,WAAW,IAAI,QAAQ;AAC5C,UAAI,SAAS;AACX,gBAAQ,cAAc,OAAO;AAC7B,YAAI,CAAC,QAAQ,MAAM;AACjB,eAAK,UAAW,OAAO,QAAQ;AAC/B,cAAI,CAAC,KAAK,UAAW,QAAQ,KAAK,YAAY;AAC5C,6BAAiB,OAAO,KAAK,UAAU;AAAA,UACzC;AAAA,QACF;AAAA,MACF;AAAA,IACF;AACA,SAAK,aAAa;AAAA,EACpB;AACD;"}

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

@@ -1,77 +1,65 @@
 import { isServer } from "lit";
-//#region src/elements/core/controllers/slot-state-controller.ts
-var SbbSlottedChangeEvent = class extends Event {
-	constructor(slot) {
-		super("slottedchange", { composed: true });
-		this.slot = slot;
-	}
+class SbbSlottedChangeEvent extends Event {
+  constructor(slot) {
+    super("slottedchange", { composed: true });
+    this.slot = slot;
+  }
+}
+class SbbSlotStateController {
+  constructor(_host, _internals) {
+    this._host = _host;
+    this._internals = _internals;
+    this._textObserver = !isServer && new MutationObserver(() => {
+      const slot = this._host.shadowRoot.querySelector("slot:not([name])");
+      if (slot) {
+        this._updateSlottedState(slot);
+      } else {
+        this._textObserver.disconnect();
+      }
+    });
+    this.hostConnected = () => {
+      this._host.shadowRoot?.addEventListener("slotchange", (e) => this._slotchangeHandler(e, e.target));
+      this._host.shadowRoot?.addEventListener("slottedchange", (e) => this._slotchangeHandler(e, e.slot), { capture: true });
+      this._internals.shadowRoot?.querySelectorAll("slot").forEach((slot) => this._handleSlotChange(slot));
+      this.hostConnected = void 0;
+    };
+    this._host.addController(this);
+  }
+  _slotchangeHandler(event, slot) {
+    const resolvedSlot = this._host.shadowRoot.contains(slot) ? slot : event.composedPath().find((el) => el instanceof HTMLSlotElement && this._host.shadowRoot.contains(el));
+    if (resolvedSlot) {
+      this._handleSlotChange(resolvedSlot);
+    }
+  }
+  _handleSlotChange(slot) {
+    this._updateSlottedState(slot);
+    if (!slot.name) {
+      this._observeTextNodesInSlot(slot);
+    }
+  }
+  _updateSlottedState(slot) {
+    const stateName = slot.name ? `slotted-${slot.name}` : "slotted";
+    const hasSlottedContent = this._hasSlottedContent(slot);
+    if (hasSlottedContent && !this._internals.states.has(stateName)) {
+      this._internals.states.add(stateName);
+      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));
+    } else if (!hasSlottedContent && this._internals.states.has(stateName)) {
+      this._internals.states.delete(stateName);
+      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));
+    }
+  }
+  _observeTextNodesInSlot(slot) {
+    this._textObserver.disconnect();
+    slot.assignedNodes().filter((n) => n.nodeType === n.TEXT_NODE).forEach((node) => this._textObserver.observe(node, { characterData: true }));
+  }
+  _hasSlottedContent(slot) {
+    return slot.name ? slot.assignedElements().some((node) => !(node instanceof HTMLSlotElement) || this._hasSlottedContent(node)) : slot.assignedNodes().some((node) => {
+      return node instanceof HTMLSlotElement ? this._hasSlottedContent(node) : node.nodeType !== node.TEXT_NODE || !!node.textContent?.trim();
+    });
+  }
+}
+export {
+  SbbSlotStateController,
+  SbbSlottedChangeEvent
 };
-/**
-* This controller checks for slotted children. From these it updates
-* the ElementInternals states with the pattern `slotted-<name>` or `slotted`
-* for the unnamed slot.
-*
-* This allows a :is(:state(slotted-<name>),[state--slotted-<name>]) CSS selector to display/hide/configure
-* a section of the component as required.
-*
-* @example
-* .example {
-*   display: none;
-*
-*   :host(:is(:state(slotted-icon),[state--slotted-icon])) & {
-*     display: inline;
-*   }
-* }
-*
-* https://developer.mozilla.org/en-US/docs/Web/CSS/:state
-*/
-var SbbSlotStateController = class {
-	constructor(_host, _internals) {
-		this._host = _host;
-		this._internals = _internals;
-		this._textObserver = !isServer && new MutationObserver(() => {
-			const slot = this._host.shadowRoot.querySelector("slot:not([name])");
-			if (slot) this._updateSlottedState(slot);
-			else this._textObserver.disconnect();
-		});
-		this.hostConnected = () => {
-			this._host.shadowRoot?.addEventListener("slotchange", (e) => this._slotchangeHandler(e, e.target));
-			this._host.shadowRoot?.addEventListener("slottedchange", (e) => this._slotchangeHandler(e, e.slot), { capture: true });
-			this._internals.shadowRoot?.querySelectorAll("slot").forEach((slot) => this._handleSlotChange(slot));
-			this.hostConnected = void 0;
-		};
-		this._host.addController(this);
-	}
-	_slotchangeHandler(event, slot) {
-		const resolvedSlot = this._host.shadowRoot.contains(slot) ? slot : event.composedPath().find((el) => el instanceof HTMLSlotElement && this._host.shadowRoot.contains(el));
-		if (resolvedSlot) this._handleSlotChange(resolvedSlot);
-	}
-	_handleSlotChange(slot) {
-		this._updateSlottedState(slot);
-		if (!slot.name) this._observeTextNodesInSlot(slot);
-	}
-	_updateSlottedState(slot) {
-		const stateName = slot.name ? `slotted-${slot.name}` : "slotted";
-		const hasSlottedContent = this._hasSlottedContent(slot);
-		if (hasSlottedContent && !this._internals.states.has(stateName)) {
-			this._internals.states.add(stateName);
-			this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));
-		} else if (!hasSlottedContent && this._internals.states.has(stateName)) {
-			this._internals.states.delete(stateName);
-			this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));
-		}
-	}
-	_observeTextNodesInSlot(slot) {
-		this._textObserver.disconnect();
-		slot.assignedNodes().filter((n) => n.nodeType === n.TEXT_NODE).forEach((node) => this._textObserver.observe(node, { characterData: true }));
-	}
-	_hasSlottedContent(slot) {
-		return slot.name ? slot.assignedElements().some((node) => !(node instanceof HTMLSlotElement) || this._hasSlottedContent(node)) : slot.assignedNodes().some((node) => {
-			return node instanceof HTMLSlotElement ? this._hasSlottedContent(node) : node.nodeType !== node.TEXT_NODE || !!node.textContent?.trim();
-		});
-	}
-};
-//#endregion
-export { SbbSlotStateController, SbbSlottedChangeEvent };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"slot-state-controller.js","names":[],"sources":["../../../../../src/elements/core/controllers/slot-state-controller.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nexport class SbbSlottedChangeEvent extends Event {\n  public constructor(public readonly slot: HTMLSlotElement) {\n    super('slottedchange', { composed: true });\n  }\n}\n\n/**\n * This controller checks for slotted children. From these it updates\n * the ElementInternals states with the pattern `slotted-<name>` or `slotted`\n * for the unnamed slot.\n *\n * This allows a :state(slotted-<name>) CSS selector to display/hide/configure\n * a section of the component as required.\n *\n * @example\n * .example {\n *   display: none;\n *\n *   :host(:state(slotted-icon)) & {\n *     display: inline;\n *   }\n * }\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/:state\n */\nexport class SbbSlotStateController implements ReactiveController {\n  private _textObserver =\n    !isServer &&\n    new MutationObserver(() => {\n      const slot = this._host.shadowRoot!.querySelector<HTMLSlotElement>('slot:not([name])');\n      if (slot) {\n        this._updateSlottedState(slot);\n      } else {\n        this._textObserver.disconnect();\n      }\n    });\n\n  public constructor(\n    private _host: ReactiveControllerHost & HTMLElement,\n    private _internals: ElementInternals,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected: ReactiveController['hostConnected'] = (): void => {\n    this._host.shadowRoot?.addEventListener('slotchange', (e) =>\n      this._slotchangeHandler(e, e.target as HTMLSlotElement),\n    );\n    this._host.shadowRoot?.addEventListener(\n      'slottedchange',\n      (e) => this._slotchangeHandler(e, e.slot),\n      { capture: true },\n    );\n    this._internals.shadowRoot\n      ?.querySelectorAll('slot')\n      .forEach((slot) => this._handleSlotChange(slot));\n    this.hostConnected = undefined;\n  };\n\n  private _slotchangeHandler(event: Event, slot: HTMLSlotElement): void {\n    const resolvedSlot = this._host.shadowRoot!.contains(slot)\n      ? slot\n      : event\n          .composedPath()\n          .find(\n            (el): el is HTMLSlotElement =>\n              el instanceof HTMLSlotElement && this._host.shadowRoot!.contains(el),\n          );\n    if (resolvedSlot) {\n      this._handleSlotChange(resolvedSlot);\n    }\n  }\n\n  private _handleSlotChange(slot: HTMLSlotElement): void {\n    this._updateSlottedState(slot);\n    if (!slot.name) {\n      this._observeTextNodesInSlot(slot);\n    }\n  }\n\n  private _updateSlottedState(slot: HTMLSlotElement): void {\n    const stateName = slot.name ? `slotted-${slot.name}` : 'slotted';\n    const hasSlottedContent = this._hasSlottedContent(slot);\n    if (hasSlottedContent && !this._internals.states.has(stateName)) {\n      this._internals.states.add(stateName);\n      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));\n    } else if (!hasSlottedContent && this._internals.states.has(stateName)) {\n      this._internals.states.delete(stateName);\n      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));\n    }\n  }\n\n  private _observeTextNodesInSlot(slot: HTMLSlotElement): void {\n    this._textObserver.disconnect();\n    // Text nodes can be empty and filled later (or vice versa).\n    // Filling an existing node later would not trigger another slotchange event.\n    // Therefore, we need to observe text nodes and check if they become filled or empty.\n    // This is only needed for the unnamed slot as for every other there would\n    // be a tag which triggers the slot change event.\n    // The main reason is that Angular creates empty text nodes and fills them later.\n    slot\n      .assignedNodes()\n      .filter((n) => n.nodeType === n.TEXT_NODE)\n      .forEach((node) => this._textObserver.observe(node, { characterData: true }));\n  }\n\n  private _hasSlottedContent(slot: HTMLSlotElement): boolean {\n    return slot.name\n      ? slot\n          .assignedElements()\n          .some((node) => !(node instanceof HTMLSlotElement) || this._hasSlottedContent(node))\n      : slot.assignedNodes().some((node) => {\n          return node instanceof HTMLSlotElement\n            ? this._hasSlottedContent(node)\n            : node.nodeType !== node.TEXT_NODE || !!node.textContent?.trim();\n        });\n  }\n}\n\ndeclare global {\n  interface HTMLElementEventMap {\n    slottedchange: SbbSlottedChangeEvent;\n  }\n  interface ShadowRootEventMap {\n    slottedchange: SbbSlottedChangeEvent;\n  }\n}\n"],"mappings":";;AAEA,IAAa,wBAAb,cAA2C,MAAK;CAC9C,YAAmC,MAAqB;AACtD,QAAM,iBAAiB,EAAE,UAAU,MAAM,CAAC;AADT,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;AAwBrC,IAAa,yBAAb,MAAmC;CAYjC,YACU,OACA,YAA4B;AAD5B,OAAA,QAAA;AACA,OAAA,aAAA;AAbF,OAAA,gBACN,CAAC,YACD,IAAI,uBAAsB;GACxB,MAAM,OAAO,KAAK,MAAM,WAAY,cAA+B,mBAAmB;AACtF,OAAI,KACF,MAAK,oBAAoB,KAAK;OAE9B,MAAK,cAAc,YAAY;IAEjC;AASG,OAAA,sBAAgE;AACrE,QAAK,MAAM,YAAY,iBAAiB,eAAe,MACrD,KAAK,mBAAmB,GAAG,EAAE,OAA0B,CACxD;AACD,QAAK,MAAM,YAAY,iBACrB,kBACC,MAAM,KAAK,mBAAmB,GAAG,EAAE,KAAK,EACzC,EAAE,SAAS,MAAM,CAClB;AACD,QAAK,WAAW,YACZ,iBAAiB,OAAO,CACzB,SAAS,SAAS,KAAK,kBAAkB,KAAK,CAAC;AAClD,QAAK,gBAAgB,KAAA;;AAfrB,OAAK,MAAM,cAAc,KAAK;;CAkBxB,mBAAmB,OAAc,MAAqB;EAC5D,MAAM,eAAe,KAAK,MAAM,WAAY,SAAS,KAAK,GACtD,OACA,MACG,cAAc,CACd,MACE,OACC,cAAc,mBAAmB,KAAK,MAAM,WAAY,SAAS,GAAG,CACvE;AACP,MAAI,aACF,MAAK,kBAAkB,aAAa;;CAIhC,kBAAkB,MAAqB;AAC7C,OAAK,oBAAoB,KAAK;AAC9B,MAAI,CAAC,KAAK,KACR,MAAK,wBAAwB,KAAK;;CAI9B,oBAAoB,MAAqB;EAC/C,MAAM,YAAY,KAAK,OAAO,WAAW,KAAK,SAAS;EACvD,MAAM,oBAAoB,KAAK,mBAAmB,KAAK;AACvD,MAAI,qBAAqB,CAAC,KAAK,WAAW,OAAO,IAAI,UAAU,EAAE;AAC/D,QAAK,WAAW,OAAO,IAAI,UAAU;AACrC,QAAK,MAAM,cAAc,IAAI,sBAAsB,KAAK,CAAC;aAChD,CAAC,qBAAqB,KAAK,WAAW,OAAO,IAAI,UAAU,EAAE;AACtE,QAAK,WAAW,OAAO,OAAO,UAAU;AACxC,QAAK,MAAM,cAAc,IAAI,sBAAsB,KAAK,CAAC;;;CAIrD,wBAAwB,MAAqB;AACnD,OAAK,cAAc,YAAY;AAO/B,OACG,eAAe,CACf,QAAQ,MAAM,EAAE,aAAa,EAAE,UAAU,CACzC,SAAS,SAAS,KAAK,cAAc,QAAQ,MAAM,EAAE,eAAe,MAAM,CAAC,CAAC;;CAGzE,mBAAmB,MAAqB;AAC9C,SAAO,KAAK,OACR,KACG,kBAAkB,CAClB,MAAM,SAAS,EAAE,gBAAgB,oBAAoB,KAAK,mBAAmB,KAAK,CAAC,GACtF,KAAK,eAAe,CAAC,MAAM,SAAQ;AACjC,UAAO,gBAAgB,kBACnB,KAAK,mBAAmB,KAAK,GAC7B,KAAK,aAAa,KAAK,aAAa,CAAC,CAAC,KAAK,aAAa,MAAM;IAClE"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"slot-state-controller.js","sources":["../../../../../src/elements/core/controllers/slot-state-controller.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nexport class SbbSlottedChangeEvent extends Event {\n  public constructor(public readonly slot: HTMLSlotElement) {\n    super('slottedchange', { composed: true });\n  }\n}\n\n/**\n * This controller checks for slotted children. From these it updates\n * the ElementInternals states with the pattern `slotted-<name>` or `slotted`\n * for the unnamed slot.\n *\n * This allows a :state(slotted-<name>) CSS selector to display/hide/configure\n * a section of the component as required.\n *\n * @example\n * .example {\n *   display: none;\n *\n *   :host(:state(slotted-icon)) & {\n *     display: inline;\n *   }\n * }\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/:state\n */\nexport class SbbSlotStateController implements ReactiveController {\n  private _textObserver =\n    !isServer &&\n    new MutationObserver(() => {\n      const slot = this._host.shadowRoot!.querySelector<HTMLSlotElement>('slot:not([name])');\n      if (slot) {\n        this._updateSlottedState(slot);\n      } else {\n        this._textObserver.disconnect();\n      }\n    });\n\n  public constructor(\n    private _host: ReactiveControllerHost & HTMLElement,\n    private _internals: ElementInternals,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected: ReactiveController['hostConnected'] = (): void => {\n    this._host.shadowRoot?.addEventListener('slotchange', (e) =>\n      this._slotchangeHandler(e, e.target as HTMLSlotElement),\n    );\n    this._host.shadowRoot?.addEventListener(\n      'slottedchange',\n      (e) => this._slotchangeHandler(e, e.slot),\n      { capture: true },\n    );\n    this._internals.shadowRoot\n      ?.querySelectorAll('slot')\n      .forEach((slot) => this._handleSlotChange(slot));\n    this.hostConnected = undefined;\n  };\n\n  private _slotchangeHandler(event: Event, slot: HTMLSlotElement): void {\n    const resolvedSlot = this._host.shadowRoot!.contains(slot)\n      ? slot\n      : event\n          .composedPath()\n          .find(\n            (el): el is HTMLSlotElement =>\n              el instanceof HTMLSlotElement && this._host.shadowRoot!.contains(el),\n          );\n    if (resolvedSlot) {\n      this._handleSlotChange(resolvedSlot);\n    }\n  }\n\n  private _handleSlotChange(slot: HTMLSlotElement): void {\n    this._updateSlottedState(slot);\n    if (!slot.name) {\n      this._observeTextNodesInSlot(slot);\n    }\n  }\n\n  private _updateSlottedState(slot: HTMLSlotElement): void {\n    const stateName = slot.name ? `slotted-${slot.name}` : 'slotted';\n    const hasSlottedContent = this._hasSlottedContent(slot);\n    if (hasSlottedContent && !this._internals.states.has(stateName)) {\n      this._internals.states.add(stateName);\n      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));\n    } else if (!hasSlottedContent && this._internals.states.has(stateName)) {\n      this._internals.states.delete(stateName);\n      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));\n    }\n  }\n\n  private _observeTextNodesInSlot(slot: HTMLSlotElement): void {\n    this._textObserver.disconnect();\n    // Text nodes can be empty and filled later (or vice versa).\n    // Filling an existing node later would not trigger another slotchange event.\n    // Therefore, we need to observe text nodes and check if they become filled or empty.\n    // This is only needed for the unnamed slot as for every other there would\n    // be a tag which triggers the slot change event.\n    // The main reason is that Angular creates empty text nodes and fills them later.\n    slot\n      .assignedNodes()\n      .filter((n) => n.nodeType === n.TEXT_NODE)\n      .forEach((node) => this._textObserver.observe(node, { characterData: true }));\n  }\n\n  private _hasSlottedContent(slot: HTMLSlotElement): boolean {\n    return slot.name\n      ? slot\n          .assignedElements()\n          .some((node) => !(node instanceof HTMLSlotElement) || this._hasSlottedContent(node))\n      : slot.assignedNodes().some((node) => {\n          return node instanceof HTMLSlotElement\n            ? this._hasSlottedContent(node)\n            : node.nodeType !== node.TEXT_NODE || !!node.textContent?.trim();\n        });\n  }\n}\n\ndeclare global {\n  interface HTMLElementEventMap {\n    slottedchange: SbbSlottedChangeEvent;\n  }\n  interface ShadowRootEventMap {\n    slottedchange: SbbSlottedChangeEvent;\n  }\n}\n"],"names":[],"mappings":";AAEM,MAAO,8BAA8B,MAAK;AAAA,EAC9C,YAAmC,MAAqB;AACtD,UAAM,iBAAiB,EAAE,UAAU,KAAA,CAAM;AADR,SAAA,OAAA;AAAA,EAEnC;AACD;MAqBY,uBAAsB;AAAA,EAYjC,YACU,OACA,YAA4B;AAD5B,SAAA,QAAA;AACA,SAAA,aAAA;AAbF,SAAA,gBACN,CAAC,YACD,IAAI,iBAAiB,MAAK;AACxB,YAAM,OAAO,KAAK,MAAM,WAAY,cAA+B,kBAAkB;AACrF,UAAI,MAAM;AACR,aAAK,oBAAoB,IAAI;AAAA,MAC/B,OAAO;AACL,aAAK,cAAc,WAAA;AAAA,MACrB;AAAA,IACF,CAAC;AASI,SAAA,gBAAqD,MAAW;AACrE,WAAK,MAAM,YAAY,iBAAiB,cAAc,CAAC,MACrD,KAAK,mBAAmB,GAAG,EAAE,MAAyB,CAAC;AAEzD,WAAK,MAAM,YAAY,iBACrB,iBACA,CAAC,MAAM,KAAK,mBAAmB,GAAG,EAAE,IAAI,GACxC,EAAE,SAAS,MAAM;AAEnB,WAAK,WAAW,YACZ,iBAAiB,MAAM,EACxB,QAAQ,CAAC,SAAS,KAAK,kBAAkB,IAAI,CAAC;AACjD,WAAK,gBAAgB;AAAA,IACvB;AAhBE,SAAK,MAAM,cAAc,IAAI;AAAA,EAC/B;AAAA,EAiBQ,mBAAmB,OAAc,MAAqB;AAC5D,UAAM,eAAe,KAAK,MAAM,WAAY,SAAS,IAAI,IACrD,OACA,MACG,aAAA,EACA,KACC,CAAC,OACC,cAAc,mBAAmB,KAAK,MAAM,WAAY,SAAS,EAAE,CAAC;AAE9E,QAAI,cAAc;AAChB,WAAK,kBAAkB,YAAY;AAAA,IACrC;AAAA,EACF;AAAA,EAEQ,kBAAkB,MAAqB;AAC7C,SAAK,oBAAoB,IAAI;AAC7B,QAAI,CAAC,KAAK,MAAM;AACd,WAAK,wBAAwB,IAAI;AAAA,IACnC;AAAA,EACF;AAAA,EAEQ,oBAAoB,MAAqB;AAC/C,UAAM,YAAY,KAAK,OAAO,WAAW,KAAK,IAAI,KAAK;AACvD,UAAM,oBAAoB,KAAK,mBAAmB,IAAI;AACtD,QAAI,qBAAqB,CAAC,KAAK,WAAW,OAAO,IAAI,SAAS,GAAG;AAC/D,WAAK,WAAW,OAAO,IAAI,SAAS;AACpC,WAAK,MAAM,cAAc,IAAI,sBAAsB,IAAI,CAAC;AAAA,IAC1D,WAAW,CAAC,qBAAqB,KAAK,WAAW,OAAO,IAAI,SAAS,GAAG;AACtE,WAAK,WAAW,OAAO,OAAO,SAAS;AACvC,WAAK,MAAM,cAAc,IAAI,sBAAsB,IAAI,CAAC;AAAA,IAC1D;AAAA,EACF;AAAA,EAEQ,wBAAwB,MAAqB;AACnD,SAAK,cAAc,WAAA;AAOnB,SACG,cAAA,EACA,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EACxC,QAAQ,CAAC,SAAS,KAAK,cAAc,QAAQ,MAAM,EAAE,eAAe,KAAA,CAAM,CAAC;AAAA,EAChF;AAAA,EAEQ,mBAAmB,MAAqB;AAC9C,WAAO,KAAK,OACR,KACG,iBAAA,EACA,KAAK,CAAC,SAAS,EAAE,gBAAgB,oBAAoB,KAAK,mBAAmB,IAAI,CAAC,IACrF,KAAK,cAAA,EAAgB,KAAK,CAAC,SAAQ;AACjC,aAAO,gBAAgB,kBACnB,KAAK,mBAAmB,IAAI,IAC5B,KAAK,aAAa,KAAK,aAAa,CAAC,CAAC,KAAK,aAAa,KAAA;AAAA,IAC9D,CAAC;AAAA,EACP;AACD;"}

package/development/core/controllers.js

@@ -6,4 +6,26 @@ import { SbbLanguageController } from "./controllers/language-controller.js";
 import { SbbDarkModeController, SbbMediaMatcherController, SbbMediaQueryBreakpointLargeAndAbove, SbbMediaQueryBreakpointLargeAndBelow, SbbMediaQueryBreakpointSmallAndAbove, SbbMediaQueryBreakpointSmallAndBelow, SbbMediaQueryBreakpointUltraAndAbove, SbbMediaQueryBreakpointZeroAndAbove, SbbMediaQueryDarkMode, SbbMediaQueryForcedColors, SbbMediaQueryHover, SbbMediaQueryPointerCoarse } from "./controllers/media-matchers-controller.js";
 import { SbbSlotStateController, SbbSlottedChangeEvent } from "./controllers/slot-state-controller.js";
 import { SbbOverlayPositionController } from "./controllers/overlay-position-controller.js";
-export { SbbDarkModeController, SbbEscapableOverlayController, SbbIdReferenceController, SbbInertController, SbbLanguageController, SbbMediaMatcherController, SbbMediaQueryBreakpointLargeAndAbove, SbbMediaQueryBreakpointLargeAndBelow, SbbMediaQueryBreakpointSmallAndAbove, SbbMediaQueryBreakpointSmallAndBelow, SbbMediaQueryBreakpointUltraAndAbove, SbbMediaQueryBreakpointZeroAndAbove, SbbMediaQueryDarkMode, SbbMediaQueryForcedColors, SbbMediaQueryHover, SbbMediaQueryPointerCoarse, SbbOverlayPositionController, SbbPropertyWatcherController, SbbSlotStateController, SbbSlottedChangeEvent };
+export {
+  SbbDarkModeController,
+  SbbEscapableOverlayController,
+  SbbIdReferenceController,
+  SbbInertController,
+  SbbLanguageController,
+  SbbMediaMatcherController,
+  SbbMediaQueryBreakpointLargeAndAbove,
+  SbbMediaQueryBreakpointLargeAndBelow,
+  SbbMediaQueryBreakpointSmallAndAbove,
+  SbbMediaQueryBreakpointSmallAndBelow,
+  SbbMediaQueryBreakpointUltraAndAbove,
+  SbbMediaQueryBreakpointZeroAndAbove,
+  SbbMediaQueryDarkMode,
+  SbbMediaQueryForcedColors,
+  SbbMediaQueryHover,
+  SbbMediaQueryPointerCoarse,
+  SbbOverlayPositionController,
+  SbbPropertyWatcherController,
+  SbbSlotStateController,
+  SbbSlottedChangeEvent
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbGxlcnMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OzsifQ==