@tylertech/forge 2.0.0 → 2.1.0

package/dist/esm/chunks/chunk.NRI7SWVX.js

@@ -0,0 +1,1347 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import {
+  TextFieldComponent
+} from "./chunk.YCW56AVX.js";
+import {
+  TEXT_FIELD_CONSTANTS,
+  TextFieldComponentDelegate
+} from "./chunk.Q4YMHFRY.js";
+import {
+  DividerComponent
+} from "./chunk.WAJDLUSQ.js";
+import {
+  CHIP_FIELD_CONSTANTS
+} from "./chunk.EARNUKJ2.js";
+import {
+  ListDropdownAware
+} from "./chunk.ST3R6JEE.js";
+import {
+  ListDropdown,
+  ListDropdownAwareFoundation
+} from "./chunk.D4XU5MZN.js";
+import {
+  SkeletonComponent
+} from "./chunk.EL6B2ODN.js";
+import {
+  ListComponent
+} from "./chunk.4UKSUUTX.js";
+import {
+  ListItemComponent
+} from "./chunk.G6FY472A.js";
+import {
+  LinearProgressComponent
+} from "./chunk.RNPIV3BY.js";
+import {
+  POPUP_CONSTANTS,
+  PopupComponent
+} from "./chunk.5EEEKOOK.js";
+import {
+  tylIconCheckBox,
+  tylIconCheckBoxOutlineBlank
+} from "./chunk.GS2AXUCN.js";
+import {
+  Platform
+} from "./chunk.BYN27JXZ.js";
+import {
+  IconComponent,
+  IconComponentDelegate,
+  IconRegistry
+} from "./chunk.P43Z3YAS.js";
+import {
+  FormFieldComponentDelegate
+} from "./chunk.HZISALRH.js";
+import {
+  highlightTextHTML
+} from "./chunk.52F6VUCF.js";
+import {
+  BaseAdapter
+} from "./chunk.KZATVOA6.js";
+import {
+  FoundationProperty
+} from "./chunk.MMIZOYAS.js";
+import {
+  COMPONENT_NAME_PREFIX,
+  CustomElement,
+  KEYSTROKE_DEBOUNCE_THRESHOLD
+} from "./chunk.35U3UPDV.js";
+import {
+  attachShadowTemplate,
+  defineCustomElement,
+  getShadowElement
+} from "./chunk.K2PCTUVN.js";
+import {
+  deepQuerySelectorAll,
+  ensureChild,
+  getActiveElement,
+  toggleAttribute
+} from "./chunk.4JURZYE4.js";
+import {
+  coerceBoolean,
+  coerceNumber,
+  debounce,
+  isDeepEqual,
+  isDefined,
+  isObject,
+  isString,
+  randomChars
+} from "./chunk.MEFT5FQC.js";
+import {
+  __decorateClass,
+  __spreadValues
+} from "./chunk.LM5TVNZY.js";
+
+// dist/build/lib/staging/src/autocomplete/autocomplete-constants.ts
+var elementName = `${COMPONENT_NAME_PREFIX}autocomplete`;
+var attributes = {
+  MODE: "mode",
+  MULTIPLE: "multiple",
+  DEBOUNCE: "debounce",
+  FILTER_ON_FOCUS: "filter-on-focus",
+  ALLOW_UNMATCHED: "allow-unmatched",
+  POPUP_TARGET: "popup-target",
+  POPUP_CLASSES: "popup-classes",
+  OPTION_LIMIT: "option-limit",
+  OBSERVE_SCROLL: "observe-scroll",
+  OBSERVE_SCROLL_THRESHOLD: "observe-scroll-threshold",
+  SYNC_POPUP_WIDTH: "sync-popup-width",
+  OPEN: "open",
+  MATCH_KEY: "match-key",
+  DROPDOWN_ICON_OPEN: "data-forge-dropdown-icon-open"
+};
+var selectors = {
+  INPUT: "input,textarea",
+  DROPDOWN_ICON: "[data-forge-dropdown-icon],[data-forge-dropdown-icon],[forge-dropdown-icon],.forge-dropdown-icon",
+  CLEAR_BUTTON: "[data-forge-autocomplete-clear],[forge-autocomplete-clear]"
+};
+var numbers = {
+  DEFAULT_DEBOUNCE_TIME: KEYSTROKE_DEBOUNCE_THRESHOLD,
+  NUM_SKELETON_ITEMS: 3
+};
+var events = {
+  CHANGE: `${elementName}-change`,
+  SELECT: `${elementName}-select`,
+  SCROLLED_BOTTOM: `${elementName}-scrolled-bottom`
+};
+var AUTOCOMPLETE_CONSTANTS = {
+  elementName,
+  attributes,
+  selectors,
+  numbers,
+  events
+};
+var AutocompleteMode = /* @__PURE__ */ ((AutocompleteMode3) => {
+  AutocompleteMode3["Default"] = "default";
+  AutocompleteMode3["Stateless"] = "stateless";
+  return AutocompleteMode3;
+})(AutocompleteMode || {});
+
+// dist/build/lib/staging/src/autocomplete/autocomplete-adapter.ts
+var AutocompleteAdapter = class extends BaseAdapter {
+  constructor(component) {
+    super(component);
+    this.setInputElement();
+  }
+  setInputElement() {
+    const inputElements = deepQuerySelectorAll(this._component, AUTOCOMPLETE_CONSTANTS.selectors.INPUT, false);
+    if (inputElements.length) {
+      this._inputElement = inputElements[0];
+    }
+    return this._inputElement;
+  }
+  setInputAttribute(name, value) {
+    this._inputElement.setAttribute(name, value);
+  }
+  addInputListener(type, listener) {
+    this._inputElement.addEventListener(type, listener);
+  }
+  removeInputListener(type, listener) {
+    this._inputElement.removeEventListener(type, listener);
+  }
+  intializeInputAccessibility(identifier) {
+    this._inputElement.setAttribute("autocomplete", "off");
+    this._inputElement.setAttribute("role", "combobox");
+    this._inputElement.setAttribute("aria-live", "polite");
+    this._inputElement.setAttribute("aria-atomic", "true");
+    this._inputElement.setAttribute("aria-haspopup", "true");
+    this._inputElement.setAttribute("aria-expanded", "false");
+    this._inputElement.setAttribute("aria-autocomplete", "list");
+  }
+  isWrappingChipField() {
+    return !!this._component.querySelector(CHIP_FIELD_CONSTANTS.elementName);
+  }
+  show(config, popupTarget) {
+    this._targetElement = this._getTargetElement(popupTarget);
+    if (!this._targetElement) {
+      return;
+    }
+    this._listDropdown = new ListDropdown(this._targetElement, config);
+    this._listDropdown.open();
+    this._inputElement.setAttribute("aria-expanded", "true");
+    this._inputElement.setAttribute("aria-controls", `list-dropdown-popup-${config.id}`);
+    this._tryToggleDropdownIconRotation(true);
+  }
+  hide(listener) {
+    if (!this._listDropdown) {
+      return;
+    }
+    const { targetElement } = this._listDropdown.dropdownElement;
+    targetElement.removeEventListener(POPUP_CONSTANTS.events.BLUR, listener);
+    this.setBusyVisibility(false);
+    this._tryToggleDropdownIconRotation(false);
+    this._inputElement.removeAttribute("aria-activedescendant");
+    this._inputElement.removeAttribute("aria-controls");
+    this._inputElement.setAttribute("aria-expanded", "false");
+    this._listDropdown.close();
+    this._listDropdown = void 0;
+  }
+  setBusyVisibility(isVisible) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.setBusyVisibility(isVisible);
+  }
+  toggleOptionMultiple(index, selected) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.toggleOptionMultiple(index, selected);
+  }
+  setDismissListener(listener) {
+    if (!this._listDropdown || !this._listDropdown.dropdownElement) {
+      return;
+    }
+    const dropdownElement = this._listDropdown.dropdownElement;
+    if (dropdownElement.targetElement) {
+      dropdownElement.targetElement.addEventListener(POPUP_CONSTANTS.events.BLUR, listener);
+    }
+  }
+  focus() {
+    window.requestAnimationFrame(() => this._inputElement.focus());
+  }
+  setOptions(options) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.setOptions(options);
+  }
+  appendOptions(options) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.appendOptions(options);
+  }
+  setSelectedText(value) {
+    this._inputElement.value = value;
+  }
+  getInputValue() {
+    return this._inputElement.value;
+  }
+  selectInputValue() {
+    window.requestAnimationFrame(() => this._inputElement.select());
+  }
+  isFocusWithinPopup(target) {
+    if (!this._listDropdown || !this._listDropdown.dropdownElement) {
+      return false;
+    }
+    return this._listDropdown.dropdownElement.contains(target);
+  }
+  hasFocus() {
+    const activeElement = getActiveElement();
+    return activeElement === this._inputElement || this.isFocusWithinPopup(activeElement);
+  }
+  hasInputElement() {
+    return !!this._inputElement;
+  }
+  setDropdownIconListener(type, listener) {
+    window.requestAnimationFrame(() => {
+      const dropdownIcon = this._component.querySelector(AUTOCOMPLETE_CONSTANTS.selectors.DROPDOWN_ICON);
+      if (dropdownIcon) {
+        dropdownIcon.addEventListener(type, listener);
+      }
+    });
+  }
+  removeDropdownIconListener(type, listener) {
+    const dropdownIcon = this._component.querySelector(AUTOCOMPLETE_CONSTANTS.selectors.DROPDOWN_ICON);
+    if (dropdownIcon) {
+      dropdownIcon.removeEventListener(type, listener);
+    }
+  }
+  setClearButtonListener(type, listener) {
+    window.requestAnimationFrame(() => {
+      const clearButton = this._component.querySelector(AUTOCOMPLETE_CONSTANTS.selectors.CLEAR_BUTTON);
+      if (clearButton) {
+        clearButton.addEventListener(type, listener);
+      }
+    });
+  }
+  removeClearButtonListener(type, listener) {
+    const clearButton = this._component.querySelector(AUTOCOMPLETE_CONSTANTS.selectors.CLEAR_BUTTON);
+    if (clearButton) {
+      clearButton.removeEventListener(type, listener);
+    }
+  }
+  propagateKey(key) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.handleKey(key);
+  }
+  updateActiveDescendant(id) {
+    if (!this._targetElement) {
+      return;
+    }
+    toggleAttribute(this._inputElement, !!id, "aria-activedescendant", id);
+  }
+  getTargetElementWidth(selector) {
+    if (!this._targetElement) {
+      this._targetElement = this._getTargetElement(selector);
+    }
+    return this._targetElement.getBoundingClientRect().width;
+  }
+  getPopupElement() {
+    var _a, _b;
+    return (_b = (_a = this._listDropdown) == null ? void 0 : _a.dropdownElement) != null ? _b : null;
+  }
+  activateFirstOption() {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.activateFirstOption();
+  }
+  activateOptionByIndex(value) {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.activateOption(value);
+  }
+  getActiveOptionIndex() {
+    var _a, _b;
+    return (_b = (_a = this._listDropdown) == null ? void 0 : _a.getActiveOptionIndex()) != null ? _b : null;
+  }
+  clearActiveOption() {
+    var _a;
+    (_a = this._listDropdown) == null ? void 0 : _a.clearActiveOption();
+  }
+  setSelectedOptions(options) {
+    if (this._listDropdown) {
+      const values = options.map((o) => o.value);
+      this._listDropdown.setSelectedValues(values);
+    }
+  }
+  _getTargetElement(selector) {
+    return selector ? this._component.querySelector(selector) || this._getDefaultTargetElement() : this._getDefaultTargetElement();
+  }
+  _getDefaultTargetElement() {
+    const textField = this._component.querySelector("forge-text-field");
+    if (textField && textField.shadowRoot) {
+      const textFieldRoot = getShadowElement(textField, TEXT_FIELD_CONSTANTS.selectors.ROOT);
+      if (textFieldRoot) {
+        return textFieldRoot;
+      }
+    }
+    const chipField = this._component.querySelector("forge-chip-field");
+    if (chipField && chipField.shadowRoot) {
+      const chipFieldRoot = getShadowElement(chipField, CHIP_FIELD_CONSTANTS.selectors.ROOT);
+      if (chipFieldRoot) {
+        return chipFieldRoot;
+      }
+    }
+    return this._component.querySelector("input") || this._component;
+  }
+  _tryToggleDropdownIconRotation(state) {
+    const dropdownIcon = this._component.querySelector(AUTOCOMPLETE_CONSTANTS.selectors.DROPDOWN_ICON);
+    if (dropdownIcon) {
+      toggleAttribute(dropdownIcon, state, AUTOCOMPLETE_CONSTANTS.attributes.DROPDOWN_ICON_OPEN);
+    }
+  }
+};
+
+// dist/build/lib/staging/src/autocomplete/autocomplete-utils.ts
+var OptionType = /* @__PURE__ */ ((OptionType2) => {
+  OptionType2[OptionType2["Option"] = 0] = "Option";
+  OptionType2[OptionType2["Group"] = 1] = "Group";
+  return OptionType2;
+})(OptionType || {});
+function isOptionType(options, type) {
+  const isOptionGroups = options.some((o) => isDefined(o) && isObject(o) && o.hasOwnProperty("options") && (o.hasOwnProperty("text") || o.hasOwnProperty("builder")));
+  const isOptionTypes = options.some((o) => isDefined(o) && isObject(o) && o.hasOwnProperty("label") && o.hasOwnProperty("value"));
+  return isOptionGroups && type === 1 /* Group */ || isOptionTypes && type === 0 /* Option */;
+}
+function getSelectedOption(options, value) {
+  return options.find((o) => o.value === value);
+}
+function optionEqualPredicate(option, value, property = null) {
+  if (property) {
+    if (!(property in option.value) || !(property in value)) {
+      return false;
+    }
+    return isDeepEqual(option.value[property], value[property]);
+  }
+  return isDeepEqual(option.value, value);
+}
+
+// dist/build/lib/staging/src/autocomplete/autocomplete-foundation.ts
+var AutocompleteFoundation = class extends ListDropdownAwareFoundation {
+  constructor(_adapter) {
+    super();
+    this._adapter = _adapter;
+    this._isInitialized = false;
+    this._isDropdownOpen = false;
+    this._mode = "default" /* Default */;
+    this._multiple = false;
+    this._debounce = AUTOCOMPLETE_CONSTANTS.numbers.DEFAULT_DEBOUNCE_TIME;
+    this._allowUnmatched = false;
+    this._filterOnFocus = true;
+    this._options = [];
+    this._filterText = "";
+    this._selectedOptions = [];
+    this._values = [];
+    this._pendingFilterPromises = [];
+    this._matchKey = null;
+    this._clickListener = (evt) => this._onClick(evt);
+    this._focusListener = () => this._onFocus();
+    this._blurListener = (evt) => this._onBlur(evt);
+    this._keydownListener = (evt) => this._onKeydown(evt);
+    this._dropdownIconClickListener = (evt) => this._onDropdownIconClick(evt);
+    this._dropdownScrollEndListener = () => this._onDropdownScrollEnd();
+    this._dropdownIconMouseDownListener = (evt) => this._onDropdownIconMouseDown(evt);
+    this._clearButtonListener = (evt) => this._onClear(evt);
+    this._dismissListener = () => this._onDismiss();
+    this._activeChangeListener = (id) => this._adapter.updateActiveDescendant(id);
+    this._targetWidthCallback = () => this._adapter.getTargetElementWidth(this._popupTarget);
+    this._optionBuilderCallback = (option, parentElement) => {
+      return this._optionBuilder(option, this._filterText, parentElement);
+    };
+    this._identifier = randomChars();
+  }
+  async initialize() {
+    if (!this._adapter.hasInputElement() && !this._adapter.setInputElement()) {
+      throw new Error("An input element is required as a child of the autocomplete component.");
+    }
+    this._setInputListener();
+    this._setFilterCallback();
+    this._attachListeners();
+    this._initializeAccessibility();
+    if (this._values.length) {
+      if (!this._selectedOptions.length) {
+        try {
+          await this._executeFilter();
+        } catch (e) {
+          console.error(e);
+        }
+        this._updateSelectedOptions(this._values);
+      }
+      this._adapter.setSelectedText(this._getSelectedText());
+    }
+    this._isInitialized = true;
+  }
+  disconnect() {
+    if (this._isInitialized) {
+      this._detachListeners();
+      this._isInitialized = false;
+    }
+    if (this._isDropdownOpen) {
+      this._closeDropdown();
+    }
+  }
+  _attachListeners() {
+    this._adapter.addInputListener("click", this._clickListener);
+    this._adapter.addInputListener("focus", this._focusListener);
+    this._adapter.addInputListener("blur", this._blurListener);
+    this._adapter.addInputListener("input", this._inputListener);
+    this._adapter.addInputListener("keydown", this._keydownListener);
+    this._adapter.setDropdownIconListener("click", this._dropdownIconClickListener);
+    this._adapter.setDropdownIconListener("mousedown", this._dropdownIconMouseDownListener);
+    this._adapter.setClearButtonListener("click", this._clearButtonListener);
+  }
+  _detachListeners() {
+    this._adapter.removeInputListener("click", this._clickListener);
+    this._adapter.removeInputListener("focus", this._focusListener);
+    this._adapter.removeInputListener("blur", this._blurListener);
+    this._adapter.removeInputListener("input", this._inputListener);
+    this._adapter.removeInputListener("keydown", this._keydownListener);
+    this._adapter.removeDropdownIconListener("click", this._dropdownIconClickListener);
+    this._adapter.removeDropdownIconListener("mousedown", this._dropdownIconMouseDownListener);
+    this._adapter.removeClearButtonListener("click", this._clearButtonListener);
+  }
+  _setInputListener() {
+    this._inputListener = (evt) => this._onInput(evt);
+  }
+  _setFilterCallback() {
+    this._filterFn = isDefined(this._debounce) && this._debounce > 0 ? debounce(this._debounceFilter, this._debounce, false) : this._debounceFilter;
+  }
+  _initializeAccessibility() {
+    this._adapter.intializeInputAccessibility(this._identifier);
+  }
+  get _flatOptions() {
+    if (isOptionType(this._options, 1 /* Group */)) {
+      return this._options.reduce((previousValue, currentValue) => previousValue.concat(currentValue.options), []);
+    }
+    return this._options;
+  }
+  _onClick(evt) {
+    if (!this._isDropdownOpen && this._filterOnFocus) {
+      this._showDropdown();
+    }
+  }
+  _onDropdownIconMouseDown(evt) {
+    evt.preventDefault();
+  }
+  _onDropdownIconClick(evt) {
+    if (!this._isDropdownOpen) {
+      this._adapter.focus();
+      window.requestAnimationFrame(() => this._showDropdown());
+    } else {
+      this._closeDropdown();
+    }
+  }
+  _onClear(evt) {
+    this._clearValue();
+    this._adapter.setSelectedText(this._getSelectedText());
+  }
+  _onDropdownScrollEnd() {
+    this._adapter.emitHostEvent(AUTOCOMPLETE_CONSTANTS.events.SCROLLED_BOTTOM);
+  }
+  _onFocus() {
+    if (!this._isDropdownOpen && this._adapter.getInputValue() && !Platform.isMobile) {
+      this._adapter.selectInputValue();
+    }
+  }
+  _onBlur(evt) {
+    if (this._adapter.isFocusWithinPopup(evt.relatedTarget)) {
+      return;
+    }
+    this._applyBlur();
+  }
+  _applyBlur() {
+    if (this._isDropdownOpen) {
+      this._closeDropdown();
+    }
+    if (this._mode === "stateless" /* Stateless */) {
+      return;
+    }
+    if (!this._selectedOptions.length) {
+      if (!this._allowUnmatched) {
+        this._filterText = "";
+        this._adapter.setSelectedText("");
+      }
+    } else {
+      this._adapter.setSelectedText(this._getSelectedText());
+    }
+  }
+  _onInput(evt) {
+    if (this._selectedOptions.length && !this._multiple && (!this._adapter.getInputValue() || this._allowUnmatched) && !this._adapter.isWrappingChipField()) {
+      this._selectedOptions = [];
+      this._values = [];
+      this._emitChangeEvent();
+    }
+    this._filterText = this._adapter.getInputValue();
+    this._filterFn();
+  }
+  async _debounceFilter() {
+    if (!this._adapter.hasFocus()) {
+      this._pendingFilterPromises = [];
+      if (this._isDropdownOpen) {
+        this._closeDropdown();
+      }
+      return;
+    }
+    const filterText = this._filterText;
+    const filterPromise = this._executeFilter();
+    this._pendingFilterPromises.push(filterPromise);
+    if (this._isDropdownOpen) {
+      this._adapter.setBusyVisibility(true);
+    } else {
+      this._showDropdown({ filter: false });
+    }
+    try {
+      await filterPromise;
+    } catch (e) {
+      this._pendingFilterPromises = [];
+      if (this._isDropdownOpen) {
+        this._closeDropdown();
+      }
+      return;
+    }
+    if (filterText === this._filterText) {
+      this._pendingFilterPromises = [];
+      this._onFilterComplete();
+    } else {
+      const promiseIndex = this._pendingFilterPromises.indexOf(filterPromise);
+      if (promiseIndex !== -1) {
+        this._pendingFilterPromises.splice(promiseIndex, 1);
+      }
+    }
+  }
+  _onKeydown(evt) {
+    switch (evt.key) {
+      case "Tab":
+        if (this._isDropdownOpen && !this._multiple) {
+          this._selectActiveOption(false);
+        }
+        break;
+      case "Esc":
+      case "Escape":
+        if (this._isDropdownOpen) {
+          evt.preventDefault();
+          this._closeDropdown();
+        }
+        break;
+      case "Down":
+      case "ArrowDown":
+        evt.preventDefault();
+        if (!this._isDropdownOpen) {
+          this._showDropdown({ activateFirst: true });
+        } else {
+          this._adapter.propagateKey(evt.key);
+        }
+        break;
+      case "Up":
+      case "ArrowUp":
+        evt.preventDefault();
+        if (this._isDropdownOpen) {
+          this._adapter.propagateKey(evt.key);
+        }
+        break;
+      case "Enter":
+      case "Home":
+      case "End":
+        if (this._isDropdownOpen) {
+          if (evt.key === "Enter") {
+            evt.stopPropagation();
+          }
+          evt.preventDefault();
+          this._adapter.propagateKey(evt.key);
+        }
+        break;
+      case "Backspace":
+      case "Delete":
+        const input = evt.target;
+        const value = this._adapter.getInputValue();
+        const isRemovingAllChars = input.value.substring(input.selectionStart, input.selectionEnd) === input.value;
+        const isBackspacingLastChar = value.length === 1 && input.selectionEnd === 1;
+        const isDeletingLastChar = value.length === 1 && input.selectionEnd === 0;
+        const isEmpty = !value || isRemovingAllChars || isBackspacingLastChar || isDeletingLastChar;
+        if (!this._adapter.isWrappingChipField() && isEmpty && !this._multiple && this._values.length) {
+          this._clearValue();
+        }
+        break;
+    }
+  }
+  _executeFilter(sendFilterText = true, sendValue = false) {
+    if (!this._filter || typeof this._filter !== "function") {
+      throw new Error('A filter callback must be provided. Did you set the "filter" property?');
+    }
+    const filterText = sendFilterText ? this._filterText : "";
+    const value = sendValue ? this._getValue() : null;
+    return new Promise((resolve, reject) => {
+      return Promise.resolve(this._filter(filterText, value)).then((options) => {
+        this._options = options;
+        resolve(this._options);
+      }).catch((e) => reject(`An unexpected error occurred while filtering: ${e}`));
+    });
+  }
+  _onFilterComplete() {
+    if (!this._adapter.hasFocus()) {
+      if (this._isDropdownOpen) {
+        this._closeDropdown();
+      }
+      return;
+    }
+    if (this._options.length) {
+      const sendFilterText = this._allowUnmatched && !this._selectedOptions.length;
+      this._dropdownReady({ userTriggered: sendFilterText });
+      if (this._filterText) {
+        this._adapter.activateFirstOption();
+      }
+    } else {
+      this._closeDropdown();
+    }
+  }
+  _clearValue() {
+    this._selectedOptions = [];
+    this._values = [];
+    if (this._isDropdownOpen) {
+      this._adapter.setSelectedOptions([]);
+      this._adapter.clearActiveOption();
+    }
+    this._emitChangeEvent();
+  }
+  async _showDropdown({ filter = true, userTriggered = true, activateFirst = false } = {}) {
+    const sendFilterText = this._allowUnmatched && !this._selectedOptions.length;
+    this._isDropdownOpen = true;
+    const config = {
+      options: this._options,
+      multiple: this._multiple,
+      selectedValues: [...this._values],
+      id: `forge-autocomplete-${this._identifier}`,
+      asyncStyle: "skeleton" /* Skeleton */,
+      optionLimit: this._optionLimit,
+      popupClasses: this._popupClasses,
+      headerBuilder: this._popupHeaderBuilder,
+      footerBuilder: this._popupFooterBuilder,
+      transform: (label) => {
+        if (this._filterText) {
+          const highlightElement = highlightTextHTML(label, this._filterText);
+          if (highlightElement) {
+            return highlightElement;
+          }
+        }
+        return label;
+      },
+      allowBusy: true,
+      optionBuilder: !!this._optionBuilder ? this._optionBuilderCallback : void 0,
+      syncWidth: this._syncPopupWidth,
+      observeScroll: this._observeScroll,
+      observeScrollThreshold: this._observeScrollThreshold,
+      scrollEndListener: this._dropdownScrollEndListener,
+      activeChangeCallback: this._activeChangeListener,
+      targetWidthCallback: this._targetWidthCallback,
+      selectCallback: (value) => this._onSelect(value),
+      closeCallback: () => this._closeDropdown()
+    };
+    this._adapter.show(config, this._popupTarget);
+    this._adapter.toggleHostAttribute(AUTOCOMPLETE_CONSTANTS.attributes.OPEN, this._isDropdownOpen);
+    if (filter) {
+      if (this._options.length) {
+        this._adapter.setBusyVisibility(true);
+      }
+      try {
+        await this._executeFilter(sendFilterText);
+      } catch (e) {
+        console.error(e);
+      }
+      this._updateSelectedOptions(this._values);
+    }
+    if (this._pendingFilterPromises.length) {
+      return;
+    }
+    this._dropdownReady({ userTriggered, activateFirst });
+  }
+  _dropdownReady({ userTriggered = true, activateFirst = false } = {}) {
+    if (!this._isDropdownOpen || !this._options.length || userTriggered && !this._adapter.hasFocus()) {
+      this._closeDropdown();
+      return;
+    }
+    this._sortSelectedOptions();
+    this._adapter.setBusyVisibility(false);
+    this._adapter.setOptions(this._options);
+    this._adapter.setSelectedOptions(this._selectedOptions);
+    this._adapter.setDismissListener(this._dismissListener);
+    if (activateFirst) {
+      this._adapter.activateFirstOption();
+    }
+  }
+  _closeDropdown() {
+    if (this._multiple) {
+      this._filterText = "";
+    }
+    this._isDropdownOpen = false;
+    this._adapter.hide(this._dismissListener);
+    this._sortSelectedOptions();
+    this._adapter.toggleHostAttribute(AUTOCOMPLETE_CONSTANTS.attributes.OPEN, this._isDropdownOpen);
+  }
+  _sortSelectedOptions() {
+    if (this._multiple && this._selectedOptions.length && isOptionType(this._options, 0 /* Option */)) {
+      const selectedOptions = [];
+      const unselectedOptions = [];
+      this._options.forEach((option) => {
+        if (this._selectedOptions.find((o) => optionEqualPredicate(o, option.value, this._matchKey))) {
+          selectedOptions.push(option);
+        } else {
+          unselectedOptions.push(option);
+        }
+      });
+      this._options = [...selectedOptions, ...unselectedOptions];
+    }
+  }
+  async _onSelect(selectedValue, keepFocus = true) {
+    if (this._valueChanging) {
+      return;
+    }
+    if (this._mode === "stateless" /* Stateless */) {
+      const data = { value: selectedValue };
+      const result = this._adapter.emitHostEvent(AUTOCOMPLETE_CONSTANTS.events.SELECT, data, true, true);
+      if (result) {
+        this._filterText = "";
+        this._closeDropdown();
+      }
+      return;
+    }
+    const select = () => {
+      const flatOptions = this._flatOptions;
+      const option = flatOptions.find((o) => optionEqualPredicate(o, selectedValue, this._matchKey));
+      const value = option ? option.value : "";
+      const label = option ? option.label : "";
+      if (this._multiple) {
+        const optionIndex = flatOptions.findIndex((o) => optionEqualPredicate(o, selectedValue, this._matchKey));
+        if (optionIndex >= 0) {
+          const selected = this._selectedOptions.some((o) => optionEqualPredicate(o, selectedValue, this._matchKey));
+          this._adapter.toggleOptionMultiple(optionIndex, selected);
+        }
+        const selectedOption = getSelectedOption(this._selectedOptions, value);
+        if (selectedOption) {
+          const index = this._selectedOptions.indexOf(selectedOption);
+          this._selectedOptions.splice(index, 1);
+        } else {
+          this._selectedOptions.push(option);
+        }
+      } else {
+        if (isDefined(value)) {
+          this._selectedOptions[0] = option;
+          this._filterText = label;
+        } else {
+          this._selectedOptions = [];
+          this._filterText = "";
+        }
+      }
+      if (this._isDropdownOpen) {
+        this._adapter.setSelectedOptions(this._selectedOptions);
+      }
+      this._values = this._selectedOptions.map((o) => o.value);
+      this._adapter.setSelectedText(this._getSelectedText());
+      if (!Platform.isMobile && keepFocus) {
+        this._adapter.selectInputValue();
+      }
+      if (this._multiple) {
+        const index = flatOptions.findIndex((o) => optionEqualPredicate(o, selectedValue, this._matchKey));
+        const isSelected = this._values.includes(selectedValue);
+        this._adapter.toggleOptionMultiple(index, isSelected);
+      }
+      this._emitChangeEvent();
+    };
+    if (this._isDropdownOpen && !this._multiple) {
+      this._closeDropdown();
+    }
+    if (typeof this._beforeValueChange === "function") {
+      this._valueChanging = Promise.resolve(this._beforeValueChange.call(null, selectedValue, this._matchKey));
+      const shouldContinue = await this._valueChanging;
+      if (shouldContinue) {
+        select();
+      }
+      this._valueChanging = void 0;
+    } else {
+      select();
+    }
+  }
+  _selectActiveOption(keepFocus = true) {
+    const activeOptionIndex = this._adapter.getActiveOptionIndex();
+    if (typeof activeOptionIndex === "number" && activeOptionIndex >= 0) {
+      const option = this._flatOptions[activeOptionIndex];
+      if (option) {
+        this._onSelect(option.value, keepFocus);
+      }
+    }
+  }
+  _emitChangeEvent() {
+    this._adapter.emitHostEvent(AUTOCOMPLETE_CONSTANTS.events.CHANGE, this._getValue(), true);
+  }
+  _getValue() {
+    if (!this._values) {
+      return null;
+    }
+    if (!this._values.length) {
+      return this._multiple ? [] : null;
+    }
+    return this._multiple ? [...this._values] : this._values[0];
+  }
+  _getSelectedText() {
+    if (this._adapter.isWrappingChipField()) {
+      return "";
+    }
+    if (this._selectedTextBuilder) {
+      return this._selectedTextBuilder(this._selectedOptions);
+    } else {
+      if (this._multiple) {
+        if (this._values.length) {
+          return `${this._values.length} ${this._values.length === 1 ? "option" : "options"} selected`;
+        } else {
+          return "";
+        }
+      } else {
+        return this._selectedOptions.filter((o) => o && o.label).map((o) => o.label).join(" ").trim();
+      }
+    }
+  }
+  _onDismiss() {
+    this._closeDropdown();
+  }
+  async _applyValue(value) {
+    let values = [];
+    this._selectedOptions = [];
+    if (!Array.isArray(value)) {
+      values = isDefined(value) ? [value] : [];
+    } else {
+      values = value;
+    }
+    if (!this._multiple && values.length > 1) {
+      values = [values[0]];
+    }
+    if (isOptionType(values, 0 /* Option */)) {
+      this._values = values.map((o) => o.value);
+      this._selectedOptions = values;
+    } else {
+      this._values = values;
+    }
+    const allOptions = this._flatOptions;
+    if (values.length && allOptions.length) {
+      this._updateSelectedOptions(values);
+    }
+    if (this._values.length && !this._selectedOptions.length && this._filter && this._isInitialized) {
+      try {
+        await this._executeFilter(false, true);
+      } catch (e) {
+        console.error(e);
+      }
+      this._updateSelectedOptions(this._values);
+    }
+    if (!this._multiple) {
+      this._filterText = this._selectedOptions.length ? this._selectedOptions[0].label : "";
+    } else {
+      this._filterText = "";
+    }
+    if (this._isInitialized) {
+      this._adapter.setSelectedText(this._getSelectedText());
+    }
+    if (this._isDropdownOpen) {
+      this._adapter.setSelectedOptions(this._selectedOptions);
+    }
+  }
+  _updateSelectedOptions(values) {
+    const flatOptions = [...this._flatOptions, ...this._selectedOptions];
+    if (this._selectedOptions.length) {
+      this._selectedOptions = [];
+    }
+    if (isOptionType(values, 0 /* Option */)) {
+      for (const option of values) {
+        const actualOption = flatOptions.find((o) => optionEqualPredicate(o, option.value, this._matchKey));
+        if (actualOption) {
+          this._selectedOptions.push(actualOption);
+        } else {
+          this._selectedOptions.push(option);
+        }
+      }
+    } else {
+      for (const value of values) {
+        const actualOption = flatOptions.find((o) => optionEqualPredicate(o, value, this._matchKey));
+        if (actualOption) {
+          this._selectedOptions.push(actualOption);
+        } else if (this._allowUnmatched) {
+          this._selectedOptions.push({ label: value, value });
+        }
+      }
+    }
+  }
+  get mode() {
+    return this._mode;
+  }
+  set mode(value) {
+    if (this._mode !== value) {
+      this._mode = value;
+      if (this._mode === "stateless" /* Stateless */) {
+        this._selectedOptions = [];
+        if (this._isDropdownOpen) {
+          this._closeDropdown();
+        }
+      }
+      this._adapter.setHostAttribute(AUTOCOMPLETE_CONSTANTS.attributes.MODE, this._mode);
+    }
+  }
+  get multiple() {
+    return this._multiple;
+  }
+  set multiple(value) {
+    if (this._multiple !== value) {
+      this._multiple = value;
+      this._adapter.setHostAttribute(AUTOCOMPLETE_CONSTANTS.attributes.MULTIPLE, isDefined(this._multiple) ? this._multiple.toString() : "");
+    }
+  }
+  get value() {
+    return this._getValue();
+  }
+  set value(value) {
+    let values = [];
+    if (value === null || value === void 0) {
+      values = [];
+    } else if (Array.isArray(value)) {
+      values = JSON.parse(JSON.stringify(value));
+    } else if (isString(value)) {
+      values = [value];
+    } else {
+      values = [JSON.parse(JSON.stringify(value))];
+    }
+    const hasNewValue = values.length !== this._values.length || values.some((v) => !this._values.includes(v));
+    if (!hasNewValue) {
+      return;
+    }
+    this._applyValue(value);
+  }
+  get filterOnFocus() {
+    return this._filterOnFocus;
+  }
+  set filterOnFocus(value) {
+    if (this._filterOnFocus !== value) {
+      this._filterOnFocus = value;
+      this._adapter.setHostAttribute(AUTOCOMPLETE_CONSTANTS.attributes.FILTER_ON_FOCUS, isDefined(this._filterOnFocus) ? this._filterOnFocus.toString() : "");
+    }
+  }
+  get allowUnmatched() {
+    return this._allowUnmatched;
+  }
+  set allowUnmatched(value) {
+    if (this._allowUnmatched !== value) {
+      this._allowUnmatched = value;
+      if (isDefined(this._allowUnmatched)) {
+        this._adapter.setHostAttribute(AUTOCOMPLETE_CONSTANTS.attributes.ALLOW_UNMATCHED, this._allowUnmatched.toString());
+      }
+    }
+  }
+  get matchKey() {
+    return this._matchKey;
+  }
+  set matchKey(value) {
+    if (this._matchKey !== value) {
+      this._matchKey = value;
+    }
+  }
+  get popupTarget() {
+    return this._popupTarget;
+  }
+  set popupTarget(value) {
+    if (this._popupTarget !== value) {
+      this._popupTarget = value;
+    }
+  }
+  get popupClasses() {
+    return Array.isArray(this._popupClasses) ? [...this._popupClasses] : [this._popupClasses];
+  }
+  set popupClasses(value) {
+    if (this._popupClasses !== value) {
+      this._popupClasses = Array.isArray(value) ? [...value] : [value];
+    }
+  }
+  set popupHeaderBuilder(value) {
+    this._popupHeaderBuilder = value;
+  }
+  set popupFooterBuilder(value) {
+    this._popupFooterBuilder = value;
+  }
+  get syncPopupWidth() {
+    return this._syncPopupWidth;
+  }
+  set syncPopupWidth(value) {
+    if (this._syncPopupWidth !== value) {
+      this._syncPopupWidth = value;
+    }
+  }
+  get optionLimit() {
+    return this._optionLimit;
+  }
+  set optionLimit(value) {
+    if (this._optionLimit !== value) {
+      this._optionLimit = value;
+    }
+  }
+  get debounce() {
+    return this._debounce;
+  }
+  set debounce(value) {
+    if (this._debounce !== value) {
+      this._debounce = value;
+      if (this._isInitialized) {
+        this._setFilterCallback();
+      }
+      this._adapter.setHostAttribute(AUTOCOMPLETE_CONSTANTS.attributes.DEBOUNCE, isDefined(this._debounce) ? this._debounce.toString() : "");
+    }
+  }
+  get optionBuilder() {
+    return this._optionBuilder;
+  }
+  set optionBuilder(fn) {
+    this._optionBuilder = fn;
+  }
+  get filter() {
+    return this._filter;
+  }
+  set filter(cb) {
+    if (this._filter !== cb) {
+      this._filter = cb;
+      if (this._isInitialized && this._values.length && !this._flatOptions.length && this._filter) {
+        this._executeFilter().then(() => {
+          this._updateSelectedOptions(this._values);
+          this._adapter.setSelectedText(this._getSelectedText());
+        });
+      }
+    }
+  }
+  get selectedTextBuilder() {
+    return this._selectedTextBuilder;
+  }
+  set selectedTextBuilder(fn) {
+    this._selectedTextBuilder = fn;
+    if (this._selectedOptions.length) {
+      this._adapter.setSelectedText(this._getSelectedText());
+    }
+  }
+  get observeScroll() {
+    return this._observeScroll;
+  }
+  set observeScroll(value) {
+    this._observeScroll = value;
+  }
+  get observeScrollThreshold() {
+    return this._observeScrollThreshold;
+  }
+  set observeScrollThreshold(value) {
+    this._observeScrollThreshold = value;
+  }
+  appendOptions(options) {
+    if (!this._isDropdownOpen) {
+      return;
+    }
+    this._options = [...this._options, ...options];
+    this._adapter.appendOptions(options);
+  }
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  get open() {
+    return this._isDropdownOpen;
+  }
+  set open(value) {
+    if (this._isDropdownOpen !== value) {
+      if (value) {
+        this._showDropdown({ userTriggered: false });
+      } else {
+        this._closeDropdown();
+      }
+    }
+  }
+  get beforeValueChange() {
+    return this._beforeValueChange;
+  }
+  set beforeValueChange(value) {
+    if (value !== this._beforeValueChange) {
+      this._beforeValueChange = value;
+    }
+  }
+  get popupElement() {
+    return this._adapter.getPopupElement();
+  }
+};
+
+// dist/build/lib/staging/src/autocomplete/autocomplete.ts
+var template = "<template><slot></slot></template>";
+var styles = ":host{display:block}:host([hidden]){display:none}";
+var AutocompleteComponent = class extends ListDropdownAware {
+  constructor() {
+    super();
+    IconRegistry.define([tylIconCheckBox, tylIconCheckBoxOutlineBlank]);
+    attachShadowTemplate(this, template, styles);
+    this._foundation = new AutocompleteFoundation(new AutocompleteAdapter(this));
+  }
+  static get observedAttributes() {
+    return [
+      AUTOCOMPLETE_CONSTANTS.attributes.MODE,
+      AUTOCOMPLETE_CONSTANTS.attributes.MULTIPLE,
+      AUTOCOMPLETE_CONSTANTS.attributes.DEBOUNCE,
+      AUTOCOMPLETE_CONSTANTS.attributes.FILTER_ON_FOCUS,
+      AUTOCOMPLETE_CONSTANTS.attributes.ALLOW_UNMATCHED,
+      AUTOCOMPLETE_CONSTANTS.attributes.POPUP_TARGET,
+      AUTOCOMPLETE_CONSTANTS.attributes.POPUP_CLASSES,
+      AUTOCOMPLETE_CONSTANTS.attributes.OBSERVE_SCROLL,
+      AUTOCOMPLETE_CONSTANTS.attributes.OBSERVE_SCROLL_THRESHOLD,
+      AUTOCOMPLETE_CONSTANTS.attributes.OPTION_LIMIT,
+      AUTOCOMPLETE_CONSTANTS.attributes.SYNC_POPUP_WIDTH,
+      AUTOCOMPLETE_CONSTANTS.attributes.OPEN,
+      AUTOCOMPLETE_CONSTANTS.attributes.MATCH_KEY
+    ];
+  }
+  connectedCallback() {
+    if (this.querySelector(AUTOCOMPLETE_CONSTANTS.selectors.INPUT)) {
+      this._foundation.initialize();
+    } else {
+      ensureChild(this, AUTOCOMPLETE_CONSTANTS.selectors.INPUT).then(() => this._foundation.initialize());
+    }
+  }
+  disconnectedCallback() {
+    this._foundation.disconnect();
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    super.attributeChangedCallback(name, oldValue, newValue);
+    switch (name) {
+      case AUTOCOMPLETE_CONSTANTS.attributes.MODE:
+        this.mode = newValue;
+        break;
+      case AUTOCOMPLETE_CONSTANTS.attributes.MULTIPLE:
+        this.multiple = coerceBoolean(newValue);
+        break;
+      case AUTOCOMPLETE_CONSTANTS.attributes.DEBOUNCE:
+        this.debounce = coerceNumber(newValue);
+        break;
+      case AUTOCOMPLETE_CONSTANTS.attributes.FILTER_ON_FOCUS:
+        this.filterOnFocus = coerceBoolean(newValue);
+        break;
+      case AUTOCOMPLETE_CONSTANTS.attributes.ALLOW_UNMATCHED:
+        this.allowUnmatched = coerceBoolean(newValue);
+        break;
+      case AUTOCOMPLETE_CONSTANTS.attributes.POPUP_TARGET:
+        this.popupTarget = newValue;
+        break;
+      case AUTOCOMPLETE_CONSTANTS.attributes.OPEN:
+        this.open = coerceBoolean(newValue);
+        break;
+      case AUTOCOMPLETE_CONSTANTS.attributes.MATCH_KEY:
+        this.matchKey = newValue;
+        break;
+    }
+  }
+  appendOptions(options) {
+    this._foundation.appendOptions(options);
+  }
+  openDropdown() {
+    this.open = true;
+  }
+  closeDropdown() {
+    this.open = false;
+  }
+};
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "mode", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "multiple", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "value", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "debounce", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "filterOnFocus", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "allowUnmatched", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "popupTarget", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "optionBuilder", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "filter", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "selectedTextBuilder", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "open", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "matchKey", 2);
+__decorateClass([
+  FoundationProperty({ set: false })
+], AutocompleteComponent.prototype, "isInitialized", 2);
+__decorateClass([
+  FoundationProperty({ set: false })
+], AutocompleteComponent.prototype, "popupElement", 2);
+__decorateClass([
+  FoundationProperty()
+], AutocompleteComponent.prototype, "beforeValueChange", 2);
+AutocompleteComponent = __decorateClass([
+  CustomElement({
+    name: AUTOCOMPLETE_CONSTANTS.elementName,
+    dependencies: [
+      TextFieldComponent,
+      PopupComponent,
+      ListComponent,
+      ListItemComponent,
+      DividerComponent,
+      SkeletonComponent,
+      LinearProgressComponent,
+      IconComponent
+    ]
+  })
+], AutocompleteComponent);
+
+// dist/build/lib/staging/src/autocomplete/autocomplete-component-delegate.ts
+var AutocompleteComponentDelegate = class extends FormFieldComponentDelegate {
+  constructor(config) {
+    super(config);
+  }
+  _build() {
+    const autocomplete = document.createElement(AUTOCOMPLETE_CONSTANTS.elementName);
+    this._attachTextField(autocomplete);
+    return autocomplete;
+  }
+  get textFieldDelegate() {
+    return this._textFieldDelegate;
+  }
+  get value() {
+    return this._element.value;
+  }
+  set value(value) {
+    this._element.value = value;
+  }
+  get disabled() {
+    return this._textFieldDelegate.inputElement.disabled;
+  }
+  set disabled(value) {
+    this._textFieldDelegate.inputElement.disabled = value;
+  }
+  get invalid() {
+    return this._textFieldDelegate.invalid || false;
+  }
+  set invalid(value) {
+    this._textFieldDelegate.invalid = value;
+  }
+  onChange(listener) {
+    this._element.addEventListener(AUTOCOMPLETE_CONSTANTS.events.CHANGE, (evt) => listener(evt.detail));
+  }
+  onFocus(listener) {
+    this._textFieldDelegate.inputElement.addEventListener("focus", (evt) => listener(evt));
+  }
+  onBlur(listener) {
+    this._textFieldDelegate.inputElement.addEventListener("blur", (evt) => listener(evt));
+  }
+  _attachTextField(autocomplete) {
+    var _a, _b, _c, _d, _e, _f;
+    const textFieldConfig = {
+      props: __spreadValues({}, (_b = (_a = this._config.options) == null ? void 0 : _a.textFieldDelegateConfig) == null ? void 0 : _b.props),
+      options: __spreadValues({}, (_d = (_c = this._config.options) == null ? void 0 : _c.textFieldDelegateConfig) == null ? void 0 : _d.options)
+    };
+    if (!textFieldConfig.options) {
+      textFieldConfig.options = {};
+    }
+    if (((_e = this._config.options) == null ? void 0 : _e.useDropdownIcon) !== false && !((_f = textFieldConfig.options) == null ? void 0 : _f.trailingElement)) {
+      textFieldConfig.options.trailingElement = this._createDropdownIconElement();
+    }
+    this._textFieldDelegate = new TextFieldComponentDelegate(textFieldConfig);
+    autocomplete.appendChild(this._textFieldDelegate.element);
+  }
+  _createDropdownIconElement() {
+    const config = {
+      props: {
+        slot: "trailing",
+        name: "arrow_drop_down"
+      },
+      options: {
+        attributes: { "forge-dropdown-icon": "" }
+      }
+    };
+    return new IconComponentDelegate(config).element;
+  }
+};
+
+// dist/build/lib/staging/src/autocomplete/index.ts
+function defineAutocompleteComponent() {
+  defineCustomElement(AutocompleteComponent);
+}
+
+export {
+  AUTOCOMPLETE_CONSTANTS,
+  AutocompleteMode,
+  AutocompleteAdapter,
+  OptionType,
+  isOptionType,
+  getSelectedOption,
+  optionEqualPredicate,
+  AutocompleteFoundation,
+  AutocompleteComponent,
+  AutocompleteComponentDelegate,
+  defineAutocompleteComponent
+};
+//# sourceMappingURL=chunk.NRI7SWVX.js.map