ember-aria-voyager 0.2.3 → 0.2.5

package/README.md

@@ -1,7 +1,7 @@
 # ember-aria-voyager
 
-[![Test Coverage](https://api.codeclimate.com/v1/badges/6bd88c10540e66d94e2a/test_coverage)](https://codeclimate.com/github/hokulea/aria-voyager/test_coverage)
-[![Maintainability](https://api.codeclimate.com/v1/badges/6bd88c10540e66d94e2a/maintainability)](https://codeclimate.com/github/hokulea/aria-voyager/maintainability)
+[![Maintainability](https://qlty.sh/gh/hokulea/projects/aria-voyager/maintainability.svg)](https://qlty.sh/gh/hokulea/projects/aria-voyager)
+[![Code Coverage](https://qlty.sh/gh/hokulea/projects/aria-voyager/coverage.svg)](https://qlty.sh/gh/hokulea/projects/aria-voyager)
 
 _Canoe vessel that navigates your aria._
 
@@ -198,3 +198,15 @@ interface TablistSignature<T> {
 ```
 
 When passing `items` the `select()` and `selection` can work off of your passed items, anyway will fall back to the HTMLElement
+
+## Use in Classic Apps
+
+`ember-aria-voyager` is primed to be used with polaris edition of ember using
+imports. Classic v1 addons and v2 addons with compat automatically provide
+re-exports, which this addon does not. Re-export it manually. Here is an example
+for `ariaListbox`:
+
+```ts
+// app/modifiers/aria-listbox.js
+export { ariaListbox as default } from 'ember-aria-voyager';
+```

package/dist/aria-tablist-ClqYX2au.d.mts

@@ -0,0 +1,96 @@
+import { IndexEmitStrategy, ItemEmitStrategy, Orientation, TablistBehavior } from "aria-voyager";
+import Modifier, { ArgsFor, NamedArgs, PositionalArgs } from "ember-modifier";
+import Owner from "@ember/owner";
+
+//#region src/modifiers/-emitter.d.ts
+type WithItems<T> = {
+  items: T[];
+  selection?: T | T[];
+  activateItem?: (item: T) => void;
+} & ({
+  multi: true;
+  select?: (selection: T[]) => void;
+} | {
+  multi?: false;
+  select?: (selection: T) => void;
+});
+type OptionalItems = {
+  items?: HTMLElement[];
+  selection?: HTMLElement | HTMLElement[];
+  activateItem?: (item: HTMLElement) => void;
+} & ({
+  multi: true;
+  select?: (selection: HTMLElement[]) => void;
+} | {
+  multi?: false;
+  select?: (selection: HTMLElement) => void;
+});
+type EmitterSignature<T> = WithItems<T> | OptionalItems;
+//#endregion
+//#region src/modifiers/aria-listbox.d.ts
+interface ListboxSignature<T> {
+  Args: {
+    Positional: [];
+    Named: {
+      disabled?: boolean;
+    } & EmitterSignature<T>;
+  };
+}
+declare class ListboxModifier<T> extends Modifier<ListboxSignature<T>> {
+  private listbox?;
+  private updater;
+  private emitter;
+  private prevItems?;
+  private prevSelection?;
+  private prevMulti?;
+  private prevDisabled?;
+  constructor(owner: Owner, args: ArgsFor<ListboxSignature<T>>);
+  modify(element: Element, _: PositionalArgs<ListboxSignature<T>>, options: NamedArgs<ListboxSignature<T>>): void;
+}
+//#endregion
+//#region src/modifiers/aria-menu.d.ts
+interface MenuSignature<T> {
+  Element: HTMLElement;
+  Args: {
+    Positional: [];
+    Named: {
+      items?: T[];
+      disabled?: boolean;
+    };
+  };
+}
+declare class MenuModifier<T> extends Modifier<MenuSignature<T>> {
+  private menu?;
+  private updater;
+  private emitter;
+  private prevItems?;
+  private prevDisabled?;
+  constructor(owner: Owner, args: ArgsFor<MenuSignature<T>>);
+  modify(element: Element, _: PositionalArgs<MenuSignature<T>>, options: NamedArgs<MenuSignature<T>>): void;
+}
+//#endregion
+//#region src/modifiers/aria-tablist.d.ts
+interface TablistSignature<T> {
+  Element: HTMLElement;
+  Args: {
+    Positional: [];
+    Named: {
+      disabled?: boolean;
+      orientation?: Orientation;
+      behavior?: TablistBehavior;
+    } & EmitterSignature<T>;
+  };
+}
+declare class TablistModifier<T> extends Modifier<TablistSignature<T>> {
+  private tablist?;
+  private updater;
+  private emitter;
+  private prevItems?;
+  private prevSelection?;
+  private prevDisabled?;
+  private prevOrientation?;
+  constructor(owner: Owner, args: ArgsFor<TablistSignature<T>>);
+  modify(element: Element, _: PositionalArgs<TablistSignature<T>>, options: NamedArgs<TablistSignature<T>>): void;
+}
+//#endregion
+export { MenuModifier as n, ListboxModifier as r, TablistModifier as t };

package/dist/aria-tablist-WuIqBROc.d.cts

@@ -0,0 +1,96 @@
+import Modifier, { ArgsFor, NamedArgs, PositionalArgs } from "ember-modifier";
+import { Orientation, TablistBehavior } from "aria-voyager";
+import Owner from "@ember/owner";
+
+//#region src/modifiers/-emitter.d.ts
+type WithItems<T> = {
+  items: T[];
+  selection?: T | T[];
+  activateItem?: (item: T) => void;
+} & ({
+  multi: true;
+  select?: (selection: T[]) => void;
+} | {
+  multi?: false;
+  select?: (selection: T) => void;
+});
+type OptionalItems = {
+  items?: HTMLElement[];
+  selection?: HTMLElement | HTMLElement[];
+  activateItem?: (item: HTMLElement) => void;
+} & ({
+  multi: true;
+  select?: (selection: HTMLElement[]) => void;
+} | {
+  multi?: false;
+  select?: (selection: HTMLElement) => void;
+});
+type EmitterSignature<T> = WithItems<T> | OptionalItems;
+//#endregion
+//#region src/modifiers/aria-listbox.d.ts
+interface ListboxSignature<T> {
+  Args: {
+    Positional: [];
+    Named: {
+      disabled?: boolean;
+    } & EmitterSignature<T>;
+  };
+}
+declare class ListboxModifier<T> extends Modifier<ListboxSignature<T>> {
+  private listbox?;
+  private updater;
+  private emitter;
+  private prevItems?;
+  private prevSelection?;
+  private prevMulti?;
+  private prevDisabled?;
+  constructor(owner: Owner, args: ArgsFor<ListboxSignature<T>>);
+  modify(element: Element, _: PositionalArgs<ListboxSignature<T>>, options: NamedArgs<ListboxSignature<T>>): void;
+}
+//#endregion
+//#region src/modifiers/aria-menu.d.ts
+interface MenuSignature<T> {
+  Element: HTMLElement;
+  Args: {
+    Positional: [];
+    Named: {
+      items?: T[];
+      disabled?: boolean;
+    };
+  };
+}
+declare class MenuModifier<T> extends Modifier<MenuSignature<T>> {
+  private menu?;
+  private updater;
+  private emitter;
+  private prevItems?;
+  private prevDisabled?;
+  constructor(owner: Owner, args: ArgsFor<MenuSignature<T>>);
+  modify(element: Element, _: PositionalArgs<MenuSignature<T>>, options: NamedArgs<MenuSignature<T>>): void;
+}
+//#endregion
+//#region src/modifiers/aria-tablist.d.ts
+interface TablistSignature<T> {
+  Element: HTMLElement;
+  Args: {
+    Positional: [];
+    Named: {
+      disabled?: boolean;
+      orientation?: Orientation;
+      behavior?: TablistBehavior;
+    } & EmitterSignature<T>;
+  };
+}
+declare class TablistModifier<T> extends Modifier<TablistSignature<T>> {
+  private tablist?;
+  private updater;
+  private emitter;
+  private prevItems?;
+  private prevSelection?;
+  private prevDisabled?;
+  private prevOrientation?;
+  constructor(owner: Owner, args: ArgsFor<TablistSignature<T>>);
+  modify(element: Element, _: PositionalArgs<TablistSignature<T>>, options: NamedArgs<TablistSignature<T>>): void;
+}
+//#endregion
+export { MenuModifier as n, ListboxModifier as r, TablistModifier as t };

package/dist/chunk-CbDLau6x.cjs

@@ -0,0 +1,34 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/index.cjs

@@ -0,0 +1,350 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+let _ember_destroyable = require("@ember/destroyable");
+let aria_voyager = require("aria-voyager");
+let ember_modifier = require("ember-modifier");
+ember_modifier = require_chunk.__toESM(ember_modifier);
+
+//#region ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function getSymbols(object) {
+	return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+function getTag(value) {
+	if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
+	return Object.prototype.toString.call(value);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+const regexpTag = "[object RegExp]";
+const stringTag = "[object String]";
+const numberTag = "[object Number]";
+const booleanTag = "[object Boolean]";
+const argumentsTag = "[object Arguments]";
+const symbolTag = "[object Symbol]";
+const dateTag = "[object Date]";
+const mapTag = "[object Map]";
+const setTag = "[object Set]";
+const arrayTag = "[object Array]";
+const functionTag = "[object Function]";
+const arrayBufferTag = "[object ArrayBuffer]";
+const objectTag = "[object Object]";
+const errorTag = "[object Error]";
+const dataViewTag = "[object DataView]";
+const uint8ArrayTag = "[object Uint8Array]";
+const uint8ClampedArrayTag = "[object Uint8ClampedArray]";
+const uint16ArrayTag = "[object Uint16Array]";
+const uint32ArrayTag = "[object Uint32Array]";
+const bigUint64ArrayTag = "[object BigUint64Array]";
+const int8ArrayTag = "[object Int8Array]";
+const int16ArrayTag = "[object Int16Array]";
+const int32ArrayTag = "[object Int32Array]";
+const bigInt64ArrayTag = "[object BigInt64Array]";
+const float32ArrayTag = "[object Float32Array]";
+const float64ArrayTag = "[object Float64Array]";
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/compat/util/eq.mjs
+function eq(value, other) {
+	return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
+function isEqualWith(a, b, areValuesEqual) {
+	return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
+}
+function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
+	const result = areValuesEqual(a, b, property, aParent, bParent, stack);
+	if (result !== void 0) return result;
+	if (typeof a === typeof b) switch (typeof a) {
+		case "bigint":
+		case "string":
+		case "boolean":
+		case "symbol":
+		case "undefined": return a === b;
+		case "number": return a === b || Object.is(a, b);
+		case "function": return a === b;
+		case "object": return areObjectsEqual(a, b, stack, areValuesEqual);
+	}
+	return areObjectsEqual(a, b, stack, areValuesEqual);
+}
+function areObjectsEqual(a, b, stack, areValuesEqual) {
+	if (Object.is(a, b)) return true;
+	let aTag = getTag(a);
+	let bTag = getTag(b);
+	if (aTag === argumentsTag) aTag = objectTag;
+	if (bTag === argumentsTag) bTag = objectTag;
+	if (aTag !== bTag) return false;
+	switch (aTag) {
+		case stringTag: return a.toString() === b.toString();
+		case numberTag: return eq(a.valueOf(), b.valueOf());
+		case booleanTag:
+		case dateTag:
+		case symbolTag: return Object.is(a.valueOf(), b.valueOf());
+		case regexpTag: return a.source === b.source && a.flags === b.flags;
+		case functionTag: return a === b;
+	}
+	stack = stack ?? /* @__PURE__ */ new Map();
+	const aStack = stack.get(a);
+	const bStack = stack.get(b);
+	if (aStack != null && bStack != null) return aStack === b;
+	stack.set(a, b);
+	stack.set(b, a);
+	try {
+		switch (aTag) {
+			case mapTag:
+				if (a.size !== b.size) return false;
+				for (const [key, value] of a.entries()) if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) return false;
+				return true;
+			case setTag: {
+				if (a.size !== b.size) return false;
+				const aValues = Array.from(a.values());
+				const bValues = Array.from(b.values());
+				for (let i = 0; i < aValues.length; i++) {
+					const aValue = aValues[i];
+					const index = bValues.findIndex((bValue) => {
+						return isEqualWithImpl(aValue, bValue, void 0, a, b, stack, areValuesEqual);
+					});
+					if (index === -1) return false;
+					bValues.splice(index, 1);
+				}
+				return true;
+			}
+			case arrayTag:
+			case uint8ArrayTag:
+			case uint8ClampedArrayTag:
+			case uint16ArrayTag:
+			case uint32ArrayTag:
+			case bigUint64ArrayTag:
+			case int8ArrayTag:
+			case int16ArrayTag:
+			case int32ArrayTag:
+			case bigInt64ArrayTag:
+			case float32ArrayTag:
+			case float64ArrayTag:
+				if (typeof Buffer !== "undefined" && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) return false;
+				if (a.length !== b.length) return false;
+				for (let i = 0; i < a.length; i++) if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) return false;
+				return true;
+			case arrayBufferTag:
+				if (a.byteLength !== b.byteLength) return false;
+				return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+			case dataViewTag:
+				if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) return false;
+				return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+			case errorTag: return a.name === b.name && a.message === b.message;
+			case objectTag: {
+				if (!(areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || isPlainObject(a) && isPlainObject(b))) return false;
+				const aKeys = [...Object.keys(a), ...getSymbols(a)];
+				const bKeys = [...Object.keys(b), ...getSymbols(b)];
+				if (aKeys.length !== bKeys.length) return false;
+				for (let i = 0; i < aKeys.length; i++) {
+					const propKey = aKeys[i];
+					const aProp = a[propKey];
+					if (!Object.hasOwn(b, propKey)) return false;
+					const bProp = b[propKey];
+					if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) return false;
+				}
+				return true;
+			}
+			default: return false;
+		}
+	} finally {
+		stack.delete(a);
+		stack.delete(b);
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/function/noop.mjs
+function noop() {}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/predicate/isEqual.mjs
+function isEqual(a, b) {
+	return isEqualWith(a, b, noop);
+}
+
+//#endregion
+//#region src/modifiers/-emitter.ts
+function asArray(val) {
+	if (val === void 0) return [];
+	return Array.isArray(val) ? val : [val];
+}
+function createItemEmitter(control, options) {
+	return new aria_voyager.ItemEmitStrategy(control, {
+		select: (selection) => {
+			options.select?.(options.multi ? selection : selection[0]);
+		},
+		activateItem: (item) => {
+			options.activateItem?.(item);
+		}
+	});
+}
+function createIndexEmitter(control, options) {
+	const findByIndex = (index) => {
+		return options.items[index] ?? void 0;
+	};
+	return new aria_voyager.IndexEmitStrategy(control, {
+		select: (selection) => {
+			if (options.multi) {
+				const items = selection.map((index) => findByIndex(index)).filter((i) => i !== void 0);
+				options.select?.(items);
+			} else {
+				const item = findByIndex(selection[0]);
+				if (item) options.select?.(item);
+			}
+		},
+		activateItem: (index) => {
+			const item = findByIndex(index);
+			if (item) options.activateItem?.(item);
+		}
+	});
+}
+
+//#endregion
+//#region src/modifiers/aria-listbox.ts
+var ListboxModifier = class extends ember_modifier.default {
+	listbox;
+	prevItems;
+	prevSelection;
+	prevMulti;
+	prevDisabled;
+	constructor(owner, args) {
+		super(owner, args);
+		(0, _ember_destroyable.registerDestructor)(this, () => {
+			this.listbox?.dispose();
+		});
+	}
+	modify(element, _, options) {
+		if (!this.listbox) {
+			this.updater = new aria_voyager.ReactiveUpdateStrategy();
+			this.listbox = new aria_voyager.Listbox(element, { updater: this.updater });
+		}
+		if (options.items && !(this.emitter instanceof aria_voyager.IndexEmitStrategy)) this.emitter = createIndexEmitter(this.listbox, options);
+		else if (!options.items && !(this.emitter instanceof aria_voyager.ItemEmitStrategy)) this.emitter = createItemEmitter(this.listbox, options);
+		if (options.items && !isEqual(this.prevItems, options.items)) {
+			this.updater.updateItems();
+			this.prevItems = [...options.items];
+		}
+		if (options.selection && !isEqual(asArray(this.prevSelection), asArray(options.selection))) {
+			this.updater.updateSelection();
+			this.prevSelection = asArray(options.selection);
+		}
+		let optionsChanged = false;
+		if (this.prevMulti !== options.multi) {
+			if (options.multi) element.setAttribute("aria-multiselectable", "true");
+			else element.removeAttribute("aria-multiselectable");
+			optionsChanged = true;
+			this.prevMulti = options.multi;
+		}
+		if (this.prevDisabled !== options.disabled) {
+			if (options.disabled) element.setAttribute("aria-disabled", "true");
+			else element.removeAttribute("aria-disabled");
+			optionsChanged = true;
+			this.prevDisabled = options.disabled;
+		}
+		if (optionsChanged) this.updater.updateOptions();
+	}
+};
+
+//#endregion
+//#region src/modifiers/aria-menu.ts
+var MenuModifier = class extends ember_modifier.default {
+	menu;
+	prevItems;
+	prevDisabled;
+	constructor(owner, args) {
+		super(owner, args);
+		(0, _ember_destroyable.registerDestructor)(this, () => {
+			this.menu?.dispose();
+		});
+	}
+	modify(element, _, options) {
+		if (!this.menu) {
+			this.updater = new aria_voyager.ReactiveUpdateStrategy();
+			this.menu = new aria_voyager.Menu(element, { updater: this.updater });
+		}
+		if (options.items && !isEqual(this.prevItems, options.items)) {
+			this.updater.updateItems();
+			this.prevItems = [...options.items];
+		}
+		let optionsChanged = false;
+		if (this.prevDisabled !== options.disabled) {
+			if (options.disabled) element.setAttribute("aria-disabled", "true");
+			else element.removeAttribute("aria-disabled");
+			optionsChanged = true;
+			this.prevDisabled = options.disabled;
+		}
+		if (optionsChanged) this.updater.updateOptions();
+	}
+};
+
+//#endregion
+//#region src/modifiers/aria-tablist.ts
+var TablistModifier = class extends ember_modifier.default {
+	tablist;
+	prevItems;
+	prevSelection;
+	prevDisabled;
+	prevOrientation;
+	constructor(owner, args) {
+		super(owner, args);
+		(0, _ember_destroyable.registerDestructor)(this, () => {
+			this.tablist?.dispose();
+		});
+	}
+	modify(element, _, options) {
+		if (!this.tablist) {
+			this.updater = new aria_voyager.ReactiveUpdateStrategy();
+			this.tablist = new aria_voyager.Tablist(element, {
+				updater: this.updater,
+				behavior: options.behavior
+			});
+		}
+		if (options.items && !(this.emitter instanceof aria_voyager.IndexEmitStrategy)) this.emitter = createIndexEmitter(this.tablist, options);
+		else if (!options.items && !(this.emitter instanceof aria_voyager.ItemEmitStrategy)) this.emitter = createItemEmitter(this.tablist, options);
+		if (options.items && !isEqual(this.prevItems, options.items)) {
+			this.updater.updateItems();
+			this.prevItems = [...options.items];
+		}
+		if (options.selection && !isEqual(asArray(this.prevSelection), asArray(options.selection))) {
+			this.updater.updateSelection();
+			this.prevSelection = asArray(options.selection);
+		}
+		let optionsChanged = false;
+		if (this.prevOrientation !== options.orientation) {
+			if (options.orientation) element.setAttribute("aria-orientation", options.orientation);
+			else element.removeAttribute("aria-orientation");
+			optionsChanged = true;
+			this.prevOrientation = options.orientation;
+		}
+		if (this.prevDisabled !== options.disabled) {
+			if (options.disabled) element.setAttribute("aria-disabled", "true");
+			else element.removeAttribute("aria-disabled");
+			optionsChanged = true;
+			this.prevDisabled = options.disabled;
+		}
+		if (optionsChanged) this.updater.updateOptions();
+	}
+};
+
+//#endregion
+exports.ariaListbox = ListboxModifier;
+exports.ariaMenu = MenuModifier;
+exports.ariaTablist = TablistModifier;
+exports.listbox = ListboxModifier;
+exports.menu = MenuModifier;
+exports.tablist = TablistModifier;

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+import { n as MenuModifier, r as ListboxModifier, t as TablistModifier } from "./aria-tablist-WuIqBROc.cjs";
+import { Orientation, TablistBehavior } from "aria-voyager";
+export { type Orientation, type TablistBehavior, ListboxModifier as ariaListbox, ListboxModifier as listbox, MenuModifier as ariaMenu, MenuModifier as menu, TablistModifier as ariaTablist, TablistModifier as tablist };

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { n as MenuModifier, r as ListboxModifier, t as TablistModifier } from "./aria-tablist-ClqYX2au.mjs";
+import { Orientation, TablistBehavior } from "aria-voyager";
+export { type Orientation, type TablistBehavior, ListboxModifier as ariaListbox, ListboxModifier as listbox, MenuModifier as ariaMenu, MenuModifier as menu, TablistModifier as ariaTablist, TablistModifier as tablist };