@sbb-esta/lyne-elements 4.7.0 → 4.8.1

package/development/core/a11y/focus-trap-controller.js

@@ -1,122 +1,106 @@
 import { interactivityChecker } from "./interactivity-checker.js";
-class SbbFocusTrapController {
-  /**
-   * Whether the focus is trap is enabled.
-   * @param enabled
-   */
-  set enabled(enabled) {
-    if (enabled) {
-      this._trap();
-    } else {
-      this._untrap();
-    }
-  }
-  get enabled() {
-    return !!this._abortController;
-  }
-  constructor(_host) {
-    this._host = _host;
-    this._abortController = null;
-    this._host.addController?.(this);
-  }
-  hostDisconnected() {
-    this._untrap();
-  }
-  /**
-   * Focuses the element that should be focused when the focus trap is initialized.
-   * @returns Whether focus was moved successfully.
-   */
-  focusInitialElement(options) {
-    const redirectToElement = this._host.querySelector("[sbb-focus-initial]");
-    if (redirectToElement) {
-      if (!interactivityChecker.isFocusable(redirectToElement)) {
-        const focusableChild = this._getFirstTabbableElement(redirectToElement);
-        focusableChild?.focus(options);
-        return !!focusableChild;
-      }
-      redirectToElement.focus(options);
-      return true;
-    }
-    return this.focusFirstTabbableElement(options);
-  }
-  /**
-   * Focuses the first tabbable element within the focus trap region.
-   * @returns Whether focus was moved successfully.
-   */
-  focusFirstTabbableElement(options) {
-    const redirectToElement = this._getFirstTabbableElement(this._host);
-    if (redirectToElement) {
-      redirectToElement.focus(options);
-    }
-    return !!redirectToElement;
-  }
-  /**
-   * Focuses the last tabbable element within the focus trap region.
-   * @returns Whether focus was moved successfully.
-   */
-  focusLastTabbableElement(options) {
-    const redirectToElement = this._getLastTabbableElement(this._host);
-    if (redirectToElement) {
-      redirectToElement.focus(options);
-    }
-    return !!redirectToElement;
-  }
-  _trap() {
-    this._abortController = new AbortController();
-    this._host.addEventListener("keydown", (event) => {
-      if (event.key !== "Tab") {
-        return;
-      }
-      if (!event.shiftKey) {
-        const lastFocusableElement = this._getLastTabbableElement(this._host);
-        if (lastFocusableElement && event.composedPath().includes(lastFocusableElement)) {
-          this._getFirstTabbableElement(this._host)?.focus();
-          event.preventDefault();
-        }
-      } else {
-        const firstFocusableElement = this._getFirstTabbableElement(this._host);
-        if (firstFocusableElement && event.composedPath().includes(firstFocusableElement)) {
-          this._getLastTabbableElement(this._host)?.focus();
-          event.preventDefault();
-        }
-      }
-    }, { signal: this._abortController.signal });
-  }
-  /** Get the first tabbable element from a DOM subtree (inclusive). */
-  _getFirstTabbableElement(root) {
-    if (root !== this._host && interactivityChecker.isFocusable(root) && interactivityChecker.isTabbable(root)) {
-      return root;
-    }
-    const children = root.shadowRoot ? root.shadowRoot.children : root.localName === "slot" ? root.assignedElements() : root.children;
-    for (let i = 0; i < children.length; i++) {
-      const tabbableChild = children[i].nodeType === document.ELEMENT_NODE ? this._getFirstTabbableElement(children[i]) : null;
-      if (tabbableChild) {
-        return tabbableChild;
-      }
-    }
-    return null;
-  }
-  /** Get the last tabbable element from a DOM subtree (inclusive). */
-  _getLastTabbableElement(root) {
-    let result = null;
-    if (root !== this._host && interactivityChecker.isFocusable(root) && interactivityChecker.isTabbable(root)) {
-      result = root;
-    }
-    const children = root.shadowRoot ? root.shadowRoot.children : root.localName === "slot" ? root.assignedElements() : root.children;
-    for (let i = children.length - 1; i >= 0; i--) {
-      const tabbableChild = children[i].nodeType === document.ELEMENT_NODE ? this._getLastTabbableElement(children[i]) : null;
-      if (tabbableChild) {
-        return tabbableChild;
-      }
-    }
-    return result;
-  }
-  _untrap() {
-    this._abortController?.abort();
-    this._abortController = null;
-  }
-}
-export {
-  SbbFocusTrapController
+//#region src/elements/core/a11y/focus-trap-controller.ts
+var SbbFocusTrapController = class {
+	/**
+	* Whether the focus is trap is enabled.
+	* @param enabled
+	*/
+	set enabled(enabled) {
+		if (enabled) this._trap();
+		else this._untrap();
+	}
+	get enabled() {
+		return !!this._abortController;
+	}
+	constructor(_host) {
+		this._host = _host;
+		this._abortController = null;
+		this._host.addController?.(this);
+	}
+	hostDisconnected() {
+		this._untrap();
+	}
+	/**
+	* Focuses the element that should be focused when the focus trap is initialized.
+	* @returns Whether focus was moved successfully.
+	*/
+	focusInitialElement(options) {
+		const redirectToElement = this._host.querySelector("[sbb-focus-initial]");
+		if (redirectToElement) {
+			if (!interactivityChecker.isFocusable(redirectToElement)) {
+				const focusableChild = this._getFirstTabbableElement(redirectToElement);
+				focusableChild?.focus(options);
+				return !!focusableChild;
+			}
+			redirectToElement.focus(options);
+			return true;
+		}
+		return this.focusFirstTabbableElement(options);
+	}
+	/**
+	* Focuses the first tabbable element within the focus trap region.
+	* @returns Whether focus was moved successfully.
+	*/
+	focusFirstTabbableElement(options) {
+		const redirectToElement = this._getFirstTabbableElement(this._host);
+		if (redirectToElement) redirectToElement.focus(options);
+		return !!redirectToElement;
+	}
+	/**
+	* Focuses the last tabbable element within the focus trap region.
+	* @returns Whether focus was moved successfully.
+	*/
+	focusLastTabbableElement(options) {
+		const redirectToElement = this._getLastTabbableElement(this._host);
+		if (redirectToElement) redirectToElement.focus(options);
+		return !!redirectToElement;
+	}
+	_trap() {
+		this._abortController = new AbortController();
+		this._host.addEventListener("keydown", (event) => {
+			if (event.key !== "Tab") return;
+			if (!event.shiftKey) {
+				const lastFocusableElement = this._getLastTabbableElement(this._host);
+				if (lastFocusableElement && event.composedPath().includes(lastFocusableElement)) {
+					this._getFirstTabbableElement(this._host)?.focus();
+					event.preventDefault();
+				}
+			} else {
+				const firstFocusableElement = this._getFirstTabbableElement(this._host);
+				if (firstFocusableElement && event.composedPath().includes(firstFocusableElement)) {
+					this._getLastTabbableElement(this._host)?.focus();
+					event.preventDefault();
+				}
+			}
+		}, { signal: this._abortController.signal });
+	}
+	/** Get the first tabbable element from a DOM subtree (inclusive). */
+	_getFirstTabbableElement(root) {
+		if (root !== this._host && interactivityChecker.isFocusable(root) && interactivityChecker.isTabbable(root)) return root;
+		const children = root.shadowRoot ? root.shadowRoot.children : root.localName === "slot" ? root.assignedElements() : root.children;
+		for (let i = 0; i < children.length; i++) {
+			const tabbableChild = children[i].nodeType === document.ELEMENT_NODE ? this._getFirstTabbableElement(children[i]) : null;
+			if (tabbableChild) return tabbableChild;
+		}
+		return null;
+	}
+	/** Get the last tabbable element from a DOM subtree (inclusive). */
+	_getLastTabbableElement(root) {
+		let result = null;
+		if (root !== this._host && interactivityChecker.isFocusable(root) && interactivityChecker.isTabbable(root)) result = root;
+		const children = root.shadowRoot ? root.shadowRoot.children : root.localName === "slot" ? root.assignedElements() : root.children;
+		for (let i = children.length - 1; i >= 0; i--) {
+			const tabbableChild = children[i].nodeType === document.ELEMENT_NODE ? this._getLastTabbableElement(children[i]) : null;
+			if (tabbableChild) return tabbableChild;
+		}
+		return result;
+	}
+	_untrap() {
+		this._abortController?.abort();
+		this._abortController = null;
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"focus-trap-controller.js","sources":["../../../../../src/elements/core/a11y/focus-trap-controller.ts"],"sourcesContent":["import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nimport { interactivityChecker } from './interactivity-checker.ts';\n\nexport class SbbFocusTrapController implements ReactiveController {\n  /**\n   * Whether the focus is trap is enabled.\n   * @param enabled\n   */\n  public set enabled(enabled: boolean) {\n    if (enabled) {\n      this._trap();\n    } else {\n      this._untrap();\n    }\n  }\n  public get enabled(): boolean {\n    return !!this._abortController;\n  }\n\n  private _abortController: AbortController | null = null;\n\n  public constructor(private _host: ReactiveControllerHost & HTMLElement) {\n    this._host.addController?.(this);\n  }\n\n  public hostDisconnected(): void {\n    this._untrap();\n  }\n\n  /**\n   * Focuses the element that should be focused when the focus trap is initialized.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusInitialElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._host.querySelector<HTMLElement>('[sbb-focus-initial]');\n\n    if (redirectToElement) {\n      // Warn the consumer if the element they've pointed to\n      // isn't focusable, when not in production mode.\n      if (import.meta.env.DEV && !interactivityChecker.isFocusable(redirectToElement)) {\n        console.warn(`Element matching '[sbb-focus-initial]' is not focusable.`, redirectToElement);\n      }\n\n      if (!interactivityChecker.isFocusable(redirectToElement)) {\n        const focusableChild = this._getFirstTabbableElement(redirectToElement);\n        focusableChild?.focus(options);\n        return !!focusableChild;\n      }\n\n      redirectToElement.focus(options);\n      return true;\n    }\n\n    return this.focusFirstTabbableElement(options);\n  }\n\n  /**\n   * Focuses the first tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusFirstTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getFirstTabbableElement(this._host);\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  /**\n   * Focuses the last tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusLastTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getLastTabbableElement(this._host);\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  private _trap(): void {\n    this._abortController = new AbortController();\n    this._host.addEventListener(\n      'keydown',\n      (event) => {\n        if (event.key !== 'Tab') {\n          return;\n        }\n\n        if (!event.shiftKey) {\n          const lastFocusableElement = this._getLastTabbableElement(this._host);\n          if (lastFocusableElement && event.composedPath().includes(lastFocusableElement)) {\n            this._getFirstTabbableElement(this._host)?.focus();\n            event.preventDefault();\n          }\n        } else {\n          const firstFocusableElement = this._getFirstTabbableElement(this._host);\n          if (firstFocusableElement && event.composedPath().includes(firstFocusableElement)) {\n            this._getLastTabbableElement(this._host)?.focus();\n            event.preventDefault();\n          }\n        }\n      },\n      { signal: this._abortController.signal },\n    );\n  }\n\n  /** Get the first tabbable element from a DOM subtree (inclusive). */\n  private _getFirstTabbableElement(root: HTMLElement): HTMLElement | null {\n    if (\n      root !== this._host &&\n      interactivityChecker.isFocusable(root) &&\n      interactivityChecker.isTabbable(root)\n    ) {\n      return root;\n    }\n\n    const children = root.shadowRoot\n      ? root.shadowRoot.children\n      : root.localName === 'slot'\n        ? (root as HTMLSlotElement).assignedElements()\n        : root.children;\n\n    for (let i = 0; i < children.length; i++) {\n      const tabbableChild =\n        children[i].nodeType === document.ELEMENT_NODE\n          ? this._getFirstTabbableElement(children[i] as HTMLElement)\n          : null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return null;\n  }\n\n  /** Get the last tabbable element from a DOM subtree (inclusive). */\n  private _getLastTabbableElement(root: HTMLElement): HTMLElement | null {\n    let result: HTMLElement | null = null;\n\n    if (\n      root !== this._host &&\n      interactivityChecker.isFocusable(root) &&\n      interactivityChecker.isTabbable(root)\n    ) {\n      result = root;\n    }\n\n    const children = root.shadowRoot\n      ? root.shadowRoot.children\n      : root.localName === 'slot'\n        ? (root as HTMLSlotElement).assignedElements()\n        : root.children;\n\n    // Iterate in reverse DOM order.\n    for (let i = children.length - 1; i >= 0; i--) {\n      const tabbableChild =\n        children[i].nodeType === document.ELEMENT_NODE\n          ? this._getLastTabbableElement(children[i] as HTMLElement)\n          : null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return result;\n  }\n\n  private _untrap(): void {\n    this._abortController?.abort();\n    this._abortController = null;\n  }\n}\n"],"names":[],"mappings":"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"}
+//#endregion
+export { SbbFocusTrapController };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"focus-trap-controller.js","names":[],"sources":["../../../../../src/elements/core/a11y/focus-trap-controller.ts"],"sourcesContent":["import type { ReactiveController, ReactiveControllerHost } from 'lit';\n\nimport { interactivityChecker } from './interactivity-checker.ts';\n\nexport class SbbFocusTrapController implements ReactiveController {\n  /**\n   * Whether the focus is trap is enabled.\n   * @param enabled\n   */\n  public set enabled(enabled: boolean) {\n    if (enabled) {\n      this._trap();\n    } else {\n      this._untrap();\n    }\n  }\n  public get enabled(): boolean {\n    return !!this._abortController;\n  }\n\n  private _abortController: AbortController | null = null;\n\n  public constructor(private _host: ReactiveControllerHost & HTMLElement) {\n    this._host.addController?.(this);\n  }\n\n  public hostDisconnected(): void {\n    this._untrap();\n  }\n\n  /**\n   * Focuses the element that should be focused when the focus trap is initialized.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusInitialElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._host.querySelector<HTMLElement>('[sbb-focus-initial]');\n\n    if (redirectToElement) {\n      // Warn the consumer if the element they've pointed to\n      // isn't focusable, when not in production mode.\n      if (import.meta.env.DEV && !interactivityChecker.isFocusable(redirectToElement)) {\n        console.warn(`Element matching '[sbb-focus-initial]' is not focusable.`, redirectToElement);\n      }\n\n      if (!interactivityChecker.isFocusable(redirectToElement)) {\n        const focusableChild = this._getFirstTabbableElement(redirectToElement);\n        focusableChild?.focus(options);\n        return !!focusableChild;\n      }\n\n      redirectToElement.focus(options);\n      return true;\n    }\n\n    return this.focusFirstTabbableElement(options);\n  }\n\n  /**\n   * Focuses the first tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusFirstTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getFirstTabbableElement(this._host);\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  /**\n   * Focuses the last tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  public focusLastTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getLastTabbableElement(this._host);\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  private _trap(): void {\n    this._abortController = new AbortController();\n    this._host.addEventListener(\n      'keydown',\n      (event) => {\n        if (event.key !== 'Tab') {\n          return;\n        }\n\n        if (!event.shiftKey) {\n          const lastFocusableElement = this._getLastTabbableElement(this._host);\n          if (lastFocusableElement && event.composedPath().includes(lastFocusableElement)) {\n            this._getFirstTabbableElement(this._host)?.focus();\n            event.preventDefault();\n          }\n        } else {\n          const firstFocusableElement = this._getFirstTabbableElement(this._host);\n          if (firstFocusableElement && event.composedPath().includes(firstFocusableElement)) {\n            this._getLastTabbableElement(this._host)?.focus();\n            event.preventDefault();\n          }\n        }\n      },\n      { signal: this._abortController.signal },\n    );\n  }\n\n  /** Get the first tabbable element from a DOM subtree (inclusive). */\n  private _getFirstTabbableElement(root: HTMLElement): HTMLElement | null {\n    if (\n      root !== this._host &&\n      interactivityChecker.isFocusable(root) &&\n      interactivityChecker.isTabbable(root)\n    ) {\n      return root;\n    }\n\n    const children = root.shadowRoot\n      ? root.shadowRoot.children\n      : root.localName === 'slot'\n        ? (root as HTMLSlotElement).assignedElements()\n        : root.children;\n\n    for (let i = 0; i < children.length; i++) {\n      const tabbableChild =\n        children[i].nodeType === document.ELEMENT_NODE\n          ? this._getFirstTabbableElement(children[i] as HTMLElement)\n          : null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return null;\n  }\n\n  /** Get the last tabbable element from a DOM subtree (inclusive). */\n  private _getLastTabbableElement(root: HTMLElement): HTMLElement | null {\n    let result: HTMLElement | null = null;\n\n    if (\n      root !== this._host &&\n      interactivityChecker.isFocusable(root) &&\n      interactivityChecker.isTabbable(root)\n    ) {\n      result = root;\n    }\n\n    const children = root.shadowRoot\n      ? root.shadowRoot.children\n      : root.localName === 'slot'\n        ? (root as HTMLSlotElement).assignedElements()\n        : root.children;\n\n    // Iterate in reverse DOM order.\n    for (let i = children.length - 1; i >= 0; i--) {\n      const tabbableChild =\n        children[i].nodeType === document.ELEMENT_NODE\n          ? this._getLastTabbableElement(children[i] as HTMLElement)\n          : null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return result;\n  }\n\n  private _untrap(): void {\n    this._abortController?.abort();\n    this._abortController = null;\n  }\n}\n"],"mappings":";;AAIA,IAAa,yBAAb,MAAmC;;;;;CAKjC,IAAW,QAAQ,SAAgB;AACjC,MAAI,QACF,MAAK,OAAO;MAEZ,MAAK,SAAS;;CAGlB,IAAW,UAAO;AAChB,SAAO,CAAC,CAAC,KAAK;;CAKhB,YAA2B,OAA2C;AAA3C,OAAA,QAAA;AAFnB,OAAA,mBAA2C;AAGjD,OAAK,MAAM,gBAAgB,KAAK;;CAG3B,mBAAgB;AACrB,OAAK,SAAS;;;;;;CAOT,oBAAoB,SAAsB;EAC/C,MAAM,oBAAoB,KAAK,MAAM,cAA2B,sBAAsB;AAEtF,MAAI,mBAAmB;AAOrB,OAAI,CAAC,qBAAqB,YAAY,kBAAkB,EAAE;IACxD,MAAM,iBAAiB,KAAK,yBAAyB,kBAAkB;AACvE,oBAAgB,MAAM,QAAQ;AAC9B,WAAO,CAAC,CAAC;;AAGX,qBAAkB,MAAM,QAAQ;AAChC,UAAO;;AAGT,SAAO,KAAK,0BAA0B,QAAQ;;;;;;CAOzC,0BAA0B,SAAsB;EACrD,MAAM,oBAAoB,KAAK,yBAAyB,KAAK,MAAM;AAEnE,MAAI,kBACF,mBAAkB,MAAM,QAAQ;AAGlC,SAAO,CAAC,CAAC;;;;;;CAOJ,yBAAyB,SAAsB;EACpD,MAAM,oBAAoB,KAAK,wBAAwB,KAAK,MAAM;AAElE,MAAI,kBACF,mBAAkB,MAAM,QAAQ;AAGlC,SAAO,CAAC,CAAC;;CAGH,QAAK;AACX,OAAK,mBAAmB,IAAI,iBAAiB;AAC7C,OAAK,MAAM,iBACT,YACC,UAAS;AACR,OAAI,MAAM,QAAQ,MAChB;AAGF,OAAI,CAAC,MAAM,UAAU;IACnB,MAAM,uBAAuB,KAAK,wBAAwB,KAAK,MAAM;AACrE,QAAI,wBAAwB,MAAM,cAAc,CAAC,SAAS,qBAAqB,EAAE;AAC/E,UAAK,yBAAyB,KAAK,MAAM,EAAE,OAAO;AAClD,WAAM,gBAAgB;;UAEnB;IACL,MAAM,wBAAwB,KAAK,yBAAyB,KAAK,MAAM;AACvE,QAAI,yBAAyB,MAAM,cAAc,CAAC,SAAS,sBAAsB,EAAE;AACjF,UAAK,wBAAwB,KAAK,MAAM,EAAE,OAAO;AACjD,WAAM,gBAAgB;;;KAI5B,EAAE,QAAQ,KAAK,iBAAiB,QAAQ,CACzC;;;CAIK,yBAAyB,MAAiB;AAChD,MACE,SAAS,KAAK,SACd,qBAAqB,YAAY,KAAK,IACtC,qBAAqB,WAAW,KAAK,CAErC,QAAO;EAGT,MAAM,WAAW,KAAK,aAClB,KAAK,WAAW,WAChB,KAAK,cAAc,SAChB,KAAyB,kBAAkB,GAC5C,KAAK;AAEX,OAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;GACxC,MAAM,gBACJ,SAAS,GAAG,aAAa,SAAS,eAC9B,KAAK,yBAAyB,SAAS,GAAkB,GACzD;AAEN,OAAI,cACF,QAAO;;AAIX,SAAO;;;CAID,wBAAwB,MAAiB;EAC/C,IAAI,SAA6B;AAEjC,MACE,SAAS,KAAK,SACd,qBAAqB,YAAY,KAAK,IACtC,qBAAqB,WAAW,KAAK,CAErC,UAAS;EAGX,MAAM,WAAW,KAAK,aAClB,KAAK,WAAW,WAChB,KAAK,cAAc,SAChB,KAAyB,kBAAkB,GAC5C,KAAK;AAGX,OAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;GAC7C,MAAM,gBACJ,SAAS,GAAG,aAAa,SAAS,eAC9B,KAAK,wBAAwB,SAAS,GAAkB,GACxD;AAEN,OAAI,cACF,QAAO;;AAIX,SAAO;;CAGD,UAAO;AACb,OAAK,kBAAkB,OAAO;AAC9B,OAAK,mBAAmB"}

package/development/core/a11y/focus-visible-within-controller.js

@@ -1,26 +1,27 @@
-import { ɵstateController as _stateController } from "../mixins/element-internals-mixin.js";
 import { sbbInputModalityDetector } from "./input-modality-detector.js";
-class SbbFocusVisibleWithinController {
-  constructor(_host) {
-    this._host = _host;
-    this._focusinHandler = () => {
-      _stateController(this._host).toggle("has-visible-focus-within", sbbInputModalityDetector.mostRecentModality === "keyboard");
-    };
-    this._focusoutHandler = () => {
-      _stateController(this._host).delete("has-visible-focus-within");
-    };
-    this._host.addController(this);
-  }
-  hostConnected() {
-    this._host.addEventListener("focusin", this._focusinHandler);
-    this._host.addEventListener("focusout", this._focusoutHandler);
-  }
-  hostDisconnected() {
-    this._host.removeEventListener("focusin", this._focusinHandler);
-    this._host.removeEventListener("focusout", this._focusoutHandler);
-  }
-}
-export {
-  SbbFocusVisibleWithinController
+import { ɵstateController } from "../mixins/element-internals-mixin.js";
+//#region src/elements/core/a11y/focus-visible-within-controller.ts
+var SbbFocusVisibleWithinController = class {
+	constructor(_host) {
+		this._host = _host;
+		this._focusinHandler = () => {
+			ɵstateController(this._host).toggle("has-visible-focus-within", sbbInputModalityDetector.mostRecentModality === "keyboard");
+		};
+		this._focusoutHandler = () => {
+			ɵstateController(this._host).delete("has-visible-focus-within");
+		};
+		this._host.addController(this);
+	}
+	hostConnected() {
+		this._host.addEventListener("focusin", this._focusinHandler);
+		this._host.addEventListener("focusout", this._focusoutHandler);
+	}
+	hostDisconnected() {
+		this._host.removeEventListener("focusin", this._focusinHandler);
+		this._host.removeEventListener("focusout", this._focusoutHandler);
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMtdmlzaWJsZS13aXRoaW4tY29udHJvbGxlci5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2NvcmUvYTExeS9mb2N1cy12aXNpYmxlLXdpdGhpbi1jb250cm9sbGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUmVhY3RpdmVDb250cm9sbGVyLCBSZWFjdGl2ZUNvbnRyb2xsZXJIb3N0IH0gZnJvbSAnbGl0JztcblxuaW1wb3J0IHsgybVzdGF0ZUNvbnRyb2xsZXIgfSBmcm9tICcuLi9taXhpbnMvZWxlbWVudC1pbnRlcm5hbHMtbWl4aW4udHMnO1xuaW1wb3J0IHR5cGUgeyBTYmJFbGVtZW50SW50ZXJuYWxzTWl4aW5UeXBlIH0gZnJvbSAnLi4vbWl4aW5zLnRzJztcblxuaW1wb3J0IHsgc2JiSW5wdXRNb2RhbGl0eURldGVjdG9yIH0gZnJvbSAnLi9pbnB1dC1tb2RhbGl0eS1kZXRlY3Rvci50cyc7XG5cbi8vIERldGVybWluZSB3aGV0aGVyIHRoZSBlbGVtZW50IGhhcyBhIHZpc2libGUgZm9jdXMgd2l0aGluLlxuZXhwb3J0IGNsYXNzIFNiYkZvY3VzVmlzaWJsZVdpdGhpbkNvbnRyb2xsZXIgaW1wbGVtZW50cyBSZWFjdGl2ZUNvbnRyb2xsZXIge1xuICBwdWJsaWMgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSBfaG9zdDogU2JiRWxlbWVudEludGVybmFsc01peGluVHlwZSAmIFJlYWN0aXZlQ29udHJvbGxlckhvc3QgJiBIVE1MRWxlbWVudCxcbiAgKSB7XG4gICAgdGhpcy5faG9zdC5hZGRDb250cm9sbGVyKHRoaXMpO1xuICB9XG5cbiAgcHJpdmF0ZSBfZm9jdXNpbkhhbmRsZXIgPSAoKTogdm9pZCA9PiB7XG4gICAgybVzdGF0ZUNvbnRyb2xsZXIodGhpcy5faG9zdCkudG9nZ2xlKFxuICAgICAgJ2hhcy12aXNpYmxlLWZvY3VzLXdpdGhpbicsXG4gICAgICBzYmJJbnB1dE1vZGFsaXR5RGV0ZWN0b3IubW9zdFJlY2VudE1vZGFsaXR5ID09PSAna2V5Ym9hcmQnLFxuICAgICk7XG4gIH07XG5cbiAgcHJpdmF0ZSBfZm9jdXNvdXRIYW5kbGVyID0gKCk6IHZvaWQgPT4ge1xuICAgIMm1c3RhdGVDb250cm9sbGVyKHRoaXMuX2hvc3QpLmRlbGV0ZSgnaGFzLXZpc2libGUtZm9jdXMtd2l0aGluJyk7XG4gIH07XG5cbiAgcHVibGljIGhvc3RDb25uZWN0ZWQoKTogdm9pZCB7XG4gICAgdGhpcy5faG9zdC5hZGRFdmVudExpc3RlbmVyKCdmb2N1c2luJywgdGhpcy5fZm9jdXNpbkhhbmRsZXIpO1xuICAgIHRoaXMuX2hvc3QuYWRkRXZlbnRMaXN0ZW5lcignZm9jdXNvdXQnLCB0aGlzLl9mb2N1c291dEhhbmRsZXIpO1xuICB9XG5cbiAgcHVibGljIGhvc3REaXNjb25uZWN0ZWQoKTogdm9pZCB7XG4gICAgdGhpcy5faG9zdC5yZW1vdmVFdmVudExpc3RlbmVyKCdmb2N1c2luJywgdGhpcy5fZm9jdXNpbkhhbmRsZXIpO1xuICAgIHRoaXMuX2hvc3QucmVtb3ZlRXZlbnRMaXN0ZW5lcignZm9jdXNvdXQnLCB0aGlzLl9mb2N1c291dEhhbmRsZXIpO1xuICB9XG59XG4iXSwibmFtZXMiOlsiybVzdGF0ZUNvbnRyb2xsZXIiXSwibWFwcGluZ3MiOiI7O01BUWEsZ0NBQStCO0FBQUEsRUFDMUMsWUFDVSxPQUEwRTtBQUExRSxTQUFBLFFBQUE7QUFLRixTQUFBLGtCQUFrQixNQUFXO0FBQ25DQSx1QkFBaUIsS0FBSyxLQUFLLEVBQUUsT0FDM0IsNEJBQ0EseUJBQXlCLHVCQUF1QixVQUFVO0FBQUEsSUFFOUQ7QUFFUSxTQUFBLG1CQUFtQixNQUFXO0FBQ3BDQSx1QkFBaUIsS0FBSyxLQUFLLEVBQUUsT0FBTywwQkFBMEI7QUFBQSxJQUNoRTtBQVpFLFNBQUssTUFBTSxjQUFjLElBQUk7QUFBQSxFQUMvQjtBQUFBLEVBYU8sZ0JBQWE7QUFDbEIsU0FBSyxNQUFNLGlCQUFpQixXQUFXLEtBQUssZUFBZTtBQUMzRCxTQUFLLE1BQU0saUJBQWlCLFlBQVksS0FBSyxnQkFBZ0I7QUFBQSxFQUMvRDtBQUFBLEVBRU8sbUJBQWdCO0FBQ3JCLFNBQUssTUFBTSxvQkFBb0IsV0FBVyxLQUFLLGVBQWU7QUFDOUQsU0FBSyxNQUFNLG9CQUFvQixZQUFZLEtBQUssZ0JBQWdCO0FBQUEsRUFDbEU7QUFDRDsifQ==
+//#endregion
+export { SbbFocusVisibleWithinController };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/a11y/focus.js

@@ -1,14 +1,15 @@
-const IS_FOCUSABLE_QUERY = [
-  "button",
-  "[href]",
-  "input",
-  "select",
-  "textarea",
-  "details",
-  "summary",
-  "[tabindex]"
+//#region src/elements/core/a11y/focus.ts
+var IS_FOCUSABLE_QUERY = [
+	"button",
+	"[href]",
+	"input",
+	"select",
+	"textarea",
+	"details",
+	"summary",
+	"[tabindex]"
 ].map((selector) => `${selector}:not([disabled],:disabled,[tabindex="-1"],[inert])`).join(",");
-export {
-  IS_FOCUSABLE_QUERY
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jb3JlL2ExMXkvZm9jdXMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IElTX0ZPQ1VTQUJMRV9RVUVSWSA9IFtcbiAgJ2J1dHRvbicsXG4gICdbaHJlZl0nLFxuICAnaW5wdXQnLFxuICAnc2VsZWN0JyxcbiAgJ3RleHRhcmVhJyxcbiAgJ2RldGFpbHMnLFxuICAnc3VtbWFyeScsXG4gICdbdGFiaW5kZXhdJyxcbl1cbiAgLm1hcCgoc2VsZWN0b3IpID0+IGAke3NlbGVjdG9yfTpub3QoW2Rpc2FibGVkXSw6ZGlzYWJsZWQsW3RhYmluZGV4PVwiLTFcIl0sW2luZXJ0XSlgKVxuICAuam9pbignLCcpO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFPLE1BQU0scUJBQXFCO0FBQUEsRUFDaEM7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQ0QsRUFDRSxJQUFJLENBQUMsYUFBYSxHQUFHLFFBQVEsb0RBQW9ELEVBQ2pGLEtBQUssR0FBRzsifQ==
+//#endregion
+export { IS_FOCUSABLE_QUERY };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2NvcmUvYTExeS9mb2N1cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgSVNfRk9DVVNBQkxFX1FVRVJZID0gW1xuICAnYnV0dG9uJyxcbiAgJ1tocmVmXScsXG4gICdpbnB1dCcsXG4gICdzZWxlY3QnLFxuICAndGV4dGFyZWEnLFxuICAnZGV0YWlscycsXG4gICdzdW1tYXJ5JyxcbiAgJ1t0YWJpbmRleF0nLFxuXVxuICAubWFwKChzZWxlY3RvcikgPT4gYCR7c2VsZWN0b3J9Om5vdChbZGlzYWJsZWRdLDpkaXNhYmxlZCxbdGFiaW5kZXg9XCItMVwiXSxbaW5lcnRdKWApXG4gIC5qb2luKCcsJyk7XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxJQUFhLHFCQUFxQjtDQUNoQztDQUNBO0NBQ0E7Q0FDQTtDQUNBO0NBQ0E7Q0FDQTtDQUNBO0NBQ0QsQ0FDRSxLQUFLLGFBQWEsR0FBRyxTQUFRLG9EQUFxRCxDQUNsRixLQUFLLElBQUkifQ==

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

@@ -1,79 +1,132 @@
+import { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from "./fake-event-detection.js";
 import { isServer } from "lit";
 import { getEventTarget } from "../eventing.js";
-import { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from "./fake-event-detection.js";
-const SHIFT = 16;
-const CONTROL = 17;
-const ALT = 18;
-const META = 91;
-const MAC_META = 224;
-const inputModalityDetectorOptions = {
-  ignoreKeys: [ALT, CONTROL, MAC_META, META, SHIFT]
-};
-const touchBufferMs = 650;
-const modalityEventListenerOptions = {
-  passive: true,
-  capture: true
+//#region src/elements/core/a11y/input-modality-detector.ts
+/**
+* Default options for the SbbInputModalityDetector.
+*
+* Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect
+* keyboard input modality) for two reasons:
+*
+* 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open
+*    in new tab', and are thus less representative of actual keyboard interaction.
+* 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but
+*    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore
+*    these keys so, as to not update the input modality.
+*
+* Note that we do not by default ignore the right Meta key on Safari because it has the same key
+* code as the ContextMenu key on other browsers. When we switch to using event.key, we can
+* distinguish between the two.
+*/
+var inputModalityDetectorOptions = { ignoreKeys: [
+	18,
+	17,
+	224,
+	91,
+	16
+] };
+/**
+* The amount of time needed to pass after a touchstart event in order for a subsequent mousedown
+* event to be attributed as mouse and not touch.
+*
+* Through trial and error it was found that a value of around 650ms seems appropriate.
+*/
+var touchBufferMs = 650;
+/**
+* Event listener options that enable capturing and also mark the listener as passive if the browser
+* supports it.
+*/
+var modalityEventListenerOptions = {
+	passive: true,
+	capture: true
 };
-class SbbInputModalityDetector {
-  /** The most recently detected input modality. */
-  get mostRecentModality() {
-    return this._mostRecentModality;
-  }
-  /**
-   * The most recently detected input modality event target. Is null if no input modality has been
-   * detected or if the associated event target is null for some unknown reason.
-   */
-  get mostRecentTarget() {
-    return this._mostRecentTarget;
-  }
-  constructor() {
-    this._mostRecentModality = "mouse";
-    this._mostRecentTarget = null;
-    this._options = {
-      ...inputModalityDetectorOptions
-    };
-    this._lastTouchMs = 0;
-    this._onKeydown = (event) => {
-      if (this._options?.ignoreKeys?.some((keyCode) => keyCode === event.keyCode)) {
-        return;
-      }
-      this._updateState("keyboard", event);
-    };
-    this._onMousedown = (event) => {
-      if (Date.now() - this._lastTouchMs < touchBufferMs) {
-        return;
-      }
-      this._updateState(isFakeMousedownFromScreenReader(event) ? "keyboard" : "mouse", event);
-    };
-    this._onTouchstart = (event) => {
-      if (isFakeTouchstartFromScreenReader(event)) {
-        this._updateState("keyboard", event);
-        return;
-      }
-      this._lastTouchMs = Date.now();
-      this._updateState("touch", event);
-    };
-    if (!isServer) {
-      document.addEventListener("keydown", this._onKeydown, modalityEventListenerOptions);
-      document.addEventListener("mousedown", this._onMousedown, modalityEventListenerOptions);
-      document.addEventListener("touchstart", this._onTouchstart, modalityEventListenerOptions);
-    }
-  }
-  reset() {
-    this._updateState("mouse", null);
-    this._lastTouchMs = 0;
-  }
-  _updateState(modality, event) {
-    if (this._mostRecentModality) {
-      document.documentElement.classList.remove(`sbb-focus-modality-${this._mostRecentModality}`);
-    }
-    this._mostRecentModality = modality;
-    this._mostRecentTarget = event ? getEventTarget(event) : null;
-    document.documentElement.classList.add(`sbb-focus-modality-${this._mostRecentModality}`);
-  }
-}
-const sbbInputModalityDetector = new SbbInputModalityDetector();
-export {
-  sbbInputModalityDetector
+/**
+* Service that detects the user's input modality.
+*
+* This service does not update the input modality when a user navigates with a screen reader
+* (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC
+* cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not
+* fire as expected in these modes) but is also arguably the correct behavior. Navigating with a
+* screen reader is akin to visually scanning a page, and should not be interpreted as actual user
+* input interaction.
+*
+* When a user is not navigating but *interacting* with a screen reader, this service attempts to
+* update the input modality to keyboard, but in general this service's behavior is largely
+* undefined.
+*/
+var SbbInputModalityDetector = class {
+	/** The most recently detected input modality. */
+	get mostRecentModality() {
+		return this._mostRecentModality;
+	}
+	/**
+	* The most recently detected input modality event target. Is null if no input modality has been
+	* detected or if the associated event target is null for some unknown reason.
+	*/
+	get mostRecentTarget() {
+		return this._mostRecentTarget;
+	}
+	constructor() {
+		/**
+		* The most recent modality must be initialised with the value 'mouse' to cover the case where an action is
+		* performed but no mouse or keyboard event has yet occurred on the page (e.g. `sbb-popover` with hover trigger).
+		*/
+		this._mostRecentModality = "mouse";
+		this._mostRecentTarget = null;
+		/** Options for this SbbInputModalityDetector. */
+		this._options = { ...inputModalityDetectorOptions };
+		/**
+		* The timestamp of the last touch input modality. Used to determine whether mousedown events
+		* should be attributed to mouse or touch.
+		*/
+		this._lastTouchMs = 0;
+		/**
+		* Handles keydown events. Must be an arrow function in order to preserve the context when it gets
+		* bound.
+		*/
+		this._onKeydown = (event) => {
+			if (this._options?.ignoreKeys?.some((keyCode) => keyCode === event.keyCode)) return;
+			this._updateState("keyboard", event);
+		};
+		/**
+		* Handles mousedown events. Must be an arrow function in order to preserve the context when it
+		* gets bound.
+		*/
+		this._onMousedown = (event) => {
+			if (Date.now() - this._lastTouchMs < touchBufferMs) return;
+			this._updateState(isFakeMousedownFromScreenReader(event) ? "keyboard" : "mouse", event);
+		};
+		/**
+		* Handles touchstart events. Must be an arrow function in order to preserve the context when it
+		* gets bound.
+		*/
+		this._onTouchstart = (event) => {
+			if (isFakeTouchstartFromScreenReader(event)) {
+				this._updateState("keyboard", event);
+				return;
+			}
+			this._lastTouchMs = Date.now();
+			this._updateState("touch", event);
+		};
+		if (!isServer) {
+			document.addEventListener("keydown", this._onKeydown, modalityEventListenerOptions);
+			document.addEventListener("mousedown", this._onMousedown, modalityEventListenerOptions);
+			document.addEventListener("touchstart", this._onTouchstart, modalityEventListenerOptions);
+		}
+	}
+	reset() {
+		this._updateState("mouse", null);
+		this._lastTouchMs = 0;
+	}
+	_updateState(modality, event) {
+		if (this._mostRecentModality) document.documentElement.classList.remove(`sbb-focus-modality-${this._mostRecentModality}`);
+		this._mostRecentModality = modality;
+		this._mostRecentTarget = event ? getEventTarget(event) : null;
+		document.documentElement.classList.add(`sbb-focus-modality-${this._mostRecentModality}`);
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"input-modality-detector.js","sources":["../../../../../src/elements/core/a11y/input-modality-detector.ts"],"sourcesContent":["// This implementation is inspired by https://github.com/angular/components/blob/main/src/cdk/a11y/input-modality/input-modality-detector.ts\n\nimport { isServer } from 'lit';\n\nimport { getEventTarget } from '../eventing.ts';\n\nimport {\n  isFakeMousedownFromScreenReader,\n  isFakeTouchstartFromScreenReader,\n} from './fake-event-detection.ts';\n\nexport type SbbInputModality = 'touch' | 'mouse' | 'keyboard' | 'program' | null;\n\n/** Options to configure the behavior of the SbbInputModalityDetector. */\ninterface SbbInputModalityDetectorOptions {\n  /** Keys to ignore when detecting keyboard input modality. */\n  ignoreKeys?: number[];\n}\n\nconst SHIFT = 16;\nconst CONTROL = 17;\nconst ALT = 18;\nconst META = 91; // WIN_KEY_LEFT\nconst MAC_META = 224;\n\n/**\n * Default options for the SbbInputModalityDetector.\n *\n * Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect\n * keyboard input modality) for two reasons:\n *\n * 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open\n *    in new tab', and are thus less representative of actual keyboard interaction.\n * 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but\n *    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore\n *    these keys so, as to not update the input modality.\n *\n * Note that we do not by default ignore the right Meta key on Safari because it has the same key\n * code as the ContextMenu key on other browsers. When we switch to using event.key, we can\n * distinguish between the two.\n */\nconst inputModalityDetectorOptions: SbbInputModalityDetectorOptions = {\n  ignoreKeys: [ALT, CONTROL, MAC_META, META, SHIFT],\n};\n\n/**\n * The amount of time needed to pass after a touchstart event in order for a subsequent mousedown\n * event to be attributed as mouse and not touch.\n *\n * Through trial and error it was found that a value of around 650ms seems appropriate.\n */\nconst touchBufferMs = 650;\n\n/**\n * Event listener options that enable capturing and also mark the listener as passive if the browser\n * supports it.\n */\nconst modalityEventListenerOptions = {\n  passive: true,\n  capture: true,\n};\n\n/**\n * Service that detects the user's input modality.\n *\n * This service does not update the input modality when a user navigates with a screen reader\n * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC\n * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not\n * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a\n * screen reader is akin to visually scanning a page, and should not be interpreted as actual user\n * input interaction.\n *\n * When a user is not navigating but *interacting* with a screen reader, this service attempts to\n * update the input modality to keyboard, but in general this service's behavior is largely\n * undefined.\n */\nclass SbbInputModalityDetector {\n  /** The most recently detected input modality. */\n  public get mostRecentModality(): SbbInputModality | null {\n    return this._mostRecentModality;\n  }\n\n  /**\n   * The most recent modality must be initialised with the value 'mouse' to cover the case where an action is\n   * performed but no mouse or keyboard event has yet occurred on the page (e.g. `sbb-popover` with hover trigger).\n   */\n  private _mostRecentModality: SbbInputModality | null = 'mouse';\n\n  /**\n   * The most recently detected input modality event target. Is null if no input modality has been\n   * detected or if the associated event target is null for some unknown reason.\n   */\n  public get mostRecentTarget(): HTMLElement | null {\n    return this._mostRecentTarget;\n  }\n  private _mostRecentTarget: HTMLElement | null = null;\n\n  /** Options for this SbbInputModalityDetector. */\n  private readonly _options: SbbInputModalityDetectorOptions = {\n    ...inputModalityDetectorOptions,\n  };\n\n  /**\n   * The timestamp of the last touch input modality. Used to determine whether mousedown events\n   * should be attributed to mouse or touch.\n   */\n  private _lastTouchMs = 0;\n\n  public constructor() {\n    if (!isServer) {\n      document.addEventListener('keydown', this._onKeydown, modalityEventListenerOptions);\n      document.addEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);\n      document.addEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);\n    }\n  }\n\n  public reset(): void {\n    this._updateState('mouse', null);\n    this._lastTouchMs = 0;\n  }\n\n  /**\n   * Handles keydown events. Must be an arrow function in order to preserve the context when it gets\n   * bound.\n   */\n  private _onKeydown = (event: KeyboardEvent): void => {\n    // If this is one of the keys we should ignore, then ignore it and don't update the input\n    // modality to keyboard.\n    if (this._options?.ignoreKeys?.some((keyCode) => keyCode === event.keyCode)) {\n      return;\n    }\n\n    this._updateState('keyboard', event);\n  };\n\n  /**\n   * Handles mousedown events. Must be an arrow function in order to preserve the context when it\n   * gets bound.\n   */\n  private _onMousedown = (event: MouseEvent): void => {\n    // Touches trigger both touch and mouse events, so we need to distinguish between mouse events\n    // that were triggered via mouse vs touch. To do so, check if the mouse event occurs closely\n    // after the previous touch event.\n    if (Date.now() - this._lastTouchMs < touchBufferMs) {\n      return;\n    }\n\n    // Fake mousedown events are fired by some screen readers when controls are activated by the\n    // screen reader. Attribute them to keyboard input modality.\n    this._updateState(isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse', event);\n  };\n\n  /**\n   * Handles touchstart events. Must be an arrow function in order to preserve the context when it\n   * gets bound.\n   */\n  private _onTouchstart = (event: TouchEvent): void => {\n    // Same scenario as mentioned in _onMousedown, but on touch screen devices, fake touchstart\n    // events are fired. Again, attribute to keyboard input modality.\n    if (isFakeTouchstartFromScreenReader(event)) {\n      this._updateState('keyboard', event);\n      return;\n    }\n\n    // Store the timestamp of this touch event, as it's used to distinguish between mouse events\n    // triggered via mouse vs touch.\n    this._lastTouchMs = Date.now();\n\n    this._updateState('touch', event);\n  };\n\n  private _updateState(modality: SbbInputModality, event: Event | null): void {\n    if (this._mostRecentModality) {\n      document.documentElement.classList.remove(`sbb-focus-modality-${this._mostRecentModality}`);\n    }\n    this._mostRecentModality = modality;\n    this._mostRecentTarget = event ? getEventTarget(event) : null;\n    document.documentElement.classList.add(`sbb-focus-modality-${this._mostRecentModality}`);\n  }\n}\n\nexport const sbbInputModalityDetector = new SbbInputModalityDetector();\n"],"names":[],"mappings":";;;AAmBA,MAAM,QAAQ;AACd,MAAM,UAAU;AAChB,MAAM,MAAM;AACZ,MAAM,OAAO;AACb,MAAM,WAAW;AAkBjB,MAAM,+BAAgE;AAAA,EACpE,YAAY,CAAC,KAAK,SAAS,UAAU,MAAM,KAAK;;AASlD,MAAM,gBAAgB;AAMtB,MAAM,+BAA+B;AAAA,EACnC,SAAS;AAAA,EACT,SAAS;;AAiBX,MAAM,yBAAwB;AAAA;AAAA,EAE5B,IAAW,qBAAkB;AAC3B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,IAAW,mBAAgB;AACzB,WAAO,KAAK;AAAA,EACd;AAAA,EAcA,cAAA;AAtBQ,SAAA,sBAA+C;AAS/C,SAAA,oBAAwC;AAG/B,SAAA,WAA4C;AAAA,MAC3D,GAAG;AAAA,IAAA;AAOG,SAAA,eAAe;AAmBf,SAAA,aAAa,CAAC,UAA8B;AAGlD,UAAI,KAAK,UAAU,YAAY,KAAK,CAAC,YAAY,YAAY,MAAM,OAAO,GAAG;AAC3E;AAAA,MACF;AAEA,WAAK,aAAa,YAAY,KAAK;AAAA,IACrC;AAMQ,SAAA,eAAe,CAAC,UAA2B;AAIjD,UAAI,KAAK,IAAA,IAAQ,KAAK,eAAe,eAAe;AAClD;AAAA,MACF;AAIA,WAAK,aAAa,gCAAgC,KAAK,IAAI,aAAa,SAAS,KAAK;AAAA,IACxF;AAMQ,SAAA,gBAAgB,CAAC,UAA2B;AAGlD,UAAI,iCAAiC,KAAK,GAAG;AAC3C,aAAK,aAAa,YAAY,KAAK;AACnC;AAAA,MACF;AAIA,WAAK,eAAe,KAAK,IAAA;AAEzB,WAAK,aAAa,SAAS,KAAK;AAAA,IAClC;AA5DE,QAAI,CAAC,UAAU;AACb,eAAS,iBAAiB,WAAW,KAAK,YAAY,4BAA4B;AAClF,eAAS,iBAAiB,aAAa,KAAK,cAAc,4BAA4B;AACtF,eAAS,iBAAiB,cAAc,KAAK,eAAe,4BAA4B;AAAA,IAC1F;AAAA,EACF;AAAA,EAEO,QAAK;AACV,SAAK,aAAa,SAAS,IAAI;AAC/B,SAAK,eAAe;AAAA,EACtB;AAAA,EAoDQ,aAAa,UAA4B,OAAmB;AAClE,QAAI,KAAK,qBAAqB;AAC5B,eAAS,gBAAgB,UAAU,OAAO,sBAAsB,KAAK,mBAAmB,EAAE;AAAA,IAC5F;AACA,SAAK,sBAAsB;AAC3B,SAAK,oBAAoB,QAAQ,eAAe,KAAK,IAAI;AACzD,aAAS,gBAAgB,UAAU,IAAI,sBAAsB,KAAK,mBAAmB,EAAE;AAAA,EACzF;AACD;AAEM,MAAM,2BAA2B,IAAI,yBAAA;"}
+var sbbInputModalityDetector = new SbbInputModalityDetector();
+//#endregion
+export { sbbInputModalityDetector };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"input-modality-detector.js","names":[],"sources":["../../../../../src/elements/core/a11y/input-modality-detector.ts"],"sourcesContent":["// This implementation is inspired by https://github.com/angular/components/blob/main/src/cdk/a11y/input-modality/input-modality-detector.ts\n\nimport { isServer } from 'lit';\n\nimport { getEventTarget } from '../eventing.ts';\n\nimport {\n  isFakeMousedownFromScreenReader,\n  isFakeTouchstartFromScreenReader,\n} from './fake-event-detection.ts';\n\nexport type SbbInputModality = 'touch' | 'mouse' | 'keyboard' | 'program' | null;\n\n/** Options to configure the behavior of the SbbInputModalityDetector. */\ninterface SbbInputModalityDetectorOptions {\n  /** Keys to ignore when detecting keyboard input modality. */\n  ignoreKeys?: number[];\n}\n\nconst SHIFT = 16;\nconst CONTROL = 17;\nconst ALT = 18;\nconst META = 91; // WIN_KEY_LEFT\nconst MAC_META = 224;\n\n/**\n * Default options for the SbbInputModalityDetector.\n *\n * Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect\n * keyboard input modality) for two reasons:\n *\n * 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open\n *    in new tab', and are thus less representative of actual keyboard interaction.\n * 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but\n *    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore\n *    these keys so, as to not update the input modality.\n *\n * Note that we do not by default ignore the right Meta key on Safari because it has the same key\n * code as the ContextMenu key on other browsers. When we switch to using event.key, we can\n * distinguish between the two.\n */\nconst inputModalityDetectorOptions: SbbInputModalityDetectorOptions = {\n  ignoreKeys: [ALT, CONTROL, MAC_META, META, SHIFT],\n};\n\n/**\n * The amount of time needed to pass after a touchstart event in order for a subsequent mousedown\n * event to be attributed as mouse and not touch.\n *\n * Through trial and error it was found that a value of around 650ms seems appropriate.\n */\nconst touchBufferMs = 650;\n\n/**\n * Event listener options that enable capturing and also mark the listener as passive if the browser\n * supports it.\n */\nconst modalityEventListenerOptions = {\n  passive: true,\n  capture: true,\n};\n\n/**\n * Service that detects the user's input modality.\n *\n * This service does not update the input modality when a user navigates with a screen reader\n * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC\n * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not\n * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a\n * screen reader is akin to visually scanning a page, and should not be interpreted as actual user\n * input interaction.\n *\n * When a user is not navigating but *interacting* with a screen reader, this service attempts to\n * update the input modality to keyboard, but in general this service's behavior is largely\n * undefined.\n */\nclass SbbInputModalityDetector {\n  /** The most recently detected input modality. */\n  public get mostRecentModality(): SbbInputModality | null {\n    return this._mostRecentModality;\n  }\n\n  /**\n   * The most recent modality must be initialised with the value 'mouse' to cover the case where an action is\n   * performed but no mouse or keyboard event has yet occurred on the page (e.g. `sbb-popover` with hover trigger).\n   */\n  private _mostRecentModality: SbbInputModality | null = 'mouse';\n\n  /**\n   * The most recently detected input modality event target. Is null if no input modality has been\n   * detected or if the associated event target is null for some unknown reason.\n   */\n  public get mostRecentTarget(): HTMLElement | null {\n    return this._mostRecentTarget;\n  }\n  private _mostRecentTarget: HTMLElement | null = null;\n\n  /** Options for this SbbInputModalityDetector. */\n  private readonly _options: SbbInputModalityDetectorOptions = {\n    ...inputModalityDetectorOptions,\n  };\n\n  /**\n   * The timestamp of the last touch input modality. Used to determine whether mousedown events\n   * should be attributed to mouse or touch.\n   */\n  private _lastTouchMs = 0;\n\n  public constructor() {\n    if (!isServer) {\n      document.addEventListener('keydown', this._onKeydown, modalityEventListenerOptions);\n      document.addEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);\n      document.addEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);\n    }\n  }\n\n  public reset(): void {\n    this._updateState('mouse', null);\n    this._lastTouchMs = 0;\n  }\n\n  /**\n   * Handles keydown events. Must be an arrow function in order to preserve the context when it gets\n   * bound.\n   */\n  private _onKeydown = (event: KeyboardEvent): void => {\n    // If this is one of the keys we should ignore, then ignore it and don't update the input\n    // modality to keyboard.\n    if (this._options?.ignoreKeys?.some((keyCode) => keyCode === event.keyCode)) {\n      return;\n    }\n\n    this._updateState('keyboard', event);\n  };\n\n  /**\n   * Handles mousedown events. Must be an arrow function in order to preserve the context when it\n   * gets bound.\n   */\n  private _onMousedown = (event: MouseEvent): void => {\n    // Touches trigger both touch and mouse events, so we need to distinguish between mouse events\n    // that were triggered via mouse vs touch. To do so, check if the mouse event occurs closely\n    // after the previous touch event.\n    if (Date.now() - this._lastTouchMs < touchBufferMs) {\n      return;\n    }\n\n    // Fake mousedown events are fired by some screen readers when controls are activated by the\n    // screen reader. Attribute them to keyboard input modality.\n    this._updateState(isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse', event);\n  };\n\n  /**\n   * Handles touchstart events. Must be an arrow function in order to preserve the context when it\n   * gets bound.\n   */\n  private _onTouchstart = (event: TouchEvent): void => {\n    // Same scenario as mentioned in _onMousedown, but on touch screen devices, fake touchstart\n    // events are fired. Again, attribute to keyboard input modality.\n    if (isFakeTouchstartFromScreenReader(event)) {\n      this._updateState('keyboard', event);\n      return;\n    }\n\n    // Store the timestamp of this touch event, as it's used to distinguish between mouse events\n    // triggered via mouse vs touch.\n    this._lastTouchMs = Date.now();\n\n    this._updateState('touch', event);\n  };\n\n  private _updateState(modality: SbbInputModality, event: Event | null): void {\n    if (this._mostRecentModality) {\n      document.documentElement.classList.remove(`sbb-focus-modality-${this._mostRecentModality}`);\n    }\n    this._mostRecentModality = modality;\n    this._mostRecentTarget = event ? getEventTarget(event) : null;\n    document.documentElement.classList.add(`sbb-focus-modality-${this._mostRecentModality}`);\n  }\n}\n\nexport const sbbInputModalityDetector = new SbbInputModalityDetector();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyCA,IAAM,+BAAgE,EACpE,YAAY;CArBF;CADI;CAGC;CADJ;CAHC;CAuBqC,EAClD;;;;;;;AAQD,IAAM,gBAAgB;;;;;AAMtB,IAAM,+BAA+B;CACnC,SAAS;CACT,SAAS;CACV;;;;;;;;;;;;;;;AAgBD,IAAM,2BAAN,MAA8B;;CAE5B,IAAW,qBAAkB;AAC3B,SAAO,KAAK;;;;;;CAad,IAAW,mBAAgB;AACzB,SAAO,KAAK;;CAed,cAAA;;;;;AAtBQ,OAAA,sBAA+C;AAS/C,OAAA,oBAAwC;;AAG/B,OAAA,WAA4C,EAC3D,GAAG,8BACJ;;;;;AAMO,OAAA,eAAe;;;;;AAmBf,OAAA,cAAc,UAA8B;AAGlD,OAAI,KAAK,UAAU,YAAY,MAAM,YAAY,YAAY,MAAM,QAAQ,CACzE;AAGF,QAAK,aAAa,YAAY,MAAM;;;;;;AAO9B,OAAA,gBAAgB,UAA2B;AAIjD,OAAI,KAAK,KAAK,GAAG,KAAK,eAAe,cACnC;AAKF,QAAK,aAAa,gCAAgC,MAAM,GAAG,aAAa,SAAS,MAAM;;;;;;AAOjF,OAAA,iBAAiB,UAA2B;AAGlD,OAAI,iCAAiC,MAAM,EAAE;AAC3C,SAAK,aAAa,YAAY,MAAM;AACpC;;AAKF,QAAK,eAAe,KAAK,KAAK;AAE9B,QAAK,aAAa,SAAS,MAAM;;AA3DjC,MAAI,CAAC,UAAU;AACb,YAAS,iBAAiB,WAAW,KAAK,YAAY,6BAA6B;AACnF,YAAS,iBAAiB,aAAa,KAAK,cAAc,6BAA6B;AACvF,YAAS,iBAAiB,cAAc,KAAK,eAAe,6BAA6B;;;CAItF,QAAK;AACV,OAAK,aAAa,SAAS,KAAK;AAChC,OAAK,eAAe;;CAqDd,aAAa,UAA4B,OAAmB;AAClE,MAAI,KAAK,oBACP,UAAS,gBAAgB,UAAU,OAAO,sBAAsB,KAAK,sBAAsB;AAE7F,OAAK,sBAAsB;AAC3B,OAAK,oBAAoB,QAAQ,eAAe,MAAM,GAAG;AACzD,WAAS,gBAAgB,UAAU,IAAI,sBAAsB,KAAK,sBAAsB;;;AAI5F,IAAa,2BAA2B,IAAI,0BAA0B"}