@tylertech/forge 2.8.0 → 2.10.0

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

@@ -1,1347 +0,0 @@
-/**
- * @license
- * Copyright 2022 Tyler Technologies, Inc. 
- * License: Apache-2.0
- */
-import {
-  TextFieldComponent
-} from "./chunk.FJJVIMZ2.js";
-import {
-  TEXT_FIELD_CONSTANTS,
-  TextFieldComponentDelegate
-} from "./chunk.Q4YMHFRY.js";
-import {
-  DividerComponent
-} from "./chunk.QHHYCB7N.js";
-import {
-  CHIP_FIELD_CONSTANTS
-} from "./chunk.I6PJGNJS.js";
-import {
-  ListDropdownAware
-} from "./chunk.3QXCVTCP.js";
-import {
-  ListDropdown,
-  ListDropdownAwareFoundation
-} from "./chunk.IGBDDH3J.js";
-import {
-  SkeletonComponent
-} from "./chunk.6ZBFCE2A.js";
-import {
-  ListComponent
-} from "./chunk.5U6ZT6MC.js";
-import {
-  ListItemComponent
-} from "./chunk.GWNR3UUX.js";
-import {
-  LinearProgressComponent
-} from "./chunk.WNVZQDNS.js";
-import {
-  POPUP_CONSTANTS,
-  PopupComponent
-} from "./chunk.DLF5JAQO.js";
-import {
-  tylIconCheckBox,
-  tylIconCheckBoxOutlineBlank
-} from "./chunk.GS2AXUCN.js";
-import {
-  Platform
-} from "./chunk.BYN27JXZ.js";
-import {
-  IconComponent,
-  IconComponentDelegate,
-  IconRegistry
-} from "./chunk.WSH4S3GM.js";
-import {
-  FormFieldComponentDelegate
-} from "./chunk.HZISALRH.js";
-import {
-  highlightTextHTML
-} from "./chunk.PM7D2SUE.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.IJW2YKP3.js.map