@sbb-esta/lyne-elements 4.7.0 → 4.8.0

package/development/core/a11y/interactivity-checker.js

@@ -1,129 +1,136 @@
 import { isServer } from "lit";
-import { isWebkit, isIOS, isFirefox } from "../dom/platform.js";
-class IsFocusableConfig {
-  constructor() {
-    this.ignoreVisibility = false;
-  }
-}
-class InteractivityChecker {
-  /**
-   * Gets whether an element is disabled.
-   *
-   * @param element Element to be checked.
-   * @returns Whether the element is disabled.
-   */
-  isDisabled(element) {
-    return element.hasAttribute("disabled") || element.matches(":disabled");
-  }
-  /**
-   * Gets whether an element is visible for the purposes of interactivity.
-   *
-   * This will capture states like `display: none` and `visibility: hidden`, but not things like
-   * being clipped by an `overflow: hidden` parent or being outside the viewport.
-   *
-   * @returns Whether the element is visible.
-   */
-  isVisible(element) {
-    return hasGeometry(element) && getComputedStyle(element).visibility === "visible";
-  }
-  /**
-   * Gets whether an element can be reached via Tab key.
-   * Assumes that the element has already been checked with isFocusable.
-   *
-   * @param element Element to be checked.
-   * @returns Whether the element is tabbable.
-   */
-  isTabbable(element) {
-    if (isServer) {
-      return false;
-    }
-    const nodeName = element.nodeName.toLowerCase();
-    const tabIndexValue = getTabIndexValue(element);
-    if (element.hasAttribute("contenteditable")) {
-      return tabIndexValue !== -1;
-    }
-    if (nodeName === "iframe" || nodeName === "object") {
-      return false;
-    }
-    if (isWebkit && isIOS && !isPotentiallyTabbableIOS(element)) {
-      return false;
-    }
-    if (nodeName === "audio") {
-      if (!element.hasAttribute("controls")) {
-        return false;
-      }
-      return tabIndexValue !== -1;
-    }
-    if (nodeName === "video") {
-      if (tabIndexValue === -1) {
-        return false;
-      }
-      if (tabIndexValue !== null) {
-        return true;
-      }
-      return isFirefox || element.hasAttribute("controls");
-    }
-    return element.tabIndex >= 0;
-  }
-  /**
-   * Gets whether an element can be focused by the user.
-   *
-   * @param element Element to be checked.
-   * @param config The config object with options to customize this method's behavior
-   * @returns Whether the element is focusable.
-   */
-  isFocusable(element, config) {
-    return isPotentiallyFocusable(element) && !element.inert && !this.isDisabled(element) && (config?.ignoreVisibility || this.isVisible(element));
-  }
-}
-const interactivityChecker = new InteractivityChecker();
+import { isFirefox, isIOS, isWebkit } from "../dom/platform.js";
+//#region src/elements/core/a11y/interactivity-checker.ts
+/**
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+/**
+* Configuration for the isFocusable method.
+*/
+var IsFocusableConfig = class {
+	constructor() {
+		/**
+		* Whether to count an element as focusable even if it is not currently visible.
+		*/
+		this.ignoreVisibility = false;
+	}
+};
+var InteractivityChecker = class {
+	/**
+	* Gets whether an element is disabled.
+	*
+	* @param element Element to be checked.
+	* @returns Whether the element is disabled.
+	*/
+	isDisabled(element) {
+		return element.hasAttribute("disabled") || element.matches(":disabled");
+	}
+	/**
+	* Gets whether an element is visible for the purposes of interactivity.
+	*
+	* This will capture states like `display: none` and `visibility: hidden`, but not things like
+	* being clipped by an `overflow: hidden` parent or being outside the viewport.
+	*
+	* @returns Whether the element is visible.
+	*/
+	isVisible(element) {
+		return hasGeometry(element) && getComputedStyle(element).visibility === "visible";
+	}
+	/**
+	* Gets whether an element can be reached via Tab key.
+	* Assumes that the element has already been checked with isFocusable.
+	*
+	* @param element Element to be checked.
+	* @returns Whether the element is tabbable.
+	*/
+	isTabbable(element) {
+		if (isServer) return false;
+		const nodeName = element.nodeName.toLowerCase();
+		const tabIndexValue = getTabIndexValue(element);
+		if (element.hasAttribute("contenteditable")) return tabIndexValue !== -1;
+		if (nodeName === "iframe" || nodeName === "object") return false;
+		if (isWebkit && isIOS && !isPotentiallyTabbableIOS(element)) return false;
+		if (nodeName === "audio") {
+			if (!element.hasAttribute("controls")) return false;
+			return tabIndexValue !== -1;
+		}
+		if (nodeName === "video") {
+			if (tabIndexValue === -1) return false;
+			if (tabIndexValue !== null) return true;
+			return isFirefox || element.hasAttribute("controls");
+		}
+		return element.tabIndex >= 0;
+	}
+	/**
+	* Gets whether an element can be focused by the user.
+	*
+	* @param element Element to be checked.
+	* @param config The config object with options to customize this method's behavior
+	* @returns Whether the element is focusable.
+	*/
+	isFocusable(element, config) {
+		return isPotentiallyFocusable(element) && !element.inert && !this.isDisabled(element) && (config?.ignoreVisibility || this.isVisible(element));
+	}
+};
+var interactivityChecker = new InteractivityChecker();
 function hasGeometry(element) {
-  return !!(element.offsetWidth || element.offsetHeight || typeof element.getClientRects === "function" && element.getClientRects().length);
+	return !!(element.offsetWidth || element.offsetHeight || typeof element.getClientRects === "function" && element.getClientRects().length);
 }
+/** Gets whether an element's  */
 function isNativeFormElement(element) {
-  const nodeName = element.nodeName.toLowerCase();
-  return nodeName === "input" || nodeName === "select" || nodeName === "button" || nodeName === "textarea";
+	const nodeName = element.nodeName.toLowerCase();
+	return nodeName === "input" || nodeName === "select" || nodeName === "button" || nodeName === "textarea";
 }
+/** Gets whether an element is an `<input type="hidden">`. */
 function isHiddenInput(element) {
-  return isInputElement(element) && element.type == "hidden";
+	return isInputElement(element) && element.type == "hidden";
 }
+/** Gets whether an element is an anchor that has a href attribute. */
 function isAnchorWithHref(element) {
-  return isAnchorElement(element) && element.hasAttribute("href");
+	return isAnchorElement(element) && element.hasAttribute("href");
 }
+/** Gets whether an element is an input element. */
 function isInputElement(element) {
-  return element.nodeName.toLowerCase() == "input";
+	return element.nodeName.toLowerCase() == "input";
 }
+/** Gets whether an element is an anchor element. */
 function isAnchorElement(element) {
-  return element.nodeName.toLowerCase() == "a";
+	return element.nodeName.toLowerCase() == "a";
 }
+/** Gets whether an element has a valid tabindex. */
 function hasValidTabIndex(element) {
-  if (!element.hasAttribute("tabindex") || element.tabIndex === void 0) {
-    return false;
-  }
-  const tabIndex = element.getAttribute("tabindex");
-  return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
+	if (!element.hasAttribute("tabindex") || element.tabIndex === void 0) return false;
+	const tabIndex = element.getAttribute("tabindex");
+	return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
 }
+/**
+* Returns the parsed tabindex from the element attributes instead of returning the
+* evaluated tabindex from the browsers defaults.
+*/
 function getTabIndexValue(element) {
-  if (!hasValidTabIndex(element)) {
-    return null;
-  }
-  const tabIndex = parseInt(element.getAttribute("tabindex") || "", 10);
-  return isNaN(tabIndex) ? -1 : tabIndex;
+	if (!hasValidTabIndex(element)) return null;
+	const tabIndex = parseInt(element.getAttribute("tabindex") || "", 10);
+	return isNaN(tabIndex) ? -1 : tabIndex;
 }
+/** Checks whether the specified element is potentially tabbable on iOS */
 function isPotentiallyTabbableIOS(element) {
-  const nodeName = element.nodeName.toLowerCase();
-  const inputType = nodeName === "input" && element.type;
-  return inputType === "text" || inputType === "password" || nodeName === "select" || nodeName === "textarea";
+	const nodeName = element.nodeName.toLowerCase();
+	const inputType = nodeName === "input" && element.type;
+	return inputType === "text" || inputType === "password" || nodeName === "select" || nodeName === "textarea";
 }
+/**
+* Gets whether an element is potentially focusable without taking current visible/disabled state
+* into account.
+*/
 function isPotentiallyFocusable(element) {
-  if (isHiddenInput(element)) {
-    return false;
-  }
-  return isNativeFormElement(element) || isAnchorWithHref(element) || element.hasAttribute("contenteditable") || hasValidTabIndex(element);
+	if (isHiddenInput(element)) return false;
+	return isNativeFormElement(element) || isAnchorWithHref(element) || element.hasAttribute("contenteditable") || hasValidTabIndex(element);
 }
-export {
-  InteractivityChecker,
-  IsFocusableConfig,
-  interactivityChecker
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"interactivity-checker.js","sources":["../../../../../src/elements/core/a11y/interactivity-checker.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// Copied from https://github.com/angular/components/blob/main/src/cdk/a11y/focus-trap/focus-trap.ts\n\n/* eslint-disable @typescript-eslint/no-use-before-define */\nimport { isServer } from 'lit';\n\nimport { isFirefox, isIOS, isWebkit } from '../dom/platform.ts';\n\n/**\n * Configuration for the isFocusable method.\n */\nexport class IsFocusableConfig {\n  /**\n   * Whether to count an element as focusable even if it is not currently visible.\n   */\n  public ignoreVisibility: boolean = false;\n}\n\nexport class InteractivityChecker {\n  /**\n   * Gets whether an element is disabled.\n   *\n   * @param element Element to be checked.\n   * @returns Whether the element is disabled.\n   */\n  public isDisabled(element: HTMLElement): boolean {\n    return element.hasAttribute('disabled') || element.matches(':disabled');\n  }\n\n  /**\n   * Gets whether an element is visible for the purposes of interactivity.\n   *\n   * This will capture states like `display: none` and `visibility: hidden`, but not things like\n   * being clipped by an `overflow: hidden` parent or being outside the viewport.\n   *\n   * @returns Whether the element is visible.\n   */\n  public isVisible(element: HTMLElement): boolean {\n    return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';\n  }\n\n  /**\n   * Gets whether an element can be reached via Tab key.\n   * Assumes that the element has already been checked with isFocusable.\n   *\n   * @param element Element to be checked.\n   * @returns Whether the element is tabbable.\n   */\n  public isTabbable(element: HTMLElement): boolean {\n    // Nothing is tabbable on the server 😎\n    if (isServer) {\n      return false;\n    }\n\n    const nodeName = element.nodeName.toLowerCase();\n    const tabIndexValue = getTabIndexValue(element);\n\n    if (element.hasAttribute('contenteditable')) {\n      return tabIndexValue !== -1;\n    }\n\n    if (nodeName === 'iframe' || nodeName === 'object') {\n      // The frame or object's content may be tabbable depending on the content, but it's\n      // not possibly to reliably detect the content of the frames. We always consider such\n      // elements as non-tabbable.\n      return false;\n    }\n\n    // In iOS, the browser only considers some specific elements as tabbable.\n    if (isWebkit && isIOS && !isPotentiallyTabbableIOS(element)) {\n      return false;\n    }\n\n    if (nodeName === 'audio') {\n      // Audio elements without controls enabled are never tabbable, regardless\n      // of the tabindex attribute explicitly being set.\n      if (!element.hasAttribute('controls')) {\n        return false;\n      }\n      // Audio elements with controls are by default tabbable unless the\n      // tabindex attribute is set to `-1` explicitly.\n      return tabIndexValue !== -1;\n    }\n\n    if (nodeName === 'video') {\n      // For all video elements, if the tabindex attribute is set to `-1`, the video\n      // is not tabbable. Note: We cannot rely on the default `HTMLElement.tabIndex`\n      // property as that one is set to `-1` in Chrome, Edge and Safari v13.1. The\n      // tabindex attribute is the source of truth here.\n      if (tabIndexValue === -1) {\n        return false;\n      }\n      // If the tabindex is explicitly set, and not `-1` (as per check before), the\n      // video element is always tabbable (regardless of whether it has controls or not).\n      if (tabIndexValue !== null) {\n        return true;\n      }\n      // Otherwise (when no explicit tabindex is set), a video is only tabbable if it\n      // has controls enabled. Firefox is special as videos are always tabbable regardless\n      // of whether there are controls or not.\n      return isFirefox || element.hasAttribute('controls');\n    }\n\n    return element.tabIndex >= 0;\n  }\n\n  /**\n   * Gets whether an element can be focused by the user.\n   *\n   * @param element Element to be checked.\n   * @param config The config object with options to customize this method's behavior\n   * @returns Whether the element is focusable.\n   */\n  public isFocusable(element: HTMLElement, config?: IsFocusableConfig): boolean {\n    // Perform checks in order of left to most expensive.\n    // Again, naive approach that does not capture many edge cases and browser quirks.\n    return (\n      isPotentiallyFocusable(element) &&\n      !element.inert &&\n      !this.isDisabled(element) &&\n      (config?.ignoreVisibility || this.isVisible(element))\n    );\n  }\n}\n\n// For unit tests we need to pretend that an element is always visible.\n// This can be done by checking if visibility property is set to empty.\nexport const interactivityChecker = new InteractivityChecker();\n\nfunction hasGeometry(element: HTMLElement): boolean {\n  // Use logic from jQuery to check for an invisible element.\n  // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12\n  return !!(\n    element.offsetWidth ||\n    element.offsetHeight ||\n    (typeof element.getClientRects === 'function' && element.getClientRects().length)\n  );\n}\n\n/** Gets whether an element's  */\nfunction isNativeFormElement(element: Node): boolean {\n  const nodeName = element.nodeName.toLowerCase();\n  return (\n    nodeName === 'input' ||\n    nodeName === 'select' ||\n    nodeName === 'button' ||\n    nodeName === 'textarea'\n  );\n}\n\n/** Gets whether an element is an `<input type=\"hidden\">`. */\nfunction isHiddenInput(element: HTMLElement): boolean {\n  return isInputElement(element) && element.type == 'hidden';\n}\n\n/** Gets whether an element is an anchor that has a href attribute. */\nfunction isAnchorWithHref(element: HTMLElement): boolean {\n  return isAnchorElement(element) && element.hasAttribute('href');\n}\n\n/** Gets whether an element is an input element. */\nfunction isInputElement(element: HTMLElement): element is HTMLInputElement {\n  return element.nodeName.toLowerCase() == 'input';\n}\n\n/** Gets whether an element is an anchor element. */\nfunction isAnchorElement(element: HTMLElement): element is HTMLAnchorElement {\n  return element.nodeName.toLowerCase() == 'a';\n}\n\n/** Gets whether an element has a valid tabindex. */\nfunction hasValidTabIndex(element: HTMLElement): boolean {\n  if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {\n    return false;\n  }\n\n  const tabIndex = element.getAttribute('tabindex');\n  return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));\n}\n\n/**\n * Returns the parsed tabindex from the element attributes instead of returning the\n * evaluated tabindex from the browsers defaults.\n */\nfunction getTabIndexValue(element: HTMLElement): number | null {\n  if (!hasValidTabIndex(element)) {\n    return null;\n  }\n\n  // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054\n  const tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);\n\n  return isNaN(tabIndex) ? -1 : tabIndex;\n}\n\n/** Checks whether the specified element is potentially tabbable on iOS */\nfunction isPotentiallyTabbableIOS(element: HTMLElement): boolean {\n  const nodeName = element.nodeName.toLowerCase();\n  const inputType = nodeName === 'input' && (element as HTMLInputElement).type;\n\n  return (\n    inputType === 'text' ||\n    inputType === 'password' ||\n    nodeName === 'select' ||\n    nodeName === 'textarea'\n  );\n}\n\n/**\n * Gets whether an element is potentially focusable without taking current visible/disabled state\n * into account.\n */\nfunction isPotentiallyFocusable(element: HTMLElement): boolean {\n  // Inputs are potentially focusable *unless* they're type=\"hidden\".\n  if (isHiddenInput(element)) {\n    return false;\n  }\n\n  return (\n    isNativeFormElement(element) ||\n    isAnchorWithHref(element) ||\n    element.hasAttribute('contenteditable') ||\n    hasValidTabIndex(element)\n  );\n}\n"],"names":[],"mappings":";;MAkBa,kBAAiB;AAAA,EAA9B,cAAA;AAIS,SAAA,mBAA4B;AAAA,EACrC;AAAC;MAEY,qBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOxB,WAAW,SAAoB;AACpC,WAAO,QAAQ,aAAa,UAAU,KAAK,QAAQ,QAAQ,WAAW;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUO,UAAU,SAAoB;AACnC,WAAO,YAAY,OAAO,KAAK,iBAAiB,OAAO,EAAE,eAAe;AAAA,EAC1E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,WAAW,SAAoB;AAEpC,QAAI,UAAU;AACZ,aAAO;AAAA,IACT;AAEA,UAAM,WAAW,QAAQ,SAAS,YAAA;AAClC,UAAM,gBAAgB,iBAAiB,OAAO;AAE9C,QAAI,QAAQ,aAAa,iBAAiB,GAAG;AAC3C,aAAO,kBAAkB;AAAA,IAC3B;AAEA,QAAI,aAAa,YAAY,aAAa,UAAU;AAIlD,aAAO;AAAA,IACT;AAGA,QAAI,YAAY,SAAS,CAAC,yBAAyB,OAAO,GAAG;AAC3D,aAAO;AAAA,IACT;AAEA,QAAI,aAAa,SAAS;AAGxB,UAAI,CAAC,QAAQ,aAAa,UAAU,GAAG;AACrC,eAAO;AAAA,MACT;AAGA,aAAO,kBAAkB;AAAA,IAC3B;AAEA,QAAI,aAAa,SAAS;AAKxB,UAAI,kBAAkB,IAAI;AACxB,eAAO;AAAA,MACT;AAGA,UAAI,kBAAkB,MAAM;AAC1B,eAAO;AAAA,MACT;AAIA,aAAO,aAAa,QAAQ,aAAa,UAAU;AAAA,IACrD;AAEA,WAAO,QAAQ,YAAY;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,YAAY,SAAsB,QAA0B;AAGjE,WACE,uBAAuB,OAAO,KAC9B,CAAC,QAAQ,SACT,CAAC,KAAK,WAAW,OAAO,MACvB,QAAQ,oBAAoB,KAAK,UAAU,OAAO;AAAA,EAEvD;AACD;AAIM,MAAM,uBAAuB,IAAI,qBAAA;AAExC,SAAS,YAAY,SAAoB;AAGvC,SAAO,CAAC,EACN,QAAQ,eACR,QAAQ,gBACP,OAAO,QAAQ,mBAAmB,cAAc,QAAQ,eAAA,EAAiB;AAE9E;AAGA,SAAS,oBAAoB,SAAa;AACxC,QAAM,WAAW,QAAQ,SAAS,YAAA;AAClC,SACE,aAAa,WACb,aAAa,YACb,aAAa,YACb,aAAa;AAEjB;AAGA,SAAS,cAAc,SAAoB;AACzC,SAAO,eAAe,OAAO,KAAK,QAAQ,QAAQ;AACpD;AAGA,SAAS,iBAAiB,SAAoB;AAC5C,SAAO,gBAAgB,OAAO,KAAK,QAAQ,aAAa,MAAM;AAChE;AAGA,SAAS,eAAe,SAAoB;AAC1C,SAAO,QAAQ,SAAS,YAAA,KAAiB;AAC3C;AAGA,SAAS,gBAAgB,SAAoB;AAC3C,SAAO,QAAQ,SAAS,YAAA,KAAiB;AAC3C;AAGA,SAAS,iBAAiB,SAAoB;AAC5C,MAAI,CAAC,QAAQ,aAAa,UAAU,KAAK,QAAQ,aAAa,QAAW;AACvE,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,QAAQ,aAAa,UAAU;AAChD,SAAO,CAAC,EAAE,YAAY,CAAC,MAAM,SAAS,UAAU,EAAE,CAAC;AACrD;AAMA,SAAS,iBAAiB,SAAoB;AAC5C,MAAI,CAAC,iBAAiB,OAAO,GAAG;AAC9B,WAAO;AAAA,EACT;AAGA,QAAM,WAAW,SAAS,QAAQ,aAAa,UAAU,KAAK,IAAI,EAAE;AAEpE,SAAO,MAAM,QAAQ,IAAI,KAAK;AAChC;AAGA,SAAS,yBAAyB,SAAoB;AACpD,QAAM,WAAW,QAAQ,SAAS,YAAA;AAClC,QAAM,YAAY,aAAa,WAAY,QAA6B;AAExE,SACE,cAAc,UACd,cAAc,cACd,aAAa,YACb,aAAa;AAEjB;AAMA,SAAS,uBAAuB,SAAoB;AAElD,MAAI,cAAc,OAAO,GAAG;AAC1B,WAAO;AAAA,EACT;AAEA,SACE,oBAAoB,OAAO,KAC3B,iBAAiB,OAAO,KACxB,QAAQ,aAAa,iBAAiB,KACtC,iBAAiB,OAAO;AAE5B;"}
+//#endregion
+export { InteractivityChecker, IsFocusableConfig, interactivityChecker };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"interactivity-checker.js","names":[],"sources":["../../../../../src/elements/core/a11y/interactivity-checker.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// Copied from https://github.com/angular/components/blob/main/src/cdk/a11y/focus-trap/focus-trap.ts\n\n/* eslint-disable @typescript-eslint/no-use-before-define */\nimport { isServer } from 'lit';\n\nimport { isFirefox, isIOS, isWebkit } from '../dom/platform.ts';\n\n/**\n * Configuration for the isFocusable method.\n */\nexport class IsFocusableConfig {\n  /**\n   * Whether to count an element as focusable even if it is not currently visible.\n   */\n  public ignoreVisibility: boolean = false;\n}\n\nexport class InteractivityChecker {\n  /**\n   * Gets whether an element is disabled.\n   *\n   * @param element Element to be checked.\n   * @returns Whether the element is disabled.\n   */\n  public isDisabled(element: HTMLElement): boolean {\n    return element.hasAttribute('disabled') || element.matches(':disabled');\n  }\n\n  /**\n   * Gets whether an element is visible for the purposes of interactivity.\n   *\n   * This will capture states like `display: none` and `visibility: hidden`, but not things like\n   * being clipped by an `overflow: hidden` parent or being outside the viewport.\n   *\n   * @returns Whether the element is visible.\n   */\n  public isVisible(element: HTMLElement): boolean {\n    return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';\n  }\n\n  /**\n   * Gets whether an element can be reached via Tab key.\n   * Assumes that the element has already been checked with isFocusable.\n   *\n   * @param element Element to be checked.\n   * @returns Whether the element is tabbable.\n   */\n  public isTabbable(element: HTMLElement): boolean {\n    // Nothing is tabbable on the server 😎\n    if (isServer) {\n      return false;\n    }\n\n    const nodeName = element.nodeName.toLowerCase();\n    const tabIndexValue = getTabIndexValue(element);\n\n    if (element.hasAttribute('contenteditable')) {\n      return tabIndexValue !== -1;\n    }\n\n    if (nodeName === 'iframe' || nodeName === 'object') {\n      // The frame or object's content may be tabbable depending on the content, but it's\n      // not possibly to reliably detect the content of the frames. We always consider such\n      // elements as non-tabbable.\n      return false;\n    }\n\n    // In iOS, the browser only considers some specific elements as tabbable.\n    if (isWebkit && isIOS && !isPotentiallyTabbableIOS(element)) {\n      return false;\n    }\n\n    if (nodeName === 'audio') {\n      // Audio elements without controls enabled are never tabbable, regardless\n      // of the tabindex attribute explicitly being set.\n      if (!element.hasAttribute('controls')) {\n        return false;\n      }\n      // Audio elements with controls are by default tabbable unless the\n      // tabindex attribute is set to `-1` explicitly.\n      return tabIndexValue !== -1;\n    }\n\n    if (nodeName === 'video') {\n      // For all video elements, if the tabindex attribute is set to `-1`, the video\n      // is not tabbable. Note: We cannot rely on the default `HTMLElement.tabIndex`\n      // property as that one is set to `-1` in Chrome, Edge and Safari v13.1. The\n      // tabindex attribute is the source of truth here.\n      if (tabIndexValue === -1) {\n        return false;\n      }\n      // If the tabindex is explicitly set, and not `-1` (as per check before), the\n      // video element is always tabbable (regardless of whether it has controls or not).\n      if (tabIndexValue !== null) {\n        return true;\n      }\n      // Otherwise (when no explicit tabindex is set), a video is only tabbable if it\n      // has controls enabled. Firefox is special as videos are always tabbable regardless\n      // of whether there are controls or not.\n      return isFirefox || element.hasAttribute('controls');\n    }\n\n    return element.tabIndex >= 0;\n  }\n\n  /**\n   * Gets whether an element can be focused by the user.\n   *\n   * @param element Element to be checked.\n   * @param config The config object with options to customize this method's behavior\n   * @returns Whether the element is focusable.\n   */\n  public isFocusable(element: HTMLElement, config?: IsFocusableConfig): boolean {\n    // Perform checks in order of left to most expensive.\n    // Again, naive approach that does not capture many edge cases and browser quirks.\n    return (\n      isPotentiallyFocusable(element) &&\n      !element.inert &&\n      !this.isDisabled(element) &&\n      (config?.ignoreVisibility || this.isVisible(element))\n    );\n  }\n}\n\n// For unit tests we need to pretend that an element is always visible.\n// This can be done by checking if visibility property is set to empty.\nexport const interactivityChecker = new InteractivityChecker();\n\nfunction hasGeometry(element: HTMLElement): boolean {\n  // Use logic from jQuery to check for an invisible element.\n  // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12\n  return !!(\n    element.offsetWidth ||\n    element.offsetHeight ||\n    (typeof element.getClientRects === 'function' && element.getClientRects().length)\n  );\n}\n\n/** Gets whether an element's  */\nfunction isNativeFormElement(element: Node): boolean {\n  const nodeName = element.nodeName.toLowerCase();\n  return (\n    nodeName === 'input' ||\n    nodeName === 'select' ||\n    nodeName === 'button' ||\n    nodeName === 'textarea'\n  );\n}\n\n/** Gets whether an element is an `<input type=\"hidden\">`. */\nfunction isHiddenInput(element: HTMLElement): boolean {\n  return isInputElement(element) && element.type == 'hidden';\n}\n\n/** Gets whether an element is an anchor that has a href attribute. */\nfunction isAnchorWithHref(element: HTMLElement): boolean {\n  return isAnchorElement(element) && element.hasAttribute('href');\n}\n\n/** Gets whether an element is an input element. */\nfunction isInputElement(element: HTMLElement): element is HTMLInputElement {\n  return element.nodeName.toLowerCase() == 'input';\n}\n\n/** Gets whether an element is an anchor element. */\nfunction isAnchorElement(element: HTMLElement): element is HTMLAnchorElement {\n  return element.nodeName.toLowerCase() == 'a';\n}\n\n/** Gets whether an element has a valid tabindex. */\nfunction hasValidTabIndex(element: HTMLElement): boolean {\n  if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {\n    return false;\n  }\n\n  const tabIndex = element.getAttribute('tabindex');\n  return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));\n}\n\n/**\n * Returns the parsed tabindex from the element attributes instead of returning the\n * evaluated tabindex from the browsers defaults.\n */\nfunction getTabIndexValue(element: HTMLElement): number | null {\n  if (!hasValidTabIndex(element)) {\n    return null;\n  }\n\n  // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054\n  const tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);\n\n  return isNaN(tabIndex) ? -1 : tabIndex;\n}\n\n/** Checks whether the specified element is potentially tabbable on iOS */\nfunction isPotentiallyTabbableIOS(element: HTMLElement): boolean {\n  const nodeName = element.nodeName.toLowerCase();\n  const inputType = nodeName === 'input' && (element as HTMLInputElement).type;\n\n  return (\n    inputType === 'text' ||\n    inputType === 'password' ||\n    nodeName === 'select' ||\n    nodeName === 'textarea'\n  );\n}\n\n/**\n * Gets whether an element is potentially focusable without taking current visible/disabled state\n * into account.\n */\nfunction isPotentiallyFocusable(element: HTMLElement): boolean {\n  // Inputs are potentially focusable *unless* they're type=\"hidden\".\n  if (isHiddenInput(element)) {\n    return false;\n  }\n\n  return (\n    isNativeFormElement(element) ||\n    isAnchorWithHref(element) ||\n    element.hasAttribute('contenteditable') ||\n    hasValidTabIndex(element)\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,IAAa,oBAAb,MAA8B;CAA9B,cAAA;;;;AAIS,OAAA,mBAA4B;;;AAGrC,IAAa,uBAAb,MAAiC;;;;;;;CAOxB,WAAW,SAAoB;AACpC,SAAO,QAAQ,aAAa,WAAW,IAAI,QAAQ,QAAQ,YAAY;;;;;;;;;;CAWlE,UAAU,SAAoB;AACnC,SAAO,YAAY,QAAQ,IAAI,iBAAiB,QAAQ,CAAC,eAAe;;;;;;;;;CAUnE,WAAW,SAAoB;AAEpC,MAAI,SACF,QAAO;EAGT,MAAM,WAAW,QAAQ,SAAS,aAAa;EAC/C,MAAM,gBAAgB,iBAAiB,QAAQ;AAE/C,MAAI,QAAQ,aAAa,kBAAkB,CACzC,QAAO,kBAAkB;AAG3B,MAAI,aAAa,YAAY,aAAa,SAIxC,QAAO;AAIT,MAAI,YAAY,SAAS,CAAC,yBAAyB,QAAQ,CACzD,QAAO;AAGT,MAAI,aAAa,SAAS;AAGxB,OAAI,CAAC,QAAQ,aAAa,WAAW,CACnC,QAAO;AAIT,UAAO,kBAAkB;;AAG3B,MAAI,aAAa,SAAS;AAKxB,OAAI,kBAAkB,GACpB,QAAO;AAIT,OAAI,kBAAkB,KACpB,QAAO;AAKT,UAAO,aAAa,QAAQ,aAAa,WAAW;;AAGtD,SAAO,QAAQ,YAAY;;;;;;;;;CAUtB,YAAY,SAAsB,QAA0B;AAGjE,SACE,uBAAuB,QAAQ,IAC/B,CAAC,QAAQ,SACT,CAAC,KAAK,WAAW,QAAQ,KACxB,QAAQ,oBAAoB,KAAK,UAAU,QAAQ;;;AAO1D,IAAa,uBAAuB,IAAI,sBAAsB;AAE9D,SAAS,YAAY,SAAoB;AAGvC,QAAO,CAAC,EACN,QAAQ,eACR,QAAQ,gBACP,OAAO,QAAQ,mBAAmB,cAAc,QAAQ,gBAAgB,CAAC;;;AAK9E,SAAS,oBAAoB,SAAa;CACxC,MAAM,WAAW,QAAQ,SAAS,aAAa;AAC/C,QACE,aAAa,WACb,aAAa,YACb,aAAa,YACb,aAAa;;;AAKjB,SAAS,cAAc,SAAoB;AACzC,QAAO,eAAe,QAAQ,IAAI,QAAQ,QAAQ;;;AAIpD,SAAS,iBAAiB,SAAoB;AAC5C,QAAO,gBAAgB,QAAQ,IAAI,QAAQ,aAAa,OAAO;;;AAIjE,SAAS,eAAe,SAAoB;AAC1C,QAAO,QAAQ,SAAS,aAAa,IAAI;;;AAI3C,SAAS,gBAAgB,SAAoB;AAC3C,QAAO,QAAQ,SAAS,aAAa,IAAI;;;AAI3C,SAAS,iBAAiB,SAAoB;AAC5C,KAAI,CAAC,QAAQ,aAAa,WAAW,IAAI,QAAQ,aAAa,KAAA,EAC5D,QAAO;CAGT,MAAM,WAAW,QAAQ,aAAa,WAAW;AACjD,QAAO,CAAC,EAAE,YAAY,CAAC,MAAM,SAAS,UAAU,GAAG,CAAC;;;;;;AAOtD,SAAS,iBAAiB,SAAoB;AAC5C,KAAI,CAAC,iBAAiB,QAAQ,CAC5B,QAAO;CAIT,MAAM,WAAW,SAAS,QAAQ,aAAa,WAAW,IAAI,IAAI,GAAG;AAErE,QAAO,MAAM,SAAS,GAAG,KAAK;;;AAIhC,SAAS,yBAAyB,SAAoB;CACpD,MAAM,WAAW,QAAQ,SAAS,aAAa;CAC/C,MAAM,YAAY,aAAa,WAAY,QAA6B;AAExE,QACE,cAAc,UACd,cAAc,cACd,aAAa,YACb,aAAa;;;;;;AAQjB,SAAS,uBAAuB,SAAoB;AAElD,KAAI,cAAc,QAAQ,CACxB,QAAO;AAGT,QACE,oBAAoB,QAAQ,IAC5B,iBAAiB,QAAQ,IACzB,QAAQ,aAAa,kBAAkB,IACvC,iBAAiB,QAAQ"}

package/development/core/a11y/live-announcer.js

@@ -1,82 +1,78 @@
 import { isServer } from "lit";
-let uniqueIds = 0;
-class SbbLiveAnnouncer {
-  constructor() {
-    if (!isServer) {
-      if (document.body) {
-        this._liveElement = this._createLiveElement();
-      } else {
-        document.addEventListener("DOMContentLoaded", () => {
-          this._liveElement = this._createLiveElement();
-        });
-      }
-    }
-  }
-  announce(message, ...args) {
-    if (!this._liveElement) {
-      return Promise.resolve();
-    }
-    const defaultOptions = {};
-    let politeness;
-    let duration;
-    if (args.length === 1 && typeof args[0] === "number") {
-      duration = args[0];
-    } else {
-      [politeness, duration] = args;
-    }
-    this.clear();
-    clearTimeout(this._previousTimeout);
-    politeness ??= defaultOptions?.politeness ?? "polite";
-    duration ??= defaultOptions?.duration;
-    this._liveElement.setAttribute("aria-live", politeness);
-    this._currentPromise ??= new Promise((resolve) => this._currentResolve = resolve);
-    clearTimeout(this._previousTimeout);
-    this._previousTimeout = setTimeout(() => {
-      this._liveElement.textContent = message;
-      if (typeof duration === "number") {
-        this._previousTimeout = setTimeout(() => this.clear(), duration);
-      }
-      this._currentResolve?.();
-      this._currentPromise = this._currentResolve = void 0;
-    }, 100);
-    return this._currentPromise;
-  }
-  /**
-   * Clears the current text from the announcer element. Can be used to prevent
-   * screen readers from reading the text out again while the user is going
-   * through the page landmarks.
-   */
-  clear() {
-    if (this._liveElement) {
-      this._liveElement.textContent = "";
-    }
-  }
-  destroy() {
-    clearTimeout(this._previousTimeout);
-    this._liveElement?.remove();
-    this._liveElement = null;
-    this._currentResolve?.();
-    this._currentPromise = this._currentResolve = void 0;
-  }
-  _createLiveElement() {
-    const elementClass = "sbb-live-announcer-element";
-    const previousElements = document.getElementsByClassName(elementClass);
-    const liveEl = document.createElement("div");
-    for (let i = 0; i < previousElements.length; i++) {
-      previousElements[i].remove();
-    }
-    liveEl.classList.add(elementClass);
-    liveEl.classList.add("sbb-screen-reader-only");
-    liveEl.setAttribute("aria-atomic", "true");
-    liveEl.setAttribute("aria-live", "polite");
-    liveEl.id = `sbb-live-announcer-${uniqueIds++}`;
-    document.body.appendChild(liveEl);
-    return liveEl;
-  }
-}
-const sbbLiveAnnouncer = new SbbLiveAnnouncer();
-export {
-  SbbLiveAnnouncer,
-  sbbLiveAnnouncer
+//#region src/elements/core/a11y/live-announcer.ts
+/**
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.dev/license
+*/
+var uniqueIds = 0;
+/**
+* Allows to announce messages to screen readers.
+*
+* Adapted from https://github.com/angular/components/blob/main/src/cdk/a11y/live-announcer/live-announcer.ts
+*/
+var SbbLiveAnnouncer = class {
+	constructor() {
+		if (!isServer) if (document.body) this._liveElement = this._createLiveElement();
+		else document.addEventListener("DOMContentLoaded", () => {
+			this._liveElement = this._createLiveElement();
+		});
+	}
+	announce(message, ...args) {
+		if (!this._liveElement) return Promise.resolve();
+		const defaultOptions = {};
+		let politeness;
+		let duration;
+		if (args.length === 1 && typeof args[0] === "number") duration = args[0];
+		else [politeness, duration] = args;
+		this.clear();
+		clearTimeout(this._previousTimeout);
+		politeness ??= defaultOptions?.politeness ?? "polite";
+		duration ??= defaultOptions?.duration;
+		this._liveElement.setAttribute("aria-live", politeness);
+		this._currentPromise ??= new Promise((resolve) => this._currentResolve = resolve);
+		clearTimeout(this._previousTimeout);
+		this._previousTimeout = setTimeout(() => {
+			this._liveElement.textContent = message;
+			if (typeof duration === "number") this._previousTimeout = setTimeout(() => this.clear(), duration);
+			this._currentResolve?.();
+			this._currentPromise = this._currentResolve = void 0;
+		}, 100);
+		return this._currentPromise;
+	}
+	/**
+	* Clears the current text from the announcer element. Can be used to prevent
+	* screen readers from reading the text out again while the user is going
+	* through the page landmarks.
+	*/
+	clear() {
+		if (this._liveElement) this._liveElement.textContent = "";
+	}
+	destroy() {
+		clearTimeout(this._previousTimeout);
+		this._liveElement?.remove();
+		this._liveElement = null;
+		this._currentResolve?.();
+		this._currentPromise = this._currentResolve = void 0;
+	}
+	_createLiveElement() {
+		const elementClass = "sbb-live-announcer-element";
+		const previousElements = document.getElementsByClassName(elementClass);
+		const liveEl = document.createElement("div");
+		for (let i = 0; i < previousElements.length; i++) previousElements[i].remove();
+		liveEl.classList.add(elementClass);
+		liveEl.classList.add("sbb-screen-reader-only");
+		liveEl.setAttribute("aria-atomic", "true");
+		liveEl.setAttribute("aria-live", "polite");
+		liveEl.id = `sbb-live-announcer-${uniqueIds++}`;
+		document.body.appendChild(liveEl);
+		return liveEl;
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"live-announcer.js","sources":["../../../../../src/elements/core/a11y/live-announcer.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport { isServer } from 'lit';\n\nexport type AriaLivePoliteness = 'off' | 'polite' | 'assertive';\n\nlet uniqueIds = 0;\n\n/**\n * Allows to announce messages to screen readers.\n *\n * Adapted from https://github.com/angular/components/blob/main/src/cdk/a11y/live-announcer/live-announcer.ts\n */\nexport class SbbLiveAnnouncer {\n  private _liveElement!: HTMLElement;\n  private _previousTimeout: ReturnType<typeof setTimeout> | undefined;\n  private _currentPromise: Promise<void> | undefined;\n  private _currentResolve: (() => void) | undefined;\n\n  public constructor() {\n    if (!isServer) {\n      if (document.body) {\n        this._liveElement = this._createLiveElement();\n      } else {\n        document.addEventListener('DOMContentLoaded', () => {\n          this._liveElement = this._createLiveElement();\n        });\n      }\n    }\n  }\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, politeness?: AriaLivePoliteness): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, duration?: number): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(\n    message: string,\n    politeness?: AriaLivePoliteness,\n    duration?: number,\n  ): Promise<void>;\n\n  public announce(message: string, ...args: any[]): Promise<void> {\n    // On the server or when the DOM is not ready yet, we don't do anything.\n    if (!this._liveElement) {\n      return Promise.resolve();\n    }\n\n    // TODO: Decide whether to have global options.\n    const defaultOptions = {} as { politeness?: AriaLivePoliteness; duration?: number };\n    let politeness: AriaLivePoliteness | undefined;\n    let duration: number | undefined;\n\n    if (args.length === 1 && typeof args[0] === 'number') {\n      duration = args[0];\n    } else {\n      [politeness, duration] = args;\n    }\n\n    this.clear();\n    clearTimeout(this._previousTimeout);\n\n    politeness ??= defaultOptions?.politeness ?? 'polite';\n    duration ??= defaultOptions?.duration;\n\n    this._liveElement.setAttribute('aria-live', politeness);\n\n    // This 100ms timeout is necessary for some browser + screen-reader combinations:\n    // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.\n    // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a\n    //   second time without clearing and then using a non-zero delay.\n    // (using JAWS 17 at time of this writing).\n    this._currentPromise ??= new Promise((resolve) => (this._currentResolve = resolve));\n\n    clearTimeout(this._previousTimeout);\n    this._previousTimeout = setTimeout(() => {\n      this._liveElement.textContent = message;\n\n      if (typeof duration === 'number') {\n        this._previousTimeout = setTimeout(() => this.clear(), duration);\n      }\n\n      this._currentResolve?.();\n      this._currentPromise = this._currentResolve = undefined;\n    }, 100);\n\n    return this._currentPromise;\n  }\n\n  /**\n   * Clears the current text from the announcer element. Can be used to prevent\n   * screen readers from reading the text out again while the user is going\n   * through the page landmarks.\n   */\n  public clear(): void {\n    if (this._liveElement) {\n      this._liveElement.textContent = '';\n    }\n  }\n\n  public destroy(): void {\n    clearTimeout(this._previousTimeout);\n    this._liveElement?.remove();\n    this._liveElement = null!;\n    this._currentResolve?.();\n    this._currentPromise = this._currentResolve = undefined;\n  }\n\n  private _createLiveElement(): HTMLElement {\n    const elementClass = 'sbb-live-announcer-element';\n    const previousElements = document.getElementsByClassName(elementClass);\n    const liveEl = document.createElement('div');\n\n    // Remove any old containers. This can happen when coming in from a server-side-rendered page.\n    for (let i = 0; i < previousElements.length; i++) {\n      previousElements[i].remove();\n    }\n\n    liveEl.classList.add(elementClass);\n    liveEl.classList.add('sbb-screen-reader-only');\n\n    liveEl.setAttribute('aria-atomic', 'true');\n    liveEl.setAttribute('aria-live', 'polite');\n    liveEl.id = `sbb-live-announcer-${uniqueIds++}`;\n\n    document.body.appendChild(liveEl);\n\n    return liveEl;\n  }\n}\n\nexport const sbbLiveAnnouncer = new SbbLiveAnnouncer();\n"],"names":[],"mappings":";AAYA,IAAI,YAAY;MAOH,iBAAgB;AAAA,EAM3B,cAAA;AACE,QAAI,CAAC,UAAU;AACb,UAAI,SAAS,MAAM;AACjB,aAAK,eAAe,KAAK,mBAAA;AAAA,MAC3B,OAAO;AACL,iBAAS,iBAAiB,oBAAoB,MAAK;AACjD,eAAK,eAAe,KAAK,mBAAA;AAAA,QAC3B,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAAA,EA0CO,SAAS,YAAoB,MAAW;AAE7C,QAAI,CAAC,KAAK,cAAc;AACtB,aAAO,QAAQ,QAAA;AAAA,IACjB;AAGA,UAAM,iBAAiB,CAAA;AACvB,QAAI;AACJ,QAAI;AAEJ,QAAI,KAAK,WAAW,KAAK,OAAO,KAAK,CAAC,MAAM,UAAU;AACpD,iBAAW,KAAK,CAAC;AAAA,IACnB,OAAO;AACL,OAAC,YAAY,QAAQ,IAAI;AAAA,IAC3B;AAEA,SAAK,MAAA;AACL,iBAAa,KAAK,gBAAgB;AAElC,mBAAe,gBAAgB,cAAc;AAC7C,iBAAa,gBAAgB;AAE7B,SAAK,aAAa,aAAa,aAAa,UAAU;AAOtD,SAAK,oBAAoB,IAAI,QAAQ,CAAC,YAAa,KAAK,kBAAkB,OAAQ;AAElF,iBAAa,KAAK,gBAAgB;AAClC,SAAK,mBAAmB,WAAW,MAAK;AACtC,WAAK,aAAa,cAAc;AAEhC,UAAI,OAAO,aAAa,UAAU;AAChC,aAAK,mBAAmB,WAAW,MAAM,KAAK,MAAA,GAAS,QAAQ;AAAA,MACjE;AAEA,WAAK,kBAAA;AACL,WAAK,kBAAkB,KAAK,kBAAkB;AAAA,IAChD,GAAG,GAAG;AAEN,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,QAAK;AACV,QAAI,KAAK,cAAc;AACrB,WAAK,aAAa,cAAc;AAAA,IAClC;AAAA,EACF;AAAA,EAEO,UAAO;AACZ,iBAAa,KAAK,gBAAgB;AAClC,SAAK,cAAc,OAAA;AACnB,SAAK,eAAe;AACpB,SAAK,kBAAA;AACL,SAAK,kBAAkB,KAAK,kBAAkB;AAAA,EAChD;AAAA,EAEQ,qBAAkB;AACxB,UAAM,eAAe;AACrB,UAAM,mBAAmB,SAAS,uBAAuB,YAAY;AACrE,UAAM,SAAS,SAAS,cAAc,KAAK;AAG3C,aAAS,IAAI,GAAG,IAAI,iBAAiB,QAAQ,KAAK;AAChD,uBAAiB,CAAC,EAAE,OAAA;AAAA,IACtB;AAEA,WAAO,UAAU,IAAI,YAAY;AACjC,WAAO,UAAU,IAAI,wBAAwB;AAE7C,WAAO,aAAa,eAAe,MAAM;AACzC,WAAO,aAAa,aAAa,QAAQ;AACzC,WAAO,KAAK,sBAAsB,WAAW;AAE7C,aAAS,KAAK,YAAY,MAAM;AAEhC,WAAO;AAAA,EACT;AACD;AAEM,MAAM,mBAAmB,IAAI,iBAAA;"}
+var sbbLiveAnnouncer = new SbbLiveAnnouncer();
+//#endregion
+export { SbbLiveAnnouncer, sbbLiveAnnouncer };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"live-announcer.js","names":[],"sources":["../../../../../src/elements/core/a11y/live-announcer.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport { isServer } from 'lit';\n\nexport type AriaLivePoliteness = 'off' | 'polite' | 'assertive';\n\nlet uniqueIds = 0;\n\n/**\n * Allows to announce messages to screen readers.\n *\n * Adapted from https://github.com/angular/components/blob/main/src/cdk/a11y/live-announcer/live-announcer.ts\n */\nexport class SbbLiveAnnouncer {\n  private _liveElement!: HTMLElement;\n  private _previousTimeout: ReturnType<typeof setTimeout> | undefined;\n  private _currentPromise: Promise<void> | undefined;\n  private _currentResolve: (() => void) | undefined;\n\n  public constructor() {\n    if (!isServer) {\n      if (document.body) {\n        this._liveElement = this._createLiveElement();\n      } else {\n        document.addEventListener('DOMContentLoaded', () => {\n          this._liveElement = this._createLiveElement();\n        });\n      }\n    }\n  }\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, politeness?: AriaLivePoliteness): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(message: string, duration?: number): Promise<void>;\n\n  /**\n   * Announces a message to screen readers.\n   * @param message Message to be announced to the screen reader.\n   * @param politeness The politeness of the announcer element.\n   * @param duration Time in milliseconds after which to clear out the announcer element. Note\n   *   that this takes effect after the message has been added to the DOM, which can be up to\n   *   100ms after `announce` has been called.\n   * @returns Promise that will be resolved when the message is added to the DOM.\n   */\n  public announce(\n    message: string,\n    politeness?: AriaLivePoliteness,\n    duration?: number,\n  ): Promise<void>;\n\n  public announce(message: string, ...args: any[]): Promise<void> {\n    // On the server or when the DOM is not ready yet, we don't do anything.\n    if (!this._liveElement) {\n      return Promise.resolve();\n    }\n\n    // TODO: Decide whether to have global options.\n    const defaultOptions = {} as { politeness?: AriaLivePoliteness; duration?: number };\n    let politeness: AriaLivePoliteness | undefined;\n    let duration: number | undefined;\n\n    if (args.length === 1 && typeof args[0] === 'number') {\n      duration = args[0];\n    } else {\n      [politeness, duration] = args;\n    }\n\n    this.clear();\n    clearTimeout(this._previousTimeout);\n\n    politeness ??= defaultOptions?.politeness ?? 'polite';\n    duration ??= defaultOptions?.duration;\n\n    this._liveElement.setAttribute('aria-live', politeness);\n\n    // This 100ms timeout is necessary for some browser + screen-reader combinations:\n    // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.\n    // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a\n    //   second time without clearing and then using a non-zero delay.\n    // (using JAWS 17 at time of this writing).\n    this._currentPromise ??= new Promise((resolve) => (this._currentResolve = resolve));\n\n    clearTimeout(this._previousTimeout);\n    this._previousTimeout = setTimeout(() => {\n      this._liveElement.textContent = message;\n\n      if (typeof duration === 'number') {\n        this._previousTimeout = setTimeout(() => this.clear(), duration);\n      }\n\n      this._currentResolve?.();\n      this._currentPromise = this._currentResolve = undefined;\n    }, 100);\n\n    return this._currentPromise;\n  }\n\n  /**\n   * Clears the current text from the announcer element. Can be used to prevent\n   * screen readers from reading the text out again while the user is going\n   * through the page landmarks.\n   */\n  public clear(): void {\n    if (this._liveElement) {\n      this._liveElement.textContent = '';\n    }\n  }\n\n  public destroy(): void {\n    clearTimeout(this._previousTimeout);\n    this._liveElement?.remove();\n    this._liveElement = null!;\n    this._currentResolve?.();\n    this._currentPromise = this._currentResolve = undefined;\n  }\n\n  private _createLiveElement(): HTMLElement {\n    const elementClass = 'sbb-live-announcer-element';\n    const previousElements = document.getElementsByClassName(elementClass);\n    const liveEl = document.createElement('div');\n\n    // Remove any old containers. This can happen when coming in from a server-side-rendered page.\n    for (let i = 0; i < previousElements.length; i++) {\n      previousElements[i].remove();\n    }\n\n    liveEl.classList.add(elementClass);\n    liveEl.classList.add('sbb-screen-reader-only');\n\n    liveEl.setAttribute('aria-atomic', 'true');\n    liveEl.setAttribute('aria-live', 'polite');\n    liveEl.id = `sbb-live-announcer-${uniqueIds++}`;\n\n    document.body.appendChild(liveEl);\n\n    return liveEl;\n  }\n}\n\nexport const sbbLiveAnnouncer = new SbbLiveAnnouncer();\n"],"mappings":";;;;;;;;;AAYA,IAAI,YAAY;;;;;;AAOhB,IAAa,mBAAb,MAA6B;CAM3B,cAAA;AACE,MAAI,CAAC,SACH,KAAI,SAAS,KACX,MAAK,eAAe,KAAK,oBAAoB;MAE7C,UAAS,iBAAiB,0BAAyB;AACjD,QAAK,eAAe,KAAK,oBAAoB;IAC7C;;CA6CD,SAAS,SAAiB,GAAG,MAAW;AAE7C,MAAI,CAAC,KAAK,aACR,QAAO,QAAQ,SAAS;EAI1B,MAAM,iBAAiB,EAA4D;EACnF,IAAI;EACJ,IAAI;AAEJ,MAAI,KAAK,WAAW,KAAK,OAAO,KAAK,OAAO,SAC1C,YAAW,KAAK;MAEhB,EAAC,YAAY,YAAY;AAG3B,OAAK,OAAO;AACZ,eAAa,KAAK,iBAAiB;AAEnC,iBAAe,gBAAgB,cAAc;AAC7C,eAAa,gBAAgB;AAE7B,OAAK,aAAa,aAAa,aAAa,WAAW;AAOvD,OAAK,oBAAoB,IAAI,SAAS,YAAa,KAAK,kBAAkB,QAAS;AAEnF,eAAa,KAAK,iBAAiB;AACnC,OAAK,mBAAmB,iBAAgB;AACtC,QAAK,aAAa,cAAc;AAEhC,OAAI,OAAO,aAAa,SACtB,MAAK,mBAAmB,iBAAiB,KAAK,OAAO,EAAE,SAAS;AAGlE,QAAK,mBAAmB;AACxB,QAAK,kBAAkB,KAAK,kBAAkB,KAAA;KAC7C,IAAI;AAEP,SAAO,KAAK;;;;;;;CAQP,QAAK;AACV,MAAI,KAAK,aACP,MAAK,aAAa,cAAc;;CAI7B,UAAO;AACZ,eAAa,KAAK,iBAAiB;AACnC,OAAK,cAAc,QAAQ;AAC3B,OAAK,eAAe;AACpB,OAAK,mBAAmB;AACxB,OAAK,kBAAkB,KAAK,kBAAkB,KAAA;;CAGxC,qBAAkB;EACxB,MAAM,eAAe;EACrB,MAAM,mBAAmB,SAAS,uBAAuB,aAAa;EACtE,MAAM,SAAS,SAAS,cAAc,MAAM;AAG5C,OAAK,IAAI,IAAI,GAAG,IAAI,iBAAiB,QAAQ,IAC3C,kBAAiB,GAAG,QAAQ;AAG9B,SAAO,UAAU,IAAI,aAAa;AAClC,SAAO,UAAU,IAAI,yBAAyB;AAE9C,SAAO,aAAa,eAAe,OAAO;AAC1C,SAAO,aAAa,aAAa,SAAS;AAC1C,SAAO,KAAK,sBAAsB;AAElC,WAAS,KAAK,YAAY,OAAO;AAEjC,SAAO;;;AAIX,IAAa,mBAAmB,IAAI,kBAAkB"}

package/development/core/a11y.d.ts

@@ -1,6 +1,4 @@
-/**
- * @entrypoint
- */
+/** @entrypoint */
 export * from './a11y/arrow-navigation.ts';
 export * from './a11y/fake-event-detection.ts';
 export * from './a11y/focus-visible-within-controller.ts';

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

@@ -1 +1 @@
-{"version":3,"file":"a11y.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/a11y.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"a11y.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/a11y.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC"}

package/development/core/a11y.js

@@ -1,27 +1,9 @@
 import { getNextElementIndex, isArrowKeyOrPageKeysPressed, isArrowKeyPressed, isNextArrowKeyPressed, isPreviousArrowKeyPressed } from "./a11y/arrow-navigation.js";
 import { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from "./a11y/fake-event-detection.js";
+import { sbbInputModalityDetector } from "./a11y/input-modality-detector.js";
 import { SbbFocusVisibleWithinController } from "./a11y/focus-visible-within-controller.js";
 import { IS_FOCUSABLE_QUERY } from "./a11y/focus.js";
-import { SbbFocusTrapController } from "./a11y/focus-trap-controller.js";
 import { InteractivityChecker, IsFocusableConfig, interactivityChecker } from "./a11y/interactivity-checker.js";
-import { sbbInputModalityDetector } from "./a11y/input-modality-detector.js";
+import { SbbFocusTrapController } from "./a11y/focus-trap-controller.js";
 import { SbbLiveAnnouncer, sbbLiveAnnouncer } from "./a11y/live-announcer.js";
-export {
-  IS_FOCUSABLE_QUERY,
-  InteractivityChecker,
-  IsFocusableConfig,
-  SbbFocusTrapController,
-  SbbFocusVisibleWithinController,
-  SbbLiveAnnouncer,
-  getNextElementIndex,
-  interactivityChecker,
-  isArrowKeyOrPageKeysPressed,
-  isArrowKeyPressed,
-  isFakeMousedownFromScreenReader,
-  isFakeTouchstartFromScreenReader,
-  isNextArrowKeyPressed,
-  isPreviousArrowKeyPressed,
-  sbbInputModalityDetector,
-  sbbLiveAnnouncer
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYTExeS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OyJ9
+export { IS_FOCUSABLE_QUERY, InteractivityChecker, IsFocusableConfig, SbbFocusTrapController, SbbFocusVisibleWithinController, SbbLiveAnnouncer, getNextElementIndex, interactivityChecker, isArrowKeyOrPageKeysPressed, isArrowKeyPressed, isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader, isNextArrowKeyPressed, isPreviousArrowKeyPressed, sbbInputModalityDetector, sbbLiveAnnouncer };

package/development/core/base-elements/action-base-element.d.ts

@@ -1,6 +1,6 @@
-import { LitElement, TemplateResult } from 'lit';
-declare const SbbActionBaseElement_base: import('../mixins.ts').AbstractConstructor<import('../mixins.ts').SbbElementInternalsMixinType> & typeof LitElement & import('../mixins.ts').SbbElementInternalsConstructor;
-export declare abstract class SbbActionBaseElement extends SbbActionBaseElement_base {
+import { TemplateResult } from 'lit';
+import { SbbElement } from './element.ts';
+export declare abstract class SbbActionBaseElement extends SbbElement {
     protected get maybeDisabled(): boolean | undefined;
     protected get maybeDisabledInteractive(): boolean | undefined;
     constructor();
@@ -11,5 +11,4 @@ export declare abstract class SbbActionBaseElement extends SbbActionBaseElement_
     /** Default render method for button-like components. */
     protected render(): TemplateResult;
 }
-export {};
 //# sourceMappingURL=action-base-element.d.ts.map

package/development/core/base-elements/action-base-element.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/action-base-element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;;AAe5D,8BAAsB,oBAAqB,SAAQ,yBAAoC;IACrF,SAAS,KAAK,aAAa,IAAI,OAAO,GAAG,SAAS,CAGjD;IAED,SAAS,KAAK,wBAAwB,IAAI,OAAO,GAAG,SAAS,CAE5D;;IAOe,iBAAiB,IAAI,IAAI;IAezC,SAAS,CAAC,sBAAsB,IAAI,IAAI;IAexC,6DAA6D;IAC7D,SAAS,CAAC,cAAc,IAAI,cAAc;IAI1C,wDAAwD;cACrC,MAAM,IAAI,cAAc;CAG5C"}
+{"version":3,"file":"action-base-element.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/base-elements/action-base-element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAEhD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAa1C,8BAAsB,oBAAqB,SAAQ,UAAU;IAC3D,SAAS,KAAK,aAAa,IAAI,OAAO,GAAG,SAAS,CAGjD;IAED,SAAS,KAAK,wBAAwB,IAAI,OAAO,GAAG,SAAS,CAE5D;;IAOe,iBAAiB,IAAI,IAAI;IAezC,SAAS,CAAC,sBAAsB,IAAI,IAAI;IAexC,6DAA6D;IAC7D,SAAS,CAAC,cAAc,IAAI,cAAc;IAI1C,wDAAwD;cACrC,MAAM,IAAI,cAAc;CAG5C"}