/**
 * ldesign v0.2.14
 * (c) 2022/11/2 16:16 built by swimly
 * @license MIT
 */

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var helper = require('../../chunks/helper.js');
var VueCompositionAPI = require('@vue/composition-api');
var isFunction = require('lodash/isFunction');
var debounce = require('lodash/debounce');
var get = require('lodash/get');
var cloneDeep = require('lodash/cloneDeep');
var isArray = require('lodash/isArray');
var isObject = require('lodash/isObject');
var log = require('../../chunks/log.js');
var hooks_useDefaultValue = require('../../hooks/use-default-value.js');
var hooks_useVmodel = require('../../hooks/use-vmodel.js');
var hooks_lnode = require('../../hooks/lnode.js');
var components_configProvider_useConfig = require('../config-provider/useConfig.js');
var components_loading_index = require('../loading/index.js');
var components_popup_index = require('../popup/index.js');
var components_input_index = require('../input/index.js');
var components_tag_index = require('../tag/index.js');
var components_selectInput_index = require('../select-input/index.js');
var components_common_fakeArrow = require('../common/fake-arrow.js');
var utils_dom = require('../../utils/dom.js');
var hooks_useFormDisabled = require('../../hooks/use-form-disabled.js');
var components_select_option = require('./option.js');
var components_select_selectPanel = require('./select-panel.js');
var components_select_utils = require('./utils.js');
var components_select_hooks_useSelectOptions = require('./hooks/use-select-options.js');
var components_select_props = require('./props.js');
require('../../chunks/_commonjsHelpers-2e6815bd.js');
require('lodash/kebabCase');
require('lodash/isEmpty');
require('lodash/camelCase');
require('../../hooks/render-lnode.js');
require('lodash');
require('../config-provider/context.js');
require('../../chunks/zh_CN.js');
require('../../utils/with-install.js');
require('vue');
require('../../config.js');
require('../loading/loading.js');
require('../../utils/render-node.js');
require('../../utils/transfer-dom.js');
require('../config-provider/config-receiver.js');
require('lodash/mergeWith');
require('../../utils/mixins.js');
require('../loading/props.js');
require('../loading/icon/gradient.js');
require('../../chunks/defineProperty-838e4192.js');
require('../../chunks/set-style.js');
require('../../chunks/helper2.js');
require('raf');
require('lodash/isString');
require('../../utils/easing.js');
require('../loading/plugin.js');
require('../../utils/map-props.js');
require('../popup/popup.js');
require('@popperjs/core');
require('../../utils/helper.js');
require('../popup/props.js');
require('../popup/container.js');
require('../input/input.js');
require('@ldesign/icons-vue');
require('../../utils/event.js');
require('../input/props.js');
require('../input/group.js');
require('../tag/tag.js');
require('../tag/props.js');
require('../tag/check-tag.js');
require('../select-input/select-input.js');
require('../select-input/props.js');
require('../select-input/hooks/use-single.js');
require('lodash/pick');
require('../../hooks/use-config.js');
require('../select-input/hooks/use-multiple.js');
require('../tag-input/index.js');
require('../tag-input/tag-input.js');
require('../../hooks/use-global-icon.js');
require('../tag-input/props.js');
require('../tag-input/hooks/use-tag-scroll.js');
require('../tag-input/hooks/use-tag-list.js');
require('../tag-input/hooks/use-hover.js');
require('../tag-input/hooks/use-drag-sorter.js');
require('../select-input/hooks/use-overlay-innerstyle.js');
require('../../utils/ripple.js');
require('../checkbox/index.js');
require('../checkbox/group.js');
require('lodash/intersection');
require('../checkbox/checkbox.js');
require('../checkbox/props.js');
require('../../hooks/use-lazy-load.js');
require('../../chunks/observe.js');
require('../../hooks/use-common-classname.js');
require('../../hooks/use-virtual-scroll.js');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var isFunction__default = /*#__PURE__*/_interopDefaultLegacy(isFunction);
var debounce__default = /*#__PURE__*/_interopDefaultLegacy(debounce);
var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
var cloneDeep__default = /*#__PURE__*/_interopDefaultLegacy(cloneDeep);
var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);

var TSelect = VueCompositionAPI.defineComponent({
  name: "LSelect",
  components: {
    TInput: components_input_index.Input,
    TLoading: components_loading_index.Loading,
    Tag: components_tag_index.Tag,
    Popup: components_popup_index.Popup,
    TOption: components_select_option["default"],
    FakeArrow: components_common_fakeArrow["default"],
    SelectPanel: components_select_selectPanel["default"]
  },
  props: {
    ...components_select_props.SelectProps
  },
  setup(props2, context) {
    const {
      t,
      global
    } = components_configProvider_useConfig.useConfig("select");
    const renderTNode = hooks_lnode.useLNodeJSX();
    const instance = VueCompositionAPI.getCurrentInstance();
    const selectInputRef = VueCompositionAPI.ref(null);
    const selectPanelRef = VueCompositionAPI.ref();
    const popupOpenTime = VueCompositionAPI.ref(250);
    const {
      formDisabled
    } = hooks_useFormDisabled["default"]();
    const COMPONENT_NAME = components_configProvider_useConfig.usePrefixClass("select");
    const {
      classPrefix
    } = components_configProvider_useConfig.useConfig("classPrefix");
    const {
      valueType,
      disabled,
      size,
      value: valueProps,
      multiple,
      placeholder,
      loading,
      max,
      reserveKeyword,
      inputValue,
      popupVisible,
      minCollapsedNum,
      creatable
    } = VueCompositionAPI.toRefs(props2);
    const keys = VueCompositionAPI.computed(() => {
      var _props2$keys, _props2$keys2;
      return {
        label: ((_props2$keys = props2.keys) === null || _props2$keys === void 0 ? void 0 : _props2$keys.label) || "label",
        value: ((_props2$keys2 = props2.keys) === null || _props2$keys2 === void 0 ? void 0 : _props2$keys2.value) || "value"
      };
    });
    const {
      options: innerOptions,
      optionsMap,
      optionsList
    } = components_select_hooks_useSelectOptions["default"](props2, instance, keys);
    const [value, setValue] = hooks_useVmodel["default"](valueProps, props2.defaultValue, props2.onChange, "change");
    const innerValue = VueCompositionAPI.computed(() => {
      const isObjValue = valueType.value === "object";
      let _value = value.value;
      if (!multiple.value && isArray__default["default"](_value)) {
        log.log.warn("Select", 'Invalid value for "value" props: got an Array when multiple was set to false');
        _value = isObjValue ? {} : "";
      }
      if (multiple.value && !isArray__default["default"](_value)) {
        log.log.warn("Select", 'Invalid value for "value" props: expected an Array when multiple was set to true');
        _value = [];
      }
      if (isObjValue) {
        if (multiple.value) {
          return _value.filter(option => {
            const isObj2 = isObject__default["default"](option);
            if (!isObj2) log.log.warn("Select", `Invalid value for "value" props: expected an Object, but got ${typeof option}`);
            return isObj2;
          }).map(option => option[keys.value.value]);
        }
        const isObj = isObject__default["default"](_value);
        if (!isObj) {
          log.log.warn("Select", `Invalid value for "value" props: expected an Object, but got ${typeof _value}`);
          return "";
        }
        return _value[keys.value.value];
      }
      return _value;
    });
    const setInnerValue = (newVal, context2, optionValue) => {
      if (newVal === value.value) return;
      const selectedOptions = [];
      const {
        value: valueOfKeys,
        label: labelOfKeys
      } = keys.value;
      const oldValueMap = /* @__PURE__ */new Map();
      if (multiple.value) {
        value.value.forEach(option => {
          oldValueMap.set(option[valueOfKeys], option);
        });
      }
      const getOriginOptions = val => {
        const option = optionsMap.value.get(val);
        if (option) delete option.index;
        return option;
      };
      const getFormatOption = val => {
        const option = optionsMap.value.get(val) || oldValueMap.get(val);
        if (option) delete option.index;
        return {
          [valueOfKeys]: get__default["default"](option, valueOfKeys),
          [labelOfKeys]: get__default["default"](option, labelOfKeys)
        };
      };
      if (multiple.value) newVal.forEach(v => selectedOptions.push(getOriginOptions(v)));else selectedOptions.push(getOriginOptions(newVal));
      if (valueType.value === "object") {
        newVal = multiple.value ? newVal.map(val => getFormatOption(val)) : getFormatOption(newVal);
      }
      const outputContext = {
        ...context2,
        selectedOptions
      };
      if (optionValue) {
        outputContext["option"] = getOriginOptions(optionValue);
      }
      setValue(newVal, outputContext);
    };
    const [tInputValue, setTInputValue] = hooks_useDefaultValue["default"](inputValue, props2.defaultInputValue || "", props2.onInputChange, "inputValue", "input-change");
    const [innerPopupVisible, setInnerPopupVisible] = hooks_useDefaultValue["default"](popupVisible, props2.defaultPopupVisible, (visible, context2) => {
      var _props2$onPopupVisibl;
      (_props2$onPopupVisibl = props2.onPopupVisibleChange) === null || _props2$onPopupVisibl === void 0 ? void 0 : _props2$onPopupVisibl.call(props2, visible, context2);
      instance.emit("visible-change", visible);
    }, "popupVisible", "popup-visible-change");
    const isDisabled = VueCompositionAPI.computed(() => formDisabled.value || disabled.value);
    const isLoading = VueCompositionAPI.computed(() => loading.value && !isDisabled.value);
    const isFilterable = VueCompositionAPI.computed(() => Boolean(props2.filterable || global.value.filterable || isFunction__default["default"](props2.filter)));
    const isReachMaxLimit = VueCompositionAPI.computed(() => multiple.value && max.value !== 0 && max.value <= innerValue.value.length);
    const placeholderText = VueCompositionAPI.computed(() => {
      var _value$value;
      return (!multiple.value && innerPopupVisible.value && (valueType.value === "object" && (((_value$value = value.value) === null || _value$value === void 0 ? void 0 : _value$value[keys.value.label]) || innerValue.value) || components_select_utils.getSingleContent(innerValue.value, optionsList.value)) || placeholder.value) ?? t(global.value.placeholder);
    });
    const displayText = VueCompositionAPI.computed(() => {
      var _value$value2;
      if (multiple.value) {
        if (valueType.value === "object") return value.value.map(v => v[keys.value.label]);
        return components_select_utils.getMultipleContent(innerValue.value, optionsList.value);
      }
      if (valueType.value === "object") return ((_value$value2 = value.value) === null || _value$value2 === void 0 ? void 0 : _value$value2[keys.value.label]) || innerValue.value;
      return components_select_utils.getSingleContent(innerValue.value, optionsList.value);
    });
    const valueDisplayParams = VueCompositionAPI.computed(() => {
      const val = multiple.value ? innerValue.value.map(value2 => {
        var _optionsMap$value$get;
        return {
          value: value2,
          label: (_optionsMap$value$get = optionsMap.value.get(value2)) === null || _optionsMap$value$get === void 0 ? void 0 : _optionsMap$value$get.label
        };
      }) : innerValue.value;
      return {
        value: val,
        onClose: multiple.value ? index => removeTag(index) : () => {}
      };
    });
    const collapsedItemsParams = VueCompositionAPI.computed(() => multiple.value ? {
      value: innerValue.value,
      collapsedSelectedItems: innerValue.value.slice(minCollapsedNum.value),
      count: innerValue.value.length - minCollapsedNum.value
    } : {});
    const removeTag = (index, context2) => {
      var _props2$onRemove;
      const {
        e
      } = context2 || {};
      e === null || e === void 0 ? void 0 : e.stopPropagation();
      if (isDisabled.value) return;
      const selectValue = cloneDeep__default["default"](innerValue.value);
      const value2 = selectValue[index];
      selectValue.splice(index, 1);
      setInnerValue(selectValue, {
        e,
        trigger: "tag-remove"
      });
      const evtObj = {
        value: value2,
        data: optionsMap.value.get(value2),
        e
      };
      instance.emit("remove", evtObj);
      (_props2$onRemove = props2.onRemove) === null || _props2$onRemove === void 0 ? void 0 : _props2$onRemove.call(props2, evtObj);
    };
    const handleCreate = () => {
      var _props2$onCreate;
      if (!tInputValue.value) return;
      const createVal = tInputValue.value;
      multiple.value && setTInputValue("");
      instance.emit("create", createVal);
      (_props2$onCreate = props2.onCreate) === null || _props2$onCreate === void 0 ? void 0 : _props2$onCreate.call(props2, createVal);
    };
    const handleClear = _ref => {
      var _props2$onClear;
      let {
        e
      } = _ref;
      e === null || e === void 0 ? void 0 : e.stopPropagation();
      if (multiple.value) setInnerValue([], {
        trigger: "clear",
        e
      });else setInnerValue("", {
        trigger: "clear",
        e
      });
      instance.emit("clear", {
        e
      });
      (_props2$onClear = props2.onClear) === null || _props2$onClear === void 0 ? void 0 : _props2$onClear.call(props2, {
        e
      });
    };
    const handleTInputValueChange = (val, context2) => {
      if (context2.trigger === "blur" || !innerPopupVisible.value) return;
      setTInputValue(val);
      debounceSearch();
    };
    const handleTagChange = (currentTags, context2) => {
      const {
        trigger,
        index,
        e
      } = context2;
      if (trigger === "clear") setInnerValue([], {
        trigger: "tag-remove",
        e
      });
      if (["tag-remove", "backspace"].includes(trigger)) removeTag(index);
    };
    const handleFocus = (value2, context2) => {
      var _props2$onFocus;
      instance.emit("focus", {
        value: value2,
        e: context2 === null || context2 === void 0 ? void 0 : context2.e
      });
      (_props2$onFocus = props2.onFocus) === null || _props2$onFocus === void 0 ? void 0 : _props2$onFocus.call(props2, {
        value: value2,
        e: context2 === null || context2 === void 0 ? void 0 : context2.e
      });
    };
    const handleBlur = (value2, context2) => {
      var _props2$onBlur;
      instance.emit("blur", {
        value: value2,
        e: context2 === null || context2 === void 0 ? void 0 : context2.e
      });
      (_props2$onBlur = props2.onBlur) === null || _props2$onBlur === void 0 ? void 0 : _props2$onBlur.call(props2, {
        value: value2,
        e: context2 === null || context2 === void 0 ? void 0 : context2.e
      });
    };
    const handleEnter = (value2, context2) => {
      var _props2$onEnter;
      instance.emit("enter", {
        value: value2,
        e: context2 === null || context2 === void 0 ? void 0 : context2.e,
        inputValue: tInputValue.value
      });
      (_props2$onEnter = props2.onEnter) === null || _props2$onEnter === void 0 ? void 0 : _props2$onEnter.call(props2, {
        value: value2,
        e: context2 === null || context2 === void 0 ? void 0 : context2.e,
        inputValue: tInputValue.value.toString()
      });
      creatable.value && hoverIndex.value < 1 && handleCreate();
    };
    const debounceSearch = debounce__default["default"](() => {
      var _props2$onSearch;
      instance.emit("search", tInputValue.value);
      (_props2$onSearch = props2.onSearch) === null || _props2$onSearch === void 0 ? void 0 : _props2$onSearch.call(props2, tInputValue.value.toString());
    }, 300);
    const getOverlayElm = () => {
      let r;
      try {
        const popupRefs = context.refs.selectInputRef.$refs.selectInputRef.$refs;
        r = popupRefs.overlay || popupRefs.component.$refs.overlay;
      } catch (e) {
        log.log.warn("Select", e);
      }
      return r;
    };
    const updateScrollTop = content => {
      var _props2$scroll;
      if (((_props2$scroll = props2.scroll) === null || _props2$scroll === void 0 ? void 0 : _props2$scroll.type) === "virtual") return;
      const overlayEl = getOverlayElm();
      if (!overlayEl) return;
      const firstSelectedNode = overlayEl === null || overlayEl === void 0 ? void 0 : overlayEl.querySelector(`.${classPrefix.value}-is-selected`);
      VueCompositionAPI.nextTick(() => {
        if (firstSelectedNode && content) {
          const {
            paddingBottom
          } = getComputedStyle(firstSelectedNode);
          const {
            marginBottom
          } = getComputedStyle(content);
          const elementBottomHeight = parseInt(paddingBottom, 10) + parseInt(marginBottom, 10);
          const updateValue = firstSelectedNode.offsetTop - content.offsetTop - (content.clientHeight - firstSelectedNode.clientHeight) + elementBottomHeight;
          content.scrollTop = updateValue;
        }
      });
    };
    const hoverIndex = VueCompositionAPI.ref(-1);
    const keydownEvent = e => {
      var _selectPanelRef$value;
      const displayOptions = [];
      const getCurrentOptionsList = options => {
        options.forEach(option => {
          if (option.group) getCurrentOptionsList(option.children);else displayOptions.push(option);
        });
      };
      getCurrentOptionsList((_selectPanelRef$value = selectPanelRef.value) === null || _selectPanelRef$value === void 0 ? void 0 : _selectPanelRef$value.getDisplayOptions());
      const displayOptionsLength = displayOptions.length;
      const arrowDownOption = () => {
        let count = 0;
        while (hoverIndex.value < displayOptionsLength) {
          var _displayOptions$hover;
          if (!((_displayOptions$hover = displayOptions[hoverIndex.value]) !== null && _displayOptions$hover !== void 0 && _displayOptions$hover.disabled)) break;
          if (hoverIndex.value === displayOptionsLength - 1) hoverIndex.value = 0;else hoverIndex.value += 1;
          count += 1;
          if (count >= displayOptionsLength) break;
        }
      };
      const arrowUpOption = () => {
        let count = 0;
        while (hoverIndex.value > -1) {
          var _displayOptions$hover2;
          if (!((_displayOptions$hover2 = displayOptions[hoverIndex.value]) !== null && _displayOptions$hover2 !== void 0 && _displayOptions$hover2.disabled)) break;
          if (hoverIndex.value === 0) hoverIndex.value = displayOptionsLength - 1;else hoverIndex.value -= 1;
          count += 1;
          if (count >= displayOptionsLength) break;
        }
      };
      if (displayOptionsLength === 0) return;
      const preventKeys = ["ArrowDown", "ArrowUp", "Enter", "Escape", "Tab"];
      if (preventKeys.includes(e.code)) e.preventDefault();
      switch (e.code) {
        case "ArrowDown":
          if (hoverIndex.value === -1) {
            hoverIndex.value = 0;
            return;
          }
          if (hoverIndex.value < displayOptionsLength - 1) {
            hoverIndex.value += 1;
            arrowDownOption();
          } else {
            hoverIndex.value = 0;
            arrowDownOption();
          }
          break;
        case "ArrowUp":
          if (hoverIndex.value === -1) {
            hoverIndex.value = 0;
            return;
          }
          if (hoverIndex.value > 0) {
            hoverIndex.value -= 1;
            arrowUpOption();
          } else {
            hoverIndex.value = displayOptionsLength - 1;
            arrowUpOption();
          }
          break;
        case "Enter":
          if (hoverIndex.value === -1) return;
          if (displayOptions[hoverIndex.value].isCreated && multiple.value) handleCreate();
          if (!multiple.value) {
            const optionValue = displayOptions[hoverIndex.value].value;
            setInnerValue(optionValue, {
              e,
              trigger: "check"
            }, optionValue);
            setInnerPopupVisible(false, {
              e
            });
          } else {
            var _displayOptions$hover3;
            if (hoverIndex.value === -1) return;
            const optionValue = (_displayOptions$hover3 = displayOptions[hoverIndex.value]) === null || _displayOptions$hover3 === void 0 ? void 0 : _displayOptions$hover3.value;
            if (!optionValue) return;
            const newValue = components_select_utils.getNewMultipleValue(innerValue.value, optionValue);
            setInnerValue(newValue.value, {
              e,
              trigger: newValue.isCheck ? "check" : "uncheck"
            }, optionValue);
          }
          break;
        case "Escape":
        case "Tab":
          setInnerPopupVisible(false, {
            trigger: "keydown-esc",
            e
          });
          setTInputValue("");
          break;
      }
    };
    VueCompositionAPI.watch(innerPopupVisible, val => {
      val && utils_dom.on(document, "keydown", keydownEvent);
      !val && utils_dom.off(document, "keydown", keydownEvent);
    }, {
      flush: "sync"
    });
    VueCompositionAPI.watch(innerPopupVisible, value2 => {
      if (value2) {
        hoverIndex.value = -1;
      } else {
        tInputValue.value && setTInputValue("");
      }
    });
    VueCompositionAPI.provide("tSelect", {
      size,
      multiple,
      popupOpenTime,
      hoverIndex,
      selectValue: innerValue,
      reserveKeyword,
      isReachMaxLimit,
      getOverlayElm,
      handleCreate,
      handleValueChange: setInnerValue,
      handlerInputChange: setTInputValue,
      handlePopupVisibleChange: setInnerPopupVisible
    });
    return {
      isFilterable,
      isDisabled,
      isLoading,
      innerOptions,
      placeholderText,
      selectInputRef,
      selectPanelRef,
      innerPopupVisible,
      displayText,
      tInputValue,
      collapsedItemsParams,
      valueDisplayParams,
      handleFocus,
      handleBlur,
      handleEnter,
      handleClear,
      handleTagChange,
      handleTInputValueChange,
      setInnerPopupVisible,
      removeTag,
      renderTNode,
      updateScrollTop,
      componentName: COMPONENT_NAME
    };
  },
  methods: {
    renderSuffixIcon() {
      const h = this.$createElement;
      const {
        isLoading,
        showArrow,
        innerPopupVisible,
        isDisabled
      } = this;
      if (isLoading) {
        return h("t-loading", {
          "class": [`${this.componentName}__right-icon`, `${this.componentName}__active-icon`],
          "attrs": {
            "size": "small"
          }
        });
      }
      return showArrow ? h("fake-arrow", {
        "attrs": {
          "overlayClassName": `${this.componentName}__right-icon`,
          "isActive": innerPopupVisible && !isDisabled
        }
      }) : null;
    }
  },
  render() {
    const h = arguments[0];
    const {
      renderTNode
    } = this;
    const prefixIcon = () => renderTNode("prefixIcon");
    const valueDisplay = () => renderTNode("valueDisplay", {
      params: this.valueDisplayParams
    });
    const collapsedItems = () => renderTNode("collapsedItems", {
      params: this.collapsedItemsParams
    });
    const {
      overlayClassName,
      ...restPopupProps
    } = this.popupProps || {};
    return h("div", {
      "ref": "select",
      "class": `${this.componentName}__wrap`
    }, [h(components_selectInput_index.SelectInput, helper.helper([{
      "ref": "selectInputRef",
      "class": this.componentName,
      "attrs": {
        "autoWidth": this.autoWidth,
        "borderless": this.borderless,
        "readonly": this.readonly,
        "allowInput": this.isFilterable,
        "multiple": this.multiple,
        "keys": this.keys,
        "status": this.status,
        "tips": this.tips,
        "value": this.displayText,
        "valueDisplay": valueDisplay,
        "clearable": this.clearable,
        "disabled": this.isDisabled,
        "label": prefixIcon,
        "suffixIcon": this.renderSuffixIcon,
        "placeholder": this.placeholderText,
        "inputValue": this.tInputValue,
        "inputProps": {
          size: this.size,
          ...this.inputProps
        },
        "tagInputProps": {
          autoWidth: true,
          ...this.tagInputProps
        },
        "tagProps": this.tagProps,
        "minCollapsedNum": this.minCollapsedNum,
        "collapsedItems": collapsedItems,
        "popupVisible": this.innerPopupVisible,
        "popupProps": {
          overlayClassName: [`${this.componentName}__dropdown`, overlayClassName],
          ...restPopupProps
        }
      }
    }, {
      "on": {
        "focus": this.handleFocus,
        "blur": this.handleBlur,
        "enter": this.handleEnter,
        "clear": this.handleClear,
        "input-change": this.handleTInputValueChange,
        "popup-visible-change": this.setInnerPopupVisible,
        "tag-change": this.handleTagChange
      }
    }, {}, this.selectInputProps, {
      "attrs": {
        "updateScrollTop": this.updateScrollTop
      }
    }]), [h("select-panel", {
      "ref": "selectPanelRef",
      "slot": "panel",
      "scopedSlots": this.$scopedSlots,
      "attrs": {
        "size": this.size,
        "options": this.innerOptions,
        "inputValue": this.tInputValue,
        "multiple": this.multiple,
        "empty": this.empty,
        "filter": this.filter,
        "filterable": this.isFilterable,
        "creatable": this.creatable,
        "scroll": this.scroll,
        "loading": this.isLoading,
        "loadingText": this.loadingText,
        "panelTopContent": this.panelTopContent,
        "panelBottomContent": this.panelBottomContent
      }
    })])]);
  }
});

exports["default"] = TSelect;
//# sourceMappingURL=select.js.map
