@sbb-esta/lyne-elements 4.6.0 → 4.8.0

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

@@ -1,287 +1,301 @@
 import { isServer } from "lit";
-const cssAnchorPositionSupported = !isServer && CSS.supports("anchor-name", "--test");
-const logicalSupportedPositions = [
-  "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"
+//#region src/elements/core/controllers/overlay-position-controller.ts
+var cssAnchorPositionSupported = !isServer && CSS.supports("anchor-name", "--test");
+var physicalSupportedPositions = [
+	"top",
+	"bottom",
+	"left",
+	"right",
+	"top span-left",
+	"top span-right",
+	"bottom span-left",
+	"bottom span-right",
+	"left span-top",
+	"left span-bottom",
+	"right span-top",
+	"right span-bottom"
 ];
-const rtlPositionMapping = {
-  "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"
+var logicalSupportedPositions = [
+	"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"
+];
+var rtlPositionMapping = {
+	"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 nextId = 0;
-class SbbOverlayPositionController {
-  /** Get the current position. (e.g. block-end, block-start, etc.) */
-  get currentPosition() {
-    if (this._usePolyfill) {
-      return this._lastPosition ?? this._positions[0] ?? "";
-    } else {
-      this._overlayStyles ??= getComputedStyle(this._overlay);
-      return this._overlayStyles.getPropertyValue("position-area");
-    }
-  }
-  constructor(host, _usePolyfill = !cssAnchorPositionSupported) {
-    this._usePolyfill = _usePolyfill;
-    this._resizeObserver = !isServer ? new ResizeObserver(() => this._requestCalculatePosition()) : null;
-    this._anchorName = `--sbb-overlay-anchor-${++nextId}`;
-    this._positions = [];
-    host.addController(this);
-    this._overlay = host;
-  }
-  hostConnected() {
-    if (!this._usePolyfill) {
-      this._overlay.style.setProperty("position-anchor", this._anchorName);
-    } else {
-      this._overlay.style.setProperty("position-area", "initial");
-    }
-  }
-  hostUpdate() {
-    if (isServer) {
-      return;
-    }
-    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(anchor) {
-    if (isServer) {
-      return;
-    }
-    if (this._anchor) {
-      this.disconnect();
-    }
-    this._anchor = anchor;
-    if (!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: true,
-      passive: true,
-      signal: this._abortController.signal
-    });
-    window.addEventListener("resize", () => this._requestCalculatePosition(), {
-      passive: true,
-      signal: this._abortController.signal
-    });
-    this._resizeObserver.observe(anchor, { 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) {
-      return;
-    }
-    if (this._usePolyfill) {
-      const position = this._getOptimalPosition(this._positions);
-      this._applyOverlayPosition(position.position, position.left, position.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(positions) {
-    const { offsetHeight: overlayHeight, offsetWidth: overlayWidth } = this._overlay;
-    const { innerHeight: viewportHeight, innerWidth: viewportWidth } = window;
-    const { top: triggerOffsetTop, left: triggerOffsetLeft, height: triggerHeight, width: triggerWidth } = this._anchor.getBoundingClientRect();
-    const isRtl = this._overlay.matches(":dir(rtl)");
-    const topSpace = triggerOffsetTop;
-    const bottomSpace = viewportHeight - triggerHeight - triggerOffsetTop;
-    const leftSpace = triggerOffsetLeft;
-    const rightSpace = viewportWidth - triggerWidth - triggerOffsetLeft;
-    const overlayWidthNet = overlayWidth - triggerWidth;
-    const overlayHeightNet = overlayHeight - triggerHeight;
-    const overlayWidthOverlap = overlayWidthNet / 2;
-    const overlayHeightOverlap = overlayHeightNet / 2;
-    this._overlay.style.setProperty("--sbb-overlay-controller-trigger-height", `${triggerHeight}px`);
-    this._overlay.style.setProperty("--sbb-overlay-controller-trigger-width", `${triggerWidth}px`);
-    let result = { left: 0, top: 0, position: "" };
-    let firstPosition = void 0;
-    for (const position of positions) {
-      const physicalPosition = isRtl && logicalSupportedPositions.includes(position) ? rtlPositionMapping[position] : position;
-      switch (physicalPosition) {
-        default:
-        case "bottom":
-        case "block-end":
-          result = {
-            position,
-            left: triggerOffsetLeft - overlayWidthOverlap,
-            top: triggerOffsetTop + triggerHeight,
-            fits: overlayHeight <= bottomSpace && overlayWidthOverlap <= leftSpace && overlayWidthOverlap <= rightSpace
-          };
-          break;
-        case "top":
-        case "block-start":
-          result = {
-            position,
-            left: triggerOffsetLeft - overlayWidthOverlap,
-            top: triggerOffsetTop - overlayHeight,
-            fits: overlayHeight <= topSpace && overlayWidthOverlap <= leftSpace && overlayWidthOverlap <= rightSpace
-          };
-          break;
-        case "right":
-        case "inline-end":
-          result = {
-            position,
-            left: triggerOffsetLeft + triggerWidth,
-            top: triggerOffsetTop - overlayHeightOverlap,
-            fits: overlayWidth <= rightSpace && overlayHeightOverlap <= topSpace && overlayHeightOverlap <= bottomSpace
-          };
-          break;
-        case "left":
-        case "inline-start":
-          result = {
-            position,
-            left: triggerOffsetLeft - overlayWidth,
-            top: triggerOffsetTop - overlayHeightOverlap,
-            fits: overlayWidth <= leftSpace && overlayHeightOverlap <= topSpace && overlayHeightOverlap <= bottomSpace
-          };
-          break;
-        case "top span-left":
-        case "block-start span-inline-start":
-          result = {
-            position,
-            left: triggerOffsetLeft - overlayWidthNet,
-            top: triggerOffsetTop - overlayHeight,
-            fits: overlayHeight <= topSpace && overlayWidthNet <= leftSpace
-          };
-          break;
-        case "top span-right":
-        case "block-start span-inline-end":
-          result = {
-            position,
-            left: triggerOffsetLeft,
-            top: triggerOffsetTop - overlayHeight,
-            fits: overlayHeight <= topSpace && overlayWidthNet <= rightSpace
-          };
-          break;
-        case "bottom span-left":
-        case "block-end span-inline-start":
-          result = {
-            position,
-            left: triggerOffsetLeft - overlayWidthNet,
-            top: triggerOffsetTop + triggerHeight,
-            fits: overlayHeight <= bottomSpace && overlayWidthNet <= leftSpace
-          };
-          break;
-        case "bottom span-right":
-        case "block-end span-inline-end":
-          result = {
-            position,
-            left: triggerOffsetLeft,
-            top: triggerOffsetTop + triggerHeight,
-            fits: overlayHeight <= bottomSpace && overlayWidthNet <= rightSpace
-          };
-          break;
-        case "left span-top":
-        case "inline-start span-block-start":
-          result = {
-            position,
-            left: triggerOffsetLeft - overlayWidth,
-            top: triggerOffsetTop + triggerHeight - overlayHeight,
-            fits: overlayWidth <= leftSpace && overlayHeightNet <= topSpace
-          };
-          break;
-        case "left span-bottom":
-        case "inline-start span-block-end":
-          result = {
-            position,
-            left: triggerOffsetLeft - overlayWidth,
-            top: triggerOffsetTop,
-            fits: overlayWidth <= leftSpace && overlayHeightNet <= bottomSpace
-          };
-          break;
-        case "right span-top":
-        case "inline-end span-block-start":
-          result = {
-            position,
-            left: triggerOffsetLeft + triggerWidth,
-            top: triggerOffsetTop + triggerHeight - overlayHeight,
-            fits: overlayWidth <= rightSpace && overlayHeightNet <= topSpace
-          };
-          break;
-        case "right span-bottom":
-        case "inline-end span-block-end":
-          result = {
-            position,
-            left: triggerOffsetLeft + triggerWidth,
-            top: triggerOffsetTop,
-            fits: overlayWidth <= rightSpace && overlayHeightNet <= bottomSpace
-          };
-          break;
-      }
-      if (result.fits) {
-        return result;
-      }
-      firstPosition ??= result;
-    }
-    return firstPosition;
-  }
-  _applyOverlayPosition(position, left, top) {
-    this._lastPosition = position;
-    this._overlay.style.left = `${left}px`;
-    this._overlay.style.top = `${top}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 positions = [
-      this._overlayStyles.getPropertyValue("--sbb-overlay-position-area") || "block-end",
-      ...this._overlayStyles.getPropertyValue("--sbb-overlay-position-try-fallbacks").split(",").map((f) => f.trim()).filter((f) => !!f)
-    ];
-    this._positions = positions;
-    if (this._lastPosition && !this._positions.includes(this._lastPosition)) {
-      this._lastPosition = void 0;
-    }
-  }
-}
-export {
-  SbbOverlayPositionController
+[...physicalSupportedPositions, ...logicalSupportedPositions];
+var nextId = 0;
+/**
+* Controller for managing overlays positioning. Also acts as a polyfill when native
+* CSS Anchor Positioning is not supported (enough).
+* Applies unique anchor names when using native CSS Anchor Positioning
+* or calculates and applies correct positions in polyfill mode.
+*
+* Also, the controller sets the 'data-position' attribute on the overlay element.
+* This can be used to apply specific styles based on the current position of the overlay.
+*
+* ### Implementation
+* Define and apply the following CSS variables on the overlay element:
+* ```scss
+*   --sbb-overlay-position-area: block-end; // Default
+*   --sbb-overlay-position-try-fallbacks: block-start, inline-end, inline-start; // Fallbacks
+*
+*   position-area: var(--sbb-overlay-position-area);
+*   position-try-fallbacks: var(--sbb-overlay-position-try-fallbacks);
+* ```
+*/
+var SbbOverlayPositionController = class {
+	/** Get the current position. (e.g. block-end, block-start, etc.) */
+	get currentPosition() {
+		if (this._usePolyfill) return this._lastPosition ?? this._positions[0] ?? "";
+		else {
+			this._overlayStyles ??= getComputedStyle(this._overlay);
+			return this._overlayStyles.getPropertyValue("position-area");
+		}
+	}
+	constructor(host, _usePolyfill = !cssAnchorPositionSupported) {
+		this._usePolyfill = _usePolyfill;
+		this._resizeObserver = !isServer ? new ResizeObserver(() => this._requestCalculatePosition()) : null;
+		this._anchorName = `--sbb-overlay-anchor-${++nextId}`;
+		this._positions = [];
+		host.addController(this);
+		this._overlay = host;
+	}
+	hostConnected() {
+		if (!this._usePolyfill) this._overlay.style.setProperty("position-anchor", this._anchorName);
+		else this._overlay.style.setProperty("position-area", "initial");
+	}
+	hostUpdate() {
+		if (isServer) return;
+		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(anchor) {
+		if (isServer) return;
+		if (this._anchor) this.disconnect();
+		this._anchor = anchor;
+		if (!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: true,
+			passive: true,
+			signal: this._abortController.signal
+		});
+		window.addEventListener("resize", () => this._requestCalculatePosition(), {
+			passive: true,
+			signal: this._abortController.signal
+		});
+		this._resizeObserver.observe(anchor, { 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) return;
+		if (this._usePolyfill) {
+			const position = this._getOptimalPosition(this._positions);
+			this._applyOverlayPosition(position.position, position.left, position.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(positions) {
+		const { offsetHeight: overlayHeight, offsetWidth: overlayWidth } = this._overlay;
+		const { innerHeight: viewportHeight, innerWidth: viewportWidth } = window;
+		const { top: triggerOffsetTop, left: triggerOffsetLeft, height: triggerHeight, width: triggerWidth } = this._anchor.getBoundingClientRect();
+		const isRtl = this._overlay.matches(":dir(rtl)");
+		const topSpace = triggerOffsetTop;
+		const bottomSpace = viewportHeight - triggerHeight - triggerOffsetTop;
+		const leftSpace = triggerOffsetLeft;
+		const rightSpace = viewportWidth - triggerWidth - triggerOffsetLeft;
+		const overlayWidthNet = overlayWidth - triggerWidth;
+		const overlayHeightNet = overlayHeight - triggerHeight;
+		const overlayWidthOverlap = overlayWidthNet / 2;
+		const overlayHeightOverlap = overlayHeightNet / 2;
+		this._overlay.style.setProperty("--sbb-overlay-controller-trigger-height", `${triggerHeight}px`);
+		this._overlay.style.setProperty("--sbb-overlay-controller-trigger-width", `${triggerWidth}px`);
+		let result = {
+			left: 0,
+			top: 0,
+			position: ""
+		};
+		let firstPosition = void 0;
+		for (const position of positions) {
+			switch (isRtl && logicalSupportedPositions.includes(position) ? rtlPositionMapping[position] : position) {
+				default:
+				case "bottom":
+				case "block-end":
+					result = {
+						position,
+						left: triggerOffsetLeft - overlayWidthOverlap,
+						top: triggerOffsetTop + triggerHeight,
+						fits: overlayHeight <= bottomSpace && overlayWidthOverlap <= leftSpace && overlayWidthOverlap <= rightSpace
+					};
+					break;
+				case "top":
+				case "block-start":
+					result = {
+						position,
+						left: triggerOffsetLeft - overlayWidthOverlap,
+						top: triggerOffsetTop - overlayHeight,
+						fits: overlayHeight <= topSpace && overlayWidthOverlap <= leftSpace && overlayWidthOverlap <= rightSpace
+					};
+					break;
+				case "right":
+				case "inline-end":
+					result = {
+						position,
+						left: triggerOffsetLeft + triggerWidth,
+						top: triggerOffsetTop - overlayHeightOverlap,
+						fits: overlayWidth <= rightSpace && overlayHeightOverlap <= topSpace && overlayHeightOverlap <= bottomSpace
+					};
+					break;
+				case "left":
+				case "inline-start":
+					result = {
+						position,
+						left: triggerOffsetLeft - overlayWidth,
+						top: triggerOffsetTop - overlayHeightOverlap,
+						fits: overlayWidth <= leftSpace && overlayHeightOverlap <= topSpace && overlayHeightOverlap <= bottomSpace
+					};
+					break;
+				case "top span-left":
+				case "block-start span-inline-start":
+					result = {
+						position,
+						left: triggerOffsetLeft - overlayWidthNet,
+						top: triggerOffsetTop - overlayHeight,
+						fits: overlayHeight <= topSpace && overlayWidthNet <= leftSpace
+					};
+					break;
+				case "top span-right":
+				case "block-start span-inline-end":
+					result = {
+						position,
+						left: triggerOffsetLeft,
+						top: triggerOffsetTop - overlayHeight,
+						fits: overlayHeight <= topSpace && overlayWidthNet <= rightSpace
+					};
+					break;
+				case "bottom span-left":
+				case "block-end span-inline-start":
+					result = {
+						position,
+						left: triggerOffsetLeft - overlayWidthNet,
+						top: triggerOffsetTop + triggerHeight,
+						fits: overlayHeight <= bottomSpace && overlayWidthNet <= leftSpace
+					};
+					break;
+				case "bottom span-right":
+				case "block-end span-inline-end":
+					result = {
+						position,
+						left: triggerOffsetLeft,
+						top: triggerOffsetTop + triggerHeight,
+						fits: overlayHeight <= bottomSpace && overlayWidthNet <= rightSpace
+					};
+					break;
+				case "left span-top":
+				case "inline-start span-block-start":
+					result = {
+						position,
+						left: triggerOffsetLeft - overlayWidth,
+						top: triggerOffsetTop + triggerHeight - overlayHeight,
+						fits: overlayWidth <= leftSpace && overlayHeightNet <= topSpace
+					};
+					break;
+				case "left span-bottom":
+				case "inline-start span-block-end":
+					result = {
+						position,
+						left: triggerOffsetLeft - overlayWidth,
+						top: triggerOffsetTop,
+						fits: overlayWidth <= leftSpace && overlayHeightNet <= bottomSpace
+					};
+					break;
+				case "right span-top":
+				case "inline-end span-block-start":
+					result = {
+						position,
+						left: triggerOffsetLeft + triggerWidth,
+						top: triggerOffsetTop + triggerHeight - overlayHeight,
+						fits: overlayWidth <= rightSpace && overlayHeightNet <= topSpace
+					};
+					break;
+				case "right span-bottom":
+				case "inline-end span-block-end":
+					result = {
+						position,
+						left: triggerOffsetLeft + triggerWidth,
+						top: triggerOffsetTop,
+						fits: overlayWidth <= rightSpace && overlayHeightNet <= bottomSpace
+					};
+					break;
+			}
+			if (result.fits) return result;
+			firstPosition ??= result;
+		}
+		return firstPosition;
+	}
+	_applyOverlayPosition(position, left, top) {
+		this._lastPosition = position;
+		this._overlay.style.left = `${left}px`;
+		this._overlay.style.top = `${top}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);
+		this._positions = [this._overlayStyles.getPropertyValue("--sbb-overlay-position-area") || "block-end", ...this._overlayStyles.getPropertyValue("--sbb-overlay-position-try-fallbacks").split(",").map((f) => f.trim()).filter((f) => !!f)];
+		if (this._lastPosition && !this._positions.includes(this._lastPosition)) this._lastPosition = void 0;
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay-position-controller.js","sources":["../../../../../src/elements/core/controllers/overlay-position-controller.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nimport type { SbbElementInternalsMixinType } from '../mixins.ts';\n\nconst cssAnchorPositionSupported = !isServer && CSS.supports('anchor-name', '--test');\n\nconst physicalSupportedPositions = [\n  'top',\n  'bottom',\n  'left',\n  'right',\n  'top span-left',\n  'top span-right',\n  'bottom span-left',\n  'bottom span-right',\n  'left span-top',\n  'left span-bottom',\n  'right span-top',\n  'right span-bottom',\n];\n\n// Note: if you add new logical supported positions, update also the 'rtlPositionMapping'\nconst logicalSupportedPositions = [\n  'block-start',\n  'block-end',\n  'inline-start',\n  'inline-end',\n  'block-start span-inline-start',\n  'block-start span-inline-end',\n  'block-end span-inline-start',\n  'block-end span-inline-end',\n  'inline-start span-block-start',\n  'inline-start span-block-end',\n  'inline-end span-block-start',\n  'inline-end span-block-end',\n];\n\nconst rtlPositionMapping: { [key: string]: string } = {\n  'block-start': 'block-start',\n  'block-end': 'block-end',\n  'inline-start': 'inline-end',\n  'inline-end': 'inline-start',\n  'block-start span-inline-start': 'block-start span-inline-end',\n  'block-start span-inline-end': 'block-start span-inline-start',\n  'block-end span-inline-start': 'block-end span-inline-end',\n  'block-end span-inline-end': 'block-end span-inline-start',\n  'inline-start span-block-start': 'inline-end span-block-start',\n  'inline-start span-block-end': 'inline-end span-block-end',\n  'inline-end span-block-start': 'inline-start span-block-start',\n  'inline-end span-block-end': 'inline-start span-block-end',\n};\n\nconst supportedPositions = [...physicalSupportedPositions, ...logicalSupportedPositions];\nlet nextId = 0;\n\n/**\n * Controller for managing overlays positioning. Also acts as a polyfill when native\n * CSS Anchor Positioning is not supported (enough).\n * Applies unique anchor names when using native CSS Anchor Positioning\n * or calculates and applies correct positions in polyfill mode.\n *\n * Also, the controller sets the 'data-position' attribute on the overlay element.\n * This can be used to apply specific styles based on the current position of the overlay.\n *\n * ### Implementation\n * Define and apply the following CSS variables on the overlay element:\n * ```scss\n *   --sbb-overlay-position-area: block-end; // Default\n *   --sbb-overlay-position-try-fallbacks: block-start, inline-end, inline-start; // Fallbacks\n *\n *   position-area: var(--sbb-overlay-position-area);\n *   position-try-fallbacks: var(--sbb-overlay-position-try-fallbacks);\n * ```\n */\nexport class SbbOverlayPositionController implements ReactiveController {\n  private readonly _resizeObserver = !isServer\n    ? new ResizeObserver(() => this._requestCalculatePosition())\n    : null!;\n  private readonly _overlay: ReactiveControllerHost & HTMLElement & SbbElementInternalsMixinType;\n  private _abortController?: AbortController;\n  private _anchor?: HTMLElement;\n  private _overlayStyles?: CSSStyleDeclaration;\n  private _frame?: ReturnType<typeof requestAnimationFrame>;\n  private _anchorName = `--sbb-overlay-anchor-${++nextId}`;\n  private _positions: string[] = [];\n  private _lastPosition?: string;\n\n  /** Get the current position. (e.g. block-end, block-start, etc.) */\n  public get currentPosition(): string {\n    if (this._usePolyfill) {\n      return this._lastPosition ?? this._positions[0] ?? '';\n    } else {\n      this._overlayStyles ??= getComputedStyle(this._overlay);\n      return this._overlayStyles.getPropertyValue('position-area');\n    }\n  }\n\n  public constructor(\n    host: ReactiveControllerHost & HTMLElement & SbbElementInternalsMixinType,\n    private _usePolyfill = !cssAnchorPositionSupported,\n  ) {\n    host.addController(this);\n    this._overlay = host;\n  }\n\n  public hostConnected(): void {\n    if (!this._usePolyfill) {\n      this._overlay.style.setProperty('position-anchor', this._anchorName);\n    } else {\n      // Reset the 'position-area' value to avoid any unwanted side effect when using the polyfill.\n      this._overlay.style.setProperty('position-area', 'initial');\n    }\n  }\n\n  public hostUpdate(): void {\n    if (isServer) {\n      return;\n    }\n    this._readPositionsFromCss();\n  }\n\n  /**\n   * Connects the overlay to the given trigger element and determines the optimal position.\n   * Usually, this is called when the overlay is opened.\n   * @param anchor The anchor element.\n   */\n  public connect(anchor: HTMLElement): void {\n    if (isServer) {\n      return;\n    }\n\n    if (this._anchor) {\n      this.disconnect();\n    }\n    this._anchor = anchor;\n\n    if (!this._usePolyfill) {\n      this._anchor.style.setProperty('anchor-name', this._anchorName!);\n    }\n\n    this._readPositionsFromCss();\n    this._calculatePosition();\n    this._abortController?.abort();\n    this._abortController = new AbortController();\n\n    // We need to use capture here to react to all scroll events.\n    // If capture was not used, then scroll events inside separate scroll\n    // containers would not be caught.\n    document.addEventListener('scroll', () => this._requestCalculatePosition(), {\n      capture: true,\n      passive: true,\n      signal: this._abortController.signal,\n    });\n    window.addEventListener('resize', () => this._requestCalculatePosition(), {\n      passive: true,\n      signal: this._abortController.signal,\n    });\n    this._resizeObserver.observe(anchor, { box: 'border-box' });\n    this._resizeObserver.observe(this._overlay, { box: 'border-box' });\n  }\n\n  public disconnect(): void {\n    this._anchor?.style.removeProperty('anchor-name');\n    this._anchor = undefined;\n    this._abortController?.abort();\n    this._resizeObserver.disconnect();\n  }\n\n  private _requestCalculatePosition(): void {\n    this._frame ??= requestAnimationFrame(() => {\n      this._calculatePosition();\n      this._frame = undefined;\n    });\n  }\n\n  private _calculatePosition(): void {\n    if (!this._anchor) {\n      return;\n    }\n\n    if (this._usePolyfill) {\n      const position = this._getOptimalPosition(this._positions);\n      this._applyOverlayPosition(position.position, position.left, position.top);\n    }\n\n    this._overlay.setAttribute('data-position', this.currentPosition);\n  }\n\n  /**\n   * Calculates the optimal position that fits the overlay.\n   * @param positions The list of positions to check.\n   * @private\n   */\n  private _getOptimalPosition(positions: string[]): {\n    left: number;\n    top: number;\n    position: string;\n    fits?: boolean;\n  } {\n    const { offsetHeight: overlayHeight, offsetWidth: overlayWidth } = this._overlay;\n    const { innerHeight: viewportHeight, innerWidth: viewportWidth } = window;\n    const {\n      top: triggerOffsetTop,\n      left: triggerOffsetLeft,\n      height: triggerHeight,\n      width: triggerWidth,\n    } = this._anchor!.getBoundingClientRect();\n\n    const isRtl = this._overlay.matches(':dir(rtl)');\n    const topSpace = triggerOffsetTop;\n    const bottomSpace = viewportHeight - triggerHeight - triggerOffsetTop;\n    const leftSpace = triggerOffsetLeft;\n    const rightSpace = viewportWidth - triggerWidth - triggerOffsetLeft;\n\n    // The difference between the overlay and the trigger width/height.\n    const overlayWidthNet = overlayWidth - triggerWidth;\n    const overlayHeightNet = overlayHeight - triggerHeight;\n\n    // The amount that would exceed the trigger if the overlay were centered on it.\n    const overlayWidthOverlap = overlayWidthNet / 2;\n    const overlayHeightOverlap = overlayHeightNet / 2;\n\n    this._overlay.style.setProperty(\n      '--sbb-overlay-controller-trigger-height',\n      `${triggerHeight}px`,\n    );\n    this._overlay.style.setProperty('--sbb-overlay-controller-trigger-width', `${triggerWidth}px`);\n\n    // eslint-disable-next-line no-useless-assignment\n    let result: ReturnType<typeof this._getOptimalPosition> = { left: 0, top: 0, position: '' };\n    let firstPosition: ReturnType<typeof this._getOptimalPosition> | undefined = undefined;\n    for (const position of positions) {\n      // If rtl is enabled, we map the logical position to their RTL equivalent. (e.g. 'inline-start' -> 'inline-end')\n      const physicalPosition =\n        isRtl && logicalSupportedPositions.includes(position)\n          ? rtlPositionMapping[position]\n          : position;\n\n      switch (physicalPosition) {\n        default:\n        case 'bottom':\n        case 'block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthOverlap,\n            top: triggerOffsetTop + triggerHeight,\n            fits:\n              overlayHeight <= bottomSpace &&\n              overlayWidthOverlap <= leftSpace &&\n              overlayWidthOverlap <= rightSpace,\n          };\n          break;\n        case 'top':\n        case 'block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthOverlap,\n            top: triggerOffsetTop - overlayHeight,\n            fits:\n              overlayHeight <= topSpace &&\n              overlayWidthOverlap <= leftSpace &&\n              overlayWidthOverlap <= rightSpace,\n          };\n          break;\n        case 'right':\n        case 'inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop - overlayHeightOverlap,\n            fits:\n              overlayWidth <= rightSpace &&\n              overlayHeightOverlap <= topSpace &&\n              overlayHeightOverlap <= bottomSpace,\n          };\n          break;\n        case 'left':\n        case 'inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop - overlayHeightOverlap,\n            fits:\n              overlayWidth <= leftSpace &&\n              overlayHeightOverlap <= topSpace &&\n              overlayHeightOverlap <= bottomSpace,\n          };\n          break;\n        case 'top span-left':\n        case 'block-start span-inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthNet,\n            top: triggerOffsetTop - overlayHeight,\n            fits: overlayHeight <= topSpace && overlayWidthNet <= leftSpace,\n          };\n          break;\n        case 'top span-right':\n        case 'block-start span-inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft,\n            top: triggerOffsetTop - overlayHeight,\n            fits: overlayHeight <= topSpace && overlayWidthNet <= rightSpace,\n          };\n          break;\n        case 'bottom span-left':\n        case 'block-end span-inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthNet,\n            top: triggerOffsetTop + triggerHeight,\n            fits: overlayHeight <= bottomSpace && overlayWidthNet <= leftSpace,\n          };\n          break;\n        case 'bottom span-right':\n        case 'block-end span-inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft,\n            top: triggerOffsetTop + triggerHeight,\n            fits: overlayHeight <= bottomSpace && overlayWidthNet <= rightSpace,\n          };\n          break;\n        case 'left span-top':\n        case 'inline-start span-block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop + triggerHeight - overlayHeight,\n            fits: overlayWidth <= leftSpace && overlayHeightNet <= topSpace,\n          };\n          break;\n        case 'left span-bottom':\n        case 'inline-start span-block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop,\n            fits: overlayWidth <= leftSpace && overlayHeightNet <= bottomSpace,\n          };\n          break;\n        case 'right span-top':\n        case 'inline-end span-block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop + triggerHeight - overlayHeight,\n            fits: overlayWidth <= rightSpace && overlayHeightNet <= topSpace,\n          };\n          break;\n        case 'right span-bottom':\n        case 'inline-end span-block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop,\n            fits: overlayWidth <= rightSpace && overlayHeightNet <= bottomSpace,\n          };\n          break;\n      }\n      if (result.fits) {\n        return result;\n      }\n      firstPosition ??= result;\n    }\n\n    // If no position fits, we return the first one.\n    return firstPosition!;\n  }\n\n  private _applyOverlayPosition(position: string, left: number, top: number): void {\n    this._lastPosition = position;\n    this._overlay.style.left = `${left}px`;\n    this._overlay.style.top = `${top}px`;\n  }\n\n  /**\n   * Only used in polyfill mode.\n   * Reads the list of the configured positions from the CSS variables.\n   * @private\n   */\n  private _readPositionsFromCss(): void {\n    if (!this._usePolyfill) {\n      return;\n    }\n    this._overlayStyles ??= getComputedStyle(this._overlay);\n    const positions = [\n      this._overlayStyles.getPropertyValue('--sbb-overlay-position-area') || 'block-end',\n      ...this._overlayStyles\n        .getPropertyValue('--sbb-overlay-position-try-fallbacks')\n        .split(',')\n        .map((f) => f.trim())\n        .filter((f) => !!f),\n    ];\n\n    if (import.meta.env.DEV && positions.some((p) => !supportedPositions.includes(p))) {\n      const unsupportedPositions = positions\n        .filter((p) => !supportedPositions.includes(p))\n        .sort()\n        .join(', ');\n      throw new Error(\n        `Unsupported position-try-fallbacks ${unsupportedPositions} (Supported: ${supportedPositions.join(', ')})`,\n      );\n    }\n\n    this._positions = positions;\n    if (this._lastPosition && !this._positions.includes(this._lastPosition)) {\n      this._lastPosition = undefined;\n    }\n  }\n}\n"],"names":[],"mappings":"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"}
+//#endregion
+export { SbbOverlayPositionController };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay-position-controller.js","names":[],"sources":["../../../../../src/elements/core/controllers/overlay-position-controller.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nimport type { SbbElementInternalsMixinType } from '../mixins.ts';\n\nconst cssAnchorPositionSupported = !isServer && CSS.supports('anchor-name', '--test');\n\nconst physicalSupportedPositions = [\n  'top',\n  'bottom',\n  'left',\n  'right',\n  'top span-left',\n  'top span-right',\n  'bottom span-left',\n  'bottom span-right',\n  'left span-top',\n  'left span-bottom',\n  'right span-top',\n  'right span-bottom',\n];\n\n// Note: if you add new logical supported positions, update also the 'rtlPositionMapping'\nconst logicalSupportedPositions = [\n  'block-start',\n  'block-end',\n  'inline-start',\n  'inline-end',\n  'block-start span-inline-start',\n  'block-start span-inline-end',\n  'block-end span-inline-start',\n  'block-end span-inline-end',\n  'inline-start span-block-start',\n  'inline-start span-block-end',\n  'inline-end span-block-start',\n  'inline-end span-block-end',\n];\n\nconst rtlPositionMapping: { [key: string]: string } = {\n  'block-start': 'block-start',\n  'block-end': 'block-end',\n  'inline-start': 'inline-end',\n  'inline-end': 'inline-start',\n  'block-start span-inline-start': 'block-start span-inline-end',\n  'block-start span-inline-end': 'block-start span-inline-start',\n  'block-end span-inline-start': 'block-end span-inline-end',\n  'block-end span-inline-end': 'block-end span-inline-start',\n  'inline-start span-block-start': 'inline-end span-block-start',\n  'inline-start span-block-end': 'inline-end span-block-end',\n  'inline-end span-block-start': 'inline-start span-block-start',\n  'inline-end span-block-end': 'inline-start span-block-end',\n};\n\nconst supportedPositions = [...physicalSupportedPositions, ...logicalSupportedPositions];\nlet nextId = 0;\n\n/**\n * Controller for managing overlays positioning. Also acts as a polyfill when native\n * CSS Anchor Positioning is not supported (enough).\n * Applies unique anchor names when using native CSS Anchor Positioning\n * or calculates and applies correct positions in polyfill mode.\n *\n * Also, the controller sets the 'data-position' attribute on the overlay element.\n * This can be used to apply specific styles based on the current position of the overlay.\n *\n * ### Implementation\n * Define and apply the following CSS variables on the overlay element:\n * ```scss\n *   --sbb-overlay-position-area: block-end; // Default\n *   --sbb-overlay-position-try-fallbacks: block-start, inline-end, inline-start; // Fallbacks\n *\n *   position-area: var(--sbb-overlay-position-area);\n *   position-try-fallbacks: var(--sbb-overlay-position-try-fallbacks);\n * ```\n */\nexport class SbbOverlayPositionController implements ReactiveController {\n  private readonly _resizeObserver = !isServer\n    ? new ResizeObserver(() => this._requestCalculatePosition())\n    : null!;\n  private readonly _overlay: ReactiveControllerHost & HTMLElement & SbbElementInternalsMixinType;\n  private _abortController?: AbortController;\n  private _anchor?: HTMLElement;\n  private _overlayStyles?: CSSStyleDeclaration;\n  private _frame?: ReturnType<typeof requestAnimationFrame>;\n  private _anchorName = `--sbb-overlay-anchor-${++nextId}`;\n  private _positions: string[] = [];\n  private _lastPosition?: string;\n\n  /** Get the current position. (e.g. block-end, block-start, etc.) */\n  public get currentPosition(): string {\n    if (this._usePolyfill) {\n      return this._lastPosition ?? this._positions[0] ?? '';\n    } else {\n      this._overlayStyles ??= getComputedStyle(this._overlay);\n      return this._overlayStyles.getPropertyValue('position-area');\n    }\n  }\n\n  public constructor(\n    host: ReactiveControllerHost & HTMLElement & SbbElementInternalsMixinType,\n    private _usePolyfill = !cssAnchorPositionSupported,\n  ) {\n    host.addController(this);\n    this._overlay = host;\n  }\n\n  public hostConnected(): void {\n    if (!this._usePolyfill) {\n      this._overlay.style.setProperty('position-anchor', this._anchorName);\n    } else {\n      // Reset the 'position-area' value to avoid any unwanted side effect when using the polyfill.\n      this._overlay.style.setProperty('position-area', 'initial');\n    }\n  }\n\n  public hostUpdate(): void {\n    if (isServer) {\n      return;\n    }\n    this._readPositionsFromCss();\n  }\n\n  /**\n   * Connects the overlay to the given trigger element and determines the optimal position.\n   * Usually, this is called when the overlay is opened.\n   * @param anchor The anchor element.\n   */\n  public connect(anchor: HTMLElement): void {\n    if (isServer) {\n      return;\n    }\n\n    if (this._anchor) {\n      this.disconnect();\n    }\n    this._anchor = anchor;\n\n    if (!this._usePolyfill) {\n      this._anchor.style.setProperty('anchor-name', this._anchorName!);\n    }\n\n    this._readPositionsFromCss();\n    this._calculatePosition();\n    this._abortController?.abort();\n    this._abortController = new AbortController();\n\n    // We need to use capture here to react to all scroll events.\n    // If capture was not used, then scroll events inside separate scroll\n    // containers would not be caught.\n    document.addEventListener('scroll', () => this._requestCalculatePosition(), {\n      capture: true,\n      passive: true,\n      signal: this._abortController.signal,\n    });\n    window.addEventListener('resize', () => this._requestCalculatePosition(), {\n      passive: true,\n      signal: this._abortController.signal,\n    });\n    this._resizeObserver.observe(anchor, { box: 'border-box' });\n    this._resizeObserver.observe(this._overlay, { box: 'border-box' });\n  }\n\n  public disconnect(): void {\n    this._anchor?.style.removeProperty('anchor-name');\n    this._anchor = undefined;\n    this._abortController?.abort();\n    this._resizeObserver.disconnect();\n  }\n\n  private _requestCalculatePosition(): void {\n    this._frame ??= requestAnimationFrame(() => {\n      this._calculatePosition();\n      this._frame = undefined;\n    });\n  }\n\n  private _calculatePosition(): void {\n    if (!this._anchor) {\n      return;\n    }\n\n    if (this._usePolyfill) {\n      const position = this._getOptimalPosition(this._positions);\n      this._applyOverlayPosition(position.position, position.left, position.top);\n    }\n\n    this._overlay.setAttribute('data-position', this.currentPosition);\n  }\n\n  /**\n   * Calculates the optimal position that fits the overlay.\n   * @param positions The list of positions to check.\n   * @private\n   */\n  private _getOptimalPosition(positions: string[]): {\n    left: number;\n    top: number;\n    position: string;\n    fits?: boolean;\n  } {\n    const { offsetHeight: overlayHeight, offsetWidth: overlayWidth } = this._overlay;\n    const { innerHeight: viewportHeight, innerWidth: viewportWidth } = window;\n    const {\n      top: triggerOffsetTop,\n      left: triggerOffsetLeft,\n      height: triggerHeight,\n      width: triggerWidth,\n    } = this._anchor!.getBoundingClientRect();\n\n    const isRtl = this._overlay.matches(':dir(rtl)');\n    const topSpace = triggerOffsetTop;\n    const bottomSpace = viewportHeight - triggerHeight - triggerOffsetTop;\n    const leftSpace = triggerOffsetLeft;\n    const rightSpace = viewportWidth - triggerWidth - triggerOffsetLeft;\n\n    // The difference between the overlay and the trigger width/height.\n    const overlayWidthNet = overlayWidth - triggerWidth;\n    const overlayHeightNet = overlayHeight - triggerHeight;\n\n    // The amount that would exceed the trigger if the overlay were centered on it.\n    const overlayWidthOverlap = overlayWidthNet / 2;\n    const overlayHeightOverlap = overlayHeightNet / 2;\n\n    this._overlay.style.setProperty(\n      '--sbb-overlay-controller-trigger-height',\n      `${triggerHeight}px`,\n    );\n    this._overlay.style.setProperty('--sbb-overlay-controller-trigger-width', `${triggerWidth}px`);\n\n    // eslint-disable-next-line no-useless-assignment\n    let result: ReturnType<typeof this._getOptimalPosition> = { left: 0, top: 0, position: '' };\n    let firstPosition: ReturnType<typeof this._getOptimalPosition> | undefined = undefined;\n    for (const position of positions) {\n      // If rtl is enabled, we map the logical position to their RTL equivalent. (e.g. 'inline-start' -> 'inline-end')\n      const physicalPosition =\n        isRtl && logicalSupportedPositions.includes(position)\n          ? rtlPositionMapping[position]\n          : position;\n\n      switch (physicalPosition) {\n        default:\n        case 'bottom':\n        case 'block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthOverlap,\n            top: triggerOffsetTop + triggerHeight,\n            fits:\n              overlayHeight <= bottomSpace &&\n              overlayWidthOverlap <= leftSpace &&\n              overlayWidthOverlap <= rightSpace,\n          };\n          break;\n        case 'top':\n        case 'block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthOverlap,\n            top: triggerOffsetTop - overlayHeight,\n            fits:\n              overlayHeight <= topSpace &&\n              overlayWidthOverlap <= leftSpace &&\n              overlayWidthOverlap <= rightSpace,\n          };\n          break;\n        case 'right':\n        case 'inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop - overlayHeightOverlap,\n            fits:\n              overlayWidth <= rightSpace &&\n              overlayHeightOverlap <= topSpace &&\n              overlayHeightOverlap <= bottomSpace,\n          };\n          break;\n        case 'left':\n        case 'inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop - overlayHeightOverlap,\n            fits:\n              overlayWidth <= leftSpace &&\n              overlayHeightOverlap <= topSpace &&\n              overlayHeightOverlap <= bottomSpace,\n          };\n          break;\n        case 'top span-left':\n        case 'block-start span-inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthNet,\n            top: triggerOffsetTop - overlayHeight,\n            fits: overlayHeight <= topSpace && overlayWidthNet <= leftSpace,\n          };\n          break;\n        case 'top span-right':\n        case 'block-start span-inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft,\n            top: triggerOffsetTop - overlayHeight,\n            fits: overlayHeight <= topSpace && overlayWidthNet <= rightSpace,\n          };\n          break;\n        case 'bottom span-left':\n        case 'block-end span-inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthNet,\n            top: triggerOffsetTop + triggerHeight,\n            fits: overlayHeight <= bottomSpace && overlayWidthNet <= leftSpace,\n          };\n          break;\n        case 'bottom span-right':\n        case 'block-end span-inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft,\n            top: triggerOffsetTop + triggerHeight,\n            fits: overlayHeight <= bottomSpace && overlayWidthNet <= rightSpace,\n          };\n          break;\n        case 'left span-top':\n        case 'inline-start span-block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop + triggerHeight - overlayHeight,\n            fits: overlayWidth <= leftSpace && overlayHeightNet <= topSpace,\n          };\n          break;\n        case 'left span-bottom':\n        case 'inline-start span-block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop,\n            fits: overlayWidth <= leftSpace && overlayHeightNet <= bottomSpace,\n          };\n          break;\n        case 'right span-top':\n        case 'inline-end span-block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop + triggerHeight - overlayHeight,\n            fits: overlayWidth <= rightSpace && overlayHeightNet <= topSpace,\n          };\n          break;\n        case 'right span-bottom':\n        case 'inline-end span-block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop,\n            fits: overlayWidth <= rightSpace && overlayHeightNet <= bottomSpace,\n          };\n          break;\n      }\n      if (result.fits) {\n        return result;\n      }\n      firstPosition ??= result;\n    }\n\n    // If no position fits, we return the first one.\n    return firstPosition!;\n  }\n\n  private _applyOverlayPosition(position: string, left: number, top: number): void {\n    this._lastPosition = position;\n    this._overlay.style.left = `${left}px`;\n    this._overlay.style.top = `${top}px`;\n  }\n\n  /**\n   * Only used in polyfill mode.\n   * Reads the list of the configured positions from the CSS variables.\n   * @private\n   */\n  private _readPositionsFromCss(): void {\n    if (!this._usePolyfill) {\n      return;\n    }\n    this._overlayStyles ??= getComputedStyle(this._overlay);\n    const positions = [\n      this._overlayStyles.getPropertyValue('--sbb-overlay-position-area') || 'block-end',\n      ...this._overlayStyles\n        .getPropertyValue('--sbb-overlay-position-try-fallbacks')\n        .split(',')\n        .map((f) => f.trim())\n        .filter((f) => !!f),\n    ];\n\n    if (import.meta.env.DEV && positions.some((p) => !supportedPositions.includes(p))) {\n      const unsupportedPositions = positions\n        .filter((p) => !supportedPositions.includes(p))\n        .sort()\n        .join(', ');\n      throw new Error(\n        `Unsupported position-try-fallbacks ${unsupportedPositions} (Supported: ${supportedPositions.join(', ')})`,\n      );\n    }\n\n    this._positions = positions;\n    if (this._lastPosition && !this._positions.includes(this._lastPosition)) {\n      this._lastPosition = undefined;\n    }\n  }\n}\n"],"mappings":"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"}