@sbb-esta/lyne-elements 4.7.0 → 4.8.0

package/development/container.component-Co2L3KBb.js

@@ -0,0 +1,238 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, html } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement } from "./core/base-elements.js";
+import { forceType } from "./core/decorators.js";
+import { ɵstateController } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+//#region src/elements/container/container/container.scss?lit&inline
+var container_default = css`@charset "UTF-8";
+:host {
+  display: block;
+}
+
+:host(:is(:not([color]), [color=white])) {
+  --sbb-container-background-color: var(--sbb-background-color-1);
+}
+
+:host([color=milk]) {
+  --sbb-container-background-color: var(--sbb-background-color-3);
+}
+
+:host([color=midnight]),
+:host([color=charcoal]) {
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+  --sbb-container-color: var(--sbb-color-1-negative);
+}
+
+:host([color=midnight]) {
+  --sbb-container-background-color: var(--sbb-background-color-1-negative);
+}
+
+:host([color=charcoal]) {
+  --sbb-container-background-color: var(--sbb-background-color-2-negative);
+}
+
+:host(:is(:state(slotted-image),[state--slotted-image])) {
+  --sbb-container-background-color: transparent;
+  --sbb-container-padding: var(--sbb-spacing-responsive-xxl);
+}
+
+:host([background-expanded]:not([expanded])) {
+  background-color: var(--sbb-container-background-color);
+}
+
+:host(:is(:state(slotted-image),[state--slotted-image])[background-expanded]) {
+  position: relative;
+}
+
+@media (min-width: calc(90rem)) {
+  :host(:not([expanded], [background-expanded])) {
+    --sbb-container-background-border-radius: var(--sbb-border-radius-4x);
+  }
+}
+
+.sbb-container {
+  color: var(--sbb-container-color);
+  background-color: var(--sbb-container-background-color);
+  padding: var(--sbb-container-padding);
+}
+.sbb-container::after, .sbb-container::before {
+  content: " ";
+  display: block;
+  visibility: hidden;
+  height: 0;
+  overflow: hidden;
+}
+:host([color=transparent]) .sbb-container {
+  background-color: transparent;
+}
+:host(:not([expanded])) .sbb-container {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));
+  margin-inline: auto;
+  width: 100%;
+}
+@media (min-width: calc(90rem)) {
+  :host(:not([expanded])) .sbb-container {
+    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));
+  }
+}
+:host([expanded]) .sbb-container {
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-spacing-responsive-xxs));
+}
+:host(:is(:state(slotted-image),[state--slotted-image]):not([background-expanded])) .sbb-container {
+  position: relative;
+}
+
+:host(:is(:state(slotted-image),[state--slotted-image])) .sbb-container__content {
+  position: relative;
+}
+
+::slotted([slot=image]) {
+  position: absolute;
+  inset: 0;
+  height: 100%;
+  width: 100%;
+}`;
+//#endregion
+//#region src/elements/container/container/container.component.ts
+/**
+* It displays its content with the default page spacing.
+*
+* @slot - Use the unnamed slot to add anything to the container.
+* @slot sticky-bar - The slot used by the sbb-sticky-bar component.
+* @slot image - The slot used to slot an `sbb-image` to use as background.
+* @cssprop --sbb-page-spacing-padding - Use this variable to override the default page spacing.
+* Note that overriding this will disable the standard responsive spacing behavior of the container.
+*/
+var SbbContainerElement = (() => {
+	let _classSuper = SbbElement;
+	let _expanded_decorators;
+	let _expanded_initializers = [];
+	let _expanded_extraInitializers = [];
+	let _backgroundExpanded_decorators;
+	let _backgroundExpanded_initializers = [];
+	let _backgroundExpanded_extraInitializers = [];
+	let _color_decorators;
+	let _color_initializers = [];
+	let _color_extraInitializers = [];
+	return class SbbContainerElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_expanded_decorators = [forceType(), property({
+				type: Boolean,
+				reflect: true
+			})];
+			_backgroundExpanded_decorators = [forceType(), property({
+				type: Boolean,
+				reflect: true,
+				attribute: "background-expanded"
+			})];
+			_color_decorators = [property({ reflect: true })];
+			__esDecorate(this, null, _expanded_decorators, {
+				kind: "accessor",
+				name: "expanded",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "expanded" in obj,
+					get: (obj) => obj.expanded,
+					set: (obj, value) => {
+						obj.expanded = value;
+					}
+				},
+				metadata: _metadata
+			}, _expanded_initializers, _expanded_extraInitializers);
+			__esDecorate(this, null, _backgroundExpanded_decorators, {
+				kind: "accessor",
+				name: "backgroundExpanded",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "backgroundExpanded" in obj,
+					get: (obj) => obj.backgroundExpanded,
+					set: (obj, value) => {
+						obj.backgroundExpanded = value;
+					}
+				},
+				metadata: _metadata
+			}, _backgroundExpanded_initializers, _backgroundExpanded_extraInitializers);
+			__esDecorate(this, null, _color_decorators, {
+				kind: "accessor",
+				name: "color",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "color" in obj,
+					get: (obj) => obj.color,
+					set: (obj, value) => {
+						obj.color = value;
+					}
+				},
+				metadata: _metadata
+			}, _color_initializers, _color_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-container";
+		}
+		static {
+			this.styles = [boxSizingStyles, container_default];
+		}
+		#expanded_accessor_storage = __runInitializers(this, _expanded_initializers, false);
+		/** Whether the container is expanded. */
+		get expanded() {
+			return this.#expanded_accessor_storage;
+		}
+		set expanded(value) {
+			this.#expanded_accessor_storage = value;
+		}
+		#backgroundExpanded_accessor_storage = (__runInitializers(this, _expanded_extraInitializers), __runInitializers(this, _backgroundExpanded_initializers, false));
+		/** Whether the background color is shown on full container width on large screens. */
+		get backgroundExpanded() {
+			return this.#backgroundExpanded_accessor_storage;
+		}
+		set backgroundExpanded(value) {
+			this.#backgroundExpanded_accessor_storage = value;
+		}
+		#color_accessor_storage = (__runInitializers(this, _backgroundExpanded_extraInitializers), __runInitializers(this, _color_initializers, "white"));
+		/** Color of the container, like transparent, white etc. */
+		get color() {
+			return this.#color_accessor_storage;
+		}
+		set color(value) {
+			this.#color_accessor_storage = value;
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("expanded")) {
+				const stickyBar = this.querySelector?.("sbb-sticky-bar");
+				ɵstateController(stickyBar)?.toggle("expanded", this.expanded);
+			}
+		}
+		render() {
+			return html`
+      <div class="sbb-container">
+        <slot name="image"></slot>
+        <div class="sbb-container__content">
+          <slot></slot>
+        </div>
+      </div>
+      <slot name="sticky-bar"></slot>
+    `;
+		}
+		constructor() {
+			super(...arguments);
+			__runInitializers(this, _color_extraInitializers);
+		}
+	};
+})();
+//#endregion
+export { SbbContainerElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"container.component-Co2L3KBb.js","names":[],"sources":["../../../src/elements/container/container/container.scss?lit&inline","../../../src/elements/container/container/container.component.ts"],"sourcesContent":["@use '../../core/styles' as sbb;\n\n:host {\n  display: block;\n}\n\n:host(:is(:not([color]), [color='white'])) {\n  --sbb-container-background-color: var(--sbb-background-color-1);\n}\n\n:host([color='milk']) {\n  --sbb-container-background-color: var(--sbb-background-color-3);\n}\n\n:host([color='midnight']),\n:host([color='charcoal']) {\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\n  --sbb-container-color: var(--sbb-color-1-negative);\n}\n\n:host([color='midnight']) {\n  --sbb-container-background-color: var(--sbb-background-color-1-negative);\n}\n\n:host([color='charcoal']) {\n  --sbb-container-background-color: var(--sbb-background-color-2-negative);\n}\n\n:host(:state(slotted-image)) {\n  --sbb-container-background-color: transparent;\n  --sbb-container-padding: var(--sbb-spacing-responsive-xxl);\n}\n\n:host([background-expanded]:not([expanded])) {\n  background-color: var(--sbb-container-background-color);\n}\n\n:host(:state(slotted-image)[background-expanded]) {\n  position: relative;\n}\n\n:host(:not([expanded], [background-expanded])) {\n  @include sbb.mq($from: ultra) {\n    --sbb-container-background-border-radius: var(--sbb-border-radius-4x);\n  }\n}\n\n.sbb-container {\n  color: var(--sbb-container-color);\n  background-color: var(--sbb-container-background-color);\n  padding: var(--sbb-container-padding);\n\n  @include sbb.ignore-children-margin;\n\n  // In order to support nested sbb-containers (e.g. if used in an overlay), we need to explicitly set background color to transparent.\n  // We cannot use the --sbb-container-background-color variable because using it would\n  // destroy sbb-sticky-bar behavior when the container and the sticky bar have transparent color.\n  :host([color='transparent']) & {\n    background-color: transparent;\n  }\n\n  :host(:not([expanded])) & {\n    @include sbb.page-spacing;\n  }\n\n  :host([expanded]) & {\n    @include sbb.page-spacing-expanded;\n  }\n\n  :host(:state(slotted-image):not([background-expanded])) & {\n    position: relative;\n  }\n}\n\n.sbb-container__content {\n  :host(:state(slotted-image)) & {\n    // With relative positioning we ensure the content is in front of the image.\n    position: relative;\n  }\n}\n\n::slotted([slot='image']) {\n  position: absolute;\n  inset: 0;\n  height: 100%;\n  width: 100%;\n}\n","import { type CSSResultGroup, html, type PropertyValues, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbElement } from '../../core/base-elements.ts';\nimport { forceType } from '../../core/decorators.ts';\nimport { ɵstateController } from '../../core/mixins.ts';\nimport { boxSizingStyles } from '../../core/styles.ts';\n\nimport style from './container.scss?lit&inline';\n\n/**\n * It displays its content with the default page spacing.\n *\n * @slot - Use the unnamed slot to add anything to the container.\n * @slot sticky-bar - The slot used by the sbb-sticky-bar component.\n * @slot image - The slot used to slot an `sbb-image` to use as background.\n * @cssprop --sbb-page-spacing-padding - Use this variable to override the default page spacing.\n * Note that overriding this will disable the standard responsive spacing behavior of the container.\n */\nexport class SbbContainerElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-container';\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  /** Whether the container is expanded. */\n  @forceType()\n  @property({ type: Boolean, reflect: true })\n  public accessor expanded: boolean = false;\n\n  /** Whether the background color is shown on full container width on large screens. */\n  @forceType()\n  @property({ type: Boolean, reflect: true, attribute: 'background-expanded' })\n  public accessor backgroundExpanded: boolean = false;\n\n  /** Color of the container, like transparent, white etc. */\n  @property({ reflect: true }) public accessor color:\n    | 'transparent'\n    | 'white'\n    | 'milk'\n    | 'midnight'\n    | 'charcoal' = 'white';\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('expanded')) {\n      const stickyBar = this.querySelector?.('sbb-sticky-bar');\n      ɵstateController(stickyBar)?.toggle('expanded', this.expanded);\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-container\">\n        <slot name=\"image\"></slot>\n        <div class=\"sbb-container__content\">\n          <slot></slot>\n        </div>\n      </div>\n      <slot name=\"sticky-bar\"></slot>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-container': SbbContainerElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ICmBa,6BAAmB;mBAAS;;;;;;;;;;cAA5B,4BAA4B,YAAU;;;2BAKhD,WAAW,EACX,SAAS;IAAE,MAAM;IAAS,SAAS;IAAM,CAAC,CAAA;qCAI1C,WAAW,EACX,SAAS;IAAE,MAAM;IAAS,SAAS;IAAM,WAAW;IAAuB,CAAC,CAAA;wBAI5E,SAAS,EAAE,SAAS,MAAM,CAAC,CAAA;AAR5B,gBAAA,MAAA,MAAA,sBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,cAAA;KAAA,MAAA,QAAA,IAAgB;KAAQ,MAAA,KAAA,UAAA;AAAA,UAAR,WAAQ;;KAAA;IAAA,UAAA;IAAA,EAAA,wBAAA,4BAAA;AAKxB,gBAAA,MAAA,MAAA,gCAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,wBAAA;KAAA,MAAA,QAAA,IAAgB;KAAkB,MAAA,KAAA,UAAA;AAAA,UAAlB,qBAAkB;;KAAA;IAAA,UAAA;IAAA,EAAA,kCAAA,sCAAA;AAGL,gBAAA,MAAA,MAAA,mBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,WAAA;KAAA,MAAA,QAAA,IAAgB;KAAK,MAAA,KAAA,UAAA;AAAA,UAAL,QAAK;;KAAA;IAAA,UAAA;IAAA,EAAA,qBAAA,yBAAA;;;;;;;;;AAdlB,QAAA,cAAsB;;;AAC/B,QAAA,SAAyB,CAAC,iBAAiB,kBAAM;;EAKxE,6BAAA,kBAAA,MAAA,wBAAoC,MAAK;;EAAzC,IAAgB,WAAQ;AAAA,UAAA,MAAA;;EAAxB,IAAgB,SAAQ,OAAA;AAAA,SAAA,4BAAA;;EAKxB,wCAAA,kBAAA,MAAA,4BAAA,EAAA,kBAAA,MAAA,kCAA8C,MAAK;;EAAnD,IAAgB,qBAAkB;AAAA,UAAA,MAAA;;EAAlC,IAAgB,mBAAkB,OAAA;AAAA,SAAA,sCAAA;;EAGL,2BAAA,kBAAA,MAAA,sCAAA,EAAA,kBAAA,MAAA,qBAKZ,QAAO;;EALK,IAAgB,QAAK;AAAA,UAAA,MAAA;;EAArB,IAAgB,MAAK,OAAA;AAAA,SAAA,yBAAA;;EAO/B,WAAW,mBAAuC;AACnE,SAAM,WAAW,kBAAkB;AAEnC,OAAI,kBAAkB,IAAI,WAAW,EAAE;IACrC,MAAM,YAAY,KAAK,gBAAgB,iBAAiB;AACxD,qBAAiB,UAAU,EAAE,OAAO,YAAY,KAAK,SAAS;;;EAI/C,SAAM;AACvB,UAAO,IAAI"}

package/development/container.d.ts

@@ -1,6 +1,2 @@
-/**
- * @entrypoint
- */
-export * from './container/container.ts';
-export * from './container/sticky-bar.ts';
+export * from './container.pure.ts';
 //# sourceMappingURL=container.d.ts.map

package/development/container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../../src/elements/container.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../../src/elements/container.ts"],"names":[],"mappings":"AAGA,cAAc,qBAAqB,CAAC"}

package/development/container.js

@@ -1,7 +1,11 @@
-import { SbbContainerElement } from "./container/container/container.component.js";
-import { SbbStickyBarElement } from "./container/sticky-bar/sticky-bar.component.js";
-export {
-  SbbContainerElement,
-  SbbStickyBarElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGFpbmVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7In0=
+import { t as SbbContainerElement } from "./container.component-Co2L3KBb.js";
+import { t as SbbStickyBarElement } from "./sticky-bar.component-DxDHpEgX.js";
+import "./container.pure.js";
+//#region src/elements/container.ts
+/** @entrypoint */
+SbbContainerElement.define();
+SbbStickyBarElement.define();
+//#endregion
+export { SbbContainerElement, SbbStickyBarElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGFpbmVyLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbGVtZW50cy9jb250YWluZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQgeyBTYmJDb250YWluZXJFbGVtZW50LCBTYmJTdGlja3lCYXJFbGVtZW50IH0gZnJvbSAnLi9jb250YWluZXIucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vY29udGFpbmVyLnB1cmUudHMnO1xuXG5TYmJDb250YWluZXJFbGVtZW50LmRlZmluZSgpO1xuU2JiU3RpY2t5QmFyRWxlbWVudC5kZWZpbmUoKTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFLQSxvQkFBb0IsUUFBUTtBQUM1QixvQkFBb0IsUUFBUSJ9

package/development/container.pure.d.ts

@@ -0,0 +1,4 @@
+/** @entrypoint */
+export * from './container/container/container.component.ts';
+export * from './container/sticky-bar/sticky-bar.component.ts';
+//# sourceMappingURL=container.pure.d.ts.map

package/development/container.pure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.pure.d.ts","sourceRoot":"","sources":["../../../src/elements/container.pure.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,cAAc,8CAA8C,CAAC;AAC7D,cAAc,gDAAgD,CAAC"}

package/development/container.pure.js

@@ -0,0 +1,3 @@
+import { t as SbbContainerElement } from "./container.component-Co2L3KBb.js";
+import { t as SbbStickyBarElement } from "./sticky-bar.component-DxDHpEgX.js";
+export { SbbContainerElement, SbbStickyBarElement };

package/development/core/a11y/arrow-navigation.js

@@ -1,43 +1,82 @@
+//#region src/elements/core/a11y/arrow-navigation.ts
 function getPrevAndNextKeys() {
-  if (document.documentElement.matches(":dir(rtl)")) {
-    return { prevKey: "ArrowRight", nextKey: "ArrowLeft" };
-  } else {
-    return { prevKey: "ArrowLeft", nextKey: "ArrowRight" };
-  }
+	if (document.documentElement.matches(":dir(rtl)")) return {
+		prevKey: "ArrowRight",
+		nextKey: "ArrowLeft"
+	};
+	else return {
+		prevKey: "ArrowLeft",
+		nextKey: "ArrowRight"
+	};
 }
+/**
+* Check if the key pressed is among those allowed for navigation.
+* @param event The keyboard event to check.
+*/
 function isArrowKeyPressed(event) {
-  return ["ArrowRight", "ArrowLeft", "ArrowUp", "ArrowDown"].includes(event.key);
+	return [
+		"ArrowRight",
+		"ArrowLeft",
+		"ArrowUp",
+		"ArrowDown"
+	].includes(event.key);
 }
+/**
+* Check if the key pressed should move the navigation to the next element.
+* @param event The keyboard event to check.
+*/
 function isPreviousArrowKeyPressed(event) {
-  return event.key === "ArrowUp" || event.key === getPrevAndNextKeys().prevKey;
+	return event.key === "ArrowUp" || event.key === getPrevAndNextKeys().prevKey;
 }
+/**
+* Check if the key pressed should move the navigation to the next element.
+* @param event The keyboard event to check.
+*/
 function isNextArrowKeyPressed(event) {
-  return event.key === "ArrowDown" || event.key === getPrevAndNextKeys().nextKey;
+	return event.key === "ArrowDown" || event.key === getPrevAndNextKeys().nextKey;
 }
+/**
+* Check if the key pressed is among those allowed for navigation.
+* @param event The keyboard event to check.
+*/
 function isArrowKeyOrPageKeysPressed(event) {
-  return isArrowKeyPressed(event) || ["PageUp", "PageDown", "Home", "End"].includes(event.key);
+	return isArrowKeyPressed(event) || [
+		"PageUp",
+		"PageDown",
+		"Home",
+		"End"
+	].includes(event.key);
 }
+/**
+* Calculate the index of the next element based on the given offset.
+* @param currentIndex The index of the current element.
+* @param maxIndex The maximum permitted value (e.g. array size).
+* @param offset The amount to move by.
+*/
 function calcNextIndexInRange(currentIndex, maxIndex, offset) {
-  return (currentIndex + offset + maxIndex) % maxIndex;
+	return (currentIndex + offset + maxIndex) % maxIndex;
 }
 function getLastIndex(size) {
-  return size - 1;
+	return size - 1;
 }
-const firstIndex = 0;
+var firstIndex = 0;
+/**
+* Gets the index of the element to move to, based on the keyboard input, the current element in the list and the list size.
+* @param event The keyboard event to check. If null, will count as a 'next' step.
+* @param current The index of the current element in the list.
+* @param size The size of the list.
+* @returns if it is a 'previous' event, returns the index of the previous element,
+* or the index of the last one if the current element is the first in the list;
+* if it is a 'next' event, returns the index of the next element,
+* or the index of the first one, if the current is the last in the list.
+*/
 function getNextElementIndex(event, current, size) {
-  const { prevKey, nextKey } = getPrevAndNextKeys();
-  if (!event || event.key === nextKey || event.key === "ArrowDown") {
-    return current >= size ? firstIndex : calcNextIndexInRange(current, size, 1);
-  } else if (event.key === prevKey || event.key === "ArrowUp") {
-    return current < firstIndex ? getLastIndex(size) : calcNextIndexInRange(current, size, -1);
-  }
-  return current;
-}
-export {
-  getNextElementIndex,
-  isArrowKeyOrPageKeysPressed,
-  isArrowKeyPressed,
-  isNextArrowKeyPressed,
-  isPreviousArrowKeyPressed
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyb3ctbmF2aWdhdGlvbi5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2NvcmUvYTExeS9hcnJvdy1uYXZpZ2F0aW9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImludGVyZmFjZSBQcmV2QW5kTmV4dEtleXMge1xuICBwcmV2S2V5OiBzdHJpbmc7XG4gIG5leHRLZXk6IHN0cmluZztcbn1cblxuZnVuY3Rpb24gZ2V0UHJldkFuZE5leHRLZXlzKCk6IFByZXZBbmROZXh0S2V5cyB7XG4gIGlmIChkb2N1bWVudC5kb2N1bWVudEVsZW1lbnQubWF0Y2hlcygnOmRpcihydGwpJykpIHtcbiAgICByZXR1cm4geyBwcmV2S2V5OiAnQXJyb3dSaWdodCcsIG5leHRLZXk6ICdBcnJvd0xlZnQnIH07XG4gIH0gZWxzZSB7XG4gICAgcmV0dXJuIHsgcHJldktleTogJ0Fycm93TGVmdCcsIG5leHRLZXk6ICdBcnJvd1JpZ2h0JyB9O1xuICB9XG59XG5cbi8qKlxuICogQ2hlY2sgaWYgdGhlIGtleSBwcmVzc2VkIGlzIGFtb25nIHRob3NlIGFsbG93ZWQgZm9yIG5hdmlnYXRpb24uXG4gKiBAcGFyYW0gZXZlbnQgVGhlIGtleWJvYXJkIGV2ZW50IHRvIGNoZWNrLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNBcnJvd0tleVByZXNzZWQoZXZlbnQ6IEtleWJvYXJkRXZlbnQpOiBib29sZWFuIHtcbiAgcmV0dXJuIFsnQXJyb3dSaWdodCcsICdBcnJvd0xlZnQnLCAnQXJyb3dVcCcsICdBcnJvd0Rvd24nXS5pbmNsdWRlcyhldmVudC5rZXkpO1xufVxuXG4vKipcbiAqIENoZWNrIGlmIHRoZSBrZXkgcHJlc3NlZCBzaG91bGQgbW92ZSB0aGUgbmF2aWdhdGlvbiB0byB0aGUgbmV4dCBlbGVtZW50LlxuICogQHBhcmFtIGV2ZW50IFRoZSBrZXlib2FyZCBldmVudCB0byBjaGVjay5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzUHJldmlvdXNBcnJvd0tleVByZXNzZWQoZXZlbnQ6IEtleWJvYXJkRXZlbnQpOiBib29sZWFuIHtcbiAgcmV0dXJuIGV2ZW50LmtleSA9PT0gJ0Fycm93VXAnIHx8IGV2ZW50LmtleSA9PT0gZ2V0UHJldkFuZE5leHRLZXlzKCkucHJldktleTtcbn1cblxuLyoqXG4gKiBDaGVjayBpZiB0aGUga2V5IHByZXNzZWQgc2hvdWxkIG1vdmUgdGhlIG5hdmlnYXRpb24gdG8gdGhlIG5leHQgZWxlbWVudC5cbiAqIEBwYXJhbSBldmVudCBUaGUga2V5Ym9hcmQgZXZlbnQgdG8gY2hlY2suXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc05leHRBcnJvd0tleVByZXNzZWQoZXZlbnQ6IEtleWJvYXJkRXZlbnQpOiBib29sZWFuIHtcbiAgcmV0dXJuIGV2ZW50LmtleSA9PT0gJ0Fycm93RG93bicgfHwgZXZlbnQua2V5ID09PSBnZXRQcmV2QW5kTmV4dEtleXMoKS5uZXh0S2V5O1xufVxuXG4vKipcbiAqIENoZWNrIGlmIHRoZSBrZXkgcHJlc3NlZCBpcyBhbW9uZyB0aG9zZSBhbGxvd2VkIGZvciBuYXZpZ2F0aW9uLlxuICogQHBhcmFtIGV2ZW50IFRoZSBrZXlib2FyZCBldmVudCB0byBjaGVjay5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzQXJyb3dLZXlPclBhZ2VLZXlzUHJlc3NlZChldmVudDogS2V5Ym9hcmRFdmVudCk6IGJvb2xlYW4ge1xuICByZXR1cm4gaXNBcnJvd0tleVByZXNzZWQoZXZlbnQpIHx8IFsnUGFnZVVwJywgJ1BhZ2VEb3duJywgJ0hvbWUnLCAnRW5kJ10uaW5jbHVkZXMoZXZlbnQua2V5KTtcbn1cblxuLyoqXG4gKiBDYWxjdWxhdGUgdGhlIGluZGV4IG9mIHRoZSBuZXh0IGVsZW1lbnQgYmFzZWQgb24gdGhlIGdpdmVuIG9mZnNldC5cbiAqIEBwYXJhbSBjdXJyZW50SW5kZXggVGhlIGluZGV4IG9mIHRoZSBjdXJyZW50IGVsZW1lbnQuXG4gKiBAcGFyYW0gbWF4SW5kZXggVGhlIG1heGltdW0gcGVybWl0dGVkIHZhbHVlIChlLmcuIGFycmF5IHNpemUpLlxuICogQHBhcmFtIG9mZnNldCBUaGUgYW1vdW50IHRvIG1vdmUgYnkuXG4gKi9cbmZ1bmN0aW9uIGNhbGNOZXh0SW5kZXhJblJhbmdlKGN1cnJlbnRJbmRleDogbnVtYmVyLCBtYXhJbmRleDogbnVtYmVyLCBvZmZzZXQ6IG51bWJlcik6IG51bWJlciB7XG4gIHJldHVybiAoY3VycmVudEluZGV4ICsgb2Zmc2V0ICsgbWF4SW5kZXgpICUgbWF4SW5kZXg7XG59XG5cbmZ1bmN0aW9uIGdldExhc3RJbmRleChzaXplOiBudW1iZXIpOiBudW1iZXIge1xuICByZXR1cm4gc2l6ZSAtIDE7XG59XG5cbmNvbnN0IGZpcnN0SW5kZXggPSAwO1xuXG4vKipcbiAqIEdldHMgdGhlIGluZGV4IG9mIHRoZSBlbGVtZW50IHRvIG1vdmUgdG8sIGJhc2VkIG9uIHRoZSBrZXlib2FyZCBpbnB1dCwgdGhlIGN1cnJlbnQgZWxlbWVudCBpbiB0aGUgbGlzdCBhbmQgdGhlIGxpc3Qgc2l6ZS5cbiAqIEBwYXJhbSBldmVudCBUaGUga2V5Ym9hcmQgZXZlbnQgdG8gY2hlY2suIElmIG51bGwsIHdpbGwgY291bnQgYXMgYSAnbmV4dCcgc3RlcC5cbiAqIEBwYXJhbSBjdXJyZW50IFRoZSBpbmRleCBvZiB0aGUgY3VycmVudCBlbGVtZW50IGluIHRoZSBsaXN0LlxuICogQHBhcmFtIHNpemUgVGhlIHNpemUgb2YgdGhlIGxpc3QuXG4gKiBAcmV0dXJucyBpZiBpdCBpcyBhICdwcmV2aW91cycgZXZlbnQsIHJldHVybnMgdGhlIGluZGV4IG9mIHRoZSBwcmV2aW91cyBlbGVtZW50LFxuICogb3IgdGhlIGluZGV4IG9mIHRoZSBsYXN0IG9uZSBpZiB0aGUgY3VycmVudCBlbGVtZW50IGlzIHRoZSBmaXJzdCBpbiB0aGUgbGlzdDtcbiAqIGlmIGl0IGlzIGEgJ25leHQnIGV2ZW50LCByZXR1cm5zIHRoZSBpbmRleCBvZiB0aGUgbmV4dCBlbGVtZW50LFxuICogb3IgdGhlIGluZGV4IG9mIHRoZSBmaXJzdCBvbmUsIGlmIHRoZSBjdXJyZW50IGlzIHRoZSBsYXN0IGluIHRoZSBsaXN0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0TmV4dEVsZW1lbnRJbmRleChcbiAgZXZlbnQ6IEtleWJvYXJkRXZlbnQgfCB1bmRlZmluZWQsXG4gIGN1cnJlbnQ6IG51bWJlcixcbiAgc2l6ZTogbnVtYmVyLFxuKTogbnVtYmVyIHtcbiAgY29uc3QgeyBwcmV2S2V5LCBuZXh0S2V5IH0gPSBnZXRQcmV2QW5kTmV4dEtleXMoKTtcblxuICBpZiAoIWV2ZW50IHx8IGV2ZW50LmtleSA9PT0gbmV4dEtleSB8fCBldmVudC5rZXkgPT09ICdBcnJvd0Rvd24nKSB7XG4gICAgcmV0dXJuIGN1cnJlbnQgPj0gc2l6ZSA/IGZpcnN0SW5kZXggOiBjYWxjTmV4dEluZGV4SW5SYW5nZShjdXJyZW50LCBzaXplLCAxKTtcbiAgfSBlbHNlIGlmIChldmVudC5rZXkgPT09IHByZXZLZXkgfHwgZXZlbnQua2V5ID09PSAnQXJyb3dVcCcpIHtcbiAgICByZXR1cm4gY3VycmVudCA8IGZpcnN0SW5kZXggPyBnZXRMYXN0SW5kZXgoc2l6ZSkgOiBjYWxjTmV4dEluZGV4SW5SYW5nZShjdXJyZW50LCBzaXplLCAtMSk7XG4gIH1cbiAgcmV0dXJuIGN1cnJlbnQ7XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsU0FBUyxxQkFBa0I7QUFDekIsTUFBSSxTQUFTLGdCQUFnQixRQUFRLFdBQVcsR0FBRztBQUNqRCxXQUFPLEVBQUUsU0FBUyxjQUFjLFNBQVMsWUFBQTtBQUFBLEVBQzNDLE9BQU87QUFDTCxXQUFPLEVBQUUsU0FBUyxhQUFhLFNBQVMsYUFBQTtBQUFBLEVBQzFDO0FBQ0Y7QUFNTSxTQUFVLGtCQUFrQixPQUFvQjtBQUNwRCxTQUFPLENBQUMsY0FBYyxhQUFhLFdBQVcsV0FBVyxFQUFFLFNBQVMsTUFBTSxHQUFHO0FBQy9FO0FBTU0sU0FBVSwwQkFBMEIsT0FBb0I7QUFDNUQsU0FBTyxNQUFNLFFBQVEsYUFBYSxNQUFNLFFBQVEscUJBQXFCO0FBQ3ZFO0FBTU0sU0FBVSxzQkFBc0IsT0FBb0I7QUFDeEQsU0FBTyxNQUFNLFFBQVEsZUFBZSxNQUFNLFFBQVEscUJBQXFCO0FBQ3pFO0FBTU0sU0FBVSw0QkFBNEIsT0FBb0I7QUFDOUQsU0FBTyxrQkFBa0IsS0FBSyxLQUFLLENBQUMsVUFBVSxZQUFZLFFBQVEsS0FBSyxFQUFFLFNBQVMsTUFBTSxHQUFHO0FBQzdGO0FBUUEsU0FBUyxxQkFBcUIsY0FBc0IsVUFBa0IsUUFBYztBQUNsRixVQUFRLGVBQWUsU0FBUyxZQUFZO0FBQzlDO0FBRUEsU0FBUyxhQUFhLE1BQVk7QUFDaEMsU0FBTyxPQUFPO0FBQ2hCO0FBRUEsTUFBTSxhQUFhO1NBWUgsb0JBQ2QsT0FDQSxTQUNBLE1BQVk7QUFFWixRQUFNLEVBQUUsU0FBUyxRQUFBLElBQVksbUJBQUE7QUFFN0IsTUFBSSxDQUFDLFNBQVMsTUFBTSxRQUFRLFdBQVcsTUFBTSxRQUFRLGFBQWE7QUFDaEUsV0FBTyxXQUFXLE9BQU8sYUFBYSxxQkFBcUIsU0FBUyxNQUFNLENBQUM7QUFBQSxFQUM3RSxXQUFXLE1BQU0sUUFBUSxXQUFXLE1BQU0sUUFBUSxXQUFXO0FBQzNELFdBQU8sVUFBVSxhQUFhLGFBQWEsSUFBSSxJQUFJLHFCQUFxQixTQUFTLE1BQU0sRUFBRTtBQUFBLEVBQzNGO0FBQ0EsU0FBTztBQUNUOyJ9
+	const { prevKey, nextKey } = getPrevAndNextKeys();
+	if (!event || event.key === nextKey || event.key === "ArrowDown") return current >= size ? firstIndex : calcNextIndexInRange(current, size, 1);
+	else if (event.key === prevKey || event.key === "ArrowUp") return current < firstIndex ? getLastIndex(size) : calcNextIndexInRange(current, size, -1);
+	return current;
+}
+//#endregion
+export { getNextElementIndex, isArrowKeyOrPageKeysPressed, isArrowKeyPressed, isNextArrowKeyPressed, isPreviousArrowKeyPressed };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyb3ctbmF2aWdhdGlvbi5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY29yZS9hMTF5L2Fycm93LW5hdmlnYXRpb24udHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW50ZXJmYWNlIFByZXZBbmROZXh0S2V5cyB7XG4gIHByZXZLZXk6IHN0cmluZztcbiAgbmV4dEtleTogc3RyaW5nO1xufVxuXG5mdW5jdGlvbiBnZXRQcmV2QW5kTmV4dEtleXMoKTogUHJldkFuZE5leHRLZXlzIHtcbiAgaWYgKGRvY3VtZW50LmRvY3VtZW50RWxlbWVudC5tYXRjaGVzKCc6ZGlyKHJ0bCknKSkge1xuICAgIHJldHVybiB7IHByZXZLZXk6ICdBcnJvd1JpZ2h0JywgbmV4dEtleTogJ0Fycm93TGVmdCcgfTtcbiAgfSBlbHNlIHtcbiAgICByZXR1cm4geyBwcmV2S2V5OiAnQXJyb3dMZWZ0JywgbmV4dEtleTogJ0Fycm93UmlnaHQnIH07XG4gIH1cbn1cblxuLyoqXG4gKiBDaGVjayBpZiB0aGUga2V5IHByZXNzZWQgaXMgYW1vbmcgdGhvc2UgYWxsb3dlZCBmb3IgbmF2aWdhdGlvbi5cbiAqIEBwYXJhbSBldmVudCBUaGUga2V5Ym9hcmQgZXZlbnQgdG8gY2hlY2suXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc0Fycm93S2V5UHJlc3NlZChldmVudDogS2V5Ym9hcmRFdmVudCk6IGJvb2xlYW4ge1xuICByZXR1cm4gWydBcnJvd1JpZ2h0JywgJ0Fycm93TGVmdCcsICdBcnJvd1VwJywgJ0Fycm93RG93biddLmluY2x1ZGVzKGV2ZW50LmtleSk7XG59XG5cbi8qKlxuICogQ2hlY2sgaWYgdGhlIGtleSBwcmVzc2VkIHNob3VsZCBtb3ZlIHRoZSBuYXZpZ2F0aW9uIHRvIHRoZSBuZXh0IGVsZW1lbnQuXG4gKiBAcGFyYW0gZXZlbnQgVGhlIGtleWJvYXJkIGV2ZW50IHRvIGNoZWNrLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNQcmV2aW91c0Fycm93S2V5UHJlc3NlZChldmVudDogS2V5Ym9hcmRFdmVudCk6IGJvb2xlYW4ge1xuICByZXR1cm4gZXZlbnQua2V5ID09PSAnQXJyb3dVcCcgfHwgZXZlbnQua2V5ID09PSBnZXRQcmV2QW5kTmV4dEtleXMoKS5wcmV2S2V5O1xufVxuXG4vKipcbiAqIENoZWNrIGlmIHRoZSBrZXkgcHJlc3NlZCBzaG91bGQgbW92ZSB0aGUgbmF2aWdhdGlvbiB0byB0aGUgbmV4dCBlbGVtZW50LlxuICogQHBhcmFtIGV2ZW50IFRoZSBrZXlib2FyZCBldmVudCB0byBjaGVjay5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzTmV4dEFycm93S2V5UHJlc3NlZChldmVudDogS2V5Ym9hcmRFdmVudCk6IGJvb2xlYW4ge1xuICByZXR1cm4gZXZlbnQua2V5ID09PSAnQXJyb3dEb3duJyB8fCBldmVudC5rZXkgPT09IGdldFByZXZBbmROZXh0S2V5cygpLm5leHRLZXk7XG59XG5cbi8qKlxuICogQ2hlY2sgaWYgdGhlIGtleSBwcmVzc2VkIGlzIGFtb25nIHRob3NlIGFsbG93ZWQgZm9yIG5hdmlnYXRpb24uXG4gKiBAcGFyYW0gZXZlbnQgVGhlIGtleWJvYXJkIGV2ZW50IHRvIGNoZWNrLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNBcnJvd0tleU9yUGFnZUtleXNQcmVzc2VkKGV2ZW50OiBLZXlib2FyZEV2ZW50KTogYm9vbGVhbiB7XG4gIHJldHVybiBpc0Fycm93S2V5UHJlc3NlZChldmVudCkgfHwgWydQYWdlVXAnLCAnUGFnZURvd24nLCAnSG9tZScsICdFbmQnXS5pbmNsdWRlcyhldmVudC5rZXkpO1xufVxuXG4vKipcbiAqIENhbGN1bGF0ZSB0aGUgaW5kZXggb2YgdGhlIG5leHQgZWxlbWVudCBiYXNlZCBvbiB0aGUgZ2l2ZW4gb2Zmc2V0LlxuICogQHBhcmFtIGN1cnJlbnRJbmRleCBUaGUgaW5kZXggb2YgdGhlIGN1cnJlbnQgZWxlbWVudC5cbiAqIEBwYXJhbSBtYXhJbmRleCBUaGUgbWF4aW11bSBwZXJtaXR0ZWQgdmFsdWUgKGUuZy4gYXJyYXkgc2l6ZSkuXG4gKiBAcGFyYW0gb2Zmc2V0IFRoZSBhbW91bnQgdG8gbW92ZSBieS5cbiAqL1xuZnVuY3Rpb24gY2FsY05leHRJbmRleEluUmFuZ2UoY3VycmVudEluZGV4OiBudW1iZXIsIG1heEluZGV4OiBudW1iZXIsIG9mZnNldDogbnVtYmVyKTogbnVtYmVyIHtcbiAgcmV0dXJuIChjdXJyZW50SW5kZXggKyBvZmZzZXQgKyBtYXhJbmRleCkgJSBtYXhJbmRleDtcbn1cblxuZnVuY3Rpb24gZ2V0TGFzdEluZGV4KHNpemU6IG51bWJlcik6IG51bWJlciB7XG4gIHJldHVybiBzaXplIC0gMTtcbn1cblxuY29uc3QgZmlyc3RJbmRleCA9IDA7XG5cbi8qKlxuICogR2V0cyB0aGUgaW5kZXggb2YgdGhlIGVsZW1lbnQgdG8gbW92ZSB0bywgYmFzZWQgb24gdGhlIGtleWJvYXJkIGlucHV0LCB0aGUgY3VycmVudCBlbGVtZW50IGluIHRoZSBsaXN0IGFuZCB0aGUgbGlzdCBzaXplLlxuICogQHBhcmFtIGV2ZW50IFRoZSBrZXlib2FyZCBldmVudCB0byBjaGVjay4gSWYgbnVsbCwgd2lsbCBjb3VudCBhcyBhICduZXh0JyBzdGVwLlxuICogQHBhcmFtIGN1cnJlbnQgVGhlIGluZGV4IG9mIHRoZSBjdXJyZW50IGVsZW1lbnQgaW4gdGhlIGxpc3QuXG4gKiBAcGFyYW0gc2l6ZSBUaGUgc2l6ZSBvZiB0aGUgbGlzdC5cbiAqIEByZXR1cm5zIGlmIGl0IGlzIGEgJ3ByZXZpb3VzJyBldmVudCwgcmV0dXJucyB0aGUgaW5kZXggb2YgdGhlIHByZXZpb3VzIGVsZW1lbnQsXG4gKiBvciB0aGUgaW5kZXggb2YgdGhlIGxhc3Qgb25lIGlmIHRoZSBjdXJyZW50IGVsZW1lbnQgaXMgdGhlIGZpcnN0IGluIHRoZSBsaXN0O1xuICogaWYgaXQgaXMgYSAnbmV4dCcgZXZlbnQsIHJldHVybnMgdGhlIGluZGV4IG9mIHRoZSBuZXh0IGVsZW1lbnQsXG4gKiBvciB0aGUgaW5kZXggb2YgdGhlIGZpcnN0IG9uZSwgaWYgdGhlIGN1cnJlbnQgaXMgdGhlIGxhc3QgaW4gdGhlIGxpc3QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXROZXh0RWxlbWVudEluZGV4KFxuICBldmVudDogS2V5Ym9hcmRFdmVudCB8IHVuZGVmaW5lZCxcbiAgY3VycmVudDogbnVtYmVyLFxuICBzaXplOiBudW1iZXIsXG4pOiBudW1iZXIge1xuICBjb25zdCB7IHByZXZLZXksIG5leHRLZXkgfSA9IGdldFByZXZBbmROZXh0S2V5cygpO1xuXG4gIGlmICghZXZlbnQgfHwgZXZlbnQua2V5ID09PSBuZXh0S2V5IHx8IGV2ZW50LmtleSA9PT0gJ0Fycm93RG93bicpIHtcbiAgICByZXR1cm4gY3VycmVudCA+PSBzaXplID8gZmlyc3RJbmRleCA6IGNhbGNOZXh0SW5kZXhJblJhbmdlKGN1cnJlbnQsIHNpemUsIDEpO1xuICB9IGVsc2UgaWYgKGV2ZW50LmtleSA9PT0gcHJldktleSB8fCBldmVudC5rZXkgPT09ICdBcnJvd1VwJykge1xuICAgIHJldHVybiBjdXJyZW50IDwgZmlyc3RJbmRleCA/IGdldExhc3RJbmRleChzaXplKSA6IGNhbGNOZXh0SW5kZXhJblJhbmdlKGN1cnJlbnQsIHNpemUsIC0xKTtcbiAgfVxuICByZXR1cm4gY3VycmVudDtcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUtBLFNBQVMscUJBQWtCO0FBQ3pCLEtBQUksU0FBUyxnQkFBZ0IsUUFBUSxZQUFZLENBQy9DLFFBQU87RUFBRSxTQUFTO0VBQWMsU0FBUztFQUFhO0tBRXRELFFBQU87RUFBRSxTQUFTO0VBQWEsU0FBUztFQUFjOzs7Ozs7QUFRMUQsU0FBZ0Isa0JBQWtCLE9BQW9CO0FBQ3BELFFBQU87RUFBQztFQUFjO0VBQWE7RUFBVztFQUFZLENBQUMsU0FBUyxNQUFNLElBQUk7Ozs7OztBQU9oRixTQUFnQiwwQkFBMEIsT0FBb0I7QUFDNUQsUUFBTyxNQUFNLFFBQVEsYUFBYSxNQUFNLFFBQVEsb0JBQW9CLENBQUM7Ozs7OztBQU92RSxTQUFnQixzQkFBc0IsT0FBb0I7QUFDeEQsUUFBTyxNQUFNLFFBQVEsZUFBZSxNQUFNLFFBQVEsb0JBQW9CLENBQUM7Ozs7OztBQU96RSxTQUFnQiw0QkFBNEIsT0FBb0I7QUFDOUQsUUFBTyxrQkFBa0IsTUFBTSxJQUFJO0VBQUM7RUFBVTtFQUFZO0VBQVE7RUFBTSxDQUFDLFNBQVMsTUFBTSxJQUFJOzs7Ozs7OztBQVM5RixTQUFTLHFCQUFxQixjQUFzQixVQUFrQixRQUFjO0FBQ2xGLFNBQVEsZUFBZSxTQUFTLFlBQVk7O0FBRzlDLFNBQVMsYUFBYSxNQUFZO0FBQ2hDLFFBQU8sT0FBTzs7QUFHaEIsSUFBTSxhQUFhOzs7Ozs7Ozs7OztBQVluQixTQUFnQixvQkFDZCxPQUNBLFNBQ0EsTUFBWTtDQUVaLE1BQU0sRUFBRSxTQUFTLFlBQVksb0JBQW9CO0FBRWpELEtBQUksQ0FBQyxTQUFTLE1BQU0sUUFBUSxXQUFXLE1BQU0sUUFBUSxZQUNuRCxRQUFPLFdBQVcsT0FBTyxhQUFhLHFCQUFxQixTQUFTLE1BQU0sRUFBRTtVQUNuRSxNQUFNLFFBQVEsV0FBVyxNQUFNLFFBQVEsVUFDaEQsUUFBTyxVQUFVLGFBQWEsYUFBYSxLQUFLLEdBQUcscUJBQXFCLFNBQVMsTUFBTSxHQUFHO0FBRTVGLFFBQU8ifQ==

package/development/core/a11y/fake-event-detection.js

@@ -1,12 +1,14 @@
+//#region src/elements/core/a11y/fake-event-detection.ts
+/** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */
 function isFakeMousedownFromScreenReader(event) {
-  return event.buttons === 0 || event.detail === 0;
+	return event.buttons === 0 || event.detail === 0;
 }
+/** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */
 function isFakeTouchstartFromScreenReader(event) {
-  const touch = event.touches && event.touches[0] || event.changedTouches && event.changedTouches[0];
-  return !!touch && touch.identifier === -1 && (touch.radiusX == null || touch.radiusX === 1) && (touch.radiusY == null || touch.radiusY === 1);
+	const touch = event.touches && event.touches[0] || event.changedTouches && event.changedTouches[0];
+	return !!touch && touch.identifier === -1 && (touch.radiusX == null || touch.radiusX === 1) && (touch.radiusY == null || touch.radiusY === 1);
 }
-export {
-  isFakeMousedownFromScreenReader,
-  isFakeTouchstartFromScreenReader
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//#endregion
+export { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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