@vonage/vivid 5.15.1 → 5.16.0

package/unbundled/listbox.js

@@ -1,464 +1,358 @@
-import { Observable, attr, observable } from '@microsoft/fast-element';
-import { keySpace, keyEscape, keyEnter, keyTab, keyEnd, keyArrowUp, keyArrowDown, keyHome, findLastIndex, uniqueId } from '@microsoft/fast-web-utilities';
-import { i as isListboxOption } from './definition3.js';
-import { V as VividElement } from './vivid-element.js';
-
-var __defProp = Object.defineProperty;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = void 0 ;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (decorator(target, key, result) ) || result;
-  if (result) __defProp(target, key, result);
-  return result;
+import { t as VividElement } from "./vivid-element.js";
+import { t as __decorate } from "./decorate.js";
+import { i as isListboxOption } from "./definition27.js";
+import { Observable, attr, observable } from "@microsoft/fast-element";
+import { findLastIndex, keyArrowDown, keyArrowUp, keyEnd, keyEnter, keyEscape, keyHome, keySpace, keyTab, uniqueId } from "@microsoft/fast-web-utilities";
+//#region src/shared/foundation/listbox/listbox.ts
+var Listbox = class Listbox extends VividElement {
+	constructor(..._args) {
+		super(..._args);
+		this._options = [];
+		this.selectedIndex = -1;
+		this.selectedOptions = [];
+		this.shouldSkipFocus = false;
+		this.typeaheadBuffer = "";
+		this.typeaheadExpired = true;
+		this.typeaheadTimeout = -1;
+		this._activeDescendant = null;
+	}
+	/**
+	* The first selected option.
+	*
+	* @internal
+	*/
+	get firstSelectedOption() {
+		return this.selectedOptions[0] ?? null;
+	}
+	/**
+	* The number of options.
+	*
+	* @public
+	*/
+	get length() {
+		return this.options.length;
+	}
+	/**
+	* The list of options.
+	*
+	* @public
+	*/
+	get options() {
+		Observable.track(this, "options");
+		return this._options;
+	}
+	set options(value) {
+		const prev = this._options;
+		this._options = value;
+		Observable.notify(this, "options");
+		if (this.$fastController.isConnected) {
+			const newSelectedIndex = this._newDefaultSelectedIndex(prev, value, this.selectedIndex);
+			if (newSelectedIndex !== null) this.selectedIndex = newSelectedIndex;
+		}
+	}
+	static {
+		this.slottedOptionFilter = (n) => isListboxOption(n) && !n.hidden;
+	}
+	static {
+		this.TYPE_AHEAD_TIMEOUT_MS = 1e3;
+	}
+	/**
+	* Handle click events for listbox options.
+	*
+	* @internal
+	*/
+	clickHandler(e) {
+		const captured = e.target.closest(`option,[role=option],[data-vvd-component=option]`);
+		if (captured && !captured.disabled) {
+			this.selectedIndex = this.options.indexOf(captured);
+			return true;
+		}
+	}
+	/**
+	* Ensures that the provided option is focused and scrolled into view.
+	*
+	* @param optionToFocus - The option to focus
+	* @internal
+	*/
+	focusAndScrollOptionIntoView(optionToFocus = this.firstSelectedOption) {
+		if (this.contains(document.activeElement) && optionToFocus !== null) {
+			optionToFocus.focus();
+			requestAnimationFrame(() => {
+				optionToFocus.scrollIntoView({ block: "nearest" });
+			});
+		}
+	}
+	/**
+	* Handles `focusin` actions for the component. When the component receives focus,
+	* the list of selected options is refreshed and the first selected option is scrolled
+	* into view.
+	*
+	* @internal
+	*/
+	focusinHandler(e) {
+		if (!this.shouldSkipFocus && e.target === e.currentTarget) {
+			this.setSelectedOptions();
+			this.focusAndScrollOptionIntoView();
+		}
+		this.shouldSkipFocus = false;
+	}
+	/**
+	* Returns the options which match the current typeahead buffer.
+	*
+	* @internal
+	*/
+	getTypeaheadMatches() {
+		const pattern = this.typeaheadBuffer.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+		const re = new RegExp(`^${pattern}`, "gi");
+		return this.options.filter((o) => o.text.trim().match(re));
+	}
+	/**
+	* Finds the index of the next non-disabled option starting from the given index.
+	*
+	* @param fromIndex - The index to start searching from (inclusive)
+	* @returns The index of the next selectable option, or -1 if none found
+	* @internal
+	*/
+	getNextSelectableIndex(fromIndex) {
+		const nextSelectableOption = this.options.reduce((nextSelectableOption, thisOption, index) => !nextSelectableOption && !thisOption.disabled && index >= fromIndex ? thisOption : nextSelectableOption, null);
+		return this.options.indexOf(nextSelectableOption);
+	}
+	/**
+	* Finds the index of the previous non-disabled option starting from the given index.
+	*
+	* @param fromIndex - The index to start searching from (inclusive)
+	* @returns The index of the previous selectable option, or -1 if none found
+	* @internal
+	*/
+	getPreviousSelectableIndex(fromIndex) {
+		const previousSelectableOption = this.options.reduceRight((previousSelectableOption, thisOption, index) => !previousSelectableOption && !thisOption.disabled && index <= fromIndex ? thisOption : previousSelectableOption, null);
+		return this.options.indexOf(previousSelectableOption);
+	}
+	/**
+	* Handles external changes to child options.
+	*
+	* @param source - the source object
+	* @param propertyName - the property
+	*
+	* @internal
+	*/
+	handleChange(source, propertyName) {
+		switch (propertyName) {
+			case "selected":
+				/* v8 ignore else -- @preserve */
+				if (Listbox.slottedOptionFilter(source)) this.selectedIndex = this.options.indexOf(source);
+				this.setSelectedOptions();
+				break;
+		}
+	}
+	/**
+	* Moves focus to an option whose label matches characters typed by the user.
+	* Consecutive keystrokes are batched into a buffer of search text used
+	* to match against the set of options.  If `TYPE_AHEAD_TIMEOUT_MS` passes
+	* between consecutive keystrokes, the search restarts.
+	*
+	* @param key - the key to be evaluated
+	*
+	* @internal
+	*/
+	handleTypeAhead(key) {
+		/* v8 ignore else -- @preserve */
+		if (this.typeaheadTimeout) window.clearTimeout(this.typeaheadTimeout);
+		this.typeaheadTimeout = window.setTimeout(() => this.typeaheadExpired = true, Listbox.TYPE_AHEAD_TIMEOUT_MS);
+		this.typeaheadBuffer = `${this.typeaheadExpired ? "" : this.typeaheadBuffer}${key}`;
+	}
+	/**
+	* Handles `keydown` actions for listbox navigation and typeahead.
+	*
+	* @internal
+	*/
+	keydownHandler(e) {
+		if (this.disabled) return true;
+		this.shouldSkipFocus = false;
+		const key = e.key;
+		switch (key) {
+			case keyHome:
+				/* v8 ignore else -- @preserve */
+				if (!e.shiftKey) {
+					e.preventDefault();
+					this.selectFirstOption();
+				}
+				break;
+			case keyArrowDown:
+				/* v8 ignore else -- @preserve */
+				if (!e.shiftKey) {
+					e.preventDefault();
+					this.selectNextOption();
+				}
+				break;
+			case keyArrowUp:
+				/* v8 ignore else -- @preserve */
+				if (!e.shiftKey) {
+					e.preventDefault();
+					this.selectPreviousOption();
+				}
+				break;
+			case keyEnd:
+				e.preventDefault();
+				this.selectLastOption();
+				break;
+			case keyTab:
+				this.focusAndScrollOptionIntoView();
+				return true;
+			case keyEnter:
+			case keyEscape: return true;
+			case keySpace:
+ /* v8 ignore else -- @preserve */
+			if (this.typeaheadExpired) return true;
+			default:
+				/* v8 ignore else -- @preserve */
+				if (key.length === 1) this.handleTypeAhead(`${key}`);
+				return true;
+		}
+	}
+	/**
+	* Prevents `focusin` events from firing before `click` events when the
+	* element is unfocused.
+	*
+	* @internal
+	*/
+	mousedownHandler(_) {
+		this.shouldSkipFocus = !this.contains(document.activeElement);
+		return true;
+	}
+	/**
+	* Updates the list of selected options when the `selectedIndex` changes.
+	*
+	* @param prev - the previous selected index value
+	* @param next - the current selected index value
+	*
+	* @internal
+	*/
+	selectedIndexChanged(prev, next) {
+		const validNext = this._validSelectedIndex(next);
+		if (next !== validNext) {
+			this.selectedIndex = validNext;
+			return;
+		}
+		this.setSelectedOptions();
+	}
+	_validSelectedIndex(index) {
+		return index > this.options.length - 1 || index < -1 ? -1 : index;
+	}
+	/**
+	* Updates the selectedness of each option when the list of selected options changes.
+	*
+	* @internal
+	*/
+	selectedOptionsChanged(_, next) {
+		const filteredNext = next.filter(Listbox.slottedOptionFilter);
+		this.options.forEach((o) => {
+			const notifier = Observable.getNotifier(o);
+			notifier.unsubscribe(this, "selected");
+			o.selected = filteredNext.includes(o);
+			notifier.subscribe(this, "selected");
+		});
+	}
+	/**
+	* Moves focus to the first selectable option.
+	*
+	* @public
+	*/
+	selectFirstOption() {
+		/* v8 ignore else -- @preserve */
+		if (!this.disabled) this.selectedIndex = this.options.findIndex((o) => !o.disabled);
+	}
+	/**
+	* Moves focus to the last selectable option.
+	*
+	* @internal
+	*/
+	selectLastOption() {
+		/* v8 ignore else -- @preserve */
+		if (!this.disabled) this.selectedIndex = findLastIndex(this.options, (o) => !o.disabled);
+	}
+	/**
+	* Moves focus to the next selectable option.
+	*
+	* @internal
+	*/
+	selectNextOption() {
+		/* v8 ignore else -- @preserve */
+		if (!this.disabled && this.selectedIndex < this.options.length - 1) {
+			const nextIndex = this.getNextSelectableIndex(this.selectedIndex + 1);
+			if (nextIndex !== -1) this.selectedIndex = nextIndex;
+		}
+	}
+	/**
+	* Moves focus to the previous selectable option.
+	*
+	* @internal
+	*/
+	selectPreviousOption() {
+		/* v8 ignore else -- @preserve */
+		if (!this.disabled && this.selectedIndex > 0) {
+			const prevIndex = this.getPreviousSelectableIndex(this.selectedIndex - 1);
+			if (prevIndex !== -1) this.selectedIndex = prevIndex;
+		}
+	}
+	_newDefaultSelectedIndex(prev, next, currentSelectedIndex) {
+		for (const [index, newOption] of next.entries()) if (this._isDefaultSelected(newOption) && !prev.includes(newOption)) return index;
+		return null;
+	}
+	_isDefaultSelected(option) {
+		return option.defaultSelected;
+	}
+	/**
+	* Sets an option as selected and gives it focus.
+	*
+	* @public
+	*/
+	setSelectedOptions() {
+		this.selectedOptions = this.selectedIndex !== -1 ? [this.options[this.selectedIndex]] : [];
+		this._activeDescendant = this.firstSelectedOption?.id ?? "";
+		this.focusAndScrollOptionIntoView();
+	}
+	/**
+	* Updates the list of options and resets the selected option when the slotted option content changes.
+	*
+	* @internal
+	*/
+	slottedOptionsChanged(_, next) {
+		this.options = next.reduce((options, item) => {
+			/* v8 ignore else -- @preserve */
+			if (isListboxOption(item)) options.push(item);
+			return options;
+		}, []);
+		const setSize = `${this.options.length}`;
+		this.options.forEach((option, index) => {
+			if (!option.id) option.id = uniqueId("option-");
+			option.ariaPosInSet = `${index + 1}`;
+			option.ariaSetSize = setSize;
+		});
+	}
+	/**
+	* Updates the filtered list of options when the typeahead buffer changes.
+	*
+	* @internal
+	*/
+	typeaheadBufferChanged(_prev, _next) {
+		if (this.$fastController.isConnected) {
+			const typeaheadMatches = this.getTypeaheadMatches();
+			/* v8 ignore else -- @preserve */
+			if (typeaheadMatches.length) {
+				const selectedIndex = this.options.indexOf(typeaheadMatches[0]);
+				/* v8 ignore else -- @preserve */
+				if (selectedIndex > -1) this.selectedIndex = selectedIndex;
+			}
+			this.typeaheadExpired = false;
+		}
+	}
 };
-const _Listbox = class _Listbox extends VividElement {
-  constructor() {
-    super(...arguments);
-    /**
-     * The internal unfiltered list of selectable options.
-     *
-     * @internal
-     */
-    this._options = [];
-    this.selectedIndex = -1;
-    this.selectedOptions = [];
-    /**
-     * A standard `click` event creates a `focus` event before firing, so a
-     * `mousedown` event is used to skip that initial focus.
-     *
-     * @internal
-     */
-    this.shouldSkipFocus = false;
-    this.typeaheadBuffer = "";
-    /**
-     * Flag for the typeahead timeout expiration.
-     *
-     * @internal
-     */
-    this.typeaheadExpired = true;
-    /**
-     * The timeout ID for the typeahead handler.
-     *
-     * @internal
-     */
-    this.typeaheadTimeout = -1;
-    this._activeDescendant = null;
-  }
-  /**
-   * The first selected option.
-   *
-   * @internal
-   */
-  get firstSelectedOption() {
-    return this.selectedOptions[0] ?? null;
-  }
-  /**
-   * The number of options.
-   *
-   * @public
-   */
-  get length() {
-    return this.options.length;
-  }
-  /**
-   * The list of options.
-   *
-   * @public
-   */
-  get options() {
-    Observable.track(this, "options");
-    return this._options;
-  }
-  set options(value) {
-    const prev = this._options;
-    this._options = value;
-    Observable.notify(this, "options");
-    if (this.$fastController.isConnected) {
-      const newSelectedIndex = this._newDefaultSelectedIndex(
-        prev,
-        value,
-        this.selectedIndex
-      );
-      if (newSelectedIndex !== null) {
-        this.selectedIndex = newSelectedIndex;
-      }
-    }
-  }
-  static {
-    /**
-     * A static filter to include only selectable options.
-     *
-     * @param n - element to filter
-     * @public
-     */
-    this.slottedOptionFilter = (n) => isListboxOption(n) && !n.hidden;
-  }
-  static {
-    /**
-     * Typeahead timeout in milliseconds.
-     *
-     * @internal
-     */
-    this.TYPE_AHEAD_TIMEOUT_MS = 1e3;
-  }
-  /**
-   * Handle click events for listbox options.
-   *
-   * @internal
-   */
-  clickHandler(e) {
-    const captured = e.target.closest(
-      `option,[role=option],[data-vvd-component=option]`
-    );
-    if (captured && !captured.disabled) {
-      this.selectedIndex = this.options.indexOf(captured);
-      return true;
-    }
-  }
-  /**
-   * Ensures that the provided option is focused and scrolled into view.
-   *
-   * @param optionToFocus - The option to focus
-   * @internal
-   */
-  focusAndScrollOptionIntoView(optionToFocus = this.firstSelectedOption) {
-    if (this.contains(document.activeElement) && optionToFocus !== null) {
-      optionToFocus.focus();
-      requestAnimationFrame(() => {
-        optionToFocus.scrollIntoView({ block: "nearest" });
-      });
-    }
-  }
-  /**
-   * Handles `focusin` actions for the component. When the component receives focus,
-   * the list of selected options is refreshed and the first selected option is scrolled
-   * into view.
-   *
-   * @internal
-   */
-  focusinHandler(e) {
-    if (!this.shouldSkipFocus && e.target === e.currentTarget) {
-      this.setSelectedOptions();
-      this.focusAndScrollOptionIntoView();
-    }
-    this.shouldSkipFocus = false;
-  }
-  /**
-   * Returns the options which match the current typeahead buffer.
-   *
-   * @internal
-   */
-  getTypeaheadMatches() {
-    const pattern = this.typeaheadBuffer.replace(
-      /[.*+\-?^${}()|[\]\\]/g,
-      "\\$&"
-    );
-    const re = new RegExp(`^${pattern}`, "gi");
-    return this.options.filter((o) => o.text.trim().match(re));
-  }
-  /**
-   * Finds the index of the next non-disabled option starting from the given index.
-   *
-   * @param fromIndex - The index to start searching from (inclusive)
-   * @returns The index of the next selectable option, or -1 if none found
-   * @internal
-   */
-  getNextSelectableIndex(fromIndex) {
-    const nextSelectableOption = this.options.reduce(
-      (nextSelectableOption2, thisOption, index) => !nextSelectableOption2 && !thisOption.disabled && index >= fromIndex ? thisOption : nextSelectableOption2,
-      null
-    );
-    return this.options.indexOf(nextSelectableOption);
-  }
-  /**
-   * Finds the index of the previous non-disabled option starting from the given index.
-   *
-   * @param fromIndex - The index to start searching from (inclusive)
-   * @returns The index of the previous selectable option, or -1 if none found
-   * @internal
-   */
-  getPreviousSelectableIndex(fromIndex) {
-    const previousSelectableOption = this.options.reduceRight(
-      (previousSelectableOption2, thisOption, index) => !previousSelectableOption2 && !thisOption.disabled && index <= fromIndex ? thisOption : previousSelectableOption2,
-      null
-    );
-    return this.options.indexOf(previousSelectableOption);
-  }
-  /**
-   * Handles external changes to child options.
-   *
-   * @param source - the source object
-   * @param propertyName - the property
-   *
-   * @internal
-   */
-  handleChange(source, propertyName) {
-    switch (propertyName) {
-      case "selected": {
-        if (_Listbox.slottedOptionFilter(source)) {
-          this.selectedIndex = this.options.indexOf(source);
-        }
-        this.setSelectedOptions();
-        break;
-      }
-    }
-  }
-  /**
-   * Moves focus to an option whose label matches characters typed by the user.
-   * Consecutive keystrokes are batched into a buffer of search text used
-   * to match against the set of options.  If `TYPE_AHEAD_TIMEOUT_MS` passes
-   * between consecutive keystrokes, the search restarts.
-   *
-   * @param key - the key to be evaluated
-   *
-   * @internal
-   */
-  handleTypeAhead(key) {
-    if (this.typeaheadTimeout) {
-      window.clearTimeout(this.typeaheadTimeout);
-    }
-    this.typeaheadTimeout = window.setTimeout(
-      () => this.typeaheadExpired = true,
-      _Listbox.TYPE_AHEAD_TIMEOUT_MS
-    );
-    this.typeaheadBuffer = `${this.typeaheadExpired ? "" : this.typeaheadBuffer}${key}`;
-  }
-  /**
-   * Handles `keydown` actions for listbox navigation and typeahead.
-   *
-   * @internal
-   */
-  keydownHandler(e) {
-    if (this.disabled) {
-      return true;
-    }
-    this.shouldSkipFocus = false;
-    const key = e.key;
-    switch (key) {
-      // Select the first available option
-      case keyHome: {
-        if (!e.shiftKey) {
-          e.preventDefault();
-          this.selectFirstOption();
-        }
-        break;
-      }
-      // Select the next selectable option
-      case keyArrowDown: {
-        if (!e.shiftKey) {
-          e.preventDefault();
-          this.selectNextOption();
-        }
-        break;
-      }
-      // Select the previous selectable option
-      case keyArrowUp: {
-        if (!e.shiftKey) {
-          e.preventDefault();
-          this.selectPreviousOption();
-        }
-        break;
-      }
-      // Select the last available option
-      case keyEnd: {
-        e.preventDefault();
-        this.selectLastOption();
-        break;
-      }
-      case keyTab: {
-        this.focusAndScrollOptionIntoView();
-        return true;
-      }
-      case keyEnter:
-      case keyEscape:
-        return true;
-      // @ts-expect-error - fallthrough case
-      case keySpace: {
-        if (this.typeaheadExpired) {
-          return true;
-        }
-      }
-      // fallthrough:
-      default: {
-        if (key.length === 1) {
-          this.handleTypeAhead(`${key}`);
-        }
-        return true;
-      }
-    }
-  }
-  /**
-   * Prevents `focusin` events from firing before `click` events when the
-   * element is unfocused.
-   *
-   * @internal
-   */
-  mousedownHandler(_) {
-    this.shouldSkipFocus = !this.contains(document.activeElement);
-    return true;
-  }
-  /**
-   * Updates the list of selected options when the `selectedIndex` changes.
-   *
-   * @param prev - the previous selected index value
-   * @param next - the current selected index value
-   *
-   * @internal
-   */
-  selectedIndexChanged(prev, next) {
-    const validNext = this._validSelectedIndex(next);
-    if (next !== validNext) {
-      this.selectedIndex = validNext;
-      return;
-    }
-    this.setSelectedOptions();
-  }
-  _validSelectedIndex(index) {
-    const outOfRange = index > this.options.length - 1 || index < -1;
-    return outOfRange ? -1 : index;
-  }
-  /**
-   * Updates the selectedness of each option when the list of selected options changes.
-   *
-   * @internal
-   */
-  selectedOptionsChanged(_, next) {
-    const filteredNext = next.filter(_Listbox.slottedOptionFilter);
-    this.options.forEach((o) => {
-      const notifier = Observable.getNotifier(o);
-      notifier.unsubscribe(this, "selected");
-      o.selected = filteredNext.includes(o);
-      notifier.subscribe(this, "selected");
-    });
-  }
-  /**
-   * Moves focus to the first selectable option.
-   *
-   * @public
-   */
-  selectFirstOption() {
-    if (!this.disabled) {
-      this.selectedIndex = this.options.findIndex((o) => !o.disabled);
-    }
-  }
-  /**
-   * Moves focus to the last selectable option.
-   *
-   * @internal
-   */
-  selectLastOption() {
-    if (!this.disabled) {
-      this.selectedIndex = findLastIndex(this.options, (o) => !o.disabled);
-    }
-  }
-  /**
-   * Moves focus to the next selectable option.
-   *
-   * @internal
-   */
-  selectNextOption() {
-    if (!this.disabled && this.selectedIndex < this.options.length - 1) {
-      const nextIndex = this.getNextSelectableIndex(this.selectedIndex + 1);
-      if (nextIndex !== -1) {
-        this.selectedIndex = nextIndex;
-      }
-    }
-  }
-  /**
-   * Moves focus to the previous selectable option.
-   *
-   * @internal
-   */
-  selectPreviousOption() {
-    if (!this.disabled && this.selectedIndex > 0) {
-      const prevIndex = this.getPreviousSelectableIndex(this.selectedIndex - 1);
-      if (prevIndex !== -1) {
-        this.selectedIndex = prevIndex;
-      }
-    }
-  }
-  /// For this options change, determine if selectedIndex should change based on defaultSelected. Otherwise, returns null.
-  _newDefaultSelectedIndex(prev, next, currentSelectedIndex) {
-    for (const [index, newOption] of next.entries()) {
-      if (this._isDefaultSelected(newOption) && !prev.includes(newOption)) {
-        return index;
-      }
-    }
-    return null;
-  }
-  /// Whether an option should be considered defaultSelected
-  _isDefaultSelected(option) {
-    return option.defaultSelected;
-  }
-  /**
-   * Sets an option as selected and gives it focus.
-   *
-   * @public
-   */
-  setSelectedOptions() {
-    this.selectedOptions = this.selectedIndex !== -1 ? [this.options[this.selectedIndex]] : [];
-    this._activeDescendant = this.firstSelectedOption?.id ?? "";
-    this.focusAndScrollOptionIntoView();
-  }
-  /**
-   * Updates the list of options and resets the selected option when the slotted option content changes.
-   *
-   * @internal
-   */
-  slottedOptionsChanged(_, next) {
-    this.options = next.reduce((options, item) => {
-      if (isListboxOption(item)) {
-        options.push(item);
-      }
-      return options;
-    }, []);
-    const setSize = `${this.options.length}`;
-    this.options.forEach((option, index) => {
-      if (!option.id) {
-        option.id = uniqueId("option-");
-      }
-      option.ariaPosInSet = `${index + 1}`;
-      option.ariaSetSize = setSize;
-    });
-  }
-  /**
-   * Updates the filtered list of options when the typeahead buffer changes.
-   *
-   * @internal
-   */
-  typeaheadBufferChanged(_prev, _next) {
-    if (this.$fastController.isConnected) {
-      const typeaheadMatches = this.getTypeaheadMatches();
-      if (typeaheadMatches.length) {
-        const selectedIndex = this.options.indexOf(typeaheadMatches[0]);
-        if (selectedIndex > -1) {
-          this.selectedIndex = selectedIndex;
-        }
-      }
-      this.typeaheadExpired = false;
-    }
-  }
-};
-// @ts-expect-error Type is incorrectly non-optional
-__decorateClass([
-  attr({ mode: "boolean" })
-], _Listbox.prototype, "disabled");
-__decorateClass([
-  observable
-], _Listbox.prototype, "selectedIndex");
-__decorateClass([
-  observable
-], _Listbox.prototype, "selectedOptions");
-__decorateClass([
-  observable
-], _Listbox.prototype, "slottedOptions");
-__decorateClass([
-  observable
-], _Listbox.prototype, "typeaheadBuffer");
-__decorateClass([
-  observable
-], _Listbox.prototype, "_activeDescendant");
-let Listbox = _Listbox;
-
-export { Listbox as L };
+__decorate([attr({ mode: "boolean" })], Listbox.prototype, "disabled", void 0);
+__decorate([observable], Listbox.prototype, "selectedIndex", void 0);
+__decorate([observable], Listbox.prototype, "selectedOptions", void 0);
+__decorate([observable], Listbox.prototype, "slottedOptions", void 0);
+__decorate([observable], Listbox.prototype, "typeaheadBuffer", void 0);
+__decorate([observable], Listbox.prototype, "_activeDescendant", void 0);
+//#endregion
+export { Listbox as t };