diff --git a/.gitignore b/.gitignore index 43f1f7b0..b4374841 100755 --- a/.gitignore +++ b/.gitignore @@ -8,7 +8,7 @@ node_modules/ yarn.lock -dist +# dist gh-pages test/unit/coverage diff --git a/dist/vue-treeselect.cjs.js b/dist/vue-treeselect.cjs.js new file mode 100644 index 00000000..bdae3fd6 --- /dev/null +++ b/dist/vue-treeselect.cjs.js @@ -0,0 +1,3948 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2022 Riophae Lee + * Released under the MIT License. + * https://vue-treeselect.js.org/ + */ +module.exports = +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = "/"; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 16); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports) { + +module.exports = require("@babel/runtime/helpers/slicedToArray"); + +/***/ }), +/* 1 */ +/***/ (function(module, exports) { + +module.exports = require("@babel/runtime/helpers/toConsumableArray"); + +/***/ }), +/* 2 */ +/***/ (function(module, exports) { + +module.exports = require("@babel/runtime/helpers/defineProperty"); + +/***/ }), +/* 3 */ +/***/ (function(module, exports) { + +module.exports = require("fuzzysearch"); + +/***/ }), +/* 4 */ +/***/ (function(module, exports) { + +module.exports = require("lodash/noop"); + +/***/ }), +/* 5 */ +/***/ (function(module, exports) { + +module.exports = require("lodash/debounce"); + +/***/ }), +/* 6 */ +/***/ (function(module, exports) { + +module.exports = require("watch-size"); + +/***/ }), +/* 7 */ +/***/ (function(module, exports) { + +module.exports = require("is-promise"); + +/***/ }), +/* 8 */ +/***/ (function(module, exports) { + +module.exports = require("lodash/once"); + +/***/ }), +/* 9 */ +/***/ (function(module, exports) { + +module.exports = require("lodash/identity"); + +/***/ }), +/* 10 */ +/***/ (function(module, exports) { + +module.exports = require("lodash/constant"); + +/***/ }), +/* 11 */ +/***/ (function(module, exports) { + +module.exports = require("@babel/runtime/helpers/typeof"); + +/***/ }), +/* 12 */ +/***/ (function(module, exports) { + +module.exports = require("lodash/last"); + +/***/ }), +/* 13 */ +/***/ (function(module, exports) { + +module.exports = require("babel-helper-vue-jsx-merge-props"); + +/***/ }), +/* 14 */ +/***/ (function(module, exports) { + +module.exports = require("vue"); + +/***/ }), +/* 15 */ +/***/ (function(module, exports, __webpack_require__) { + +// extracted by mini-css-extract-plugin + +/***/ }), +/* 16 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +// ESM COMPAT FLAG +__webpack_require__.r(__webpack_exports__); + +// EXPORTS +__webpack_require__.d(__webpack_exports__, "Treeselect", function() { return /* reexport */ Treeselect; }); +__webpack_require__.d(__webpack_exports__, "treeselectMixin", function() { return /* reexport */ treeselectMixin; }); +__webpack_require__.d(__webpack_exports__, "LOAD_ROOT_OPTIONS", function() { return /* reexport */ LOAD_ROOT_OPTIONS; }); +__webpack_require__.d(__webpack_exports__, "LOAD_CHILDREN_OPTIONS", function() { return /* reexport */ LOAD_CHILDREN_OPTIONS; }); +__webpack_require__.d(__webpack_exports__, "ASYNC_SEARCH", function() { return /* reexport */ ASYNC_SEARCH; }); +__webpack_require__.d(__webpack_exports__, "VERSION", function() { return /* binding */ VERSION; }); + +// EXTERNAL MODULE: external "@babel/runtime/helpers/slicedToArray" +var slicedToArray_ = __webpack_require__(0); +var slicedToArray_default = /*#__PURE__*/__webpack_require__.n(slicedToArray_); + +// EXTERNAL MODULE: external "@babel/runtime/helpers/toConsumableArray" +var toConsumableArray_ = __webpack_require__(1); +var toConsumableArray_default = /*#__PURE__*/__webpack_require__.n(toConsumableArray_); + +// EXTERNAL MODULE: external "@babel/runtime/helpers/defineProperty" +var defineProperty_ = __webpack_require__(2); +var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty_); + +// EXTERNAL MODULE: external "fuzzysearch" +var external_fuzzysearch_ = __webpack_require__(3); +var external_fuzzysearch_default = /*#__PURE__*/__webpack_require__.n(external_fuzzysearch_); + +// EXTERNAL MODULE: external "lodash/noop" +var noop_ = __webpack_require__(4); +var noop_default = /*#__PURE__*/__webpack_require__.n(noop_); + +// CONCATENATED MODULE: ./src/utils/noop.js + +// CONCATENATED MODULE: ./src/utils/warning.js + + +var warning_warning = process.env.NODE_ENV === 'production' ? noop_default.a : function warning(checker, complainer) { + if (!checker()) { + var _console; + + var message = ['[Vue-Treeselect Warning]'].concat(complainer()); + + (_console = console).error.apply(_console, toConsumableArray_default()(message)); + } +}; +// CONCATENATED MODULE: ./src/utils/onLeftClick.js +function onLeftClick(mouseDownHandler) { + return function onMouseDown(evt) { + if (evt.type === 'mousedown' && evt.button === 0) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + mouseDownHandler.call.apply(mouseDownHandler, [this, evt].concat(args)); + } + }; +} +// CONCATENATED MODULE: ./src/utils/scrollIntoView.js +function scrollIntoView($scrollingEl, $focusedEl) { + var scrollingReact = $scrollingEl.getBoundingClientRect(); + var focusedRect = $focusedEl.getBoundingClientRect(); + var overScroll = $focusedEl.offsetHeight / 3; + + if (focusedRect.bottom + overScroll > scrollingReact.bottom) { + $scrollingEl.scrollTop = Math.min($focusedEl.offsetTop + $focusedEl.clientHeight - $scrollingEl.offsetHeight + overScroll, $scrollingEl.scrollHeight); + } else if (focusedRect.top - overScroll < scrollingReact.top) { + $scrollingEl.scrollTop = Math.max($focusedEl.offsetTop - overScroll, 0); + } +} +// EXTERNAL MODULE: external "lodash/debounce" +var debounce_ = __webpack_require__(5); +var debounce_default = /*#__PURE__*/__webpack_require__.n(debounce_); + +// CONCATENATED MODULE: ./src/utils/debounce.js + +// EXTERNAL MODULE: external "watch-size" +var external_watch_size_ = __webpack_require__(6); +var external_watch_size_default = /*#__PURE__*/__webpack_require__.n(external_watch_size_); + +// CONCATENATED MODULE: ./src/utils/removeFromArray.js +function removeFromArray(arr, elem) { + var idx = arr.indexOf(elem); + if (idx !== -1) arr.splice(idx, 1); +} +// CONCATENATED MODULE: ./src/utils/watchSize.js + + +var intervalId; +var registered = []; +var INTERVAL_DURATION = 100; + +function run() { + intervalId = setInterval(function () { + registered.forEach(test); + }, INTERVAL_DURATION); +} + +function stop() { + clearInterval(intervalId); + intervalId = null; +} + +function test(item) { + var $el = item.$el, + listener = item.listener, + lastWidth = item.lastWidth, + lastHeight = item.lastHeight; + var width = $el.offsetWidth; + var height = $el.offsetHeight; + + if (lastWidth !== width || lastHeight !== height) { + item.lastWidth = width; + item.lastHeight = height; + listener({ + width: width, + height: height + }); + } +} + +function watchSizeForIE9($el, listener) { + var item = { + $el: $el, + listener: listener, + lastWidth: null, + lastHeight: null + }; + + var unwatch = function unwatch() { + removeFromArray(registered, item); + if (!registered.length) stop(); + }; + + registered.push(item); + test(item); + run(); + return unwatch; +} + +function watchSize($el, listener) { + var isIE9 = document.documentMode === 9; + var locked = true; + + var wrappedListener = function wrappedListener() { + return locked || listener.apply(void 0, arguments); + }; + + var implementation = isIE9 ? watchSizeForIE9 : external_watch_size_default.a; + var removeSizeWatcher = implementation($el, wrappedListener); + locked = false; + return removeSizeWatcher; +} +// CONCATENATED MODULE: ./src/utils/setupResizeAndScrollEventListeners.js +function findScrollParents($el) { + var $scrollParents = []; + var $parent = $el.parentNode; + + while ($parent && $parent.nodeName !== 'BODY' && $parent.nodeType === document.ELEMENT_NODE) { + if (isScrollElment($parent)) $scrollParents.push($parent); + $parent = $parent.parentNode; + } + + $scrollParents.push(window); + return $scrollParents; +} + +function isScrollElment($el) { + var _getComputedStyle = getComputedStyle($el), + overflow = _getComputedStyle.overflow, + overflowX = _getComputedStyle.overflowX, + overflowY = _getComputedStyle.overflowY; + + return /(auto|scroll|overlay)/.test(overflow + overflowY + overflowX); +} + +function setupResizeAndScrollEventListeners($el, listener) { + var $scrollParents = findScrollParents($el); + window.addEventListener('resize', listener, { + passive: true + }); + $scrollParents.forEach(function (scrollParent) { + scrollParent.addEventListener('scroll', listener, { + passive: true + }); + }); + return function removeEventListeners() { + window.removeEventListener('resize', listener, { + passive: true + }); + $scrollParents.forEach(function ($scrollParent) { + $scrollParent.removeEventListener('scroll', listener, { + passive: true + }); + }); + }; +} +// CONCATENATED MODULE: ./src/utils/isNaN.js +function isNaN_isNaN(x) { + return x !== x; +} +// EXTERNAL MODULE: external "is-promise" +var external_is_promise_ = __webpack_require__(7); +var external_is_promise_default = /*#__PURE__*/__webpack_require__.n(external_is_promise_); + +// CONCATENATED MODULE: ./src/utils/isPromise.js + +// EXTERNAL MODULE: external "lodash/once" +var once_ = __webpack_require__(8); +var once_default = /*#__PURE__*/__webpack_require__.n(once_); + +// CONCATENATED MODULE: ./src/utils/once.js + +// EXTERNAL MODULE: external "lodash/identity" +var identity_ = __webpack_require__(9); +var identity_default = /*#__PURE__*/__webpack_require__.n(identity_); + +// CONCATENATED MODULE: ./src/utils/identity.js + +// EXTERNAL MODULE: external "lodash/constant" +var constant_ = __webpack_require__(10); +var constant_default = /*#__PURE__*/__webpack_require__.n(constant_); + +// CONCATENATED MODULE: ./src/utils/constant.js + +// CONCATENATED MODULE: ./src/utils/createMap.js +var createMap = function createMap() { + return Object.create(null); +}; +// EXTERNAL MODULE: external "@babel/runtime/helpers/typeof" +var typeof_ = __webpack_require__(11); +var typeof_default = /*#__PURE__*/__webpack_require__.n(typeof_); + +// CONCATENATED MODULE: ./src/utils/deepExtend.js + + +function isPlainObject(value) { + if (value == null || typeof_default()(value) !== 'object') return false; + return Object.getPrototypeOf(value) === Object.prototype; +} + +function copy(obj, key, value) { + if (isPlainObject(value)) { + obj[key] || (obj[key] = {}); + deepExtend(obj[key], value); + } else { + obj[key] = value; + } +} + +function deepExtend(target, source) { + if (isPlainObject(source)) { + var keys = Object.keys(source); + + for (var i = 0, len = keys.length; i < len; i++) { + copy(target, keys[i], source[keys[i]]); + } + } + + return target; +} +// EXTERNAL MODULE: external "lodash/last" +var last_ = __webpack_require__(12); +var last_default = /*#__PURE__*/__webpack_require__.n(last_); + +// CONCATENATED MODULE: ./src/utils/last.js + +// CONCATENATED MODULE: ./src/utils/includes.js +function includes(arrOrStr, elem) { + return arrOrStr.indexOf(elem) !== -1; +} +// CONCATENATED MODULE: ./src/utils/find.js +function find(arr, predicate, ctx) { + for (var i = 0, len = arr.length; i < len; i++) { + if (predicate.call(ctx, arr[i], i, arr)) return arr[i]; + } + + return undefined; +} +// CONCATENATED MODULE: ./src/utils/quickDiff.js +function quickDiff(arrA, arrB) { + if (arrA.length !== arrB.length) return true; + + for (var i = 0; i < arrA.length; i++) { + if (arrA[i] !== arrB[i]) return true; + } + + return false; +} +// CONCATENATED MODULE: ./src/utils/index.js + + + + + + + + + + + + + + + + + + + +// CONCATENATED MODULE: ./src/constants.js +var NO_PARENT_NODE = null; +var UNCHECKED = 0; +var INDETERMINATE = 1; +var CHECKED = 2; +var ALL_CHILDREN = 'ALL_CHILDREN'; +var ALL_DESCENDANTS = 'ALL_DESCENDANTS'; +var LEAF_CHILDREN = 'LEAF_CHILDREN'; +var LEAF_DESCENDANTS = 'LEAF_DESCENDANTS'; +var LOAD_ROOT_OPTIONS = 'LOAD_ROOT_OPTIONS'; +var LOAD_CHILDREN_OPTIONS = 'LOAD_CHILDREN_OPTIONS'; +var ASYNC_SEARCH = 'ASYNC_SEARCH'; +var ALL = 'ALL'; +var BRANCH_PRIORITY = 'BRANCH_PRIORITY'; +var LEAF_PRIORITY = 'LEAF_PRIORITY'; +var ALL_WITH_INDETERMINATE = 'ALL_WITH_INDETERMINATE'; +var ORDER_SELECTED = 'ORDER_SELECTED'; +var LEVEL = 'LEVEL'; +var INDEX = 'INDEX'; +var KEY_CODES = { + BACKSPACE: 8, + ENTER: 13, + ESCAPE: 27, + END: 35, + HOME: 36, + ARROW_LEFT: 37, + ARROW_UP: 38, + ARROW_RIGHT: 39, + ARROW_DOWN: 40, + DELETE: 46 +}; +var INPUT_DEBOUNCE_DELAY = process.env.NODE_ENV === 'testing' ? 10 : 200; +var MIN_INPUT_WIDTH = 5; +var MENU_BUFFER = 40; +// CONCATENATED MODULE: ./src/mixins/treeselectMixin.js + + + + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { defineProperty_default()(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + + + + + +function sortValueByIndex(a, b) { + var i = 0; + + do { + if (a.level < i) return -1; + if (b.level < i) return 1; + if (a.index[i] !== b.index[i]) return a.index[i] - b.index[i]; + i++; + } while (true); +} + +function sortValueByLevel(a, b) { + return a.level === b.level ? sortValueByIndex(a, b) : a.level - b.level; +} + +function createAsyncOptionsStates() { + return { + isLoaded: false, + isLoading: false, + loadingError: '' + }; +} + +function stringifyOptionPropValue(value) { + if (typeof value === 'string') return removeAccents(value); + if (typeof value === 'number' && !isNaN_isNaN(value)) return value + ''; + return ''; +} + +function removeAccents(str) { + if (!str) return ''; + return str.normalize('NFD').replace(/[\u0300-\u036F]/g, ''); +} + +function match(enableFuzzyMatch, needle, haystack) { + return enableFuzzyMatch ? external_fuzzysearch_default()(needle, haystack) : includes(haystack, needle); +} + +function getErrorMessage(err) { + return err.message || String(err); +} + +var instanceId = 0; +/* harmony default export */ var treeselectMixin = ({ + provide: function provide() { + return { + instance: this + }; + }, + props: { + allowClearingDisabled: { + type: Boolean, + default: false + }, + allowSelectingDisabledDescendants: { + type: Boolean, + default: false + }, + alwaysOpen: { + type: Boolean, + default: false + }, + appendToBody: { + type: Boolean, + default: false + }, + async: { + type: Boolean, + default: false + }, + autoFocus: { + type: Boolean, + default: false + }, + autoLoadRootOptions: { + type: Boolean, + default: true + }, + autoDeselectAncestors: { + type: Boolean, + default: false + }, + autoDeselectDescendants: { + type: Boolean, + default: false + }, + autoSelectAncestors: { + type: Boolean, + default: false + }, + autoSelectDescendants: { + type: Boolean, + default: false + }, + backspaceRemoves: { + type: Boolean, + default: true + }, + beforeClearAll: { + type: Function, + default: constant_default()(true) + }, + branchNodesFirst: { + type: Boolean, + default: false + }, + cacheOptions: { + type: Boolean, + default: true + }, + clearable: { + type: Boolean, + default: true + }, + clearAllText: { + type: String, + default: 'Clear all' + }, + clearOnSelect: { + type: Boolean, + default: false + }, + clearValueText: { + type: String, + default: 'Clear value' + }, + closeOnSelect: { + type: Boolean, + default: true + }, + defaultExpandLevel: { + type: Number, + default: 0 + }, + defaultOptions: { + default: false + }, + deleteRemoves: { + type: Boolean, + default: true + }, + delimiter: { + type: String, + default: ',' + }, + flattenSearchResults: { + type: Boolean, + default: false + }, + disableBranchNodes: { + type: Boolean, + default: false + }, + disabled: { + type: Boolean, + default: false + }, + disableFuzzyMatching: { + type: Boolean, + default: false + }, + flat: { + type: Boolean, + default: false + }, + instanceId: { + default: function _default() { + return "".concat(instanceId++, "$$"); + }, + type: [String, Number] + }, + joinValues: { + type: Boolean, + default: false + }, + limit: { + type: Number, + default: Infinity + }, + limitText: { + type: Function, + default: function limitTextDefault(count) { + return "and ".concat(count, " more"); + } + }, + loadingText: { + type: String, + default: 'Loading...' + }, + loadOptions: { + type: Function + }, + matchKeys: { + type: Array, + default: constant_default()(['label']) + }, + maxHeight: { + type: Number, + default: 300 + }, + multiple: { + type: Boolean, + default: false + }, + name: { + type: String + }, + noChildrenText: { + type: String, + default: 'No sub-options.' + }, + noOptionsText: { + type: String, + default: 'No options available.' + }, + noResultsText: { + type: String, + default: 'No results found...' + }, + normalizer: { + type: Function, + default: identity_default.a + }, + openDirection: { + type: String, + default: 'auto', + validator: function validator(value) { + var acceptableValues = ['auto', 'top', 'bottom', 'above', 'below']; + return includes(acceptableValues, value); + } + }, + openOnClick: { + type: Boolean, + default: true + }, + openOnFocus: { + type: Boolean, + default: false + }, + options: { + type: Array + }, + placeholder: { + type: String, + default: 'Select...' + }, + required: { + type: Boolean, + default: false + }, + retryText: { + type: String, + default: 'Retry?' + }, + retryTitle: { + type: String, + default: 'Click to retry' + }, + searchable: { + type: Boolean, + default: true + }, + searchNested: { + type: Boolean, + default: false + }, + searchPromptText: { + type: String, + default: 'Type to search...' + }, + showCount: { + type: Boolean, + default: false + }, + showCountOf: { + type: String, + default: ALL_CHILDREN, + validator: function validator(value) { + var acceptableValues = [ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS]; + return includes(acceptableValues, value); + } + }, + showCountOnSearch: null, + sortValueBy: { + type: String, + default: ORDER_SELECTED, + validator: function validator(value) { + var acceptableValues = [ORDER_SELECTED, LEVEL, INDEX]; + return includes(acceptableValues, value); + } + }, + tabIndex: { + type: Number, + default: 0 + }, + value: null, + valueConsistsOf: { + type: String, + default: BRANCH_PRIORITY, + validator: function validator(value) { + var acceptableValues = [ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE]; + return includes(acceptableValues, value); + } + }, + valueFormat: { + type: String, + default: 'id' + }, + zIndex: { + type: [Number, String], + default: 999 + } + }, + data: function data() { + return { + trigger: { + isFocused: false, + searchQuery: '' + }, + menu: { + isOpen: false, + current: null, + lastScrollPosition: 0, + placement: 'bottom' + }, + forest: { + normalizedOptions: [], + nodeMap: createMap(), + checkedStateMap: createMap(), + selectedNodeIds: this.extractCheckedNodeIdsFromValue(), + selectedNodeMap: createMap() + }, + rootOptionsStates: createAsyncOptionsStates(), + localSearch: { + active: false, + noResults: true, + countMap: createMap() + }, + remoteSearch: createMap() + }; + }, + computed: { + selectedNodes: function selectedNodes() { + return this.forest.selectedNodeIds.map(this.getNode); + }, + internalValue: function internalValue() { + var _this = this; + + var internalValue; + + if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) { + internalValue = this.forest.selectedNodeIds.slice(); + } else if (this.valueConsistsOf === BRANCH_PRIORITY) { + internalValue = this.forest.selectedNodeIds.filter(function (id) { + var node = _this.getNode(id); + + if (node.isRootNode) return true; + return !_this.isSelected(node.parentNode); + }); + } else if (this.valueConsistsOf === LEAF_PRIORITY) { + internalValue = this.forest.selectedNodeIds.filter(function (id) { + var node = _this.getNode(id); + + if (node.isLeaf) return true; + return node.children.length === 0; + }); + } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) { + var _internalValue; + + var indeterminateNodeIds = []; + internalValue = this.forest.selectedNodeIds.slice(); + this.selectedNodes.forEach(function (selectedNode) { + selectedNode.ancestors.forEach(function (ancestor) { + if (includes(indeterminateNodeIds, ancestor.id)) return; + if (includes(internalValue, ancestor.id)) return; + indeterminateNodeIds.push(ancestor.id); + }); + }); + + (_internalValue = internalValue).push.apply(_internalValue, indeterminateNodeIds); + } + + if (this.sortValueBy === LEVEL) { + internalValue.sort(function (a, b) { + return sortValueByLevel(_this.getNode(a), _this.getNode(b)); + }); + } else if (this.sortValueBy === INDEX) { + internalValue.sort(function (a, b) { + return sortValueByIndex(_this.getNode(a), _this.getNode(b)); + }); + } + + return internalValue; + }, + hasValue: function hasValue() { + return this.internalValue.length > 0; + }, + single: function single() { + return !this.multiple; + }, + visibleOptionIds: function visibleOptionIds() { + var _this2 = this; + + var visibleOptionIds = []; + this.traverseAllNodesByIndex(function (node) { + if (!_this2.localSearch.active || _this2.shouldOptionBeIncludedInSearchResult(node)) { + visibleOptionIds.push(node.id); + } + + if (node.isBranch && !_this2.shouldExpand(node)) { + return false; + } + }); + return visibleOptionIds; + }, + hasVisibleOptions: function hasVisibleOptions() { + return this.visibleOptionIds.length !== 0; + }, + showCountOnSearchComputed: function showCountOnSearchComputed() { + return typeof this.showCountOnSearch === 'boolean' ? this.showCountOnSearch : this.showCount; + }, + hasBranchNodes: function hasBranchNodes() { + return this.forest.normalizedOptions.some(function (rootNode) { + return rootNode.isBranch; + }); + }, + shouldFlattenOptions: function shouldFlattenOptions() { + return this.localSearch.active && this.flattenSearchResults; + } + }, + watch: { + alwaysOpen: function alwaysOpen(newValue) { + if (newValue) this.openMenu();else this.closeMenu(); + }, + branchNodesFirst: function branchNodesFirst() { + this.initialize(); + }, + disabled: function disabled(newValue) { + if (newValue && this.menu.isOpen) this.closeMenu();else if (!newValue && !this.menu.isOpen && this.alwaysOpen) this.openMenu(); + }, + flat: function flat() { + this.initialize(); + }, + internalValue: function internalValue(newValue, oldValue) { + var hasChanged = quickDiff(newValue, oldValue); + if (hasChanged) this.$emit('input', this.getValue(), this.getInstanceId()); + }, + matchKeys: function matchKeys() { + this.initialize(); + }, + multiple: function multiple(newValue) { + if (newValue) this.buildForestState(); + }, + options: { + handler: function handler() { + if (this.async) return; + this.initialize(); + this.rootOptionsStates.isLoaded = Array.isArray(this.options); + }, + deep: true, + immediate: true + }, + 'trigger.searchQuery': function triggerSearchQuery() { + if (this.async) { + this.handleRemoteSearch(); + } else { + this.handleLocalSearch(); + } + + this.$emit('search-change', this.trigger.searchQuery, this.getInstanceId()); + }, + value: function value() { + var nodeIdsFromValue = this.extractCheckedNodeIdsFromValue(); + var hasChanged = quickDiff(nodeIdsFromValue, this.internalValue); + if (hasChanged) this.fixSelectedNodeIds(nodeIdsFromValue); + } + }, + methods: { + verifyProps: function verifyProps() { + var _this3 = this; + + warning_warning(function () { + return _this3.async ? _this3.searchable : true; + }, function () { + return 'For async search mode, the value of "searchable" prop must be true.'; + }); + + if (this.options == null && !this.loadOptions) { + warning_warning(function () { + return false; + }, function () { + return 'Are you meant to dynamically load options? You need to use "loadOptions" prop.'; + }); + } + + if (this.flat) { + warning_warning(function () { + return _this3.multiple; + }, function () { + return 'You are using flat mode. But you forgot to add "multiple=true"?'; + }); + } + + if (!this.flat) { + var propNames = ['autoSelectAncestors', 'autoSelectDescendants', 'autoDeselectAncestors', 'autoDeselectDescendants']; + propNames.forEach(function (propName) { + warning_warning(function () { + return !_this3[propName]; + }, function () { + return "\"".concat(propName, "\" only applies to flat mode."); + }); + }); + } + }, + resetFlags: function resetFlags() { + this._blurOnSelect = false; + }, + initialize: function initialize() { + var options = this.async ? this.getRemoteSearchEntry().options : this.options; + + if (Array.isArray(options)) { + var prevNodeMap = this.forest.nodeMap; + this.forest.nodeMap = createMap(); + this.keepDataOfSelectedNodes(prevNodeMap); + this.forest.normalizedOptions = this.normalize(NO_PARENT_NODE, options, prevNodeMap); + this.fixSelectedNodeIds(this.internalValue); + } else { + this.forest.normalizedOptions = []; + } + }, + getInstanceId: function getInstanceId() { + return this.instanceId == null ? this.id : this.instanceId; + }, + getValue: function getValue() { + var _this4 = this; + + if (this.valueFormat === 'id') { + return this.multiple ? this.getUniqChildValues(this.internalValue.slice()) : this.internalValue[0]; + } + + var rawNodes = this.internalValue.map(function (id) { + return _this4.getNode(id).raw; + }); + return this.multiple ? this.getUniqChildValues(rawNodes) : rawNodes[0]; + }, + getUniqChildValues: function getUniqChildValues(ids) { + var _this5 = this; + + if (this.valueConsistsOf !== BRANCH_PRIORITY) return ids; + var values = ids.map(function (id) { + var node = _this5.getNode(id); + + if (node.hasBeenSelected) return node.id; + + if (_this5.hasOneChild(node)) { + var children = []; + + _this5.traverseDescendantsBFS(node, function (descendant) { + if (!descendant.isDisabled || _this5.allowSelectingDisabledDescendants) { + if (descendant.hasBeenSelected) { + children.push(descendant.id); + } + } + }); + + if (children && children.length) return children[0]; + } + + return id; + }); + return values; + }, + hasOneChild: function hasOneChild(node) { + return node && node.children && node.children.length === 1; + }, + getNode: function getNode(nodeId) { + warning_warning(function () { + return nodeId != null; + }, function () { + return "Invalid node id: ".concat(nodeId); + }); + if (nodeId == null) return null; + return nodeId in this.forest.nodeMap ? this.forest.nodeMap[nodeId] : this.createFallbackNode(nodeId); + }, + createFallbackNode: function createFallbackNode(id) { + var raw = this.extractNodeFromValue(id); + var label = this.enhancedNormalizer(raw).label || "".concat(id, " (unknown)"); + var fallbackNode = { + id: id, + label: label, + ancestors: [], + parentNode: NO_PARENT_NODE, + isFallbackNode: true, + isRootNode: true, + isLeaf: true, + isBranch: false, + isDisabled: false, + isNew: false, + index: [-1], + level: 0, + raw: raw + }; + return this.$set(this.forest.nodeMap, id, fallbackNode); + }, + extractCheckedNodeIdsFromValue: function extractCheckedNodeIdsFromValue() { + var _this6 = this; + + if (this.value == null) return []; + + if (this.valueFormat === 'id') { + return this.multiple ? this.value.slice() : [this.value]; + } + + return (this.multiple ? this.value : [this.value]).map(function (node) { + return _this6.enhancedNormalizer(node); + }).map(function (node) { + return node.id; + }); + }, + extractNodeFromValue: function extractNodeFromValue(id) { + var _this7 = this; + + var defaultNode = { + id: id + }; + + if (this.valueFormat === 'id') { + return defaultNode; + } + + var valueArray = this.multiple ? Array.isArray(this.value) ? this.value : [] : this.value ? [this.value] : []; + var matched = find(valueArray, function (node) { + return node && _this7.enhancedNormalizer(node).id === id; + }); + return matched || defaultNode; + }, + fixSelectedNodeIds: function fixSelectedNodeIds(nodeIdListOfPrevValue) { + var _this8 = this; + + var nextSelectedNodeIds = []; + + if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) { + nextSelectedNodeIds = nodeIdListOfPrevValue; + } else if (this.valueConsistsOf === BRANCH_PRIORITY) { + nodeIdListOfPrevValue.forEach(function (nodeId) { + nextSelectedNodeIds.push(nodeId); + + var node = _this8.getNode(nodeId); + + if (node.isBranch) _this8.traverseDescendantsBFS(node, function (descendant) { + nextSelectedNodeIds.push(descendant.id); + }); + }); + } else if (this.valueConsistsOf === LEAF_PRIORITY) { + var map = createMap(); + var queue = nodeIdListOfPrevValue.slice(); + + while (queue.length) { + var nodeId = queue.shift(); + var node = this.getNode(nodeId); + nextSelectedNodeIds.push(nodeId); + if (node.isRootNode) continue; + if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length; + if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id); + } + } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) { + var _map = createMap(); + + var _queue = nodeIdListOfPrevValue.filter(function (nodeId) { + var node = _this8.getNode(nodeId); + + return node.isLeaf || node.children.length === 0; + }); + + while (_queue.length) { + var _nodeId = _queue.shift(); + + var _node = this.getNode(_nodeId); + + nextSelectedNodeIds.push(_nodeId); + if (_node.isRootNode) continue; + if (!(_node.parentNode.id in _map)) _map[_node.parentNode.id] = _node.parentNode.children.length; + if (--_map[_node.parentNode.id] === 0) _queue.push(_node.parentNode.id); + } + } + + var hasChanged = quickDiff(this.forest.selectedNodeIds, nextSelectedNodeIds); + if (hasChanged) this.forest.selectedNodeIds = nextSelectedNodeIds; + this.buildForestState(); + }, + keepDataOfSelectedNodes: function keepDataOfSelectedNodes(prevNodeMap) { + var _this9 = this; + + this.forest.selectedNodeIds.forEach(function (id) { + if (!prevNodeMap[id]) return; + + var node = _objectSpread(_objectSpread({}, prevNodeMap[id]), {}, { + isFallbackNode: true + }); + + _this9.$set(_this9.forest.nodeMap, id, node); + }); + }, + isSelected: function isSelected(node) { + return this.forest.selectedNodeMap[node.id] === true; + }, + traverseDescendantsBFS: function traverseDescendantsBFS(parentNode, callback) { + if (!parentNode.isBranch) return; + var queue = parentNode.children.slice(); + + while (queue.length) { + var currNode = queue[0]; + if (currNode.isBranch) queue.push.apply(queue, toConsumableArray_default()(currNode.children)); + callback(currNode); + queue.shift(); + } + }, + traverseDescendantsDFS: function traverseDescendantsDFS(parentNode, callback) { + var _this10 = this; + + if (!parentNode.isBranch) return; + parentNode.children.forEach(function (child) { + _this10.traverseDescendantsDFS(child, callback); + + callback(child); + }); + }, + traverseAllNodesDFS: function traverseAllNodesDFS(callback) { + var _this11 = this; + + this.forest.normalizedOptions.forEach(function (rootNode) { + _this11.traverseDescendantsDFS(rootNode, callback); + + callback(rootNode); + }); + }, + traverseAllNodesByIndex: function traverseAllNodesByIndex(callback) { + var walk = function walk(parentNode) { + parentNode.children.forEach(function (child) { + if (callback(child) !== false && child.isBranch) { + walk(child); + } + }); + }; + + walk({ + children: this.forest.normalizedOptions + }); + }, + toggleClickOutsideEvent: function toggleClickOutsideEvent(enabled) { + if (enabled) { + document.addEventListener('mousedown', this.handleClickOutside, false); + } else { + document.removeEventListener('mousedown', this.handleClickOutside, false); + } + }, + getValueContainer: function getValueContainer() { + return this.$refs.control.$refs['value-container']; + }, + getInput: function getInput() { + return this.getValueContainer().$refs.input; + }, + focusInput: function focusInput() { + this.getInput().focus(); + }, + blurInput: function blurInput() { + this.getInput().blur(); + }, + handleMouseDown: onLeftClick(function handleMouseDown(evt) { + evt.preventDefault(); + evt.stopPropagation(); + if (this.disabled) return; + var isClickedOnValueContainer = this.getValueContainer().$el.contains(evt.target); + + if (isClickedOnValueContainer && !this.menu.isOpen && (this.openOnClick || this.trigger.isFocused)) { + this.openMenu(); + } + + if (this._blurOnSelect) { + this.blurInput(); + } else { + this.focusInput(); + } + + this.resetFlags(); + }), + handleClickOutside: function handleClickOutside(evt) { + if (this.$refs.wrapper && !this.$refs.wrapper.contains(evt.target)) { + this.blurInput(); + this.closeMenu(); + } + }, + handleLocalSearch: function handleLocalSearch() { + var _this12 = this; + + var searchQuery = this.trigger.searchQuery; + + var done = function done() { + return _this12.resetHighlightedOptionWhenNecessary(true); + }; + + if (!searchQuery) { + this.localSearch.active = false; + return done(); + } + + this.localSearch.active = true; + this.localSearch.noResults = true; + this.traverseAllNodesDFS(function (node) { + if (node.isBranch) { + var _this12$$set; + + node.isExpandedOnSearch = false; + node.showAllChildrenOnSearch = false; + node.isMatched = false; + node.hasMatchedDescendants = false; + + _this12.$set(_this12.localSearch.countMap, node.id, (_this12$$set = {}, defineProperty_default()(_this12$$set, ALL_CHILDREN, 0), defineProperty_default()(_this12$$set, ALL_DESCENDANTS, 0), defineProperty_default()(_this12$$set, LEAF_CHILDREN, 0), defineProperty_default()(_this12$$set, LEAF_DESCENDANTS, 0), _this12$$set)); + } + }); + var lowerCasedSearchQuery = removeAccents(searchQuery).trim().toLocaleLowerCase(); + var splitSearchQuery = lowerCasedSearchQuery.replace(/\s+/g, ' ').split(' '); + this.traverseAllNodesDFS(function (node) { + if (_this12.searchNested && splitSearchQuery.length > 1) { + node.isMatched = splitSearchQuery.every(function (filterValue) { + return match(false, filterValue, node.nestedSearchLabel); + }); + } else { + node.isMatched = _this12.matchKeys.some(function (matchKey) { + return match(!_this12.disableFuzzyMatching, lowerCasedSearchQuery, node.lowerCased[matchKey]); + }); + } + + if (node.isMatched) { + _this12.localSearch.noResults = false; + node.ancestors.forEach(function (ancestor) { + return _this12.localSearch.countMap[ancestor.id][ALL_DESCENDANTS]++; + }); + if (node.isLeaf) node.ancestors.forEach(function (ancestor) { + return _this12.localSearch.countMap[ancestor.id][LEAF_DESCENDANTS]++; + }); + + if (node.parentNode !== NO_PARENT_NODE) { + _this12.localSearch.countMap[node.parentNode.id][ALL_CHILDREN] += 1; + if (node.isLeaf) _this12.localSearch.countMap[node.parentNode.id][LEAF_CHILDREN] += 1; + } + } + + if ((node.isMatched || node.isBranch && node.isExpandedOnSearch) && node.parentNode !== NO_PARENT_NODE) { + node.parentNode.isExpandedOnSearch = true; + node.parentNode.hasMatchedDescendants = true; + } + }); + done(); + }, + handleRemoteSearch: function handleRemoteSearch() { + var _this13 = this; + + var searchQuery = this.trigger.searchQuery; + var entry = this.getRemoteSearchEntry(); + + var done = function done() { + _this13.initialize(); + + _this13.resetHighlightedOptionWhenNecessary(true); + }; + + if ((searchQuery === '' || this.cacheOptions) && entry.isLoaded) { + return done(); + } + + this.callLoadOptionsProp({ + action: ASYNC_SEARCH, + args: { + searchQuery: searchQuery + }, + isPending: function isPending() { + return entry.isLoading; + }, + start: function start() { + entry.isLoading = true; + entry.isLoaded = false; + entry.loadingError = ''; + }, + succeed: function succeed(options) { + entry.isLoaded = true; + entry.options = options; + if (_this13.trigger.searchQuery === searchQuery) done(); + }, + fail: function fail(err) { + entry.loadingError = getErrorMessage(err); + }, + end: function end() { + entry.isLoading = false; + } + }); + }, + getRemoteSearchEntry: function getRemoteSearchEntry() { + var _this14 = this; + + var searchQuery = this.trigger.searchQuery; + + var entry = this.remoteSearch[searchQuery] || _objectSpread(_objectSpread({}, createAsyncOptionsStates()), {}, { + options: [] + }); + + this.$watch(function () { + return entry.options; + }, function () { + if (_this14.trigger.searchQuery === searchQuery) _this14.initialize(); + }, { + deep: true + }); + + if (searchQuery === '') { + if (Array.isArray(this.defaultOptions)) { + entry.options = this.defaultOptions; + entry.isLoaded = true; + return entry; + } else if (this.defaultOptions !== true) { + entry.isLoaded = true; + return entry; + } + } + + if (!this.remoteSearch[searchQuery]) { + this.$set(this.remoteSearch, searchQuery, entry); + } + + return entry; + }, + shouldExpand: function shouldExpand(node) { + return this.localSearch.active ? node.isExpandedOnSearch : node.isExpanded; + }, + shouldOptionBeIncludedInSearchResult: function shouldOptionBeIncludedInSearchResult(node) { + if (node.isMatched) return true; + if (node.isBranch && node.hasMatchedDescendants && !this.flattenSearchResults) return true; + if (!node.isRootNode && node.parentNode.showAllChildrenOnSearch) return true; + return false; + }, + shouldShowOptionInMenu: function shouldShowOptionInMenu(node) { + if (this.localSearch.active && !this.shouldOptionBeIncludedInSearchResult(node)) { + return false; + } + + return true; + }, + getControl: function getControl() { + return this.$refs.control.$el; + }, + getMenu: function getMenu() { + var ref = this.appendToBody ? this.$refs.portal.portalTarget : this; + var $menu = ref.$refs.menu.$refs.menu; + return $menu && $menu.nodeName !== '#comment' ? $menu : null; + }, + setCurrentHighlightedOption: function setCurrentHighlightedOption(node) { + var _this15 = this; + + var scroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var prev = this.menu.current; + + if (prev != null && prev in this.forest.nodeMap) { + this.forest.nodeMap[prev].isHighlighted = false; + } + + this.menu.current = node.id; + node.isHighlighted = true; + + if (this.menu.isOpen && scroll) { + var scrollToOption = function scrollToOption() { + var $menu = _this15.getMenu(); + + var $option = $menu.querySelector(".vue-treeselect__option[data-id=\"".concat(node.id, "\"]")); + if ($option) scrollIntoView($menu, $option); + }; + + if (this.getMenu()) { + scrollToOption(); + } else { + this.$nextTick(scrollToOption); + } + } + }, + resetHighlightedOptionWhenNecessary: function resetHighlightedOptionWhenNecessary() { + var forceReset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var current = this.menu.current; + + if (forceReset || current == null || !(current in this.forest.nodeMap) || !this.shouldShowOptionInMenu(this.getNode(current))) { + this.highlightFirstOption(); + } + }, + highlightFirstOption: function highlightFirstOption() { + if (!this.hasVisibleOptions) return; + var first = this.visibleOptionIds[0]; + this.setCurrentHighlightedOption(this.getNode(first)); + }, + highlightPrevOption: function highlightPrevOption() { + if (!this.hasVisibleOptions) return; + var prev = this.visibleOptionIds.indexOf(this.menu.current) - 1; + if (prev === -1) return this.highlightLastOption(); + this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[prev])); + }, + highlightNextOption: function highlightNextOption() { + if (!this.hasVisibleOptions) return; + var next = this.visibleOptionIds.indexOf(this.menu.current) + 1; + if (next === this.visibleOptionIds.length) return this.highlightFirstOption(); + this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[next])); + }, + highlightLastOption: function highlightLastOption() { + if (!this.hasVisibleOptions) return; + var last = last_default()(this.visibleOptionIds); + this.setCurrentHighlightedOption(this.getNode(last)); + }, + resetSearchQuery: function resetSearchQuery() { + this.trigger.searchQuery = ''; + }, + closeMenu: function closeMenu() { + if (!this.menu.isOpen || !this.disabled && this.alwaysOpen) return; + this.saveMenuScrollPosition(); + this.menu.isOpen = false; + this.toggleClickOutsideEvent(false); + this.resetSearchQuery(); + this.$emit('close', this.getValue(), this.getInstanceId()); + }, + openMenu: function openMenu() { + if (this.disabled || this.menu.isOpen) return; + this.menu.isOpen = true; + this.$nextTick(this.resetHighlightedOptionWhenNecessary); + this.$nextTick(this.restoreMenuScrollPosition); + if (!this.options && !this.async) this.loadRootOptions(); + this.toggleClickOutsideEvent(true); + this.$emit('open', this.getInstanceId()); + }, + toggleMenu: function toggleMenu() { + if (this.menu.isOpen) { + this.closeMenu(); + } else { + this.openMenu(); + } + }, + toggleExpanded: function toggleExpanded(node) { + var nextState; + + if (this.localSearch.active) { + nextState = node.isExpandedOnSearch = !node.isExpandedOnSearch; + if (nextState) node.showAllChildrenOnSearch = true; + } else { + nextState = node.isExpanded = !node.isExpanded; + } + + if (nextState && !node.childrenStates.isLoaded) { + this.loadChildrenOptions(node); + } + }, + buildForestState: function buildForestState() { + var _this16 = this; + + var selectedNodeMap = createMap(); + this.forest.selectedNodeIds.forEach(function (selectedNodeId) { + selectedNodeMap[selectedNodeId] = true; + }); + this.forest.selectedNodeMap = selectedNodeMap; + var checkedStateMap = createMap(); + + if (this.multiple) { + this.traverseAllNodesByIndex(function (node) { + checkedStateMap[node.id] = UNCHECKED; + }); + this.selectedNodes.forEach(function (selectedNode) { + checkedStateMap[selectedNode.id] = CHECKED; + + if (!_this16.flat && !_this16.disableBranchNodes) { + selectedNode.ancestors.forEach(function (ancestorNode) { + if (!_this16.isSelected(ancestorNode)) { + checkedStateMap[ancestorNode.id] = INDETERMINATE; + } + }); + } + }); + } + + this.forest.checkedStateMap = checkedStateMap; + }, + enhancedNormalizer: function enhancedNormalizer(raw) { + return _objectSpread(_objectSpread({}, raw), this.normalizer(raw, this.getInstanceId())); + }, + normalize: function normalize(parentNode, nodes, prevNodeMap) { + var _this17 = this; + + var normalizedOptions = nodes.map(function (node) { + return [_this17.enhancedNormalizer(node), node]; + }).map(function (_ref, index) { + var _ref2 = slicedToArray_default()(_ref, 2), + node = _ref2[0], + raw = _ref2[1]; + + _this17.checkDuplication(node); + + _this17.verifyNodeShape(node); + + var id = node.id, + label = node.label, + children = node.children, + isDefaultExpanded = node.isDefaultExpanded; + var isRootNode = parentNode === NO_PARENT_NODE; + var level = isRootNode ? 0 : parentNode.level + 1; + var isBranch = Array.isArray(children) || children === null; + var isLeaf = !isBranch; + var isDisabled = !!node.isDisabled || !_this17.flat && !isRootNode && parentNode.isDisabled; + var isNew = !!node.isNew; + + var lowerCased = _this17.matchKeys.reduce(function (prev, key) { + return _objectSpread(_objectSpread({}, prev), {}, defineProperty_default()({}, key, stringifyOptionPropValue(node[key]).toLocaleLowerCase())); + }, {}); + + var nestedSearchLabel = isRootNode ? lowerCased.label : parentNode.nestedSearchLabel + ' ' + lowerCased.label; + + var normalized = _this17.$set(_this17.forest.nodeMap, id, createMap()); + + _this17.$set(normalized, 'id', id); + + _this17.$set(normalized, 'label', label); + + _this17.$set(normalized, 'level', level); + + _this17.$set(normalized, 'ancestors', isRootNode ? [] : [parentNode].concat(parentNode.ancestors)); + + _this17.$set(normalized, 'index', (isRootNode ? [] : parentNode.index).concat(index)); + + _this17.$set(normalized, 'parentNode', parentNode); + + _this17.$set(normalized, 'lowerCased', lowerCased); + + _this17.$set(normalized, 'nestedSearchLabel', nestedSearchLabel); + + _this17.$set(normalized, 'isDisabled', isDisabled); + + _this17.$set(normalized, 'isNew', isNew); + + _this17.$set(normalized, 'isMatched', false); + + _this17.$set(normalized, 'isHighlighted', false); + + _this17.$set(normalized, 'isBranch', isBranch); + + _this17.$set(normalized, 'isLeaf', isLeaf); + + _this17.$set(normalized, 'isRootNode', isRootNode); + + _this17.$set(normalized, 'raw', raw); + + if (isBranch) { + var _this17$$set; + + var isLoaded = Array.isArray(children); + + _this17.$set(normalized, 'childrenStates', _objectSpread(_objectSpread({}, createAsyncOptionsStates()), {}, { + isLoaded: isLoaded + })); + + _this17.$set(normalized, 'isExpanded', typeof isDefaultExpanded === 'boolean' ? isDefaultExpanded : level < _this17.defaultExpandLevel); + + _this17.$set(normalized, 'hasMatchedDescendants', false); + + _this17.$set(normalized, 'hasDisabledDescendants', false); + + _this17.$set(normalized, 'isExpandedOnSearch', false); + + _this17.$set(normalized, 'showAllChildrenOnSearch', false); + + _this17.$set(normalized, 'count', (_this17$$set = {}, defineProperty_default()(_this17$$set, ALL_CHILDREN, 0), defineProperty_default()(_this17$$set, ALL_DESCENDANTS, 0), defineProperty_default()(_this17$$set, LEAF_CHILDREN, 0), defineProperty_default()(_this17$$set, LEAF_DESCENDANTS, 0), _this17$$set)); + + _this17.$set(normalized, 'children', isLoaded ? _this17.normalize(normalized, children, prevNodeMap) : []); + + if (isDefaultExpanded === true) normalized.ancestors.forEach(function (ancestor) { + ancestor.isExpanded = true; + }); + + if (!isLoaded && typeof _this17.loadOptions !== 'function') { + warning_warning(function () { + return false; + }, function () { + return 'Unloaded branch node detected. "loadOptions" prop is required to load its children.'; + }); + } else if (!isLoaded && normalized.isExpanded) { + _this17.loadChildrenOptions(normalized); + } + } + + normalized.ancestors.forEach(function (ancestor) { + return ancestor.count[ALL_DESCENDANTS]++; + }); + if (isLeaf) normalized.ancestors.forEach(function (ancestor) { + return ancestor.count[LEAF_DESCENDANTS]++; + }); + + if (!isRootNode) { + parentNode.count[ALL_CHILDREN] += 1; + if (isLeaf) parentNode.count[LEAF_CHILDREN] += 1; + if (isDisabled) parentNode.hasDisabledDescendants = true; + } + + if (prevNodeMap && prevNodeMap[id]) { + var prev = prevNodeMap[id]; + normalized.isMatched = prev.isMatched; + normalized.showAllChildrenOnSearch = prev.showAllChildrenOnSearch; + normalized.isHighlighted = prev.isHighlighted; + + if (prev.isBranch && normalized.isBranch) { + normalized.isExpanded = prev.isExpanded; + normalized.isExpandedOnSearch = prev.isExpandedOnSearch; + + if (prev.childrenStates.isLoaded && !normalized.childrenStates.isLoaded) { + normalized.isExpanded = false; + } else { + normalized.childrenStates = _objectSpread({}, prev.childrenStates); + } + } + } + + return normalized; + }); + + if (this.branchNodesFirst) { + var branchNodes = normalizedOptions.filter(function (option) { + return option.isBranch; + }); + var leafNodes = normalizedOptions.filter(function (option) { + return option.isLeaf; + }); + normalizedOptions = branchNodes.concat(leafNodes); + } + + return normalizedOptions; + }, + loadRootOptions: function loadRootOptions() { + var _this18 = this; + + this.callLoadOptionsProp({ + action: LOAD_ROOT_OPTIONS, + isPending: function isPending() { + return _this18.rootOptionsStates.isLoading; + }, + start: function start() { + _this18.rootOptionsStates.isLoading = true; + _this18.rootOptionsStates.loadingError = ''; + }, + succeed: function succeed() { + _this18.rootOptionsStates.isLoaded = true; + + _this18.$nextTick(function () { + _this18.resetHighlightedOptionWhenNecessary(true); + }); + }, + fail: function fail(err) { + _this18.rootOptionsStates.loadingError = getErrorMessage(err); + }, + end: function end() { + _this18.rootOptionsStates.isLoading = false; + } + }); + }, + loadChildrenOptions: function loadChildrenOptions(parentNode) { + var _this19 = this; + + var id = parentNode.id, + raw = parentNode.raw; + this.callLoadOptionsProp({ + action: LOAD_CHILDREN_OPTIONS, + args: { + parentNode: raw + }, + isPending: function isPending() { + return _this19.getNode(id).childrenStates.isLoading; + }, + start: function start() { + _this19.getNode(id).childrenStates.isLoading = true; + _this19.getNode(id).childrenStates.loadingError = ''; + }, + succeed: function succeed() { + _this19.getNode(id).childrenStates.isLoaded = true; + }, + fail: function fail(err) { + _this19.getNode(id).childrenStates.loadingError = getErrorMessage(err); + }, + end: function end() { + _this19.getNode(id).childrenStates.isLoading = false; + } + }); + }, + callLoadOptionsProp: function callLoadOptionsProp(_ref3) { + var action = _ref3.action, + args = _ref3.args, + isPending = _ref3.isPending, + start = _ref3.start, + succeed = _ref3.succeed, + fail = _ref3.fail, + end = _ref3.end; + + if (!this.loadOptions || isPending()) { + return; + } + + start(); + var callback = once_default()(function (err, result) { + if (err) { + fail(err); + } else { + succeed(result); + } + + end(); + }); + var result = this.loadOptions(_objectSpread(_objectSpread({ + id: this.getInstanceId(), + instanceId: this.getInstanceId(), + action: action + }, args), {}, { + callback: callback + })); + + if (external_is_promise_default()(result)) { + result.then(function () { + callback(); + }, function (err) { + callback(err); + }).catch(function (err) { + console.error(err); + }); + } + }, + checkDuplication: function checkDuplication(node) { + var _this20 = this; + + warning_warning(function () { + return !(node.id in _this20.forest.nodeMap && !_this20.forest.nodeMap[node.id].isFallbackNode); + }, function () { + return "Detected duplicate presence of node id ".concat(JSON.stringify(node.id), ". ") + "Their labels are \"".concat(_this20.forest.nodeMap[node.id].label, "\" and \"").concat(node.label, "\" respectively."); + }); + }, + verifyNodeShape: function verifyNodeShape(node) { + warning_warning(function () { + return !(node.children === undefined && node.isBranch === true); + }, function () { + return 'Are you meant to declare an unloaded branch node? ' + '`isBranch: true` is no longer supported, please use `children: null` instead.'; + }); + }, + select: function select(node) { + if (this.disabled || node.isDisabled) { + return; + } + + if (this.single) { + this.clear(); + } + + var nextState = this.multiple && !this.flat ? this.forest.checkedStateMap[node.id] === UNCHECKED : !this.isSelected(node); + + if (nextState) { + this._selectNode(node); + } else { + this._deselectNode(node); + } + + this.buildForestState(); + + if (nextState) { + this.$emit('select', node.raw, this.getInstanceId()); + } else { + this.$emit('deselect', node.raw, this.getInstanceId()); + } + + if (this.localSearch.active && nextState && (this.single || this.clearOnSelect)) { + this.resetSearchQuery(); + } + + if (this.single && this.closeOnSelect) { + this.closeMenu(); + + if (this.searchable) { + this._blurOnSelect = true; + } + } + }, + clear: function clear() { + var _this21 = this; + + if (this.hasValue) { + if (this.single || this.allowClearingDisabled) { + this.forest.selectedNodeIds = []; + } else { + this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(function (nodeId) { + return _this21.getNode(nodeId).isDisabled; + }); + } + + this.buildForestState(); + } + }, + _selectNode: function _selectNode(node) { + var _this22 = this; + + node.hasBeenSelected = node.id; + + if (this.single || this.disableBranchNodes) { + return this.addValue(node); + } + + if (this.flat) { + this.addValue(node); + + if (this.autoSelectAncestors) { + node.ancestors.forEach(function (ancestor) { + if (!_this22.isSelected(ancestor) && !ancestor.isDisabled) _this22.addValue(ancestor); + }); + } else if (this.autoSelectDescendants) { + this.traverseDescendantsBFS(node, function (descendant) { + if (!_this22.isSelected(descendant) && !descendant.isDisabled) _this22.addValue(descendant); + }); + } + + return; + } + + var isFullyChecked = node.isLeaf || !node.hasDisabledDescendants || this.allowSelectingDisabledDescendants; + + if (isFullyChecked) { + this.addValue(node); + } + + if (node.isBranch) { + this.traverseDescendantsBFS(node, function (descendant) { + if (!descendant.isDisabled || _this22.allowSelectingDisabledDescendants) { + _this22.addValue(descendant); + } + }); + } + + if (isFullyChecked) { + var curr = node; + + while ((curr = curr.parentNode) !== NO_PARENT_NODE) { + if (curr.children.every(this.isSelected)) this.addValue(curr);else break; + } + } + }, + _deselectNode: function _deselectNode(node) { + var _this23 = this; + + if (this.disableBranchNodes) { + return this.removeValue(node); + } + + if (this.flat) { + this.removeValue(node); + + if (this.autoDeselectAncestors) { + node.ancestors.forEach(function (ancestor) { + if (_this23.isSelected(ancestor) && !ancestor.isDisabled) _this23.removeValue(ancestor); + }); + } else if (this.autoDeselectDescendants) { + this.traverseDescendantsBFS(node, function (descendant) { + if (_this23.isSelected(descendant) && !descendant.isDisabled) _this23.removeValue(descendant); + }); + } + + return; + } + + var hasUncheckedSomeDescendants = false; + + if (node.isBranch) { + this.traverseDescendantsDFS(node, function (descendant) { + if (!descendant.isDisabled || _this23.allowSelectingDisabledDescendants) { + _this23.removeValue(descendant); + + hasUncheckedSomeDescendants = true; + } + }); + } + + if (node.isLeaf || hasUncheckedSomeDescendants || node.children.length === 0) { + this.removeValue(node); + var curr = node; + + while ((curr = curr.parentNode) !== NO_PARENT_NODE) { + if (this.isSelected(curr)) this.removeValue(curr);else break; + } + } + }, + addValue: function addValue(node) { + this.forest.selectedNodeIds.push(node.id); + this.forest.selectedNodeMap[node.id] = true; + }, + removeValue: function removeValue(node) { + delete node.hasBeenSelected; + removeFromArray(this.forest.selectedNodeIds, node.id); + delete this.forest.selectedNodeMap[node.id]; + }, + removeLastValue: function removeLastValue() { + if (!this.hasValue) return; + if (this.single) return this.clear(); + var lastValue = last_default()(this.internalValue); + var lastSelectedNode = this.getNode(lastValue); + this.select(lastSelectedNode); + }, + saveMenuScrollPosition: function saveMenuScrollPosition() { + var $menu = this.getMenu(); + if ($menu) this.menu.lastScrollPosition = $menu.scrollTop; + }, + restoreMenuScrollPosition: function restoreMenuScrollPosition() { + var $menu = this.getMenu(); + if ($menu) $menu.scrollTop = this.menu.lastScrollPosition; + } + }, + created: function created() { + this.verifyProps(); + this.resetFlags(); + }, + mounted: function mounted() { + if (this.autoFocus) this.focusInput(); + if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions(); + if (this.alwaysOpen) this.openMenu(); + if (this.async && this.defaultOptions) this.handleRemoteSearch(); + }, + destroyed: function destroyed() { + this.toggleClickOutsideEvent(false); + } +}); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/HiddenFields.vue?vue&type=script&lang=js& + + +function stringifyValue(value) { + if (typeof value === 'string') return value; + if (value != null && !isNaN_isNaN(value)) return JSON.stringify(value); + return ''; +} + +/* harmony default export */ var HiddenFieldsvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--hidden-fields', + inject: ['instance'], + functional: true, + render: function render(_, context) { + var h = arguments[0]; + var instance = context.injections.instance; + if (!instance.name || instance.disabled || !instance.hasValue) return null; + var stringifiedValues = instance.internalValue.map(stringifyValue); + if (instance.multiple && instance.joinValues) stringifiedValues = [stringifiedValues.join(instance.delimiter)]; + return stringifiedValues.map(function (stringifiedValue, i) { + return h("input", { + attrs: { + type: "hidden", + name: instance.name + }, + domProps: { + "value": stringifiedValue + }, + key: 'hidden-field-' + i + }); + }); + } +}); +// CONCATENATED MODULE: ./src/components/HiddenFields.vue?vue&type=script&lang=js& + /* harmony default export */ var components_HiddenFieldsvue_type_script_lang_js_ = (HiddenFieldsvue_type_script_lang_js_); +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js +/* globals __VUE_SSR_CONTEXT__ */ + +// IMPORTANT: Do NOT use ES2015 features in this file (except for modules). +// This module is a runtime utility for cleaner component module output and will +// be included in the final webpack user bundle. + +function normalizeComponent ( + scriptExports, + render, + staticRenderFns, + functionalTemplate, + injectStyles, + scopeId, + moduleIdentifier, /* server only */ + shadowMode /* vue-cli only */ +) { + // Vue.extend constructor export interop + var options = typeof scriptExports === 'function' + ? scriptExports.options + : scriptExports + + // render functions + if (render) { + options.render = render + options.staticRenderFns = staticRenderFns + options._compiled = true + } + + // functional template + if (functionalTemplate) { + options.functional = true + } + + // scopedId + if (scopeId) { + options._scopeId = 'data-v-' + scopeId + } + + var hook + if (moduleIdentifier) { // server build + hook = function (context) { + // 2.3 injection + context = + context || // cached call + (this.$vnode && this.$vnode.ssrContext) || // stateful + (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional + // 2.2 with runInNewContext: true + if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') { + context = __VUE_SSR_CONTEXT__ + } + // inject component styles + if (injectStyles) { + injectStyles.call(this, context) + } + // register component module identifier for async chunk inferrence + if (context && context._registeredComponents) { + context._registeredComponents.add(moduleIdentifier) + } + } + // used by ssr in case component is cached and beforeCreate + // never gets called + options._ssrRegister = hook + } else if (injectStyles) { + hook = shadowMode + ? function () { + injectStyles.call( + this, + (options.functional ? this.parent : this).$root.$options.shadowRoot + ) + } + : injectStyles + } + + if (hook) { + if (options.functional) { + // for template-only hot-reload because in that case the render fn doesn't + // go through the normalizer + options._injectStyles = hook + // register for functional component in vue file + var originalRender = options.render + options.render = function renderWithStyleInjection (h, context) { + hook.call(context) + return originalRender(h, context) + } + } else { + // inject component registration as beforeCreate hook + var existing = options.beforeCreate + options.beforeCreate = existing + ? [].concat(existing, hook) + : [hook] + } + } + + return { + exports: scriptExports, + options: options + } +} + +// CONCATENATED MODULE: ./src/components/HiddenFields.vue +var HiddenFields_render, staticRenderFns + + + + +/* normalize component */ + +var component = normalizeComponent( + components_HiddenFieldsvue_type_script_lang_js_, + HiddenFields_render, + staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var api; } +component.options.__file = "src/components/HiddenFields.vue" +/* harmony default export */ var HiddenFields = (component.exports); +// EXTERNAL MODULE: external "babel-helper-vue-jsx-merge-props" +var external_babel_helper_vue_jsx_merge_props_ = __webpack_require__(13); +var external_babel_helper_vue_jsx_merge_props_default = /*#__PURE__*/__webpack_require__.n(external_babel_helper_vue_jsx_merge_props_); + +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Input.vue?vue&type=script&lang=js& + + + +var keysThatRequireMenuBeingOpen = [KEY_CODES.ENTER, KEY_CODES.END, KEY_CODES.HOME, KEY_CODES.ARROW_LEFT, KEY_CODES.ARROW_UP, KEY_CODES.ARROW_RIGHT, KEY_CODES.ARROW_DOWN]; +/* harmony default export */ var Inputvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--input', + inject: ['instance'], + data: function data() { + return { + inputWidth: MIN_INPUT_WIDTH, + value: '' + }; + }, + computed: { + needAutoSize: function needAutoSize() { + var instance = this.instance; + return instance.searchable && !instance.disabled && instance.multiple; + }, + inputStyle: function inputStyle() { + return { + width: this.needAutoSize ? "".concat(this.inputWidth, "px") : null + }; + } + }, + watch: { + 'instance.trigger.searchQuery': function instanceTriggerSearchQuery(newValue) { + this.value = newValue; + }, + value: function value() { + if (this.needAutoSize) this.$nextTick(this.updateInputWidth); + } + }, + created: function created() { + this.debouncedCallback = debounce_default()(this.updateSearchQuery, INPUT_DEBOUNCE_DELAY, { + leading: true, + trailing: true + }); + }, + methods: { + clear: function clear() { + this.onInput({ + target: { + value: '' + } + }); + }, + focus: function focus() { + var instance = this.instance; + + if (!instance.disabled) { + this.$refs.input && this.$refs.input.focus(); + } + }, + blur: function blur() { + this.$refs.input && this.$refs.input.blur(); + }, + onFocus: function onFocus() { + var instance = this.instance; + instance.trigger.isFocused = true; + if (instance.openOnFocus) instance.openMenu(); + }, + onBlur: function onBlur() { + var instance = this.instance; + var menu = instance.getMenu(); + + if (menu && document.activeElement === menu) { + return this.focus(); + } + + instance.trigger.isFocused = false; + instance.closeMenu(); + }, + onInput: function onInput(evt) { + var value = evt.target.value; + this.value = value; + + if (value) { + this.debouncedCallback(); + } else { + this.debouncedCallback.cancel(); + this.updateSearchQuery(); + } + }, + onKeyDown: function onKeyDown(evt) { + var instance = this.instance; + var key = 'which' in evt ? evt.which : evt.keyCode; + if (evt.ctrlKey || evt.shiftKey || evt.altKey || evt.metaKey) return; + + if (!instance.menu.isOpen && includes(keysThatRequireMenuBeingOpen, key)) { + evt.preventDefault(); + return instance.openMenu(); + } + + switch (key) { + case KEY_CODES.BACKSPACE: + { + if (instance.backspaceRemoves && !this.value.length) { + instance.removeLastValue(); + } + + break; + } + + case KEY_CODES.ENTER: + { + evt.preventDefault(); + if (instance.menu.current === null) return; + var current = instance.getNode(instance.menu.current); + if (current.isBranch && instance.disableBranchNodes) return; + instance.select(current); + break; + } + + case KEY_CODES.ESCAPE: + { + if (this.value.length) { + this.clear(); + } else if (instance.menu.isOpen) { + instance.closeMenu(); + } + + break; + } + + case KEY_CODES.END: + { + evt.preventDefault(); + instance.highlightLastOption(); + break; + } + + case KEY_CODES.HOME: + { + evt.preventDefault(); + instance.highlightFirstOption(); + break; + } + + case KEY_CODES.ARROW_LEFT: + { + var _current = instance.getNode(instance.menu.current); + + if (_current.isBranch && instance.shouldExpand(_current)) { + evt.preventDefault(); + instance.toggleExpanded(_current); + } else if (!_current.isRootNode && (_current.isLeaf || _current.isBranch && !instance.shouldExpand(_current))) { + evt.preventDefault(); + instance.setCurrentHighlightedOption(_current.parentNode); + } + + break; + } + + case KEY_CODES.ARROW_UP: + { + evt.preventDefault(); + instance.highlightPrevOption(); + break; + } + + case KEY_CODES.ARROW_RIGHT: + { + var _current2 = instance.getNode(instance.menu.current); + + if (_current2.isBranch && !instance.shouldExpand(_current2)) { + evt.preventDefault(); + instance.toggleExpanded(_current2); + } + + break; + } + + case KEY_CODES.ARROW_DOWN: + { + evt.preventDefault(); + instance.highlightNextOption(); + break; + } + + case KEY_CODES.DELETE: + { + if (instance.deleteRemoves && !this.value.length) { + instance.removeLastValue(); + } + + break; + } + + default: + { + instance.openMenu(); + } + } + }, + onMouseDown: function onMouseDown(evt) { + if (this.value.length) { + evt.stopPropagation(); + } + }, + renderInputContainer: function renderInputContainer() { + var h = this.$createElement; + var instance = this.instance; + var props = {}; + var children = []; + + if (instance.searchable && !instance.disabled) { + children.push(this.renderInput()); + if (this.needAutoSize) children.push(this.renderSizer()); + } + + if (!instance.searchable) { + deepExtend(props, { + on: { + focus: this.onFocus, + blur: this.onBlur, + keydown: this.onKeyDown + }, + ref: 'input' + }); + } + + if (!instance.searchable && !instance.disabled) { + deepExtend(props, { + attrs: { + tabIndex: instance.tabIndex + } + }); + } + + return h("div", external_babel_helper_vue_jsx_merge_props_default()([{ + "class": "vue-treeselect__input-container" + }, props]), [children]); + }, + renderInput: function renderInput() { + var h = this.$createElement; + var instance = this.instance; + return h("input", { + ref: "input", + "class": "vue-treeselect__input", + attrs: { + type: "text", + autocomplete: "off", + tabIndex: instance.tabIndex, + required: instance.required && !instance.hasValue + }, + domProps: { + "value": this.value + }, + style: this.inputStyle, + on: { + "focus": this.onFocus, + "input": this.onInput, + "blur": this.onBlur, + "keydown": this.onKeyDown, + "mousedown": this.onMouseDown + } + }); + }, + renderSizer: function renderSizer() { + var h = this.$createElement; + return h("div", { + ref: "sizer", + "class": "vue-treeselect__sizer" + }, [this.value]); + }, + updateInputWidth: function updateInputWidth() { + this.inputWidth = Math.max(MIN_INPUT_WIDTH, this.$refs.sizer.scrollWidth + 15); + }, + updateSearchQuery: function updateSearchQuery() { + var instance = this.instance; + instance.trigger.searchQuery = this.value; + } + }, + render: function render() { + return this.renderInputContainer(); + } +}); +// CONCATENATED MODULE: ./src/components/Input.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Inputvue_type_script_lang_js_ = (Inputvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Input.vue +var Input_render, Input_staticRenderFns + + + + +/* normalize component */ + +var Input_component = normalizeComponent( + components_Inputvue_type_script_lang_js_, + Input_render, + Input_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Input_api; } +Input_component.options.__file = "src/components/Input.vue" +/* harmony default export */ var Input = (Input_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Placeholder.vue?vue&type=script&lang=js& +/* harmony default export */ var Placeholdervue_type_script_lang_js_ = ({ + name: 'vue-treeselect--placeholder', + inject: ['instance'], + render: function render() { + var h = arguments[0]; + var instance = this.instance; + var placeholderClass = { + 'vue-treeselect__placeholder': true, + 'vue-treeselect-helper-zoom-effect-off': true, + 'vue-treeselect-helper-hide': instance.hasValue || instance.trigger.searchQuery + }; + return h("div", { + "class": placeholderClass + }, [instance.placeholder]); + } +}); +// CONCATENATED MODULE: ./src/components/Placeholder.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Placeholdervue_type_script_lang_js_ = (Placeholdervue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Placeholder.vue +var Placeholder_render, Placeholder_staticRenderFns + + + + +/* normalize component */ + +var Placeholder_component = normalizeComponent( + components_Placeholdervue_type_script_lang_js_, + Placeholder_render, + Placeholder_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Placeholder_api; } +Placeholder_component.options.__file = "src/components/Placeholder.vue" +/* harmony default export */ var Placeholder = (Placeholder_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/SingleValue.vue?vue&type=script&lang=js& + + +/* harmony default export */ var SingleValuevue_type_script_lang_js_ = ({ + name: 'vue-treeselect--single-value', + inject: ['instance'], + methods: { + renderSingleValueLabel: function renderSingleValueLabel() { + var instance = this.instance; + var node = instance.selectedNodes[0]; + var customValueLabelRenderer = instance.$scopedSlots['value-label']; + return customValueLabelRenderer ? customValueLabelRenderer({ + node: node + }) : node.label; + } + }, + render: function render() { + var h = arguments[0]; + var instance = this.instance, + renderValueContainer = this.$parent.renderValueContainer; + var shouldShowValue = instance.hasValue && !instance.trigger.searchQuery; + return renderValueContainer([shouldShowValue && h("div", { + "class": "vue-treeselect__single-value" + }, [this.renderSingleValueLabel()]), h(Placeholder), h(Input, { + ref: "input" + })]); + } +}); +// CONCATENATED MODULE: ./src/components/SingleValue.vue?vue&type=script&lang=js& + /* harmony default export */ var components_SingleValuevue_type_script_lang_js_ = (SingleValuevue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/SingleValue.vue +var SingleValue_render, SingleValue_staticRenderFns + + + + +/* normalize component */ + +var SingleValue_component = normalizeComponent( + components_SingleValuevue_type_script_lang_js_, + SingleValue_render, + SingleValue_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var SingleValue_api; } +SingleValue_component.options.__file = "src/components/SingleValue.vue" +/* harmony default export */ var SingleValue = (SingleValue_component.exports); +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/cache-loader/dist/cjs.js!./node_modules/vue-loader/lib??vue-loader-options!./src/components/icons/Delete.vue?vue&type=template&id=364b6320& +var Deletevue_type_template_id_364b6320_render = function () { + var _vm = this + var _h = _vm.$createElement + var _c = _vm._self._c || _h + return _c( + "svg", + { + attrs: { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 348.333 348.333", + }, + }, + [ + _c("path", { + attrs: { + d: "M336.559 68.611L231.016 174.165l105.543 105.549c15.699 15.705 15.699 41.145 0 56.85-7.844 7.844-18.128 11.769-28.407 11.769-10.296 0-20.581-3.919-28.419-11.769L174.167 231.003 68.609 336.563c-7.843 7.844-18.128 11.769-28.416 11.769-10.285 0-20.563-3.919-28.413-11.769-15.699-15.698-15.699-41.139 0-56.85l105.54-105.549L11.774 68.611c-15.699-15.699-15.699-41.145 0-56.844 15.696-15.687 41.127-15.687 56.829 0l105.563 105.554L279.721 11.767c15.705-15.687 41.139-15.687 56.832 0 15.705 15.699 15.705 41.145.006 56.844z", + }, + }), + ] + ) +} +var Deletevue_type_template_id_364b6320_staticRenderFns = [] +Deletevue_type_template_id_364b6320_render._withStripped = true + + +// CONCATENATED MODULE: ./src/components/icons/Delete.vue?vue&type=template&id=364b6320& + +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/icons/Delete.vue?vue&type=script&lang=js& +/* harmony default export */ var Deletevue_type_script_lang_js_ = ({ + name: 'vue-treeselect--x' +}); +// CONCATENATED MODULE: ./src/components/icons/Delete.vue?vue&type=script&lang=js& + /* harmony default export */ var icons_Deletevue_type_script_lang_js_ = (Deletevue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/icons/Delete.vue + + + + + +/* normalize component */ + +var Delete_component = normalizeComponent( + icons_Deletevue_type_script_lang_js_, + Deletevue_type_template_id_364b6320_render, + Deletevue_type_template_id_364b6320_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Delete_api; } +Delete_component.options.__file = "src/components/icons/Delete.vue" +/* harmony default export */ var Delete = (Delete_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/MultiValueItem.vue?vue&type=script&lang=js& + + +/* harmony default export */ var MultiValueItemvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--multi-value-item', + inject: ['instance'], + props: { + node: { + type: Object, + required: true + } + }, + methods: { + handleMouseDown: onLeftClick(function handleMouseDown() { + var instance = this.instance, + node = this.node; + instance.select(node); + }) + }, + render: function render() { + var h = arguments[0]; + var instance = this.instance, + node = this.node; + var itemClass = { + 'vue-treeselect__multi-value-item': true, + 'vue-treeselect__multi-value-item-disabled': node.isDisabled, + 'vue-treeselect__multi-value-item-new': node.isNew + }; + var customValueLabelRenderer = instance.$scopedSlots['value-label']; + var labelRenderer = customValueLabelRenderer ? customValueLabelRenderer({ + node: node + }) : node.label; + return h("div", { + "class": "vue-treeselect__multi-value-item-container" + }, [h("div", { + "class": itemClass, + on: { + "mousedown": this.handleMouseDown + } + }, [h("span", { + "class": "vue-treeselect__multi-value-label" + }, [labelRenderer]), h("span", { + "class": "vue-treeselect__icon vue-treeselect__value-remove" + }, [h(Delete)])])]); + } +}); +// CONCATENATED MODULE: ./src/components/MultiValueItem.vue?vue&type=script&lang=js& + /* harmony default export */ var components_MultiValueItemvue_type_script_lang_js_ = (MultiValueItemvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/MultiValueItem.vue +var MultiValueItem_render, MultiValueItem_staticRenderFns + + + + +/* normalize component */ + +var MultiValueItem_component = normalizeComponent( + components_MultiValueItemvue_type_script_lang_js_, + MultiValueItem_render, + MultiValueItem_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var MultiValueItem_api; } +MultiValueItem_component.options.__file = "src/components/MultiValueItem.vue" +/* harmony default export */ var MultiValueItem = (MultiValueItem_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/MultiValue.vue?vue&type=script&lang=js& + + + + +/* harmony default export */ var MultiValuevue_type_script_lang_js_ = ({ + name: 'vue-treeselect--multi-value', + inject: ['instance'], + methods: { + renderMultiValueItems: function renderMultiValueItems() { + var h = this.$createElement; + var instance = this.instance; + return instance.internalValue.slice(0, instance.limit).map(instance.getNode).map(function (node) { + return h(MultiValueItem, { + key: "multi-value-item-".concat(node.id), + attrs: { + node: node + } + }); + }); + }, + renderExceedLimitTip: function renderExceedLimitTip() { + var h = this.$createElement; + var instance = this.instance; + var count = instance.internalValue.length - instance.limit; + if (count <= 0) return null; + return h("div", { + "class": "vue-treeselect__limit-tip vue-treeselect-helper-zoom-effect-off", + key: "exceed-limit-tip" + }, [h("span", { + "class": "vue-treeselect__limit-tip-text" + }, [instance.limitText(count)])]); + } + }, + render: function render() { + var h = arguments[0]; + var renderValueContainer = this.$parent.renderValueContainer; + var transitionGroupProps = { + props: { + tag: 'div', + name: 'vue-treeselect__multi-value-item--transition', + appear: true + } + }; + return renderValueContainer(h("transition-group", external_babel_helper_vue_jsx_merge_props_default()([{ + "class": "vue-treeselect__multi-value" + }, transitionGroupProps]), [this.renderMultiValueItems(), this.renderExceedLimitTip(), h(Placeholder, { + key: "placeholder" + }), h(Input, { + ref: "input", + key: "input" + })])); + } +}); +// CONCATENATED MODULE: ./src/components/MultiValue.vue?vue&type=script&lang=js& + /* harmony default export */ var components_MultiValuevue_type_script_lang_js_ = (MultiValuevue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/MultiValue.vue +var MultiValue_render, MultiValue_staticRenderFns + + + + +/* normalize component */ + +var MultiValue_component = normalizeComponent( + components_MultiValuevue_type_script_lang_js_, + MultiValue_render, + MultiValue_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var MultiValue_api; } +MultiValue_component.options.__file = "src/components/MultiValue.vue" +/* harmony default export */ var MultiValue = (MultiValue_component.exports); +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/cache-loader/dist/cjs.js!./node_modules/vue-loader/lib??vue-loader-options!./src/components/icons/Arrow.vue?vue&type=template&id=11186cd4& +var Arrowvue_type_template_id_11186cd4_render = function () { + var _vm = this + var _h = _vm.$createElement + var _c = _vm._self._c || _h + return _c( + "svg", + { + attrs: { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 292.362 292.362", + }, + }, + [ + _c("path", { + attrs: { + d: "M286.935 69.377c-3.614-3.617-7.898-5.424-12.848-5.424H18.274c-4.952 0-9.233 1.807-12.85 5.424C1.807 72.998 0 77.279 0 82.228c0 4.948 1.807 9.229 5.424 12.847l127.907 127.907c3.621 3.617 7.902 5.428 12.85 5.428s9.233-1.811 12.847-5.428L286.935 95.074c3.613-3.617 5.427-7.898 5.427-12.847 0-4.948-1.814-9.229-5.427-12.85z", + }, + }), + ] + ) +} +var Arrowvue_type_template_id_11186cd4_staticRenderFns = [] +Arrowvue_type_template_id_11186cd4_render._withStripped = true + + +// CONCATENATED MODULE: ./src/components/icons/Arrow.vue?vue&type=template&id=11186cd4& + +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/icons/Arrow.vue?vue&type=script&lang=js& +/* harmony default export */ var Arrowvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--arrow' +}); +// CONCATENATED MODULE: ./src/components/icons/Arrow.vue?vue&type=script&lang=js& + /* harmony default export */ var icons_Arrowvue_type_script_lang_js_ = (Arrowvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/icons/Arrow.vue + + + + + +/* normalize component */ + +var Arrow_component = normalizeComponent( + icons_Arrowvue_type_script_lang_js_, + Arrowvue_type_template_id_11186cd4_render, + Arrowvue_type_template_id_11186cd4_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Arrow_api; } +Arrow_component.options.__file = "src/components/icons/Arrow.vue" +/* harmony default export */ var Arrow = (Arrow_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Control.vue?vue&type=script&lang=js& + + + + + +/* harmony default export */ var Controlvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--control', + inject: ['instance'], + computed: { + shouldShowX: function shouldShowX() { + var instance = this.instance; + return instance.clearable && !instance.disabled && instance.hasValue && (this.hasUndisabledValue || instance.allowClearingDisabled); + }, + shouldShowArrow: function shouldShowArrow() { + var instance = this.instance; + if (!instance.alwaysOpen) return true; + return !instance.menu.isOpen; + }, + hasUndisabledValue: function hasUndisabledValue() { + var instance = this.instance; + return instance.hasValue && instance.internalValue.some(function (id) { + return !instance.getNode(id).isDisabled; + }); + } + }, + methods: { + renderX: function renderX() { + var h = this.$createElement; + var instance = this.instance; + var title = instance.multiple ? instance.clearAllText : instance.clearValueText; + if (!this.shouldShowX) return null; + return h("div", { + "class": "vue-treeselect__x-container", + attrs: { + title: title + }, + on: { + "mousedown": this.handleMouseDownOnX + } + }, [h(Delete, { + "class": "vue-treeselect__x" + })]); + }, + renderArrow: function renderArrow() { + var h = this.$createElement; + var instance = this.instance; + var arrowClass = { + 'vue-treeselect__control-arrow': true, + 'vue-treeselect__control-arrow--rotated': instance.menu.isOpen + }; + if (!this.shouldShowArrow) return null; + return h("div", { + "class": "vue-treeselect__control-arrow-container", + on: { + "mousedown": this.handleMouseDownOnArrow + } + }, [h(Arrow, { + "class": arrowClass + })]); + }, + handleMouseDownOnX: onLeftClick(function handleMouseDownOnX(evt) { + evt.stopPropagation(); + evt.preventDefault(); + var instance = this.instance; + var result = instance.beforeClearAll(); + + var handler = function handler(shouldClear) { + if (shouldClear) instance.clear(); + }; + + if (external_is_promise_default()(result)) { + result.then(handler); + } else { + setTimeout(function () { + return handler(result); + }, 0); + } + }), + handleMouseDownOnArrow: onLeftClick(function handleMouseDownOnArrow(evt) { + evt.preventDefault(); + evt.stopPropagation(); + var instance = this.instance; + instance.focusInput(); + instance.toggleMenu(); + }), + renderValueContainer: function renderValueContainer(children) { + var h = this.$createElement; + return h("div", { + "class": "vue-treeselect__value-container" + }, [children]); + } + }, + render: function render() { + var h = arguments[0]; + var instance = this.instance; + var ValueContainer = instance.single ? SingleValue : MultiValue; + return h("div", { + "class": "vue-treeselect__control", + on: { + "mousedown": instance.handleMouseDown + } + }, [h(ValueContainer, { + ref: "value-container" + }), this.renderX(), this.renderArrow()]); + } +}); +// CONCATENATED MODULE: ./src/components/Control.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Controlvue_type_script_lang_js_ = (Controlvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Control.vue +var Control_render, Control_staticRenderFns + + + + +/* normalize component */ + +var Control_component = normalizeComponent( + components_Controlvue_type_script_lang_js_, + Control_render, + Control_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Control_api; } +Control_component.options.__file = "src/components/Control.vue" +/* harmony default export */ var Control = (Control_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Tip.vue?vue&type=script&lang=js& +/* harmony default export */ var Tipvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--tip', + functional: true, + props: { + type: { + type: String, + required: true + }, + icon: { + type: String, + required: true + } + }, + render: function render(_, context) { + var h = arguments[0]; + var props = context.props, + children = context.children; + return h("div", { + "class": "vue-treeselect__tip vue-treeselect__".concat(props.type, "-tip") + }, [h("div", { + "class": "vue-treeselect__icon-container" + }, [h("span", { + "class": "vue-treeselect__icon-".concat(props.icon) + })]), h("span", { + "class": "vue-treeselect__tip-text vue-treeselect__".concat(props.type, "-tip-text") + }, [children])]); + } +}); +// CONCATENATED MODULE: ./src/components/Tip.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Tipvue_type_script_lang_js_ = (Tipvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Tip.vue +var Tip_render, Tip_staticRenderFns + + + + +/* normalize component */ + +var Tip_component = normalizeComponent( + components_Tipvue_type_script_lang_js_, + Tip_render, + Tip_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Tip_api; } +Tip_component.options.__file = "src/components/Tip.vue" +/* harmony default export */ var Tip = (Tip_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Option.vue?vue&type=script&lang=js& + + + + + +var arrowPlaceholder, checkMark, minusMark; +var Option = { + name: 'vue-treeselect--option', + inject: ['instance'], + props: { + node: { + type: Object, + required: true + } + }, + computed: { + shouldExpand: function shouldExpand() { + var instance = this.instance, + node = this.node; + return node.isBranch && instance.shouldExpand(node); + }, + shouldShow: function shouldShow() { + var instance = this.instance, + node = this.node; + return instance.shouldShowOptionInMenu(node); + } + }, + methods: { + renderOption: function renderOption() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + var optionClass = { + 'vue-treeselect__option': true, + 'vue-treeselect__option--disabled': node.isDisabled, + 'vue-treeselect__option--selected': instance.isSelected(node), + 'vue-treeselect__option--highlight': node.isHighlighted, + 'vue-treeselect__option--matched': instance.localSearch.active && node.isMatched, + 'vue-treeselect__option--hide': !this.shouldShow + }; + return h("div", { + "class": optionClass, + on: { + "mouseenter": this.handleMouseEnterOption + }, + attrs: { + "data-id": node.id + } + }, [this.renderArrow(), this.renderLabelContainer([this.renderCheckboxContainer([this.renderCheckbox()]), this.renderLabel()])]); + }, + renderSubOptionsList: function renderSubOptionsList() { + var h = this.$createElement; + if (!this.shouldExpand) return null; + return h("div", { + "class": "vue-treeselect__list" + }, [this.renderSubOptions(), this.renderNoChildrenTip(), this.renderLoadingChildrenTip(), this.renderLoadingChildrenErrorTip()]); + }, + renderArrow: function renderArrow() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (instance.shouldFlattenOptions && this.shouldShow) return null; + + if (node.isBranch) { + var transitionProps = { + props: { + name: 'vue-treeselect__option-arrow--prepare', + appear: true + } + }; + var arrowClass = { + 'vue-treeselect__option-arrow': true, + 'vue-treeselect__option-arrow--rotated': this.shouldExpand + }; + return h("div", { + "class": "vue-treeselect__option-arrow-container", + on: { + "mousedown": this.handleMouseDownOnArrow + } + }, [h("transition", transitionProps, [h(Arrow, { + "class": arrowClass + })])]); + } + + if (instance.hasBranchNodes) { + if (!arrowPlaceholder) arrowPlaceholder = h("div", { + "class": "vue-treeselect__option-arrow-placeholder" + }, ["\xA0"]); + return arrowPlaceholder; + } + + return null; + }, + renderLabelContainer: function renderLabelContainer(children) { + var h = this.$createElement; + return h("div", { + "class": "vue-treeselect__label-container", + on: { + "mousedown": this.handleMouseDownOnLabelContainer + } + }, [children]); + }, + renderCheckboxContainer: function renderCheckboxContainer(children) { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (instance.single) return null; + if (instance.disableBranchNodes && node.isBranch) return null; + return h("div", { + "class": "vue-treeselect__checkbox-container" + }, [children]); + }, + renderCheckbox: function renderCheckbox() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + var checkedState = instance.forest.checkedStateMap[node.id]; + var checkboxClass = { + 'vue-treeselect__checkbox': true, + 'vue-treeselect__checkbox--checked': checkedState === CHECKED, + 'vue-treeselect__checkbox--indeterminate': checkedState === INDETERMINATE, + 'vue-treeselect__checkbox--unchecked': checkedState === UNCHECKED, + 'vue-treeselect__checkbox--disabled': node.isDisabled + }; + if (!checkMark) checkMark = h("span", { + "class": "vue-treeselect__check-mark" + }); + if (!minusMark) minusMark = h("span", { + "class": "vue-treeselect__minus-mark" + }); + return h("span", { + "class": checkboxClass + }, [checkMark, minusMark]); + }, + renderLabel: function renderLabel() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + var shouldShowCount = node.isBranch && (instance.localSearch.active ? instance.showCountOnSearchComputed : instance.showCount); + var count = shouldShowCount ? instance.localSearch.active ? instance.localSearch.countMap[node.id][instance.showCountOf] : node.count[instance.showCountOf] : NaN; + var labelClassName = 'vue-treeselect__label'; + var countClassName = 'vue-treeselect__count'; + var customLabelRenderer = instance.$scopedSlots['option-label']; + if (customLabelRenderer) return customLabelRenderer({ + node: node, + shouldShowCount: shouldShowCount, + count: count, + labelClassName: labelClassName, + countClassName: countClassName + }); + return h("label", { + "class": labelClassName + }, [node.label, shouldShowCount && h("span", { + "class": countClassName + }, ["(", count, ")"])]); + }, + renderSubOptions: function renderSubOptions() { + var h = this.$createElement; + var node = this.node; + if (!node.childrenStates.isLoaded) return null; + return node.children.map(function (childNode) { + return h(Option, { + attrs: { + node: childNode + }, + key: childNode.id + }); + }); + }, + renderNoChildrenTip: function renderNoChildrenTip() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (!node.childrenStates.isLoaded || node.children.length) return null; + return h(Tip, { + attrs: { + type: "no-children", + icon: "warning" + } + }, [instance.noChildrenText]); + }, + renderLoadingChildrenTip: function renderLoadingChildrenTip() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (!node.childrenStates.isLoading) return null; + return h(Tip, { + attrs: { + type: "loading", + icon: "loader" + } + }, [instance.loadingText]); + }, + renderLoadingChildrenErrorTip: function renderLoadingChildrenErrorTip() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (!node.childrenStates.loadingError) return null; + return h(Tip, { + attrs: { + type: "error", + icon: "error" + } + }, [node.childrenStates.loadingError, h("a", { + "class": "vue-treeselect__retry", + attrs: { + title: instance.retryTitle + }, + on: { + "mousedown": this.handleMouseDownOnRetry + } + }, [instance.retryText])]); + }, + handleMouseEnterOption: function handleMouseEnterOption(evt) { + var instance = this.instance, + node = this.node; + if (evt.target !== evt.currentTarget) return; + instance.setCurrentHighlightedOption(node, false); + }, + handleMouseDownOnArrow: onLeftClick(function handleMouseDownOnOptionArrow() { + var instance = this.instance, + node = this.node; + instance.toggleExpanded(node); + }), + handleMouseDownOnLabelContainer: onLeftClick(function handleMouseDownOnLabelContainer() { + var instance = this.instance, + node = this.node; + + if (node.isBranch && instance.disableBranchNodes) { + instance.toggleExpanded(node); + } else { + instance.select(node); + } + }), + handleMouseDownOnRetry: onLeftClick(function handleMouseDownOnRetry() { + var instance = this.instance, + node = this.node; + instance.loadChildrenOptions(node); + }) + }, + render: function render() { + var h = arguments[0]; + var node = this.node; + var indentLevel = this.instance.shouldFlattenOptions ? 0 : node.level; + + var listItemClass = defineProperty_default()({ + 'vue-treeselect__list-item': true + }, "vue-treeselect__indent-level-".concat(indentLevel), true); + + var transitionProps = { + props: { + name: 'vue-treeselect__list--transition' + } + }; + return h("div", { + "class": listItemClass + }, [this.renderOption(), node.isBranch && h("transition", transitionProps, [this.renderSubOptionsList()])]); + } +}; +/* harmony default export */ var Optionvue_type_script_lang_js_ = (Option); +// CONCATENATED MODULE: ./src/components/Option.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Optionvue_type_script_lang_js_ = (Optionvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Option.vue +var Option_render, Option_staticRenderFns + + + + +/* normalize component */ + +var Option_component = normalizeComponent( + components_Optionvue_type_script_lang_js_, + Option_render, + Option_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Option_api; } +Option_component.options.__file = "src/components/Option.vue" +/* harmony default export */ var components_Option = (Option_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Menu.vue?vue&type=script&lang=js& + + + + +var directionMap = { + top: 'top', + bottom: 'bottom', + above: 'top', + below: 'bottom' +}; +/* harmony default export */ var Menuvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--menu', + inject: ['instance'], + computed: { + menuStyle: function menuStyle() { + var instance = this.instance; + return { + maxHeight: instance.maxHeight + 'px' + }; + }, + menuContainerStyle: function menuContainerStyle() { + var instance = this.instance; + return { + zIndex: instance.appendToBody ? null : instance.zIndex + }; + } + }, + watch: { + 'instance.menu.isOpen': function instanceMenuIsOpen(newValue) { + if (newValue) { + this.$nextTick(this.onMenuOpen); + } else { + this.onMenuClose(); + } + } + }, + created: function created() { + this.menuSizeWatcher = null; + this.menuResizeAndScrollEventListeners = null; + }, + mounted: function mounted() { + var instance = this.instance; + if (instance.menu.isOpen) this.$nextTick(this.onMenuOpen); + }, + destroyed: function destroyed() { + this.onMenuClose(); + }, + methods: { + renderMenu: function renderMenu() { + var h = this.$createElement; + var instance = this.instance; + if (!instance.menu.isOpen) return null; + return h("div", { + ref: "menu", + "class": "vue-treeselect__menu", + on: { + "mousedown": instance.handleMouseDown + }, + style: this.menuStyle + }, [this.renderBeforeList(), instance.async ? this.renderAsyncSearchMenuInner() : instance.localSearch.active ? this.renderLocalSearchMenuInner() : this.renderNormalMenuInner(), this.renderAfterList()]); + }, + renderBeforeList: function renderBeforeList() { + var instance = this.instance; + var beforeListRenderer = instance.$scopedSlots['before-list']; + return beforeListRenderer ? beforeListRenderer() : null; + }, + renderAfterList: function renderAfterList() { + var instance = this.instance; + var afterListRenderer = instance.$scopedSlots['after-list']; + return afterListRenderer ? afterListRenderer() : null; + }, + renderNormalMenuInner: function renderNormalMenuInner() { + var instance = this.instance; + + if (instance.rootOptionsStates.isLoading) { + return this.renderLoadingOptionsTip(); + } else if (instance.rootOptionsStates.loadingError) { + return this.renderLoadingRootOptionsErrorTip(); + } else if (instance.rootOptionsStates.isLoaded && instance.forest.normalizedOptions.length === 0) { + return this.renderNoAvailableOptionsTip(); + } else { + return this.renderOptionList(); + } + }, + renderLocalSearchMenuInner: function renderLocalSearchMenuInner() { + var instance = this.instance; + + if (instance.rootOptionsStates.isLoading) { + return this.renderLoadingOptionsTip(); + } else if (instance.rootOptionsStates.loadingError) { + return this.renderLoadingRootOptionsErrorTip(); + } else if (instance.rootOptionsStates.isLoaded && instance.forest.normalizedOptions.length === 0) { + return this.renderNoAvailableOptionsTip(); + } else if (instance.localSearch.noResults) { + return this.renderNoResultsTip(); + } else { + return this.renderOptionList(); + } + }, + renderAsyncSearchMenuInner: function renderAsyncSearchMenuInner() { + var instance = this.instance; + var entry = instance.getRemoteSearchEntry(); + var shouldShowSearchPromptTip = instance.trigger.searchQuery === '' && !instance.defaultOptions; + var shouldShowNoResultsTip = shouldShowSearchPromptTip ? false : entry.isLoaded && entry.options.length === 0; + + if (shouldShowSearchPromptTip) { + return this.renderSearchPromptTip(); + } else if (entry.isLoading) { + return this.renderLoadingOptionsTip(); + } else if (entry.loadingError) { + return this.renderAsyncSearchLoadingErrorTip(); + } else if (shouldShowNoResultsTip) { + return this.renderNoResultsTip(); + } else { + return this.renderOptionList(); + } + }, + renderOptionList: function renderOptionList() { + var h = this.$createElement; + var instance = this.instance; + return h("div", { + "class": "vue-treeselect__list" + }, [instance.forest.normalizedOptions.map(function (rootNode) { + return h(components_Option, { + attrs: { + node: rootNode + }, + key: rootNode.id + }); + })]); + }, + renderSearchPromptTip: function renderSearchPromptTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "search-prompt", + icon: "warning" + } + }, [instance.searchPromptText]); + }, + renderLoadingOptionsTip: function renderLoadingOptionsTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "loading", + icon: "loader" + } + }, [instance.loadingText]); + }, + renderLoadingRootOptionsErrorTip: function renderLoadingRootOptionsErrorTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "error", + icon: "error" + } + }, [instance.rootOptionsStates.loadingError, h("a", { + "class": "vue-treeselect__retry", + on: { + "click": instance.loadRootOptions + }, + attrs: { + title: instance.retryTitle + } + }, [instance.retryText])]); + }, + renderAsyncSearchLoadingErrorTip: function renderAsyncSearchLoadingErrorTip() { + var h = this.$createElement; + var instance = this.instance; + var entry = instance.getRemoteSearchEntry(); + return h(Tip, { + attrs: { + type: "error", + icon: "error" + } + }, [entry.loadingError, h("a", { + "class": "vue-treeselect__retry", + on: { + "click": instance.handleRemoteSearch + }, + attrs: { + title: instance.retryTitle + } + }, [instance.retryText])]); + }, + renderNoAvailableOptionsTip: function renderNoAvailableOptionsTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "no-options", + icon: "warning" + } + }, [instance.noOptionsText]); + }, + renderNoResultsTip: function renderNoResultsTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "no-results", + icon: "warning" + } + }, [instance.noResultsText]); + }, + onMenuOpen: function onMenuOpen() { + this.adjustMenuOpenDirection(); + this.setupMenuSizeWatcher(); + this.setupMenuResizeAndScrollEventListeners(); + }, + onMenuClose: function onMenuClose() { + this.removeMenuSizeWatcher(); + this.removeMenuResizeAndScrollEventListeners(); + }, + adjustMenuOpenDirection: function adjustMenuOpenDirection() { + var instance = this.instance; + if (!instance.menu.isOpen) return; + var $menu = instance.getMenu(); + var $control = instance.getControl(); + var menuRect = $menu.getBoundingClientRect(); + var controlRect = $control.getBoundingClientRect(); + var menuHeight = menuRect.height; + var viewportHeight = window.innerHeight; + var spaceAbove = controlRect.top; + var spaceBelow = window.innerHeight - controlRect.bottom; + var isControlInViewport = controlRect.top >= 0 && controlRect.top <= viewportHeight || controlRect.top < 0 && controlRect.bottom > 0; + var hasEnoughSpaceBelow = spaceBelow > menuHeight + MENU_BUFFER; + var hasEnoughSpaceAbove = spaceAbove > menuHeight + MENU_BUFFER; + + if (!isControlInViewport) { + instance.closeMenu(); + } else if (instance.openDirection !== 'auto') { + instance.menu.placement = directionMap[instance.openDirection]; + } else if (hasEnoughSpaceBelow || !hasEnoughSpaceAbove) { + instance.menu.placement = 'bottom'; + } else { + instance.menu.placement = 'top'; + } + }, + setupMenuSizeWatcher: function setupMenuSizeWatcher() { + var instance = this.instance; + var $menu = instance.getMenu(); + if (this.menuSizeWatcher) return; + this.menuSizeWatcher = { + remove: watchSize($menu, this.adjustMenuOpenDirection) + }; + }, + setupMenuResizeAndScrollEventListeners: function setupMenuResizeAndScrollEventListeners() { + var instance = this.instance; + var $control = instance.getControl(); + if (this.menuResizeAndScrollEventListeners) return; + this.menuResizeAndScrollEventListeners = { + remove: setupResizeAndScrollEventListeners($control, this.adjustMenuOpenDirection) + }; + }, + removeMenuSizeWatcher: function removeMenuSizeWatcher() { + if (!this.menuSizeWatcher) return; + this.menuSizeWatcher.remove(); + this.menuSizeWatcher = null; + }, + removeMenuResizeAndScrollEventListeners: function removeMenuResizeAndScrollEventListeners() { + if (!this.menuResizeAndScrollEventListeners) return; + this.menuResizeAndScrollEventListeners.remove(); + this.menuResizeAndScrollEventListeners = null; + } + }, + render: function render() { + var h = arguments[0]; + return h("div", { + ref: "menu-container", + "class": "vue-treeselect__menu-container", + style: this.menuContainerStyle + }, [h("transition", { + attrs: { + name: "vue-treeselect__menu--transition" + } + }, [this.renderMenu()])]); + } +}); +// CONCATENATED MODULE: ./src/components/Menu.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Menuvue_type_script_lang_js_ = (Menuvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Menu.vue +var Menu_render, Menu_staticRenderFns + + + + +/* normalize component */ + +var Menu_component = normalizeComponent( + components_Menuvue_type_script_lang_js_, + Menu_render, + Menu_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Menu_api; } +Menu_component.options.__file = "src/components/Menu.vue" +/* harmony default export */ var Menu = (Menu_component.exports); +// EXTERNAL MODULE: external "vue" +var external_vue_ = __webpack_require__(14); +var external_vue_default = /*#__PURE__*/__webpack_require__.n(external_vue_); + +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/MenuPortal.vue?vue&type=script&lang=js& + + +function MenuPortalvue_type_script_lang_js_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function MenuPortalvue_type_script_lang_js_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? MenuPortalvue_type_script_lang_js_ownKeys(Object(source), !0).forEach(function (key) { defineProperty_default()(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : MenuPortalvue_type_script_lang_js_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + + + + +var PortalTarget = { + name: 'vue-treeselect--portal-target', + inject: ['instance'], + watch: { + 'instance.menu.isOpen': function instanceMenuIsOpen(newValue) { + if (newValue) { + this.setupHandlers(); + } else { + this.removeHandlers(); + } + }, + 'instance.menu.placement': function instanceMenuPlacement() { + this.updateMenuContainerOffset(); + } + }, + created: function created() { + this.controlResizeAndScrollEventListeners = null; + this.controlSizeWatcher = null; + }, + mounted: function mounted() { + var instance = this.instance; + if (instance.menu.isOpen) this.setupHandlers(); + }, + methods: { + setupHandlers: function setupHandlers() { + this.updateWidth(); + this.updateMenuContainerOffset(); + this.setupControlResizeAndScrollEventListeners(); + this.setupControlSizeWatcher(); + }, + removeHandlers: function removeHandlers() { + this.removeControlResizeAndScrollEventListeners(); + this.removeControlSizeWatcher(); + }, + setupControlResizeAndScrollEventListeners: function setupControlResizeAndScrollEventListeners() { + var instance = this.instance; + var $control = instance.getControl(); + if (this.controlResizeAndScrollEventListeners) return; + this.controlResizeAndScrollEventListeners = { + remove: setupResizeAndScrollEventListeners($control, this.updateMenuContainerOffset) + }; + }, + setupControlSizeWatcher: function setupControlSizeWatcher() { + var _this = this; + + var instance = this.instance; + var $control = instance.getControl(); + if (this.controlSizeWatcher) return; + this.controlSizeWatcher = { + remove: watchSize($control, function () { + _this.updateWidth(); + + _this.updateMenuContainerOffset(); + }) + }; + }, + removeControlResizeAndScrollEventListeners: function removeControlResizeAndScrollEventListeners() { + if (!this.controlResizeAndScrollEventListeners) return; + this.controlResizeAndScrollEventListeners.remove(); + this.controlResizeAndScrollEventListeners = null; + }, + removeControlSizeWatcher: function removeControlSizeWatcher() { + if (!this.controlSizeWatcher) return; + this.controlSizeWatcher.remove(); + this.controlSizeWatcher = null; + }, + updateWidth: function updateWidth() { + var instance = this.instance; + var $portalTarget = this.$el; + var $control = instance.getControl(); + var controlRect = $control.getBoundingClientRect(); + $portalTarget.style.width = controlRect.width + 'px'; + }, + updateMenuContainerOffset: function updateMenuContainerOffset() { + var instance = this.instance; + var $control = instance.getControl(); + var $portalTarget = this.$el; + var controlRect = $control.getBoundingClientRect(); + var portalTargetRect = $portalTarget.getBoundingClientRect(); + var offsetY = instance.menu.placement === 'bottom' ? controlRect.height : 0; + var left = Math.round(controlRect.left - portalTargetRect.left) + 'px'; + var top = Math.round(controlRect.top - portalTargetRect.top + offsetY) + 'px'; + var menuContainerStyle = this.$refs.menu.$refs['menu-container'].style; + var transformVariations = ['transform', 'webkitTransform', 'MozTransform', 'msTransform']; + var transform = find(transformVariations, function (t) { + return t in document.body.style; + }); + menuContainerStyle[transform] = "translate(".concat(left, ", ").concat(top, ")"); + } + }, + render: function render() { + var h = arguments[0]; + var instance = this.instance; + var portalTargetClass = ['vue-treeselect__portal-target', instance.wrapperClass]; + var portalTargetStyle = { + zIndex: instance.zIndex + }; + return h("div", { + "class": portalTargetClass, + style: portalTargetStyle, + attrs: { + "data-instance-id": instance.getInstanceId() + } + }, [h(Menu, { + ref: "menu" + })]); + }, + destroyed: function destroyed() { + this.removeHandlers(); + } +}; +var placeholder; +/* harmony default export */ var MenuPortalvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--menu-portal', + created: function created() { + this.portalTarget = null; + }, + mounted: function mounted() { + this.setup(); + }, + destroyed: function destroyed() { + this.teardown(); + }, + methods: { + setup: function setup() { + var el = document.createElement('div'); + document.body.appendChild(el); + this.portalTarget = new external_vue_default.a(MenuPortalvue_type_script_lang_js_objectSpread({ + el: el, + parent: this + }, PortalTarget)); + }, + teardown: function teardown() { + document.body.removeChild(this.portalTarget.$el); + this.portalTarget.$el.innerHTML = ''; + this.portalTarget.$destroy(); + this.portalTarget = null; + } + }, + render: function render() { + var h = arguments[0]; + if (!placeholder) placeholder = h("div", { + "class": "vue-treeselect__menu-placeholder" + }); + return placeholder; + } +}); +// CONCATENATED MODULE: ./src/components/MenuPortal.vue?vue&type=script&lang=js& + /* harmony default export */ var components_MenuPortalvue_type_script_lang_js_ = (MenuPortalvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/MenuPortal.vue +var MenuPortal_render, MenuPortal_staticRenderFns + + + + +/* normalize component */ + +var MenuPortal_component = normalizeComponent( + components_MenuPortalvue_type_script_lang_js_, + MenuPortal_render, + MenuPortal_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var MenuPortal_api; } +MenuPortal_component.options.__file = "src/components/MenuPortal.vue" +/* harmony default export */ var MenuPortal = (MenuPortal_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Treeselect.vue?vue&type=script&lang=js& + + + + + +/* harmony default export */ var Treeselectvue_type_script_lang_js_ = ({ + name: 'vue-treeselect', + mixins: [treeselectMixin], + computed: { + wrapperClass: function wrapperClass() { + return { + 'vue-treeselect': true, + 'vue-treeselect--single': this.single, + 'vue-treeselect--multi': this.multiple, + 'vue-treeselect--searchable': this.searchable, + 'vue-treeselect--disabled': this.disabled, + 'vue-treeselect--focused': this.trigger.isFocused, + 'vue-treeselect--has-value': this.hasValue, + 'vue-treeselect--open': this.menu.isOpen, + 'vue-treeselect--open-above': this.menu.placement === 'top', + 'vue-treeselect--open-below': this.menu.placement === 'bottom', + 'vue-treeselect--branch-nodes-disabled': this.disableBranchNodes, + 'vue-treeselect--append-to-body': this.appendToBody + }; + } + }, + render: function render() { + var h = arguments[0]; + return h("div", { + ref: "wrapper", + "class": this.wrapperClass + }, [h(HiddenFields), h(Control, { + ref: "control" + }), this.appendToBody ? h(MenuPortal, { + ref: "portal" + }) : h(Menu, { + ref: "menu" + })]); + } +}); +// CONCATENATED MODULE: ./src/components/Treeselect.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Treeselectvue_type_script_lang_js_ = (Treeselectvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Treeselect.vue +var Treeselect_render, Treeselect_staticRenderFns + + + + +/* normalize component */ + +var Treeselect_component = normalizeComponent( + components_Treeselectvue_type_script_lang_js_, + Treeselect_render, + Treeselect_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Treeselect_api; } +Treeselect_component.options.__file = "src/components/Treeselect.vue" +/* harmony default export */ var Treeselect = (Treeselect_component.exports); +// EXTERNAL MODULE: ./src/style.less +var style = __webpack_require__(15); + +// CONCATENATED MODULE: ./src/index.js + + + +/* harmony default export */ var src = __webpack_exports__["default"] = (Treeselect); + + +var VERSION = "0.4.0"; + +/***/ }) +/******/ ]); +//# sourceMappingURL=vue-treeselect.cjs.js.map \ No newline at end of file diff --git a/dist/vue-treeselect.cjs.js.map b/dist/vue-treeselect.cjs.js.map new file mode 100644 index 00000000..d7560940 --- /dev/null +++ b/dist/vue-treeselect.cjs.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/external \"@babel/runtime/helpers/slicedToArray\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/toConsumableArray\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/defineProperty\"","webpack://VueTreeselect/external \"fuzzysearch\"","webpack://VueTreeselect/external \"lodash/noop\"","webpack://VueTreeselect/external \"lodash/debounce\"","webpack://VueTreeselect/external \"watch-size\"","webpack://VueTreeselect/external \"is-promise\"","webpack://VueTreeselect/external \"lodash/once\"","webpack://VueTreeselect/external \"lodash/identity\"","webpack://VueTreeselect/external \"lodash/constant\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/typeof\"","webpack://VueTreeselect/external \"lodash/last\"","webpack://VueTreeselect/external \"babel-helper-vue-jsx-merge-props\"","webpack://VueTreeselect/external \"vue\"","webpack://VueTreeselect/./src/style.less?1f4a","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/removeFromArray.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./src/utils/setupResizeAndScrollEventListeners.js","webpack://VueTreeselect/./src/utils/isNaN.js","webpack://VueTreeselect/./src/utils/createMap.js","webpack://VueTreeselect/./src/utils/deepExtend.js","webpack://VueTreeselect/./src/utils/includes.js","webpack://VueTreeselect/./src/utils/find.js","webpack://VueTreeselect/./src/utils/quickDiff.js","webpack://VueTreeselect/./src/utils/index.js","webpack://VueTreeselect/./src/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","webpack://VueTreeselect/./src/components/HiddenFields.vue?750c","webpack://VueTreeselect/./node_modules/vue-loader/lib/runtime/componentNormalizer.js","webpack://VueTreeselect/./src/components/HiddenFields.vue","webpack://VueTreeselect/src/components/Input.vue","webpack://VueTreeselect/./src/components/Input.vue?449d","webpack://VueTreeselect/./src/components/Input.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/Placeholder.vue?238d","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/SingleValue.vue","webpack://VueTreeselect/./src/components/SingleValue.vue?5aaa","webpack://VueTreeselect/./src/components/SingleValue.vue","webpack://VueTreeselect/./src/components/icons/Delete.vue?2d39","webpack://VueTreeselect/src/components/icons/Delete.vue","webpack://VueTreeselect/./src/components/icons/Delete.vue?ada5","webpack://VueTreeselect/./src/components/icons/Delete.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValueItem.vue?9a1f","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValue.vue","webpack://VueTreeselect/./src/components/MultiValue.vue?6f61","webpack://VueTreeselect/./src/components/MultiValue.vue","webpack://VueTreeselect/./src/components/icons/Arrow.vue?2ad4","webpack://VueTreeselect/src/components/icons/Arrow.vue","webpack://VueTreeselect/./src/components/icons/Arrow.vue?525a","webpack://VueTreeselect/./src/components/icons/Arrow.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Control.vue?57ab","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/./src/components/Tip.vue?5960","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue?0a09","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue?c349","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue?ca92","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/components/Treeselect.vue?85a0","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["warning","process","env","NODE_ENV","noop","checker","complainer","message","concat","console","error","onLeftClick","mouseDownHandler","onMouseDown","evt","type","button","args","call","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","Math","min","offsetTop","clientHeight","scrollHeight","top","max","removeFromArray","arr","elem","idx","indexOf","splice","intervalId","registered","INTERVAL_DURATION","run","setInterval","forEach","test","stop","clearInterval","item","$el","listener","lastWidth","lastHeight","width","offsetWidth","height","watchSizeForIE9","unwatch","length","push","watchSize","isIE9","document","documentMode","locked","wrappedListener","implementation","watchSizeForBrowsersOtherThanIE9","removeSizeWatcher","findScrollParents","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","isScrollElment","window","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","addEventListener","passive","scrollParent","removeEventListeners","removeEventListener","$scrollParent","isNaN","x","createMap","Object","create","isPlainObject","value","getPrototypeOf","prototype","copy","obj","key","deepExtend","target","source","keys","i","len","includes","arrOrStr","find","predicate","ctx","undefined","quickDiff","arrA","arrB","NO_PARENT_NODE","UNCHECKED","INDETERMINATE","CHECKED","ALL_CHILDREN","ALL_DESCENDANTS","LEAF_CHILDREN","LEAF_DESCENDANTS","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","ALL","BRANCH_PRIORITY","LEAF_PRIORITY","ALL_WITH_INDETERMINATE","ORDER_SELECTED","LEVEL","INDEX","KEY_CODES","BACKSPACE","ENTER","ESCAPE","END","HOME","ARROW_LEFT","ARROW_UP","ARROW_RIGHT","ARROW_DOWN","DELETE","INPUT_DEBOUNCE_DELAY","MIN_INPUT_WIDTH","MENU_BUFFER","sortValueByIndex","a","b","level","index","sortValueByLevel","createAsyncOptionsStates","isLoaded","isLoading","loadingError","stringifyOptionPropValue","removeAccents","str","normalize","replace","match","enableFuzzyMatch","needle","haystack","fuzzysearch","getErrorMessage","err","String","instanceId","provide","instance","props","allowClearingDisabled","Boolean","default","allowSelectingDisabledDescendants","alwaysOpen","appendToBody","async","autoFocus","autoLoadRootOptions","autoDeselectAncestors","autoDeselectDescendants","autoSelectAncestors","autoSelectDescendants","backspaceRemoves","beforeClearAll","Function","constant","branchNodesFirst","cacheOptions","clearable","clearAllText","clearOnSelect","clearValueText","closeOnSelect","defaultExpandLevel","Number","defaultOptions","deleteRemoves","delimiter","flattenSearchResults","disableBranchNodes","disabled","disableFuzzyMatching","flat","joinValues","limit","Infinity","limitText","limitTextDefault","count","loadingText","loadOptions","matchKeys","Array","maxHeight","multiple","name","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","acceptableValues","openOnClick","openOnFocus","options","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","localSearch","active","noResults","countMap","remoteSearch","computed","selectedNodes","map","getNode","internalValue","single","slice","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","hasBranchNodes","some","rootNode","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","hasChanged","$emit","getValue","getInstanceId","buildForestState","handler","isArray","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propNames","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","getUniqChildValues","rawNodes","raw","ids","values","hasBeenSelected","hasOneChild","traverseDescendantsBFS","descendant","isDisabled","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","isClickedOnValueContainer","contains","wrapper","done","resetHighlightedOptionWhenNecessary","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","split","every","filterValue","nestedSearchLabel","matchKey","lowerCased","entry","callLoadOptionsProp","action","isPending","start","succeed","fail","end","$watch","isExpanded","shouldShowOptionInMenu","getControl","getMenu","ref","portal","portalTarget","$menu","setCurrentHighlightedOption","scroll","prev","isHighlighted","scrollToOption","$option","querySelector","$nextTick","forceReset","highlightFirstOption","first","highlightPrevOption","highlightLastOption","highlightNextOption","next","last","getLast","resetSearchQuery","saveMenuScrollPosition","restoreMenuScrollPosition","loadRootOptions","toggleMenu","toggleExpanded","nextState","childrenStates","loadChildrenOptions","selectedNodeId","ancestorNode","nodes","checkDuplication","verifyNodeShape","isDefaultExpanded","reduce","normalized","hasDisabledDescendants","branchNodes","option","leafNodes","once","result","isPromise","then","catch","JSON","stringify","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","Treeselect","VERSION","PKG_VERSION"],"mappings":";;;;;;;QAAA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;QAEA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;;;QAGA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA,0CAA0C,gCAAgC;QAC1E;QACA;;QAEA;QACA;QACA;QACA,wDAAwD,kBAAkB;QAC1E;QACA,iDAAiD,cAAc;QAC/D;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,yCAAyC,iCAAiC;QAC1E,gHAAgH,mBAAmB,EAAE;QACrI;QACA;;QAEA;QACA;QACA;QACA,2BAA2B,0BAA0B,EAAE;QACvD,iCAAiC,eAAe;QAChD;QACA;QACA;;QAEA;QACA,sDAAsD,+DAA+D;;QAErH;QACA;;;QAGA;QACA;;;;;;;AClFA,iE;;;;;;ACAA,qE;;;;;;ACAA,kE;;;;;;ACAA,wC;;;;;;ACAA,wC;;;;;;ACAA,4C;;;;;;ACAA,uC;;;;;;ACAA,uC;;;;;;ACAA,wC;;;;;;ACAA,4C;;;;;;ACAA,4C;;;;;;ACAA,0D;;;;;;ACAA,wC;;;;;;ACAA,6D;;;;;;ACAA,gC;;;;;;ACAA,uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;AAEO,IAAMA,eAAO,GAAGC,OAAO,CAACC,GAAR,CAAYC,QAAZ,KAAyB,YAAzB,GACQC,cADR,GAEnB,SAASJ,OAAT,CAAiBK,OAAjB,EAA0BC,UAA1B,EAAsC;AACtC,MAAI,CAACD,OAAO,EAAZ,EAAgB;AAAA;;AACd,QAAME,OAAO,GAAG,CAAE,0BAAF,EAA+BC,MAA/B,CAAsCF,UAAU,EAAhD,CAAhB;;AAEA,gBAAAG,OAAO,EAACC,KAAR,6CAAiBH,OAAjB;AACD;AACF,CARI,C;;ACFA,SAASI,WAAT,CAAqBC,gBAArB,EAAuC;AAC5C,SAAO,SAASC,WAAT,CAAqBC,GAArB,EAAmC;AACxC,QAAIA,GAAG,CAACC,IAAJ,KAAa,WAAb,IAA4BD,GAAG,CAACE,MAAJ,KAAe,CAA/C,EAAkD;AAAA,wCADhBC,IACgB;AADhBA,YACgB;AAAA;;AAChDL,sBAAgB,CAACM,IAAjB,OAAAN,gBAAgB,GAAM,IAAN,EAAYE,GAAZ,SAAoBG,IAApB,EAAhB;AACD;AACF,GAJD;AAKD,C;;ACLM,SAASE,cAAT,CAAwBC,YAAxB,EAAsCC,UAAtC,EAAkD;AACvD,MAAMC,cAAc,GAAGF,YAAY,CAACG,qBAAb,EAAvB;AACA,MAAMC,WAAW,GAAGH,UAAU,CAACE,qBAAX,EAApB;AACA,MAAME,UAAU,GAAGJ,UAAU,CAACK,YAAX,GAA0B,CAA7C;;AAEA,MAAIF,WAAW,CAACG,MAAZ,GAAqBF,UAArB,GAAkCH,cAAc,CAACK,MAArD,EAA6D;AAC3DP,gBAAY,CAACQ,SAAb,GAAyBC,IAAI,CAACC,GAAL,CACvBT,UAAU,CAACU,SAAX,GAAuBV,UAAU,CAACW,YAAlC,GAAiDZ,YAAY,CAACM,YAA9D,GAA6ED,UADtD,EAEvBL,YAAY,CAACa,YAFU,CAAzB;AAID,GALD,MAKO,IAAIT,WAAW,CAACU,GAAZ,GAAkBT,UAAlB,GAA+BH,cAAc,CAACY,GAAlD,EAAuD;AAC5Dd,gBAAY,CAACQ,SAAb,GAAyBC,IAAI,CAACM,GAAL,CAASd,UAAU,CAACU,SAAX,GAAuBN,UAAhC,EAA4C,CAA5C,CAAzB;AACD;AACF,C;;;;;;;;;;;;ACdM,SAASW,eAAT,CAAyBC,GAAzB,EAA8BC,IAA9B,EAAoC;AACzC,MAAMC,GAAG,GAAGF,GAAG,CAACG,OAAJ,CAAYF,IAAZ,CAAZ;AACA,MAAIC,GAAG,KAAK,CAAC,CAAb,EAAgBF,GAAG,CAACI,MAAJ,CAAWF,GAAX,EAAgB,CAAhB;AACjB,C;;ACHD;AACA;AAEA,IAAIG,UAAJ;AACA,IAAMC,UAAU,GAAG,EAAnB;AACA,IAAMC,iBAAiB,GAAG,GAA1B;;AAEA,SAASC,GAAT,GAAe;AACbH,YAAU,GAAGI,WAAW,CAAC,YAAM;AAC7BH,cAAU,CAACI,OAAX,CAAmBC,IAAnB;AACD,GAFuB,EAErBJ,iBAFqB,CAAxB;AAGD;;AAED,SAASK,IAAT,GAAgB;AACdC,eAAa,CAACR,UAAD,CAAb;AACAA,YAAU,GAAG,IAAb;AACD;;AAED,SAASM,IAAT,CAAcG,IAAd,EAAoB;AAClB,MAAQC,GAAR,GAAiDD,IAAjD,CAAQC,GAAR;AAAA,MAAaC,QAAb,GAAiDF,IAAjD,CAAaE,QAAb;AAAA,MAAuBC,SAAvB,GAAiDH,IAAjD,CAAuBG,SAAvB;AAAA,MAAkCC,UAAlC,GAAiDJ,IAAjD,CAAkCI,UAAlC;AACA,MAAMC,KAAK,GAAGJ,GAAG,CAACK,WAAlB;AACA,MAAMC,MAAM,GAAGN,GAAG,CAAC1B,YAAnB;;AAEA,MAAI4B,SAAS,KAAKE,KAAd,IAAuBD,UAAU,KAAKG,MAA1C,EAAkD;AAChDP,QAAI,CAACG,SAAL,GAAiBE,KAAjB;AACAL,QAAI,CAACI,UAAL,GAAkBG,MAAlB;AAEAL,YAAQ,CAAC;AAAEG,WAAK,EAALA,KAAF;AAASE,YAAM,EAANA;AAAT,KAAD,CAAR;AACD;AACF;;AAED,SAASC,eAAT,CAAyBP,GAAzB,EAA8BC,QAA9B,EAAwC;AACtC,MAAMF,IAAI,GAAG;AACXC,OAAG,EAAHA,GADW;AAEXC,YAAQ,EAARA,QAFW;AAGXC,aAAS,EAAE,IAHA;AAIXC,cAAU,EAAE;AAJD,GAAb;;AAMA,MAAMK,OAAO,GAAG,SAAVA,OAAU,GAAM;AACpBxB,mBAAe,CAACO,UAAD,EAAaQ,IAAb,CAAf;AACA,QAAI,CAACR,UAAU,CAACkB,MAAhB,EAAwBZ,IAAI;AAC7B,GAHD;;AAKAN,YAAU,CAACmB,IAAX,CAAgBX,IAAhB;AAGAH,MAAI,CAACG,IAAD,CAAJ;AACAN,KAAG;AAEH,SAAOe,OAAP;AACD;;AAEM,SAASG,SAAT,CAAmBX,GAAnB,EAAwBC,QAAxB,EAAkC;AAEvC,MAAMW,KAAK,GAAGC,QAAQ,CAACC,YAAT,KAA0B,CAAxC;AAGA,MAAIC,MAAM,GAAG,IAAb;;AACA,MAAMC,eAAe,GAAG,SAAlBA,eAAkB;AAAA,WAAaD,MAAM,IAAId,QAAQ,MAAR,mBAAvB;AAAA,GAAxB;;AACA,MAAMgB,cAAc,GAAGL,KAAK,GACxBL,eADwB,GAExBW,6BAFJ;AAGA,MAAMC,iBAAiB,GAAGF,cAAc,CAACjB,GAAD,EAAMgB,eAAN,CAAxC;AACAD,QAAM,GAAG,KAAT;AAEA,SAAOI,iBAAP;AACD,C;;AClED,SAASC,iBAAT,CAA2BpB,GAA3B,EAAgC;AAC9B,MAAMqB,cAAc,GAAG,EAAvB;AACA,MAAIC,OAAO,GAAGtB,GAAG,CAACuB,UAAlB;;AAEA,SAAOD,OAAO,IAAIA,OAAO,CAACE,QAAR,KAAqB,MAAhC,IAA0CF,OAAO,CAACG,QAAR,KAAqBZ,QAAQ,CAACa,YAA/E,EAA6F;AAC3F,QAAIC,cAAc,CAACL,OAAD,CAAlB,EAA6BD,cAAc,CAACX,IAAf,CAAoBY,OAApB;AAC7BA,WAAO,GAAGA,OAAO,CAACC,UAAlB;AACD;;AACDF,gBAAc,CAACX,IAAf,CAAoBkB,MAApB;AAEA,SAAOP,cAAP;AACD;;AAED,SAASM,cAAT,CAAwB3B,GAAxB,EAA6B;AAE3B,0BAA2C6B,gBAAgB,CAAC7B,GAAD,CAA3D;AAAA,MAAQ8B,QAAR,qBAAQA,QAAR;AAAA,MAAkBC,SAAlB,qBAAkBA,SAAlB;AAAA,MAA6BC,SAA7B,qBAA6BA,SAA7B;;AACA,SAAO,wBAAwBpC,IAAxB,CAA6BkC,QAAQ,GAAGE,SAAX,GAAuBD,SAApD,CAAP;AACD;;AAEM,SAASE,kCAAT,CAA4CjC,GAA5C,EAAiDC,QAAjD,EAA2D;AAChE,MAAMoB,cAAc,GAAGD,iBAAiB,CAACpB,GAAD,CAAxC;AAEA4B,QAAM,CAACM,gBAAP,CAAwB,QAAxB,EAAkCjC,QAAlC,EAA4C;AAAEkC,WAAO,EAAE;AAAX,GAA5C;AACAd,gBAAc,CAAC1B,OAAf,CAAuB,UAAAyC,YAAY,EAAI;AACrCA,gBAAY,CAACF,gBAAb,CAA8B,QAA9B,EAAwCjC,QAAxC,EAAkD;AAAEkC,aAAO,EAAE;AAAX,KAAlD;AACD,GAFD;AAIA,SAAO,SAASE,oBAAT,GAAgC;AACrCT,UAAM,CAACU,mBAAP,CAA2B,QAA3B,EAAqCrC,QAArC,EAA+C;AAAEkC,aAAO,EAAE;AAAX,KAA/C;AACAd,kBAAc,CAAC1B,OAAf,CAAuB,UAAA4C,aAAa,EAAI;AACtCA,mBAAa,CAACD,mBAAd,CAAkC,QAAlC,EAA4CrC,QAA5C,EAAsD;AAAEkC,eAAO,EAAE;AAAX,OAAtD;AACD,KAFD;AAGD,GALD;AAMD,C;;ACjCM,SAASK,WAAT,CAAeC,CAAf,EAAkB;AACvB,SAAOA,CAAC,KAAKA,CAAb;AACD,C;;;;;;;;;;;;;;;;;;;;;;;;;;ACFM,IAAMC,SAAS,GAAG,SAAZA,SAAY;AAAA,SAAMC,MAAM,CAACC,MAAP,CAAc,IAAd,CAAN;AAAA,CAAlB,C;;;;;;;;ACAP,SAASC,aAAT,CAAuBC,KAAvB,EAA8B;AAC5B,MAAIA,KAAK,IAAI,IAAT,IAAiB,iBAAOA,KAAP,MAAiB,QAAtC,EAAgD,OAAO,KAAP;AAChD,SAAOH,MAAM,CAACI,cAAP,CAAsBD,KAAtB,MAAiCH,MAAM,CAACK,SAA/C;AACD;;AAED,SAASC,IAAT,CAAcC,GAAd,EAAmBC,GAAnB,EAAwBL,KAAxB,EAA+B;AAC7B,MAAID,aAAa,CAACC,KAAD,CAAjB,EAA0B;AACxBI,OAAG,CAACC,GAAD,CAAH,KAAaD,GAAG,CAACC,GAAD,CAAH,GAAW,EAAxB;AACAC,cAAU,CAACF,GAAG,CAACC,GAAD,CAAJ,EAAWL,KAAX,CAAV;AACD,GAHD,MAGO;AACLI,OAAG,CAACC,GAAD,CAAH,GAAWL,KAAX;AACD;AACF;;AAEM,SAASM,UAAT,CAAoBC,MAApB,EAA4BC,MAA5B,EAAoC;AACzC,MAAIT,aAAa,CAACS,MAAD,CAAjB,EAA2B;AACzB,QAAMC,IAAI,GAAGZ,MAAM,CAACY,IAAP,CAAYD,MAAZ,CAAb;;AAEA,SAAK,IAAIE,CAAC,GAAG,CAAR,EAAWC,GAAG,GAAGF,IAAI,CAAC9C,MAA3B,EAAmC+C,CAAC,GAAGC,GAAvC,EAA4CD,CAAC,EAA7C,EAAiD;AAC/CP,UAAI,CAACI,MAAD,EAASE,IAAI,CAACC,CAAD,CAAb,EAAkBF,MAAM,CAACC,IAAI,CAACC,CAAD,CAAL,CAAxB,CAAJ;AACD;AACF;;AAED,SAAOH,MAAP;AACD,C;;;;;;;;ACxBM,SAASK,QAAT,CAAkBC,QAAlB,EAA4BzE,IAA5B,EAAkC;AACvC,SAAOyE,QAAQ,CAACvE,OAAT,CAAiBF,IAAjB,MAA2B,CAAC,CAAnC;AACD,C;;ACFM,SAAS0E,IAAT,CAAc3E,GAAd,EAAmB4E,SAAnB,EAA8BC,GAA9B,EAAmC;AACxC,OAAK,IAAIN,CAAC,GAAG,CAAR,EAAWC,GAAG,GAAGxE,GAAG,CAACwB,MAA1B,EAAkC+C,CAAC,GAAGC,GAAtC,EAA2CD,CAAC,EAA5C,EAAgD;AAC9C,QAAIK,SAAS,CAAC/F,IAAV,CAAegG,GAAf,EAAoB7E,GAAG,CAACuE,CAAD,CAAvB,EAA4BA,CAA5B,EAA+BvE,GAA/B,CAAJ,EAAyC,OAAOA,GAAG,CAACuE,CAAD,CAAV;AAC1C;;AACD,SAAOO,SAAP;AACD,C;;ACLM,SAASC,SAAT,CAAmBC,IAAnB,EAAyBC,IAAzB,EAA+B;AACpC,MAAID,IAAI,CAACxD,MAAL,KAAgByD,IAAI,CAACzD,MAAzB,EAAiC,OAAO,IAAP;;AAEjC,OAAK,IAAI+C,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGS,IAAI,CAACxD,MAAzB,EAAiC+C,CAAC,EAAlC,EAAsC;AACpC,QAAIS,IAAI,CAACT,CAAD,CAAJ,KAAYU,IAAI,CAACV,CAAD,CAApB,EAAyB,OAAO,IAAP;AAC1B;;AAED,SAAO,KAAP;AACD,C;;ACJD;AAMA;AACA;AACA;AACA;AACA;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC9BO,IAAMW,cAAc,GAAG,IAAvB;AAGA,IAAMC,SAAS,GAAG,CAAlB;AACA,IAAMC,aAAa,GAAG,CAAtB;AACA,IAAMC,OAAO,GAAG,CAAhB;AAGA,IAAMC,YAAY,GAAG,cAArB;AACA,IAAMC,eAAe,GAAG,iBAAxB;AACA,IAAMC,aAAa,GAAG,eAAtB;AACA,IAAMC,gBAAgB,GAAG,kBAAzB;AAGA,IAAMC,iBAAiB,GAAG,mBAA1B;AACA,IAAMC,qBAAqB,GAAG,uBAA9B;AACA,IAAMC,YAAY,GAAG,cAArB;AAGA,IAAMC,GAAG,GAAG,KAAZ;AACA,IAAMC,eAAe,GAAG,iBAAxB;AACA,IAAMC,aAAa,GAAG,eAAtB;AACA,IAAMC,sBAAsB,GAAG,wBAA/B;AAGA,IAAMC,cAAc,GAAG,gBAAvB;AACA,IAAMC,KAAK,GAAG,OAAd;AACA,IAAMC,KAAK,GAAG,OAAd;AAGA,IAAMC,SAAS,GAAG;AACvBC,WAAS,EAAE,CADY;AAEvBC,OAAK,EAAE,EAFgB;AAGvBC,QAAM,EAAE,EAHe;AAIvBC,KAAG,EAAE,EAJkB;AAKvBC,MAAI,EAAE,EALiB;AAMvBC,YAAU,EAAE,EANW;AAOvBC,UAAQ,EAAE,EAPa;AAQvBC,aAAW,EAAE,EARU;AASvBC,YAAU,EAAE,EATW;AAUvBC,QAAM,EAAE;AAVe,CAAlB;AAcA,IAAMC,oBAAoB,GAAGnJ,OAAO,CAACC,GAAR,CAAYC,QAAZ,KAAyB,SAAzB,GACD,EADC,GAEL,GAFxB;AAGA,IAAMkJ,eAAe,GAAG,CAAxB;AACA,IAAMC,WAAW,GAAG,EAApB,C;;;;;;;;;;ACjDP;AAEA;AAQA;;AASA,SAASC,gBAAT,CAA0BC,CAA1B,EAA6BC,CAA7B,EAAgC;AAC9B,MAAI7C,CAAC,GAAG,CAAR;;AACA,KAAG;AACD,QAAI4C,CAAC,CAACE,KAAF,GAAU9C,CAAd,EAAiB,OAAO,CAAC,CAAR;AACjB,QAAI6C,CAAC,CAACC,KAAF,GAAU9C,CAAd,EAAiB,OAAO,CAAP;AACjB,QAAI4C,CAAC,CAACG,KAAF,CAAQ/C,CAAR,MAAe6C,CAAC,CAACE,KAAF,CAAQ/C,CAAR,CAAnB,EAA+B,OAAO4C,CAAC,CAACG,KAAF,CAAQ/C,CAAR,IAAa6C,CAAC,CAACE,KAAF,CAAQ/C,CAAR,CAApB;AAC/BA,KAAC;AACF,GALD,QAKS,IALT;AAMD;;AAED,SAASgD,gBAAT,CAA0BJ,CAA1B,EAA6BC,CAA7B,EAAgC;AAC9B,SAAOD,CAAC,CAACE,KAAF,KAAYD,CAAC,CAACC,KAAd,GACHH,gBAAgB,CAACC,CAAD,EAAIC,CAAJ,CADb,GAEHD,CAAC,CAACE,KAAF,GAAUD,CAAC,CAACC,KAFhB;AAGD;;AAED,SAASG,wBAAT,GAAoC;AAClC,SAAO;AACLC,YAAQ,EAAE,KADL;AAELC,aAAS,EAAE,KAFN;AAGLC,gBAAY,EAAE;AAHT,GAAP;AAKD;;AAED,SAASC,wBAAT,CAAkC/D,KAAlC,EAAyC;AACvC,MAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B,OAAOgE,aAAa,CAAChE,KAAD,CAApB;AAC/B,MAAI,OAAOA,KAAP,KAAiB,QAAjB,IAA6B,CAACN,WAAK,CAACM,KAAD,CAAvC,EAAgD,OAAOA,KAAK,GAAG,EAAf;AAEhD,SAAO,EAAP;AACD;;AACD,SAASgE,aAAT,CAAuBC,GAAvB,EAA4B;AAC1B,MAAI,CAACA,GAAL,EAAU,OAAO,EAAP;AACV,SAAOA,GAAG,CAACC,SAAJ,CAAc,KAAd,EAAqBC,OAArB,CAA6B,kBAA7B,EAAiD,EAAjD,CAAP;AACD;;AAED,SAASC,KAAT,CAAeC,gBAAf,EAAiCC,MAAjC,EAAyCC,QAAzC,EAAmD;AACjD,SAAOF,gBAAgB,GACnBG,8BAAW,CAACF,MAAD,EAASC,QAAT,CADQ,GAEnB3D,QAAQ,CAAC2D,QAAD,EAAWD,MAAX,CAFZ;AAGD;;AAED,SAASG,eAAT,CAAyBC,GAAzB,EAA8B;AAC5B,SAAOA,GAAG,CAACrK,OAAJ,IAAyCsK,MAAM,CAACD,GAAD,CAAtD;AACD;;AAED,IAAIE,UAAU,GAAG,CAAjB;AAEe;AACbC,SADa,qBACH;AACR,WAAO;AAGLC,cAAQ,EAAE;AAHL,KAAP;AAKD,GAPY;AASbC,OAAK,EAAE;AAILC,yBAAqB,EAAE;AACrBnK,UAAI,EAAEoK,OADe;AAErBC,aAAO,EAAE;AAFY,KAJlB;AAaLC,qCAAiC,EAAE;AACjCtK,UAAI,EAAEoK,OAD2B;AAEjCC,aAAO,EAAE;AAFwB,KAb9B;AAqBLE,cAAU,EAAE;AACVvK,UAAI,EAAEoK,OADI;AAEVC,aAAO,EAAE;AAFC,KArBP;AA6BLG,gBAAY,EAAE;AACZxK,UAAI,EAAEoK,OADM;AAEZC,aAAO,EAAE;AAFG,KA7BT;AAqCLI,SAAK,EAAE;AACLzK,UAAI,EAAEoK,OADD;AAELC,aAAO,EAAE;AAFJ,KArCF;AA6CLK,aAAS,EAAE;AACT1K,UAAI,EAAEoK,OADG;AAETC,aAAO,EAAE;AAFA,KA7CN;AAqDLM,uBAAmB,EAAE;AACnB3K,UAAI,EAAEoK,OADa;AAEnBC,aAAO,EAAE;AAFU,KArDhB;AA6DLO,yBAAqB,EAAE;AACrB5K,UAAI,EAAEoK,OADe;AAErBC,aAAO,EAAE;AAFY,KA7DlB;AAqELQ,2BAAuB,EAAE;AACvB7K,UAAI,EAAEoK,OADiB;AAEvBC,aAAO,EAAE;AAFc,KArEpB;AA6ELS,uBAAmB,EAAE;AACnB9K,UAAI,EAAEoK,OADa;AAEnBC,aAAO,EAAE;AAFU,KA7EhB;AAqFLU,yBAAqB,EAAE;AACrB/K,UAAI,EAAEoK,OADe;AAErBC,aAAO,EAAE;AAFY,KArFlB;AA6FLW,oBAAgB,EAAE;AAChBhL,UAAI,EAAEoK,OADU;AAEhBC,aAAO,EAAE;AAFO,KA7Fb;AAuGLY,kBAAc,EAAE;AACdjL,UAAI,EAAEkL,QADQ;AAEdb,aAAO,EAAEc,kBAAQ,CAAC,IAAD;AAFH,KAvGX;AA+GLC,oBAAgB,EAAE;AAChBpL,UAAI,EAAEoK,OADU;AAEhBC,aAAO,EAAE;AAFO,KA/Gb;AAuHLgB,gBAAY,EAAE;AACZrL,UAAI,EAAEoK,OADM;AAEZC,aAAO,EAAE;AAFG,KAvHT;AA+HLiB,aAAS,EAAE;AACTtL,UAAI,EAAEoK,OADG;AAETC,aAAO,EAAE;AAFA,KA/HN;AAuILkB,gBAAY,EAAE;AACZvL,UAAI,EAAE8J,MADM;AAEZO,aAAO,EAAE;AAFG,KAvIT;AAiJLmB,iBAAa,EAAE;AACbxL,UAAI,EAAEoK,OADO;AAEbC,aAAO,EAAE;AAFI,KAjJV;AAyJLoB,kBAAc,EAAE;AACdzL,UAAI,EAAE8J,MADQ;AAEdO,aAAO,EAAE;AAFK,KAzJX;AAkKLqB,iBAAa,EAAE;AACb1L,UAAI,EAAEoK,OADO;AAEbC,aAAO,EAAE;AAFI,KAlKV;AA2KLsB,sBAAkB,EAAE;AAClB3L,UAAI,EAAE4L,MADY;AAElBvB,aAAO,EAAE;AAFS,KA3Kf;AAqLLwB,kBAAc,EAAE;AACdxB,aAAO,EAAE;AADK,KArLX;AA4LLyB,iBAAa,EAAE;AACb9L,UAAI,EAAEoK,OADO;AAEbC,aAAO,EAAE;AAFI,KA5LV;AAoML0B,aAAS,EAAE;AACT/L,UAAI,EAAE8J,MADG;AAETO,aAAO,EAAE;AAFA,KApMN;AA8ML2B,wBAAoB,EAAE;AACpBhM,UAAI,EAAEoK,OADc;AAEpBC,aAAO,EAAE;AAFW,KA9MjB;AAsNL4B,sBAAkB,EAAE;AAClBjM,UAAI,EAAEoK,OADY;AAElBC,aAAO,EAAE;AAFS,KAtNf;AA8NL6B,YAAQ,EAAE;AACRlM,UAAI,EAAEoK,OADE;AAERC,aAAO,EAAE;AAFD,KA9NL;AAsOL8B,wBAAoB,EAAE;AACpBnM,UAAI,EAAEoK,OADc;AAEpBC,aAAO,EAAE;AAFW,KAtOjB;AAiPL+B,QAAI,EAAE;AACJpM,UAAI,EAAEoK,OADF;AAEJC,aAAO,EAAE;AAFL,KAjPD;AA0PLN,cAAU,EAAE;AAEVM,aAAO,EAAE;AAAA,yBAASN,UAAU,EAAnB;AAAA,OAFC;AAGV/J,UAAI,EAAE,CAAE8J,MAAF,EAAU8B,MAAV;AAHI,KA1PP;AAmQLS,cAAU,EAAE;AACVrM,UAAI,EAAEoK,OADI;AAEVC,aAAO,EAAE;AAFC,KAnQP;AA4QLiC,SAAK,EAAE;AACLtM,UAAI,EAAE4L,MADD;AAELvB,aAAO,EAAEkC;AAFJ,KA5QF;AAqRLC,aAAS,EAAE;AACTxM,UAAI,EAAEkL,QADG;AAETb,aAAO,EAAE,SAASoC,gBAAT,CAA0BC,KAA1B,EAAiC;AACxC,6BAAcA,KAAd;AACD;AAJQ,KArRN;AA+RLC,eAAW,EAAE;AACX3M,UAAI,EAAE8J,MADK;AAEXO,aAAO,EAAE;AAFE,KA/RR;AAwSLuC,eAAW,EAAE;AACX5M,UAAI,EAAEkL;AADK,KAxSR;AA+SL2B,aAAS,EAAE;AACT7M,UAAI,EAAE8M,KADG;AAETzC,aAAO,EAAEc,kBAAQ,CAAC,CAAE,OAAF,CAAD;AAFR,KA/SN;AAuTL4B,aAAS,EAAE;AACT/M,UAAI,EAAE4L,MADG;AAETvB,aAAO,EAAE;AAFA,KAvTN;AA+TL2C,YAAQ,EAAE;AACRhN,UAAI,EAAEoK,OADE;AAERC,aAAO,EAAE;AAFD,KA/TL;AAuUL4C,QAAI,EAAE;AACJjN,UAAI,EAAE8J;AADF,KAvUD;AA8ULoD,kBAAc,EAAE;AACdlN,UAAI,EAAE8J,MADQ;AAEdO,aAAO,EAAE;AAFK,KA9UX;AAsVL8C,iBAAa,EAAE;AACbnN,UAAI,EAAE8J,MADO;AAEbO,aAAO,EAAE;AAFI,KAtVV;AA8VL+C,iBAAa,EAAE;AACbpN,UAAI,EAAE8J,MADO;AAEbO,aAAO,EAAE;AAFI,KA9VV;AAuWLgD,cAAU,EAAE;AACVrN,UAAI,EAAEkL,QADI;AAEVb,aAAO,EAAEiD,kBAAQA;AAFP,KAvWP;AAwXLC,iBAAa,EAAE;AACbvN,UAAI,EAAE8J,MADO;AAEbO,aAAO,EAAE,MAFI;AAGbmD,eAHa,qBAGHrI,KAHG,EAGI;AACf,YAAMsI,gBAAgB,GAAG,CAAE,MAAF,EAAU,KAAV,EAAiB,QAAjB,EAA2B,OAA3B,EAAoC,OAApC,CAAzB;AACA,eAAO1H,QAAQ,CAAC0H,gBAAD,EAAmBtI,KAAnB,CAAf;AACD;AANY,KAxXV;AAoYLuI,eAAW,EAAE;AACX1N,UAAI,EAAEoK,OADK;AAEXC,aAAO,EAAE;AAFE,KApYR;AA4YLsD,eAAW,EAAE;AACX3N,UAAI,EAAEoK,OADK;AAEXC,aAAO,EAAE;AAFE,KA5YR;AAqZLuD,WAAO,EAAE;AACP5N,UAAI,EAAE8M;AADC,KArZJ;AA4ZLe,eAAW,EAAE;AACX7N,UAAI,EAAE8J,MADK;AAEXO,aAAO,EAAE;AAFE,KA5ZR;AAoaLyD,YAAQ,EAAE;AACR9N,UAAI,EAAEoK,OADE;AAERC,aAAO,EAAE;AAFD,KApaL;AA4aL0D,aAAS,EAAE;AACT/N,UAAI,EAAE8J,MADG;AAETO,aAAO,EAAE;AAFA,KA5aN;AAobL2D,cAAU,EAAE;AACVhO,UAAI,EAAE8J,MADI;AAEVO,aAAO,EAAE;AAFC,KApbP;AA4bL4D,cAAU,EAAE;AACVjO,UAAI,EAAEoK,OADI;AAEVC,aAAO,EAAE;AAFC,KA5bP;AAocL6D,gBAAY,EAAE;AACZlO,UAAI,EAAEoK,OADM;AAEZC,aAAO,EAAE;AAFG,KApcT;AA4cL8D,oBAAgB,EAAE;AAChBnO,UAAI,EAAE8J,MADU;AAEhBO,aAAO,EAAE;AAFO,KA5cb;AAodL+D,aAAS,EAAE;AACTpO,UAAI,EAAEoK,OADG;AAETC,aAAO,EAAE;AAFA,KApdN;AAieLgE,eAAW,EAAE;AACXrO,UAAI,EAAE8J,MADK;AAEXO,aAAO,EAAEzD,YAFE;AAGX4G,eAHW,qBAGDrI,KAHC,EAGM;AACf,YAAMsI,gBAAgB,GAAG,CAAE7G,YAAF,EAAgBC,eAAhB,EAAiCC,aAAjC,EAAgDC,gBAAhD,CAAzB;AACA,eAAOhB,QAAQ,CAAC0H,gBAAD,EAAmBtI,KAAnB,CAAf;AACD;AANU,KAjeR;AA+eLmJ,qBAAiB,EAAE,IA/ed;AAyfLC,eAAW,EAAE;AACXvO,UAAI,EAAE8J,MADK;AAEXO,aAAO,EAAE9C,cAFE;AAGXiG,eAHW,qBAGDrI,KAHC,EAGM;AACf,YAAMsI,gBAAgB,GAAG,CAAElG,cAAF,EAAkBC,KAAlB,EAAyBC,KAAzB,CAAzB;AACA,eAAO1B,QAAQ,CAAC0H,gBAAD,EAAmBtI,KAAnB,CAAf;AACD;AANU,KAzfR;AAqgBLqJ,YAAQ,EAAE;AACRxO,UAAI,EAAE4L,MADE;AAERvB,aAAO,EAAE;AAFD,KArgBL;AAihBLlF,SAAK,EAAE,IAjhBF;AA2hBLsJ,mBAAe,EAAE;AACfzO,UAAI,EAAE8J,MADS;AAEfO,aAAO,EAAEjD,eAFM;AAGfoG,eAHe,qBAGLrI,KAHK,EAGE;AACf,YAAMsI,gBAAgB,GAAG,CAAEtG,GAAF,EAAOC,eAAP,EAAwBC,aAAxB,EAAuCC,sBAAvC,CAAzB;AACA,eAAOvB,QAAQ,CAAC0H,gBAAD,EAAmBtI,KAAnB,CAAf;AACD;AANc,KA3hBZ;AA2iBLuJ,eAAW,EAAE;AACX1O,UAAI,EAAE8J,MADK;AAEXO,aAAO,EAAE;AAFE,KA3iBR;AAmjBLsE,UAAM,EAAE;AACN3O,UAAI,EAAE,CAAE4L,MAAF,EAAU9B,MAAV,CADA;AAENO,aAAO,EAAE;AAFH;AAnjBH,GATM;AAkkBbuE,MAlkBa,kBAkkBN;AACL,WAAO;AACLC,aAAO,EAAE;AAEPC,iBAAS,EAAE,KAFJ;AAIPC,mBAAW,EAAE;AAJN,OADJ;AAQLC,UAAI,EAAE;AAEJC,cAAM,EAAE,KAFJ;AAIJC,eAAO,EAAE,IAJL;AAMJC,0BAAkB,EAAE,CANhB;AAQJC,iBAAS,EAAE;AARP,OARD;AAmBLC,YAAM,EAAE;AAENC,yBAAiB,EAAE,EAFb;AAINC,eAAO,EAAExK,SAAS,EAJZ;AAMNyK,uBAAe,EAAEzK,SAAS,EANpB;AAQN0K,uBAAe,EAAE,KAAKC,8BAAL,EARX;AAWNC,uBAAe,EAAE5K,SAAS;AAXpB,OAnBH;AAkCL6K,uBAAiB,EAAE9G,wBAAwB,EAlCtC;AAoCL+G,iBAAW,EAAE;AAEXC,cAAM,EAAE,KAFG;AAIXC,iBAAS,EAAE,IAJA;AAMXC,gBAAQ,EAAEjL,SAAS;AANR,OApCR;AA8CLkL,kBAAY,EAAElL,SAAS;AA9ClB,KAAP;AAgDD,GAnnBY;AAqnBbmL,UAAQ,EAAE;AAMRC,iBANQ,2BAMQ;AACd,aAAO,KAAKd,MAAL,CAAYI,eAAZ,CAA4BW,GAA5B,CAAgC,KAAKC,OAArC,CAAP;AACD,KARO;AAaRC,iBAbQ,2BAaQ;AAAA;;AACd,UAAIA,aAAJ;;AAGA,UAAI,KAAKC,MAAL,IAAe,KAAKnE,IAApB,IAA4B,KAAKH,kBAAjC,IAAuD,KAAKwC,eAAL,KAAyBtH,GAApF,EAAyF;AACvFmJ,qBAAa,GAAG,KAAKjB,MAAL,CAAYI,eAAZ,CAA4Be,KAA5B,EAAhB;AACD,OAFD,MAEO,IAAI,KAAK/B,eAAL,KAAyBrH,eAA7B,EAA8C;AACnDkJ,qBAAa,GAAG,KAAKjB,MAAL,CAAYI,eAAZ,CAA4BgB,MAA5B,CAAmC,UAAAC,EAAE,EAAI;AACvD,cAAMC,IAAI,GAAG,KAAI,CAACN,OAAL,CAAaK,EAAb,CAAb;;AACA,cAAIC,IAAI,CAACC,UAAT,EAAqB,OAAO,IAAP;AACrB,iBAAO,CAAC,KAAI,CAACC,UAAL,CAAgBF,IAAI,CAAC/M,UAArB,CAAR;AACD,SAJe,CAAhB;AAKD,OANM,MAMA,IAAI,KAAK6K,eAAL,KAAyBpH,aAA7B,EAA4C;AACjDiJ,qBAAa,GAAG,KAAKjB,MAAL,CAAYI,eAAZ,CAA4BgB,MAA5B,CAAmC,UAAAC,EAAE,EAAI;AACvD,cAAMC,IAAI,GAAG,KAAI,CAACN,OAAL,CAAaK,EAAb,CAAb;;AACA,cAAIC,IAAI,CAACG,MAAT,EAAiB,OAAO,IAAP;AACjB,iBAAOH,IAAI,CAACI,QAAL,CAAcjO,MAAd,KAAyB,CAAhC;AACD,SAJe,CAAhB;AAKD,OANM,MAMA,IAAI,KAAK2L,eAAL,KAAyBnH,sBAA7B,EAAqD;AAAA;;AAC1D,YAAM0J,oBAAoB,GAAG,EAA7B;AACAV,qBAAa,GAAG,KAAKjB,MAAL,CAAYI,eAAZ,CAA4Be,KAA5B,EAAhB;AACA,aAAKL,aAAL,CAAmBnO,OAAnB,CAA2B,UAAAiP,YAAY,EAAI;AACzCA,sBAAY,CAACC,SAAb,CAAuBlP,OAAvB,CAA+B,UAAAmP,QAAQ,EAAI;AACzC,gBAAIpL,QAAQ,CAACiL,oBAAD,EAAuBG,QAAQ,CAACT,EAAhC,CAAZ,EAAiD;AACjD,gBAAI3K,QAAQ,CAACuK,aAAD,EAAgBa,QAAQ,CAACT,EAAzB,CAAZ,EAA0C;AAC1CM,gCAAoB,CAACjO,IAArB,CAA0BoO,QAAQ,CAACT,EAAnC;AACD,WAJD;AAKD,SAND;;AAOA,0BAAAJ,aAAa,EAACvN,IAAd,uBAAsBiO,oBAAtB;AACD;;AAED,UAAI,KAAKzC,WAAL,KAAqB/G,KAAzB,EAAgC;AAC9B8I,qBAAa,CAACc,IAAd,CAAmB,UAAC3I,CAAD,EAAIC,CAAJ;AAAA,iBAAUG,gBAAgB,CAAC,KAAI,CAACwH,OAAL,CAAa5H,CAAb,CAAD,EAAkB,KAAI,CAAC4H,OAAL,CAAa3H,CAAb,CAAlB,CAA1B;AAAA,SAAnB;AACD,OAFD,MAEO,IAAI,KAAK6F,WAAL,KAAqB9G,KAAzB,EAAgC;AACrC6I,qBAAa,CAACc,IAAd,CAAmB,UAAC3I,CAAD,EAAIC,CAAJ;AAAA,iBAAUF,gBAAgB,CAAC,KAAI,CAAC6H,OAAL,CAAa5H,CAAb,CAAD,EAAkB,KAAI,CAAC4H,OAAL,CAAa3H,CAAb,CAAlB,CAA1B;AAAA,SAAnB;AACD;;AAED,aAAO4H,aAAP;AACD,KAnDO;AAwDRe,YAxDQ,sBAwDG;AACT,aAAO,KAAKf,aAAL,CAAmBxN,MAAnB,GAA4B,CAAnC;AACD,KA1DO;AA+DRyN,UA/DQ,oBA+DC;AACP,aAAO,CAAC,KAAKvD,QAAb;AACD,KAjEO;AA0ERsE,oBA1EQ,8BA0EW;AAAA;;AACjB,UAAMA,gBAAgB,GAAG,EAAzB;AAEA,WAAKC,uBAAL,CAA6B,UAAAZ,IAAI,EAAI;AACnC,YAAI,CAAC,MAAI,CAACd,WAAL,CAAiBC,MAAlB,IAA4B,MAAI,CAAC0B,oCAAL,CAA0Cb,IAA1C,CAAhC,EAAiF;AAC/EW,0BAAgB,CAACvO,IAAjB,CAAsB4N,IAAI,CAACD,EAA3B;AACD;;AAED,YAAIC,IAAI,CAACc,QAAL,IAAiB,CAAC,MAAI,CAACC,YAAL,CAAkBf,IAAlB,CAAtB,EAA+C;AAC7C,iBAAO,KAAP;AACD;AACF,OARD;AAUA,aAAOW,gBAAP;AACD,KAxFO;AA6FRK,qBA7FQ,+BA6FY;AAClB,aAAO,KAAKL,gBAAL,CAAsBxO,MAAtB,KAAiC,CAAxC;AACD,KA/FO;AAoGR8O,6BApGQ,uCAoGoB;AAI1B,aAAO,OAAO,KAAKtD,iBAAZ,KAAkC,SAAlC,GACH,KAAKA,iBADF,GAEH,KAAKF,SAFT;AAGD,KA3GO;AAgHRyD,kBAhHQ,4BAgHS;AACf,aAAO,KAAKxC,MAAL,CAAYC,iBAAZ,CAA8BwC,IAA9B,CAAmC,UAAAC,QAAQ;AAAA,eAAIA,QAAQ,CAACN,QAAb;AAAA,OAA3C,CAAP;AACD,KAlHO;AAmHRO,wBAnHQ,kCAmHe;AACrB,aAAO,KAAKnC,WAAL,CAAiBC,MAAjB,IAA2B,KAAK9D,oBAAvC;AACD;AArHO,GArnBG;AA8uBbiG,OAAK,EAAE;AACL1H,cADK,sBACM2H,QADN,EACgB;AACnB,UAAIA,QAAJ,EAAc,KAAKC,QAAL,GAAd,KACK,KAAKC,SAAL;AACN,KAJI;AAMLhH,oBANK,8BAMc;AACjB,WAAKiH,UAAL;AACD,KARI;AAULnG,YAVK,oBAUIgG,QAVJ,EAUc;AAEjB,UAAIA,QAAQ,IAAI,KAAKlD,IAAL,CAAUC,MAA1B,EAAkC,KAAKmD,SAAL,GAAlC,KACK,IAAI,CAACF,QAAD,IAAa,CAAC,KAAKlD,IAAL,CAAUC,MAAxB,IAAkC,KAAK1E,UAA3C,EAAuD,KAAK4H,QAAL;AAC7D,KAdI;AAgBL/F,QAhBK,kBAgBE;AACL,WAAKiG,UAAL;AACD,KAlBI;AAoBL/B,iBApBK,yBAoBS4B,QApBT,EAoBmBI,QApBnB,EAoB6B;AAChC,UAAMC,UAAU,GAAGlM,SAAS,CAAC6L,QAAD,EAAWI,QAAX,CAA5B;AAIA,UAAIC,UAAJ,EAAgB,KAAKC,KAAL,CAAW,OAAX,EAAoB,KAAKC,QAAL,EAApB,EAAqC,KAAKC,aAAL,EAArC;AACjB,KA1BI;AA4BL7F,aA5BK,uBA4BO;AACV,WAAKwF,UAAL;AACD,KA9BI;AAgCLrF,YAhCK,oBAgCIkF,QAhCJ,EAgCc;AAIjB,UAAIA,QAAJ,EAAc,KAAKS,gBAAL;AACf,KArCI;AAuCL/E,WAAO,EAAE;AACPgF,aADO,qBACG;AACR,YAAI,KAAKnI,KAAT,EAAgB;AAEhB,aAAK4H,UAAL;AACA,aAAKzC,iBAAL,CAAuB7G,QAAvB,GAAkC+D,KAAK,CAAC+F,OAAN,CAAc,KAAKjF,OAAnB,CAAlC;AACD,OANM;AAOPkF,UAAI,EAAE,IAPC;AAQPC,eAAS,EAAE;AARJ,KAvCJ;AAkDL,yBAlDK,gCAkDmB;AACtB,UAAI,KAAKtI,KAAT,EAAgB;AACd,aAAKuI,kBAAL;AACD,OAFD,MAEO;AACL,aAAKC,iBAAL;AACD;;AAED,WAAKT,KAAL,CAAW,eAAX,EAA4B,KAAK3D,OAAL,CAAaE,WAAzC,EAAsD,KAAK2D,aAAL,EAAtD;AACD,KA1DI;AA4DLvN,SA5DK,mBA4DG;AACN,UAAM+N,gBAAgB,GAAG,KAAKxD,8BAAL,EAAzB;AACA,UAAM6C,UAAU,GAAGlM,SAAS,CAAC6M,gBAAD,EAAmB,KAAK5C,aAAxB,CAA5B;AACA,UAAIiC,UAAJ,EAAgB,KAAKY,kBAAL,CAAwBD,gBAAxB;AACjB;AAhEI,GA9uBM;AAizBbE,SAAO,EAAE;AACPC,eADO,yBACO;AAAA;;AACZpU,qBAAO,CACL;AAAA,eAAM,MAAI,CAACwL,KAAL,GAAa,MAAI,CAACwD,UAAlB,GAA+B,IAArC;AAAA,OADK,EAEL;AAAA,eAAM,qEAAN;AAAA,OAFK,CAAP;;AAKA,UAAI,KAAKL,OAAL,IAAgB,IAAhB,IAAwB,CAAC,KAAKhB,WAAlC,EAA+C;AAC7C3N,uBAAO,CACL;AAAA,iBAAM,KAAN;AAAA,SADK,EAEL;AAAA,iBAAM,gFAAN;AAAA,SAFK,CAAP;AAID;;AAED,UAAI,KAAKmN,IAAT,EAAe;AACbnN,uBAAO,CACL;AAAA,iBAAM,MAAI,CAAC+N,QAAX;AAAA,SADK,EAEL;AAAA,iBAAM,iEAAN;AAAA,SAFK,CAAP;AAID;;AAED,UAAI,CAAC,KAAKZ,IAAV,EAAgB;AACd,YAAMkH,SAAS,GAAG,CAChB,qBADgB,EAEhB,uBAFgB,EAGhB,uBAHgB,EAIhB,yBAJgB,CAAlB;AAOAA,iBAAS,CAACtR,OAAV,CAAkB,UAAAuR,QAAQ,EAAI;AAC5BtU,yBAAO,CACL;AAAA,mBAAM,CAAC,MAAI,CAACsU,QAAD,CAAX;AAAA,WADK,EAEL;AAAA,+BAAUA,QAAV;AAAA,WAFK,CAAP;AAID,SALD;AAMD;AACF,KApCM;AAsCPC,cAtCO,wBAsCM;AACX,WAAKC,aAAL,GAAqB,KAArB;AACD,KAxCM;AA0CPpB,cA1CO,wBA0CM;AACX,UAAMzE,OAAO,GAAG,KAAKnD,KAAL,GACZ,KAAKiJ,oBAAL,GAA4B9F,OADhB,GAEZ,KAAKA,OAFT;;AAIA,UAAId,KAAK,CAAC+F,OAAN,CAAcjF,OAAd,CAAJ,EAA4B;AAE1B,YAAM+F,WAAW,GAAG,KAAKtE,MAAL,CAAYE,OAAhC;AACA,aAAKF,MAAL,CAAYE,OAAZ,GAAsBxK,SAAS,EAA/B;AACA,aAAK6O,uBAAL,CAA6BD,WAA7B;AACA,aAAKtE,MAAL,CAAYC,iBAAZ,GAAgC,KAAKjG,SAAL,CAAe7C,cAAf,EAA+BoH,OAA/B,EAAwC+F,WAAxC,CAAhC;AAOA,aAAKR,kBAAL,CAAwB,KAAK7C,aAA7B;AACD,OAbD,MAaO;AACL,aAAKjB,MAAL,CAAYC,iBAAZ,GAAgC,EAAhC;AACD;AACF,KA/DM;AAiEPoD,iBAjEO,2BAiES;AACd,aAAO,KAAK3I,UAAL,IAAmB,IAAnB,GAA0B,KAAK2G,EAA/B,GAAoC,KAAK3G,UAAhD;AACD,KAnEM;AAqEP0I,YArEO,sBAqEI;AAAA;;AACT,UAAI,KAAK/D,WAAL,KAAqB,IAAzB,EAA+B;AAC7B,eAAO,KAAK1B,QAAL,GACH,KAAK6G,kBAAL,CAAwB,KAAKvD,aAAL,CAAmBE,KAAnB,EAAxB,CADG,GAEH,KAAKF,aAAL,CAAmB,CAAnB,CAFJ;AAGD;;AAED,UAAMwD,QAAQ,GAAG,KAAKxD,aAAL,CAAmBF,GAAnB,CAAuB,UAAAM,EAAE;AAAA,eAAI,MAAI,CAACL,OAAL,CAAaK,EAAb,EAAiBqD,GAArB;AAAA,OAAzB,CAAjB;AACA,aAAO,KAAK/G,QAAL,GACH,KAAK6G,kBAAL,CAAwBC,QAAxB,CADG,GAEHA,QAAQ,CAAC,CAAD,CAFZ;AAGD,KAhFM;AAkFPD,sBAlFO,8BAkFYG,GAlFZ,EAkFiB;AAAA;;AACtB,UAAI,KAAKvF,eAAL,KAAyBrH,eAA7B,EAA8C,OAAO4M,GAAP;AAC9C,UAAMC,MAAM,GAAGD,GAAG,CAAC5D,GAAJ,CAAQ,UAAAM,EAAE,EAAI;AAC3B,YAAMC,IAAI,GAAG,MAAI,CAACN,OAAL,CAAaK,EAAb,CAAb;;AACA,YAAIC,IAAI,CAACuD,eAAT,EAA0B,OAAOvD,IAAI,CAACD,EAAZ;;AAC1B,YAAI,MAAI,CAACyD,WAAL,CAAiBxD,IAAjB,CAAJ,EAA4B;AAC1B,cAAMI,QAAQ,GAAG,EAAjB;;AACA,gBAAI,CAACqD,sBAAL,CAA4BzD,IAA5B,EAAkC,UAAA0D,UAAU,EAAI;AAC9C,gBAAI,CAACA,UAAU,CAACC,UAAZ,IAA0B,MAAI,CAAChK,iCAAnC,EAAsE;AACpE,kBAAI+J,UAAU,CAACH,eAAf,EAAgC;AAC9BnD,wBAAQ,CAAChO,IAAT,CAAcsR,UAAU,CAAC3D,EAAzB;AACD;AACF;AACF,WAND;;AAOA,cAAIK,QAAQ,IAAIA,QAAQ,CAACjO,MAAzB,EAAiC,OAAOiO,QAAQ,CAAC,CAAD,CAAf;AAClC;;AACD,eAAOL,EAAP;AACD,OAfc,CAAf;AAgBA,aAAOuD,MAAP;AACD,KArGM;AAsGPE,eAtGO,uBAsGKxD,IAtGL,EAsGW;AAChB,aAAOA,IAAI,IAAIA,IAAI,CAACI,QAAb,IAAyBJ,IAAI,CAACI,QAAL,CAAcjO,MAAd,KAAyB,CAAzD;AACD,KAxGM;AAyGPuN,WAzGO,mBAyGCkE,MAzGD,EAyGS;AACdtV,qBAAO,CACL;AAAA,eAAMsV,MAAM,IAAI,IAAhB;AAAA,OADK,EAEL;AAAA,0CAA0BA,MAA1B;AAAA,OAFK,CAAP;AAKA,UAAIA,MAAM,IAAI,IAAd,EAAoB,OAAO,IAAP;AAEpB,aAAOA,MAAM,IAAI,KAAKlF,MAAL,CAAYE,OAAtB,GACH,KAAKF,MAAL,CAAYE,OAAZ,CAAoBgF,MAApB,CADG,GAEH,KAAKC,kBAAL,CAAwBD,MAAxB,CAFJ;AAGD,KApHM;AAsHPC,sBAtHO,8BAsHY9D,EAtHZ,EAsHgB;AAKrB,UAAMqD,GAAG,GAAG,KAAKU,oBAAL,CAA0B/D,EAA1B,CAAZ;AACA,UAAMgE,KAAK,GAAG,KAAKC,kBAAL,CAAwBZ,GAAxB,EAA6BW,KAA7B,cAAyChE,EAAzC,eAAd;AACA,UAAMkE,YAAY,GAAG;AACnBlE,UAAE,EAAFA,EADmB;AAEnBgE,aAAK,EAALA,KAFmB;AAGnBxD,iBAAS,EAAE,EAHQ;AAInBtN,kBAAU,EAAE4C,cAJO;AAKnBqO,sBAAc,EAAE,IALG;AAMnBjE,kBAAU,EAAE,IANO;AAOnBE,cAAM,EAAE,IAPW;AAQnBW,gBAAQ,EAAE,KARS;AASnB6C,kBAAU,EAAE,KATO;AAUnBQ,aAAK,EAAE,KAVY;AAWnBlM,aAAK,EAAE,CAAE,CAAC,CAAH,CAXY;AAYnBD,aAAK,EAAE,CAZY;AAanBoL,WAAG,EAAHA;AAbmB,OAArB;AAgBA,aAAO,KAAKgB,IAAL,CAAU,KAAK1F,MAAL,CAAYE,OAAtB,EAA+BmB,EAA/B,EAAmCkE,YAAnC,CAAP;AACD,KA9IM;AAgJPlF,kCAhJO,4CAgJ0B;AAAA;;AAC/B,UAAI,KAAKvK,KAAL,IAAc,IAAlB,EAAwB,OAAO,EAAP;;AAExB,UAAI,KAAKuJ,WAAL,KAAqB,IAAzB,EAA+B;AAC7B,eAAO,KAAK1B,QAAL,GACH,KAAK7H,KAAL,CAAWqL,KAAX,EADG,GAEH,CAAE,KAAKrL,KAAP,CAFJ;AAGD;;AAED,aAAO,CAAC,KAAK6H,QAAL,GAAgB,KAAK7H,KAArB,GAA6B,CAAE,KAAKA,KAAP,CAA9B,EACJiL,GADI,CACA,UAAAO,IAAI;AAAA,eAAI,MAAI,CAACgE,kBAAL,CAAwBhE,IAAxB,CAAJ;AAAA,OADJ,EAEJP,GAFI,CAEA,UAAAO,IAAI;AAAA,eAAIA,IAAI,CAACD,EAAT;AAAA,OAFJ,CAAP;AAGD,KA5JM;AA8JP+D,wBA9JO,gCA8Jc/D,EA9Jd,EA8JkB;AAAA;;AACvB,UAAMsE,WAAW,GAAG;AAAEtE,UAAE,EAAFA;AAAF,OAApB;;AAEA,UAAI,KAAKhC,WAAL,KAAqB,IAAzB,EAA+B;AAC7B,eAAOsG,WAAP;AACD;;AAED,UAAMC,UAAU,GAAG,KAAKjI,QAAL,GACfF,KAAK,CAAC+F,OAAN,CAAc,KAAK1N,KAAnB,IAA4B,KAAKA,KAAjC,GAAyC,EAD1B,GAEf,KAAKA,KAAL,GAAa,CAAE,KAAKA,KAAP,CAAb,GAA8B,EAFlC;AAGA,UAAM+P,OAAO,GAAGjP,IAAI,CAClBgP,UADkB,EAElB,UAAAtE,IAAI;AAAA,eAAIA,IAAI,IAAI,MAAI,CAACgE,kBAAL,CAAwBhE,IAAxB,EAA8BD,EAA9B,KAAqCA,EAAjD;AAAA,OAFc,CAApB;AAKA,aAAOwE,OAAO,IAAIF,WAAlB;AACD,KA9KM;AAgLP7B,sBAhLO,8BAgLYgC,qBAhLZ,EAgLmC;AAAA;;AACxC,UAAIC,mBAAmB,GAAG,EAA1B;;AAGA,UAAI,KAAK7E,MAAL,IAAe,KAAKnE,IAApB,IAA4B,KAAKH,kBAAjC,IAAuD,KAAKwC,eAAL,KAAyBtH,GAApF,EAAyF;AACvFiO,2BAAmB,GAAGD,qBAAtB;AACD,OAFD,MAEO,IAAI,KAAK1G,eAAL,KAAyBrH,eAA7B,EAA8C;AACnD+N,6BAAqB,CAACnT,OAAtB,CAA8B,UAAAuS,MAAM,EAAI;AACtCa,6BAAmB,CAACrS,IAApB,CAAyBwR,MAAzB;;AACA,cAAM5D,IAAI,GAAG,MAAI,CAACN,OAAL,CAAakE,MAAb,CAAb;;AACA,cAAI5D,IAAI,CAACc,QAAT,EAAmB,MAAI,CAAC2C,sBAAL,CAA4BzD,IAA5B,EAAkC,UAAA0D,UAAU,EAAI;AACjEe,+BAAmB,CAACrS,IAApB,CAAyBsR,UAAU,CAAC3D,EAApC;AACD,WAFkB;AAGpB,SAND;AAOD,OARM,MAQA,IAAI,KAAKjC,eAAL,KAAyBpH,aAA7B,EAA4C;AACjD,YAAM+I,GAAG,GAAGrL,SAAS,EAArB;AACA,YAAMsQ,KAAK,GAAGF,qBAAqB,CAAC3E,KAAtB,EAAd;;AACA,eAAO6E,KAAK,CAACvS,MAAb,EAAqB;AACnB,cAAMyR,MAAM,GAAGc,KAAK,CAACC,KAAN,EAAf;AACA,cAAM3E,IAAI,GAAG,KAAKN,OAAL,CAAakE,MAAb,CAAb;AACAa,6BAAmB,CAACrS,IAApB,CAAyBwR,MAAzB;AACA,cAAI5D,IAAI,CAACC,UAAT,EAAqB;AACrB,cAAI,EAAED,IAAI,CAAC/M,UAAL,CAAgB8M,EAAhB,IAAsBN,GAAxB,CAAJ,EAAkCA,GAAG,CAACO,IAAI,CAAC/M,UAAL,CAAgB8M,EAAjB,CAAH,GAA0BC,IAAI,CAAC/M,UAAL,CAAgBmN,QAAhB,CAAyBjO,MAAnD;AAClC,cAAI,EAAEsN,GAAG,CAACO,IAAI,CAAC/M,UAAL,CAAgB8M,EAAjB,CAAL,KAA8B,CAAlC,EAAqC2E,KAAK,CAACtS,IAAN,CAAW4N,IAAI,CAAC/M,UAAL,CAAgB8M,EAA3B;AACtC;AACF,OAXM,MAWA,IAAI,KAAKjC,eAAL,KAAyBnH,sBAA7B,EAAqD;AAC1D,YAAM8I,IAAG,GAAGrL,SAAS,EAArB;;AACA,YAAMsQ,MAAK,GAAGF,qBAAqB,CAAC1E,MAAtB,CAA6B,UAAA8D,MAAM,EAAI;AACnD,cAAM5D,IAAI,GAAG,MAAI,CAACN,OAAL,CAAakE,MAAb,CAAb;;AACA,iBAAO5D,IAAI,CAACG,MAAL,IAAeH,IAAI,CAACI,QAAL,CAAcjO,MAAd,KAAyB,CAA/C;AACD,SAHa,CAAd;;AAIA,eAAOuS,MAAK,CAACvS,MAAb,EAAqB;AACnB,cAAMyR,OAAM,GAAGc,MAAK,CAACC,KAAN,EAAf;;AACA,cAAM3E,KAAI,GAAG,KAAKN,OAAL,CAAakE,OAAb,CAAb;;AACAa,6BAAmB,CAACrS,IAApB,CAAyBwR,OAAzB;AACA,cAAI5D,KAAI,CAACC,UAAT,EAAqB;AACrB,cAAI,EAAED,KAAI,CAAC/M,UAAL,CAAgB8M,EAAhB,IAAsBN,IAAxB,CAAJ,EAAkCA,IAAG,CAACO,KAAI,CAAC/M,UAAL,CAAgB8M,EAAjB,CAAH,GAA0BC,KAAI,CAAC/M,UAAL,CAAgBmN,QAAhB,CAAyBjO,MAAnD;AAClC,cAAI,EAAEsN,IAAG,CAACO,KAAI,CAAC/M,UAAL,CAAgB8M,EAAjB,CAAL,KAA8B,CAAlC,EAAqC2E,MAAK,CAACtS,IAAN,CAAW4N,KAAI,CAAC/M,UAAL,CAAgB8M,EAA3B;AACtC;AACF;;AAED,UAAM6B,UAAU,GAAGlM,SAAS,CAAC,KAAKgJ,MAAL,CAAYI,eAAb,EAA8B2F,mBAA9B,CAA5B;AAIA,UAAI7C,UAAJ,EAAgB,KAAKlD,MAAL,CAAYI,eAAZ,GAA8B2F,mBAA9B;AAEhB,WAAKzC,gBAAL;AACD,KAhOM;AAkOPiB,2BAlOO,mCAkOiBD,WAlOjB,EAkO8B;AAAA;;AAGnC,WAAKtE,MAAL,CAAYI,eAAZ,CAA4BzN,OAA5B,CAAoC,UAAA0O,EAAE,EAAI;AACxC,YAAI,CAACiD,WAAW,CAACjD,EAAD,CAAhB,EAAsB;;AACtB,YAAMC,IAAI,mCACLgD,WAAW,CAACjD,EAAD,CADN;AAERmE,wBAAc,EAAE;AAFR,UAAV;;AAIA,cAAI,CAACE,IAAL,CAAU,MAAI,CAAC1F,MAAL,CAAYE,OAAtB,EAA+BmB,EAA/B,EAAmCC,IAAnC;AACD,OAPD;AAQD,KA7OM;AA+OPE,cA/OO,sBA+OIF,IA/OJ,EA+OU;AAEf,aAAO,KAAKtB,MAAL,CAAYM,eAAZ,CAA4BgB,IAAI,CAACD,EAAjC,MAAyC,IAAhD;AACD,KAlPM;AAoPP0D,0BApPO,kCAoPgBxQ,UApPhB,EAoP4B2R,QApP5B,EAoPsC;AAE3C,UAAI,CAAC3R,UAAU,CAAC6N,QAAhB,EAA0B;AAC1B,UAAM4D,KAAK,GAAGzR,UAAU,CAACmN,QAAX,CAAoBP,KAApB,EAAd;;AACA,aAAO6E,KAAK,CAACvS,MAAb,EAAqB;AACnB,YAAM0S,QAAQ,GAAGH,KAAK,CAAC,CAAD,CAAtB;AACA,YAAIG,QAAQ,CAAC/D,QAAb,EAAuB4D,KAAK,CAACtS,IAAN,OAAAsS,KAAK,8BAASG,QAAQ,CAACzE,QAAlB,EAAL;AACvBwE,gBAAQ,CAACC,QAAD,CAAR;AACAH,aAAK,CAACC,KAAN;AACD;AACF,KA9PM;AAgQPG,0BAhQO,kCAgQgB7R,UAhQhB,EAgQ4B2R,QAhQ5B,EAgQsC;AAAA;;AAC3C,UAAI,CAAC3R,UAAU,CAAC6N,QAAhB,EAA0B;AAC1B7N,gBAAU,CAACmN,QAAX,CAAoB/O,OAApB,CAA4B,UAAA0T,KAAK,EAAI;AAEnC,eAAI,CAACD,sBAAL,CAA4BC,KAA5B,EAAmCH,QAAnC;;AACAA,gBAAQ,CAACG,KAAD,CAAR;AACD,OAJD;AAKD,KAvQM;AAyQPC,uBAzQO,+BAyQaJ,QAzQb,EAyQuB;AAAA;;AAC5B,WAAKlG,MAAL,CAAYC,iBAAZ,CAA8BtN,OAA9B,CAAsC,UAAA+P,QAAQ,EAAI;AAEhD,eAAI,CAAC0D,sBAAL,CAA4B1D,QAA5B,EAAsCwD,QAAtC;;AACAA,gBAAQ,CAACxD,QAAD,CAAR;AACD,OAJD;AAKD,KA/QM;AAiRPR,2BAjRO,mCAiRiBgE,QAjRjB,EAiR2B;AAChC,UAAMK,IAAI,GAAG,SAAPA,IAAO,CAAAhS,UAAU,EAAI;AACzBA,kBAAU,CAACmN,QAAX,CAAoB/O,OAApB,CAA4B,UAAA0T,KAAK,EAAI;AACnC,cAAIH,QAAQ,CAACG,KAAD,CAAR,KAAoB,KAApB,IAA6BA,KAAK,CAACjE,QAAvC,EAAiD;AAC/CmE,gBAAI,CAACF,KAAD,CAAJ;AACD;AACF,SAJD;AAKD,OAND;;AAUAE,UAAI,CAAC;AAAE7E,gBAAQ,EAAE,KAAK1B,MAAL,CAAYC;AAAxB,OAAD,CAAJ;AACD,KA7RM;AA+RPuG,2BA/RO,mCA+RiBC,OA/RjB,EA+R0B;AAC/B,UAAIA,OAAJ,EAAa;AACX5S,gBAAQ,CAACqB,gBAAT,CAA0B,WAA1B,EAAuC,KAAKwR,kBAA5C,EAAgE,KAAhE;AACD,OAFD,MAEO;AACL7S,gBAAQ,CAACyB,mBAAT,CAA6B,WAA7B,EAA0C,KAAKoR,kBAA/C,EAAmE,KAAnE;AACD;AACF,KArSM;AAuSPC,qBAvSO,+BAuSa;AAClB,aAAO,KAAKC,KAAL,CAAWC,OAAX,CAAmBD,KAAnB,CAAyB,iBAAzB,CAAP;AACD,KAzSM;AA2SPE,YA3SO,sBA2SI;AACT,aAAO,KAAKH,iBAAL,GAAyBC,KAAzB,CAA+BG,KAAtC;AACD,KA7SM;AA+SPC,cA/SO,wBA+SM;AACX,WAAKF,QAAL,GAAgBG,KAAhB;AACD,KAjTM;AAmTPC,aAnTO,uBAmTK;AACV,WAAKJ,QAAL,GAAgBK,IAAhB;AACD,KArTM;AAuTPC,mBAAe,EAAE7W,WAAW,CAAC,SAAS6W,eAAT,CAAyB1W,GAAzB,EAA8B;AACzDA,SAAG,CAAC2W,cAAJ;AACA3W,SAAG,CAAC4W,eAAJ;AAEA,UAAI,KAAKzK,QAAT,EAAmB;AAEnB,UAAM0K,yBAAyB,GAAG,KAAKZ,iBAAL,GAAyB3T,GAAzB,CAA6BwU,QAA7B,CAAsC9W,GAAG,CAAC2F,MAA1C,CAAlC;;AACA,UAAIkR,yBAAyB,IAAI,CAAC,KAAK5H,IAAL,CAAUC,MAAxC,KAAmD,KAAKvB,WAAL,IAAoB,KAAKmB,OAAL,CAAaC,SAApF,CAAJ,EAAoG;AAClG,aAAKqD,QAAL;AACD;;AAED,UAAI,KAAKsB,aAAT,EAAwB;AACtB,aAAK8C,SAAL;AACD,OAFD,MAEO;AAEL,aAAKF,UAAL;AACD;;AAED,WAAK7C,UAAL;AACD,KAnB2B,CAvTrB;AA4UPuC,sBA5UO,8BA4UYhW,GA5UZ,EA4UiB;AAEtB,UAAI,KAAKkW,KAAL,CAAWa,OAAX,IAAsB,CAAC,KAAKb,KAAL,CAAWa,OAAX,CAAmBD,QAAnB,CAA4B9W,GAAG,CAAC2F,MAAhC,CAA3B,EAAoE;AAClE,aAAK6Q,SAAL;AACA,aAAKnE,SAAL;AACD;AACF,KAlVM;AAoVPa,qBApVO,+BAoVa;AAAA;;AAClB,UAAQlE,WAAR,GAAwB,KAAKF,OAA7B,CAAQE,WAAR;;AACA,UAAMgI,IAAI,GAAG,SAAPA,IAAO;AAAA,eAAM,OAAI,CAACC,mCAAL,CAAyC,IAAzC,CAAN;AAAA,OAAb;;AAEA,UAAI,CAACjI,WAAL,EAAkB;AAEhB,aAAKc,WAAL,CAAiBC,MAAjB,GAA0B,KAA1B;AACA,eAAOiH,IAAI,EAAX;AACD;;AAGD,WAAKlH,WAAL,CAAiBC,MAAjB,GAA0B,IAA1B;AAGA,WAAKD,WAAL,CAAiBE,SAAjB,GAA6B,IAA7B;AACA,WAAK4F,mBAAL,CAAyB,UAAAhF,IAAI,EAAI;AAC/B,YAAIA,IAAI,CAACc,QAAT,EAAmB;AAAA;;AACjBd,cAAI,CAACsG,kBAAL,GAA0B,KAA1B;AACAtG,cAAI,CAACuG,uBAAL,GAA+B,KAA/B;AACAvG,cAAI,CAACwG,SAAL,GAAiB,KAAjB;AACAxG,cAAI,CAACyG,qBAAL,GAA6B,KAA7B;;AACA,iBAAI,CAACrC,IAAL,CAAU,OAAI,CAAClF,WAAL,CAAiBG,QAA3B,EAAqCW,IAAI,CAACD,EAA1C,6DACG9J,YADH,EACkB,CADlB,0CAEGC,eAFH,EAEqB,CAFrB,0CAGGC,aAHH,EAGmB,CAHnB,0CAIGC,gBAJH,EAIsB,CAJtB;AAMD;AACF,OAbD;AAeA,UAAMsQ,qBAAqB,GAAGlO,aAAa,CAAC4F,WAAD,CAAb,CAA2BuI,IAA3B,GAAkCC,iBAAlC,EAA9B;AACA,UAAMC,gBAAgB,GAAGH,qBAAqB,CAAC/N,OAAtB,CAA8B,MAA9B,EAAsC,GAAtC,EAA2CmO,KAA3C,CAAiD,GAAjD,CAAzB;AACA,WAAK9B,mBAAL,CAAyB,UAAAhF,IAAI,EAAI;AAC/B,YAAI,OAAI,CAACzC,YAAL,IAAqBsJ,gBAAgB,CAAC1U,MAAjB,GAA0B,CAAnD,EAAsD;AACpD6N,cAAI,CAACwG,SAAL,GAAiBK,gBAAgB,CAACE,KAAjB,CAAuB,UAAAC,WAAW;AAAA,mBACjDpO,KAAK,CAAC,KAAD,EAAQoO,WAAR,EAAqBhH,IAAI,CAACiH,iBAA1B,CAD4C;AAAA,WAAlC,CAAjB;AAGD,SAJD,MAIO;AACLjH,cAAI,CAACwG,SAAL,GAAiB,OAAI,CAACtK,SAAL,CAAeiF,IAAf,CAAoB,UAAA+F,QAAQ;AAAA,mBAC3CtO,KAAK,CAAC,CAAC,OAAI,CAAC4C,oBAAP,EAA6BkL,qBAA7B,EAAoD1G,IAAI,CAACmH,UAAL,CAAgBD,QAAhB,CAApD,CADsC;AAAA,WAA5B,CAAjB;AAGD;;AAED,YAAIlH,IAAI,CAACwG,SAAT,EAAoB;AAClB,iBAAI,CAACtH,WAAL,CAAiBE,SAAjB,GAA6B,KAA7B;AACAY,cAAI,CAACO,SAAL,CAAelP,OAAf,CAAuB,UAAAmP,QAAQ;AAAA,mBAAI,OAAI,CAACtB,WAAL,CAAiBG,QAAjB,CAA0BmB,QAAQ,CAACT,EAAnC,EAAuC7J,eAAvC,GAAJ;AAAA,WAA/B;AACA,cAAI8J,IAAI,CAACG,MAAT,EAAiBH,IAAI,CAACO,SAAL,CAAelP,OAAf,CAAuB,UAAAmP,QAAQ;AAAA,mBAAI,OAAI,CAACtB,WAAL,CAAiBG,QAAjB,CAA0BmB,QAAQ,CAACT,EAAnC,EAAuC3J,gBAAvC,GAAJ;AAAA,WAA/B;;AACjB,cAAI4J,IAAI,CAAC/M,UAAL,KAAoB4C,cAAxB,EAAwC;AACtC,mBAAI,CAACqJ,WAAL,CAAiBG,QAAjB,CAA0BW,IAAI,CAAC/M,UAAL,CAAgB8M,EAA1C,EAA8C9J,YAA9C,KAA+D,CAA/D;AAEA,gBAAI+J,IAAI,CAACG,MAAT,EAAiB,OAAI,CAACjB,WAAL,CAAiBG,QAAjB,CAA0BW,IAAI,CAAC/M,UAAL,CAAgB8M,EAA1C,EAA8C5J,aAA9C,KAAgE,CAAhE;AAClB;AACF;;AAED,YACE,CAAC6J,IAAI,CAACwG,SAAL,IAAmBxG,IAAI,CAACc,QAAL,IAAiBd,IAAI,CAACsG,kBAA1C,KACAtG,IAAI,CAAC/M,UAAL,KAAoB4C,cAFtB,EAGE;AACAmK,cAAI,CAAC/M,UAAL,CAAgBqT,kBAAhB,GAAqC,IAArC;AACAtG,cAAI,CAAC/M,UAAL,CAAgBwT,qBAAhB,GAAwC,IAAxC;AACD;AACF,OA7BD;AA+BAL,UAAI;AACL,KApZM;AAsZP/D,sBAtZO,gCAsZc;AAAA;;AACnB,UAAQjE,WAAR,GAAwB,KAAKF,OAA7B,CAAQE,WAAR;AACA,UAAMgJ,KAAK,GAAG,KAAKrE,oBAAL,EAAd;;AACA,UAAMqD,IAAI,GAAG,SAAPA,IAAO,GAAM;AACjB,eAAI,CAAC1E,UAAL;;AACA,eAAI,CAAC2E,mCAAL,CAAyC,IAAzC;AACD,OAHD;;AAKA,UAAI,CAACjI,WAAW,KAAK,EAAhB,IAAsB,KAAK1D,YAA5B,KAA6C0M,KAAK,CAAChP,QAAvD,EAAiE;AAC/D,eAAOgO,IAAI,EAAX;AACD;;AAED,WAAKiB,mBAAL,CAAyB;AACvBC,cAAM,EAAE/Q,YADe;AAEvBhH,YAAI,EAAE;AAAE6O,qBAAW,EAAXA;AAAF,SAFiB;AAGvBmJ,iBAHuB,uBAGX;AACV,iBAAOH,KAAK,CAAC/O,SAAb;AACD,SALsB;AAMvBmP,aAAK,EAAE,iBAAM;AACXJ,eAAK,CAAC/O,SAAN,GAAkB,IAAlB;AACA+O,eAAK,CAAChP,QAAN,GAAiB,KAAjB;AACAgP,eAAK,CAAC9O,YAAN,GAAqB,EAArB;AACD,SAVsB;AAWvBmP,eAAO,EAAE,iBAAAxK,OAAO,EAAI;AAClBmK,eAAK,CAAChP,QAAN,GAAiB,IAAjB;AACAgP,eAAK,CAACnK,OAAN,GAAgBA,OAAhB;AAGA,cAAI,OAAI,CAACiB,OAAL,CAAaE,WAAb,KAA6BA,WAAjC,EAA8CgI,IAAI;AACnD,SAjBsB;AAkBvBsB,YAAI,EAAE,cAAAxO,GAAG,EAAI;AACXkO,eAAK,CAAC9O,YAAN,GAAqBW,eAAe,CAACC,GAAD,CAApC;AACD,SApBsB;AAqBvByO,WAAG,EAAE,eAAM;AACTP,eAAK,CAAC/O,SAAN,GAAkB,KAAlB;AACD;AAvBsB,OAAzB;AAyBD,KA3bM;AA6bP0K,wBA7bO,kCA6bgB;AAAA;;AACrB,UAAQ3E,WAAR,GAAwB,KAAKF,OAA7B,CAAQE,WAAR;;AACA,UAAMgJ,KAAK,GAAG,KAAK9H,YAAL,CAAkBlB,WAAlB,qCACTjG,wBAAwB,EADf;AAEZ8E,eAAO,EAAE;AAFG,QAAd;;AAMA,WAAK2K,MAAL,CACE;AAAA,eAAMR,KAAK,CAACnK,OAAZ;AAAA,OADF,EAEE,YAAM;AAEJ,YAAI,OAAI,CAACiB,OAAL,CAAaE,WAAb,KAA6BA,WAAjC,EAA8C,OAAI,CAACsD,UAAL;AAC/C,OALH,EAME;AAAES,YAAI,EAAE;AAAR,OANF;;AASA,UAAI/D,WAAW,KAAK,EAApB,EAAwB;AACtB,YAAIjC,KAAK,CAAC+F,OAAN,CAAc,KAAKhH,cAAnB,CAAJ,EAAwC;AACtCkM,eAAK,CAACnK,OAAN,GAAgB,KAAK/B,cAArB;AACAkM,eAAK,CAAChP,QAAN,GAAiB,IAAjB;AACA,iBAAOgP,KAAP;AACD,SAJD,MAIO,IAAI,KAAKlM,cAAL,KAAwB,IAA5B,EAAkC;AACvCkM,eAAK,CAAChP,QAAN,GAAiB,IAAjB;AACA,iBAAOgP,KAAP;AACD;AACF;;AAED,UAAI,CAAC,KAAK9H,YAAL,CAAkBlB,WAAlB,CAAL,EAAqC;AACnC,aAAKgG,IAAL,CAAU,KAAK9E,YAAf,EAA6BlB,WAA7B,EAA0CgJ,KAA1C;AACD;;AAED,aAAOA,KAAP;AACD,KA9dM;AAgePrG,gBAheO,wBAgeMf,IAheN,EAgeY;AACjB,aAAO,KAAKd,WAAL,CAAiBC,MAAjB,GAA0Ba,IAAI,CAACsG,kBAA/B,GAAoDtG,IAAI,CAAC6H,UAAhE;AACD,KAleM;AAoePhH,wCApeO,gDAoe8Bb,IApe9B,EAoeoC;AAEzC,UAAIA,IAAI,CAACwG,SAAT,EAAoB,OAAO,IAAP;AAEpB,UAAIxG,IAAI,CAACc,QAAL,IAAiBd,IAAI,CAACyG,qBAAtB,IAA+C,CAAC,KAAKpL,oBAAzD,EAA+E,OAAO,IAAP;AAG/E,UAAI,CAAC2E,IAAI,CAACC,UAAN,IAAoBD,IAAI,CAAC/M,UAAL,CAAgBsT,uBAAxC,EAAiE,OAAO,IAAP;AAEjE,aAAO,KAAP;AACD,KA9eM;AAgfPuB,0BAhfO,kCAgfgB9H,IAhfhB,EAgfsB;AAC3B,UAAI,KAAKd,WAAL,CAAiBC,MAAjB,IAA2B,CAAC,KAAK0B,oCAAL,CAA0Cb,IAA1C,CAAhC,EAAiF;AAC/E,eAAO,KAAP;AACD;;AACD,aAAO,IAAP;AACD,KArfM;AAufP+H,cAvfO,wBAufM;AACX,aAAO,KAAKzC,KAAL,CAAWC,OAAX,CAAmB7T,GAA1B;AACD,KAzfM;AA2fPsW,WA3fO,qBA2fG;AACR,UAAMC,GAAG,GAAG,KAAKpO,YAAL,GAAoB,KAAKyL,KAAL,CAAW4C,MAAX,CAAkBC,YAAtC,GAAqD,IAAjE;AACA,UAAMC,KAAK,GAAGH,GAAG,CAAC3C,KAAJ,CAAUjH,IAAV,CAAeiH,KAAf,CAAqBjH,IAAnC;AACA,aAAO+J,KAAK,IAAIA,KAAK,CAAClV,QAAN,KAAmB,UAA5B,GAAyCkV,KAAzC,GAAiD,IAAxD;AACD,KA/fM;AAigBPC,+BAjgBO,uCAigBqBrI,IAjgBrB,EAigB0C;AAAA;;AAAA,UAAfsI,MAAe,uEAAN,IAAM;AAC/C,UAAMC,IAAI,GAAG,KAAKlK,IAAL,CAAUE,OAAvB;;AACA,UAAIgK,IAAI,IAAI,IAAR,IAAgBA,IAAI,IAAI,KAAK7J,MAAL,CAAYE,OAAxC,EAAiD;AAC/C,aAAKF,MAAL,CAAYE,OAAZ,CAAoB2J,IAApB,EAA0BC,aAA1B,GAA0C,KAA1C;AACD;;AAED,WAAKnK,IAAL,CAAUE,OAAV,GAAoByB,IAAI,CAACD,EAAzB;AACAC,UAAI,CAACwI,aAAL,GAAqB,IAArB;;AAEA,UAAI,KAAKnK,IAAL,CAAUC,MAAV,IAAoBgK,MAAxB,EAAgC;AAC9B,YAAMG,cAAc,GAAG,SAAjBA,cAAiB,GAAM;AAC3B,cAAML,KAAK,GAAG,OAAI,CAACJ,OAAL,EAAd;;AACA,cAAMU,OAAO,GAAGN,KAAK,CAACO,aAAN,6CAAwD3I,IAAI,CAACD,EAA7D,SAAhB;AACA,cAAI2I,OAAJ,EAAajZ,cAAc,CAAC2Y,KAAD,EAAQM,OAAR,CAAd;AACd,SAJD;;AAOA,YAAI,KAAKV,OAAL,EAAJ,EAAoB;AAClBS,wBAAc;AACf,SAFD,MAEO;AAEL,eAAKG,SAAL,CAAeH,cAAf;AACD;AACF;AACF,KAzhBM;AA2hBPpC,uCA3hBO,iDA2hBiD;AAAA,UAApBwC,UAAoB,uEAAP,KAAO;AACtD,UAAQtK,OAAR,GAAoB,KAAKF,IAAzB,CAAQE,OAAR;;AAEA,UACEsK,UAAU,IAAItK,OAAO,IAAI,IAAzB,IACA,EAAEA,OAAO,IAAI,KAAKG,MAAL,CAAYE,OAAzB,CADA,IAEA,CAAC,KAAKkJ,sBAAL,CAA4B,KAAKpI,OAAL,CAAanB,OAAb,CAA5B,CAHH,EAIE;AACA,aAAKuK,oBAAL;AACD;AACF,KAriBM;AAuiBPA,wBAviBO,kCAuiBgB;AACrB,UAAI,CAAC,KAAK9H,iBAAV,EAA6B;AAE7B,UAAM+H,KAAK,GAAG,KAAKpI,gBAAL,CAAsB,CAAtB,CAAd;AACA,WAAK0H,2BAAL,CAAiC,KAAK3I,OAAL,CAAaqJ,KAAb,CAAjC;AACD,KA5iBM;AA8iBPC,uBA9iBO,iCA8iBe;AACpB,UAAI,CAAC,KAAKhI,iBAAV,EAA6B;AAE7B,UAAMuH,IAAI,GAAG,KAAK5H,gBAAL,CAAsB7P,OAAtB,CAA8B,KAAKuN,IAAL,CAAUE,OAAxC,IAAmD,CAAhE;AACA,UAAIgK,IAAI,KAAK,CAAC,CAAd,EAAiB,OAAO,KAAKU,mBAAL,EAAP;AACjB,WAAKZ,2BAAL,CAAiC,KAAK3I,OAAL,CAAa,KAAKiB,gBAAL,CAAsB4H,IAAtB,CAAb,CAAjC;AACD,KApjBM;AAsjBPW,uBAtjBO,iCAsjBe;AACpB,UAAI,CAAC,KAAKlI,iBAAV,EAA6B;AAE7B,UAAMmI,IAAI,GAAG,KAAKxI,gBAAL,CAAsB7P,OAAtB,CAA8B,KAAKuN,IAAL,CAAUE,OAAxC,IAAmD,CAAhE;AACA,UAAI4K,IAAI,KAAK,KAAKxI,gBAAL,CAAsBxO,MAAnC,EAA2C,OAAO,KAAK2W,oBAAL,EAAP;AAC3C,WAAKT,2BAAL,CAAiC,KAAK3I,OAAL,CAAa,KAAKiB,gBAAL,CAAsBwI,IAAtB,CAAb,CAAjC;AACD,KA5jBM;AA8jBPF,uBA9jBO,iCA8jBe;AACpB,UAAI,CAAC,KAAKjI,iBAAV,EAA6B;AAE7B,UAAMoI,IAAI,GAAGC,cAAO,CAAC,KAAK1I,gBAAN,CAApB;AACA,WAAK0H,2BAAL,CAAiC,KAAK3I,OAAL,CAAa0J,IAAb,CAAjC;AACD,KAnkBM;AAqkBPE,oBArkBO,8BAqkBY;AACjB,WAAKpL,OAAL,CAAaE,WAAb,GAA2B,EAA3B;AACD,KAvkBM;AAykBPqD,aAzkBO,uBAykBK;AACV,UAAI,CAAC,KAAKpD,IAAL,CAAUC,MAAX,IAAsB,CAAC,KAAK/C,QAAN,IAAkB,KAAK3B,UAAjD,EAA8D;AAC9D,WAAK2P,sBAAL;AACA,WAAKlL,IAAL,CAAUC,MAAV,GAAmB,KAAnB;AACA,WAAK4G,uBAAL,CAA6B,KAA7B;AACA,WAAKoE,gBAAL;AACA,WAAKzH,KAAL,CAAW,OAAX,EAAoB,KAAKC,QAAL,EAApB,EAAqC,KAAKC,aAAL,EAArC;AACD,KAhlBM;AAklBPP,YAllBO,sBAklBI;AACT,UAAI,KAAKjG,QAAL,IAAiB,KAAK8C,IAAL,CAAUC,MAA/B,EAAuC;AACvC,WAAKD,IAAL,CAAUC,MAAV,GAAmB,IAAnB;AACA,WAAKsK,SAAL,CAAe,KAAKvC,mCAApB;AACA,WAAKuC,SAAL,CAAe,KAAKY,yBAApB;AACA,UAAI,CAAC,KAAKvM,OAAN,IAAiB,CAAC,KAAKnD,KAA3B,EAAkC,KAAK2P,eAAL;AAClC,WAAKvE,uBAAL,CAA6B,IAA7B;AACA,WAAKrD,KAAL,CAAW,MAAX,EAAmB,KAAKE,aAAL,EAAnB;AACD,KA1lBM;AA4lBP2H,cA5lBO,wBA4lBM;AACX,UAAI,KAAKrL,IAAL,CAAUC,MAAd,EAAsB;AACpB,aAAKmD,SAAL;AACD,OAFD,MAEO;AACL,aAAKD,QAAL;AACD;AACF,KAlmBM;AAomBPmI,kBApmBO,0BAomBQ3J,IApmBR,EAomBc;AACnB,UAAI4J,SAAJ;;AAEA,UAAI,KAAK1K,WAAL,CAAiBC,MAArB,EAA6B;AAC3ByK,iBAAS,GAAG5J,IAAI,CAACsG,kBAAL,GAA0B,CAACtG,IAAI,CAACsG,kBAA5C;AACA,YAAIsD,SAAJ,EAAe5J,IAAI,CAACuG,uBAAL,GAA+B,IAA/B;AAChB,OAHD,MAGO;AACLqD,iBAAS,GAAG5J,IAAI,CAAC6H,UAAL,GAAkB,CAAC7H,IAAI,CAAC6H,UAApC;AACD;;AAED,UAAI+B,SAAS,IAAI,CAAC5J,IAAI,CAAC6J,cAAL,CAAoBzR,QAAtC,EAAgD;AAC9C,aAAK0R,mBAAL,CAAyB9J,IAAzB;AACD;AACF,KAjnBM;AAmnBPgC,oBAnnBO,8BAmnBY;AAAA;;AACjB,UAAMhD,eAAe,GAAG5K,SAAS,EAAjC;AACA,WAAKsK,MAAL,CAAYI,eAAZ,CAA4BzN,OAA5B,CAAoC,UAAA0Y,cAAc,EAAI;AACpD/K,uBAAe,CAAC+K,cAAD,CAAf,GAAkC,IAAlC;AACD,OAFD;AAGA,WAAKrL,MAAL,CAAYM,eAAZ,GAA8BA,eAA9B;AAEA,UAAMH,eAAe,GAAGzK,SAAS,EAAjC;;AACA,UAAI,KAAKiI,QAAT,EAAmB;AACjB,aAAKuE,uBAAL,CAA6B,UAAAZ,IAAI,EAAI;AACnCnB,yBAAe,CAACmB,IAAI,CAACD,EAAN,CAAf,GAA2BjK,SAA3B;AACD,SAFD;AAIA,aAAK0J,aAAL,CAAmBnO,OAAnB,CAA2B,UAAAiP,YAAY,EAAI;AACzCzB,yBAAe,CAACyB,YAAY,CAACP,EAAd,CAAf,GAAmC/J,OAAnC;;AAEA,cAAI,CAAC,OAAI,CAACyF,IAAN,IAAc,CAAC,OAAI,CAACH,kBAAxB,EAA4C;AAC1CgF,wBAAY,CAACC,SAAb,CAAuBlP,OAAvB,CAA+B,UAAA2Y,YAAY,EAAI;AAC7C,kBAAI,CAAC,OAAI,CAAC9J,UAAL,CAAgB8J,YAAhB,CAAL,EAAoC;AAClCnL,+BAAe,CAACmL,YAAY,CAACjK,EAAd,CAAf,GAAmChK,aAAnC;AACD;AACF,aAJD;AAKD;AACF,SAVD;AAWD;;AACD,WAAK2I,MAAL,CAAYG,eAAZ,GAA8BA,eAA9B;AACD,KA7oBM;AA+oBPmF,sBA/oBO,8BA+oBYZ,GA/oBZ,EA+oBiB;AACtB,6CACKA,GADL,GAEK,KAAK1G,UAAL,CAAgB0G,GAAhB,EAAqB,KAAKrB,aAAL,EAArB,CAFL;AAID,KAppBM;AAspBPrJ,aAtpBO,qBAspBGzF,UAtpBH,EAspBegX,KAtpBf,EAspBsBjH,WAtpBtB,EAspBmC;AAAA;;AACxC,UAAIrE,iBAAiB,GAAGsL,KAAK,CAC1BxK,GADqB,CACjB,UAAAO,IAAI;AAAA,eAAI,CAAE,OAAI,CAACgE,kBAAL,CAAwBhE,IAAxB,CAAF,EAAiCA,IAAjC,CAAJ;AAAA,OADa,EAErBP,GAFqB,CAEjB,gBAAgBxH,KAAhB,EAA0B;AAAA;AAAA,YAAvB+H,IAAuB;AAAA,YAAjBoD,GAAiB;;AAC7B,eAAI,CAAC8G,gBAAL,CAAsBlK,IAAtB;;AACA,eAAI,CAACmK,eAAL,CAAqBnK,IAArB;;AAEA,YAAQD,EAAR,GAAmDC,IAAnD,CAAQD,EAAR;AAAA,YAAYgE,KAAZ,GAAmD/D,IAAnD,CAAY+D,KAAZ;AAAA,YAAmB3D,QAAnB,GAAmDJ,IAAnD,CAAmBI,QAAnB;AAAA,YAA6BgK,iBAA7B,GAAmDpK,IAAnD,CAA6BoK,iBAA7B;AACA,YAAMnK,UAAU,GAAGhN,UAAU,KAAK4C,cAAlC;AACA,YAAMmC,KAAK,GAAGiI,UAAU,GAAG,CAAH,GAAOhN,UAAU,CAAC+E,KAAX,GAAmB,CAAlD;AACA,YAAM8I,QAAQ,GAAG3E,KAAK,CAAC+F,OAAN,CAAc9B,QAAd,KAA2BA,QAAQ,KAAK,IAAzD;AACA,YAAMD,MAAM,GAAG,CAACW,QAAhB;AACA,YAAM6C,UAAU,GAAG,CAAC,CAAC3D,IAAI,CAAC2D,UAAP,IAAsB,CAAC,OAAI,CAAClI,IAAN,IAAc,CAACwE,UAAf,IAA6BhN,UAAU,CAAC0Q,UAAjF;AACA,YAAMQ,KAAK,GAAG,CAAC,CAACnE,IAAI,CAACmE,KAArB;;AACA,YAAMgD,UAAU,GAAG,OAAI,CAACjL,SAAL,CAAemO,MAAf,CAAsB,UAAC9B,IAAD,EAAO1T,GAAP;AAAA,iDACpC0T,IADoC,oCAEtC1T,GAFsC,EAEhC0D,wBAAwB,CAACyH,IAAI,CAACnL,GAAD,CAAL,CAAxB,CAAoC+R,iBAApC,EAFgC;AAAA,SAAtB,EAGf,EAHe,CAAnB;;AAIA,YAAMK,iBAAiB,GAAGhH,UAAU,GAChCkH,UAAU,CAACpD,KADqB,GAEhC9Q,UAAU,CAACgU,iBAAX,GAA+B,GAA/B,GAAqCE,UAAU,CAACpD,KAFpD;;AAIA,YAAMuG,UAAU,GAAG,OAAI,CAAClG,IAAL,CAAU,OAAI,CAAC1F,MAAL,CAAYE,OAAtB,EAA+BmB,EAA/B,EAAmC3L,SAAS,EAA5C,CAAnB;;AACA,eAAI,CAACgQ,IAAL,CAAUkG,UAAV,EAAsB,IAAtB,EAA4BvK,EAA5B;;AACA,eAAI,CAACqE,IAAL,CAAUkG,UAAV,EAAsB,OAAtB,EAA+BvG,KAA/B;;AACA,eAAI,CAACK,IAAL,CAAUkG,UAAV,EAAsB,OAAtB,EAA+BtS,KAA/B;;AACA,eAAI,CAACoM,IAAL,CAAUkG,UAAV,EAAsB,WAAtB,EAAmCrK,UAAU,GAAG,EAAH,GAAQ,CAAEhN,UAAF,EAAenE,MAAf,CAAsBmE,UAAU,CAACsN,SAAjC,CAArD;;AACA,eAAI,CAAC6D,IAAL,CAAUkG,UAAV,EAAsB,OAAtB,EAA+B,CAACrK,UAAU,GAAG,EAAH,GAAQhN,UAAU,CAACgF,KAA9B,EAAqCnJ,MAArC,CAA4CmJ,KAA5C,CAA/B;;AACA,eAAI,CAACmM,IAAL,CAAUkG,UAAV,EAAsB,YAAtB,EAAoCrX,UAApC;;AACA,eAAI,CAACmR,IAAL,CAAUkG,UAAV,EAAsB,YAAtB,EAAoCnD,UAApC;;AACA,eAAI,CAAC/C,IAAL,CAAUkG,UAAV,EAAsB,mBAAtB,EAA2CrD,iBAA3C;;AACA,eAAI,CAAC7C,IAAL,CAAUkG,UAAV,EAAsB,YAAtB,EAAoC3G,UAApC;;AACA,eAAI,CAACS,IAAL,CAAUkG,UAAV,EAAsB,OAAtB,EAA+BnG,KAA/B;;AACA,eAAI,CAACC,IAAL,CAAUkG,UAAV,EAAsB,WAAtB,EAAmC,KAAnC;;AACA,eAAI,CAAClG,IAAL,CAAUkG,UAAV,EAAsB,eAAtB,EAAuC,KAAvC;;AACA,eAAI,CAAClG,IAAL,CAAUkG,UAAV,EAAsB,UAAtB,EAAkCxJ,QAAlC;;AACA,eAAI,CAACsD,IAAL,CAAUkG,UAAV,EAAsB,QAAtB,EAAgCnK,MAAhC;;AACA,eAAI,CAACiE,IAAL,CAAUkG,UAAV,EAAsB,YAAtB,EAAoCrK,UAApC;;AACA,eAAI,CAACmE,IAAL,CAAUkG,UAAV,EAAsB,KAAtB,EAA6BlH,GAA7B;;AAEA,YAAItC,QAAJ,EAAc;AAAA;;AACZ,cAAM1I,QAAQ,GAAG+D,KAAK,CAAC+F,OAAN,CAAc9B,QAAd,CAAjB;;AAEA,iBAAI,CAACgE,IAAL,CAAUkG,UAAV,EAAsB,gBAAtB,kCACKnS,wBAAwB,EAD7B;AAEEC,oBAAQ,EAARA;AAFF;;AAIA,iBAAI,CAACgM,IAAL,CAAUkG,UAAV,EAAsB,YAAtB,EAAoC,OAAOF,iBAAP,KAA6B,SAA7B,GAChCA,iBADgC,GAEhCpS,KAAK,GAAG,OAAI,CAACgD,kBAFjB;;AAGA,iBAAI,CAACoJ,IAAL,CAAUkG,UAAV,EAAsB,uBAAtB,EAA+C,KAA/C;;AACA,iBAAI,CAAClG,IAAL,CAAUkG,UAAV,EAAsB,wBAAtB,EAAgD,KAAhD;;AACA,iBAAI,CAAClG,IAAL,CAAUkG,UAAV,EAAsB,oBAAtB,EAA4C,KAA5C;;AACA,iBAAI,CAAClG,IAAL,CAAUkG,UAAV,EAAsB,yBAAtB,EAAiD,KAAjD;;AACA,iBAAI,CAAClG,IAAL,CAAUkG,UAAV,EAAsB,OAAtB,6DACGrU,YADH,EACkB,CADlB,0CAEGC,eAFH,EAEqB,CAFrB,0CAGGC,aAHH,EAGmB,CAHnB,0CAIGC,gBAJH,EAIsB,CAJtB;;AAMA,iBAAI,CAACgO,IAAL,CAAUkG,UAAV,EAAsB,UAAtB,EAAkClS,QAAQ,GACtC,OAAI,CAACM,SAAL,CAAe4R,UAAf,EAA2BlK,QAA3B,EAAqC4C,WAArC,CADsC,GAEtC,EAFJ;;AAIA,cAAIoH,iBAAiB,KAAK,IAA1B,EAAgCE,UAAU,CAAC/J,SAAX,CAAqBlP,OAArB,CAA6B,UAAAmP,QAAQ,EAAI;AACvEA,oBAAQ,CAACqH,UAAT,GAAsB,IAAtB;AACD,WAF+B;;AAIhC,cAAI,CAACzP,QAAD,IAAa,OAAO,OAAI,CAAC6D,WAAZ,KAA4B,UAA7C,EAAyD;AACvD3N,2BAAO,CACL;AAAA,qBAAM,KAAN;AAAA,aADK,EAEL;AAAA,qBAAM,qFAAN;AAAA,aAFK,CAAP;AAID,WALD,MAKO,IAAI,CAAC8J,QAAD,IAAakS,UAAU,CAACzC,UAA5B,EAAwC;AAC7C,mBAAI,CAACiC,mBAAL,CAAyBQ,UAAzB;AACD;AACF;;AAEDA,kBAAU,CAAC/J,SAAX,CAAqBlP,OAArB,CAA6B,UAAAmP,QAAQ;AAAA,iBAAIA,QAAQ,CAACzE,KAAT,CAAe7F,eAAf,GAAJ;AAAA,SAArC;AACA,YAAIiK,MAAJ,EAAYmK,UAAU,CAAC/J,SAAX,CAAqBlP,OAArB,CAA6B,UAAAmP,QAAQ;AAAA,iBAAIA,QAAQ,CAACzE,KAAT,CAAe3F,gBAAf,GAAJ;AAAA,SAArC;;AACZ,YAAI,CAAC6J,UAAL,EAAiB;AACfhN,oBAAU,CAAC8I,KAAX,CAAiB9F,YAAjB,KAAkC,CAAlC;AACA,cAAIkK,MAAJ,EAAYlN,UAAU,CAAC8I,KAAX,CAAiB5F,aAAjB,KAAmC,CAAnC;AACZ,cAAIwN,UAAJ,EAAgB1Q,UAAU,CAACsX,sBAAX,GAAoC,IAApC;AACjB;;AAGD,YAAIvH,WAAW,IAAIA,WAAW,CAACjD,EAAD,CAA9B,EAAoC;AAClC,cAAMwI,IAAI,GAAGvF,WAAW,CAACjD,EAAD,CAAxB;AAEAuK,oBAAU,CAAC9D,SAAX,GAAuB+B,IAAI,CAAC/B,SAA5B;AACA8D,oBAAU,CAAC/D,uBAAX,GAAqCgC,IAAI,CAAChC,uBAA1C;AACA+D,oBAAU,CAAC9B,aAAX,GAA2BD,IAAI,CAACC,aAAhC;;AAEA,cAAID,IAAI,CAACzH,QAAL,IAAiBwJ,UAAU,CAACxJ,QAAhC,EAA0C;AACxCwJ,sBAAU,CAACzC,UAAX,GAAwBU,IAAI,CAACV,UAA7B;AACAyC,sBAAU,CAAChE,kBAAX,GAAgCiC,IAAI,CAACjC,kBAArC;;AAIA,gBAAIiC,IAAI,CAACsB,cAAL,CAAoBzR,QAApB,IAAgC,CAACkS,UAAU,CAACT,cAAX,CAA0BzR,QAA/D,EAAyE;AAGvEkS,wBAAU,CAACzC,UAAX,GAAwB,KAAxB;AAED,aALD,MAKO;AACLyC,wBAAU,CAACT,cAAX,qBAAiCtB,IAAI,CAACsB,cAAtC;AACD;AACF;AACF;;AAED,eAAOS,UAAP;AACD,OA/GqB,CAAxB;;AAiHA,UAAI,KAAK7P,gBAAT,EAA2B;AACzB,YAAM+P,WAAW,GAAG7L,iBAAiB,CAACmB,MAAlB,CAAyB,UAAA2K,MAAM;AAAA,iBAAIA,MAAM,CAAC3J,QAAX;AAAA,SAA/B,CAApB;AACA,YAAM4J,SAAS,GAAG/L,iBAAiB,CAACmB,MAAlB,CAAyB,UAAA2K,MAAM;AAAA,iBAAIA,MAAM,CAACtK,MAAX;AAAA,SAA/B,CAAlB;AACAxB,yBAAiB,GAAG6L,WAAW,CAAC1b,MAAZ,CAAmB4b,SAAnB,CAApB;AACD;;AAED,aAAO/L,iBAAP;AACD,KA/wBM;AAixBP8K,mBAjxBO,6BAixBW;AAAA;;AAChB,WAAKpC,mBAAL,CAAyB;AACvBC,cAAM,EAAEjR,iBADe;AAEvBkR,iBAAS,EAAE,qBAAM;AACf,iBAAO,OAAI,CAACtI,iBAAL,CAAuB5G,SAA9B;AACD,SAJsB;AAKvBmP,aAAK,EAAE,iBAAM;AACX,iBAAI,CAACvI,iBAAL,CAAuB5G,SAAvB,GAAmC,IAAnC;AACA,iBAAI,CAAC4G,iBAAL,CAAuB3G,YAAvB,GAAsC,EAAtC;AACD,SARsB;AASvBmP,eAAO,EAAE,mBAAM;AACb,iBAAI,CAACxI,iBAAL,CAAuB7G,QAAvB,GAAkC,IAAlC;;AAEA,iBAAI,CAACwQ,SAAL,CAAe,YAAM;AACnB,mBAAI,CAACvC,mCAAL,CAAyC,IAAzC;AACD,WAFD;AAGD,SAfsB;AAgBvBqB,YAAI,EAAE,cAAAxO,GAAG,EAAI;AACX,iBAAI,CAAC+F,iBAAL,CAAuB3G,YAAvB,GAAsCW,eAAe,CAACC,GAAD,CAArD;AACD,SAlBsB;AAmBvByO,WAAG,EAAE,eAAM;AACT,iBAAI,CAAC1I,iBAAL,CAAuB5G,SAAvB,GAAmC,KAAnC;AACD;AArBsB,OAAzB;AAuBD,KAzyBM;AA2yBPyR,uBA3yBO,+BA2yBa7W,UA3yBb,EA2yByB;AAAA;;AAI9B,UAAQ8M,EAAR,GAAoB9M,UAApB,CAAQ8M,EAAR;AAAA,UAAYqD,GAAZ,GAAoBnQ,UAApB,CAAYmQ,GAAZ;AAEA,WAAKiE,mBAAL,CAAyB;AACvBC,cAAM,EAAEhR,qBADe;AAEvB/G,YAAI,EAAE;AAKJ0D,oBAAU,EAAEmQ;AALR,SAFiB;AASvBmE,iBAAS,EAAE,qBAAM;AACf,iBAAO,OAAI,CAAC7H,OAAL,CAAaK,EAAb,EAAiB8J,cAAjB,CAAgCxR,SAAvC;AACD,SAXsB;AAYvBmP,aAAK,EAAE,iBAAM;AACX,iBAAI,CAAC9H,OAAL,CAAaK,EAAb,EAAiB8J,cAAjB,CAAgCxR,SAAhC,GAA4C,IAA5C;AACA,iBAAI,CAACqH,OAAL,CAAaK,EAAb,EAAiB8J,cAAjB,CAAgCvR,YAAhC,GAA+C,EAA/C;AACD,SAfsB;AAgBvBmP,eAAO,EAAE,mBAAM;AACb,iBAAI,CAAC/H,OAAL,CAAaK,EAAb,EAAiB8J,cAAjB,CAAgCzR,QAAhC,GAA2C,IAA3C;AACD,SAlBsB;AAmBvBsP,YAAI,EAAE,cAAAxO,GAAG,EAAI;AACX,iBAAI,CAACwG,OAAL,CAAaK,EAAb,EAAiB8J,cAAjB,CAAgCvR,YAAhC,GAA+CW,eAAe,CAACC,GAAD,CAA9D;AACD,SArBsB;AAsBvByO,WAAG,EAAE,eAAM;AACT,iBAAI,CAACjI,OAAL,CAAaK,EAAb,EAAiB8J,cAAjB,CAAgCxR,SAAhC,GAA4C,KAA5C;AACD;AAxBsB,OAAzB;AA0BD,KA30BM;AA60BPgP,uBA70BO,sCA60BqE;AAAA,UAAtDC,MAAsD,SAAtDA,MAAsD;AAAA,UAA9C/X,IAA8C,SAA9CA,IAA8C;AAAA,UAAxCgY,SAAwC,SAAxCA,SAAwC;AAAA,UAA7BC,KAA6B,SAA7BA,KAA6B;AAAA,UAAtBC,OAAsB,SAAtBA,OAAsB;AAAA,UAAbC,IAAa,SAAbA,IAAa;AAAA,UAAPC,GAAO,SAAPA,GAAO;;AAC1E,UAAI,CAAC,KAAK1L,WAAN,IAAqBsL,SAAS,EAAlC,EAAsC;AACpC;AACD;;AAEDC,WAAK;AAEL,UAAM5C,QAAQ,GAAG+F,cAAI,CAAC,UAACzR,GAAD,EAAM0R,MAAN,EAAiB;AACrC,YAAI1R,GAAJ,EAAS;AACPwO,cAAI,CAACxO,GAAD,CAAJ;AACD,SAFD,MAEO;AACLuO,iBAAO,CAACmD,MAAD,CAAP;AACD;;AAEDjD,WAAG;AACJ,OARoB,CAArB;AASA,UAAMiD,MAAM,GAAG,KAAK3O,WAAL;AACb8D,UAAE,EAAE,KAAKgC,aAAL,EADS;AAEb3I,kBAAU,EAAE,KAAK2I,aAAL,EAFC;AAGbuF,cAAM,EAANA;AAHa,SAIV/X,IAJU;AAKbqV,gBAAQ,EAARA;AALa,SAAf;;AAQA,UAAIiG,6BAAS,CAACD,MAAD,CAAb,EAAuB;AACrBA,cAAM,CAACE,IAAP,CAAY,YAAM;AAChBlG,kBAAQ;AACT,SAFD,EAEG,UAAA1L,GAAG,EAAI;AACR0L,kBAAQ,CAAC1L,GAAD,CAAR;AACD,SAJD,EAIG6R,KAJH,CAIS,UAAA7R,GAAG,EAAI;AAEdnK,iBAAO,CAACC,KAAR,CAAckK,GAAd;AACD,SAPD;AAQD;AACF,KA/2BM;AAi3BPgR,oBAj3BO,4BAi3BUlK,IAj3BV,EAi3BgB;AAAA;;AACrB1R,qBAAO,CACL;AAAA,eAAM,EAAG0R,IAAI,CAACD,EAAL,IAAW,OAAI,CAACrB,MAAL,CAAYE,OAAxB,IAAoC,CAAC,OAAI,CAACF,MAAL,CAAYE,OAAZ,CAAoBoB,IAAI,CAACD,EAAzB,EAA6BmE,cAApE,CAAN;AAAA,OADK,EAEL;AAAA,eAAM,iDAA0C8G,IAAI,CAACC,SAAL,CAAejL,IAAI,CAACD,EAApB,CAA1C,uCACiB,OAAI,CAACrB,MAAL,CAAYE,OAAZ,CAAoBoB,IAAI,CAACD,EAAzB,EAA6BgE,KAD9C,sBAC6D/D,IAAI,CAAC+D,KADlE,qBAAN;AAAA,OAFK,CAAP;AAKD,KAv3BM;AAy3BPoG,mBAz3BO,2BAy3BSnK,IAz3BT,EAy3Be;AACpB1R,qBAAO,CACL;AAAA,eAAM,EAAE0R,IAAI,CAACI,QAAL,KAAkB3K,SAAlB,IAA+BuK,IAAI,CAACc,QAAL,KAAkB,IAAnD,CAAN;AAAA,OADK,EAEL;AAAA,eAAM,uDACJ,+EADF;AAAA,OAFK,CAAP;AAKD,KA/3BM;AAi4BPoK,UAj4BO,kBAi4BAlL,IAj4BA,EAi4BM;AACX,UAAI,KAAKzE,QAAL,IAAiByE,IAAI,CAAC2D,UAA1B,EAAsC;AACpC;AACD;;AAED,UAAI,KAAK/D,MAAT,EAAiB;AACf,aAAKuL,KAAL;AACD;;AAED,UAAMvB,SAAS,GAAG,KAAKvN,QAAL,IAAiB,CAAC,KAAKZ,IAAvB,GACd,KAAKiD,MAAL,CAAYG,eAAZ,CAA4BmB,IAAI,CAACD,EAAjC,MAAyCjK,SAD3B,GAEd,CAAC,KAAKoK,UAAL,CAAgBF,IAAhB,CAFL;;AAIA,UAAI4J,SAAJ,EAAe;AACb,aAAKwB,WAAL,CAAiBpL,IAAjB;AACD,OAFD,MAEO;AACL,aAAKqL,aAAL,CAAmBrL,IAAnB;AACD;;AAED,WAAKgC,gBAAL;;AAEA,UAAI4H,SAAJ,EAAe;AACb,aAAK/H,KAAL,CAAW,QAAX,EAAqB7B,IAAI,CAACoD,GAA1B,EAA+B,KAAKrB,aAAL,EAA/B;AACD,OAFD,MAEO;AACL,aAAKF,KAAL,CAAW,UAAX,EAAuB7B,IAAI,CAACoD,GAA5B,EAAiC,KAAKrB,aAAL,EAAjC;AACD;;AAED,UAAI,KAAK7C,WAAL,CAAiBC,MAAjB,IAA2ByK,SAA3B,KAAyC,KAAKhK,MAAL,IAAe,KAAK/E,aAA7D,CAAJ,EAAiF;AAC/E,aAAKyO,gBAAL;AACD;;AAED,UAAI,KAAK1J,MAAL,IAAe,KAAK7E,aAAxB,EAAuC;AACrC,aAAK0G,SAAL;;AAGA,YAAI,KAAKnE,UAAT,EAAqB;AACnB,eAAKwF,aAAL,GAAqB,IAArB;AACD;AACF;AACF,KAx6BM;AA06BPqI,SA16BO,mBA06BC;AAAA;;AACN,UAAI,KAAKzK,QAAT,EAAmB;AACjB,YAAI,KAAKd,MAAL,IAAe,KAAKpG,qBAAxB,EAA+C;AAC7C,eAAKkF,MAAL,CAAYI,eAAZ,GAA8B,EAA9B;AACD,SAFD,MAE+D;AAC7D,iBAAKJ,MAAL,CAAYI,eAAZ,GAA8B,KAAKJ,MAAL,CAAYI,eAAZ,CAA4BgB,MAA5B,CAAmC,UAAA8D,MAAM;AAAA,qBACrE,OAAI,CAAClE,OAAL,CAAakE,MAAb,EAAqBD,UADgD;AAAA,aAAzC,CAA9B;AAGD;;AAED,aAAK3B,gBAAL;AACD;AACF,KAt7BM;AAy7BPoJ,eAz7BO,uBAy7BKpL,IAz7BL,EAy7BW;AAAA;;AAChBA,UAAI,CAACuD,eAAL,GAAuBvD,IAAI,CAACD,EAA5B;;AACA,UAAI,KAAKH,MAAL,IAAe,KAAKtE,kBAAxB,EAA4C;AAC1C,eAAO,KAAKgQ,QAAL,CAActL,IAAd,CAAP;AACD;;AAED,UAAI,KAAKvE,IAAT,EAAe;AACb,aAAK6P,QAAL,CAActL,IAAd;;AAEA,YAAI,KAAK7F,mBAAT,EAA8B;AAC5B6F,cAAI,CAACO,SAAL,CAAelP,OAAf,CAAuB,UAAAmP,QAAQ,EAAI;AACjC,gBAAI,CAAC,OAAI,CAACN,UAAL,CAAgBM,QAAhB,CAAD,IAA8B,CAACA,QAAQ,CAACmD,UAA5C,EAAwD,OAAI,CAAC2H,QAAL,CAAc9K,QAAd;AACzD,WAFD;AAGD,SAJD,MAIO,IAAI,KAAKpG,qBAAT,EAAgC;AACrC,eAAKqJ,sBAAL,CAA4BzD,IAA5B,EAAkC,UAAA0D,UAAU,EAAI;AAC9C,gBAAI,CAAC,OAAI,CAACxD,UAAL,CAAgBwD,UAAhB,CAAD,IAAgC,CAACA,UAAU,CAACC,UAAhD,EAA4D,OAAI,CAAC2H,QAAL,CAAc5H,UAAd;AAC7D,WAFD;AAGD;;AAED;AACD;;AAED,UAAM6H,cAAc,GAClBvL,IAAI,CAACG,MAAL,IACuB,CAACH,IAAI,CAACuK,sBAD7B,IAEuB,KAAK5Q,iCAH9B;;AAKA,UAAI4R,cAAJ,EAAoB;AAClB,aAAKD,QAAL,CAActL,IAAd;AACD;;AAED,UAAIA,IAAI,CAACc,QAAT,EAAmB;AACjB,aAAK2C,sBAAL,CAA4BzD,IAA5B,EAAkC,UAAA0D,UAAU,EAAI;AAC9C,cAAI,CAACA,UAAU,CAACC,UAAZ,IAA0B,OAAI,CAAChK,iCAAnC,EAAsE;AACpE,mBAAI,CAAC2R,QAAL,CAAc5H,UAAd;AACD;AACF,SAJD;AAKD;;AAED,UAAI6H,cAAJ,EAAoB;AAClB,YAAIC,IAAI,GAAGxL,IAAX;;AACA,eAAO,CAACwL,IAAI,GAAGA,IAAI,CAACvY,UAAb,MAA6B4C,cAApC,EAAoD;AAClD,cAAI2V,IAAI,CAACpL,QAAL,CAAc2G,KAAd,CAAoB,KAAK7G,UAAzB,CAAJ,EAA0C,KAAKoL,QAAL,CAAcE,IAAd,EAA1C,KACK;AACN;AACF;AACF,KAv+BM;AA0+BPH,iBA1+BO,yBA0+BOrL,IA1+BP,EA0+Ba;AAAA;;AAClB,UAAI,KAAK1E,kBAAT,EAA6B;AAC3B,eAAO,KAAKmQ,WAAL,CAAiBzL,IAAjB,CAAP;AACD;;AAED,UAAI,KAAKvE,IAAT,EAAe;AACb,aAAKgQ,WAAL,CAAiBzL,IAAjB;;AAEA,YAAI,KAAK/F,qBAAT,EAAgC;AAC9B+F,cAAI,CAACO,SAAL,CAAelP,OAAf,CAAuB,UAAAmP,QAAQ,EAAI;AACjC,gBAAI,OAAI,CAACN,UAAL,CAAgBM,QAAhB,KAA6B,CAACA,QAAQ,CAACmD,UAA3C,EAAuD,OAAI,CAAC8H,WAAL,CAAiBjL,QAAjB;AACxD,WAFD;AAGD,SAJD,MAIO,IAAI,KAAKtG,uBAAT,EAAkC;AACvC,eAAKuJ,sBAAL,CAA4BzD,IAA5B,EAAkC,UAAA0D,UAAU,EAAI;AAC9C,gBAAI,OAAI,CAACxD,UAAL,CAAgBwD,UAAhB,KAA+B,CAACA,UAAU,CAACC,UAA/C,EAA2D,OAAI,CAAC8H,WAAL,CAAiB/H,UAAjB;AAC5D,WAFD;AAGD;;AAED;AACD;;AAED,UAAIgI,2BAA2B,GAAG,KAAlC;;AACA,UAAI1L,IAAI,CAACc,QAAT,EAAmB;AACjB,aAAKgE,sBAAL,CAA4B9E,IAA5B,EAAkC,UAAA0D,UAAU,EAAI;AAC9C,cAAI,CAACA,UAAU,CAACC,UAAZ,IAA0B,OAAI,CAAChK,iCAAnC,EAAsE;AACpE,mBAAI,CAAC8R,WAAL,CAAiB/H,UAAjB;;AACAgI,uCAA2B,GAAG,IAA9B;AACD;AACF,SALD;AAMD;;AAED,UACE1L,IAAI,CAACG,MAAL,IACsBuL,2BADtB,IAEsB1L,IAAI,CAACI,QAAL,CAAcjO,MAAd,KAAyB,CAHjD,EAIE;AACA,aAAKsZ,WAAL,CAAiBzL,IAAjB;AAEA,YAAIwL,IAAI,GAAGxL,IAAX;;AACA,eAAO,CAACwL,IAAI,GAAGA,IAAI,CAACvY,UAAb,MAA6B4C,cAApC,EAAoD;AAClD,cAAI,KAAKqK,UAAL,CAAgBsL,IAAhB,CAAJ,EAA2B,KAAKC,WAAL,CAAiBD,IAAjB,EAA3B,KACK;AACN;AACF;AACF,KAthCM;AAwhCPF,YAxhCO,oBAwhCEtL,IAxhCF,EAwhCQ;AACb,WAAKtB,MAAL,CAAYI,eAAZ,CAA4B1M,IAA5B,CAAiC4N,IAAI,CAACD,EAAtC;AACA,WAAKrB,MAAL,CAAYM,eAAZ,CAA4BgB,IAAI,CAACD,EAAjC,IAAuC,IAAvC;AACD,KA3hCM;AA6hCP0L,eA7hCO,uBA6hCKzL,IA7hCL,EA6hCW;AAChB,aAAOA,IAAI,CAACuD,eAAZ;AACA7S,qBAAe,CAAC,KAAKgO,MAAL,CAAYI,eAAb,EAA8BkB,IAAI,CAACD,EAAnC,CAAf;AACA,aAAO,KAAKrB,MAAL,CAAYM,eAAZ,CAA4BgB,IAAI,CAACD,EAAjC,CAAP;AACD,KAjiCM;AAmiCP4L,mBAniCO,6BAmiCW;AAChB,UAAI,CAAC,KAAKjL,QAAV,EAAoB;AACpB,UAAI,KAAKd,MAAT,EAAiB,OAAO,KAAKuL,KAAL,EAAP;AACjB,UAAMS,SAAS,GAAGvC,cAAO,CAAC,KAAK1J,aAAN,CAAzB;AACA,UAAMkM,gBAAgB,GAAG,KAAKnM,OAAL,CAAakM,SAAb,CAAzB;AACA,WAAKV,MAAL,CAAYW,gBAAZ;AACD,KAziCM;AA2iCPtC,0BA3iCO,oCA2iCkB;AACvB,UAAMnB,KAAK,GAAG,KAAKJ,OAAL,EAAd;AAEA,UAAII,KAAJ,EAAW,KAAK/J,IAAL,CAAUG,kBAAV,GAA+B4J,KAAK,CAAClY,SAArC;AACZ,KA/iCM;AAijCPsZ,6BAjjCO,uCAijCqB;AAC1B,UAAMpB,KAAK,GAAG,KAAKJ,OAAL,EAAd;AAEA,UAAII,KAAJ,EAAWA,KAAK,CAAClY,SAAN,GAAkB,KAAKmO,IAAL,CAAUG,kBAA5B;AACZ;AArjCM,GAjzBI;AAy2DbsN,SAz2Da,qBAy2DH;AACR,SAAKpJ,WAAL;AACA,SAAKG,UAAL;AACD,GA52DY;AA82DbkJ,SA92Da,qBA82DH;AACR,QAAI,KAAKhS,SAAT,EAAoB,KAAK2L,UAAL;AACpB,QAAI,CAAC,KAAKzI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAKyP,eAAL;AAC9D,QAAI,KAAK7P,UAAT,EAAqB,KAAK4H,QAAL;AACrB,QAAI,KAAK1H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKmH,kBAAL;AACxC,GAn3DY;AAq3Db2J,WAr3Da,uBAq3DD;AAEV,SAAK9G,uBAAL,CAA6B,KAA7B;AACD;AAx3DY,CAAf,E;;ACjEA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AACA;AAEA;AAEA;AAEA,uEACA,0CADA;AAIA;AAAA,aACA;AAAA;AAAA;AACA;AADA;AAAA;AAAA,mBAEA;AAFA;AAGA;AAHA,QADA;AAAA;AAOA;AAvBA,G;;ACXwN,CAAgB,wHAAG,EAAC,C;;ACA5O;;AAEA;AACA;AACA;;AAEe;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;ACjGA,IAAI,mBAAM;AACsD;AACL;;;AAG3D;AAC0F;AAC1F,gBAAgB,kBAAU;AAC1B,EAAE,+CAAM;AACR,EAAE,mBAAM;AACR;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,YAYf;AACD;AACe,kE;;;;;;;AChCf;AACA;AAEA,oCACA,eADA,EAEA,aAFA,EAGA,cAHA,EAIA,oBAJA,EAKA,kBALA,EAMA,qBANA,EAOA,oBAPA;AAUA;AACA,+BADA;AAEA,sBAFA;AAIA;AAAA;AACA,iCADA;AAEA;AAFA;AAAA,GAJA;AASA;AACA,gBADA,0BACA;AACA;AAEA,aACA,uBACA,kBADA,IAEA,iBAHA;AAKA,KATA;AAWA,cAXA,wBAWA;AACA;AACA;AADA;AAGA;AAfA,GATA;AA2BA;AACA,kCADA,sCACA,QADA,EACA;AACA;AACA,KAHA;AAKA,SALA,mBAKA;AAEA;AACA;AARA,GA3BA;AAsCA,SAtCA,qBAsCA;AACA,gDACA,sBADA,EAEA,oBAFA,EAGA;AAAA;AAAA;AAAA,KAHA;AAKA,GA5CA;AA8CA;AACA,SADA,mBACA;AACA;AACA;AAAA;AAAA;AADA;AAGA,KALA;AAOA,SAPA,mBAOA;AACA;;AAEA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AACA;AAEA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AACA;AACA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AACA;AAEA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AACA;AAGA;AAEA,oEACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AAAA;AACA;AACA;AACA;;AACA;AACA;;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA;AAAA;AACA;AACA;AACA,aAFA,MAEA;AACA;AACA;;AACA;AACA;;AACA;AAAA;AACA;AACA;AACA;AACA;;AACA;AAAA;AACA;AACA;AACA;AACA;;AACA;AAAA;AACA;;AACA;AACA;AACA;AACA,aAHA,MAGA;AACA;AACA;AACA;;AACA;AACA;;AACA;AAAA;AACA;AACA;AACA;AACA;;AACA;AAAA;AACA;;AACA;AACA;AACA;AACA;;AACA;AACA;;AACA;AAAA;AACA;AACA;AACA;AACA;;AACA;AAAA;AACA;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","file":"vue-treeselect.cjs.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 16);\n","module.exports = require(\"@babel/runtime/helpers/slicedToArray\");","module.exports = require(\"@babel/runtime/helpers/toConsumableArray\");","module.exports = require(\"@babel/runtime/helpers/defineProperty\");","module.exports = require(\"fuzzysearch\");","module.exports = require(\"lodash/noop\");","module.exports = require(\"lodash/debounce\");","module.exports = require(\"watch-size\");","module.exports = require(\"is-promise\");","module.exports = require(\"lodash/once\");","module.exports = require(\"lodash/identity\");","module.exports = require(\"lodash/constant\");","module.exports = require(\"@babel/runtime/helpers/typeof\");","module.exports = require(\"lodash/last\");","module.exports = require(\"babel-helper-vue-jsx-merge-props\");","module.exports = require(\"vue\");","// extracted by mini-css-extract-plugin","import { noop } from './noop'\n\nexport const warning = process.env.NODE_ENV === 'production'\n ? /* istanbul ignore next */ noop\n : function warning(checker, complainer) {\n if (!checker()) {\n const message = [ '[Vue-Treeselect Warning]' ].concat(complainer())\n // eslint-disable-next-line no-console\n console.error(...message)\n }\n }\n","export function onLeftClick(mouseDownHandler) {\n return function onMouseDown(evt, ...args) {\n if (evt.type === 'mousedown' && evt.button === 0) {\n mouseDownHandler.call(this, evt, ...args)\n }\n }\n}\n","// from react-select\nexport function scrollIntoView($scrollingEl, $focusedEl) {\n const scrollingReact = $scrollingEl.getBoundingClientRect()\n const focusedRect = $focusedEl.getBoundingClientRect()\n const overScroll = $focusedEl.offsetHeight / 3\n\n if (focusedRect.bottom + overScroll > scrollingReact.bottom) {\n $scrollingEl.scrollTop = Math.min(\n $focusedEl.offsetTop + $focusedEl.clientHeight - $scrollingEl.offsetHeight + overScroll,\n $scrollingEl.scrollHeight,\n )\n } else if (focusedRect.top - overScroll < scrollingReact.top) {\n $scrollingEl.scrollTop = Math.max($focusedEl.offsetTop - overScroll, 0)\n }\n}\n","export function removeFromArray(arr, elem) {\n const idx = arr.indexOf(elem)\n if (idx !== -1) arr.splice(idx, 1)\n}\n","import watchSizeForBrowsersOtherThanIE9 from 'watch-size'\nimport { removeFromArray } from './removeFromArray'\n\nlet intervalId\nconst registered = []\nconst INTERVAL_DURATION = 100\n\nfunction run() {\n intervalId = setInterval(() => {\n registered.forEach(test)\n }, INTERVAL_DURATION)\n}\n\nfunction stop() {\n clearInterval(intervalId)\n intervalId = null\n}\n\nfunction test(item) {\n const { $el, listener, lastWidth, lastHeight } = item\n const width = $el.offsetWidth\n const height = $el.offsetHeight\n\n if (lastWidth !== width || lastHeight !== height) {\n item.lastWidth = width\n item.lastHeight = height\n\n listener({ width, height })\n }\n}\n\nfunction watchSizeForIE9($el, listener) {\n const item = {\n $el,\n listener,\n lastWidth: null,\n lastHeight: null,\n }\n const unwatch = () => {\n removeFromArray(registered, item)\n if (!registered.length) stop()\n }\n\n registered.push(item)\n // The original watch-size will call the listener on initialization.\n // Keep the same behavior here.\n test(item)\n run()\n\n return unwatch\n}\n\nexport function watchSize($el, listener) {\n // See: https://stackoverflow.com/a/31293352\n const isIE9 = document.documentMode === 9\n // watch-size will call the listener on initialization.\n // Disable this behavior with a lock to achieve a clearer code logic.\n let locked = true\n const wrappedListener = (...args) => locked || listener(...args)\n const implementation = isIE9\n ? watchSizeForIE9\n : watchSizeForBrowsersOtherThanIE9\n const removeSizeWatcher = implementation($el, wrappedListener)\n locked = false // unlock after initialization\n\n return removeSizeWatcher\n}\n","function findScrollParents($el) {\n const $scrollParents = []\n let $parent = $el.parentNode\n\n while ($parent && $parent.nodeName !== 'BODY' && $parent.nodeType === document.ELEMENT_NODE) {\n if (isScrollElment($parent)) $scrollParents.push($parent)\n $parent = $parent.parentNode\n }\n $scrollParents.push(window)\n\n return $scrollParents\n}\n\nfunction isScrollElment($el) {\n // Firefox wants us to check `-x` and `-y` variations as well\n const { overflow, overflowX, overflowY } = getComputedStyle($el)\n return /(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)\n}\n\nexport function setupResizeAndScrollEventListeners($el, listener) {\n const $scrollParents = findScrollParents($el)\n\n window.addEventListener('resize', listener, { passive: true })\n $scrollParents.forEach(scrollParent => {\n scrollParent.addEventListener('scroll', listener, { passive: true })\n })\n\n return function removeEventListeners() {\n window.removeEventListener('resize', listener, { passive: true })\n $scrollParents.forEach($scrollParent => {\n $scrollParent.removeEventListener('scroll', listener, { passive: true })\n })\n }\n}\n","export function isNaN(x) {\n return x !== x\n}\n","export const createMap = () => Object.create(null)\n","function isPlainObject(value) {\n if (value == null || typeof value !== 'object') return false\n return Object.getPrototypeOf(value) === Object.prototype\n}\n\nfunction copy(obj, key, value) {\n if (isPlainObject(value)) {\n obj[key] || (obj[key] = {})\n deepExtend(obj[key], value)\n } else {\n obj[key] = value\n }\n}\n\nexport function deepExtend(target, source) {\n if (isPlainObject(source)) {\n const keys = Object.keys(source)\n\n for (let i = 0, len = keys.length; i < len; i++) {\n copy(target, keys[i], source[keys[i]])\n }\n }\n\n return target\n}\n","export function includes(arrOrStr, elem) {\n return arrOrStr.indexOf(elem) !== -1\n}\n","export function find(arr, predicate, ctx) {\n for (let i = 0, len = arr.length; i < len; i++) {\n if (predicate.call(ctx, arr[i], i, arr)) return arr[i]\n }\n return undefined\n}\n","export function quickDiff(arrA, arrB) {\n if (arrA.length !== arrB.length) return true\n\n for (let i = 0; i < arrA.length; i++) {\n if (arrA[i] !== arrB[i]) return true\n }\n\n return false\n}\n","// ========================\n// Debugging Helpers\n// ========================\n\nexport { warning } from './warning'\n\n// ========================\n// DOM Utilities\n// ========================\n\nexport { onLeftClick } from './onLeftClick'\nexport { scrollIntoView } from './scrollIntoView'\nexport { debounce } from './debounce'\nexport { watchSize } from './watchSize'\nexport { setupResizeAndScrollEventListeners } from './setupResizeAndScrollEventListeners'\n\n// ========================\n// Language Helpers\n// ========================\n\nexport { isNaN } from './isNaN'\nexport { isPromise } from './isPromise'\nexport { once } from './once'\nexport { noop } from './noop'\nexport { identity } from './identity'\nexport { constant } from './constant'\nexport { createMap } from './createMap'\nexport { deepExtend } from './deepExtend'\nexport { last } from './last'\nexport { includes } from './includes'\nexport { find } from './find'\nexport { removeFromArray } from './removeFromArray'\n\n// ========================\n// Other Utilities\n// ========================\n\nexport { quickDiff } from './quickDiff'\n","// Magic value that indicates a root level node.\nexport const NO_PARENT_NODE = null\n\n// Types of checked state.\nexport const UNCHECKED = 0\nexport const INDETERMINATE = 1\nexport const CHECKED = 2\n\n// Types of count number.\nexport const ALL_CHILDREN = 'ALL_CHILDREN'\nexport const ALL_DESCENDANTS = 'ALL_DESCENDANTS'\nexport const LEAF_CHILDREN = 'LEAF_CHILDREN'\nexport const LEAF_DESCENDANTS = 'LEAF_DESCENDANTS'\n\n// Action types of delayed loading.\nexport const LOAD_ROOT_OPTIONS = 'LOAD_ROOT_OPTIONS'\nexport const LOAD_CHILDREN_OPTIONS = 'LOAD_CHILDREN_OPTIONS'\nexport const ASYNC_SEARCH = 'ASYNC_SEARCH'\n\n// Acceptable values of `valueConsistsOf` prop.\nexport const ALL = 'ALL'\nexport const BRANCH_PRIORITY = 'BRANCH_PRIORITY'\nexport const LEAF_PRIORITY = 'LEAF_PRIORITY'\nexport const ALL_WITH_INDETERMINATE = 'ALL_WITH_INDETERMINATE'\n\n// Acceptable values of `sortValueBy` prop.\nexport const ORDER_SELECTED = 'ORDER_SELECTED'\nexport const LEVEL = 'LEVEL'\nexport const INDEX = 'INDEX'\n\n// Key codes look-up table.\nexport const KEY_CODES = {\n BACKSPACE: 8,\n ENTER: 13,\n ESCAPE: 27,\n END: 35,\n HOME: 36,\n ARROW_LEFT: 37,\n ARROW_UP: 38,\n ARROW_RIGHT: 39,\n ARROW_DOWN: 40,\n DELETE: 46,\n}\n\n// Other constants.\nexport const INPUT_DEBOUNCE_DELAY = process.env.NODE_ENV === 'testing'\n ? /* to speed up unit testing */ 10\n : /* istanbul ignore next */ 200\nexport const MIN_INPUT_WIDTH = 5\nexport const MENU_BUFFER = 40\n","import fuzzysearch from 'fuzzysearch'\n\nimport {\n warning,\n onLeftClick, scrollIntoView,\n isNaN, isPromise, once,\n identity, constant, createMap,\n quickDiff, last as getLast, includes, find, removeFromArray,\n} from '../utils'\n\nimport {\n NO_PARENT_NODE,\n UNCHECKED, INDETERMINATE, CHECKED,\n LOAD_ROOT_OPTIONS, LOAD_CHILDREN_OPTIONS, ASYNC_SEARCH,\n ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE,\n ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS,\n ORDER_SELECTED, LEVEL, INDEX,\n} from '../constants'\n\nfunction sortValueByIndex(a, b) {\n let i = 0\n do {\n if (a.level < i) return -1\n if (b.level < i) return 1\n if (a.index[i] !== b.index[i]) return a.index[i] - b.index[i]\n i++\n } while (true)\n}\n\nfunction sortValueByLevel(a, b) {\n return a.level === b.level\n ? sortValueByIndex(a, b)\n : a.level - b.level\n}\n\nfunction createAsyncOptionsStates() {\n return {\n isLoaded: false,\n isLoading: false,\n loadingError: '',\n }\n}\n\nfunction stringifyOptionPropValue(value) {\n if (typeof value === 'string') return removeAccents(value)\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\n}\nfunction removeAccents(str) {\n if (!str) return ''\n return str.normalize('NFD').replace(/[\\u0300-\\u036F]/g, '')\n}\n\nfunction match(enableFuzzyMatch, needle, haystack) {\n return enableFuzzyMatch\n ? fuzzysearch(needle, haystack)\n : includes(haystack, needle)\n}\n\nfunction getErrorMessage(err) {\n return err.message || /* istanbul ignore next */String(err)\n}\n\nlet instanceId = 0\n\nexport default {\n provide() {\n return {\n // Enable access to the instance of root component of vue-treeselect\n // across hierarchy.\n instance: this,\n }\n },\n\n props: {\n /**\n * Whether to allow resetting value even if there are disabled selected nodes.\n */\n allowClearingDisabled: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When an ancestor node is selected/deselected, whether its disabled descendants should be selected/deselected.\n * You may want to use this in conjunction with `allowClearingDisabled` prop.\n */\n allowSelectingDisabledDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether the menu should be always open.\n */\n alwaysOpen: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Append the menu to ?\n */\n appendToBody: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether to enable async search mode.\n */\n async: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Automatically focus the component on mount?\n */\n autoFocus: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Automatically load root options on mount. When set to `false`, root options will be loaded when the menu is opened.\n */\n autoLoadRootOptions: {\n type: Boolean,\n default: true,\n },\n\n /**\n * When user deselects a node, automatically deselect its ancestors. Applies to flat mode only.\n */\n autoDeselectAncestors: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user deselects a node, automatically deselect its descendants. Applies to flat mode only.\n */\n autoDeselectDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user selects a node, automatically select its ancestors. Applies to flat mode only.\n */\n autoSelectAncestors: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user selects a node, automatically select its descendants. Applies to flat mode only.\n */\n autoSelectDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether pressing backspace key removes the last item if there is no text input.\n */\n backspaceRemoves: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Function that processes before clearing all input fields.\n * Return `false` to prevent value from being cleared.\n * @type {function(): (boolean|Promise)}\n */\n beforeClearAll: {\n type: Function,\n default: constant(true),\n },\n\n /**\n * Show branch nodes before leaf nodes?\n */\n branchNodesFirst: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Should cache results of every search request?\n */\n cacheOptions: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Show an \"×\" button that resets value?\n */\n clearable: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Title for the \"×\" button when `multiple: true`.\n */\n clearAllText: {\n type: String,\n default: 'Clear all',\n },\n\n /**\n * Whether to clear the search input after selecting.\n * Use only when `multiple` is `true`.\n * For single-select mode, it **always** clears the input after selecting an option regardless of the prop value.\n */\n clearOnSelect: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Title for the \"×\" button.\n */\n clearValueText: {\n type: String,\n default: 'Clear value',\n },\n\n /**\n * Whether to close the menu after selecting an option?\n * Use only when `multiple` is `true`.\n */\n closeOnSelect: {\n type: Boolean,\n default: true,\n },\n\n /**\n * How many levels of branch nodes should be automatically expanded when loaded.\n * Set `Infinity` to make all branch nodes expanded by default.\n */\n defaultExpandLevel: {\n type: Number,\n default: 0,\n },\n\n /**\n * The default set of options to show before the user starts searching. Used for async search mode.\n * When set to `true`, the results for search query as a empty string will be autoloaded.\n * @type {boolean|node[]}\n */\n defaultOptions: {\n default: false,\n },\n\n /**\n * Whether pressing delete key removes the last item if there is no text input.\n */\n deleteRemoves: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Delimiter to use to join multiple values for the hidden field value.\n */\n delimiter: {\n type: String,\n default: ',',\n },\n\n /**\n * Only show the nodes that match the search value directly, excluding its ancestors.\n *\n * @type {Object}\n */\n flattenSearchResults: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Prevent branch nodes from being selected?\n */\n disableBranchNodes: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Disable the control?\n */\n disabled: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Disable the fuzzy matching functionality?\n */\n disableFuzzyMatching: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether to enable flat mode or not. Non-flat mode (default) means:\n * - Whenever a branch node gets checked, all its children will be checked too\n * - Whenever a branch node has all children checked, the branch node itself will be checked too\n * Set `true` to disable this mechanism\n */\n flat: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Will be passed with all events as the last param.\n * Useful for identifying events origin.\n */\n instanceId: {\n // Add two trailing \"$\" to distinguish from explictly specified ids.\n default: () => `${instanceId++}$$`,\n type: [ String, Number ],\n },\n\n /**\n * Joins multiple values into a single form field with the `delimiter` (legacy mode).\n */\n joinValues: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Limit the display of selected options.\n * The rest will be hidden within the limitText string.\n */\n limit: {\n type: Number,\n default: Infinity,\n },\n\n /**\n * Function that processes the message shown when selected elements pass the defined limit.\n * @type {function(number): string}\n */\n limitText: {\n type: Function,\n default: function limitTextDefault(count) { // eslint-disable-line func-name-matching\n return `and ${count} more`\n },\n },\n\n /**\n * Text displayed when loading options.\n */\n loadingText: {\n type: String,\n default: 'Loading...',\n },\n\n /**\n * Used for dynamically loading options.\n * @type {function({action: string, callback: (function((Error|string)=): void), parentNode: node=, instanceId}): void}\n */\n loadOptions: {\n type: Function,\n },\n\n /**\n * Which node properties to filter on.\n */\n matchKeys: {\n type: Array,\n default: constant([ 'label' ]),\n },\n\n /**\n * Sets `maxHeight` style value of the menu.\n */\n maxHeight: {\n type: Number,\n default: 300,\n },\n\n /**\n * Set `true` to allow selecting multiple options (a.k.a., multi-select mode).\n */\n multiple: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Generates a hidden tag with this field name for html forms.\n */\n name: {\n type: String,\n },\n\n /**\n * Text displayed when a branch node has no children.\n */\n noChildrenText: {\n type: String,\n default: 'No sub-options.',\n },\n\n /**\n * Text displayed when there are no available options.\n */\n noOptionsText: {\n type: String,\n default: 'No options available.',\n },\n\n /**\n * Text displayed when there are no matching search results.\n */\n noResultsText: {\n type: String,\n default: 'No results found...',\n },\n\n /**\n * Used for normalizing source data.\n * @type {function(node, instanceId): node}\n */\n normalizer: {\n type: Function,\n default: identity,\n },\n\n /**\n * By default (`auto`), the menu will open below the control. If there is not\n * enough space, vue-treeselect will automatically flip the menu.\n * You can use one of other four options to force the menu to be always opened\n * to specified direction.\n * Acceptable values:\n * - `\"auto\"`\n * - `\"below\"`\n * - `\"bottom\"`\n * - `\"above\"`\n * - `\"top\"`\n */\n openDirection: {\n type: String,\n default: 'auto',\n validator(value) {\n const acceptableValues = [ 'auto', 'top', 'bottom', 'above', 'below' ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Whether to automatically open the menu when the control is clicked.\n */\n openOnClick: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Whether to automatically open the menu when the control is focused.\n */\n openOnFocus: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Array of available options.\n * @type {node[]}\n */\n options: {\n type: Array,\n },\n\n /**\n * Field placeholder, displayed when there's no value.\n */\n placeholder: {\n type: String,\n default: 'Select...',\n },\n\n /**\n * Applies HTML5 required attribute when needed.\n */\n required: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Text displayed asking user whether to retry loading children options.\n */\n retryText: {\n type: String,\n default: 'Retry?',\n },\n\n /**\n * Title for the retry button.\n */\n retryTitle: {\n type: String,\n default: 'Click to retry',\n },\n\n /**\n * Enable searching feature?\n */\n searchable: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Search in ancestor nodes too.\n */\n searchNested: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Text tip to prompt for async search.\n */\n searchPromptText: {\n type: String,\n default: 'Type to search...',\n },\n\n /**\n * Whether to show a children count next to the label of each branch node.\n */\n showCount: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Used in conjunction with `showCount` to specify which type of count number should be displayed.\n * Acceptable values:\n * - \"ALL_CHILDREN\"\n * - \"ALL_DESCENDANTS\"\n * - \"LEAF_CHILDREN\"\n * - \"LEAF_DESCENDANTS\"\n */\n showCountOf: {\n type: String,\n default: ALL_CHILDREN,\n validator(value) {\n const acceptableValues = [ ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Whether to show children count when searching.\n * Fallbacks to the value of `showCount` when not specified.\n * @type {boolean}\n */\n showCountOnSearch: null,\n\n /**\n * In which order the selected options should be displayed in trigger & sorted in `value` array.\n * Used for multi-select mode only.\n * Acceptable values:\n * - \"ORDER_SELECTED\"\n * - \"LEVEL\"\n * - \"INDEX\"\n */\n sortValueBy: {\n type: String,\n default: ORDER_SELECTED,\n validator(value) {\n const acceptableValues = [ ORDER_SELECTED, LEVEL, INDEX ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Tab index of the control.\n */\n tabIndex: {\n type: Number,\n default: 0,\n },\n\n /**\n * The value of the control.\n * Should be `id` or `node` object for single-select mode, or an array of `id` or `node` object for multi-select mode.\n * Its format depends on the `valueFormat` prop.\n * For most cases, just use `v-model` instead.\n * @type {?Array}\n */\n value: null,\n\n /**\n * Which kind of nodes should be included in the `value` array in multi-select mode.\n * Acceptable values:\n * - \"ALL\" - Any node that is checked will be included in the `value` array\n * - \"BRANCH_PRIORITY\" (default) - If a branch node is checked, all its descendants will be excluded in the `value` array\n * - \"LEAF_PRIORITY\" - If a branch node is checked, this node itself and its branch descendants will be excluded from the `value` array but its leaf descendants will be included\n * - \"ALL_WITH_INDETERMINATE\" - Any node that is checked will be included in the `value` array, plus indeterminate nodes\n */\n valueConsistsOf: {\n type: String,\n default: BRANCH_PRIORITY,\n validator(value) {\n const acceptableValues = [ ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Format of `value` prop.\n * Note that, when set to `\"object\"`, only `id` & `label` properties are required in each `node` object in `value` prop.\n * Acceptable values:\n * - \"id\"\n * - \"object\"\n */\n valueFormat: {\n type: String,\n default: 'id',\n },\n\n /**\n * z-index of the menu.\n */\n zIndex: {\n type: [ Number, String ],\n default: 999,\n },\n },\n\n data() {\n return {\n trigger: {\n // Is the control focused?\n isFocused: false,\n // User entered search query - value of the input.\n searchQuery: '',\n },\n\n menu: {\n // Is the menu opened?\n isOpen: false,\n // Id of current highlighted option.\n current: null,\n // The scroll position before last menu closing.\n lastScrollPosition: 0,\n // Which direction to open the menu.\n placement: 'bottom',\n },\n\n forest: {\n // Normalized options.\n normalizedOptions: [],\n // map for quick look-up.\n nodeMap: createMap(),\n // map, used for multi-select mode.\n checkedStateMap: createMap(),\n // Id list of all selected options.\n selectedNodeIds: this.extractCheckedNodeIdsFromValue(),\n // map for fast checking:\n // if (forest.selectedNodeIds.indexOf(id) !== -1) forest.selectedNodeMap[id] === true\n selectedNodeMap: createMap(),\n },\n\n // States of root options.\n rootOptionsStates: createAsyncOptionsStates(),\n\n localSearch: {\n // Has user entered any query to search local options?\n active: false,\n // Has any options matched the search query?\n noResults: true,\n // map for counting matched children/descendants.\n countMap: createMap(),\n },\n\n // map.\n remoteSearch: createMap(),\n }\n },\n\n computed: {\n /* eslint-disable valid-jsdoc */\n /**\n * Normalized nodes that have been selected.\n * @type {node[]}\n */\n selectedNodes() {\n return this.forest.selectedNodeIds.map(this.getNode)\n },\n /**\n * Id list of selected nodes with `sortValueBy` prop applied.\n * @type {nodeId[]}\n */\n internalValue() {\n let internalValue\n\n // istanbul ignore else\n if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) {\n internalValue = this.forest.selectedNodeIds.slice()\n } else if (this.valueConsistsOf === BRANCH_PRIORITY) {\n internalValue = this.forest.selectedNodeIds.filter(id => {\n const node = this.getNode(id)\n if (node.isRootNode) return true\n return !this.isSelected(node.parentNode)\n })\n } else if (this.valueConsistsOf === LEAF_PRIORITY) {\n internalValue = this.forest.selectedNodeIds.filter(id => {\n const node = this.getNode(id)\n if (node.isLeaf) return true\n return node.children.length === 0\n })\n } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) {\n const indeterminateNodeIds = []\n internalValue = this.forest.selectedNodeIds.slice()\n this.selectedNodes.forEach(selectedNode => {\n selectedNode.ancestors.forEach(ancestor => {\n if (includes(indeterminateNodeIds, ancestor.id)) return\n if (includes(internalValue, ancestor.id)) return\n indeterminateNodeIds.push(ancestor.id)\n })\n })\n internalValue.push(...indeterminateNodeIds)\n }\n\n if (this.sortValueBy === LEVEL) {\n internalValue.sort((a, b) => sortValueByLevel(this.getNode(a), this.getNode(b)))\n } else if (this.sortValueBy === INDEX) {\n internalValue.sort((a, b) => sortValueByIndex(this.getNode(a), this.getNode(b)))\n }\n\n return internalValue\n },\n /**\n * Has any option been selected?\n * @type {boolean}\n */\n hasValue() {\n return this.internalValue.length > 0\n },\n /**\n * Single-select mode?\n * @type {boolean}\n */\n single() {\n return !this.multiple\n },\n /**\n * Id list of nodes displayed in the menu. Nodes that are considered NOT visible:\n * - descendants of a collapsed branch node\n * - in local search mode, nodes that are not matched, unless\n * - it's a branch node and has matched descendants\n * - it's a leaf node and its parent node is explicitly set to show all children\n * @type {id[]}\n */\n visibleOptionIds() {\n const visibleOptionIds = []\n\n this.traverseAllNodesByIndex(node => {\n if (!this.localSearch.active || this.shouldOptionBeIncludedInSearchResult(node)) {\n visibleOptionIds.push(node.id)\n }\n // Skip the traversal of descendants of a branch node if it's not expanded.\n if (node.isBranch && !this.shouldExpand(node)) {\n return false\n }\n })\n\n return visibleOptionIds\n },\n /**\n * Has any option should be displayed in the menu?\n * @type {boolean}\n */\n hasVisibleOptions() {\n return this.visibleOptionIds.length !== 0\n },\n /**\n * Should show children count when searching?\n * @type {boolean}\n */\n showCountOnSearchComputed() {\n // Vue doesn't allow setting default prop value based on another prop value.\n // So use computed property as a workaround.\n // https://github.com/vuejs/vue/issues/6358\n return typeof this.showCountOnSearch === 'boolean'\n ? this.showCountOnSearch\n : this.showCount\n },\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes() {\n return this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\n },\n shouldFlattenOptions() {\n return this.localSearch.active && this.flattenSearchResults\n },\n /* eslint-enable valid-jsdoc */\n },\n\n watch: {\n alwaysOpen(newValue) {\n if (newValue) this.openMenu()\n else this.closeMenu()\n },\n\n branchNodesFirst() {\n this.initialize()\n },\n\n disabled(newValue) {\n // force close the menu after disabling the control\n if (newValue && this.menu.isOpen) this.closeMenu()\n else if (!newValue && !this.menu.isOpen && this.alwaysOpen) this.openMenu()\n },\n\n flat() {\n this.initialize()\n },\n\n internalValue(newValue, oldValue) {\n const hasChanged = quickDiff(newValue, oldValue)\n // #122\n // Vue would trigger this watcher when `newValue` and `oldValue` are shallow-equal.\n // We emit the `input` event only when the value actually changes.\n if (hasChanged) this.$emit('input', this.getValue(), this.getInstanceId())\n },\n\n matchKeys() {\n this.initialize()\n },\n\n multiple(newValue) {\n // We need to rebuild the state when switching from single-select mode\n // to multi-select mode.\n // istanbul ignore else\n if (newValue) this.buildForestState()\n },\n\n options: {\n handler() {\n if (this.async) return\n // Re-initialize options when the `options` prop has changed.\n this.initialize()\n this.rootOptionsStates.isLoaded = Array.isArray(this.options)\n },\n deep: true,\n immediate: true,\n },\n\n 'trigger.searchQuery'() {\n if (this.async) {\n this.handleRemoteSearch()\n } else {\n this.handleLocalSearch()\n }\n\n this.$emit('search-change', this.trigger.searchQuery, this.getInstanceId())\n },\n\n value() {\n const nodeIdsFromValue = this.extractCheckedNodeIdsFromValue()\n const hasChanged = quickDiff(nodeIdsFromValue, this.internalValue)\n if (hasChanged) this.fixSelectedNodeIds(nodeIdsFromValue)\n },\n },\n\n methods: {\n verifyProps() {\n warning(\n () => this.async ? this.searchable : true,\n () => 'For async search mode, the value of \"searchable\" prop must be true.',\n )\n\n if (this.options == null && !this.loadOptions) {\n warning(\n () => false,\n () => 'Are you meant to dynamically load options? You need to use \"loadOptions\" prop.',\n )\n }\n\n if (this.flat) {\n warning(\n () => this.multiple,\n () => 'You are using flat mode. But you forgot to add \"multiple=true\"?',\n )\n }\n\n if (!this.flat) {\n const propNames = [\n 'autoSelectAncestors',\n 'autoSelectDescendants',\n 'autoDeselectAncestors',\n 'autoDeselectDescendants',\n ]\n\n propNames.forEach(propName => {\n warning(\n () => !this[propName],\n () => `\"${propName}\" only applies to flat mode.`,\n )\n })\n }\n },\n\n resetFlags() {\n this._blurOnSelect = false\n },\n\n initialize() {\n const options = this.async\n ? this.getRemoteSearchEntry().options\n : this.options\n\n if (Array.isArray(options)) {\n // In case we are re-initializing options, keep the old state tree temporarily.\n const prevNodeMap = this.forest.nodeMap\n this.forest.nodeMap = createMap()\n this.keepDataOfSelectedNodes(prevNodeMap)\n this.forest.normalizedOptions = this.normalize(NO_PARENT_NODE, options, prevNodeMap)\n // Cases that need fixing `selectedNodeIds`:\n // 1) Children options of a checked node have been delayed loaded,\n // we should also mark these children as checked. (multi-select mode)\n // 2) Root options have been delayed loaded, we need to initialize states\n // of these nodes. (multi-select mode)\n // 3) Async search mode.\n this.fixSelectedNodeIds(this.internalValue)\n } else {\n this.forest.normalizedOptions = []\n }\n },\n\n getInstanceId() {\n return this.instanceId == null ? this.id : this.instanceId\n },\n\n getValue() {\n if (this.valueFormat === 'id') {\n return this.multiple\n ? this.getUniqChildValues(this.internalValue.slice())\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple\n ? this.getUniqChildValues(rawNodes)\n : rawNodes[0]\n },\n\n getUniqChildValues(ids) {\n if (this.valueConsistsOf !== BRANCH_PRIORITY) return ids\n const values = ids.map(id => {\n const node = this.getNode(id)\n if (node.hasBeenSelected) return node.id\n if (this.hasOneChild(node)) {\n const children = []\n this.traverseDescendantsBFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n if (descendant.hasBeenSelected) {\n children.push(descendant.id)\n }\n }\n })\n if (children && children.length) return children[0]\n }\n return id\n })\n return values\n },\n hasOneChild(node) {\n return node && node.children && node.children.length === 1\n },\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) return null\n\n return nodeId in this.forest.nodeMap\n ? this.forest.nodeMap[nodeId]\n : this.createFallbackNode(nodeId)\n },\n\n createFallbackNode(id) {\n // In case there is a default selected node that is not loaded into the tree yet,\n // we create a fallback node to keep the component working.\n // When the real data is loaded, we'll override this fake node.\n\n const raw = this.extractNodeFromValue(id)\n const label = this.enhancedNormalizer(raw).label || `${id} (unknown)`\n const fallbackNode = {\n id,\n label,\n ancestors: [],\n parentNode: NO_PARENT_NODE,\n isFallbackNode: true,\n isRootNode: true,\n isLeaf: true,\n isBranch: false,\n isDisabled: false,\n isNew: false,\n index: [ -1 ],\n level: 0,\n raw,\n }\n\n return this.$set(this.forest.nodeMap, id, fallbackNode)\n },\n\n extractCheckedNodeIdsFromValue() {\n if (this.value == null) return []\n\n if (this.valueFormat === 'id') {\n return this.multiple\n ? this.value.slice()\n : [ this.value ]\n }\n\n return (this.multiple ? this.value : [ this.value ])\n .map(node => this.enhancedNormalizer(node))\n .map(node => node.id)\n },\n\n extractNodeFromValue(id) {\n const defaultNode = { id }\n\n if (this.valueFormat === 'id') {\n return defaultNode\n }\n\n const valueArray = this.multiple\n ? Array.isArray(this.value) ? this.value : []\n : this.value ? [ this.value ] : []\n const matched = find(\n valueArray,\n node => node && this.enhancedNormalizer(node).id === id,\n )\n\n return matched || defaultNode\n },\n\n fixSelectedNodeIds(nodeIdListOfPrevValue) {\n let nextSelectedNodeIds = []\n\n // istanbul ignore else\n if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) {\n nextSelectedNodeIds = nodeIdListOfPrevValue\n } else if (this.valueConsistsOf === BRANCH_PRIORITY) {\n nodeIdListOfPrevValue.forEach(nodeId => {\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n nextSelectedNodeIds.push(descendant.id)\n })\n })\n } else if (this.valueConsistsOf === LEAF_PRIORITY) {\n const map = createMap()\n const queue = nodeIdListOfPrevValue.slice()\n while (queue.length) {\n const nodeId = queue.shift()\n const node = this.getNode(nodeId)\n nextSelectedNodeIds.push(nodeId)\n if (node.isRootNode) continue\n if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length\n if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id)\n }\n } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) {\n const map = createMap()\n const queue = nodeIdListOfPrevValue.filter(nodeId => {\n const node = this.getNode(nodeId)\n return node.isLeaf || node.children.length === 0\n })\n while (queue.length) {\n const nodeId = queue.shift()\n const node = this.getNode(nodeId)\n nextSelectedNodeIds.push(nodeId)\n if (node.isRootNode) continue\n if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length\n if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id)\n }\n }\n\n const hasChanged = quickDiff(this.forest.selectedNodeIds, nextSelectedNodeIds)\n // If `nextSelectedNodeIds` doesn't actually differ from old `selectedNodeIds`,\n // we don't make the assignment to avoid triggering its watchers which may cause\n // unnecessary calculations.\n if (hasChanged) this.forest.selectedNodeIds = nextSelectedNodeIds\n\n this.buildForestState()\n },\n\n keepDataOfSelectedNodes(prevNodeMap) {\n // In case there is any selected node that is not present in the new `options` array.\n // It could be useful for async search mode.\n this.forest.selectedNodeIds.forEach(id => {\n if (!prevNodeMap[id]) return\n const node = {\n ...prevNodeMap[id],\n isFallbackNode: true,\n }\n this.$set(this.forest.nodeMap, id, node)\n })\n },\n\n isSelected(node) {\n // whether a node is selected (single-select mode) or fully-checked (multi-select mode)\n return this.forest.selectedNodeMap[node.id] === true\n },\n\n traverseDescendantsBFS(parentNode, callback) {\n // istanbul ignore if\n if (!parentNode.isBranch) return\n const queue = parentNode.children.slice()\n while (queue.length) {\n const currNode = queue[0]\n if (currNode.isBranch) queue.push(...currNode.children)\n callback(currNode)\n queue.shift()\n }\n },\n\n traverseDescendantsDFS(parentNode, callback) {\n if (!parentNode.isBranch) return\n parentNode.children.forEach(child => {\n // deep-level node first\n this.traverseDescendantsDFS(child, callback)\n callback(child)\n })\n },\n\n traverseAllNodesDFS(callback) {\n this.forest.normalizedOptions.forEach(rootNode => {\n // deep-level node first\n this.traverseDescendantsDFS(rootNode, callback)\n callback(rootNode)\n })\n },\n\n traverseAllNodesByIndex(callback) {\n const walk = parentNode => {\n parentNode.children.forEach(child => {\n if (callback(child) !== false && child.isBranch) {\n walk(child)\n }\n })\n }\n\n // To simplify the code logic of traversal,\n // we create a fake root node that holds all the root options.\n walk({ children: this.forest.normalizedOptions })\n },\n\n toggleClickOutsideEvent(enabled) {\n if (enabled) {\n document.addEventListener('mousedown', this.handleClickOutside, false)\n } else {\n document.removeEventListener('mousedown', this.handleClickOutside, false)\n }\n },\n\n getValueContainer() {\n return this.$refs.control.$refs['value-container']\n },\n\n getInput() {\n return this.getValueContainer().$refs.input\n },\n\n focusInput() {\n this.getInput().focus()\n },\n\n blurInput() {\n this.getInput().blur()\n },\n\n handleMouseDown: onLeftClick(function handleMouseDown(evt) {\n evt.preventDefault()\n evt.stopPropagation()\n\n if (this.disabled) return\n\n const isClickedOnValueContainer = this.getValueContainer().$el.contains(evt.target)\n if (isClickedOnValueContainer && !this.menu.isOpen && (this.openOnClick || this.trigger.isFocused)) {\n this.openMenu()\n }\n\n if (this._blurOnSelect) {\n this.blurInput()\n } else {\n // Focus the input or prevent blurring.\n this.focusInput()\n }\n\n this.resetFlags()\n }),\n\n handleClickOutside(evt) {\n // istanbul ignore else\n if (this.$refs.wrapper && !this.$refs.wrapper.contains(evt.target)) {\n this.blurInput()\n this.closeMenu()\n }\n },\n\n handleLocalSearch() {\n const { searchQuery } = this.trigger\n const done = () => this.resetHighlightedOptionWhenNecessary(true)\n\n if (!searchQuery) {\n // Exit sync search mode.\n this.localSearch.active = false\n return done()\n }\n\n // Enter sync search mode.\n this.localSearch.active = true\n\n // Reset states.\n this.localSearch.noResults = true\n this.traverseAllNodesDFS(node => {\n if (node.isBranch) {\n node.isExpandedOnSearch = false\n node.showAllChildrenOnSearch = false\n node.isMatched = false\n node.hasMatchedDescendants = false\n this.$set(this.localSearch.countMap, node.id, {\n [ALL_CHILDREN]: 0,\n [ALL_DESCENDANTS]: 0,\n [LEAF_CHILDREN]: 0,\n [LEAF_DESCENDANTS]: 0,\n })\n }\n })\n\n const lowerCasedSearchQuery = removeAccents(searchQuery).trim().toLocaleLowerCase()\n const splitSearchQuery = lowerCasedSearchQuery.replace(/\\s+/g, ' ').split(' ')\n this.traverseAllNodesDFS(node => {\n if (this.searchNested && splitSearchQuery.length > 1) {\n node.isMatched = splitSearchQuery.every(filterValue =>\n match(false, filterValue, node.nestedSearchLabel),\n )\n } else {\n node.isMatched = this.matchKeys.some(matchKey =>\n match(!this.disableFuzzyMatching, lowerCasedSearchQuery, node.lowerCased[matchKey]),\n )\n }\n\n if (node.isMatched) {\n this.localSearch.noResults = false\n node.ancestors.forEach(ancestor => this.localSearch.countMap[ancestor.id][ALL_DESCENDANTS]++)\n if (node.isLeaf) node.ancestors.forEach(ancestor => this.localSearch.countMap[ancestor.id][LEAF_DESCENDANTS]++)\n if (node.parentNode !== NO_PARENT_NODE) {\n this.localSearch.countMap[node.parentNode.id][ALL_CHILDREN] += 1\n // istanbul ignore else\n if (node.isLeaf) this.localSearch.countMap[node.parentNode.id][LEAF_CHILDREN] += 1\n }\n }\n\n if (\n (node.isMatched || (node.isBranch && node.isExpandedOnSearch)) &&\n node.parentNode !== NO_PARENT_NODE\n ) {\n node.parentNode.isExpandedOnSearch = true\n node.parentNode.hasMatchedDescendants = true\n }\n })\n\n done()\n },\n\n handleRemoteSearch() {\n const { searchQuery } = this.trigger\n const entry = this.getRemoteSearchEntry()\n const done = () => {\n this.initialize()\n this.resetHighlightedOptionWhenNecessary(true)\n }\n\n if ((searchQuery === '' || this.cacheOptions) && entry.isLoaded) {\n return done()\n }\n\n this.callLoadOptionsProp({\n action: ASYNC_SEARCH,\n args: { searchQuery },\n isPending() {\n return entry.isLoading\n },\n start: () => {\n entry.isLoading = true\n entry.isLoaded = false\n entry.loadingError = ''\n },\n succeed: options => {\n entry.isLoaded = true\n entry.options = options\n // When the request completes, the search query may have changed.\n // We only show these options if they are for the current search query.\n if (this.trigger.searchQuery === searchQuery) done()\n },\n fail: err => {\n entry.loadingError = getErrorMessage(err)\n },\n end: () => {\n entry.isLoading = false\n },\n })\n },\n\n getRemoteSearchEntry() {\n const { searchQuery } = this.trigger\n const entry = this.remoteSearch[searchQuery] || {\n ...createAsyncOptionsStates(),\n options: [],\n }\n\n // Vue doesn't support directly watching on objects.\n this.$watch(\n () => entry.options,\n () => {\n // TODO: potential redundant re-initialization.\n if (this.trigger.searchQuery === searchQuery) this.initialize()\n },\n { deep: true },\n )\n\n if (searchQuery === '') {\n if (Array.isArray(this.defaultOptions)) {\n entry.options = this.defaultOptions\n entry.isLoaded = true\n return entry\n } else if (this.defaultOptions !== true) {\n entry.isLoaded = true\n return entry\n }\n }\n\n if (!this.remoteSearch[searchQuery]) {\n this.$set(this.remoteSearch, searchQuery, entry)\n }\n\n return entry\n },\n\n shouldExpand(node) {\n return this.localSearch.active ? node.isExpandedOnSearch : node.isExpanded\n },\n\n shouldOptionBeIncludedInSearchResult(node) {\n // 1) This option is matched.\n if (node.isMatched) return true\n // 2) This option is not matched, but has matched descendant(s).\n if (node.isBranch && node.hasMatchedDescendants && !this.flattenSearchResults) return true\n // 3) This option's parent has no matched descendants,\n // but after being expanded, all its children should be shown.\n if (!node.isRootNode && node.parentNode.showAllChildrenOnSearch) return true\n // 4) The default case.\n return false\n },\n\n shouldShowOptionInMenu(node) {\n if (this.localSearch.active && !this.shouldOptionBeIncludedInSearchResult(node)) {\n return false\n }\n return true\n },\n\n getControl() {\n return this.$refs.control.$el\n },\n\n getMenu() {\n const ref = this.appendToBody ? this.$refs.portal.portalTarget : this\n const $menu = ref.$refs.menu.$refs.menu\n return $menu && $menu.nodeName !== '#comment' ? $menu : null\n },\n\n setCurrentHighlightedOption(node, scroll = true) {\n const prev = this.menu.current\n if (prev != null && prev in this.forest.nodeMap) {\n this.forest.nodeMap[prev].isHighlighted = false\n }\n\n this.menu.current = node.id\n node.isHighlighted = true\n\n if (this.menu.isOpen && scroll) {\n const scrollToOption = () => {\n const $menu = this.getMenu()\n const $option = $menu.querySelector(`.vue-treeselect__option[data-id=\"${node.id}\"]`)\n if ($option) scrollIntoView($menu, $option)\n }\n\n // In case `openMenu()` is just called and the menu is not rendered yet.\n if (this.getMenu()) {\n scrollToOption()\n } else {\n // istanbul ignore next\n this.$nextTick(scrollToOption)\n }\n }\n },\n\n resetHighlightedOptionWhenNecessary(forceReset = false) {\n const { current } = this.menu\n\n if (\n forceReset || current == null ||\n !(current in this.forest.nodeMap) ||\n !this.shouldShowOptionInMenu(this.getNode(current))\n ) {\n this.highlightFirstOption()\n }\n },\n\n highlightFirstOption() {\n if (!this.hasVisibleOptions) return\n\n const first = this.visibleOptionIds[0]\n this.setCurrentHighlightedOption(this.getNode(first))\n },\n\n highlightPrevOption() {\n if (!this.hasVisibleOptions) return\n\n const prev = this.visibleOptionIds.indexOf(this.menu.current) - 1\n if (prev === -1) return this.highlightLastOption()\n this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[prev]))\n },\n\n highlightNextOption() {\n if (!this.hasVisibleOptions) return\n\n const next = this.visibleOptionIds.indexOf(this.menu.current) + 1\n if (next === this.visibleOptionIds.length) return this.highlightFirstOption()\n this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[next]))\n },\n\n highlightLastOption() {\n if (!this.hasVisibleOptions) return\n\n const last = getLast(this.visibleOptionIds)\n this.setCurrentHighlightedOption(this.getNode(last))\n },\n\n resetSearchQuery() {\n this.trigger.searchQuery = ''\n },\n\n closeMenu() {\n if (!this.menu.isOpen || (!this.disabled && this.alwaysOpen)) return\n this.saveMenuScrollPosition()\n this.menu.isOpen = false\n this.toggleClickOutsideEvent(false)\n this.resetSearchQuery()\n this.$emit('close', this.getValue(), this.getInstanceId())\n },\n\n openMenu() {\n if (this.disabled || this.menu.isOpen) return\n this.menu.isOpen = true\n this.$nextTick(this.resetHighlightedOptionWhenNecessary)\n this.$nextTick(this.restoreMenuScrollPosition)\n if (!this.options && !this.async) this.loadRootOptions()\n this.toggleClickOutsideEvent(true)\n this.$emit('open', this.getInstanceId())\n },\n\n toggleMenu() {\n if (this.menu.isOpen) {\n this.closeMenu()\n } else {\n this.openMenu()\n }\n },\n\n toggleExpanded(node) {\n let nextState\n\n if (this.localSearch.active) {\n nextState = node.isExpandedOnSearch = !node.isExpandedOnSearch\n if (nextState) node.showAllChildrenOnSearch = true\n } else {\n nextState = node.isExpanded = !node.isExpanded\n }\n\n if (nextState && !node.childrenStates.isLoaded) {\n this.loadChildrenOptions(node)\n }\n },\n\n buildForestState() {\n const selectedNodeMap = createMap()\n this.forest.selectedNodeIds.forEach(selectedNodeId => {\n selectedNodeMap[selectedNodeId] = true\n })\n this.forest.selectedNodeMap = selectedNodeMap\n\n const checkedStateMap = createMap()\n if (this.multiple) {\n this.traverseAllNodesByIndex(node => {\n checkedStateMap[node.id] = UNCHECKED\n })\n\n this.selectedNodes.forEach(selectedNode => {\n checkedStateMap[selectedNode.id] = CHECKED\n\n if (!this.flat && !this.disableBranchNodes) {\n selectedNode.ancestors.forEach(ancestorNode => {\n if (!this.isSelected(ancestorNode)) {\n checkedStateMap[ancestorNode.id] = INDETERMINATE\n }\n })\n }\n })\n }\n this.forest.checkedStateMap = checkedStateMap\n },\n\n enhancedNormalizer(raw) {\n return {\n ...raw,\n ...this.normalizer(raw, this.getInstanceId()),\n }\n },\n\n normalize(parentNode, nodes, prevNodeMap) {\n let normalizedOptions = nodes\n .map(node => [ this.enhancedNormalizer(node), node ])\n .map(([ node, raw ], index) => {\n this.checkDuplication(node)\n this.verifyNodeShape(node)\n\n const { id, label, children, isDefaultExpanded } = node\n const isRootNode = parentNode === NO_PARENT_NODE\n const level = isRootNode ? 0 : parentNode.level + 1\n const isBranch = Array.isArray(children) || children === null\n const isLeaf = !isBranch\n const isDisabled = !!node.isDisabled || (!this.flat && !isRootNode && parentNode.isDisabled)\n const isNew = !!node.isNew\n const lowerCased = this.matchKeys.reduce((prev, key) => ({\n ...prev,\n [key]: stringifyOptionPropValue(node[key]).toLocaleLowerCase(),\n }), {})\n const nestedSearchLabel = isRootNode\n ? lowerCased.label\n : parentNode.nestedSearchLabel + ' ' + lowerCased.label\n\n const normalized = this.$set(this.forest.nodeMap, id, createMap())\n this.$set(normalized, 'id', id)\n this.$set(normalized, 'label', label)\n this.$set(normalized, 'level', level)\n this.$set(normalized, 'ancestors', isRootNode ? [] : [ parentNode ].concat(parentNode.ancestors))\n this.$set(normalized, 'index', (isRootNode ? [] : parentNode.index).concat(index))\n this.$set(normalized, 'parentNode', parentNode)\n this.$set(normalized, 'lowerCased', lowerCased)\n this.$set(normalized, 'nestedSearchLabel', nestedSearchLabel)\n this.$set(normalized, 'isDisabled', isDisabled)\n this.$set(normalized, 'isNew', isNew)\n this.$set(normalized, 'isMatched', false)\n this.$set(normalized, 'isHighlighted', false)\n this.$set(normalized, 'isBranch', isBranch)\n this.$set(normalized, 'isLeaf', isLeaf)\n this.$set(normalized, 'isRootNode', isRootNode)\n this.$set(normalized, 'raw', raw)\n\n if (isBranch) {\n const isLoaded = Array.isArray(children)\n\n this.$set(normalized, 'childrenStates', {\n ...createAsyncOptionsStates(),\n isLoaded,\n })\n this.$set(normalized, 'isExpanded', typeof isDefaultExpanded === 'boolean'\n ? isDefaultExpanded\n : level < this.defaultExpandLevel)\n this.$set(normalized, 'hasMatchedDescendants', false)\n this.$set(normalized, 'hasDisabledDescendants', false)\n this.$set(normalized, 'isExpandedOnSearch', false)\n this.$set(normalized, 'showAllChildrenOnSearch', false)\n this.$set(normalized, 'count', {\n [ALL_CHILDREN]: 0,\n [ALL_DESCENDANTS]: 0,\n [LEAF_CHILDREN]: 0,\n [LEAF_DESCENDANTS]: 0,\n })\n this.$set(normalized, 'children', isLoaded\n ? this.normalize(normalized, children, prevNodeMap)\n : [])\n\n if (isDefaultExpanded === true) normalized.ancestors.forEach(ancestor => {\n ancestor.isExpanded = true\n })\n\n if (!isLoaded && typeof this.loadOptions !== 'function') {\n warning(\n () => false,\n () => 'Unloaded branch node detected. \"loadOptions\" prop is required to load its children.',\n )\n } else if (!isLoaded && normalized.isExpanded) {\n this.loadChildrenOptions(normalized)\n }\n }\n\n normalized.ancestors.forEach(ancestor => ancestor.count[ALL_DESCENDANTS]++)\n if (isLeaf) normalized.ancestors.forEach(ancestor => ancestor.count[LEAF_DESCENDANTS]++)\n if (!isRootNode) {\n parentNode.count[ALL_CHILDREN] += 1\n if (isLeaf) parentNode.count[LEAF_CHILDREN] += 1\n if (isDisabled) parentNode.hasDisabledDescendants = true\n }\n\n // Preserve previous states.\n if (prevNodeMap && prevNodeMap[id]) {\n const prev = prevNodeMap[id]\n\n normalized.isMatched = prev.isMatched\n normalized.showAllChildrenOnSearch = prev.showAllChildrenOnSearch\n normalized.isHighlighted = prev.isHighlighted\n\n if (prev.isBranch && normalized.isBranch) {\n normalized.isExpanded = prev.isExpanded\n normalized.isExpandedOnSearch = prev.isExpandedOnSearch\n // #97\n // If `isLoaded` was true, but IS NOT now, we consider this branch node\n // to be reset to unloaded state by the user of this component.\n if (prev.childrenStates.isLoaded && !normalized.childrenStates.isLoaded) {\n // Make sure the node is collapsed, then the user can load its\n // children again (by expanding).\n normalized.isExpanded = false\n // We have reset `childrenStates` and don't want to preserve states here.\n } else {\n normalized.childrenStates = { ...prev.childrenStates }\n }\n }\n }\n\n return normalized\n })\n\n if (this.branchNodesFirst) {\n const branchNodes = normalizedOptions.filter(option => option.isBranch)\n const leafNodes = normalizedOptions.filter(option => option.isLeaf)\n normalizedOptions = branchNodes.concat(leafNodes)\n }\n\n return normalizedOptions\n },\n\n loadRootOptions() {\n this.callLoadOptionsProp({\n action: LOAD_ROOT_OPTIONS,\n isPending: () => {\n return this.rootOptionsStates.isLoading\n },\n start: () => {\n this.rootOptionsStates.isLoading = true\n this.rootOptionsStates.loadingError = ''\n },\n succeed: () => {\n this.rootOptionsStates.isLoaded = true\n // Wait for `options` being re-initialized.\n this.$nextTick(() => {\n this.resetHighlightedOptionWhenNecessary(true)\n })\n },\n fail: err => {\n this.rootOptionsStates.loadingError = getErrorMessage(err)\n },\n end: () => {\n this.rootOptionsStates.isLoading = false\n },\n })\n },\n\n loadChildrenOptions(parentNode) {\n // The options may be re-initialized anytime during the loading process.\n // So `parentNode` can be stale and we use `getNode()` to avoid that.\n\n const { id, raw } = parentNode\n\n this.callLoadOptionsProp({\n action: LOAD_CHILDREN_OPTIONS,\n args: {\n // We always pass the raw node instead of the normalized node to any\n // callback provided by the user of this component.\n // Because the shape of the raw node is more likely to be closing to\n // what the back-end API service of the application needs.\n parentNode: raw,\n },\n isPending: () => {\n return this.getNode(id).childrenStates.isLoading\n },\n start: () => {\n this.getNode(id).childrenStates.isLoading = true\n this.getNode(id).childrenStates.loadingError = ''\n },\n succeed: () => {\n this.getNode(id).childrenStates.isLoaded = true\n },\n fail: err => {\n this.getNode(id).childrenStates.loadingError = getErrorMessage(err)\n },\n end: () => {\n this.getNode(id).childrenStates.isLoading = false\n },\n })\n },\n\n callLoadOptionsProp({ action, args, isPending, start, succeed, fail, end }) {\n if (!this.loadOptions || isPending()) {\n return\n }\n\n start()\n\n const callback = once((err, result) => {\n if (err) {\n fail(err)\n } else {\n succeed(result)\n }\n\n end()\n })\n const result = this.loadOptions({\n id: this.getInstanceId(),\n instanceId: this.getInstanceId(),\n action,\n ...args,\n callback,\n })\n\n if (isPromise(result)) {\n result.then(() => {\n callback()\n }, err => {\n callback(err)\n }).catch(err => {\n // istanbul ignore next\n console.error(err)\n })\n }\n },\n\n checkDuplication(node) {\n warning(\n () => !((node.id in this.forest.nodeMap) && !this.forest.nodeMap[node.id].isFallbackNode),\n () => `Detected duplicate presence of node id ${JSON.stringify(node.id)}. ` +\n `Their labels are \"${this.forest.nodeMap[node.id].label}\" and \"${node.label}\" respectively.`,\n )\n },\n\n verifyNodeShape(node) {\n warning(\n () => !(node.children === undefined && node.isBranch === true),\n () => 'Are you meant to declare an unloaded branch node? ' +\n '`isBranch: true` is no longer supported, please use `children: null` instead.',\n )\n },\n\n select(node) {\n if (this.disabled || node.isDisabled) {\n return\n }\n\n if (this.single) {\n this.clear()\n }\n\n const nextState = this.multiple && !this.flat\n ? this.forest.checkedStateMap[node.id] === UNCHECKED\n : !this.isSelected(node)\n\n if (nextState) {\n this._selectNode(node)\n } else {\n this._deselectNode(node)\n }\n\n this.buildForestState()\n\n if (nextState) {\n this.$emit('select', node.raw, this.getInstanceId())\n } else {\n this.$emit('deselect', node.raw, this.getInstanceId())\n }\n\n if (this.localSearch.active && nextState && (this.single || this.clearOnSelect)) {\n this.resetSearchQuery()\n }\n\n if (this.single && this.closeOnSelect) {\n this.closeMenu()\n\n // istanbul ignore else\n if (this.searchable) {\n this._blurOnSelect = true\n }\n }\n },\n\n clear() {\n if (this.hasValue) {\n if (this.single || this.allowClearingDisabled) {\n this.forest.selectedNodeIds = []\n } else /* if (this.multiple && !this.allowClearingDisabled) */ {\n this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(nodeId =>\n this.getNode(nodeId).isDisabled,\n )\n }\n\n this.buildForestState()\n }\n },\n\n // This is meant to be called only by `select()`.\n _selectNode(node) {\n node.hasBeenSelected = node.id\n if (this.single || this.disableBranchNodes) {\n return this.addValue(node)\n }\n\n if (this.flat) {\n this.addValue(node)\n\n if (this.autoSelectAncestors) {\n node.ancestors.forEach(ancestor => {\n if (!this.isSelected(ancestor) && !ancestor.isDisabled) this.addValue(ancestor)\n })\n } else if (this.autoSelectDescendants) {\n this.traverseDescendantsBFS(node, descendant => {\n if (!this.isSelected(descendant) && !descendant.isDisabled) this.addValue(descendant)\n })\n }\n\n return\n }\n\n const isFullyChecked = (\n node.isLeaf ||\n (/* node.isBranch && */!node.hasDisabledDescendants) ||\n (/* node.isBranch && */this.allowSelectingDisabledDescendants)\n )\n if (isFullyChecked) {\n this.addValue(node)\n }\n\n if (node.isBranch) {\n this.traverseDescendantsBFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n this.addValue(descendant)\n }\n })\n }\n\n if (isFullyChecked) {\n let curr = node\n while ((curr = curr.parentNode) !== NO_PARENT_NODE) {\n if (curr.children.every(this.isSelected)) this.addValue(curr)\n else break\n }\n }\n },\n\n // This is meant to be called only by `select()`.\n _deselectNode(node) {\n if (this.disableBranchNodes) {\n return this.removeValue(node)\n }\n\n if (this.flat) {\n this.removeValue(node)\n\n if (this.autoDeselectAncestors) {\n node.ancestors.forEach(ancestor => {\n if (this.isSelected(ancestor) && !ancestor.isDisabled) this.removeValue(ancestor)\n })\n } else if (this.autoDeselectDescendants) {\n this.traverseDescendantsBFS(node, descendant => {\n if (this.isSelected(descendant) && !descendant.isDisabled) this.removeValue(descendant)\n })\n }\n\n return\n }\n\n let hasUncheckedSomeDescendants = false\n if (node.isBranch) {\n this.traverseDescendantsDFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n this.removeValue(descendant)\n hasUncheckedSomeDescendants = true\n }\n })\n }\n\n if (\n node.isLeaf ||\n /* node.isBranch && */hasUncheckedSomeDescendants ||\n /* node.isBranch && */node.children.length === 0\n ) {\n this.removeValue(node)\n\n let curr = node\n while ((curr = curr.parentNode) !== NO_PARENT_NODE) {\n if (this.isSelected(curr)) this.removeValue(curr)\n else break\n }\n }\n },\n\n addValue(node) {\n this.forest.selectedNodeIds.push(node.id)\n this.forest.selectedNodeMap[node.id] = true\n },\n\n removeValue(node) {\n delete node.hasBeenSelected\n removeFromArray(this.forest.selectedNodeIds, node.id)\n delete this.forest.selectedNodeMap[node.id]\n },\n\n removeLastValue() {\n if (!this.hasValue) return\n if (this.single) return this.clear()\n const lastValue = getLast(this.internalValue)\n const lastSelectedNode = this.getNode(lastValue)\n this.select(lastSelectedNode) // deselect\n },\n\n saveMenuScrollPosition() {\n const $menu = this.getMenu()\n // istanbul ignore else\n if ($menu) this.menu.lastScrollPosition = $menu.scrollTop\n },\n\n restoreMenuScrollPosition() {\n const $menu = this.getMenu()\n // istanbul ignore else\n if ($menu) $menu.scrollTop = this.menu.lastScrollPosition\n },\n },\n\n created() {\n this.verifyProps()\n this.resetFlags()\n },\n\n mounted() {\n if (this.autoFocus) this.focusInput()\n if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions()\n if (this.alwaysOpen) this.openMenu()\n if (this.async && this.defaultOptions) this.handleRemoteSearch()\n },\n\n destroyed() {\n // istanbul ignore next\n this.toggleClickOutsideEvent(false)\n },\n}\n","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./HiddenFields.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./HiddenFields.vue?vue&type=script&lang=js&\"","/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nexport default function normalizeComponent (\n scriptExports,\n render,\n staticRenderFns,\n functionalTemplate,\n injectStyles,\n scopeId,\n moduleIdentifier, /* server only */\n shadowMode /* vue-cli only */\n) {\n // Vue.extend constructor export interop\n var options = typeof scriptExports === 'function'\n ? scriptExports.options\n : scriptExports\n\n // render functions\n if (render) {\n options.render = render\n options.staticRenderFns = staticRenderFns\n options._compiled = true\n }\n\n // functional template\n if (functionalTemplate) {\n options.functional = true\n }\n\n // scopedId\n if (scopeId) {\n options._scopeId = 'data-v-' + scopeId\n }\n\n var hook\n if (moduleIdentifier) { // server build\n hook = function (context) {\n // 2.3 injection\n context =\n context || // cached call\n (this.$vnode && this.$vnode.ssrContext) || // stateful\n (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n // 2.2 with runInNewContext: true\n if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n context = __VUE_SSR_CONTEXT__\n }\n // inject component styles\n if (injectStyles) {\n injectStyles.call(this, context)\n }\n // register component module identifier for async chunk inferrence\n if (context && context._registeredComponents) {\n context._registeredComponents.add(moduleIdentifier)\n }\n }\n // used by ssr in case component is cached and beforeCreate\n // never gets called\n options._ssrRegister = hook\n } else if (injectStyles) {\n hook = shadowMode\n ? function () {\n injectStyles.call(\n this,\n (options.functional ? this.parent : this).$root.$options.shadowRoot\n )\n }\n : injectStyles\n }\n\n if (hook) {\n if (options.functional) {\n // for template-only hot-reload because in that case the render fn doesn't\n // go through the normalizer\n options._injectStyles = hook\n // register for functional component in vue file\n var originalRender = options.render\n options.render = function renderWithStyleInjection (h, context) {\n hook.call(context)\n return originalRender(h, context)\n }\n } else {\n // inject component registration as beforeCreate hook\n var existing = options.beforeCreate\n options.beforeCreate = existing\n ? [].concat(existing, hook)\n : [hook]\n }\n }\n\n return {\n exports: scriptExports,\n options: options\n }\n}\n","var render, staticRenderFns\nimport script from \"./HiddenFields.vue?vue&type=script&lang=js&\"\nexport * from \"./HiddenFields.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('4d48089a')) {\n api.createRecord('4d48089a', component.options)\n } else {\n api.reload('4d48089a', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/HiddenFields.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Input.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Input.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Input.vue?vue&type=script&lang=js&\"\nexport * from \"./Input.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('54844eca')) {\n api.createRecord('54844eca', component.options)\n } else {\n api.reload('54844eca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Input.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Placeholder.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Placeholder.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Placeholder.vue?vue&type=script&lang=js&\"\nexport * from \"./Placeholder.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('5a99d1f3')) {\n api.createRecord('5a99d1f3', component.options)\n } else {\n api.reload('5a99d1f3', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Placeholder.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SingleValue.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SingleValue.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./SingleValue.vue?vue&type=script&lang=js&\"\nexport * from \"./SingleValue.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('03d19b89')) {\n api.createRecord('03d19b89', component.options)\n } else {\n api.reload('03d19b89', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/SingleValue.vue\"\nexport default component.exports","var render = function () {\n var _vm = this\n var _h = _vm.$createElement\n var _c = _vm._self._c || _h\n return _c(\n \"svg\",\n {\n attrs: {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 348.333 348.333\",\n },\n },\n [\n _c(\"path\", {\n attrs: {\n d: \"M336.559 68.611L231.016 174.165l105.543 105.549c15.699 15.705 15.699 41.145 0 56.85-7.844 7.844-18.128 11.769-28.407 11.769-10.296 0-20.581-3.919-28.419-11.769L174.167 231.003 68.609 336.563c-7.843 7.844-18.128 11.769-28.416 11.769-10.285 0-20.563-3.919-28.413-11.769-15.699-15.698-15.699-41.139 0-56.85l105.54-105.549L11.774 68.611c-15.699-15.699-15.699-41.145 0-56.844 15.696-15.687 41.127-15.687 56.829 0l105.563 105.554L279.721 11.767c15.705-15.687 41.139-15.687 56.832 0 15.705 15.699 15.705 41.145.006 56.844z\",\n },\n }),\n ]\n )\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\nexport { render, staticRenderFns }","\n\n\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Delete.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Delete.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Delete.vue?vue&type=template&id=364b6320&\"\nimport script from \"./Delete.vue?vue&type=script&lang=js&\"\nexport * from \"./Delete.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('364b6320')) {\n api.createRecord('364b6320', component.options)\n } else {\n api.reload('364b6320', component.options)\n }\n module.hot.accept(\"./Delete.vue?vue&type=template&id=364b6320&\", function () {\n api.rerender('364b6320', {\n render: render,\n staticRenderFns: staticRenderFns\n })\n })\n }\n}\ncomponent.options.__file = \"src/components/icons/Delete.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MultiValueItem.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MultiValueItem.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./MultiValueItem.vue?vue&type=script&lang=js&\"\nexport * from \"./MultiValueItem.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('6dd6c8ca')) {\n api.createRecord('6dd6c8ca', component.options)\n } else {\n api.reload('6dd6c8ca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MultiValueItem.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MultiValue.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MultiValue.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./MultiValue.vue?vue&type=script&lang=js&\"\nexport * from \"./MultiValue.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('14fca5e8')) {\n api.createRecord('14fca5e8', component.options)\n } else {\n api.reload('14fca5e8', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MultiValue.vue\"\nexport default component.exports","var render = function () {\n var _vm = this\n var _h = _vm.$createElement\n var _c = _vm._self._c || _h\n return _c(\n \"svg\",\n {\n attrs: {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 292.362 292.362\",\n },\n },\n [\n _c(\"path\", {\n attrs: {\n d: \"M286.935 69.377c-3.614-3.617-7.898-5.424-12.848-5.424H18.274c-4.952 0-9.233 1.807-12.85 5.424C1.807 72.998 0 77.279 0 82.228c0 4.948 1.807 9.229 5.424 12.847l127.907 127.907c3.621 3.617 7.902 5.428 12.85 5.428s9.233-1.811 12.847-5.428L286.935 95.074c3.613-3.617 5.427-7.898 5.427-12.847 0-4.948-1.814-9.229-5.427-12.85z\",\n },\n }),\n ]\n )\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\nexport { render, staticRenderFns }","\n\n\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Arrow.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Arrow.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Arrow.vue?vue&type=template&id=11186cd4&\"\nimport script from \"./Arrow.vue?vue&type=script&lang=js&\"\nexport * from \"./Arrow.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('11186cd4')) {\n api.createRecord('11186cd4', component.options)\n } else {\n api.reload('11186cd4', component.options)\n }\n module.hot.accept(\"./Arrow.vue?vue&type=template&id=11186cd4&\", function () {\n api.rerender('11186cd4', {\n render: render,\n staticRenderFns: staticRenderFns\n })\n })\n }\n}\ncomponent.options.__file = \"src/components/icons/Arrow.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Control.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Control.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Control.vue?vue&type=script&lang=js&\"\nexport * from \"./Control.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('2fa0a0dd')) {\n api.createRecord('2fa0a0dd', component.options)\n } else {\n api.reload('2fa0a0dd', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Control.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Tip.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Tip.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Tip.vue?vue&type=script&lang=js&\"\nexport * from \"./Tip.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('9f31bdca')) {\n api.createRecord('9f31bdca', component.options)\n } else {\n api.reload('9f31bdca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Tip.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Option.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Option.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Option.vue?vue&type=script&lang=js&\"\nexport * from \"./Option.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('3dddec25')) {\n api.createRecord('3dddec25', component.options)\n } else {\n api.reload('3dddec25', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Option.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Menu.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Menu.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Menu.vue?vue&type=script&lang=js&\"\nexport * from \"./Menu.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('9bcc0be2')) {\n api.createRecord('9bcc0be2', component.options)\n } else {\n api.reload('9bcc0be2', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Menu.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MenuPortal.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MenuPortal.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./MenuPortal.vue?vue&type=script&lang=js&\"\nexport * from \"./MenuPortal.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('4802d94a')) {\n api.createRecord('4802d94a', component.options)\n } else {\n api.reload('4802d94a', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MenuPortal.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Treeselect.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Treeselect.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Treeselect.vue?vue&type=script&lang=js&\"\nexport * from \"./Treeselect.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('aebf116c')) {\n api.createRecord('aebf116c', component.options)\n } else {\n api.reload('aebf116c', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Treeselect.vue\"\nexport default component.exports","import Treeselect from './components/Treeselect'\nimport treeselectMixin from './mixins/treeselectMixin'\nimport './style.less'\n\nexport default Treeselect\nexport { Treeselect, treeselectMixin }\nexport {\n // Delayed loading.\n LOAD_ROOT_OPTIONS,\n LOAD_CHILDREN_OPTIONS,\n ASYNC_SEARCH,\n} from './constants'\n\nexport const VERSION = PKG_VERSION\n"],"sourceRoot":""} \ No newline at end of file diff --git a/dist/vue-treeselect.cjs.min.js b/dist/vue-treeselect.cjs.min.js new file mode 100644 index 00000000..0fa9cf80 --- /dev/null +++ b/dist/vue-treeselect.cjs.min.js @@ -0,0 +1,7 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2022 Riophae Lee + * Released under the MIT License. + * https://vue-treeselect.js.org/ + */ +module.exports=function(e){var t={};function n(i){if(t[i])return t[i].exports;var r=t[i]={i:i,l:!1,exports:{}};return e[i].call(r.exports,r,r.exports,n),r.l=!0,r.exports}return n.m=e,n.c=t,n.d=function(e,t,i){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:i})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var i=Object.create(null);if(n.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var r in e)n.d(i,r,function(t){return e[t]}.bind(null,r));return i},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="/",n(n.s=16)}([function(e,t){e.exports=require("@babel/runtime/helpers/defineProperty")},function(e,t){e.exports=require("babel-helper-vue-jsx-merge-props")},function(e,t){e.exports=require("@babel/runtime/helpers/toConsumableArray")},function(e,t){e.exports=require("lodash/noop")},function(e,t){e.exports=require("lodash/debounce")},function(e,t){e.exports=require("is-promise")},function(e,t){e.exports=require("lodash/once")},function(e,t){e.exports=require("lodash/identity")},function(e,t){e.exports=require("lodash/constant")},function(e,t){e.exports=require("lodash/last")},function(e,t){e.exports=require("@babel/runtime/helpers/slicedToArray")},function(e,t){e.exports=require("fuzzysearch")},function(e,t){e.exports=require("watch-size")},function(e,t){e.exports=require("@babel/runtime/helpers/typeof")},function(e,t){e.exports=require("vue")},function(e,t,n){},function(e,t,n){"use strict";n.r(t),n.d(t,"Treeselect",(function(){return it})),n.d(t,"treeselectMixin",(function(){return he})),n.d(t,"LOAD_ROOT_OPTIONS",(function(){return Q})),n.d(t,"LOAD_CHILDREN_OPTIONS",(function(){return Y})),n.d(t,"ASYNC_SEARCH",(function(){return K})),n.d(t,"VERSION",(function(){return rt}));var i=n(10),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(11),u=n.n(c),d=n(3),h=n.n(d).a;function p(e){return function(t){if("mousedown"===t.type&&0===t.button){for(var n=arguments.length,i=new Array(n>1?n-1:0),r=1;rn.bottom?e.scrollTop=Math.min(t.offsetTop+t.clientHeight-e.offsetHeight+r,e.scrollHeight):i.top-r0},single:function(){return!this.multiple},visibleOptionIds:function(){var e=this,t=[];return this.traverseAllNodesByIndex((function(n){if(e.localSearch.active&&!e.shouldOptionBeIncludedInSearchResult(n)||t.push(n.id),n.isBranch&&!e.shouldExpand(n))return!1})),t},hasVisibleOptions:function(){return 0!==this.visibleOptionIds.length},showCountOnSearchComputed:function(){return"boolean"==typeof this.showCountOnSearch?this.showCountOnSearch:this.showCount},hasBranchNodes:function(){return this.forest.normalizedOptions.some((function(e){return e.isBranch}))},shouldFlattenOptions:function(){return this.localSearch.active&&this.flattenSearchResults}},watch:{alwaysOpen:function(e){e?this.openMenu():this.closeMenu()},branchNodesFirst:function(){this.initialize()},disabled:function(e){e&&this.menu.isOpen?this.closeMenu():e||this.menu.isOpen||!this.alwaysOpen||this.openMenu()},flat:function(){this.initialize()},internalValue:function(e,t){q(e,t)&&this.$emit("input",this.getValue(),this.getInstanceId())},matchKeys:function(){this.initialize()},multiple:function(e){e&&this.buildForestState()},options:{handler:function(){this.async||(this.initialize(),this.rootOptionsStates.isLoaded=Array.isArray(this.options))},deep:!0,immediate:!0},"trigger.searchQuery":function(){this.async?this.handleRemoteSearch():this.handleLocalSearch(),this.$emit("search-change",this.trigger.searchQuery,this.getInstanceId())},value:function(){var e=this.extractCheckedNodeIdsFromValue();q(e,this.internalValue)&&this.fixSelectedNodeIds(e)}},methods:{verifyProps:function(){var e=this;if(h((function(){return!e.async||e.searchable}),(function(){return'For async search mode, the value of "searchable" prop must be true.'})),null!=this.options||this.loadOptions||h((function(){return!1}),(function(){return'Are you meant to dynamically load options? You need to use "loadOptions" prop.'})),this.flat&&h((function(){return e.multiple}),(function(){return'You are using flat mode. But you forgot to add "multiple=true"?'})),!this.flat){["autoSelectAncestors","autoSelectDescendants","autoDeselectAncestors","autoDeselectDescendants"].forEach((function(t){h((function(){return!e[t]}),(function(){return'"'.concat(t,'" only applies to flat mode.')}))}))}},resetFlags:function(){this._blurOnSelect=!1},initialize:function(){var e=this.async?this.getRemoteSearchEntry().options:this.options;if(Array.isArray(e)){var t=this.forest.nodeMap;this.forest.nodeMap=$(),this.keepDataOfSelectedNodes(t),this.forest.normalizedOptions=this.normalize(null,e,t),this.fixSelectedNodeIds(this.internalValue)}else this.forest.normalizedOptions=[]},getInstanceId:function(){return null==this.instanceId?this.id:this.instanceId},getValue:function(){var e=this;if("id"===this.valueFormat)return this.multiple?this.getUniqChildValues(this.internalValue.slice()):this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?this.getUniqChildValues(t):t[0]},getUniqChildValues:function(e){var t=this;return"BRANCH_PRIORITY"!==this.valueConsistsOf?e:e.map((function(e){var n=t.getNode(e);if(n.hasBeenSelected)return n.id;if(t.hasOneChild(n)){var i=[];if(t.traverseDescendantsBFS(n,(function(e){e.isDisabled&&!t.allowSelectingDisabledDescendants||e.hasBeenSelected&&i.push(e.id)})),i&&i.length)return i[0]}return e}))},hasOneChild:function(e){return e&&e.children&&1===e.children.length},getNode:function(e){return h((function(){return null!=e}),(function(){return"Invalid node id: ".concat(e)})),null==e?null:e in this.forest.nodeMap?this.forest.nodeMap[e]:this.createFallbackNode(e)},createFallbackNode:function(e){var t=this.extractNodeFromValue(e),n={id:e,label:this.enhancedNormalizer(t).label||"".concat(e," (unknown)"),ancestors:[],parentNode:null,isFallbackNode:!0,isRootNode:!0,isLeaf:!0,isBranch:!1,isDisabled:!1,isNew:!1,index:[-1],level:0,raw:t};return this.$set(this.forest.nodeMap,e,n)},extractCheckedNodeIdsFromValue:function(){var e=this;return null==this.value?[]:"id"===this.valueFormat?this.multiple?this.value.slice():[this.value]:(this.multiple?this.value:[this.value]).map((function(t){return e.enhancedNormalizer(t)})).map((function(e){return e.id}))},extractNodeFromValue:function(e){var t=this,n={id:e};return"id"===this.valueFormat?n:W(this.multiple?Array.isArray(this.value)?this.value:[]:this.value?[this.value]:[],(function(n){return n&&t.enhancedNormalizer(n).id===e}))||n},fixSelectedNodeIds:function(e){var t=this,n=[];if(this.single||this.flat||this.disableBranchNodes||"ALL"===this.valueConsistsOf)n=e;else if("BRANCH_PRIORITY"===this.valueConsistsOf)e.forEach((function(e){n.push(e);var i=t.getNode(e);i.isBranch&&t.traverseDescendantsBFS(i,(function(e){n.push(e.id)}))}));else if("LEAF_PRIORITY"===this.valueConsistsOf)for(var i=$(),r=e.slice();r.length;){var s=r.shift(),o=this.getNode(s);n.push(s),o.isRootNode||(o.parentNode.id in i||(i[o.parentNode.id]=o.parentNode.children.length),0==--i[o.parentNode.id]&&r.push(o.parentNode.id))}else if("ALL_WITH_INDETERMINATE"===this.valueConsistsOf)for(var a=$(),l=e.filter((function(e){var n=t.getNode(e);return n.isLeaf||0===n.children.length}));l.length;){var c=l.shift(),u=this.getNode(c);n.push(c),u.isRootNode||(u.parentNode.id in a||(a[u.parentNode.id]=u.parentNode.children.length),0==--a[u.parentNode.id]&&l.push(u.parentNode.id))}q(this.forest.selectedNodeIds,n)&&(this.forest.selectedNodeIds=n),this.buildForestState()},keepDataOfSelectedNodes:function(e){var t=this;this.forest.selectedNodeIds.forEach((function(n){if(e[n]){var i=oe(oe({},e[n]),{},{isFallbackNode:!0});t.$set(t.forest.nodeMap,n,i)}}))},isSelected:function(e){return!0===this.forest.selectedNodeMap[e.id]},traverseDescendantsBFS:function(e,t){if(e.isBranch)for(var n=e.children.slice();n.length;){var i=n[0];i.isBranch&&n.push.apply(n,o()(i.children)),t(i),n.shift()}},traverseDescendantsDFS:function(e,t){var n=this;e.isBranch&&e.children.forEach((function(e){n.traverseDescendantsDFS(e,t),t(e)}))},traverseAllNodesDFS:function(e){var t=this;this.forest.normalizedOptions.forEach((function(n){t.traverseDescendantsDFS(n,e),e(n)}))},traverseAllNodesByIndex:function(e){!function t(n){n.children.forEach((function(n){!1!==e(n)&&n.isBranch&&t(n)}))}({children:this.forest.normalizedOptions})},toggleClickOutsideEvent:function(e){e?document.addEventListener("mousedown",this.handleClickOutside,!1):document.removeEventListener("mousedown",this.handleClickOutside,!1)},getValueContainer:function(){return this.$refs.control.$refs["value-container"]},getInput:function(){return this.getValueContainer().$refs.input},focusInput:function(){this.getInput().focus()},blurInput:function(){this.getInput().blur()},handleMouseDown:p((function(e){(e.preventDefault(),e.stopPropagation(),this.disabled)||(this.getValueContainer().$el.contains(e.target)&&!this.menu.isOpen&&(this.openOnClick||this.trigger.isFocused)&&this.openMenu(),this._blurOnSelect?this.blurInput():this.focusInput(),this.resetFlags())})),handleClickOutside:function(e){this.$refs.wrapper&&!this.$refs.wrapper.contains(e.target)&&(this.blurInput(),this.closeMenu())},handleLocalSearch:function(){var e=this,t=this.trigger.searchQuery,n=function(){return e.resetHighlightedOptionWhenNecessary(!0)};if(!t)return this.localSearch.active=!1,n();this.localSearch.active=!0,this.localSearch.noResults=!0,this.traverseAllNodesDFS((function(t){var n;t.isBranch&&(t.isExpandedOnSearch=!1,t.showAllChildrenOnSearch=!1,t.isMatched=!1,t.hasMatchedDescendants=!1,e.$set(e.localSearch.countMap,t.id,(n={},l()(n,"ALL_CHILDREN",0),l()(n,"ALL_DESCENDANTS",0),l()(n,"LEAF_CHILDREN",0),l()(n,"LEAF_DESCENDANTS",0),n)))}));var i=le(t).trim().toLocaleLowerCase(),r=i.replace(/\s+/g," ").split(" ");this.traverseAllNodesDFS((function(t){e.searchNested&&r.length>1?t.isMatched=r.every((function(e){return ce(!1,e,t.nestedSearchLabel)})):t.isMatched=e.matchKeys.some((function(n){return ce(!e.disableFuzzyMatching,i,t.lowerCased[n])})),t.isMatched&&(e.localSearch.noResults=!1,t.ancestors.forEach((function(t){return e.localSearch.countMap[t.id].ALL_DESCENDANTS++})),t.isLeaf&&t.ancestors.forEach((function(t){return e.localSearch.countMap[t.id].LEAF_DESCENDANTS++})),null!==t.parentNode&&(e.localSearch.countMap[t.parentNode.id].ALL_CHILDREN+=1,t.isLeaf&&(e.localSearch.countMap[t.parentNode.id].LEAF_CHILDREN+=1))),(t.isMatched||t.isBranch&&t.isExpandedOnSearch)&&null!==t.parentNode&&(t.parentNode.isExpandedOnSearch=!0,t.parentNode.hasMatchedDescendants=!0)})),n()},handleRemoteSearch:function(){var e=this,t=this.trigger.searchQuery,n=this.getRemoteSearchEntry(),i=function(){e.initialize(),e.resetHighlightedOptionWhenNecessary(!0)};if((""===t||this.cacheOptions)&&n.isLoaded)return i();this.callLoadOptionsProp({action:K,args:{searchQuery:t},isPending:function(){return n.isLoading},start:function(){n.isLoading=!0,n.isLoaded=!1,n.loadingError=""},succeed:function(r){n.isLoaded=!0,n.options=r,e.trigger.searchQuery===t&&i()},fail:function(e){n.loadingError=ue(e)},end:function(){n.isLoading=!1}})},getRemoteSearchEntry:function(){var e=this,t=this.trigger.searchQuery,n=this.remoteSearch[t]||oe(oe({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{options:[]});if(this.$watch((function(){return n.options}),(function(){e.trigger.searchQuery===t&&e.initialize()}),{deep:!0}),""===t){if(Array.isArray(this.defaultOptions))return n.options=this.defaultOptions,n.isLoaded=!0,n;if(!0!==this.defaultOptions)return n.isLoaded=!0,n}return this.remoteSearch[t]||this.$set(this.remoteSearch,t,n),n},shouldExpand:function(e){return this.localSearch.active?e.isExpandedOnSearch:e.isExpanded},shouldOptionBeIncludedInSearchResult:function(e){return!!e.isMatched||(!(!e.isBranch||!e.hasMatchedDescendants||this.flattenSearchResults)||!(e.isRootNode||!e.parentNode.showAllChildrenOnSearch))},shouldShowOptionInMenu:function(e){return!(this.localSearch.active&&!this.shouldOptionBeIncludedInSearchResult(e))},getControl:function(){return this.$refs.control.$el},getMenu:function(){var e=(this.appendToBody?this.$refs.portal.portalTarget:this).$refs.menu.$refs.menu;return e&&"#comment"!==e.nodeName?e:null},setCurrentHighlightedOption:function(e){var t=this,n=!(arguments.length>1&&void 0!==arguments[1])||arguments[1],i=this.menu.current;if(null!=i&&i in this.forest.nodeMap&&(this.forest.nodeMap[i].isHighlighted=!1),this.menu.current=e.id,e.isHighlighted=!0,this.menu.isOpen&&n){var r=function(){var n=t.getMenu(),i=n.querySelector('.vue-treeselect__option[data-id="'.concat(e.id,'"]'));i&&f(n,i)};this.getMenu()?r():this.$nextTick(r)}},resetHighlightedOptionWhenNecessary:function(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0],t=this.menu.current;!e&&null!=t&&t in this.forest.nodeMap&&this.shouldShowOptionInMenu(this.getNode(t))||this.highlightFirstOption()},highlightFirstOption:function(){if(this.hasVisibleOptions){var e=this.visibleOptionIds[0];this.setCurrentHighlightedOption(this.getNode(e))}},highlightPrevOption:function(){if(this.hasVisibleOptions){var e=this.visibleOptionIds.indexOf(this.menu.current)-1;if(-1===e)return this.highlightLastOption();this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[e]))}},highlightNextOption:function(){if(this.hasVisibleOptions){var e=this.visibleOptionIds.indexOf(this.menu.current)+1;if(e===this.visibleOptionIds.length)return this.highlightFirstOption();this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[e]))}},highlightLastOption:function(){if(this.hasVisibleOptions){var e=H()(this.visibleOptionIds);this.setCurrentHighlightedOption(this.getNode(e))}},resetSearchQuery:function(){this.trigger.searchQuery=""},closeMenu:function(){!this.menu.isOpen||!this.disabled&&this.alwaysOpen||(this.saveMenuScrollPosition(),this.menu.isOpen=!1,this.toggleClickOutsideEvent(!1),this.resetSearchQuery(),this.$emit("close",this.getValue(),this.getInstanceId()))},openMenu:function(){this.disabled||this.menu.isOpen||(this.menu.isOpen=!0,this.$nextTick(this.resetHighlightedOptionWhenNecessary),this.$nextTick(this.restoreMenuScrollPosition),this.options||this.async||this.loadRootOptions(),this.toggleClickOutsideEvent(!0),this.$emit("open",this.getInstanceId()))},toggleMenu:function(){this.menu.isOpen?this.closeMenu():this.openMenu()},toggleExpanded:function(e){var t;this.localSearch.active?(t=e.isExpandedOnSearch=!e.isExpandedOnSearch)&&(e.showAllChildrenOnSearch=!0):t=e.isExpanded=!e.isExpanded,t&&!e.childrenStates.isLoaded&&this.loadChildrenOptions(e)},buildForestState:function(){var e=this,t=$();this.forest.selectedNodeIds.forEach((function(e){t[e]=!0})),this.forest.selectedNodeMap=t;var n=$();this.multiple&&(this.traverseAllNodesByIndex((function(e){n[e.id]=0})),this.selectedNodes.forEach((function(t){n[t.id]=2,e.flat||e.disableBranchNodes||t.ancestors.forEach((function(t){e.isSelected(t)||(n[t.id]=1)}))}))),this.forest.checkedStateMap=n},enhancedNormalizer:function(e){return oe(oe({},e),this.normalizer(e,this.getInstanceId()))},normalize:function(e,t,n){var i=this,s=t.map((function(e){return[i.enhancedNormalizer(e),e]})).map((function(t,s){var o=r()(t,2),a=o[0],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,p=a.children,f=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(p)||null===p,S=!g,O=!!a.isDisabled||!i.flat&&!v&&e.isDisabled,y=!!a.isNew,b=i.matchKeys.reduce((function(e,t){return oe(oe({},e),{},l()({},t,(n=a[t],"string"==typeof n?le(n):"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?b.label:e.nestedSearchLabel+" "+b.label,N=i.$set(i.forest.nodeMap,u,$());if(i.$set(N,"id",u),i.$set(N,"label",d),i.$set(N,"level",m),i.$set(N,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(N,"index",(v?[]:e.index).concat(s)),i.$set(N,"parentNode",e),i.$set(N,"lowerCased",b),i.$set(N,"nestedSearchLabel",_),i.$set(N,"isDisabled",O),i.$set(N,"isNew",y),i.$set(N,"isMatched",!1),i.$set(N,"isHighlighted",!1),i.$set(N,"isBranch",g),i.$set(N,"isLeaf",S),i.$set(N,"isRootNode",v),i.$set(N,"raw",c),g){var E,L=Array.isArray(p);i.$set(N,"childrenStates",oe(oe({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(N,"isExpanded","boolean"==typeof f?f:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=Qe[e.openDirection]:e.menu.placement=l||!c?"bottom":"top":e.closeMenu()}},setupMenuSizeWatcher:function(){var e=this.instance.getMenu();this.menuSizeWatcher||(this.menuSizeWatcher={remove:E(e,this.adjustMenuOpenDirection)})},setupMenuResizeAndScrollEventListeners:function(){var e=this.instance.getControl();this.menuResizeAndScrollEventListeners||(this.menuResizeAndScrollEventListeners={remove:C(e,this.adjustMenuOpenDirection)})},removeMenuSizeWatcher:function(){this.menuSizeWatcher&&(this.menuSizeWatcher.remove(),this.menuSizeWatcher=null)},removeMenuResizeAndScrollEventListeners:function(){this.menuResizeAndScrollEventListeners&&(this.menuResizeAndScrollEventListeners.remove(),this.menuResizeAndScrollEventListeners=null)}},render:function(){var e=arguments[0];return e("div",{ref:"menu-container",class:"vue-treeselect__menu-container",style:this.menuContainerStyle},[e("transition",{attrs:{name:"vue-treeselect__menu--transition"}},[this.renderMenu()])])}},void 0,void 0,!1,null,null,null);Ye.options.__file="src/components/Menu.vue";var Ke=Ye.exports,Xe=n(14),Ue=n.n(Xe);function Je(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var i=Object.getOwnPropertySymbols(e);t&&(i=i.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,i)}return n}var Ge,Ze={name:"vue-treeselect--portal-target",inject:["instance"],watch:{"instance.menu.isOpen":function(e){e?this.setupHandlers():this.removeHandlers()},"instance.menu.placement":function(){this.updateMenuContainerOffset()}},created:function(){this.controlResizeAndScrollEventListeners=null,this.controlSizeWatcher=null},mounted:function(){this.instance.menu.isOpen&&this.setupHandlers()},methods:{setupHandlers:function(){this.updateWidth(),this.updateMenuContainerOffset(),this.setupControlResizeAndScrollEventListeners(),this.setupControlSizeWatcher()},removeHandlers:function(){this.removeControlResizeAndScrollEventListeners(),this.removeControlSizeWatcher()},setupControlResizeAndScrollEventListeners:function(){var e=this.instance.getControl();this.controlResizeAndScrollEventListeners||(this.controlResizeAndScrollEventListeners={remove:C(e,this.updateMenuContainerOffset)})},setupControlSizeWatcher:function(){var e=this,t=this.instance.getControl();this.controlSizeWatcher||(this.controlSizeWatcher={remove:E(t,(function(){e.updateWidth(),e.updateMenuContainerOffset()}))})},removeControlResizeAndScrollEventListeners:function(){this.controlResizeAndScrollEventListeners&&(this.controlResizeAndScrollEventListeners.remove(),this.controlResizeAndScrollEventListeners=null)},removeControlSizeWatcher:function(){this.controlSizeWatcher&&(this.controlSizeWatcher.remove(),this.controlSizeWatcher=null)},updateWidth:function(){var e=this.instance,t=this.$el,n=e.getControl().getBoundingClientRect();t.style.width=n.width+"px"},updateMenuContainerOffset:function(){var e=this.instance,t=e.getControl(),n=this.$el,i=t.getBoundingClientRect(),r=n.getBoundingClientRect(),s="bottom"===e.menu.placement?i.height:0,o=Math.round(i.left-r.left)+"px",a=Math.round(i.top-r.top+s)+"px";this.$refs.menu.$refs["menu-container"].style[W(["transform","webkitTransform","MozTransform","msTransform"],(function(e){return e in document.body.style}))]="translate(".concat(o,", ").concat(a,")")}},render:function(){var e=arguments[0],t=this.instance,n=["vue-treeselect__portal-target",t.wrapperClass],i={zIndex:t.zIndex};return e("div",{class:n,style:i,attrs:{"data-instance-id":t.getInstanceId()}},[e(Ke,{ref:"menu"})])},destroyed:function(){this.removeHandlers()}},et=fe({name:"vue-treeselect--menu-portal",created:function(){this.portalTarget=null},mounted:function(){this.setup()},destroyed:function(){this.teardown()},methods:{setup:function(){var e=document.createElement("div");document.body.appendChild(e),this.portalTarget=new Ue.a(function(e){for(var t=1;t scrollingReact.bottom) {\n $scrollingEl.scrollTop = Math.min(\n $focusedEl.offsetTop + $focusedEl.clientHeight - $scrollingEl.offsetHeight + overScroll,\n $scrollingEl.scrollHeight,\n )\n } else if (focusedRect.top - overScroll < scrollingReact.top) {\n $scrollingEl.scrollTop = Math.max($focusedEl.offsetTop - overScroll, 0)\n }\n}\n","import watchSizeForBrowsersOtherThanIE9 from 'watch-size'\nimport { removeFromArray } from './removeFromArray'\n\nlet intervalId\nconst registered = []\nconst INTERVAL_DURATION = 100\n\nfunction run() {\n intervalId = setInterval(() => {\n registered.forEach(test)\n }, INTERVAL_DURATION)\n}\n\nfunction stop() {\n clearInterval(intervalId)\n intervalId = null\n}\n\nfunction test(item) {\n const { $el, listener, lastWidth, lastHeight } = item\n const width = $el.offsetWidth\n const height = $el.offsetHeight\n\n if (lastWidth !== width || lastHeight !== height) {\n item.lastWidth = width\n item.lastHeight = height\n\n listener({ width, height })\n }\n}\n\nfunction watchSizeForIE9($el, listener) {\n const item = {\n $el,\n listener,\n lastWidth: null,\n lastHeight: null,\n }\n const unwatch = () => {\n removeFromArray(registered, item)\n if (!registered.length) stop()\n }\n\n registered.push(item)\n // The original watch-size will call the listener on initialization.\n // Keep the same behavior here.\n test(item)\n run()\n\n return unwatch\n}\n\nexport function watchSize($el, listener) {\n // See: https://stackoverflow.com/a/31293352\n const isIE9 = document.documentMode === 9\n // watch-size will call the listener on initialization.\n // Disable this behavior with a lock to achieve a clearer code logic.\n let locked = true\n const wrappedListener = (...args) => locked || listener(...args)\n const implementation = isIE9\n ? watchSizeForIE9\n : watchSizeForBrowsersOtherThanIE9\n const removeSizeWatcher = implementation($el, wrappedListener)\n locked = false // unlock after initialization\n\n return removeSizeWatcher\n}\n","export function removeFromArray(arr, elem) {\n const idx = arr.indexOf(elem)\n if (idx !== -1) arr.splice(idx, 1)\n}\n","function findScrollParents($el) {\n const $scrollParents = []\n let $parent = $el.parentNode\n\n while ($parent && $parent.nodeName !== 'BODY' && $parent.nodeType === document.ELEMENT_NODE) {\n if (isScrollElment($parent)) $scrollParents.push($parent)\n $parent = $parent.parentNode\n }\n $scrollParents.push(window)\n\n return $scrollParents\n}\n\nfunction isScrollElment($el) {\n // Firefox wants us to check `-x` and `-y` variations as well\n const { overflow, overflowX, overflowY } = getComputedStyle($el)\n return /(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)\n}\n\nexport function setupResizeAndScrollEventListeners($el, listener) {\n const $scrollParents = findScrollParents($el)\n\n window.addEventListener('resize', listener, { passive: true })\n $scrollParents.forEach(scrollParent => {\n scrollParent.addEventListener('scroll', listener, { passive: true })\n })\n\n return function removeEventListeners() {\n window.removeEventListener('resize', listener, { passive: true })\n $scrollParents.forEach($scrollParent => {\n $scrollParent.removeEventListener('scroll', listener, { passive: true })\n })\n }\n}\n","export function isNaN(x) {\n return x !== x\n}\n","export const createMap = () => Object.create(null)\n","function isPlainObject(value) {\n if (value == null || typeof value !== 'object') return false\n return Object.getPrototypeOf(value) === Object.prototype\n}\n\nfunction copy(obj, key, value) {\n if (isPlainObject(value)) {\n obj[key] || (obj[key] = {})\n deepExtend(obj[key], value)\n } else {\n obj[key] = value\n }\n}\n\nexport function deepExtend(target, source) {\n if (isPlainObject(source)) {\n const keys = Object.keys(source)\n\n for (let i = 0, len = keys.length; i < len; i++) {\n copy(target, keys[i], source[keys[i]])\n }\n }\n\n return target\n}\n","export function includes(arrOrStr, elem) {\n return arrOrStr.indexOf(elem) !== -1\n}\n","export function find(arr, predicate, ctx) {\n for (let i = 0, len = arr.length; i < len; i++) {\n if (predicate.call(ctx, arr[i], i, arr)) return arr[i]\n }\n return undefined\n}\n","export function quickDiff(arrA, arrB) {\n if (arrA.length !== arrB.length) return true\n\n for (let i = 0; i < arrA.length; i++) {\n if (arrA[i] !== arrB[i]) return true\n }\n\n return false\n}\n","// Magic value that indicates a root level node.\nexport const NO_PARENT_NODE = null\n\n// Types of checked state.\nexport const UNCHECKED = 0\nexport const INDETERMINATE = 1\nexport const CHECKED = 2\n\n// Types of count number.\nexport const ALL_CHILDREN = 'ALL_CHILDREN'\nexport const ALL_DESCENDANTS = 'ALL_DESCENDANTS'\nexport const LEAF_CHILDREN = 'LEAF_CHILDREN'\nexport const LEAF_DESCENDANTS = 'LEAF_DESCENDANTS'\n\n// Action types of delayed loading.\nexport const LOAD_ROOT_OPTIONS = 'LOAD_ROOT_OPTIONS'\nexport const LOAD_CHILDREN_OPTIONS = 'LOAD_CHILDREN_OPTIONS'\nexport const ASYNC_SEARCH = 'ASYNC_SEARCH'\n\n// Acceptable values of `valueConsistsOf` prop.\nexport const ALL = 'ALL'\nexport const BRANCH_PRIORITY = 'BRANCH_PRIORITY'\nexport const LEAF_PRIORITY = 'LEAF_PRIORITY'\nexport const ALL_WITH_INDETERMINATE = 'ALL_WITH_INDETERMINATE'\n\n// Acceptable values of `sortValueBy` prop.\nexport const ORDER_SELECTED = 'ORDER_SELECTED'\nexport const LEVEL = 'LEVEL'\nexport const INDEX = 'INDEX'\n\n// Key codes look-up table.\nexport const KEY_CODES = {\n BACKSPACE: 8,\n ENTER: 13,\n ESCAPE: 27,\n END: 35,\n HOME: 36,\n ARROW_LEFT: 37,\n ARROW_UP: 38,\n ARROW_RIGHT: 39,\n ARROW_DOWN: 40,\n DELETE: 46,\n}\n\n// Other constants.\nexport const INPUT_DEBOUNCE_DELAY = process.env.NODE_ENV === 'testing'\n ? /* to speed up unit testing */ 10\n : /* istanbul ignore next */ 200\nexport const MIN_INPUT_WIDTH = 5\nexport const MENU_BUFFER = 40\n","import fuzzysearch from 'fuzzysearch'\n\nimport {\n warning,\n onLeftClick, scrollIntoView,\n isNaN, isPromise, once,\n identity, constant, createMap,\n quickDiff, last as getLast, includes, find, removeFromArray,\n} from '../utils'\n\nimport {\n NO_PARENT_NODE,\n UNCHECKED, INDETERMINATE, CHECKED,\n LOAD_ROOT_OPTIONS, LOAD_CHILDREN_OPTIONS, ASYNC_SEARCH,\n ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE,\n ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS,\n ORDER_SELECTED, LEVEL, INDEX,\n} from '../constants'\n\nfunction sortValueByIndex(a, b) {\n let i = 0\n do {\n if (a.level < i) return -1\n if (b.level < i) return 1\n if (a.index[i] !== b.index[i]) return a.index[i] - b.index[i]\n i++\n } while (true)\n}\n\nfunction sortValueByLevel(a, b) {\n return a.level === b.level\n ? sortValueByIndex(a, b)\n : a.level - b.level\n}\n\nfunction createAsyncOptionsStates() {\n return {\n isLoaded: false,\n isLoading: false,\n loadingError: '',\n }\n}\n\nfunction stringifyOptionPropValue(value) {\n if (typeof value === 'string') return removeAccents(value)\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\n}\nfunction removeAccents(str) {\n if (!str) return ''\n return str.normalize('NFD').replace(/[\\u0300-\\u036F]/g, '')\n}\n\nfunction match(enableFuzzyMatch, needle, haystack) {\n return enableFuzzyMatch\n ? fuzzysearch(needle, haystack)\n : includes(haystack, needle)\n}\n\nfunction getErrorMessage(err) {\n return err.message || /* istanbul ignore next */String(err)\n}\n\nlet instanceId = 0\n\nexport default {\n provide() {\n return {\n // Enable access to the instance of root component of vue-treeselect\n // across hierarchy.\n instance: this,\n }\n },\n\n props: {\n /**\n * Whether to allow resetting value even if there are disabled selected nodes.\n */\n allowClearingDisabled: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When an ancestor node is selected/deselected, whether its disabled descendants should be selected/deselected.\n * You may want to use this in conjunction with `allowClearingDisabled` prop.\n */\n allowSelectingDisabledDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether the menu should be always open.\n */\n alwaysOpen: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Append the menu to ?\n */\n appendToBody: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether to enable async search mode.\n */\n async: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Automatically focus the component on mount?\n */\n autoFocus: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Automatically load root options on mount. When set to `false`, root options will be loaded when the menu is opened.\n */\n autoLoadRootOptions: {\n type: Boolean,\n default: true,\n },\n\n /**\n * When user deselects a node, automatically deselect its ancestors. Applies to flat mode only.\n */\n autoDeselectAncestors: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user deselects a node, automatically deselect its descendants. Applies to flat mode only.\n */\n autoDeselectDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user selects a node, automatically select its ancestors. Applies to flat mode only.\n */\n autoSelectAncestors: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user selects a node, automatically select its descendants. Applies to flat mode only.\n */\n autoSelectDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether pressing backspace key removes the last item if there is no text input.\n */\n backspaceRemoves: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Function that processes before clearing all input fields.\n * Return `false` to prevent value from being cleared.\n * @type {function(): (boolean|Promise)}\n */\n beforeClearAll: {\n type: Function,\n default: constant(true),\n },\n\n /**\n * Show branch nodes before leaf nodes?\n */\n branchNodesFirst: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Should cache results of every search request?\n */\n cacheOptions: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Show an \"×\" button that resets value?\n */\n clearable: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Title for the \"×\" button when `multiple: true`.\n */\n clearAllText: {\n type: String,\n default: 'Clear all',\n },\n\n /**\n * Whether to clear the search input after selecting.\n * Use only when `multiple` is `true`.\n * For single-select mode, it **always** clears the input after selecting an option regardless of the prop value.\n */\n clearOnSelect: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Title for the \"×\" button.\n */\n clearValueText: {\n type: String,\n default: 'Clear value',\n },\n\n /**\n * Whether to close the menu after selecting an option?\n * Use only when `multiple` is `true`.\n */\n closeOnSelect: {\n type: Boolean,\n default: true,\n },\n\n /**\n * How many levels of branch nodes should be automatically expanded when loaded.\n * Set `Infinity` to make all branch nodes expanded by default.\n */\n defaultExpandLevel: {\n type: Number,\n default: 0,\n },\n\n /**\n * The default set of options to show before the user starts searching. Used for async search mode.\n * When set to `true`, the results for search query as a empty string will be autoloaded.\n * @type {boolean|node[]}\n */\n defaultOptions: {\n default: false,\n },\n\n /**\n * Whether pressing delete key removes the last item if there is no text input.\n */\n deleteRemoves: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Delimiter to use to join multiple values for the hidden field value.\n */\n delimiter: {\n type: String,\n default: ',',\n },\n\n /**\n * Only show the nodes that match the search value directly, excluding its ancestors.\n *\n * @type {Object}\n */\n flattenSearchResults: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Prevent branch nodes from being selected?\n */\n disableBranchNodes: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Disable the control?\n */\n disabled: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Disable the fuzzy matching functionality?\n */\n disableFuzzyMatching: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether to enable flat mode or not. Non-flat mode (default) means:\n * - Whenever a branch node gets checked, all its children will be checked too\n * - Whenever a branch node has all children checked, the branch node itself will be checked too\n * Set `true` to disable this mechanism\n */\n flat: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Will be passed with all events as the last param.\n * Useful for identifying events origin.\n */\n instanceId: {\n // Add two trailing \"$\" to distinguish from explictly specified ids.\n default: () => `${instanceId++}$$`,\n type: [ String, Number ],\n },\n\n /**\n * Joins multiple values into a single form field with the `delimiter` (legacy mode).\n */\n joinValues: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Limit the display of selected options.\n * The rest will be hidden within the limitText string.\n */\n limit: {\n type: Number,\n default: Infinity,\n },\n\n /**\n * Function that processes the message shown when selected elements pass the defined limit.\n * @type {function(number): string}\n */\n limitText: {\n type: Function,\n default: function limitTextDefault(count) { // eslint-disable-line func-name-matching\n return `and ${count} more`\n },\n },\n\n /**\n * Text displayed when loading options.\n */\n loadingText: {\n type: String,\n default: 'Loading...',\n },\n\n /**\n * Used for dynamically loading options.\n * @type {function({action: string, callback: (function((Error|string)=): void), parentNode: node=, instanceId}): void}\n */\n loadOptions: {\n type: Function,\n },\n\n /**\n * Which node properties to filter on.\n */\n matchKeys: {\n type: Array,\n default: constant([ 'label' ]),\n },\n\n /**\n * Sets `maxHeight` style value of the menu.\n */\n maxHeight: {\n type: Number,\n default: 300,\n },\n\n /**\n * Set `true` to allow selecting multiple options (a.k.a., multi-select mode).\n */\n multiple: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Generates a hidden tag with this field name for html forms.\n */\n name: {\n type: String,\n },\n\n /**\n * Text displayed when a branch node has no children.\n */\n noChildrenText: {\n type: String,\n default: 'No sub-options.',\n },\n\n /**\n * Text displayed when there are no available options.\n */\n noOptionsText: {\n type: String,\n default: 'No options available.',\n },\n\n /**\n * Text displayed when there are no matching search results.\n */\n noResultsText: {\n type: String,\n default: 'No results found...',\n },\n\n /**\n * Used for normalizing source data.\n * @type {function(node, instanceId): node}\n */\n normalizer: {\n type: Function,\n default: identity,\n },\n\n /**\n * By default (`auto`), the menu will open below the control. If there is not\n * enough space, vue-treeselect will automatically flip the menu.\n * You can use one of other four options to force the menu to be always opened\n * to specified direction.\n * Acceptable values:\n * - `\"auto\"`\n * - `\"below\"`\n * - `\"bottom\"`\n * - `\"above\"`\n * - `\"top\"`\n */\n openDirection: {\n type: String,\n default: 'auto',\n validator(value) {\n const acceptableValues = [ 'auto', 'top', 'bottom', 'above', 'below' ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Whether to automatically open the menu when the control is clicked.\n */\n openOnClick: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Whether to automatically open the menu when the control is focused.\n */\n openOnFocus: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Array of available options.\n * @type {node[]}\n */\n options: {\n type: Array,\n },\n\n /**\n * Field placeholder, displayed when there's no value.\n */\n placeholder: {\n type: String,\n default: 'Select...',\n },\n\n /**\n * Applies HTML5 required attribute when needed.\n */\n required: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Text displayed asking user whether to retry loading children options.\n */\n retryText: {\n type: String,\n default: 'Retry?',\n },\n\n /**\n * Title for the retry button.\n */\n retryTitle: {\n type: String,\n default: 'Click to retry',\n },\n\n /**\n * Enable searching feature?\n */\n searchable: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Search in ancestor nodes too.\n */\n searchNested: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Text tip to prompt for async search.\n */\n searchPromptText: {\n type: String,\n default: 'Type to search...',\n },\n\n /**\n * Whether to show a children count next to the label of each branch node.\n */\n showCount: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Used in conjunction with `showCount` to specify which type of count number should be displayed.\n * Acceptable values:\n * - \"ALL_CHILDREN\"\n * - \"ALL_DESCENDANTS\"\n * - \"LEAF_CHILDREN\"\n * - \"LEAF_DESCENDANTS\"\n */\n showCountOf: {\n type: String,\n default: ALL_CHILDREN,\n validator(value) {\n const acceptableValues = [ ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Whether to show children count when searching.\n * Fallbacks to the value of `showCount` when not specified.\n * @type {boolean}\n */\n showCountOnSearch: null,\n\n /**\n * In which order the selected options should be displayed in trigger & sorted in `value` array.\n * Used for multi-select mode only.\n * Acceptable values:\n * - \"ORDER_SELECTED\"\n * - \"LEVEL\"\n * - \"INDEX\"\n */\n sortValueBy: {\n type: String,\n default: ORDER_SELECTED,\n validator(value) {\n const acceptableValues = [ ORDER_SELECTED, LEVEL, INDEX ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Tab index of the control.\n */\n tabIndex: {\n type: Number,\n default: 0,\n },\n\n /**\n * The value of the control.\n * Should be `id` or `node` object for single-select mode, or an array of `id` or `node` object for multi-select mode.\n * Its format depends on the `valueFormat` prop.\n * For most cases, just use `v-model` instead.\n * @type {?Array}\n */\n value: null,\n\n /**\n * Which kind of nodes should be included in the `value` array in multi-select mode.\n * Acceptable values:\n * - \"ALL\" - Any node that is checked will be included in the `value` array\n * - \"BRANCH_PRIORITY\" (default) - If a branch node is checked, all its descendants will be excluded in the `value` array\n * - \"LEAF_PRIORITY\" - If a branch node is checked, this node itself and its branch descendants will be excluded from the `value` array but its leaf descendants will be included\n * - \"ALL_WITH_INDETERMINATE\" - Any node that is checked will be included in the `value` array, plus indeterminate nodes\n */\n valueConsistsOf: {\n type: String,\n default: BRANCH_PRIORITY,\n validator(value) {\n const acceptableValues = [ ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Format of `value` prop.\n * Note that, when set to `\"object\"`, only `id` & `label` properties are required in each `node` object in `value` prop.\n * Acceptable values:\n * - \"id\"\n * - \"object\"\n */\n valueFormat: {\n type: String,\n default: 'id',\n },\n\n /**\n * z-index of the menu.\n */\n zIndex: {\n type: [ Number, String ],\n default: 999,\n },\n },\n\n data() {\n return {\n trigger: {\n // Is the control focused?\n isFocused: false,\n // User entered search query - value of the input.\n searchQuery: '',\n },\n\n menu: {\n // Is the menu opened?\n isOpen: false,\n // Id of current highlighted option.\n current: null,\n // The scroll position before last menu closing.\n lastScrollPosition: 0,\n // Which direction to open the menu.\n placement: 'bottom',\n },\n\n forest: {\n // Normalized options.\n normalizedOptions: [],\n // map for quick look-up.\n nodeMap: createMap(),\n // map, used for multi-select mode.\n checkedStateMap: createMap(),\n // Id list of all selected options.\n selectedNodeIds: this.extractCheckedNodeIdsFromValue(),\n // map for fast checking:\n // if (forest.selectedNodeIds.indexOf(id) !== -1) forest.selectedNodeMap[id] === true\n selectedNodeMap: createMap(),\n },\n\n // States of root options.\n rootOptionsStates: createAsyncOptionsStates(),\n\n localSearch: {\n // Has user entered any query to search local options?\n active: false,\n // Has any options matched the search query?\n noResults: true,\n // map for counting matched children/descendants.\n countMap: createMap(),\n },\n\n // map.\n remoteSearch: createMap(),\n }\n },\n\n computed: {\n /* eslint-disable valid-jsdoc */\n /**\n * Normalized nodes that have been selected.\n * @type {node[]}\n */\n selectedNodes() {\n return this.forest.selectedNodeIds.map(this.getNode)\n },\n /**\n * Id list of selected nodes with `sortValueBy` prop applied.\n * @type {nodeId[]}\n */\n internalValue() {\n let internalValue\n\n // istanbul ignore else\n if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) {\n internalValue = this.forest.selectedNodeIds.slice()\n } else if (this.valueConsistsOf === BRANCH_PRIORITY) {\n internalValue = this.forest.selectedNodeIds.filter(id => {\n const node = this.getNode(id)\n if (node.isRootNode) return true\n return !this.isSelected(node.parentNode)\n })\n } else if (this.valueConsistsOf === LEAF_PRIORITY) {\n internalValue = this.forest.selectedNodeIds.filter(id => {\n const node = this.getNode(id)\n if (node.isLeaf) return true\n return node.children.length === 0\n })\n } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) {\n const indeterminateNodeIds = []\n internalValue = this.forest.selectedNodeIds.slice()\n this.selectedNodes.forEach(selectedNode => {\n selectedNode.ancestors.forEach(ancestor => {\n if (includes(indeterminateNodeIds, ancestor.id)) return\n if (includes(internalValue, ancestor.id)) return\n indeterminateNodeIds.push(ancestor.id)\n })\n })\n internalValue.push(...indeterminateNodeIds)\n }\n\n if (this.sortValueBy === LEVEL) {\n internalValue.sort((a, b) => sortValueByLevel(this.getNode(a), this.getNode(b)))\n } else if (this.sortValueBy === INDEX) {\n internalValue.sort((a, b) => sortValueByIndex(this.getNode(a), this.getNode(b)))\n }\n\n return internalValue\n },\n /**\n * Has any option been selected?\n * @type {boolean}\n */\n hasValue() {\n return this.internalValue.length > 0\n },\n /**\n * Single-select mode?\n * @type {boolean}\n */\n single() {\n return !this.multiple\n },\n /**\n * Id list of nodes displayed in the menu. Nodes that are considered NOT visible:\n * - descendants of a collapsed branch node\n * - in local search mode, nodes that are not matched, unless\n * - it's a branch node and has matched descendants\n * - it's a leaf node and its parent node is explicitly set to show all children\n * @type {id[]}\n */\n visibleOptionIds() {\n const visibleOptionIds = []\n\n this.traverseAllNodesByIndex(node => {\n if (!this.localSearch.active || this.shouldOptionBeIncludedInSearchResult(node)) {\n visibleOptionIds.push(node.id)\n }\n // Skip the traversal of descendants of a branch node if it's not expanded.\n if (node.isBranch && !this.shouldExpand(node)) {\n return false\n }\n })\n\n return visibleOptionIds\n },\n /**\n * Has any option should be displayed in the menu?\n * @type {boolean}\n */\n hasVisibleOptions() {\n return this.visibleOptionIds.length !== 0\n },\n /**\n * Should show children count when searching?\n * @type {boolean}\n */\n showCountOnSearchComputed() {\n // Vue doesn't allow setting default prop value based on another prop value.\n // So use computed property as a workaround.\n // https://github.com/vuejs/vue/issues/6358\n return typeof this.showCountOnSearch === 'boolean'\n ? this.showCountOnSearch\n : this.showCount\n },\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes() {\n return this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\n },\n shouldFlattenOptions() {\n return this.localSearch.active && this.flattenSearchResults\n },\n /* eslint-enable valid-jsdoc */\n },\n\n watch: {\n alwaysOpen(newValue) {\n if (newValue) this.openMenu()\n else this.closeMenu()\n },\n\n branchNodesFirst() {\n this.initialize()\n },\n\n disabled(newValue) {\n // force close the menu after disabling the control\n if (newValue && this.menu.isOpen) this.closeMenu()\n else if (!newValue && !this.menu.isOpen && this.alwaysOpen) this.openMenu()\n },\n\n flat() {\n this.initialize()\n },\n\n internalValue(newValue, oldValue) {\n const hasChanged = quickDiff(newValue, oldValue)\n // #122\n // Vue would trigger this watcher when `newValue` and `oldValue` are shallow-equal.\n // We emit the `input` event only when the value actually changes.\n if (hasChanged) this.$emit('input', this.getValue(), this.getInstanceId())\n },\n\n matchKeys() {\n this.initialize()\n },\n\n multiple(newValue) {\n // We need to rebuild the state when switching from single-select mode\n // to multi-select mode.\n // istanbul ignore else\n if (newValue) this.buildForestState()\n },\n\n options: {\n handler() {\n if (this.async) return\n // Re-initialize options when the `options` prop has changed.\n this.initialize()\n this.rootOptionsStates.isLoaded = Array.isArray(this.options)\n },\n deep: true,\n immediate: true,\n },\n\n 'trigger.searchQuery'() {\n if (this.async) {\n this.handleRemoteSearch()\n } else {\n this.handleLocalSearch()\n }\n\n this.$emit('search-change', this.trigger.searchQuery, this.getInstanceId())\n },\n\n value() {\n const nodeIdsFromValue = this.extractCheckedNodeIdsFromValue()\n const hasChanged = quickDiff(nodeIdsFromValue, this.internalValue)\n if (hasChanged) this.fixSelectedNodeIds(nodeIdsFromValue)\n },\n },\n\n methods: {\n verifyProps() {\n warning(\n () => this.async ? this.searchable : true,\n () => 'For async search mode, the value of \"searchable\" prop must be true.',\n )\n\n if (this.options == null && !this.loadOptions) {\n warning(\n () => false,\n () => 'Are you meant to dynamically load options? You need to use \"loadOptions\" prop.',\n )\n }\n\n if (this.flat) {\n warning(\n () => this.multiple,\n () => 'You are using flat mode. But you forgot to add \"multiple=true\"?',\n )\n }\n\n if (!this.flat) {\n const propNames = [\n 'autoSelectAncestors',\n 'autoSelectDescendants',\n 'autoDeselectAncestors',\n 'autoDeselectDescendants',\n ]\n\n propNames.forEach(propName => {\n warning(\n () => !this[propName],\n () => `\"${propName}\" only applies to flat mode.`,\n )\n })\n }\n },\n\n resetFlags() {\n this._blurOnSelect = false\n },\n\n initialize() {\n const options = this.async\n ? this.getRemoteSearchEntry().options\n : this.options\n\n if (Array.isArray(options)) {\n // In case we are re-initializing options, keep the old state tree temporarily.\n const prevNodeMap = this.forest.nodeMap\n this.forest.nodeMap = createMap()\n this.keepDataOfSelectedNodes(prevNodeMap)\n this.forest.normalizedOptions = this.normalize(NO_PARENT_NODE, options, prevNodeMap)\n // Cases that need fixing `selectedNodeIds`:\n // 1) Children options of a checked node have been delayed loaded,\n // we should also mark these children as checked. (multi-select mode)\n // 2) Root options have been delayed loaded, we need to initialize states\n // of these nodes. (multi-select mode)\n // 3) Async search mode.\n this.fixSelectedNodeIds(this.internalValue)\n } else {\n this.forest.normalizedOptions = []\n }\n },\n\n getInstanceId() {\n return this.instanceId == null ? this.id : this.instanceId\n },\n\n getValue() {\n if (this.valueFormat === 'id') {\n return this.multiple\n ? this.getUniqChildValues(this.internalValue.slice())\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple\n ? this.getUniqChildValues(rawNodes)\n : rawNodes[0]\n },\n\n getUniqChildValues(ids) {\n if (this.valueConsistsOf !== BRANCH_PRIORITY) return ids\n const values = ids.map(id => {\n const node = this.getNode(id)\n if (node.hasBeenSelected) return node.id\n if (this.hasOneChild(node)) {\n const children = []\n this.traverseDescendantsBFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n if (descendant.hasBeenSelected) {\n children.push(descendant.id)\n }\n }\n })\n if (children && children.length) return children[0]\n }\n return id\n })\n return values\n },\n hasOneChild(node) {\n return node && node.children && node.children.length === 1\n },\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) return null\n\n return nodeId in this.forest.nodeMap\n ? this.forest.nodeMap[nodeId]\n : this.createFallbackNode(nodeId)\n },\n\n createFallbackNode(id) {\n // In case there is a default selected node that is not loaded into the tree yet,\n // we create a fallback node to keep the component working.\n // When the real data is loaded, we'll override this fake node.\n\n const raw = this.extractNodeFromValue(id)\n const label = this.enhancedNormalizer(raw).label || `${id} (unknown)`\n const fallbackNode = {\n id,\n label,\n ancestors: [],\n parentNode: NO_PARENT_NODE,\n isFallbackNode: true,\n isRootNode: true,\n isLeaf: true,\n isBranch: false,\n isDisabled: false,\n isNew: false,\n index: [ -1 ],\n level: 0,\n raw,\n }\n\n return this.$set(this.forest.nodeMap, id, fallbackNode)\n },\n\n extractCheckedNodeIdsFromValue() {\n if (this.value == null) return []\n\n if (this.valueFormat === 'id') {\n return this.multiple\n ? this.value.slice()\n : [ this.value ]\n }\n\n return (this.multiple ? this.value : [ this.value ])\n .map(node => this.enhancedNormalizer(node))\n .map(node => node.id)\n },\n\n extractNodeFromValue(id) {\n const defaultNode = { id }\n\n if (this.valueFormat === 'id') {\n return defaultNode\n }\n\n const valueArray = this.multiple\n ? Array.isArray(this.value) ? this.value : []\n : this.value ? [ this.value ] : []\n const matched = find(\n valueArray,\n node => node && this.enhancedNormalizer(node).id === id,\n )\n\n return matched || defaultNode\n },\n\n fixSelectedNodeIds(nodeIdListOfPrevValue) {\n let nextSelectedNodeIds = []\n\n // istanbul ignore else\n if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) {\n nextSelectedNodeIds = nodeIdListOfPrevValue\n } else if (this.valueConsistsOf === BRANCH_PRIORITY) {\n nodeIdListOfPrevValue.forEach(nodeId => {\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n nextSelectedNodeIds.push(descendant.id)\n })\n })\n } else if (this.valueConsistsOf === LEAF_PRIORITY) {\n const map = createMap()\n const queue = nodeIdListOfPrevValue.slice()\n while (queue.length) {\n const nodeId = queue.shift()\n const node = this.getNode(nodeId)\n nextSelectedNodeIds.push(nodeId)\n if (node.isRootNode) continue\n if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length\n if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id)\n }\n } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) {\n const map = createMap()\n const queue = nodeIdListOfPrevValue.filter(nodeId => {\n const node = this.getNode(nodeId)\n return node.isLeaf || node.children.length === 0\n })\n while (queue.length) {\n const nodeId = queue.shift()\n const node = this.getNode(nodeId)\n nextSelectedNodeIds.push(nodeId)\n if (node.isRootNode) continue\n if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length\n if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id)\n }\n }\n\n const hasChanged = quickDiff(this.forest.selectedNodeIds, nextSelectedNodeIds)\n // If `nextSelectedNodeIds` doesn't actually differ from old `selectedNodeIds`,\n // we don't make the assignment to avoid triggering its watchers which may cause\n // unnecessary calculations.\n if (hasChanged) this.forest.selectedNodeIds = nextSelectedNodeIds\n\n this.buildForestState()\n },\n\n keepDataOfSelectedNodes(prevNodeMap) {\n // In case there is any selected node that is not present in the new `options` array.\n // It could be useful for async search mode.\n this.forest.selectedNodeIds.forEach(id => {\n if (!prevNodeMap[id]) return\n const node = {\n ...prevNodeMap[id],\n isFallbackNode: true,\n }\n this.$set(this.forest.nodeMap, id, node)\n })\n },\n\n isSelected(node) {\n // whether a node is selected (single-select mode) or fully-checked (multi-select mode)\n return this.forest.selectedNodeMap[node.id] === true\n },\n\n traverseDescendantsBFS(parentNode, callback) {\n // istanbul ignore if\n if (!parentNode.isBranch) return\n const queue = parentNode.children.slice()\n while (queue.length) {\n const currNode = queue[0]\n if (currNode.isBranch) queue.push(...currNode.children)\n callback(currNode)\n queue.shift()\n }\n },\n\n traverseDescendantsDFS(parentNode, callback) {\n if (!parentNode.isBranch) return\n parentNode.children.forEach(child => {\n // deep-level node first\n this.traverseDescendantsDFS(child, callback)\n callback(child)\n })\n },\n\n traverseAllNodesDFS(callback) {\n this.forest.normalizedOptions.forEach(rootNode => {\n // deep-level node first\n this.traverseDescendantsDFS(rootNode, callback)\n callback(rootNode)\n })\n },\n\n traverseAllNodesByIndex(callback) {\n const walk = parentNode => {\n parentNode.children.forEach(child => {\n if (callback(child) !== false && child.isBranch) {\n walk(child)\n }\n })\n }\n\n // To simplify the code logic of traversal,\n // we create a fake root node that holds all the root options.\n walk({ children: this.forest.normalizedOptions })\n },\n\n toggleClickOutsideEvent(enabled) {\n if (enabled) {\n document.addEventListener('mousedown', this.handleClickOutside, false)\n } else {\n document.removeEventListener('mousedown', this.handleClickOutside, false)\n }\n },\n\n getValueContainer() {\n return this.$refs.control.$refs['value-container']\n },\n\n getInput() {\n return this.getValueContainer().$refs.input\n },\n\n focusInput() {\n this.getInput().focus()\n },\n\n blurInput() {\n this.getInput().blur()\n },\n\n handleMouseDown: onLeftClick(function handleMouseDown(evt) {\n evt.preventDefault()\n evt.stopPropagation()\n\n if (this.disabled) return\n\n const isClickedOnValueContainer = this.getValueContainer().$el.contains(evt.target)\n if (isClickedOnValueContainer && !this.menu.isOpen && (this.openOnClick || this.trigger.isFocused)) {\n this.openMenu()\n }\n\n if (this._blurOnSelect) {\n this.blurInput()\n } else {\n // Focus the input or prevent blurring.\n this.focusInput()\n }\n\n this.resetFlags()\n }),\n\n handleClickOutside(evt) {\n // istanbul ignore else\n if (this.$refs.wrapper && !this.$refs.wrapper.contains(evt.target)) {\n this.blurInput()\n this.closeMenu()\n }\n },\n\n handleLocalSearch() {\n const { searchQuery } = this.trigger\n const done = () => this.resetHighlightedOptionWhenNecessary(true)\n\n if (!searchQuery) {\n // Exit sync search mode.\n this.localSearch.active = false\n return done()\n }\n\n // Enter sync search mode.\n this.localSearch.active = true\n\n // Reset states.\n this.localSearch.noResults = true\n this.traverseAllNodesDFS(node => {\n if (node.isBranch) {\n node.isExpandedOnSearch = false\n node.showAllChildrenOnSearch = false\n node.isMatched = false\n node.hasMatchedDescendants = false\n this.$set(this.localSearch.countMap, node.id, {\n [ALL_CHILDREN]: 0,\n [ALL_DESCENDANTS]: 0,\n [LEAF_CHILDREN]: 0,\n [LEAF_DESCENDANTS]: 0,\n })\n }\n })\n\n const lowerCasedSearchQuery = removeAccents(searchQuery).trim().toLocaleLowerCase()\n const splitSearchQuery = lowerCasedSearchQuery.replace(/\\s+/g, ' ').split(' ')\n this.traverseAllNodesDFS(node => {\n if (this.searchNested && splitSearchQuery.length > 1) {\n node.isMatched = splitSearchQuery.every(filterValue =>\n match(false, filterValue, node.nestedSearchLabel),\n )\n } else {\n node.isMatched = this.matchKeys.some(matchKey =>\n match(!this.disableFuzzyMatching, lowerCasedSearchQuery, node.lowerCased[matchKey]),\n )\n }\n\n if (node.isMatched) {\n this.localSearch.noResults = false\n node.ancestors.forEach(ancestor => this.localSearch.countMap[ancestor.id][ALL_DESCENDANTS]++)\n if (node.isLeaf) node.ancestors.forEach(ancestor => this.localSearch.countMap[ancestor.id][LEAF_DESCENDANTS]++)\n if (node.parentNode !== NO_PARENT_NODE) {\n this.localSearch.countMap[node.parentNode.id][ALL_CHILDREN] += 1\n // istanbul ignore else\n if (node.isLeaf) this.localSearch.countMap[node.parentNode.id][LEAF_CHILDREN] += 1\n }\n }\n\n if (\n (node.isMatched || (node.isBranch && node.isExpandedOnSearch)) &&\n node.parentNode !== NO_PARENT_NODE\n ) {\n node.parentNode.isExpandedOnSearch = true\n node.parentNode.hasMatchedDescendants = true\n }\n })\n\n done()\n },\n\n handleRemoteSearch() {\n const { searchQuery } = this.trigger\n const entry = this.getRemoteSearchEntry()\n const done = () => {\n this.initialize()\n this.resetHighlightedOptionWhenNecessary(true)\n }\n\n if ((searchQuery === '' || this.cacheOptions) && entry.isLoaded) {\n return done()\n }\n\n this.callLoadOptionsProp({\n action: ASYNC_SEARCH,\n args: { searchQuery },\n isPending() {\n return entry.isLoading\n },\n start: () => {\n entry.isLoading = true\n entry.isLoaded = false\n entry.loadingError = ''\n },\n succeed: options => {\n entry.isLoaded = true\n entry.options = options\n // When the request completes, the search query may have changed.\n // We only show these options if they are for the current search query.\n if (this.trigger.searchQuery === searchQuery) done()\n },\n fail: err => {\n entry.loadingError = getErrorMessage(err)\n },\n end: () => {\n entry.isLoading = false\n },\n })\n },\n\n getRemoteSearchEntry() {\n const { searchQuery } = this.trigger\n const entry = this.remoteSearch[searchQuery] || {\n ...createAsyncOptionsStates(),\n options: [],\n }\n\n // Vue doesn't support directly watching on objects.\n this.$watch(\n () => entry.options,\n () => {\n // TODO: potential redundant re-initialization.\n if (this.trigger.searchQuery === searchQuery) this.initialize()\n },\n { deep: true },\n )\n\n if (searchQuery === '') {\n if (Array.isArray(this.defaultOptions)) {\n entry.options = this.defaultOptions\n entry.isLoaded = true\n return entry\n } else if (this.defaultOptions !== true) {\n entry.isLoaded = true\n return entry\n }\n }\n\n if (!this.remoteSearch[searchQuery]) {\n this.$set(this.remoteSearch, searchQuery, entry)\n }\n\n return entry\n },\n\n shouldExpand(node) {\n return this.localSearch.active ? node.isExpandedOnSearch : node.isExpanded\n },\n\n shouldOptionBeIncludedInSearchResult(node) {\n // 1) This option is matched.\n if (node.isMatched) return true\n // 2) This option is not matched, but has matched descendant(s).\n if (node.isBranch && node.hasMatchedDescendants && !this.flattenSearchResults) return true\n // 3) This option's parent has no matched descendants,\n // but after being expanded, all its children should be shown.\n if (!node.isRootNode && node.parentNode.showAllChildrenOnSearch) return true\n // 4) The default case.\n return false\n },\n\n shouldShowOptionInMenu(node) {\n if (this.localSearch.active && !this.shouldOptionBeIncludedInSearchResult(node)) {\n return false\n }\n return true\n },\n\n getControl() {\n return this.$refs.control.$el\n },\n\n getMenu() {\n const ref = this.appendToBody ? this.$refs.portal.portalTarget : this\n const $menu = ref.$refs.menu.$refs.menu\n return $menu && $menu.nodeName !== '#comment' ? $menu : null\n },\n\n setCurrentHighlightedOption(node, scroll = true) {\n const prev = this.menu.current\n if (prev != null && prev in this.forest.nodeMap) {\n this.forest.nodeMap[prev].isHighlighted = false\n }\n\n this.menu.current = node.id\n node.isHighlighted = true\n\n if (this.menu.isOpen && scroll) {\n const scrollToOption = () => {\n const $menu = this.getMenu()\n const $option = $menu.querySelector(`.vue-treeselect__option[data-id=\"${node.id}\"]`)\n if ($option) scrollIntoView($menu, $option)\n }\n\n // In case `openMenu()` is just called and the menu is not rendered yet.\n if (this.getMenu()) {\n scrollToOption()\n } else {\n // istanbul ignore next\n this.$nextTick(scrollToOption)\n }\n }\n },\n\n resetHighlightedOptionWhenNecessary(forceReset = false) {\n const { current } = this.menu\n\n if (\n forceReset || current == null ||\n !(current in this.forest.nodeMap) ||\n !this.shouldShowOptionInMenu(this.getNode(current))\n ) {\n this.highlightFirstOption()\n }\n },\n\n highlightFirstOption() {\n if (!this.hasVisibleOptions) return\n\n const first = this.visibleOptionIds[0]\n this.setCurrentHighlightedOption(this.getNode(first))\n },\n\n highlightPrevOption() {\n if (!this.hasVisibleOptions) return\n\n const prev = this.visibleOptionIds.indexOf(this.menu.current) - 1\n if (prev === -1) return this.highlightLastOption()\n this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[prev]))\n },\n\n highlightNextOption() {\n if (!this.hasVisibleOptions) return\n\n const next = this.visibleOptionIds.indexOf(this.menu.current) + 1\n if (next === this.visibleOptionIds.length) return this.highlightFirstOption()\n this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[next]))\n },\n\n highlightLastOption() {\n if (!this.hasVisibleOptions) return\n\n const last = getLast(this.visibleOptionIds)\n this.setCurrentHighlightedOption(this.getNode(last))\n },\n\n resetSearchQuery() {\n this.trigger.searchQuery = ''\n },\n\n closeMenu() {\n if (!this.menu.isOpen || (!this.disabled && this.alwaysOpen)) return\n this.saveMenuScrollPosition()\n this.menu.isOpen = false\n this.toggleClickOutsideEvent(false)\n this.resetSearchQuery()\n this.$emit('close', this.getValue(), this.getInstanceId())\n },\n\n openMenu() {\n if (this.disabled || this.menu.isOpen) return\n this.menu.isOpen = true\n this.$nextTick(this.resetHighlightedOptionWhenNecessary)\n this.$nextTick(this.restoreMenuScrollPosition)\n if (!this.options && !this.async) this.loadRootOptions()\n this.toggleClickOutsideEvent(true)\n this.$emit('open', this.getInstanceId())\n },\n\n toggleMenu() {\n if (this.menu.isOpen) {\n this.closeMenu()\n } else {\n this.openMenu()\n }\n },\n\n toggleExpanded(node) {\n let nextState\n\n if (this.localSearch.active) {\n nextState = node.isExpandedOnSearch = !node.isExpandedOnSearch\n if (nextState) node.showAllChildrenOnSearch = true\n } else {\n nextState = node.isExpanded = !node.isExpanded\n }\n\n if (nextState && !node.childrenStates.isLoaded) {\n this.loadChildrenOptions(node)\n }\n },\n\n buildForestState() {\n const selectedNodeMap = createMap()\n this.forest.selectedNodeIds.forEach(selectedNodeId => {\n selectedNodeMap[selectedNodeId] = true\n })\n this.forest.selectedNodeMap = selectedNodeMap\n\n const checkedStateMap = createMap()\n if (this.multiple) {\n this.traverseAllNodesByIndex(node => {\n checkedStateMap[node.id] = UNCHECKED\n })\n\n this.selectedNodes.forEach(selectedNode => {\n checkedStateMap[selectedNode.id] = CHECKED\n\n if (!this.flat && !this.disableBranchNodes) {\n selectedNode.ancestors.forEach(ancestorNode => {\n if (!this.isSelected(ancestorNode)) {\n checkedStateMap[ancestorNode.id] = INDETERMINATE\n }\n })\n }\n })\n }\n this.forest.checkedStateMap = checkedStateMap\n },\n\n enhancedNormalizer(raw) {\n return {\n ...raw,\n ...this.normalizer(raw, this.getInstanceId()),\n }\n },\n\n normalize(parentNode, nodes, prevNodeMap) {\n let normalizedOptions = nodes\n .map(node => [ this.enhancedNormalizer(node), node ])\n .map(([ node, raw ], index) => {\n this.checkDuplication(node)\n this.verifyNodeShape(node)\n\n const { id, label, children, isDefaultExpanded } = node\n const isRootNode = parentNode === NO_PARENT_NODE\n const level = isRootNode ? 0 : parentNode.level + 1\n const isBranch = Array.isArray(children) || children === null\n const isLeaf = !isBranch\n const isDisabled = !!node.isDisabled || (!this.flat && !isRootNode && parentNode.isDisabled)\n const isNew = !!node.isNew\n const lowerCased = this.matchKeys.reduce((prev, key) => ({\n ...prev,\n [key]: stringifyOptionPropValue(node[key]).toLocaleLowerCase(),\n }), {})\n const nestedSearchLabel = isRootNode\n ? lowerCased.label\n : parentNode.nestedSearchLabel + ' ' + lowerCased.label\n\n const normalized = this.$set(this.forest.nodeMap, id, createMap())\n this.$set(normalized, 'id', id)\n this.$set(normalized, 'label', label)\n this.$set(normalized, 'level', level)\n this.$set(normalized, 'ancestors', isRootNode ? [] : [ parentNode ].concat(parentNode.ancestors))\n this.$set(normalized, 'index', (isRootNode ? [] : parentNode.index).concat(index))\n this.$set(normalized, 'parentNode', parentNode)\n this.$set(normalized, 'lowerCased', lowerCased)\n this.$set(normalized, 'nestedSearchLabel', nestedSearchLabel)\n this.$set(normalized, 'isDisabled', isDisabled)\n this.$set(normalized, 'isNew', isNew)\n this.$set(normalized, 'isMatched', false)\n this.$set(normalized, 'isHighlighted', false)\n this.$set(normalized, 'isBranch', isBranch)\n this.$set(normalized, 'isLeaf', isLeaf)\n this.$set(normalized, 'isRootNode', isRootNode)\n this.$set(normalized, 'raw', raw)\n\n if (isBranch) {\n const isLoaded = Array.isArray(children)\n\n this.$set(normalized, 'childrenStates', {\n ...createAsyncOptionsStates(),\n isLoaded,\n })\n this.$set(normalized, 'isExpanded', typeof isDefaultExpanded === 'boolean'\n ? isDefaultExpanded\n : level < this.defaultExpandLevel)\n this.$set(normalized, 'hasMatchedDescendants', false)\n this.$set(normalized, 'hasDisabledDescendants', false)\n this.$set(normalized, 'isExpandedOnSearch', false)\n this.$set(normalized, 'showAllChildrenOnSearch', false)\n this.$set(normalized, 'count', {\n [ALL_CHILDREN]: 0,\n [ALL_DESCENDANTS]: 0,\n [LEAF_CHILDREN]: 0,\n [LEAF_DESCENDANTS]: 0,\n })\n this.$set(normalized, 'children', isLoaded\n ? this.normalize(normalized, children, prevNodeMap)\n : [])\n\n if (isDefaultExpanded === true) normalized.ancestors.forEach(ancestor => {\n ancestor.isExpanded = true\n })\n\n if (!isLoaded && typeof this.loadOptions !== 'function') {\n warning(\n () => false,\n () => 'Unloaded branch node detected. \"loadOptions\" prop is required to load its children.',\n )\n } else if (!isLoaded && normalized.isExpanded) {\n this.loadChildrenOptions(normalized)\n }\n }\n\n normalized.ancestors.forEach(ancestor => ancestor.count[ALL_DESCENDANTS]++)\n if (isLeaf) normalized.ancestors.forEach(ancestor => ancestor.count[LEAF_DESCENDANTS]++)\n if (!isRootNode) {\n parentNode.count[ALL_CHILDREN] += 1\n if (isLeaf) parentNode.count[LEAF_CHILDREN] += 1\n if (isDisabled) parentNode.hasDisabledDescendants = true\n }\n\n // Preserve previous states.\n if (prevNodeMap && prevNodeMap[id]) {\n const prev = prevNodeMap[id]\n\n normalized.isMatched = prev.isMatched\n normalized.showAllChildrenOnSearch = prev.showAllChildrenOnSearch\n normalized.isHighlighted = prev.isHighlighted\n\n if (prev.isBranch && normalized.isBranch) {\n normalized.isExpanded = prev.isExpanded\n normalized.isExpandedOnSearch = prev.isExpandedOnSearch\n // #97\n // If `isLoaded` was true, but IS NOT now, we consider this branch node\n // to be reset to unloaded state by the user of this component.\n if (prev.childrenStates.isLoaded && !normalized.childrenStates.isLoaded) {\n // Make sure the node is collapsed, then the user can load its\n // children again (by expanding).\n normalized.isExpanded = false\n // We have reset `childrenStates` and don't want to preserve states here.\n } else {\n normalized.childrenStates = { ...prev.childrenStates }\n }\n }\n }\n\n return normalized\n })\n\n if (this.branchNodesFirst) {\n const branchNodes = normalizedOptions.filter(option => option.isBranch)\n const leafNodes = normalizedOptions.filter(option => option.isLeaf)\n normalizedOptions = branchNodes.concat(leafNodes)\n }\n\n return normalizedOptions\n },\n\n loadRootOptions() {\n this.callLoadOptionsProp({\n action: LOAD_ROOT_OPTIONS,\n isPending: () => {\n return this.rootOptionsStates.isLoading\n },\n start: () => {\n this.rootOptionsStates.isLoading = true\n this.rootOptionsStates.loadingError = ''\n },\n succeed: () => {\n this.rootOptionsStates.isLoaded = true\n // Wait for `options` being re-initialized.\n this.$nextTick(() => {\n this.resetHighlightedOptionWhenNecessary(true)\n })\n },\n fail: err => {\n this.rootOptionsStates.loadingError = getErrorMessage(err)\n },\n end: () => {\n this.rootOptionsStates.isLoading = false\n },\n })\n },\n\n loadChildrenOptions(parentNode) {\n // The options may be re-initialized anytime during the loading process.\n // So `parentNode` can be stale and we use `getNode()` to avoid that.\n\n const { id, raw } = parentNode\n\n this.callLoadOptionsProp({\n action: LOAD_CHILDREN_OPTIONS,\n args: {\n // We always pass the raw node instead of the normalized node to any\n // callback provided by the user of this component.\n // Because the shape of the raw node is more likely to be closing to\n // what the back-end API service of the application needs.\n parentNode: raw,\n },\n isPending: () => {\n return this.getNode(id).childrenStates.isLoading\n },\n start: () => {\n this.getNode(id).childrenStates.isLoading = true\n this.getNode(id).childrenStates.loadingError = ''\n },\n succeed: () => {\n this.getNode(id).childrenStates.isLoaded = true\n },\n fail: err => {\n this.getNode(id).childrenStates.loadingError = getErrorMessage(err)\n },\n end: () => {\n this.getNode(id).childrenStates.isLoading = false\n },\n })\n },\n\n callLoadOptionsProp({ action, args, isPending, start, succeed, fail, end }) {\n if (!this.loadOptions || isPending()) {\n return\n }\n\n start()\n\n const callback = once((err, result) => {\n if (err) {\n fail(err)\n } else {\n succeed(result)\n }\n\n end()\n })\n const result = this.loadOptions({\n id: this.getInstanceId(),\n instanceId: this.getInstanceId(),\n action,\n ...args,\n callback,\n })\n\n if (isPromise(result)) {\n result.then(() => {\n callback()\n }, err => {\n callback(err)\n }).catch(err => {\n // istanbul ignore next\n console.error(err)\n })\n }\n },\n\n checkDuplication(node) {\n warning(\n () => !((node.id in this.forest.nodeMap) && !this.forest.nodeMap[node.id].isFallbackNode),\n () => `Detected duplicate presence of node id ${JSON.stringify(node.id)}. ` +\n `Their labels are \"${this.forest.nodeMap[node.id].label}\" and \"${node.label}\" respectively.`,\n )\n },\n\n verifyNodeShape(node) {\n warning(\n () => !(node.children === undefined && node.isBranch === true),\n () => 'Are you meant to declare an unloaded branch node? ' +\n '`isBranch: true` is no longer supported, please use `children: null` instead.',\n )\n },\n\n select(node) {\n if (this.disabled || node.isDisabled) {\n return\n }\n\n if (this.single) {\n this.clear()\n }\n\n const nextState = this.multiple && !this.flat\n ? this.forest.checkedStateMap[node.id] === UNCHECKED\n : !this.isSelected(node)\n\n if (nextState) {\n this._selectNode(node)\n } else {\n this._deselectNode(node)\n }\n\n this.buildForestState()\n\n if (nextState) {\n this.$emit('select', node.raw, this.getInstanceId())\n } else {\n this.$emit('deselect', node.raw, this.getInstanceId())\n }\n\n if (this.localSearch.active && nextState && (this.single || this.clearOnSelect)) {\n this.resetSearchQuery()\n }\n\n if (this.single && this.closeOnSelect) {\n this.closeMenu()\n\n // istanbul ignore else\n if (this.searchable) {\n this._blurOnSelect = true\n }\n }\n },\n\n clear() {\n if (this.hasValue) {\n if (this.single || this.allowClearingDisabled) {\n this.forest.selectedNodeIds = []\n } else /* if (this.multiple && !this.allowClearingDisabled) */ {\n this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(nodeId =>\n this.getNode(nodeId).isDisabled,\n )\n }\n\n this.buildForestState()\n }\n },\n\n // This is meant to be called only by `select()`.\n _selectNode(node) {\n node.hasBeenSelected = node.id\n if (this.single || this.disableBranchNodes) {\n return this.addValue(node)\n }\n\n if (this.flat) {\n this.addValue(node)\n\n if (this.autoSelectAncestors) {\n node.ancestors.forEach(ancestor => {\n if (!this.isSelected(ancestor) && !ancestor.isDisabled) this.addValue(ancestor)\n })\n } else if (this.autoSelectDescendants) {\n this.traverseDescendantsBFS(node, descendant => {\n if (!this.isSelected(descendant) && !descendant.isDisabled) this.addValue(descendant)\n })\n }\n\n return\n }\n\n const isFullyChecked = (\n node.isLeaf ||\n (/* node.isBranch && */!node.hasDisabledDescendants) ||\n (/* node.isBranch && */this.allowSelectingDisabledDescendants)\n )\n if (isFullyChecked) {\n this.addValue(node)\n }\n\n if (node.isBranch) {\n this.traverseDescendantsBFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n this.addValue(descendant)\n }\n })\n }\n\n if (isFullyChecked) {\n let curr = node\n while ((curr = curr.parentNode) !== NO_PARENT_NODE) {\n if (curr.children.every(this.isSelected)) this.addValue(curr)\n else break\n }\n }\n },\n\n // This is meant to be called only by `select()`.\n _deselectNode(node) {\n if (this.disableBranchNodes) {\n return this.removeValue(node)\n }\n\n if (this.flat) {\n this.removeValue(node)\n\n if (this.autoDeselectAncestors) {\n node.ancestors.forEach(ancestor => {\n if (this.isSelected(ancestor) && !ancestor.isDisabled) this.removeValue(ancestor)\n })\n } else if (this.autoDeselectDescendants) {\n this.traverseDescendantsBFS(node, descendant => {\n if (this.isSelected(descendant) && !descendant.isDisabled) this.removeValue(descendant)\n })\n }\n\n return\n }\n\n let hasUncheckedSomeDescendants = false\n if (node.isBranch) {\n this.traverseDescendantsDFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n this.removeValue(descendant)\n hasUncheckedSomeDescendants = true\n }\n })\n }\n\n if (\n node.isLeaf ||\n /* node.isBranch && */hasUncheckedSomeDescendants ||\n /* node.isBranch && */node.children.length === 0\n ) {\n this.removeValue(node)\n\n let curr = node\n while ((curr = curr.parentNode) !== NO_PARENT_NODE) {\n if (this.isSelected(curr)) this.removeValue(curr)\n else break\n }\n }\n },\n\n addValue(node) {\n this.forest.selectedNodeIds.push(node.id)\n this.forest.selectedNodeMap[node.id] = true\n },\n\n removeValue(node) {\n delete node.hasBeenSelected\n removeFromArray(this.forest.selectedNodeIds, node.id)\n delete this.forest.selectedNodeMap[node.id]\n },\n\n removeLastValue() {\n if (!this.hasValue) return\n if (this.single) return this.clear()\n const lastValue = getLast(this.internalValue)\n const lastSelectedNode = this.getNode(lastValue)\n this.select(lastSelectedNode) // deselect\n },\n\n saveMenuScrollPosition() {\n const $menu = this.getMenu()\n // istanbul ignore else\n if ($menu) this.menu.lastScrollPosition = $menu.scrollTop\n },\n\n restoreMenuScrollPosition() {\n const $menu = this.getMenu()\n // istanbul ignore else\n if ($menu) $menu.scrollTop = this.menu.lastScrollPosition\n },\n },\n\n created() {\n this.verifyProps()\n this.resetFlags()\n },\n\n mounted() {\n if (this.autoFocus) this.focusInput()\n if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions()\n if (this.alwaysOpen) this.openMenu()\n if (this.async && this.defaultOptions) this.handleRemoteSearch()\n },\n\n destroyed() {\n // istanbul ignore next\n this.toggleClickOutsideEvent(false)\n },\n}\n","\n","/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nexport default function normalizeComponent (\n scriptExports,\n render,\n staticRenderFns,\n functionalTemplate,\n injectStyles,\n scopeId,\n moduleIdentifier, /* server only */\n shadowMode /* vue-cli only */\n) {\n // Vue.extend constructor export interop\n var options = typeof scriptExports === 'function'\n ? scriptExports.options\n : scriptExports\n\n // render functions\n if (render) {\n options.render = render\n options.staticRenderFns = staticRenderFns\n options._compiled = true\n }\n\n // functional template\n if (functionalTemplate) {\n options.functional = true\n }\n\n // scopedId\n if (scopeId) {\n options._scopeId = 'data-v-' + scopeId\n }\n\n var hook\n if (moduleIdentifier) { // server build\n hook = function (context) {\n // 2.3 injection\n context =\n context || // cached call\n (this.$vnode && this.$vnode.ssrContext) || // stateful\n (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n // 2.2 with runInNewContext: true\n if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n context = __VUE_SSR_CONTEXT__\n }\n // inject component styles\n if (injectStyles) {\n injectStyles.call(this, context)\n }\n // register component module identifier for async chunk inferrence\n if (context && context._registeredComponents) {\n context._registeredComponents.add(moduleIdentifier)\n }\n }\n // used by ssr in case component is cached and beforeCreate\n // never gets called\n options._ssrRegister = hook\n } else if (injectStyles) {\n hook = shadowMode\n ? function () {\n injectStyles.call(\n this,\n (options.functional ? this.parent : this).$root.$options.shadowRoot\n )\n }\n : injectStyles\n }\n\n if (hook) {\n if (options.functional) {\n // for template-only hot-reload because in that case the render fn doesn't\n // go through the normalizer\n options._injectStyles = hook\n // register for functional component in vue file\n var originalRender = options.render\n options.render = function renderWithStyleInjection (h, context) {\n hook.call(context)\n return originalRender(h, context)\n }\n } else {\n // inject component registration as beforeCreate hook\n var existing = options.beforeCreate\n options.beforeCreate = existing\n ? [].concat(existing, hook)\n : [hook]\n }\n }\n\n return {\n exports: scriptExports,\n options: options\n }\n}\n","var render, staticRenderFns\nimport script from \"./HiddenFields.vue?vue&type=script&lang=js&\"\nexport * from \"./HiddenFields.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('4d48089a')) {\n api.createRecord('4d48089a', component.options)\n } else {\n api.reload('4d48089a', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/HiddenFields.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./Input.vue?vue&type=script&lang=js&\"\nexport * from \"./Input.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('54844eca')) {\n api.createRecord('54844eca', component.options)\n } else {\n api.reload('54844eca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Input.vue\"\nexport default component.exports","var render, staticRenderFns\nimport script from \"./Placeholder.vue?vue&type=script&lang=js&\"\nexport * from \"./Placeholder.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('5a99d1f3')) {\n api.createRecord('5a99d1f3', component.options)\n } else {\n api.reload('5a99d1f3', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Placeholder.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./SingleValue.vue?vue&type=script&lang=js&\"\nexport * from \"./SingleValue.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('03d19b89')) {\n api.createRecord('03d19b89', component.options)\n } else {\n api.reload('03d19b89', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/SingleValue.vue\"\nexport default component.exports","\n","var render = function () {\n var _vm = this\n var _h = _vm.$createElement\n var _c = _vm._self._c || _h\n return _c(\n \"svg\",\n {\n attrs: {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 348.333 348.333\",\n },\n },\n [\n _c(\"path\", {\n attrs: {\n d: \"M336.559 68.611L231.016 174.165l105.543 105.549c15.699 15.705 15.699 41.145 0 56.85-7.844 7.844-18.128 11.769-28.407 11.769-10.296 0-20.581-3.919-28.419-11.769L174.167 231.003 68.609 336.563c-7.843 7.844-18.128 11.769-28.416 11.769-10.285 0-20.563-3.919-28.413-11.769-15.699-15.698-15.699-41.139 0-56.85l105.54-105.549L11.774 68.611c-15.699-15.699-15.699-41.145 0-56.844 15.696-15.687 41.127-15.687 56.829 0l105.563 105.554L279.721 11.767c15.705-15.687 41.139-15.687 56.832 0 15.705 15.699 15.705 41.145.006 56.844z\",\n },\n }),\n ]\n )\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\nexport { render, staticRenderFns }","\n\n\n","import { render, staticRenderFns } from \"./Delete.vue?vue&type=template&id=364b6320&\"\nimport script from \"./Delete.vue?vue&type=script&lang=js&\"\nexport * from \"./Delete.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('364b6320')) {\n api.createRecord('364b6320', component.options)\n } else {\n api.reload('364b6320', component.options)\n }\n module.hot.accept(\"./Delete.vue?vue&type=template&id=364b6320&\", function () {\n api.rerender('364b6320', {\n render: render,\n staticRenderFns: staticRenderFns\n })\n })\n }\n}\ncomponent.options.__file = \"src/components/icons/Delete.vue\"\nexport default component.exports","var render, staticRenderFns\nimport script from \"./MultiValueItem.vue?vue&type=script&lang=js&\"\nexport * from \"./MultiValueItem.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('6dd6c8ca')) {\n api.createRecord('6dd6c8ca', component.options)\n } else {\n api.reload('6dd6c8ca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MultiValueItem.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./MultiValue.vue?vue&type=script&lang=js&\"\nexport * from \"./MultiValue.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('14fca5e8')) {\n api.createRecord('14fca5e8', component.options)\n } else {\n api.reload('14fca5e8', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MultiValue.vue\"\nexport default component.exports","\n","var render = function () {\n var _vm = this\n var _h = _vm.$createElement\n var _c = _vm._self._c || _h\n return _c(\n \"svg\",\n {\n attrs: {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 292.362 292.362\",\n },\n },\n [\n _c(\"path\", {\n attrs: {\n d: \"M286.935 69.377c-3.614-3.617-7.898-5.424-12.848-5.424H18.274c-4.952 0-9.233 1.807-12.85 5.424C1.807 72.998 0 77.279 0 82.228c0 4.948 1.807 9.229 5.424 12.847l127.907 127.907c3.621 3.617 7.902 5.428 12.85 5.428s9.233-1.811 12.847-5.428L286.935 95.074c3.613-3.617 5.427-7.898 5.427-12.847 0-4.948-1.814-9.229-5.427-12.85z\",\n },\n }),\n ]\n )\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\nexport { render, staticRenderFns }","\n\n\n","import { render, staticRenderFns } from \"./Arrow.vue?vue&type=template&id=11186cd4&\"\nimport script from \"./Arrow.vue?vue&type=script&lang=js&\"\nexport * from \"./Arrow.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('11186cd4')) {\n api.createRecord('11186cd4', component.options)\n } else {\n api.reload('11186cd4', component.options)\n }\n module.hot.accept(\"./Arrow.vue?vue&type=template&id=11186cd4&\", function () {\n api.rerender('11186cd4', {\n render: render,\n staticRenderFns: staticRenderFns\n })\n })\n }\n}\ncomponent.options.__file = \"src/components/icons/Arrow.vue\"\nexport default component.exports","var render, staticRenderFns\nimport script from \"./Control.vue?vue&type=script&lang=js&\"\nexport * from \"./Control.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('2fa0a0dd')) {\n api.createRecord('2fa0a0dd', component.options)\n } else {\n api.reload('2fa0a0dd', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Control.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./Tip.vue?vue&type=script&lang=js&\"\nexport * from \"./Tip.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('9f31bdca')) {\n api.createRecord('9f31bdca', component.options)\n } else {\n api.reload('9f31bdca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Tip.vue\"\nexport default component.exports","\n","\n","var render, staticRenderFns\nimport script from \"./Option.vue?vue&type=script&lang=js&\"\nexport * from \"./Option.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('3dddec25')) {\n api.createRecord('3dddec25', component.options)\n } else {\n api.reload('3dddec25', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Option.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./Menu.vue?vue&type=script&lang=js&\"\nexport * from \"./Menu.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('9bcc0be2')) {\n api.createRecord('9bcc0be2', component.options)\n } else {\n api.reload('9bcc0be2', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Menu.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./MenuPortal.vue?vue&type=script&lang=js&\"\nexport * from \"./MenuPortal.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('4802d94a')) {\n api.createRecord('4802d94a', component.options)\n } else {\n api.reload('4802d94a', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MenuPortal.vue\"\nexport default component.exports","var render, staticRenderFns\nimport script from \"./Treeselect.vue?vue&type=script&lang=js&\"\nexport * from \"./Treeselect.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('aebf116c')) {\n api.createRecord('aebf116c', component.options)\n } else {\n api.reload('aebf116c', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Treeselect.vue\"\nexport default component.exports","\n","import Treeselect from './components/Treeselect'\nimport treeselectMixin from './mixins/treeselectMixin'\nimport './style.less'\n\nexport default Treeselect\nexport { Treeselect, treeselectMixin }\nexport {\n // Delayed loading.\n LOAD_ROOT_OPTIONS,\n LOAD_CHILDREN_OPTIONS,\n ASYNC_SEARCH,\n} from './constants'\n\nexport const VERSION = PKG_VERSION\n"],"sourceRoot":""} \ No newline at end of file diff --git a/dist/vue-treeselect.css b/dist/vue-treeselect.css new file mode 100644 index 00000000..bc445763 --- /dev/null +++ b/dist/vue-treeselect.css @@ -0,0 +1,952 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2022 Riophae Lee + * Released under the MIT License. + * https://vue-treeselect.js.org/ + */ +/** + * Dependencies + */ +/** + * Variables + */ +/** + * Mixins + */ +/** + * Helpers + */ +.vue-treeselect-helper-hide { + display: none; +} +.vue-treeselect-helper-zoom-effect-off { + -ms-transform: none !important; + transform: none !important; +} +/** + * Animations + */ +@keyframes vue-treeselect-animation-fade-in { + 0% { + opacity: 0; + } +} +@keyframes vue-treeselect-animation-bounce { + 0%, + 100% { + transform: scale(0); + } + 50% { + transform: scale(1); + } +} +@keyframes vue-treeselect-animation-rotate { + 100% { + transform: rotate(360deg); + } +} +/** + * Transitions + */ +.vue-treeselect__multi-value-item--transition-enter-active, +.vue-treeselect__multi-value-item--transition-leave-active { + transition-duration: 200ms; + transition-property: transform, opacity; +} +.vue-treeselect__multi-value-item--transition-enter-active { + transition-timing-function: cubic-bezier(0.075, 0.82, 0.165, 1); +} +.vue-treeselect__multi-value-item--transition-leave-active { + transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1); + position: absolute; +} +.vue-treeselect__multi-value-item--transition-enter, +.vue-treeselect__multi-value-item--transition-leave-to { + -ms-transform: scale(0.7); + transform: scale(0.7); + opacity: 0; +} +.vue-treeselect__multi-value-item--transition-move { + transition: 200ms transform cubic-bezier(0.165, 0.84, 0.44, 1); +} +/** + * Namespace + */ +.vue-treeselect { + position: relative; + text-align: left; +} +[dir="rtl"] .vue-treeselect { + text-align: right; +} +.vue-treeselect div, +.vue-treeselect span { + box-sizing: border-box; +} +.vue-treeselect svg { + fill: currentColor; +} +/** + * Control + */ +.vue-treeselect__control { + padding-left: 5px; + padding-right: 5px; + display: table; + table-layout: fixed; + width: 100%; + height: 36px; + border: 1px solid #ddd; + border-radius: 5px; + background: #fff; + transition-duration: 200ms; + transition-property: border-color, box-shadow, width, height, background-color, opacity; + transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1); +} +.vue-treeselect:not(.vue-treeselect--disabled):not(.vue-treeselect--focused) .vue-treeselect__control:hover { + border-color: #cfcfcf; +} +.vue-treeselect--focused:not(.vue-treeselect--open) .vue-treeselect__control { + border-color: #039be5; + box-shadow: 0 0 0 3px rgba(3, 155, 229, 0.1); +} +.vue-treeselect--disabled .vue-treeselect__control { + background-color: #f9f9f9; +} +.vue-treeselect--open .vue-treeselect__control { + border-color: #cfcfcf; +} +.vue-treeselect--open.vue-treeselect--open-below .vue-treeselect__control { + border-bottom-left-radius: 0; + border-bottom-right-radius: 0; +} +.vue-treeselect--open.vue-treeselect--open-above .vue-treeselect__control { + border-top-left-radius: 0; + border-top-right-radius: 0; +} +.vue-treeselect__value-container, +.vue-treeselect__multi-value { + width: 100%; + vertical-align: middle; +} +.vue-treeselect__value-container { + display: table-cell; + position: relative; +} +.vue-treeselect--searchable:not(.vue-treeselect--disabled) .vue-treeselect__value-container { + cursor: text; +} +.vue-treeselect__multi-value { + display: inline-block; +} +.vue-treeselect--has-value .vue-treeselect__multi-value { + margin-bottom: 5px; +} +.vue-treeselect__placeholder, +.vue-treeselect__single-value { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + padding-left: 5px; + padding-right: 5px; + position: absolute; + top: 0; + right: 0; + bottom: 0; + left: 0; + line-height: 34px; + -webkit-user-select: none; + -ms-user-select: none; + user-select: none; + pointer-events: none; +} +.vue-treeselect__placeholder { + color: #bdbdbd; +} +.vue-treeselect__single-value { + color: #333; +} +.vue-treeselect--focused.vue-treeselect--searchable .vue-treeselect__single-value { + color: #bdbdbd; +} +.vue-treeselect--disabled .vue-treeselect__single-value { + position: static; +} +.vue-treeselect__multi-value-item-container { + display: inline-block; + padding-top: 5px; + padding-right: 5px; + vertical-align: top; +} +[dir="rtl"] .vue-treeselect__multi-value-item-container { + padding-right: 0; + padding-left: 5px; +} +.vue-treeselect__multi-value-item { + cursor: pointer; + display: inline-table; + background: #e3f2fd; + padding: 2px 0; + border: 1px solid transparent; + border-radius: 2px; + color: #039be5; + font-size: 12px; + vertical-align: top; +} +.vue-treeselect:not(.vue-treeselect--disabled) .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-disabled):hover .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-new) .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-new):hover { + cursor: pointer; + background: #e3f2fd; + color: #039be5; +} +.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-disabled { + cursor: default; + background: #f5f5f5; + color: #757575; +} +.vue-treeselect--disabled .vue-treeselect__multi-value-item { + cursor: default; + background: #fff; + border-color: #e5e5e5; + color: #555; +} +.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-new { + background: #e8f5e9; +} +.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-new:hover { + background: #e8f5e9; +} +.vue-treeselect__value-remove, +.vue-treeselect__multi-value-label { + display: table-cell; + padding: 0 5px; + vertical-align: middle; +} +.vue-treeselect__value-remove { + color: #039be5; + padding-left: 5px; + border-left: 1px solid #fff; + line-height: 0; +} +[dir="rtl"] .vue-treeselect__value-remove { + border-left: 0 none; + border-right: 1px solid #fff; +} +.vue-treeselect__multi-value-item:hover .vue-treeselect__value-remove { + color: #e53935; +} +.vue-treeselect--disabled .vue-treeselect__value-remove, +.vue-treeselect__multi-value-item-disabled .vue-treeselect__value-remove { + display: none; +} +.vue-treeselect__value-remove > svg { + width: 6px; + height: 6px; +} +.vue-treeselect__multi-value-label { + padding-right: 5px; + white-space: pre-line; + -webkit-user-select: none; + -ms-user-select: none; + user-select: none; +} +.vue-treeselect__limit-tip { + display: inline-block; + padding-top: 5px; + padding-right: 5px; + vertical-align: top; +} +[dir="rtl"] .vue-treeselect__limit-tip { + padding-right: 0; + padding-left: 5px; +} +.vue-treeselect__limit-tip-text { + cursor: default; + display: block; + margin: 2px 0; + padding: 1px 0; + color: #bdbdbd; + font-size: 12px; + font-weight: 600; +} +.vue-treeselect__input-container { + display: block; + max-width: 100%; + outline: none; +} +.vue-treeselect--single .vue-treeselect__input-container { + font-size: inherit; + height: 100%; +} +.vue-treeselect--multi .vue-treeselect__input-container { + display: inline-block; + font-size: 12px; + vertical-align: top; +} +.vue-treeselect--searchable .vue-treeselect__input-container { + padding-left: 5px; + padding-right: 5px; +} +.vue-treeselect--searchable.vue-treeselect--multi.vue-treeselect--has-value .vue-treeselect__input-container { + padding-top: 5px; + padding-left: 0; +} +[dir="rtl"] .vue-treeselect--searchable.vue-treeselect--multi.vue-treeselect--has-value .vue-treeselect__input-container { + padding-left: 5px; + padding-right: 0; +} +.vue-treeselect--disabled .vue-treeselect__input-container { + display: none; +} +.vue-treeselect__input, +.vue-treeselect__sizer { + margin: 0; + line-height: inherit; + font-family: inherit; + font-size: inherit; +} +.vue-treeselect__input { + max-width: 100%; + margin: 0; + padding: 0; + border: 0; + outline: none; + box-sizing: content-box; + box-shadow: none; + background: none transparent; + line-height: 1; + vertical-align: middle; +} +.vue-treeselect__input::-ms-clear { + display: none; +} +.vue-treeselect--single .vue-treeselect__input { + width: 100%; + height: 100%; +} +.vue-treeselect--multi .vue-treeselect__input { + padding-top: 3px; + padding-bottom: 3px; +} +.vue-treeselect--has-value .vue-treeselect__input { + line-height: inherit; + vertical-align: top; +} +.vue-treeselect__sizer { + position: absolute; + top: 0; + left: 0; + visibility: hidden; + height: 0; + overflow: scroll; + white-space: pre; +} +.vue-treeselect__x-container { + display: table-cell; + vertical-align: middle; + width: 20px; + text-align: center; + line-height: 0; + cursor: pointer; + color: #ccc; + animation: 200ms vue-treeselect-animation-fade-in cubic-bezier(0.075, 0.82, 0.165, 1); +} +.vue-treeselect__x-container:hover { + color: #e53935; +} +.vue-treeselect__x { + width: 8px; + height: 8px; +} +.vue-treeselect__control-arrow-container { + display: table-cell; + vertical-align: middle; + width: 20px; + text-align: center; + line-height: 0; + cursor: pointer; +} +.vue-treeselect--disabled .vue-treeselect__control-arrow-container { + cursor: default; +} +.vue-treeselect__control-arrow { + width: 9px; + height: 9px; + color: #ccc; +} +.vue-treeselect:not(.vue-treeselect--disabled) .vue-treeselect__control-arrow-container:hover .vue-treeselect__control-arrow { + color: #616161; +} +.vue-treeselect--disabled .vue-treeselect__control-arrow { + opacity: 0.35; +} +.vue-treeselect__control-arrow--rotated { + -ms-transform: rotate(180deg); + transform: rotateZ(180deg); +} +/** + * Menu + */ +.vue-treeselect__menu-container { + position: absolute; + left: 0; + width: 100%; + overflow: visible; + transition: 0s; +} +.vue-treeselect--open-below:not(.vue-treeselect--append-to-body) .vue-treeselect__menu-container { + top: 100%; +} +.vue-treeselect--open-above:not(.vue-treeselect--append-to-body) .vue-treeselect__menu-container { + bottom: 100%; +} +.vue-treeselect__menu { + cursor: default; + padding-top: 5px; + padding-bottom: 5px; + display: block; + position: absolute; + overflow-x: hidden; + overflow-y: auto; + width: auto; + border: 1px solid #cfcfcf; + background: #fff; + line-height: 180%; + -webkit-overflow-scrolling: touch; +} +.vue-treeselect--open-below .vue-treeselect__menu { + border-bottom-left-radius: 5px; + border-bottom-right-radius: 5px; + top: 0; + margin-top: -1px; + border-top-color: #f2f2f2; + box-shadow: 0 1px 0 rgba(0, 0, 0, 0.06); +} +.vue-treeselect--open-above .vue-treeselect__menu { + border-top-left-radius: 5px; + border-top-right-radius: 5px; + bottom: 0; + margin-bottom: -1px; + border-bottom-color: #f2f2f2; +} +.vue-treeselect__indent-level-0 .vue-treeselect__option { + padding-left: 5px; +} +[dir="rtl"] .vue-treeselect__indent-level-0 .vue-treeselect__option { + padding-left: 5px; + padding-right: 5px; +} +.vue-treeselect__indent-level-0 .vue-treeselect__tip { + padding-left: 25px; +} +[dir="rtl"] .vue-treeselect__indent-level-0 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 25px; +} +.vue-treeselect__indent-level-1 .vue-treeselect__option { + padding-left: 25px; +} +[dir="rtl"] .vue-treeselect__indent-level-1 .vue-treeselect__option { + padding-left: 5px; + padding-right: 25px; +} +.vue-treeselect__indent-level-1 .vue-treeselect__tip { + padding-left: 45px; +} +[dir="rtl"] .vue-treeselect__indent-level-1 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 45px; +} +.vue-treeselect__indent-level-2 .vue-treeselect__option { + padding-left: 45px; +} +[dir="rtl"] .vue-treeselect__indent-level-2 .vue-treeselect__option { + padding-left: 5px; + padding-right: 45px; +} +.vue-treeselect__indent-level-2 .vue-treeselect__tip { + padding-left: 65px; +} +[dir="rtl"] .vue-treeselect__indent-level-2 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 65px; +} +.vue-treeselect__indent-level-3 .vue-treeselect__option { + padding-left: 65px; +} +[dir="rtl"] .vue-treeselect__indent-level-3 .vue-treeselect__option { + padding-left: 5px; + padding-right: 65px; +} +.vue-treeselect__indent-level-3 .vue-treeselect__tip { + padding-left: 85px; +} +[dir="rtl"] .vue-treeselect__indent-level-3 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 85px; +} +.vue-treeselect__indent-level-4 .vue-treeselect__option { + padding-left: 85px; +} +[dir="rtl"] .vue-treeselect__indent-level-4 .vue-treeselect__option { + padding-left: 5px; + padding-right: 85px; +} +.vue-treeselect__indent-level-4 .vue-treeselect__tip { + padding-left: 105px; +} +[dir="rtl"] .vue-treeselect__indent-level-4 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 105px; +} +.vue-treeselect__indent-level-5 .vue-treeselect__option { + padding-left: 105px; +} +[dir="rtl"] .vue-treeselect__indent-level-5 .vue-treeselect__option { + padding-left: 5px; + padding-right: 105px; +} +.vue-treeselect__indent-level-5 .vue-treeselect__tip { + padding-left: 125px; +} +[dir="rtl"] .vue-treeselect__indent-level-5 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 125px; +} +.vue-treeselect__indent-level-6 .vue-treeselect__option { + padding-left: 125px; +} +[dir="rtl"] .vue-treeselect__indent-level-6 .vue-treeselect__option { + padding-left: 5px; + padding-right: 125px; +} +.vue-treeselect__indent-level-6 .vue-treeselect__tip { + padding-left: 145px; +} +[dir="rtl"] .vue-treeselect__indent-level-6 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 145px; +} +.vue-treeselect__indent-level-7 .vue-treeselect__option { + padding-left: 145px; +} +[dir="rtl"] .vue-treeselect__indent-level-7 .vue-treeselect__option { + padding-left: 5px; + padding-right: 145px; +} +.vue-treeselect__indent-level-7 .vue-treeselect__tip { + padding-left: 165px; +} +[dir="rtl"] .vue-treeselect__indent-level-7 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 165px; +} +.vue-treeselect__indent-level-8 .vue-treeselect__option { + padding-left: 165px; +} +[dir="rtl"] .vue-treeselect__indent-level-8 .vue-treeselect__option { + padding-left: 5px; + padding-right: 165px; +} +.vue-treeselect__indent-level-8 .vue-treeselect__tip { + padding-left: 185px; +} +[dir="rtl"] .vue-treeselect__indent-level-8 .vue-treeselect__tip { + padding-left: 5px; + padding-right: 185px; +} +.vue-treeselect__option { + padding-left: 5px; + padding-right: 5px; + display: table; + table-layout: fixed; + width: 100%; +} +.vue-treeselect__option--highlight { + background: #f5f5f5; +} +.vue-treeselect--single .vue-treeselect__option--selected { + background: #e3f2fd; + font-weight: 600; +} +.vue-treeselect--single .vue-treeselect__option--selected:hover { + background: #e3f2fd; +} +.vue-treeselect__option--hide { + display: none; +} +.vue-treeselect__option-arrow-container, +.vue-treeselect__option-arrow-placeholder { + display: table-cell; + vertical-align: middle; + width: 20px; + text-align: center; + line-height: 0; +} +.vue-treeselect__option-arrow-container { + cursor: pointer; +} +.vue-treeselect__option-arrow { + display: inline-block; + width: 9px; + height: 9px; + color: #ccc; + vertical-align: middle; + transition: 200ms transform cubic-bezier(0.19, 1, 0.22, 1); + -ms-transform: rotate(-90deg); + transform: rotateZ(-90deg); +} +[dir="rtl"] .vue-treeselect__option-arrow { + -ms-transform: rotate(90deg); + transform: rotateZ(90deg); +} +.vue-treeselect__option-arrow-container:hover .vue-treeselect__option-arrow, +.vue-treeselect--branch-nodes-disabled .vue-treeselect__option:hover .vue-treeselect__option-arrow { + color: #616161; +} +.vue-treeselect__option-arrow--rotated { + -ms-transform: rotate(0); + transform: rotateZ(0); +} +[dir="rtl"] .vue-treeselect__option-arrow--rotated { + -ms-transform: rotate(0); + transform: rotateZ(0); +} +.vue-treeselect__option-arrow--rotated.vue-treeselect__option-arrow--prepare-enter { + -ms-transform: rotate(-90deg) !important; + transform: rotateZ(-90deg) !important; +} +[dir="rtl"] .vue-treeselect__option-arrow--rotated.vue-treeselect__option-arrow--prepare-enter { + -ms-transform: rotate(90deg) !important; + transform: rotateZ(90deg) !important; +} +.vue-treeselect__label-container { + display: table-cell; + vertical-align: middle; + cursor: pointer; + display: table; + width: 100%; + table-layout: fixed; + color: inherit; +} +.vue-treeselect__option--disabled .vue-treeselect__label-container { + cursor: not-allowed; + color: rgba(0, 0, 0, 0.25); +} +.vue-treeselect__checkbox-container { + display: table-cell; + width: 20px; + min-width: 20px; + height: 100%; + text-align: center; + vertical-align: middle; +} +.vue-treeselect__checkbox { + display: block; + margin: auto; + width: 12px; + height: 12px; + border-width: 1px; + border-style: solid; + border-radius: 2px; + position: relative; + transition: 200ms all cubic-bezier(0.075, 0.82, 0.165, 1); +} +.vue-treeselect__check-mark, +.vue-treeselect__minus-mark { + display: block; + position: absolute; + left: 1px; + top: 1px; + background-repeat: no-repeat; + opacity: 0; + transition: 200ms all ease; +} +.vue-treeselect__minus-mark { + width: 8px; + height: 8px; + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAgMAAAC5YVYYAAAACVBMVEUAAAD///////9zeKVjAAAAAnRSTlMAuLMp9oYAAAAPSURBVAjXY4CDrJUgBAMAGaECJ9dz3BAAAAAASUVORK5CYII=); + background-size: 8px 8px; +} +@media (-webkit-min-device-pixel-ratio: 1.5), (min-resolution: 1.5dppx) { + .vue-treeselect__minus-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAADFBMVEUAAAD///////////84wDuoAAAAA3RSTlMAyTzPIdReAAAAGUlEQVQI12PAD+b///+Nof7//79gAsLFCwAx/w4blADeeQAAAABJRU5ErkJggg==); + } +} +@media (-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi) { + .vue-treeselect__minus-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAADFBMVEUAAAD///////////84wDuoAAAAA3RSTlMAyTzPIdReAAAAGUlEQVQI12PAD+b///+Nof7//79gAsLFCwAx/w4blADeeQAAAABJRU5ErkJggg==); + } +} +@media (-webkit-min-device-pixel-ratio: 3), (min-resolution: 288dpi) { + .vue-treeselect__minus-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYBAMAAAASWSDLAAAAD1BMVEUAAAD///////////////+PQt5oAAAABHRSTlMAy2EFIuWxUgAAACRJREFUGNNjGBBgJOICBY7KDCoucODEAJSAS6FwUJShGjAQAADBPRGrK2/FhgAAAABJRU5ErkJggg==); + } +} +.vue-treeselect__checkbox--indeterminate > .vue-treeselect__minus-mark { + opacity: 1; +} +.vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAgMAAAC5YVYYAAAACVBMVEUAAADi4uLh4eHOxeSRAAAAAnRSTlMAuLMp9oYAAAAPSURBVAjXY4CDrJUgBAMAGaECJ9dz3BAAAAAASUVORK5CYII=); +} +@media (-webkit-min-device-pixel-ratio: 1.5), (min-resolution: 1.5dppx) { + .vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAADFBMVEUAAADi4uLi4uLh4eE5RQaIAAAAA3RSTlMAyTzPIdReAAAAGUlEQVQI12PAD+b///+Nof7//79gAsLFCwAx/w4blADeeQAAAABJRU5ErkJggg==); + } +} +@media (-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi) { + .vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAADFBMVEUAAADi4uLi4uLh4eE5RQaIAAAAA3RSTlMAyTzPIdReAAAAGUlEQVQI12PAD+b///+Nof7//79gAsLFCwAx/w4blADeeQAAAABJRU5ErkJggg==); + } +} +@media (-webkit-min-device-pixel-ratio: 3), (min-resolution: 288dpi) { + .vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYBAMAAAASWSDLAAAAD1BMVEUAAADh4eHg4ODNzc3h4eEYfw2wAAAABHRSTlMAy2EFIuWxUgAAACRJREFUGNNjGBBgJOICBY7KDCoucODEAJSAS6FwUJShGjAQAADBPRGrK2/FhgAAAABJRU5ErkJggg==); + } +} +.vue-treeselect__check-mark { + width: 8px; + height: 8px; + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAMAAADz0U65AAAAQlBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////8IX9KGAAAAFXRSTlMA8u24NxILB+Tawb6jiH1zRz0xIQIIP3GUAAAAMklEQVQI1y3FtQEAMQDDQD+EGbz/qkEVOpyEOP6PudKjZNSXn4Jm2CKRdBKzSLsFWl8fMG0Bl6Jk1rMAAAAASUVORK5CYII=); + background-size: 8px 8px; + -ms-transform: scaleY(0.125); + transform: scaleY(0.125); +} +@media (-webkit-min-device-pixel-ratio: 1.5), (min-resolution: 1.5dppx) { + .vue-treeselect__check-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAYFBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////98JRy6AAAAH3RSTlMAzu4sDenl38fBvo1OMyIdEQrj1cSihX5hYFpHNycIcQOASAAAAF9JREFUGNN9zEcOgDAMRFHTS0LvNfe/JRmHKAIJ/mqeLJn+k9uDtaeUeFnFziGsBucUTirrprfe81RqZ3Bb6hPWeuZwDFOHyf+ig9CCzQ7INBn7bG5kF+QSt13BHNJnF7AaCT4Y+CW7AAAAAElFTkSuQmCC); + } +} +@media (-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi) { + .vue-treeselect__check-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAYFBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////98JRy6AAAAH3RSTlMAzu4sDenl38fBvo1OMyIdEQrj1cSihX5hYFpHNycIcQOASAAAAF9JREFUGNN9zEcOgDAMRFHTS0LvNfe/JRmHKAIJ/mqeLJn+k9uDtaeUeFnFziGsBucUTirrprfe81RqZ3Bb6hPWeuZwDFOHyf+ig9CCzQ7INBn7bG5kF+QSt13BHNJnF7AaCT4Y+CW7AAAAAElFTkSuQmCC); + } +} +@media (-webkit-min-device-pixel-ratio: 3), (min-resolution: 288dpi) { + .vue-treeselect__check-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAWlBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////9ZMre9AAAAHXRSTlMA/PiJhGNI9XlEHJB/b2ldV08+Oibk49vPp6QhAYgGBuwAAACCSURBVCjPrdHdDoIwDAXgTWAqCigo/+f9X5OwnoUwtis4V92XNWladUl+rzQPeQJAN2EHxoOnsPn7/oYk8fxBv08Rr/deOH/aZ2Nm8ZJ+s573QGfWKnNuZGzWm3+lv2V3pcU1XQ385/yjmBoM3Z+dXvlbYLLD3ujhTaOM3KaIXvNkFkuSEvYy1LqOAAAAAElFTkSuQmCC); + } +} +.vue-treeselect__checkbox--checked > .vue-treeselect__check-mark { + opacity: 1; + -ms-transform: scaleY(1); + transform: scaleY(1); +} +.vue-treeselect__checkbox--disabled .vue-treeselect__check-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAMAAADz0U65AAAAP1BMVEUAAADj4+Pf39/h4eHh4eHh4eHk5OTh4eHg4ODi4uLh4eHh4eHg4ODh4eHh4eHg4ODh4eHh4eHp6en////h4eFqcyvUAAAAFHRSTlMAOQfy7bgS5NrBvqOIfXNHMSELAgQ/iFsAAAA2SURBVAjXY4AANjYIzcjMAaVFuBkY+RkEWERYmRjYRXjANAOfiIgIFxNIAa8IpxBEi6AwiAQAK2MBd7xY8csAAAAASUVORK5CYII=); +} +@media (-webkit-min-device-pixel-ratio: 1.5), (min-resolution: 1.5dppx) { + .vue-treeselect__checkbox--disabled .vue-treeselect__check-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAXVBMVEUAAADh4eHh4eHh4eHi4uLb29vh4eHh4eHh4eHh4eHh4eHh4eHh4eHi4uLi4uLj4+Pi4uLk5OTo6Ojh4eHh4eHi4uLg4ODg4ODh4eHg4ODh4eHf39/g4OD////h4eEzIk+wAAAAHnRSTlMAzu6/LA3p5eLZx8ONTjYiHRIKooV+YWBaRzEnCANnm5rnAAAAZElEQVQY033P2wqAIAyA4VWaaWrnc/n+j5mbhBjUf7WPoTD47TJb4i5zTr/sRDRHuyFaoWX7uK/RlbctlPEuyI1f4WY9yQINEkf6rzzo8YIzmUFoCs7J1EjeIaa9bXIEmzl8dgOZEAj/+2IvzAAAAABJRU5ErkJggg==); + } +} +@media (-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi) { + .vue-treeselect__checkbox--disabled .vue-treeselect__check-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAXVBMVEUAAADh4eHh4eHh4eHi4uLb29vh4eHh4eHh4eHh4eHh4eHh4eHh4eHi4uLi4uLj4+Pi4uLk5OTo6Ojh4eHh4eHi4uLg4ODg4ODh4eHg4ODh4eHf39/g4OD////h4eEzIk+wAAAAHnRSTlMAzu6/LA3p5eLZx8ONTjYiHRIKooV+YWBaRzEnCANnm5rnAAAAZElEQVQY033P2wqAIAyA4VWaaWrnc/n+j5mbhBjUf7WPoTD47TJb4i5zTr/sRDRHuyFaoWX7uK/RlbctlPEuyI1f4WY9yQINEkf6rzzo8YIzmUFoCs7J1EjeIaa9bXIEmzl8dgOZEAj/+2IvzAAAAABJRU5ErkJggg==); + } +} +@media (-webkit-min-device-pixel-ratio: 3), (min-resolution: 288dpi) { + .vue-treeselect__checkbox--disabled .vue-treeselect__check-mark { + background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAUVBMVEUAAADh4eHh4eHh4eHh4eHi4uLi4uLh4eHh4eHh4eHf39/j4+Ph4eHh4eHh4eHg4ODi4uLh4eHh4eHi4uLh4eHh4eHh4eHh4eHh4eH////h4eF3FMFTAAAAGnRSTlMA+/eJhGhfSHE9JBzz5KaQf3pXT0Xbz0I5AYDw8F0AAAB+SURBVCjPrdHbDoMgEEVRKAii1dZe9fz/hxplTiKIT7qfYCWTEEZdUvOwbckNAD2WHeh3brHW5f5EzGQ+iN+b1Gt6KPvtv16Dn6JX9M9ya3/A1yfu5dlyduL6Hec7mXY6ddXLPP2lpABGZ8PWXfYLTJxZekVhhl7eTX24zZPNKXoRC7zQLjUAAAAASUVORK5CYII=); + } +} +.vue-treeselect__checkbox--unchecked { + border-color: #e0e0e0; + background: #fff; +} +.vue-treeselect__label-container:hover .vue-treeselect__checkbox--unchecked { + border-color: #039be5; + background: #fff; +} +.vue-treeselect__checkbox--indeterminate { + border-color: #039be5; + background: #039be5; +} +.vue-treeselect__label-container:hover .vue-treeselect__checkbox--indeterminate { + border-color: #039be5; + background: #039be5; +} +.vue-treeselect__checkbox--checked { + border-color: #039be5; + background: #039be5; +} +.vue-treeselect__label-container:hover .vue-treeselect__checkbox--checked { + border-color: #039be5; + background: #039be5; +} +.vue-treeselect__checkbox--disabled { + border-color: #e0e0e0; + background-color: #f7f7f7; +} +.vue-treeselect__label-container:hover .vue-treeselect__checkbox--disabled { + border-color: #e0e0e0; + background-color: #f7f7f7; +} +.vue-treeselect__label { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + display: table-cell; + padding-left: 5px; + max-width: 100%; + vertical-align: middle; + cursor: inherit; +} +[dir="rtl"] .vue-treeselect__label { + padding-left: 0; + padding-right: 5px; +} +.vue-treeselect__count { + margin-left: 5px; + font-weight: 400; + opacity: 0.6; +} +[dir="rtl"] .vue-treeselect__count { + margin-left: 0; + margin-right: 5px; +} +.vue-treeselect__tip { + padding-left: 5px; + padding-right: 5px; + display: table; + table-layout: fixed; + width: 100%; + color: #757575; +} +.vue-treeselect__tip-text { + display: table-cell; + vertical-align: middle; + padding-left: 5px; + padding-right: 5px; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + width: 100%; + font-size: 12px; +} +.vue-treeselect__error-tip .vue-treeselect__retry { + cursor: pointer; + margin-left: 5px; + font-style: normal; + font-weight: 600; + text-decoration: none; + color: #039be5; +} +[dir="rtl"] .vue-treeselect__error-tip .vue-treeselect__retry { + margin-left: 0; + margin-right: 5px; +} +.vue-treeselect__icon-container { + display: table-cell; + vertical-align: middle; + width: 20px; + text-align: center; + line-height: 0; +} +.vue-treeselect--single .vue-treeselect__icon-container { + padding-left: 5px; +} +[dir="rtl"] .vue-treeselect--single .vue-treeselect__icon-container { + padding-left: 0; + padding-right: 5px; +} +.vue-treeselect__icon-warning { + display: block; + margin: auto; + border-radius: 50%; + position: relative; + width: 12px; + height: 12px; + background: #fb8c00; +} +.vue-treeselect__icon-warning::after { + display: block; + position: absolute; + content: ""; + left: 5px; + top: 2.5px; + width: 2px; + height: 1px; + border: 0 solid #fff; + border-top-width: 5px; + border-bottom-width: 1px; +} +.vue-treeselect__icon-error { + display: block; + margin: auto; + border-radius: 50%; + position: relative; + width: 12px; + height: 12px; + background: #e53935; +} +.vue-treeselect__icon-error::before, +.vue-treeselect__icon-error::after { + display: block; + position: absolute; + content: ""; + background: #fff; + -ms-transform: rotate(45deg); + transform: rotate(45deg); +} +.vue-treeselect__icon-error::before { + width: 6px; + height: 2px; + left: 3px; + top: 5px; +} +.vue-treeselect__icon-error::after { + width: 2px; + height: 6px; + left: 5px; + top: 3px; +} +.vue-treeselect__icon-loader { + display: block; + margin: auto; + position: relative; + width: 12px; + height: 12px; + text-align: center; + animation: 1.6s vue-treeselect-animation-rotate linear infinite; +} +.vue-treeselect__icon-loader::before, +.vue-treeselect__icon-loader::after { + border-radius: 50%; + position: absolute; + content: ""; + left: 0; + top: 0; + display: block; + width: 100%; + height: 100%; + opacity: 0.6; + animation: 1.6s vue-treeselect-animation-bounce ease-in-out infinite; +} +.vue-treeselect__icon-loader::before { + background: #039be5; +} +.vue-treeselect__icon-loader::after { + background: #b3e5fc; + animation-delay: -0.8s; +} +/** + * Menu Portal + */ +.vue-treeselect__menu-placeholder { + display: none; +} +.vue-treeselect__portal-target { + position: absolute; + display: block; + left: 0; + top: 0; + height: 0; + width: 0; + padding: 0; + margin: 0; + border: 0; + overflow: visible; + box-sizing: border-box; +} + + +/*# sourceMappingURL=vue-treeselect.css.map*/ \ No newline at end of file diff --git a/dist/vue-treeselect.css.map b/dist/vue-treeselect.css.map new file mode 100644 index 00000000..d784806e --- /dev/null +++ b/dist/vue-treeselect.css.map @@ -0,0 +1 @@ +{"version":3,"sources":["webpack://VueTreeselect/style.less","webpack://VueTreeselect/./src/style.less","webpack://VueTreeselect/./node_modules/material-colors/dist/colors.less"],"names":[],"mappings":"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EACE;EACA;ADjUR;AE5bC;EDgvBK;ADjTN;ACmTM;EACE;EACA;ADjTR;AEncC;EDyvBK;ADnTN;ACqTM;EACE;EACA;ADnTR;AE1cC;EDgvBK;ADnSN;ACqSM;EACE;EACA;ADnSR;AEjdC;EDyvBK;ADrSN;ACuSM;EACE;EACA;ADrSR;AExdC;EDgvBK;ADrRN;ACuRM;EACE;EACA;ADrRR;AE/dC;EDyvBK;ADvRN;ACyRM;EACE;EACA;ADvRR;AEteC;EDgvBK;ADvQN;ACyQM;EACE;EACA;ADvQR;AE7eC;EDyvBK;ADzQN;AC2QM;EACE;EACA;ADzQR;AEpfC;EDgvBK;ADzPN;AC2PM;EACE;EACA;ADzPR;AE3fC;EDyvBK;AD3PN;AC6PM;EACE;EACA;AD3PR;AElgBC;EDgvBK;AD3ON;AC6OM;EACE;EACA;AD3OR;AEzgBC;EDyvBK;AD7ON;AC+OM;EACE;EACA;AD7OR;AEhhBC;EDgvBK;AD7NN;AC+NM;EACE;EACA;AD7NR;AEvhBC;EDyvBK;AD/NN;ACiOM;EACE;EACA;AD/NR;ACsOA;EApmBE;EACA;EAgBA;EACA;EACA;ADkXF;ACmOA;EACE;ADjOF;ACsOE;EACE;EACA;ADpOJ;ACsOI;EACE;ADpON;ACyOA;EACE;ADvOF;AC0OA;;EArmBE;EACA;EAcA;EACA;EACA;ADkXF;ACuOA;EArqBE;ADicF;ACwOA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;MAAA;ADtOF;ACwOE;EACE;MAAA;ADtOJ;ACyOE;;EAEE;ADvOJ;AC2OA;EACE;MAAA;ADzOF;AC2OE;EACE;MAAA;ADzOJ;AC4OE;EACE;MAAA;AD1OJ;AC4OI;EACE;MAAA;AD1ON;AC+OA;EAjpBE;EACA;EA5DA;EAgtBA;EACA;EACA;EACA;AD7OF;AC+OE;EA7sBA;EAgtBE;AD9OJ;ACkPA;EACE;EACA;EACA;EACA;EACA;EACA;ADhPF;ACmPA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;ADjPF;ACoPA;;EAEE;EACA;EACA;EACA;EACA;EACA;EACA;ADlPF;ACqPA;EACE;EACA;EA1qBA;EA+qBA;ADtPF;ACvbE;EAAA;IACE;ED0bF;AACF;ACrbM;EAAA;IACE;EDwbN;AACF;AC1bM;EAAA;IACE;ED6bN;AACF;ACyOE;EACE;ADvOJ;AC0OE;EArrBA;AD8cF;AC5cE;EAAA;IACE;ED+cF;AACF;AC1cM;EAAA;IACE;ED6cN;AACF;AC/cM;EAAA;IACE;EDkdN;AACF;AC6NA;EACE;EACA;EA5rBA;EA8rBA;EAEA;MAAA;AD5NF;ACleE;EAAA;IACE;EDqeF;AACF;ACheM;EAAA;IACE;EDmeN;AACF;ACreM;EAAA;IACE;EDweN;AACF;AC+ME;EACE;EACA;MAAA;AD7MJ;ACgNE;EAvsBA;AD0fF;ACxfE;EAAA;IACE;ED2fF;AACF;ACtfM;EAAA;IACE;EDyfN;AACF;AC3fM;EAAA;IACE;ED8fN;AACF;ACmMA;EACE;EACA;ADjMF;ACmME;EACE;EACA;ADjMJ;ACqMA;EACE;EACA;ADnMF;ACqME;EACE;EACA;ADnMJ;ACuMA;EACE;EACA;ADrMF;ACuME;EACE;EACA;ADrMJ;ACyMA;EACE;EACA;ADvMF;ACyME;EACE;EACA;ADvMJ;AC4MA;EA3yBE;EACA;EACA;EA4yBA;EACA;EACA;EACA;EACA;ADzMF;AC2ME;EACE;EACA;ADzMJ;AC6MA;EACE;EACA;EACA;AD3MF;AC6ME;EACE;EACA;AD3MJ;AC+MA;EA/zBE;EACA;EAgBA;EACA;EACA;EA+yBA;AD1MF;AC6MA;EA9yBE;EACA;EAxBA;EACA;EAPA;EACA;EACA;EAoCA;EAwyBA;ADrMF;ACyME;EAh3BA;EAm3BE;EACA;EACA;EACA;EACA;ADxMJ;AC0MI;EACE;EACA;ADxMN;AC6MA;EAr0BE;EACA;EAcA;EACA;EACA;AD8mBF;ACyME;EACE;ADvMJ;ACyMI;EACE;EACA;ADvMN;AC4MA;EA/1BE;EACA;EA/BA;EAi4BA;EACA;EACA;EACA;AD1MF;AC4ME;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;AD1MJ;AC8MA;EAt3BE;EACA;EA/BA;EA05BA;EACA;EACA;EACA;AD9MF;ACgNE;;EAEE;EACA;EACA;EACA;EACA;MAAA;AD9MJ;ACiNE;EACE;EACA;EACA;EACA;AD/MJ;ACkNE;EACE;EACA;EACA;EACA;ADhNJ;ACoNA;EAz5BE;EACA;EA25BA;EACA;EACA;EACA;EACA;ADlNF;ACoNE;;EAh8BA;EAo8BE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;ADnNJ;ACsNE;EACE;ADpNJ;ACuNE;EACE;EACA;ADrNJ;AACA;;EAEE;AC2NF;EACE;ADzNF;AC4NA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;AD1NF","file":"vue-treeselect.css","sourcesContent":["/**\n * Dependencies\n */\n/**\n * Variables\n */\n/**\n * Mixins\n */\n/**\n * Helpers\n */\n.vue-treeselect-helper-hide {\n display: none;\n}\n.vue-treeselect-helper-zoom-effect-off {\n transform: none !important;\n}\n/**\n * Animations\n */\n@keyframes vue-treeselect-animation-fade-in {\n 0% {\n opacity: 0;\n }\n}\n@keyframes vue-treeselect-animation-bounce {\n 0%,\n 100% {\n transform: scale(0);\n }\n 50% {\n transform: scale(1);\n }\n}\n@keyframes vue-treeselect-animation-rotate {\n 100% {\n transform: rotate(360deg);\n }\n}\n/**\n * Transitions\n */\n.vue-treeselect__multi-value-item--transition-enter-active,\n.vue-treeselect__multi-value-item--transition-leave-active {\n transition-duration: 200ms;\n transition-property: transform, opacity;\n}\n.vue-treeselect__multi-value-item--transition-enter-active {\n transition-timing-function: cubic-bezier(0.075, 0.82, 0.165, 1);\n}\n.vue-treeselect__multi-value-item--transition-leave-active {\n transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);\n position: absolute;\n}\n.vue-treeselect__multi-value-item--transition-enter,\n.vue-treeselect__multi-value-item--transition-leave-to {\n transform: scale(0.7);\n opacity: 0;\n}\n.vue-treeselect__multi-value-item--transition-move {\n transition: 200ms transform cubic-bezier(0.165, 0.84, 0.44, 1);\n}\n/**\n * Namespace\n */\n.vue-treeselect {\n position: relative;\n text-align: left;\n}\n[dir=\"rtl\"] .vue-treeselect {\n text-align: right;\n}\n.vue-treeselect div,\n.vue-treeselect span {\n box-sizing: border-box;\n}\n.vue-treeselect svg {\n fill: currentColor;\n}\n/**\n * Control\n */\n.vue-treeselect__control {\n padding-left: 5px;\n padding-right: 5px;\n display: table;\n table-layout: fixed;\n width: 100%;\n height: 36px;\n border: 1px solid #ddd;\n border-radius: 5px;\n background: #fff;\n transition-duration: 200ms;\n transition-property: border-color, box-shadow, width, height, background-color, opacity;\n transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);\n}\n.vue-treeselect:not(.vue-treeselect--disabled):not(.vue-treeselect--focused) .vue-treeselect__control:hover {\n border-color: #cfcfcf;\n}\n.vue-treeselect--focused:not(.vue-treeselect--open) .vue-treeselect__control {\n border-color: #039be5;\n box-shadow: 0 0 0 3px rgba(3, 155, 229, 0.1);\n}\n.vue-treeselect--disabled .vue-treeselect__control {\n background-color: #f9f9f9;\n}\n.vue-treeselect--open .vue-treeselect__control {\n border-color: #cfcfcf;\n}\n.vue-treeselect--open.vue-treeselect--open-below .vue-treeselect__control {\n border-bottom-left-radius: 0;\n border-bottom-right-radius: 0;\n}\n.vue-treeselect--open.vue-treeselect--open-above .vue-treeselect__control {\n border-top-left-radius: 0;\n border-top-right-radius: 0;\n}\n.vue-treeselect__value-container,\n.vue-treeselect__multi-value {\n width: 100%;\n vertical-align: middle;\n}\n.vue-treeselect__value-container {\n display: table-cell;\n position: relative;\n}\n.vue-treeselect--searchable:not(.vue-treeselect--disabled) .vue-treeselect__value-container {\n cursor: text;\n}\n.vue-treeselect__multi-value {\n display: inline-block;\n}\n.vue-treeselect--has-value .vue-treeselect__multi-value {\n margin-bottom: 5px;\n}\n.vue-treeselect__placeholder,\n.vue-treeselect__single-value {\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n padding-left: 5px;\n padding-right: 5px;\n position: absolute;\n top: 0;\n right: 0;\n bottom: 0;\n left: 0;\n line-height: 34px;\n user-select: none;\n pointer-events: none;\n}\n.vue-treeselect__placeholder {\n color: #bdbdbd;\n}\n.vue-treeselect__single-value {\n color: #333;\n}\n.vue-treeselect--focused.vue-treeselect--searchable .vue-treeselect__single-value {\n color: #bdbdbd;\n}\n.vue-treeselect--disabled .vue-treeselect__single-value {\n position: static;\n}\n.vue-treeselect__multi-value-item-container {\n display: inline-block;\n padding-top: 5px;\n padding-right: 5px;\n vertical-align: top;\n}\n[dir=\"rtl\"] .vue-treeselect__multi-value-item-container {\n padding-right: 0;\n padding-left: 5px;\n}\n.vue-treeselect__multi-value-item {\n cursor: pointer;\n display: inline-table;\n background: #e3f2fd;\n padding: 2px 0;\n border: 1px solid transparent;\n border-radius: 2px;\n color: #039be5;\n font-size: 12px;\n vertical-align: top;\n}\n.vue-treeselect:not(.vue-treeselect--disabled) .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-disabled):hover .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-new) .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-new):hover {\n cursor: pointer;\n background: #e3f2fd;\n color: #039be5;\n}\n.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-disabled {\n cursor: default;\n background: #f5f5f5;\n color: #757575;\n}\n.vue-treeselect--disabled .vue-treeselect__multi-value-item {\n cursor: default;\n background: #fff;\n border-color: #e5e5e5;\n color: #555;\n}\n.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-new {\n background: #e8f5e9;\n}\n.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-new:hover {\n background: #e8f5e9;\n}\n.vue-treeselect__value-remove,\n.vue-treeselect__multi-value-label {\n display: table-cell;\n padding: 0 5px;\n vertical-align: middle;\n}\n.vue-treeselect__value-remove {\n color: #039be5;\n padding-left: 5px;\n border-left: 1px solid #fff;\n line-height: 0;\n}\n[dir=\"rtl\"] .vue-treeselect__value-remove {\n border-left: 0 none;\n border-right: 1px solid #fff;\n}\n.vue-treeselect__multi-value-item:hover .vue-treeselect__value-remove {\n color: #e53935;\n}\n.vue-treeselect--disabled .vue-treeselect__value-remove,\n.vue-treeselect__multi-value-item-disabled .vue-treeselect__value-remove {\n display: none;\n}\n.vue-treeselect__value-remove > svg {\n width: 6px;\n height: 6px;\n}\n.vue-treeselect__multi-value-label {\n padding-right: 5px;\n white-space: pre-line;\n user-select: none;\n}\n.vue-treeselect__limit-tip {\n display: inline-block;\n padding-top: 5px;\n padding-right: 5px;\n vertical-align: top;\n}\n[dir=\"rtl\"] .vue-treeselect__limit-tip {\n padding-right: 0;\n padding-left: 5px;\n}\n.vue-treeselect__limit-tip-text {\n cursor: default;\n display: block;\n margin: 2px 0;\n padding: 1px 0;\n color: #bdbdbd;\n font-size: 12px;\n font-weight: 600;\n}\n.vue-treeselect__input-container {\n display: block;\n max-width: 100%;\n outline: none;\n}\n.vue-treeselect--single .vue-treeselect__input-container {\n font-size: inherit;\n height: 100%;\n}\n.vue-treeselect--multi .vue-treeselect__input-container {\n display: inline-block;\n font-size: 12px;\n vertical-align: top;\n}\n.vue-treeselect--searchable .vue-treeselect__input-container {\n padding-left: 5px;\n padding-right: 5px;\n}\n.vue-treeselect--searchable.vue-treeselect--multi.vue-treeselect--has-value .vue-treeselect__input-container {\n padding-top: 5px;\n padding-left: 0;\n}\n[dir=\"rtl\"] .vue-treeselect--searchable.vue-treeselect--multi.vue-treeselect--has-value .vue-treeselect__input-container {\n padding-left: 5px;\n padding-right: 0;\n}\n.vue-treeselect--disabled .vue-treeselect__input-container {\n display: none;\n}\n.vue-treeselect__input,\n.vue-treeselect__sizer {\n margin: 0;\n line-height: inherit;\n font-family: inherit;\n font-size: inherit;\n}\n.vue-treeselect__input {\n max-width: 100%;\n margin: 0;\n padding: 0;\n border: 0;\n outline: none;\n box-sizing: content-box;\n box-shadow: none;\n background: none transparent;\n line-height: 1;\n vertical-align: middle;\n}\n.vue-treeselect__input::-ms-clear {\n display: none;\n}\n.vue-treeselect--single .vue-treeselect__input {\n width: 100%;\n height: 100%;\n}\n.vue-treeselect--multi .vue-treeselect__input {\n padding-top: 3px;\n padding-bottom: 3px;\n}\n.vue-treeselect--has-value .vue-treeselect__input {\n line-height: inherit;\n vertical-align: top;\n}\n.vue-treeselect__sizer {\n position: absolute;\n top: 0;\n left: 0;\n visibility: hidden;\n height: 0;\n overflow: scroll;\n white-space: pre;\n}\n.vue-treeselect__x-container {\n display: table-cell;\n vertical-align: middle;\n width: 20px;\n text-align: center;\n line-height: 0;\n cursor: pointer;\n color: #ccc;\n animation: 200ms vue-treeselect-animation-fade-in cubic-bezier(0.075, 0.82, 0.165, 1);\n}\n.vue-treeselect__x-container:hover {\n color: #e53935;\n}\n.vue-treeselect__x {\n width: 8px;\n height: 8px;\n}\n.vue-treeselect__control-arrow-container {\n display: table-cell;\n vertical-align: middle;\n width: 20px;\n text-align: center;\n line-height: 0;\n cursor: pointer;\n}\n.vue-treeselect--disabled .vue-treeselect__control-arrow-container {\n cursor: default;\n}\n.vue-treeselect__control-arrow {\n width: 9px;\n height: 9px;\n color: #ccc;\n}\n.vue-treeselect:not(.vue-treeselect--disabled) .vue-treeselect__control-arrow-container:hover .vue-treeselect__control-arrow {\n color: #616161;\n}\n.vue-treeselect--disabled .vue-treeselect__control-arrow {\n opacity: 0.35;\n}\n.vue-treeselect__control-arrow--rotated {\n transform: rotateZ(180deg);\n}\n/**\n * Menu\n */\n.vue-treeselect__menu-container {\n position: absolute;\n left: 0;\n width: 100%;\n overflow: visible;\n transition: 0s;\n}\n.vue-treeselect--open-below:not(.vue-treeselect--append-to-body) .vue-treeselect__menu-container {\n top: 100%;\n}\n.vue-treeselect--open-above:not(.vue-treeselect--append-to-body) .vue-treeselect__menu-container {\n bottom: 100%;\n}\n.vue-treeselect__menu {\n cursor: default;\n padding-top: 5px;\n padding-bottom: 5px;\n display: block;\n position: absolute;\n overflow-x: hidden;\n overflow-y: auto;\n width: auto;\n border: 1px solid #cfcfcf;\n background: #fff;\n line-height: 180%;\n -webkit-overflow-scrolling: touch;\n}\n.vue-treeselect--open-below .vue-treeselect__menu {\n border-bottom-left-radius: 5px;\n border-bottom-right-radius: 5px;\n top: 0;\n margin-top: -1px;\n border-top-color: #f2f2f2;\n box-shadow: 0 1px 0 rgba(0, 0, 0, 0.06);\n}\n.vue-treeselect--open-above .vue-treeselect__menu {\n border-top-left-radius: 5px;\n border-top-right-radius: 5px;\n bottom: 0;\n margin-bottom: -1px;\n border-bottom-color: #f2f2f2;\n}\n.vue-treeselect__indent-level-0 .vue-treeselect__option {\n padding-left: 5px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-0 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 5px;\n}\n.vue-treeselect__indent-level-0 .vue-treeselect__tip {\n padding-left: 25px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-0 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 25px;\n}\n.vue-treeselect__indent-level-1 .vue-treeselect__option {\n padding-left: 25px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-1 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 25px;\n}\n.vue-treeselect__indent-level-1 .vue-treeselect__tip {\n padding-left: 45px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-1 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 45px;\n}\n.vue-treeselect__indent-level-2 .vue-treeselect__option {\n padding-left: 45px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-2 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 45px;\n}\n.vue-treeselect__indent-level-2 .vue-treeselect__tip {\n padding-left: 65px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-2 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 65px;\n}\n.vue-treeselect__indent-level-3 .vue-treeselect__option {\n padding-left: 65px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-3 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 65px;\n}\n.vue-treeselect__indent-level-3 .vue-treeselect__tip {\n padding-left: 85px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-3 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 85px;\n}\n.vue-treeselect__indent-level-4 .vue-treeselect__option {\n padding-left: 85px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-4 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 85px;\n}\n.vue-treeselect__indent-level-4 .vue-treeselect__tip {\n padding-left: 105px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-4 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 105px;\n}\n.vue-treeselect__indent-level-5 .vue-treeselect__option {\n padding-left: 105px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-5 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 105px;\n}\n.vue-treeselect__indent-level-5 .vue-treeselect__tip {\n padding-left: 125px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-5 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 125px;\n}\n.vue-treeselect__indent-level-6 .vue-treeselect__option {\n padding-left: 125px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-6 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 125px;\n}\n.vue-treeselect__indent-level-6 .vue-treeselect__tip {\n padding-left: 145px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-6 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 145px;\n}\n.vue-treeselect__indent-level-7 .vue-treeselect__option {\n padding-left: 145px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-7 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 145px;\n}\n.vue-treeselect__indent-level-7 .vue-treeselect__tip {\n padding-left: 165px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-7 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 165px;\n}\n.vue-treeselect__indent-level-8 .vue-treeselect__option {\n padding-left: 165px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-8 .vue-treeselect__option {\n padding-left: 5px;\n padding-right: 165px;\n}\n.vue-treeselect__indent-level-8 .vue-treeselect__tip {\n padding-left: 185px;\n}\n[dir=\"rtl\"] .vue-treeselect__indent-level-8 .vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 185px;\n}\n.vue-treeselect__option {\n padding-left: 5px;\n padding-right: 5px;\n display: table;\n table-layout: fixed;\n width: 100%;\n}\n.vue-treeselect__option--highlight {\n background: #f5f5f5;\n}\n.vue-treeselect--single .vue-treeselect__option--selected {\n background: #e3f2fd;\n font-weight: 600;\n}\n.vue-treeselect--single .vue-treeselect__option--selected:hover {\n background: #e3f2fd;\n}\n.vue-treeselect__option--hide {\n display: none;\n}\n.vue-treeselect__option-arrow-container,\n.vue-treeselect__option-arrow-placeholder {\n display: table-cell;\n vertical-align: middle;\n width: 20px;\n text-align: center;\n line-height: 0;\n}\n.vue-treeselect__option-arrow-container {\n cursor: pointer;\n}\n.vue-treeselect__option-arrow {\n display: inline-block;\n width: 9px;\n height: 9px;\n color: #ccc;\n vertical-align: middle;\n transition: 200ms transform cubic-bezier(0.19, 1, 0.22, 1);\n transform: rotateZ(-90deg);\n}\n[dir=\"rtl\"] .vue-treeselect__option-arrow {\n transform: rotateZ(90deg);\n}\n.vue-treeselect__option-arrow-container:hover .vue-treeselect__option-arrow,\n.vue-treeselect--branch-nodes-disabled .vue-treeselect__option:hover .vue-treeselect__option-arrow {\n color: #616161;\n}\n.vue-treeselect__option-arrow--rotated {\n transform: rotateZ(0);\n}\n[dir=\"rtl\"] .vue-treeselect__option-arrow--rotated {\n transform: rotateZ(0);\n}\n.vue-treeselect__option-arrow--rotated.vue-treeselect__option-arrow--prepare-enter {\n transform: rotateZ(-90deg) !important;\n}\n[dir=\"rtl\"] .vue-treeselect__option-arrow--rotated.vue-treeselect__option-arrow--prepare-enter {\n transform: rotateZ(90deg) !important;\n}\n.vue-treeselect__label-container {\n display: table-cell;\n vertical-align: middle;\n cursor: pointer;\n display: table;\n width: 100%;\n table-layout: fixed;\n color: inherit;\n}\n.vue-treeselect__option--disabled .vue-treeselect__label-container {\n cursor: not-allowed;\n color: rgba(0, 0, 0, 0.25);\n}\n.vue-treeselect__checkbox-container {\n display: table-cell;\n width: 20px;\n min-width: 20px;\n height: 100%;\n text-align: center;\n vertical-align: middle;\n}\n.vue-treeselect__checkbox {\n display: block;\n margin: auto;\n width: 12px;\n height: 12px;\n border-width: 1px;\n border-style: solid;\n border-radius: 2px;\n position: relative;\n transition: 200ms all cubic-bezier(0.075, 0.82, 0.165, 1);\n}\n.vue-treeselect__check-mark,\n.vue-treeselect__minus-mark {\n display: block;\n position: absolute;\n left: 1px;\n top: 1px;\n background-repeat: no-repeat;\n opacity: 0;\n transition: 200ms all ease;\n}\n.vue-treeselect__minus-mark {\n width: 8px;\n height: 8px;\n background-image: url(\"./assets/checkbox-indeterminate.png\");\n background-size: 8px 8px;\n}\n@media (min-resolution: 1.5dppx) {\n .vue-treeselect__minus-mark {\n background-image: url(\"./assets/checkbox-indeterminate@2x.png\");\n }\n}\n@media (min-resolution: 192dpi) {\n .vue-treeselect__minus-mark {\n background-image: url(\"./assets/checkbox-indeterminate@2x.png\");\n }\n}\n@media (min-resolution: 288dpi) {\n .vue-treeselect__minus-mark {\n background-image: url(\"./assets/checkbox-indeterminate@3x.png\");\n }\n}\n.vue-treeselect__checkbox--indeterminate > .vue-treeselect__minus-mark {\n opacity: 1;\n}\n.vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark {\n background-image: url(\"./assets/checkbox-indeterminate-disabled.png\");\n}\n@media (min-resolution: 1.5dppx) {\n .vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark {\n background-image: url(\"./assets/checkbox-indeterminate-disabled@2x.png\");\n }\n}\n@media (min-resolution: 192dpi) {\n .vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark {\n background-image: url(\"./assets/checkbox-indeterminate-disabled@2x.png\");\n }\n}\n@media (min-resolution: 288dpi) {\n .vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark {\n background-image: url(\"./assets/checkbox-indeterminate-disabled@3x.png\");\n }\n}\n.vue-treeselect__check-mark {\n width: 8px;\n height: 8px;\n background-image: url(\"./assets/checkbox-checked.png\");\n background-size: 8px 8px;\n transform: scaleY(0.125);\n}\n@media (min-resolution: 1.5dppx) {\n .vue-treeselect__check-mark {\n background-image: url(\"./assets/checkbox-checked@2x.png\");\n }\n}\n@media (min-resolution: 192dpi) {\n .vue-treeselect__check-mark {\n background-image: url(\"./assets/checkbox-checked@2x.png\");\n }\n}\n@media (min-resolution: 288dpi) {\n .vue-treeselect__check-mark {\n background-image: url(\"./assets/checkbox-checked@3x.png\");\n }\n}\n.vue-treeselect__checkbox--checked > .vue-treeselect__check-mark {\n opacity: 1;\n transform: scaleY(1);\n}\n.vue-treeselect__checkbox--disabled .vue-treeselect__check-mark {\n background-image: url(\"./assets/checkbox-checked-disabled.png\");\n}\n@media (min-resolution: 1.5dppx) {\n .vue-treeselect__checkbox--disabled .vue-treeselect__check-mark {\n background-image: url(\"./assets/checkbox-checked-disabled@2x.png\");\n }\n}\n@media (min-resolution: 192dpi) {\n .vue-treeselect__checkbox--disabled .vue-treeselect__check-mark {\n background-image: url(\"./assets/checkbox-checked-disabled@2x.png\");\n }\n}\n@media (min-resolution: 288dpi) {\n .vue-treeselect__checkbox--disabled .vue-treeselect__check-mark {\n background-image: url(\"./assets/checkbox-checked-disabled@3x.png\");\n }\n}\n.vue-treeselect__checkbox--unchecked {\n border-color: #e0e0e0;\n background: #fff;\n}\n.vue-treeselect__label-container:hover .vue-treeselect__checkbox--unchecked {\n border-color: #039be5;\n background: #fff;\n}\n.vue-treeselect__checkbox--indeterminate {\n border-color: #039be5;\n background: #039be5;\n}\n.vue-treeselect__label-container:hover .vue-treeselect__checkbox--indeterminate {\n border-color: #039be5;\n background: #039be5;\n}\n.vue-treeselect__checkbox--checked {\n border-color: #039be5;\n background: #039be5;\n}\n.vue-treeselect__label-container:hover .vue-treeselect__checkbox--checked {\n border-color: #039be5;\n background: #039be5;\n}\n.vue-treeselect__checkbox--disabled {\n border-color: #e0e0e0;\n background-color: #f7f7f7;\n}\n.vue-treeselect__label-container:hover .vue-treeselect__checkbox--disabled {\n border-color: #e0e0e0;\n background-color: #f7f7f7;\n}\n.vue-treeselect__label {\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n display: table-cell;\n padding-left: 5px;\n max-width: 100%;\n vertical-align: middle;\n cursor: inherit;\n}\n[dir=\"rtl\"] .vue-treeselect__label {\n padding-left: 0;\n padding-right: 5px;\n}\n.vue-treeselect__count {\n margin-left: 5px;\n font-weight: 400;\n opacity: 0.6;\n}\n[dir=\"rtl\"] .vue-treeselect__count {\n margin-left: 0;\n margin-right: 5px;\n}\n.vue-treeselect__tip {\n padding-left: 5px;\n padding-right: 5px;\n display: table;\n table-layout: fixed;\n width: 100%;\n color: #757575;\n}\n.vue-treeselect__tip-text {\n display: table-cell;\n vertical-align: middle;\n padding-left: 5px;\n padding-right: 5px;\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n width: 100%;\n font-size: 12px;\n}\n.vue-treeselect__error-tip .vue-treeselect__retry {\n cursor: pointer;\n margin-left: 5px;\n font-style: normal;\n font-weight: 600;\n text-decoration: none;\n color: #039be5;\n}\n[dir=\"rtl\"] .vue-treeselect__error-tip .vue-treeselect__retry {\n margin-left: 0;\n margin-right: 5px;\n}\n.vue-treeselect__icon-container {\n display: table-cell;\n vertical-align: middle;\n width: 20px;\n text-align: center;\n line-height: 0;\n}\n.vue-treeselect--single .vue-treeselect__icon-container {\n padding-left: 5px;\n}\n[dir=\"rtl\"] .vue-treeselect--single .vue-treeselect__icon-container {\n padding-left: 0;\n padding-right: 5px;\n}\n.vue-treeselect__icon-warning {\n display: block;\n margin: auto;\n border-radius: 50%;\n position: relative;\n width: 12px;\n height: 12px;\n background: #fb8c00;\n}\n.vue-treeselect__icon-warning::after {\n display: block;\n position: absolute;\n content: \"\";\n left: 5px;\n top: 2.5px;\n width: 2px;\n height: 1px;\n border: 0 solid #fff;\n border-top-width: 5px;\n border-bottom-width: 1px;\n}\n.vue-treeselect__icon-error {\n display: block;\n margin: auto;\n border-radius: 50%;\n position: relative;\n width: 12px;\n height: 12px;\n background: #e53935;\n}\n.vue-treeselect__icon-error::before,\n.vue-treeselect__icon-error::after {\n display: block;\n position: absolute;\n content: \"\";\n background: #fff;\n transform: rotate(45deg);\n}\n.vue-treeselect__icon-error::before {\n width: 6px;\n height: 2px;\n left: 3px;\n top: 5px;\n}\n.vue-treeselect__icon-error::after {\n width: 2px;\n height: 6px;\n left: 5px;\n top: 3px;\n}\n.vue-treeselect__icon-loader {\n display: block;\n margin: auto;\n position: relative;\n width: 12px;\n height: 12px;\n text-align: center;\n animation: 1.6s vue-treeselect-animation-rotate linear infinite;\n}\n.vue-treeselect__icon-loader::before,\n.vue-treeselect__icon-loader::after {\n border-radius: 50%;\n position: absolute;\n content: \"\";\n left: 0;\n top: 0;\n display: block;\n width: 100%;\n height: 100%;\n opacity: 0.6;\n animation: 1.6s vue-treeselect-animation-bounce ease-in-out infinite;\n}\n.vue-treeselect__icon-loader::before {\n background: #039be5;\n}\n.vue-treeselect__icon-loader::after {\n background: #b3e5fc;\n animation-delay: -0.8s;\n}\n/**\n * Menu Portal\n */\n.vue-treeselect__menu-placeholder {\n display: none;\n}\n.vue-treeselect__portal-target {\n position: absolute;\n display: block;\n left: 0;\n top: 0;\n height: 0;\n width: 0;\n padding: 0;\n margin: 0;\n border: 0;\n overflow: visible;\n box-sizing: border-box;\n}\n","/**\n * Dependencies\n */\n\n@import \"~material-colors/dist/colors.less\";\n@import \"~easings-css/easings.less\";\n\n/**\n * Variables\n */\n\n@treeselect-font-size: 1em;\n@treeselect-font-size-sm: 12px;\n@treeselect-padding: 5px;\n@treeselect-border-radius-lg: 5px;\n@treeselect-border-radius-sm: 2px;\n@treeselect-narrow-cell-width: 20px;\n@treeselect-wide-cell-width: 100%;\n@treeselect-icon-size: 12px;\n@treeselect-transition-duration: 200ms;\n@treeselect-transition-duration-slow: 400ms;\n@treeselect-max-level: 8;\n\n@treeselect-control-height: 36px;\n@treeselect-control-inner-height: @treeselect-control-height - @treeselect-control-border-width * 2;\n@treeselect-control-border-width: 1px;\n@treeselect-control-border-color: #ddd;\n@treeselect-control-border-color-hover: #cfcfcf;\n@treeselect-control-border-color-active: @treeselect-control-border-color-hover;\n@treeselect-control-border-color-focus: @md-light-blue-600;\n@treeselect-control-border-radius: @treeselect-border-radius-lg;\n@treeselect-control-bg: #fff;\n@treeselect-control-box-shadow-focus: 0 0 0 3px fade(@treeselect-control-border-color-focus, 10%);\n@treeselect-control-bg-disabled: #f9f9f9;\n\n@treeselect-placeholder-font-color: @md-grey-400;\n@treeselect-single-value-font-color: #333;\n@treeselect-single-value-font-color-focused: @treeselect-placeholder-font-color;\n@treeselect-multi-value-margin-x: 0;\n@treeselect-multi-value-margin-y: 2px;\n@treeselect-multi-value-padding-x: @treeselect-padding;\n@treeselect-multi-value-padding-y: 0;\n@treeselect-multi-value-font-size: @treeselect-font-size-sm;\n@treeselect-multi-value-font-color: @md-light-blue-600;\n@treeselect-multi-value-item-bg: @md-blue-50;\n@treeselect-multi-value-item-bg-new: @md-green-50;\n@treeselect-multi-value-item-border-width: 1px;\n@treeselect-multi-value-item-border-color: transparent;\n@treeselect-multi-value-font-color-hover: @treeselect-multi-value-font-color;\n@treeselect-multi-value-item-bg-hover: @treeselect-multi-value-item-bg;\n@treeselect-multi-value-item-bg-new-hover: @treeselect-multi-value-item-bg-new;\n@treeselect-multi-value-font-color-disabled: @md-grey-600;\n@treeselect-multi-value-item-bg-disabled: @md-grey-100;\n@treeselect-multi-value-item-font-color-control-disabled: #555;\n@treeselect-multi-value-item-bg-control-disabled: #fff;\n@treeselect-multi-value-item-border-color-control-disabled: #e5e5e5;\n@treeselect-multi-value-remove-color: @treeselect-multi-value-font-color;\n@treeselect-multi-value-remove-color-hover: @md-red-600;\n@treeselect-multi-value-remove-size: 6px;\n@treeselect-multi-value-divider-color: #fff;\n@treeselect-limit-tip-font-color: @md-grey-400;\n@treeselect-limit-tip-font-size: @treeselect-multi-value-font-size;\n@treeselect-limit-tip-font-weight: 600;\n@treeselect-single-input-font-size: inherit;\n@treeselect-multi-input-font-size: @treeselect-multi-value-font-size;\n\n@treeselect-menu-bg: #fff;\n@treeselect-menu-padding-y: @treeselect-padding;\n@treeselect-menu-line-height: 180%;\n@treeselect-menu-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.06);\n@treeselect-control-menu-divider-color: #f2f2f2;\n\n@treeselect-arrow-size: 9px;\n@treeselect-arrow-color: #ccc;\n@treeselect-arrow-color-hover: @md-grey-700;\n@treeselect-arrow-transition-timing-function: @ease-out-expo;\n\n@treeselect-x-size: 8px;\n@treeselect-x-color: @treeselect-arrow-color;\n@treeselect-x-color-hover: @md-red-600;\n\n@treeselect-option-bg-highlight: @md-grey-100;\n@treeselect-option-selected-bg: @md-blue-50;\n@treeselect-option-selected-bg-hover: @treeselect-option-selected-bg;\n@treeselect-checkbox-size: @treeselect-icon-size;\n@treeselect-checkbox-border-radius: @treeselect-border-radius-sm;\n@treeselect-checkbox-color: @md-grey-300;\n@treeselect-checkbox-color-highlight: @md-light-blue-600;\n@treeselect-checkbox-border-color: @treeselect-checkbox-color;\n@treeselect-checkbox-bg: #fff;\n@treeselect-checkbox-border-color-hover: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-bg-hover: @treeselect-checkbox-bg;\n@treeselect-checkbox-indeterminate-border-color: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-indeterminate-bg: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-indeterminate-icon: \"./assets/checkbox-indeterminate.png\";\n@treeselect-checkbox-indeterminate-border-color-hover: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-indeterminate-bg-hover: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-checked-border-color: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-checked-bg: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-checked-icon: \"./assets/checkbox-checked.png\";\n@treeselect-checkbox-checked-border-color-hover: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-checked-bg-hover: @treeselect-checkbox-color-highlight;\n@treeselect-checkbox-disabled-border-color: @treeselect-checkbox-border-color;\n@treeselect-checkbox-disabled-bg-color: darken(@treeselect-checkbox-bg, 3%);\n@treeselect-checkbox-disabled-indeterminate-icon: \"./assets/checkbox-indeterminate-disabled.png\";\n@treeselect-checkbox-disabled-checked-icon: \"./assets/checkbox-checked-disabled.png\";\n@treeselect-option-label-color: inherit;\n@treeselect-option-label-color-disabled: rgba(0, 0, 0, 0.25);\n\n@treeselect-loader-color-dark: @md-light-blue-600;\n@treeselect-loader-color-light: @md-light-blue-100;\n@treeselect-loader-animation-duration: 1.6s;\n@treeselect-warning-icon-bg: @md-orange-600;\n@treeselect-error-icon-bg: @md-red-600;\n@treeselect-tip-color: @md-grey-600;\n@treeselect-tip-font-size: @treeselect-font-size-sm;\n@treeselect-retry-text-color: @md-light-blue-600;\n\n\n/**\n * Mixins\n */\n\n.clickable() {\n cursor: pointer;\n}\n\n.inputtable() {\n cursor: text;\n}\n\n.forbidden() {\n cursor: not-allowed;\n}\n\n.reset-cursor() {\n cursor: default;\n}\n\n.rounded() {\n border-radius: 50%;\n}\n\n.border-radius-top(@size) {\n border-top-left-radius: @size;\n border-top-right-radius: @size;\n}\n\n.border-radius-bottom(@size) {\n border-bottom-left-radius: @size;\n border-bottom-right-radius: @size;\n}\n\n.text-truncate() {\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n}\n\n.horizontal-padding(@value) {\n padding-left: @value;\n padding-right: @value;\n}\n\n.vertical-padding(@value) {\n padding-top: @value;\n padding-bottom: @value;\n}\n\n.icon() {\n display: block;\n margin: auto;\n}\n\n.row() {\n .horizontal-padding(@treeselect-padding);\n\n display: table;\n table-layout: fixed;\n width: 100%;\n}\n\n.cell() {\n display: table-cell;\n vertical-align: middle;\n}\n\n.wide-cell() {\n .cell();\n .horizontal-padding(@treeselect-padding);\n .text-truncate();\n\n width: @treeselect-wide-cell-width;\n}\n\n.narrow-cell() {\n .cell();\n\n width: @treeselect-narrow-cell-width;\n text-align: center;\n line-height: 0;\n}\n\n// based on: https://github.com/strues/retinajs/blob/master/dist/retina.less\n.retina(@path, @cap: 2) { // stylelint-disable-line selector-class-pattern\n @lowretina: ~\"(min-resolution: 1.5dppx)\";\n @2xpath: replace(@path, \"(\\.\\w+)$\", \"@2x$1\");\n\n background-image: url(@path);\n\n @media @lowretina {\n background-image: url(@2xpath);\n }\n\n .create-queries() when (@cap >= 2) {\n .loop(@env) when (@env <= @cap) {\n @retinapath: replace(@path, \"(\\.\\w+)$\", \"@@{env}x$1\");\n @media (min-resolution: @env * 96dpi) {\n background-image: url(@retinapath);\n }\n\n .loop((@env + 1));\n }\n\n .loop(2);\n }\n .create-queries();\n}\n\n/**\n * Helpers\n */\n\n.vue-treeselect-helper-hide {\n display: none;\n}\n\n.vue-treeselect-helper-zoom-effect-off {\n transform: none !important; // stylelint-disable-line declaration-no-important\n}\n\n\n/**\n * Animations\n */\n\n@keyframes vue-treeselect-animation-fade-in {\n 0% {\n opacity: 0;\n }\n}\n\n@keyframes vue-treeselect-animation-bounce {\n 0%, 100% {\n transform: scale(0);\n }\n 50% {\n transform: scale(1);\n }\n}\n\n@keyframes vue-treeselect-animation-rotate {\n 100% {\n transform: rotate(360deg);\n }\n}\n\n\n/**\n * Transitions\n */\n\n.vue-treeselect__multi-value-item--transition {\n &-enter-active,\n &-leave-active {\n transition-duration: @treeselect-transition-duration;\n transition-property: transform, opacity;\n }\n\n &-enter-active {\n transition-timing-function: @ease-out-circ;\n }\n\n &-leave-active {\n transition-timing-function: @ease-out-cubic;\n // trigger animation when element is removed\n position: absolute;\n }\n\n &-enter,\n &-leave-to {\n transform: scale(0.7);\n opacity: 0;\n }\n\n &-move {\n transition: @treeselect-transition-duration transform @ease-out-quart;\n }\n}\n\n.vue-treeselect__menu--transition {\n &-enter-active,\n &-leave-active {\n // to be overriden\n }\n\n &-enter,\n &-leave-to {\n // to be overriden\n }\n}\n\n.vue-treeselect__list--transition {\n &-enter-active,\n &-leave-active {\n // to be overriden\n }\n\n &-enter,\n &-leave-to {\n // to be overriden\n }\n}\n\n\n/**\n * Namespace\n */\n\n.vue-treeselect {\n position: relative;\n text-align: left;\n\n [dir=\"rtl\"] & {\n text-align: right;\n }\n\n div,\n span {\n box-sizing: border-box;\n }\n\n svg {\n fill: currentColor;\n }\n}\n\n\n/**\n * Control\n */\n\n.vue-treeselect__control {\n .row();\n\n height: @treeselect-control-height;\n border: @treeselect-control-border-width solid @treeselect-control-border-color;\n border-radius: @treeselect-control-border-radius;\n background: @treeselect-control-bg;\n transition-duration: @treeselect-transition-duration;\n transition-property: border-color, box-shadow, width, height, background-color, opacity;\n transition-timing-function: @ease-out-cubic;\n\n .vue-treeselect:not(.vue-treeselect--disabled):not(.vue-treeselect--focused) &:hover {\n border-color: @treeselect-control-border-color-hover;\n }\n\n .vue-treeselect--focused:not(.vue-treeselect--open) & {\n border-color: @treeselect-control-border-color-focus;\n box-shadow: @treeselect-control-box-shadow-focus;\n }\n\n .vue-treeselect--disabled & {\n background-color: @treeselect-control-bg-disabled;\n }\n\n .vue-treeselect--open & {\n border-color: @treeselect-control-border-color-active;\n }\n\n .vue-treeselect--open.vue-treeselect--open-below & {\n .border-radius-bottom(0);\n }\n\n .vue-treeselect--open.vue-treeselect--open-above & {\n .border-radius-top(0);\n }\n}\n\n.vue-treeselect__value-container,\n.vue-treeselect__multi-value {\n width: 100%;\n vertical-align: middle;\n}\n\n.vue-treeselect__value-container {\n display: table-cell;\n position: relative;\n\n .vue-treeselect--searchable:not(.vue-treeselect--disabled) & {\n // The real input is small and not covering the whole control.\n // We show an I-shape cursor to give user a hint that\n // clicking anywhere in the control will make the input focused.\n .inputtable();\n }\n}\n\n.vue-treeselect__multi-value {\n display: inline-block;\n\n .vue-treeselect--has-value & {\n margin-bottom: @treeselect-padding;\n }\n}\n\n.vue-treeselect__placeholder,\n.vue-treeselect__single-value {\n .text-truncate();\n .horizontal-padding(@treeselect-padding);\n\n position: absolute;\n top: 0;\n right: 0;\n bottom: 0;\n left: 0;\n line-height: @treeselect-control-inner-height;\n user-select: none;\n pointer-events: none;\n}\n\n.vue-treeselect__placeholder {\n color: @treeselect-placeholder-font-color;\n}\n\n.vue-treeselect__single-value {\n color: @treeselect-single-value-font-color;\n\n .vue-treeselect--focused.vue-treeselect--searchable & {\n color: @treeselect-single-value-font-color-focused;\n }\n\n .vue-treeselect--disabled & {\n // #274 Fix for IE\n position: static;\n }\n}\n\n.vue-treeselect__multi-value-item-container {\n display: inline-block;\n padding-top: @treeselect-padding;\n padding-right: @treeselect-padding;\n vertical-align: top;\n\n [dir=\"rtl\"] & {\n padding-right: 0;\n padding-left: @treeselect-padding;\n }\n}\n\n.vue-treeselect__multi-value-item {\n .clickable();\n\n display: inline-table;\n background: @treeselect-multi-value-item-bg;\n // Table elements do not have margin, so we set at the container element.\n padding: @treeselect-multi-value-margin-y @treeselect-multi-value-margin-x;\n border: @treeselect-multi-value-item-border-width solid @treeselect-multi-value-item-border-color;\n border-radius: @treeselect-border-radius-sm;\n color: @treeselect-multi-value-font-color;\n font-size: @treeselect-multi-value-font-size;\n vertical-align: top; // stylelint-disable-line plugin/declaration-block-no-ignored-properties\n\n .vue-treeselect:not(.vue-treeselect--disabled) &:not(.vue-treeselect__multi-value-item-disabled):hover &:not(.vue-treeselect__multi-value-item-new) &:not(.vue-treeselect__multi-value-item-new):hover {\n .clickable();\n\n background: @treeselect-multi-value-item-bg-hover;\n color: @treeselect-multi-value-font-color-hover;\n }\n\n &.vue-treeselect__multi-value-item-disabled {\n .reset-cursor();\n\n background: @treeselect-multi-value-item-bg-disabled;\n color: @treeselect-multi-value-font-color-disabled;\n }\n\n .vue-treeselect--disabled & {\n .reset-cursor();\n\n background: @treeselect-multi-value-item-bg-control-disabled;\n border-color: @treeselect-multi-value-item-border-color-control-disabled;\n color: @treeselect-multi-value-item-font-color-control-disabled;\n }\n\n &.vue-treeselect__multi-value-item-new {\n background: @treeselect-multi-value-item-bg-new;\n &:hover {\n background: @treeselect-multi-value-item-bg-new;\n }\n }\n}\n\n.vue-treeselect__value-remove,\n.vue-treeselect__multi-value-label {\n display: table-cell;\n padding: @treeselect-multi-value-padding-y @treeselect-multi-value-padding-x;\n vertical-align: middle;\n}\n\n.vue-treeselect__value-remove {\n color: @treeselect-multi-value-remove-color;\n padding-left: @treeselect-multi-value-padding-x;\n border-left: 1px solid @treeselect-multi-value-divider-color;\n line-height: 0;\n\n [dir=\"rtl\"] & {\n border-left: 0 none;\n border-right: 1px solid @treeselect-multi-value-divider-color;\n }\n\n .vue-treeselect__multi-value-item:hover & {\n color: @treeselect-multi-value-remove-color-hover;\n }\n\n .vue-treeselect--disabled &,\n .vue-treeselect__multi-value-item-disabled & {\n display: none;\n }\n\n > svg {\n width: @treeselect-multi-value-remove-size;\n height: @treeselect-multi-value-remove-size;\n }\n}\n\n.vue-treeselect__multi-value-label {\n padding-right: @treeselect-multi-value-padding-x;\n white-space: pre-line;\n user-select: none;\n}\n\n.vue-treeselect__limit-tip {\n display: inline-block;\n padding-top: @treeselect-padding;\n padding-right: @treeselect-padding;\n vertical-align: top;\n\n [dir=\"rtl\"] & {\n padding-right: 0;\n padding-left: @treeselect-padding;\n }\n}\n\n.vue-treeselect__limit-tip-text {\n .reset-cursor();\n\n display: block;\n margin: @treeselect-multi-value-margin-y @treeselect-multi-value-margin-x;\n padding: (@treeselect-multi-value-padding-y + @treeselect-multi-value-item-border-width) 0;\n color: @treeselect-limit-tip-font-color;\n font-size: @treeselect-limit-tip-font-size;\n font-weight: @treeselect-limit-tip-font-weight;\n}\n\n.vue-treeselect__input-container {\n display: block;\n max-width: 100%;\n outline: none;\n\n .vue-treeselect--single & {\n font-size: @treeselect-single-input-font-size;\n height: 100%;\n }\n\n .vue-treeselect--multi & {\n display: inline-block;\n font-size: @treeselect-multi-input-font-size;\n vertical-align: top;\n }\n\n .vue-treeselect--searchable & {\n .horizontal-padding(@treeselect-padding);\n }\n\n .vue-treeselect--searchable.vue-treeselect--multi.vue-treeselect--has-value & {\n padding-top: @treeselect-padding;\n padding-left: 0;\n\n [dir=\"rtl\"] & {\n padding-left: @treeselect-padding;\n padding-right: 0;\n }\n }\n\n .vue-treeselect--disabled & {\n display: none;\n }\n}\n\n.vue-treeselect__input,\n.vue-treeselect__sizer {\n margin: 0;\n line-height: inherit;\n font-family: inherit;\n font-size: inherit;\n}\n\n.vue-treeselect__input {\n max-width: 100%;\n margin: 0;\n padding: 0;\n border: 0;\n outline: none;\n box-sizing: content-box;\n box-shadow: none;\n background: none transparent;\n line-height: 1;\n vertical-align: middle;\n\n &::-ms-clear {\n display: none;\n }\n\n .vue-treeselect--single & {\n width: 100%;\n height: 100%;\n }\n\n .vue-treeselect--multi & {\n .vertical-padding(@treeselect-multi-value-margin-y + @treeselect-multi-value-item-border-width);\n }\n\n .vue-treeselect--has-value & {\n line-height: inherit;\n vertical-align: top;\n }\n}\n\n.vue-treeselect__sizer {\n position: absolute;\n top: 0;\n left: 0;\n visibility: hidden;\n height: 0;\n overflow: scroll;\n white-space: pre;\n}\n\n.vue-treeselect__x-container {\n .narrow-cell();\n .clickable();\n\n color: @treeselect-x-color;\n animation: @treeselect-transition-duration vue-treeselect-animation-fade-in @ease-out-circ;\n\n &:hover {\n color: @treeselect-x-color-hover;\n }\n}\n\n.vue-treeselect__x {\n width: @treeselect-x-size;\n height: @treeselect-x-size;\n}\n\n.vue-treeselect__control-arrow-container {\n .narrow-cell();\n .clickable();\n\n .vue-treeselect--disabled & {\n .reset-cursor();\n }\n}\n\n.vue-treeselect__control-arrow {\n width: @treeselect-arrow-size;\n height: @treeselect-arrow-size;\n color: @treeselect-arrow-color;\n\n .vue-treeselect:not(.vue-treeselect--disabled) .vue-treeselect__control-arrow-container:hover & {\n color: @treeselect-arrow-color-hover;\n }\n\n .vue-treeselect--disabled & {\n opacity: 0.35;\n }\n}\n\n.vue-treeselect__control-arrow--rotated {\n transform: rotateZ(180deg);\n}\n\n\n/**\n * Menu\n */\n\n.vue-treeselect__menu-container {\n position: absolute;\n left: 0;\n width: 100%;\n overflow: visible;\n transition: 0s;\n\n .vue-treeselect--open-below:not(.vue-treeselect--append-to-body) & {\n top: 100%;\n }\n\n .vue-treeselect--open-above:not(.vue-treeselect--append-to-body) & {\n bottom: 100%;\n }\n}\n\n.vue-treeselect__menu {\n .reset-cursor(); // set to normal cursor since text is unselectable\n .vertical-padding(@treeselect-menu-padding-y);\n\n display: block;\n position: absolute;\n overflow-x: hidden;\n overflow-y: auto;\n // IE9 does not properly handle `width: 100%` with scrollbar when `box-sizing: border-box`\n width: auto;\n border: 1px solid @treeselect-control-border-color-active;\n background: @treeselect-menu-bg;\n line-height: @treeselect-menu-line-height;\n // https://css-tricks.com/snippets/css/momentum-scrolling-on-ios-overflow-elements/\n -webkit-overflow-scrolling: touch;\n\n .vue-treeselect--open-below & {\n .border-radius-bottom(@treeselect-border-radius-lg);\n\n top: 0;\n margin-top: (-@treeselect-control-border-width);\n border-top-color: @treeselect-control-menu-divider-color;\n box-shadow: @treeselect-menu-box-shadow;\n }\n\n .vue-treeselect--open-above & {\n .border-radius-top(@treeselect-border-radius-lg);\n\n bottom: 0;\n margin-bottom: (-@treeselect-control-border-width);\n border-bottom-color: @treeselect-control-menu-divider-color;\n }\n}\n\n.generate-level-indentations(@i) when (@i >= 0) {\n .generate-level-indentations((@i - 1));\n\n .vue-treeselect__indent-level-@{i} {\n .vue-treeselect__option {\n padding-left: @treeselect-padding + @i * @treeselect-narrow-cell-width;\n\n [dir=\"rtl\"] & {\n padding-left: @treeselect-padding;\n padding-right: @treeselect-padding + @i * @treeselect-narrow-cell-width;\n }\n }\n\n .vue-treeselect__tip {\n padding-left: @treeselect-padding + (@i + 1) * @treeselect-narrow-cell-width;\n\n [dir=\"rtl\"] & {\n padding-left: @treeselect-padding;\n padding-right: @treeselect-padding + (@i + 1) * @treeselect-narrow-cell-width;\n }\n }\n }\n}\n.generate-level-indentations(@treeselect-max-level);\n\n.vue-treeselect__option {\n .row();\n}\n\n.vue-treeselect__option--highlight {\n background: @treeselect-option-bg-highlight;\n}\n\n.vue-treeselect__option--selected {\n // note that these should override `.vue-treeselect__option--highlight`\n .vue-treeselect--single & {\n background: @treeselect-option-selected-bg;\n font-weight: 600;\n\n &:hover {\n background: @treeselect-option-selected-bg-hover;\n }\n }\n}\n\n.vue-treeselect__option--hide {\n display: none;\n}\n\n.vue-treeselect__option-arrow-container,\n.vue-treeselect__option-arrow-placeholder {\n .narrow-cell();\n}\n\n.vue-treeselect__option-arrow-container {\n .clickable();\n}\n\n.vue-treeselect__option-arrow {\n display: inline-block;\n width: @treeselect-arrow-size;\n height: @treeselect-arrow-size;\n color: @treeselect-arrow-color;\n vertical-align: middle;\n transition: @treeselect-transition-duration transform @treeselect-arrow-transition-timing-function;\n transform: rotateZ(-90deg);\n\n [dir=\"rtl\"] & {\n transform: rotateZ(90deg);\n }\n\n .vue-treeselect__option-arrow-container:hover &,\n .vue-treeselect--branch-nodes-disabled .vue-treeselect__option:hover & {\n color: @treeselect-arrow-color-hover;\n }\n}\n\n.vue-treeselect__option-arrow--rotated {\n transform: rotateZ(0);\n\n [dir=\"rtl\"] & {\n transform: rotateZ(0);\n }\n\n &.vue-treeselect__option-arrow--prepare-enter {\n transform: rotateZ(-90deg) !important; // stylelint-disable-line declaration-no-important\n\n [dir=\"rtl\"] & {\n transform: rotateZ(90deg) !important; // stylelint-disable-line declaration-no-important\n }\n }\n}\n\n.vue-treeselect__label-container {\n .cell();\n .clickable();\n\n display: table;\n width: 100%;\n table-layout: fixed;\n color: @treeselect-option-label-color;\n\n .vue-treeselect__option--disabled & {\n .forbidden();\n\n color: @treeselect-option-label-color-disabled;\n }\n}\n\n.vue-treeselect__checkbox-container {\n display: table-cell;\n width: @treeselect-narrow-cell-width;\n min-width: @treeselect-narrow-cell-width;\n height: 100%;\n text-align: center;\n vertical-align: middle;\n}\n\n.vue-treeselect__checkbox {\n display: block;\n margin: auto;\n width: @treeselect-checkbox-size;\n height: @treeselect-checkbox-size;\n border-width: 1px;\n border-style: solid;\n border-radius: @treeselect-border-radius-sm;\n position: relative;\n transition: @treeselect-transition-duration all @ease-out-circ;\n}\n\n.vue-treeselect__check-mark,\n.vue-treeselect__minus-mark {\n display: block;\n position: absolute;\n left: 1px;\n top: 1px;\n background-repeat: no-repeat;\n opacity: 0;\n transition: @treeselect-transition-duration all ease;\n}\n\n.vue-treeselect__minus-mark {\n width: image-width(@treeselect-checkbox-indeterminate-icon);\n height: image-height(@treeselect-checkbox-indeterminate-icon);\n // Svg icons are rendered differently in different browsers thus unacceptable.\n // Png provides the best consistency with a drawback that\n // its color can't be controlled by CSS.\n .retina(@treeselect-checkbox-indeterminate-icon, 3);\n background-size: image-size(@treeselect-checkbox-indeterminate-icon);\n\n .vue-treeselect__checkbox--indeterminate > & {\n opacity: 1;\n }\n\n .vue-treeselect__checkbox--disabled & {\n .retina(@treeselect-checkbox-disabled-indeterminate-icon, 3);\n }\n}\n\n.vue-treeselect__check-mark {\n width: image-width(@treeselect-checkbox-checked-icon);\n height: image-height(@treeselect-checkbox-checked-icon);\n .retina(@treeselect-checkbox-checked-icon, 3);\n background-size: image-size(@treeselect-checkbox-checked-icon);\n // Set initial height to 1px.\n transform: scaleY(1 / unit(image-height(@treeselect-checkbox-checked-icon)));\n\n .vue-treeselect__checkbox--checked > & {\n opacity: 1;\n transform: scaleY(1);\n }\n\n .vue-treeselect__checkbox--disabled & {\n .retina(@treeselect-checkbox-disabled-checked-icon, 3);\n }\n}\n\n.vue-treeselect__checkbox--unchecked {\n border-color: @treeselect-checkbox-border-color;\n background: @treeselect-checkbox-bg;\n\n .vue-treeselect__label-container:hover & {\n border-color: @treeselect-checkbox-border-color-hover;\n background: @treeselect-checkbox-bg-hover;\n }\n}\n\n.vue-treeselect__checkbox--indeterminate {\n border-color: @treeselect-checkbox-indeterminate-border-color;\n background: @treeselect-checkbox-indeterminate-bg;\n\n .vue-treeselect__label-container:hover & {\n border-color: @treeselect-checkbox-indeterminate-border-color-hover;\n background: @treeselect-checkbox-indeterminate-bg-hover;\n }\n}\n\n.vue-treeselect__checkbox--checked {\n border-color: @treeselect-checkbox-checked-border-color;\n background: @treeselect-checkbox-checked-bg;\n\n .vue-treeselect__label-container:hover & {\n border-color: @treeselect-checkbox-checked-border-color-hover;\n background: @treeselect-checkbox-checked-bg-hover;\n }\n}\n\n.vue-treeselect__checkbox--disabled {\n border-color: @treeselect-checkbox-disabled-border-color;\n background-color: @treeselect-checkbox-disabled-bg-color;\n\n .vue-treeselect__label-container:hover & {\n border-color: @treeselect-checkbox-disabled-border-color;\n background-color: @treeselect-checkbox-disabled-bg-color;\n }\n}\n\n\n.vue-treeselect__label {\n .text-truncate();\n\n display: table-cell;\n padding-left: @treeselect-padding;\n max-width: 100%;\n vertical-align: middle;\n cursor: inherit; // override user agent style\n\n [dir=\"rtl\"] & {\n padding-left: 0;\n padding-right: @treeselect-padding;\n }\n}\n\n.vue-treeselect__count {\n margin-left: @treeselect-padding;\n font-weight: 400;\n opacity: 0.6;\n\n [dir=\"rtl\"] & {\n margin-left: 0;\n margin-right: @treeselect-padding;\n }\n}\n\n.vue-treeselect__tip {\n .row();\n\n color: @treeselect-tip-color;\n}\n\n.vue-treeselect__tip-text {\n .wide-cell();\n\n font-size: @treeselect-tip-font-size;\n}\n\n.vue-treeselect__retry {\n .vue-treeselect__error-tip & {\n .clickable();\n\n margin-left: @treeselect-padding;\n font-style: normal;\n font-weight: 600;\n text-decoration: none;\n color: @treeselect-retry-text-color;\n\n [dir=\"rtl\"] & {\n margin-left: 0;\n margin-right: @treeselect-padding;\n }\n }\n}\n\n.vue-treeselect__icon-container {\n .narrow-cell();\n\n .vue-treeselect--single & {\n padding-left: @treeselect-padding;\n\n [dir=\"rtl\"] & {\n padding-left: 0;\n padding-right: @treeselect-padding;\n }\n }\n}\n\n.vue-treeselect__icon-warning {\n .icon();\n .rounded();\n\n position: relative;\n width: @treeselect-icon-size;\n height: @treeselect-icon-size;\n background: @treeselect-warning-icon-bg;\n\n &::after {\n display: block;\n position: absolute;\n content: \"\";\n left: 5px;\n top: 2.5px;\n width: 2px;\n height: 1px;\n border: 0 solid #fff;\n border-top-width: 5px;\n border-bottom-width: 1px;\n }\n}\n\n.vue-treeselect__icon-error {\n .icon();\n .rounded();\n\n @stroke-length: 6px;\n\n position: relative;\n width: @treeselect-icon-size;\n height: @treeselect-icon-size;\n background: @treeselect-error-icon-bg;\n\n &::before,\n &::after {\n display: block;\n position: absolute;\n content: \"\";\n background: #fff;\n transform: rotate(45deg);\n }\n\n &::before {\n width: @stroke-length;\n height: 2px;\n left: 3px;\n top: 5px;\n }\n\n &::after {\n width: 2px;\n height: @stroke-length;\n left: 5px;\n top: 3px;\n }\n}\n\n.vue-treeselect__icon-loader {\n .icon();\n\n position: relative;\n width: @treeselect-icon-size;\n height: @treeselect-icon-size;\n text-align: center;\n animation: @treeselect-loader-animation-duration vue-treeselect-animation-rotate linear infinite;\n\n &::before,\n &::after {\n .rounded();\n\n position: absolute;\n content: \"\";\n left: 0;\n top: 0;\n display: block;\n width: 100%;\n height: 100%;\n opacity: 0.6;\n animation: @treeselect-loader-animation-duration vue-treeselect-animation-bounce ease-in-out infinite;\n }\n\n &::before {\n background: @treeselect-loader-color-dark;\n }\n\n &::after {\n background: @treeselect-loader-color-light;\n animation-delay: -(@treeselect-loader-animation-duration / 2);\n }\n}\n\n\n/**\n * Menu Portal\n */\n\n.vue-treeselect__menu-placeholder {\n display: none;\n}\n\n.vue-treeselect__portal-target {\n position: absolute;\n display: block;\n left: 0;\n top: 0;\n height: 0;\n width: 0;\n padding: 0;\n margin: 0;\n border: 0;\n overflow: visible;\n box-sizing: border-box;\n}\n","@md-red-50: #ffebee;\n@md-red-100: #ffcdd2;\n@md-red-200: #ef9a9a;\n@md-red-300: #e57373;\n@md-red-400: #ef5350;\n@md-red-500: #f44336;\n@md-red-600: #e53935;\n@md-red-700: #d32f2f;\n@md-red-800: #c62828;\n@md-red-900: #b71c1c;\n@md-red-a100: #ff8a80;\n@md-red-a200: #ff5252;\n@md-red-a400: #ff1744;\n@md-red-a700: #d50000;\n\n@md-pink-50: #fce4ec;\n@md-pink-100: #f8bbd0;\n@md-pink-200: #f48fb1;\n@md-pink-300: #f06292;\n@md-pink-400: #ec407a;\n@md-pink-500: #e91e63;\n@md-pink-600: #d81b60;\n@md-pink-700: #c2185b;\n@md-pink-800: #ad1457;\n@md-pink-900: #880e4f;\n@md-pink-a100: #ff80ab;\n@md-pink-a200: #ff4081;\n@md-pink-a400: #f50057;\n@md-pink-a700: #c51162;\n\n@md-purple-50: #f3e5f5;\n@md-purple-100: #e1bee7;\n@md-purple-200: #ce93d8;\n@md-purple-300: #ba68c8;\n@md-purple-400: #ab47bc;\n@md-purple-500: #9c27b0;\n@md-purple-600: #8e24aa;\n@md-purple-700: #7b1fa2;\n@md-purple-800: #6a1b9a;\n@md-purple-900: #4a148c;\n@md-purple-a100: #ea80fc;\n@md-purple-a200: #e040fb;\n@md-purple-a400: #d500f9;\n@md-purple-a700: #aa00ff;\n\n@md-deep-purple-50: #ede7f6;\n@md-deep-purple-100: #d1c4e9;\n@md-deep-purple-200: #b39ddb;\n@md-deep-purple-300: #9575cd;\n@md-deep-purple-400: #7e57c2;\n@md-deep-purple-500: #673ab7;\n@md-deep-purple-600: #5e35b1;\n@md-deep-purple-700: #512da8;\n@md-deep-purple-800: #4527a0;\n@md-deep-purple-900: #311b92;\n@md-deep-purple-a100: #b388ff;\n@md-deep-purple-a200: #7c4dff;\n@md-deep-purple-a400: #651fff;\n@md-deep-purple-a700: #6200ea;\n\n@md-indigo-50: #e8eaf6;\n@md-indigo-100: #c5cae9;\n@md-indigo-200: #9fa8da;\n@md-indigo-300: #7986cb;\n@md-indigo-400: #5c6bc0;\n@md-indigo-500: #3f51b5;\n@md-indigo-600: #3949ab;\n@md-indigo-700: #303f9f;\n@md-indigo-800: #283593;\n@md-indigo-900: #1a237e;\n@md-indigo-a100: #8c9eff;\n@md-indigo-a200: #536dfe;\n@md-indigo-a400: #3d5afe;\n@md-indigo-a700: #304ffe;\n\n@md-blue-50: #e3f2fd;\n@md-blue-100: #bbdefb;\n@md-blue-200: #90caf9;\n@md-blue-300: #64b5f6;\n@md-blue-400: #42a5f5;\n@md-blue-500: #2196f3;\n@md-blue-600: #1e88e5;\n@md-blue-700: #1976d2;\n@md-blue-800: #1565c0;\n@md-blue-900: #0d47a1;\n@md-blue-a100: #82b1ff;\n@md-blue-a200: #448aff;\n@md-blue-a400: #2979ff;\n@md-blue-a700: #2962ff;\n\n@md-light-blue-50: #e1f5fe;\n@md-light-blue-100: #b3e5fc;\n@md-light-blue-200: #81d4fa;\n@md-light-blue-300: #4fc3f7;\n@md-light-blue-400: #29b6f6;\n@md-light-blue-500: #03a9f4;\n@md-light-blue-600: #039be5;\n@md-light-blue-700: #0288d1;\n@md-light-blue-800: #0277bd;\n@md-light-blue-900: #01579b;\n@md-light-blue-a100: #80d8ff;\n@md-light-blue-a200: #40c4ff;\n@md-light-blue-a400: #00b0ff;\n@md-light-blue-a700: #0091ea;\n\n@md-cyan-50: #e0f7fa;\n@md-cyan-100: #b2ebf2;\n@md-cyan-200: #80deea;\n@md-cyan-300: #4dd0e1;\n@md-cyan-400: #26c6da;\n@md-cyan-500: #00bcd4;\n@md-cyan-600: #00acc1;\n@md-cyan-700: #0097a7;\n@md-cyan-800: #00838f;\n@md-cyan-900: #006064;\n@md-cyan-a100: #84ffff;\n@md-cyan-a200: #18ffff;\n@md-cyan-a400: #00e5ff;\n@md-cyan-a700: #00b8d4;\n\n@md-teal-50: #e0f2f1;\n@md-teal-100: #b2dfdb;\n@md-teal-200: #80cbc4;\n@md-teal-300: #4db6ac;\n@md-teal-400: #26a69a;\n@md-teal-500: #009688;\n@md-teal-600: #00897b;\n@md-teal-700: #00796b;\n@md-teal-800: #00695c;\n@md-teal-900: #004d40;\n@md-teal-a100: #a7ffeb;\n@md-teal-a200: #64ffda;\n@md-teal-a400: #1de9b6;\n@md-teal-a700: #00bfa5;\n\n@md-green-50: #e8f5e9;\n@md-green-100: #c8e6c9;\n@md-green-200: #a5d6a7;\n@md-green-300: #81c784;\n@md-green-400: #66bb6a;\n@md-green-500: #4caf50;\n@md-green-600: #43a047;\n@md-green-700: #388e3c;\n@md-green-800: #2e7d32;\n@md-green-900: #1b5e20;\n@md-green-a100: #b9f6ca;\n@md-green-a200: #69f0ae;\n@md-green-a400: #00e676;\n@md-green-a700: #00c853;\n\n@md-light-green-50: #f1f8e9;\n@md-light-green-100: #dcedc8;\n@md-light-green-200: #c5e1a5;\n@md-light-green-300: #aed581;\n@md-light-green-400: #9ccc65;\n@md-light-green-500: #8bc34a;\n@md-light-green-600: #7cb342;\n@md-light-green-700: #689f38;\n@md-light-green-800: #558b2f;\n@md-light-green-900: #33691e;\n@md-light-green-a100: #ccff90;\n@md-light-green-a200: #b2ff59;\n@md-light-green-a400: #76ff03;\n@md-light-green-a700: #64dd17;\n\n@md-lime-50: #f9fbe7;\n@md-lime-100: #f0f4c3;\n@md-lime-200: #e6ee9c;\n@md-lime-300: #dce775;\n@md-lime-400: #d4e157;\n@md-lime-500: #cddc39;\n@md-lime-600: #c0ca33;\n@md-lime-700: #afb42b;\n@md-lime-800: #9e9d24;\n@md-lime-900: #827717;\n@md-lime-a100: #f4ff81;\n@md-lime-a200: #eeff41;\n@md-lime-a400: #c6ff00;\n@md-lime-a700: #aeea00;\n\n@md-yellow-50: #fffde7;\n@md-yellow-100: #fff9c4;\n@md-yellow-200: #fff59d;\n@md-yellow-300: #fff176;\n@md-yellow-400: #ffee58;\n@md-yellow-500: #ffeb3b;\n@md-yellow-600: #fdd835;\n@md-yellow-700: #fbc02d;\n@md-yellow-800: #f9a825;\n@md-yellow-900: #f57f17;\n@md-yellow-a100: #ffff8d;\n@md-yellow-a200: #ffff00;\n@md-yellow-a400: #ffea00;\n@md-yellow-a700: #ffd600;\n\n@md-amber-50: #fff8e1;\n@md-amber-100: #ffecb3;\n@md-amber-200: #ffe082;\n@md-amber-300: #ffd54f;\n@md-amber-400: #ffca28;\n@md-amber-500: #ffc107;\n@md-amber-600: #ffb300;\n@md-amber-700: #ffa000;\n@md-amber-800: #ff8f00;\n@md-amber-900: #ff6f00;\n@md-amber-a100: #ffe57f;\n@md-amber-a200: #ffd740;\n@md-amber-a400: #ffc400;\n@md-amber-a700: #ffab00;\n\n@md-orange-50: #fff3e0;\n@md-orange-100: #ffe0b2;\n@md-orange-200: #ffcc80;\n@md-orange-300: #ffb74d;\n@md-orange-400: #ffa726;\n@md-orange-500: #ff9800;\n@md-orange-600: #fb8c00;\n@md-orange-700: #f57c00;\n@md-orange-800: #ef6c00;\n@md-orange-900: #e65100;\n@md-orange-a100: #ffd180;\n@md-orange-a200: #ffab40;\n@md-orange-a400: #ff9100;\n@md-orange-a700: #ff6d00;\n\n@md-deep-orange-50: #fbe9e7;\n@md-deep-orange-100: #ffccbc;\n@md-deep-orange-200: #ffab91;\n@md-deep-orange-300: #ff8a65;\n@md-deep-orange-400: #ff7043;\n@md-deep-orange-500: #ff5722;\n@md-deep-orange-600: #f4511e;\n@md-deep-orange-700: #e64a19;\n@md-deep-orange-800: #d84315;\n@md-deep-orange-900: #bf360c;\n@md-deep-orange-a100: #ff9e80;\n@md-deep-orange-a200: #ff6e40;\n@md-deep-orange-a400: #ff3d00;\n@md-deep-orange-a700: #dd2c00;\n\n@md-brown-50: #efebe9;\n@md-brown-100: #d7ccc8;\n@md-brown-200: #bcaaa4;\n@md-brown-300: #a1887f;\n@md-brown-400: #8d6e63;\n@md-brown-500: #795548;\n@md-brown-600: #6d4c41;\n@md-brown-700: #5d4037;\n@md-brown-800: #4e342e;\n@md-brown-900: #3e2723;\n\n@md-grey-50: #fafafa;\n@md-grey-100: #f5f5f5;\n@md-grey-200: #eeeeee;\n@md-grey-300: #e0e0e0;\n@md-grey-400: #bdbdbd;\n@md-grey-500: #9e9e9e;\n@md-grey-600: #757575;\n@md-grey-700: #616161;\n@md-grey-800: #424242;\n@md-grey-900: #212121;\n\n@md-blue-grey-50: #eceff1;\n@md-blue-grey-100: #cfd8dc;\n@md-blue-grey-200: #b0bec5;\n@md-blue-grey-300: #90a4ae;\n@md-blue-grey-400: #78909c;\n@md-blue-grey-500: #607d8b;\n@md-blue-grey-600: #546e7a;\n@md-blue-grey-700: #455a64;\n@md-blue-grey-800: #37474f;\n@md-blue-grey-900: #263238;\n\n@md-dark-text-primary: rgba(0, 0, 0, 0.87);\n@md-dark-text-secondary: rgba(0, 0, 0, 0.54);\n@md-dark-text-disabled: rgba(0, 0, 0, 0.38);\n@md-dark-text-dividers: rgba(0, 0, 0, 0.12);\n\n@md-light-text-primary: rgba(255, 255, 255, 1);\n@md-light-text-secondary: rgba(255, 255, 255, 0.7);\n@md-light-text-disabled: rgba(255, 255, 255, 0.5);\n@md-light-text-dividers: rgba(255, 255, 255, 0.12);\n\n@md-dark-icons-active: rgba(0, 0, 0, 0.54);\n@md-dark-icons-inactive: rgba(0, 0, 0, 0.38);\n\n@md-light-icons-active: rgba(255, 255, 255, 1);\n@md-light-icons-inactive: rgba(255, 255, 255, 0.5);\n\n@md-white: #ffffff;\n\n@md-black: #000000;\n\n\n"],"sourceRoot":""} \ No newline at end of file diff --git a/dist/vue-treeselect.min.css b/dist/vue-treeselect.min.css new file mode 100644 index 00000000..84404274 --- /dev/null +++ b/dist/vue-treeselect.min.css @@ -0,0 +1,5 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2022 Riophae Lee + * Released under the MIT License. + * https://vue-treeselect.js.org/ + */.vue-treeselect-helper-hide{display:none}.vue-treeselect-helper-zoom-effect-off{-ms-transform:none!important;transform:none!important}@keyframes vue-treeselect-animation-fade-in{0%{opacity:0}}@keyframes vue-treeselect-animation-bounce{0%,to{transform:scale(0)}50%{transform:scale(1)}}@keyframes vue-treeselect-animation-rotate{to{transform:rotate(1turn)}}.vue-treeselect__multi-value-item--transition-enter-active,.vue-treeselect__multi-value-item--transition-leave-active{transition-duration:.2s;transition-property:transform,opacity}.vue-treeselect__multi-value-item--transition-enter-active{transition-timing-function:cubic-bezier(.075,.82,.165,1)}.vue-treeselect__multi-value-item--transition-leave-active{transition-timing-function:cubic-bezier(.215,.61,.355,1);position:absolute}.vue-treeselect__multi-value-item--transition-enter,.vue-treeselect__multi-value-item--transition-leave-to{-ms-transform:scale(.7);transform:scale(.7);opacity:0}.vue-treeselect__multi-value-item--transition-move{transition:transform .2s cubic-bezier(.165,.84,.44,1)}.vue-treeselect{position:relative;text-align:left}[dir=rtl] .vue-treeselect{text-align:right}.vue-treeselect div,.vue-treeselect span{box-sizing:border-box}.vue-treeselect svg{fill:currentColor}.vue-treeselect__control{padding-left:5px;padding-right:5px;display:table;table-layout:fixed;width:100%;height:36px;border:1px solid #ddd;border-radius:5px;background:#fff;transition-duration:.2s;transition-property:border-color,box-shadow,width,height,background-color,opacity;transition-timing-function:cubic-bezier(.215,.61,.355,1)}.vue-treeselect:not(.vue-treeselect--disabled):not(.vue-treeselect--focused) .vue-treeselect__control:hover{border-color:#cfcfcf}.vue-treeselect--focused:not(.vue-treeselect--open) .vue-treeselect__control{border-color:#039be5;box-shadow:0 0 0 3px rgba(3,155,229,.1)}.vue-treeselect--disabled .vue-treeselect__control{background-color:#f9f9f9}.vue-treeselect--open .vue-treeselect__control{border-color:#cfcfcf}.vue-treeselect--open.vue-treeselect--open-below .vue-treeselect__control{border-bottom-left-radius:0;border-bottom-right-radius:0}.vue-treeselect--open.vue-treeselect--open-above .vue-treeselect__control{border-top-left-radius:0;border-top-right-radius:0}.vue-treeselect__multi-value,.vue-treeselect__value-container{width:100%;vertical-align:middle}.vue-treeselect__value-container{display:table-cell;position:relative}.vue-treeselect--searchable:not(.vue-treeselect--disabled) .vue-treeselect__value-container{cursor:text}.vue-treeselect__multi-value{display:inline-block}.vue-treeselect--has-value .vue-treeselect__multi-value{margin-bottom:5px}.vue-treeselect__placeholder,.vue-treeselect__single-value{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;padding-left:5px;padding-right:5px;position:absolute;top:0;right:0;bottom:0;left:0;line-height:34px;-webkit-user-select:none;-ms-user-select:none;user-select:none;pointer-events:none}.vue-treeselect__placeholder{color:#bdbdbd}.vue-treeselect__single-value{color:#333}.vue-treeselect--focused.vue-treeselect--searchable .vue-treeselect__single-value{color:#bdbdbd}.vue-treeselect--disabled .vue-treeselect__single-value{position:static}.vue-treeselect__multi-value-item-container{display:inline-block;padding-top:5px;padding-right:5px;vertical-align:top}[dir=rtl] .vue-treeselect__multi-value-item-container{padding-right:0;padding-left:5px}.vue-treeselect__multi-value-item{display:inline-table;padding:2px 0;border:1px solid rgba(0,0,0,0);border-radius:2px;font-size:12px;vertical-align:top}.vue-treeselect:not(.vue-treeselect--disabled) .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-disabled):hover .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-new) .vue-treeselect__multi-value-item:not(.vue-treeselect__multi-value-item-new):hover,.vue-treeselect__multi-value-item{cursor:pointer;background:#e3f2fd;color:#039be5}.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-disabled{cursor:default;background:#f5f5f5;color:#757575}.vue-treeselect--disabled .vue-treeselect__multi-value-item{cursor:default;background:#fff;border-color:#e5e5e5;color:#555}.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-new,.vue-treeselect__multi-value-item.vue-treeselect__multi-value-item-new:hover{background:#e8f5e9}.vue-treeselect__multi-value-label,.vue-treeselect__value-remove{display:table-cell;padding:0 5px;vertical-align:middle}.vue-treeselect__value-remove{color:#039be5;padding-left:5px;border-left:1px solid #fff;line-height:0}[dir=rtl] .vue-treeselect__value-remove{border-left:0;border-right:1px solid #fff}.vue-treeselect__multi-value-item:hover .vue-treeselect__value-remove{color:#e53935}.vue-treeselect--disabled .vue-treeselect__value-remove,.vue-treeselect__multi-value-item-disabled .vue-treeselect__value-remove{display:none}.vue-treeselect__value-remove>svg{width:6px;height:6px}.vue-treeselect__multi-value-label{padding-right:5px;white-space:pre-line;-webkit-user-select:none;-ms-user-select:none;user-select:none}.vue-treeselect__limit-tip{display:inline-block;padding-top:5px;padding-right:5px;vertical-align:top}[dir=rtl] .vue-treeselect__limit-tip{padding-right:0;padding-left:5px}.vue-treeselect__limit-tip-text{cursor:default;display:block;margin:2px 0;padding:1px 0;color:#bdbdbd;font-size:12px;font-weight:600}.vue-treeselect__input-container{display:block;max-width:100%;outline:none}.vue-treeselect--single .vue-treeselect__input-container{font-size:inherit;height:100%}.vue-treeselect--multi .vue-treeselect__input-container{display:inline-block;font-size:12px;vertical-align:top}.vue-treeselect--searchable .vue-treeselect__input-container{padding-left:5px;padding-right:5px}.vue-treeselect--searchable.vue-treeselect--multi.vue-treeselect--has-value .vue-treeselect__input-container{padding-top:5px;padding-left:0}[dir=rtl] .vue-treeselect--searchable.vue-treeselect--multi.vue-treeselect--has-value .vue-treeselect__input-container{padding-left:5px;padding-right:0}.vue-treeselect--disabled .vue-treeselect__input-container{display:none}.vue-treeselect__input,.vue-treeselect__sizer{margin:0;line-height:inherit;font-family:inherit;font-size:inherit}.vue-treeselect__input{max-width:100%;margin:0;padding:0;border:0;outline:none;box-sizing:content-box;box-shadow:none;background:none rgba(0,0,0,0);line-height:1;vertical-align:middle}.vue-treeselect__input::-ms-clear{display:none}.vue-treeselect--single .vue-treeselect__input{width:100%;height:100%}.vue-treeselect--multi .vue-treeselect__input{padding-top:3px;padding-bottom:3px}.vue-treeselect--has-value .vue-treeselect__input{line-height:inherit;vertical-align:top}.vue-treeselect__sizer{position:absolute;top:0;left:0;visibility:hidden;height:0;overflow:scroll;white-space:pre}.vue-treeselect__x-container{display:table-cell;vertical-align:middle;width:20px;text-align:center;line-height:0;cursor:pointer;color:#ccc;animation:vue-treeselect-animation-fade-in .2s cubic-bezier(.075,.82,.165,1)}.vue-treeselect__x-container:hover{color:#e53935}.vue-treeselect__x{width:8px;height:8px}.vue-treeselect__control-arrow-container{display:table-cell;vertical-align:middle;width:20px;text-align:center;line-height:0;cursor:pointer}.vue-treeselect--disabled .vue-treeselect__control-arrow-container{cursor:default}.vue-treeselect__control-arrow{width:9px;height:9px;color:#ccc}.vue-treeselect:not(.vue-treeselect--disabled) .vue-treeselect__control-arrow-container:hover .vue-treeselect__control-arrow{color:#616161}.vue-treeselect--disabled .vue-treeselect__control-arrow{opacity:.35}.vue-treeselect__control-arrow--rotated{-ms-transform:rotate(180deg);transform:rotate(180deg)}.vue-treeselect__menu-container{position:absolute;left:0;width:100%;overflow:visible;transition:0s}.vue-treeselect--open-below:not(.vue-treeselect--append-to-body) .vue-treeselect__menu-container{top:100%}.vue-treeselect--open-above:not(.vue-treeselect--append-to-body) .vue-treeselect__menu-container{bottom:100%}.vue-treeselect__menu{cursor:default;padding-top:5px;padding-bottom:5px;display:block;position:absolute;overflow-x:hidden;overflow-y:auto;width:auto;border:1px solid #cfcfcf;background:#fff;line-height:180%;-webkit-overflow-scrolling:touch}.vue-treeselect--open-below .vue-treeselect__menu{border-bottom-left-radius:5px;border-bottom-right-radius:5px;top:0;margin-top:-1px;border-top-color:#f2f2f2;box-shadow:0 1px 0 rgba(0,0,0,.06)}.vue-treeselect--open-above .vue-treeselect__menu{border-top-left-radius:5px;border-top-right-radius:5px;bottom:0;margin-bottom:-1px;border-bottom-color:#f2f2f2}.vue-treeselect__indent-level-0 .vue-treeselect__option{padding-left:5px}[dir=rtl] .vue-treeselect__indent-level-0 .vue-treeselect__option{padding-left:5px;padding-right:5px}.vue-treeselect__indent-level-0 .vue-treeselect__tip{padding-left:25px}[dir=rtl] .vue-treeselect__indent-level-0 .vue-treeselect__tip{padding-left:5px;padding-right:25px}.vue-treeselect__indent-level-1 .vue-treeselect__option{padding-left:25px}[dir=rtl] .vue-treeselect__indent-level-1 .vue-treeselect__option{padding-left:5px;padding-right:25px}.vue-treeselect__indent-level-1 .vue-treeselect__tip{padding-left:45px}[dir=rtl] .vue-treeselect__indent-level-1 .vue-treeselect__tip{padding-left:5px;padding-right:45px}.vue-treeselect__indent-level-2 .vue-treeselect__option{padding-left:45px}[dir=rtl] .vue-treeselect__indent-level-2 .vue-treeselect__option{padding-left:5px;padding-right:45px}.vue-treeselect__indent-level-2 .vue-treeselect__tip{padding-left:65px}[dir=rtl] .vue-treeselect__indent-level-2 .vue-treeselect__tip{padding-left:5px;padding-right:65px}.vue-treeselect__indent-level-3 .vue-treeselect__option{padding-left:65px}[dir=rtl] .vue-treeselect__indent-level-3 .vue-treeselect__option{padding-left:5px;padding-right:65px}.vue-treeselect__indent-level-3 .vue-treeselect__tip{padding-left:85px}[dir=rtl] .vue-treeselect__indent-level-3 .vue-treeselect__tip{padding-left:5px;padding-right:85px}.vue-treeselect__indent-level-4 .vue-treeselect__option{padding-left:85px}[dir=rtl] .vue-treeselect__indent-level-4 .vue-treeselect__option{padding-left:5px;padding-right:85px}.vue-treeselect__indent-level-4 .vue-treeselect__tip{padding-left:105px}[dir=rtl] .vue-treeselect__indent-level-4 .vue-treeselect__tip{padding-left:5px;padding-right:105px}.vue-treeselect__indent-level-5 .vue-treeselect__option{padding-left:105px}[dir=rtl] .vue-treeselect__indent-level-5 .vue-treeselect__option{padding-left:5px;padding-right:105px}.vue-treeselect__indent-level-5 .vue-treeselect__tip{padding-left:125px}[dir=rtl] .vue-treeselect__indent-level-5 .vue-treeselect__tip{padding-left:5px;padding-right:125px}.vue-treeselect__indent-level-6 .vue-treeselect__option{padding-left:125px}[dir=rtl] .vue-treeselect__indent-level-6 .vue-treeselect__option{padding-left:5px;padding-right:125px}.vue-treeselect__indent-level-6 .vue-treeselect__tip{padding-left:145px}[dir=rtl] .vue-treeselect__indent-level-6 .vue-treeselect__tip{padding-left:5px;padding-right:145px}.vue-treeselect__indent-level-7 .vue-treeselect__option{padding-left:145px}[dir=rtl] .vue-treeselect__indent-level-7 .vue-treeselect__option{padding-left:5px;padding-right:145px}.vue-treeselect__indent-level-7 .vue-treeselect__tip{padding-left:165px}[dir=rtl] .vue-treeselect__indent-level-7 .vue-treeselect__tip{padding-left:5px;padding-right:165px}.vue-treeselect__indent-level-8 .vue-treeselect__option{padding-left:165px}[dir=rtl] .vue-treeselect__indent-level-8 .vue-treeselect__option{padding-left:5px;padding-right:165px}.vue-treeselect__indent-level-8 .vue-treeselect__tip{padding-left:185px}[dir=rtl] .vue-treeselect__indent-level-8 .vue-treeselect__tip{padding-left:5px;padding-right:185px}.vue-treeselect__option{padding-left:5px;padding-right:5px;display:table;table-layout:fixed;width:100%}.vue-treeselect__option--highlight{background:#f5f5f5}.vue-treeselect--single .vue-treeselect__option--selected{background:#e3f2fd;font-weight:600}.vue-treeselect--single .vue-treeselect__option--selected:hover{background:#e3f2fd}.vue-treeselect__option--hide{display:none}.vue-treeselect__option-arrow-container,.vue-treeselect__option-arrow-placeholder{display:table-cell;vertical-align:middle;width:20px;text-align:center;line-height:0}.vue-treeselect__option-arrow-container{cursor:pointer}.vue-treeselect__option-arrow{display:inline-block;width:9px;height:9px;color:#ccc;vertical-align:middle;transition:transform .2s cubic-bezier(.19,1,.22,1);-ms-transform:rotate(-90deg);transform:rotate(-90deg)}[dir=rtl] .vue-treeselect__option-arrow{-ms-transform:rotate(90deg);transform:rotate(90deg)}.vue-treeselect--branch-nodes-disabled .vue-treeselect__option:hover .vue-treeselect__option-arrow,.vue-treeselect__option-arrow-container:hover .vue-treeselect__option-arrow{color:#616161}.vue-treeselect__option-arrow--rotated,[dir=rtl] .vue-treeselect__option-arrow--rotated{-ms-transform:rotate(0);transform:rotate(0)}.vue-treeselect__option-arrow--rotated.vue-treeselect__option-arrow--prepare-enter{-ms-transform:rotate(-90deg)!important;transform:rotate(-90deg)!important}[dir=rtl] .vue-treeselect__option-arrow--rotated.vue-treeselect__option-arrow--prepare-enter{-ms-transform:rotate(90deg)!important;transform:rotate(90deg)!important}.vue-treeselect__label-container{display:table-cell;vertical-align:middle;cursor:pointer;display:table;width:100%;table-layout:fixed;color:inherit}.vue-treeselect__option--disabled .vue-treeselect__label-container{cursor:not-allowed;color:rgba(0,0,0,.25)}.vue-treeselect__checkbox-container{display:table-cell;width:20px;min-width:20px;height:100%;text-align:center;vertical-align:middle}.vue-treeselect__checkbox{display:block;margin:auto;width:12px;height:12px;border-width:1px;border-style:solid;border-radius:2px;position:relative;transition:all .2s cubic-bezier(.075,.82,.165,1)}.vue-treeselect__check-mark,.vue-treeselect__minus-mark{display:block;position:absolute;left:1px;top:1px;background-repeat:no-repeat;opacity:0;transition:all .2s ease}.vue-treeselect__minus-mark{width:8px;height:8px;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAgMAAAC5YVYYAAAACVBMVEUAAAD///////9zeKVjAAAAAnRSTlMAuLMp9oYAAAAPSURBVAjXY4CDrJUgBAMAGaECJ9dz3BAAAAAASUVORK5CYII=);background-size:8px 8px}@media (-webkit-min-device-pixel-ratio:1.5),(min-resolution:1.5dppx){.vue-treeselect__minus-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAADFBMVEUAAAD///////////84wDuoAAAAA3RSTlMAyTzPIdReAAAAGUlEQVQI12PAD+b///+Nof7//79gAsLFCwAx/w4blADeeQAAAABJRU5ErkJggg==)}}@media (-webkit-min-device-pixel-ratio:2),(min-resolution:192dpi){.vue-treeselect__minus-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAADFBMVEUAAAD///////////84wDuoAAAAA3RSTlMAyTzPIdReAAAAGUlEQVQI12PAD+b///+Nof7//79gAsLFCwAx/w4blADeeQAAAABJRU5ErkJggg==)}}@media (-webkit-min-device-pixel-ratio:3),(min-resolution:288dpi){.vue-treeselect__minus-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYBAMAAAASWSDLAAAAD1BMVEUAAAD///////////////+PQt5oAAAABHRSTlMAy2EFIuWxUgAAACRJREFUGNNjGBBgJOICBY7KDCoucODEAJSAS6FwUJShGjAQAADBPRGrK2/FhgAAAABJRU5ErkJggg==)}}.vue-treeselect__checkbox--indeterminate>.vue-treeselect__minus-mark{opacity:1}.vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAgMAAAC5YVYYAAAACVBMVEUAAADi4uLh4eHOxeSRAAAAAnRSTlMAuLMp9oYAAAAPSURBVAjXY4CDrJUgBAMAGaECJ9dz3BAAAAAASUVORK5CYII=)}@media (-webkit-min-device-pixel-ratio:1.5),(min-resolution:1.5dppx){.vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAADFBMVEUAAADi4uLi4uLh4eE5RQaIAAAAA3RSTlMAyTzPIdReAAAAGUlEQVQI12PAD+b///+Nof7//79gAsLFCwAx/w4blADeeQAAAABJRU5ErkJggg==)}}@media (-webkit-min-device-pixel-ratio:2),(min-resolution:192dpi){.vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAADFBMVEUAAADi4uLi4uLh4eE5RQaIAAAAA3RSTlMAyTzPIdReAAAAGUlEQVQI12PAD+b///+Nof7//79gAsLFCwAx/w4blADeeQAAAABJRU5ErkJggg==)}}@media (-webkit-min-device-pixel-ratio:3),(min-resolution:288dpi){.vue-treeselect__checkbox--disabled .vue-treeselect__minus-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYBAMAAAASWSDLAAAAD1BMVEUAAADh4eHg4ODNzc3h4eEYfw2wAAAABHRSTlMAy2EFIuWxUgAAACRJREFUGNNjGBBgJOICBY7KDCoucODEAJSAS6FwUJShGjAQAADBPRGrK2/FhgAAAABJRU5ErkJggg==)}}.vue-treeselect__check-mark{width:8px;height:8px;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAMAAADz0U65AAAAQlBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////8IX9KGAAAAFXRSTlMA8u24NxILB+Tawb6jiH1zRz0xIQIIP3GUAAAAMklEQVQI1y3FtQEAMQDDQD+EGbz/qkEVOpyEOP6PudKjZNSXn4Jm2CKRdBKzSLsFWl8fMG0Bl6Jk1rMAAAAASUVORK5CYII=);background-size:8px 8px;-ms-transform:scaleY(.125);transform:scaleY(.125)}@media (-webkit-min-device-pixel-ratio:1.5),(min-resolution:1.5dppx){.vue-treeselect__check-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAYFBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////98JRy6AAAAH3RSTlMAzu4sDenl38fBvo1OMyIdEQrj1cSihX5hYFpHNycIcQOASAAAAF9JREFUGNN9zEcOgDAMRFHTS0LvNfe/JRmHKAIJ/mqeLJn+k9uDtaeUeFnFziGsBucUTirrprfe81RqZ3Bb6hPWeuZwDFOHyf+ig9CCzQ7INBn7bG5kF+QSt13BHNJnF7AaCT4Y+CW7AAAAAElFTkSuQmCC)}}@media (-webkit-min-device-pixel-ratio:2),(min-resolution:192dpi){.vue-treeselect__check-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAYFBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////98JRy6AAAAH3RSTlMAzu4sDenl38fBvo1OMyIdEQrj1cSihX5hYFpHNycIcQOASAAAAF9JREFUGNN9zEcOgDAMRFHTS0LvNfe/JRmHKAIJ/mqeLJn+k9uDtaeUeFnFziGsBucUTirrprfe81RqZ3Bb6hPWeuZwDFOHyf+ig9CCzQ7INBn7bG5kF+QSt13BHNJnF7AaCT4Y+CW7AAAAAElFTkSuQmCC)}}@media (-webkit-min-device-pixel-ratio:3),(min-resolution:288dpi){.vue-treeselect__check-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAWlBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////9ZMre9AAAAHXRSTlMA/PiJhGNI9XlEHJB/b2ldV08+Oibk49vPp6QhAYgGBuwAAACCSURBVCjPrdHdDoIwDAXgTWAqCigo/+f9X5OwnoUwtis4V92XNWladUl+rzQPeQJAN2EHxoOnsPn7/oYk8fxBv08Rr/deOH/aZ2Nm8ZJ+s573QGfWKnNuZGzWm3+lv2V3pcU1XQ385/yjmBoM3Z+dXvlbYLLD3ujhTaOM3KaIXvNkFkuSEvYy1LqOAAAAAElFTkSuQmCC)}}.vue-treeselect__checkbox--checked>.vue-treeselect__check-mark{opacity:1;-ms-transform:scaleY(1);transform:scaleY(1)}.vue-treeselect__checkbox--disabled .vue-treeselect__check-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAMAAADz0U65AAAAP1BMVEUAAADj4+Pf39/h4eHh4eHh4eHk5OTh4eHg4ODi4uLh4eHh4eHg4ODh4eHh4eHg4ODh4eHh4eHp6en////h4eFqcyvUAAAAFHRSTlMAOQfy7bgS5NrBvqOIfXNHMSELAgQ/iFsAAAA2SURBVAjXY4AANjYIzcjMAaVFuBkY+RkEWERYmRjYRXjANAOfiIgIFxNIAa8IpxBEi6AwiAQAK2MBd7xY8csAAAAASUVORK5CYII=)}@media (-webkit-min-device-pixel-ratio:1.5),(min-resolution:1.5dppx){.vue-treeselect__checkbox--disabled .vue-treeselect__check-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAXVBMVEUAAADh4eHh4eHh4eHi4uLb29vh4eHh4eHh4eHh4eHh4eHh4eHh4eHi4uLi4uLj4+Pi4uLk5OTo6Ojh4eHh4eHi4uLg4ODg4ODh4eHg4ODh4eHf39/g4OD////h4eEzIk+wAAAAHnRSTlMAzu6/LA3p5eLZx8ONTjYiHRIKooV+YWBaRzEnCANnm5rnAAAAZElEQVQY033P2wqAIAyA4VWaaWrnc/n+j5mbhBjUf7WPoTD47TJb4i5zTr/sRDRHuyFaoWX7uK/RlbctlPEuyI1f4WY9yQINEkf6rzzo8YIzmUFoCs7J1EjeIaa9bXIEmzl8dgOZEAj/+2IvzAAAAABJRU5ErkJggg==)}}@media (-webkit-min-device-pixel-ratio:2),(min-resolution:192dpi){.vue-treeselect__checkbox--disabled .vue-treeselect__check-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAXVBMVEUAAADh4eHh4eHh4eHi4uLb29vh4eHh4eHh4eHh4eHh4eHh4eHh4eHi4uLi4uLj4+Pi4uLk5OTo6Ojh4eHh4eHi4uLg4ODg4ODh4eHg4ODh4eHf39/g4OD////h4eEzIk+wAAAAHnRSTlMAzu6/LA3p5eLZx8ONTjYiHRIKooV+YWBaRzEnCANnm5rnAAAAZElEQVQY033P2wqAIAyA4VWaaWrnc/n+j5mbhBjUf7WPoTD47TJb4i5zTr/sRDRHuyFaoWX7uK/RlbctlPEuyI1f4WY9yQINEkf6rzzo8YIzmUFoCs7J1EjeIaa9bXIEmzl8dgOZEAj/+2IvzAAAAABJRU5ErkJggg==)}}@media (-webkit-min-device-pixel-ratio:3),(min-resolution:288dpi){.vue-treeselect__checkbox--disabled .vue-treeselect__check-mark{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAMAAADXqc3KAAAAUVBMVEUAAADh4eHh4eHh4eHh4eHi4uLi4uLh4eHh4eHh4eHf39/j4+Ph4eHh4eHh4eHg4ODi4uLh4eHh4eHi4uLh4eHh4eHh4eHh4eHh4eH////h4eF3FMFTAAAAGnRSTlMA+/eJhGhfSHE9JBzz5KaQf3pXT0Xbz0I5AYDw8F0AAAB+SURBVCjPrdHbDoMgEEVRKAii1dZe9fz/hxplTiKIT7qfYCWTEEZdUvOwbckNAD2WHeh3brHW5f5EzGQ+iN+b1Gt6KPvtv16Dn6JX9M9ya3/A1yfu5dlyduL6Hec7mXY6ddXLPP2lpABGZ8PWXfYLTJxZekVhhl7eTX24zZPNKXoRC7zQLjUAAAAASUVORK5CYII=)}}.vue-treeselect__checkbox--unchecked{border-color:#e0e0e0;background:#fff}.vue-treeselect__label-container:hover .vue-treeselect__checkbox--unchecked{border-color:#039be5;background:#fff}.vue-treeselect__checkbox--checked,.vue-treeselect__checkbox--indeterminate,.vue-treeselect__label-container:hover .vue-treeselect__checkbox--checked,.vue-treeselect__label-container:hover .vue-treeselect__checkbox--indeterminate{border-color:#039be5;background:#039be5}.vue-treeselect__checkbox--disabled,.vue-treeselect__label-container:hover .vue-treeselect__checkbox--disabled{border-color:#e0e0e0;background-color:#f7f7f7}.vue-treeselect__label{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;display:table-cell;padding-left:5px;max-width:100%;vertical-align:middle;cursor:inherit}[dir=rtl] .vue-treeselect__label{padding-left:0;padding-right:5px}.vue-treeselect__count{margin-left:5px;font-weight:400;opacity:.6}[dir=rtl] .vue-treeselect__count{margin-left:0;margin-right:5px}.vue-treeselect__tip{padding-left:5px;padding-right:5px;display:table;table-layout:fixed;width:100%;color:#757575}.vue-treeselect__tip-text{display:table-cell;vertical-align:middle;padding-left:5px;padding-right:5px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;width:100%;font-size:12px}.vue-treeselect__error-tip .vue-treeselect__retry{cursor:pointer;margin-left:5px;font-style:normal;font-weight:600;text-decoration:none;color:#039be5}[dir=rtl] .vue-treeselect__error-tip .vue-treeselect__retry{margin-left:0;margin-right:5px}.vue-treeselect__icon-container{display:table-cell;vertical-align:middle;width:20px;text-align:center;line-height:0}.vue-treeselect--single .vue-treeselect__icon-container{padding-left:5px}[dir=rtl] .vue-treeselect--single .vue-treeselect__icon-container{padding-left:0;padding-right:5px}.vue-treeselect__icon-warning{display:block;margin:auto;border-radius:50%;position:relative;width:12px;height:12px;background:#fb8c00}.vue-treeselect__icon-warning:after{display:block;position:absolute;content:"";left:5px;top:2.5px;width:2px;height:1px;border-color:#fff;border-style:solid;border-width:5px 0 1px}.vue-treeselect__icon-error{display:block;margin:auto;border-radius:50%;position:relative;width:12px;height:12px;background:#e53935}.vue-treeselect__icon-error:after,.vue-treeselect__icon-error:before{display:block;position:absolute;content:"";background:#fff;-ms-transform:rotate(45deg);transform:rotate(45deg)}.vue-treeselect__icon-error:before{width:6px;height:2px;left:3px;top:5px}.vue-treeselect__icon-error:after{width:2px;height:6px;left:5px;top:3px}.vue-treeselect__icon-loader{display:block;margin:auto;position:relative;width:12px;height:12px;text-align:center;animation:vue-treeselect-animation-rotate 1.6s linear infinite}.vue-treeselect__icon-loader:after,.vue-treeselect__icon-loader:before{border-radius:50%;position:absolute;content:"";left:0;top:0;display:block;width:100%;height:100%;opacity:.6;animation:vue-treeselect-animation-bounce 1.6s ease-in-out infinite}.vue-treeselect__icon-loader:before{background:#039be5}.vue-treeselect__icon-loader:after{background:#b3e5fc;animation-delay:-.8s}.vue-treeselect__menu-placeholder{display:none}.vue-treeselect__portal-target{position:absolute;display:block;left:0;top:0;height:0;width:0;padding:0;margin:0;border:0;overflow:visible;box-sizing:border-box} \ No newline at end of file diff --git a/dist/vue-treeselect.umd.js b/dist/vue-treeselect.umd.js new file mode 100644 index 00000000..c96a4f6f --- /dev/null +++ b/dist/vue-treeselect.umd.js @@ -0,0 +1,5127 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2022 Riophae Lee + * Released under the MIT License. + * https://vue-treeselect.js.org/ + */ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("Vue")); + else if(typeof define === 'function' && define.amd) + define(["Vue"], factory); + else if(typeof exports === 'object') + exports["VueTreeselect"] = factory(require("Vue")); + else + root["VueTreeselect"] = factory(root["Vue"]); +})(window, function(__WEBPACK_EXTERNAL_MODULE__38__) { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = "/"; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 40); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + +var arrayWithHoles = __webpack_require__(1); + +var iterableToArrayLimit = __webpack_require__(2); + +var unsupportedIterableToArray = __webpack_require__(3); + +var nonIterableRest = __webpack_require__(5); + +function _slicedToArray(arr, i) { + return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest(); +} + +module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 1 */ +/***/ (function(module, exports) { + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 2 */ +/***/ (function(module, exports) { + +function _iterableToArrayLimit(arr, i) { + var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; + + if (_i == null) return; + var _arr = []; + var _n = true; + var _d = false; + + var _s, _e; + + try { + for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + +var arrayLikeToArray = __webpack_require__(4); + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen); +} + +module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 4 */ +/***/ (function(module, exports) { + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) { + arr2[i] = arr[i]; + } + + return arr2; +} + +module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 5 */ +/***/ (function(module, exports) { + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + +var arrayWithoutHoles = __webpack_require__(7); + +var iterableToArray = __webpack_require__(8); + +var unsupportedIterableToArray = __webpack_require__(3); + +var nonIterableSpread = __webpack_require__(9); + +function _toConsumableArray(arr) { + return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread(); +} + +module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + +var arrayLikeToArray = __webpack_require__(4); + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return arrayLikeToArray(arr); +} + +module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 8 */ +/***/ (function(module, exports) { + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); +} + +module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 9 */ +/***/ (function(module, exports) { + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 10 */ +/***/ (function(module, exports) { + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 11 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +function fuzzysearch (needle, haystack) { + var tlen = haystack.length; + var qlen = needle.length; + if (qlen > tlen) { + return false; + } + if (qlen === tlen) { + return needle === haystack; + } + outer: for (var i = 0, j = 0; i < qlen; i++) { + var nch = needle.charCodeAt(i); + while (j < tlen) { + if (haystack.charCodeAt(j++) === nch) { + continue outer; + } + } + return false; + } + return true; +} + +module.exports = fuzzysearch; + + +/***/ }), +/* 12 */ +/***/ (function(module, exports) { + +/** + * This method returns `undefined`. + * + * @static + * @memberOf _ + * @since 2.3.0 + * @category Util + * @example + * + * _.times(2, _.noop); + * // => [undefined, undefined] + */ +function noop() { + // No operation performed. +} + +module.exports = noop; + + +/***/ }), +/* 13 */ +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__(14), + now = __webpack_require__(15), + toNumber = __webpack_require__(19); + +/** Error message constants. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max, + nativeMin = Math.min; + +/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ +function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + timeWaiting = wait - timeSinceLastCall; + + return maxing + ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) + : timeWaiting; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + clearTimeout(timerId); + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; +} + +module.exports = debounce; + + +/***/ }), +/* 14 */ +/***/ (function(module, exports) { + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); +} + +module.exports = isObject; + + +/***/ }), +/* 15 */ +/***/ (function(module, exports, __webpack_require__) { + +var root = __webpack_require__(16); + +/** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ +var now = function() { + return root.Date.now(); +}; + +module.exports = now; + + +/***/ }), +/* 16 */ +/***/ (function(module, exports, __webpack_require__) { + +var freeGlobal = __webpack_require__(17); + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +module.exports = root; + + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +module.exports = freeGlobal; + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(18))) + +/***/ }), +/* 18 */ +/***/ (function(module, exports) { + +var g; + +// This works in non-strict mode +g = (function() { + return this; +})(); + +try { + // This works if eval is allowed (see CSP) + g = g || new Function("return this")(); +} catch (e) { + // This works if the window reference is available + if (typeof window === "object") g = window; +} + +// g can still be undefined, but nothing to do about it... +// We return undefined, instead of nothing here, so it's +// easier to handle this case. if(!global) { ...} + +module.exports = g; + + +/***/ }), +/* 19 */ +/***/ (function(module, exports, __webpack_require__) { + +var baseTrim = __webpack_require__(20), + isObject = __webpack_require__(14), + isSymbol = __webpack_require__(22); + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** Used to detect bad signed hexadecimal string values. */ +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + +/** Used to detect binary string values. */ +var reIsBinary = /^0b[01]+$/i; + +/** Used to detect octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + +/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ +function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = baseTrim(value); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); +} + +module.exports = toNumber; + + +/***/ }), +/* 20 */ +/***/ (function(module, exports, __webpack_require__) { + +var trimmedEndIndex = __webpack_require__(21); + +/** Used to match leading whitespace. */ +var reTrimStart = /^\s+/; + +/** + * The base implementation of `_.trim`. + * + * @private + * @param {string} string The string to trim. + * @returns {string} Returns the trimmed string. + */ +function baseTrim(string) { + return string + ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') + : string; +} + +module.exports = baseTrim; + + +/***/ }), +/* 21 */ +/***/ (function(module, exports) { + +/** Used to match a single whitespace character. */ +var reWhitespace = /\s/; + +/** + * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace + * character of `string`. + * + * @private + * @param {string} string The string to inspect. + * @returns {number} Returns the index of the last non-whitespace character. + */ +function trimmedEndIndex(string) { + var index = string.length; + + while (index-- && reWhitespace.test(string.charAt(index))) {} + return index; +} + +module.exports = trimmedEndIndex; + + +/***/ }), +/* 22 */ +/***/ (function(module, exports, __webpack_require__) { + +var baseGetTag = __webpack_require__(23), + isObjectLike = __webpack_require__(27); + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); +} + +module.exports = isSymbol; + + +/***/ }), +/* 23 */ +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__(24), + getRawTag = __webpack_require__(25), + objectToString = __webpack_require__(26); + +/** `Object#toString` result references. */ +var nullTag = '[object Null]', + undefinedTag = '[object Undefined]'; + +/** Built-in value references. */ +var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + +/** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ +function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString(value); +} + +module.exports = baseGetTag; + + +/***/ }), +/* 24 */ +/***/ (function(module, exports, __webpack_require__) { + +var root = __webpack_require__(16); + +/** Built-in value references. */ +var Symbol = root.Symbol; + +module.exports = Symbol; + + +/***/ }), +/* 25 */ +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__(24); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto.toString; + +/** Built-in value references. */ +var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + +/** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ +function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), + tag = value[symToStringTag]; + + try { + value[symToStringTag] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result; +} + +module.exports = getRawTag; + + +/***/ }), +/* 26 */ +/***/ (function(module, exports) { + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto.toString; + +/** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ +function objectToString(value) { + return nativeObjectToString.call(value); +} + +module.exports = objectToString; + + +/***/ }), +/* 27 */ +/***/ (function(module, exports) { + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return value != null && typeof value == 'object'; +} + +module.exports = isObjectLike; + + +/***/ }), +/* 28 */ +/***/ (function(module, exports) { + +module.exports = isPromise; +module.exports.default = isPromise; + +function isPromise(obj) { + return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function'; +} + + +/***/ }), +/* 29 */ +/***/ (function(module, exports, __webpack_require__) { + +var before = __webpack_require__(30); + +/** + * Creates a function that is restricted to invoking `func` once. Repeat calls + * to the function return the value of the first invocation. The `func` is + * invoked with the `this` binding and arguments of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var initialize = _.once(createApplication); + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ +function once(func) { + return before(2, func); +} + +module.exports = once; + + +/***/ }), +/* 30 */ +/***/ (function(module, exports, __webpack_require__) { + +var toInteger = __webpack_require__(31); + +/** Error message constants. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {number} n The number of calls at which `func` is no longer invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * jQuery(element).on('click', _.before(5, addContactToList)); + * // => Allows adding up to 4 contacts to the list. + */ +function before(n, func) { + var result; + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function() { + if (--n > 0) { + result = func.apply(this, arguments); + } + if (n <= 1) { + func = undefined; + } + return result; + }; +} + +module.exports = before; + + +/***/ }), +/* 31 */ +/***/ (function(module, exports, __webpack_require__) { + +var toFinite = __webpack_require__(32); + +/** + * Converts `value` to an integer. + * + * **Note:** This method is loosely based on + * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toInteger(3.2); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3.2'); + * // => 3 + */ +function toInteger(value) { + var result = toFinite(value), + remainder = result % 1; + + return result === result ? (remainder ? result - remainder : result) : 0; +} + +module.exports = toInteger; + + +/***/ }), +/* 32 */ +/***/ (function(module, exports, __webpack_require__) { + +var toNumber = __webpack_require__(19); + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0, + MAX_INTEGER = 1.7976931348623157e+308; + +/** + * Converts `value` to a finite number. + * + * @static + * @memberOf _ + * @since 4.12.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted number. + * @example + * + * _.toFinite(3.2); + * // => 3.2 + * + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toFinite('3.2'); + * // => 3.2 + */ +function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === INFINITY || value === -INFINITY) { + var sign = (value < 0 ? -1 : 1); + return sign * MAX_INTEGER; + } + return value === value ? value : 0; +} + +module.exports = toFinite; + + +/***/ }), +/* 33 */ +/***/ (function(module, exports) { + +/** + * This method returns the first argument it receives. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Util + * @param {*} value Any value. + * @returns {*} Returns `value`. + * @example + * + * var object = { 'a': 1 }; + * + * console.log(_.identity(object) === object); + * // => true + */ +function identity(value) { + return value; +} + +module.exports = identity; + + +/***/ }), +/* 34 */ +/***/ (function(module, exports) { + +/** + * Creates a function that returns `value`. + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Util + * @param {*} value The value to return from the new function. + * @returns {Function} Returns the new constant function. + * @example + * + * var objects = _.times(2, _.constant({ 'a': 1 })); + * + * console.log(objects); + * // => [{ 'a': 1 }, { 'a': 1 }] + * + * console.log(objects[0] === objects[1]); + * // => true + */ +function constant(value) { + return function() { + return value; + }; +} + +module.exports = constant; + + +/***/ }), +/* 35 */ +/***/ (function(module, exports) { + +function _typeof(obj) { + "@babel/helpers - typeof"; + + return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj); +} + +module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports; + +/***/ }), +/* 36 */ +/***/ (function(module, exports) { + +/** + * Gets the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the last element of `array`. + * @example + * + * _.last([1, 2, 3]); + * // => 3 + */ +function last(array) { + var length = array == null ? 0 : array.length; + return length ? array[length - 1] : undefined; +} + +module.exports = last; + + +/***/ }), +/* 37 */ +/***/ (function(module, exports) { + +var nestRE = /^(attrs|props|on|nativeOn|class|style|hook)$/ + +module.exports = function mergeJSXProps (objs) { + return objs.reduce(function (a, b) { + var aa, bb, key, nestedKey, temp + for (key in b) { + aa = a[key] + bb = b[key] + if (aa && nestRE.test(key)) { + // normalize class + if (key === 'class') { + if (typeof aa === 'string') { + temp = aa + a[key] = aa = {} + aa[temp] = true + } + if (typeof bb === 'string') { + temp = bb + b[key] = bb = {} + bb[temp] = true + } + } + if (key === 'on' || key === 'nativeOn' || key === 'hook') { + // merge functions + for (nestedKey in bb) { + aa[nestedKey] = mergeFn(aa[nestedKey], bb[nestedKey]) + } + } else if (Array.isArray(aa)) { + a[key] = aa.concat(bb) + } else if (Array.isArray(bb)) { + a[key] = [aa].concat(bb) + } else { + for (nestedKey in bb) { + aa[nestedKey] = bb[nestedKey] + } + } + } else { + a[key] = b[key] + } + } + return a + }, {}) +} + +function mergeFn (a, b) { + return function () { + a && a.apply(this, arguments) + b && b.apply(this, arguments) + } +} + + +/***/ }), +/* 38 */ +/***/ (function(module, exports) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__38__; + +/***/ }), +/* 39 */ +/***/ (function(module, exports, __webpack_require__) { + +// extracted by mini-css-extract-plugin + +/***/ }), +/* 40 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +// ESM COMPAT FLAG +__webpack_require__.r(__webpack_exports__); + +// EXPORTS +__webpack_require__.d(__webpack_exports__, "Treeselect", function() { return /* reexport */ Treeselect; }); +__webpack_require__.d(__webpack_exports__, "treeselectMixin", function() { return /* reexport */ treeselectMixin; }); +__webpack_require__.d(__webpack_exports__, "LOAD_ROOT_OPTIONS", function() { return /* reexport */ LOAD_ROOT_OPTIONS; }); +__webpack_require__.d(__webpack_exports__, "LOAD_CHILDREN_OPTIONS", function() { return /* reexport */ LOAD_CHILDREN_OPTIONS; }); +__webpack_require__.d(__webpack_exports__, "ASYNC_SEARCH", function() { return /* reexport */ ASYNC_SEARCH; }); +__webpack_require__.d(__webpack_exports__, "VERSION", function() { return /* binding */ VERSION; }); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/slicedToArray.js +var slicedToArray = __webpack_require__(0); +var slicedToArray_default = /*#__PURE__*/__webpack_require__.n(slicedToArray); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/toConsumableArray.js +var toConsumableArray = __webpack_require__(6); +var toConsumableArray_default = /*#__PURE__*/__webpack_require__.n(toConsumableArray); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/defineProperty.js +var defineProperty = __webpack_require__(10); +var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty); + +// EXTERNAL MODULE: ./node_modules/fuzzysearch/index.js +var fuzzysearch = __webpack_require__(11); +var fuzzysearch_default = /*#__PURE__*/__webpack_require__.n(fuzzysearch); + +// EXTERNAL MODULE: ./node_modules/lodash/noop.js +var noop = __webpack_require__(12); + +// CONCATENATED MODULE: ./src/utils/noop.js + +// CONCATENATED MODULE: ./src/utils/warning.js + + +var warning_warning = false ? undefined : function warning(checker, complainer) { + if (!checker()) { + var _console; + + var message = ['[Vue-Treeselect Warning]'].concat(complainer()); + + (_console = console).error.apply(_console, toConsumableArray_default()(message)); + } +}; +// CONCATENATED MODULE: ./src/utils/onLeftClick.js +function onLeftClick(mouseDownHandler) { + return function onMouseDown(evt) { + if (evt.type === 'mousedown' && evt.button === 0) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + mouseDownHandler.call.apply(mouseDownHandler, [this, evt].concat(args)); + } + }; +} +// CONCATENATED MODULE: ./src/utils/scrollIntoView.js +function scrollIntoView($scrollingEl, $focusedEl) { + var scrollingReact = $scrollingEl.getBoundingClientRect(); + var focusedRect = $focusedEl.getBoundingClientRect(); + var overScroll = $focusedEl.offsetHeight / 3; + + if (focusedRect.bottom + overScroll > scrollingReact.bottom) { + $scrollingEl.scrollTop = Math.min($focusedEl.offsetTop + $focusedEl.clientHeight - $scrollingEl.offsetHeight + overScroll, $scrollingEl.scrollHeight); + } else if (focusedRect.top - overScroll < scrollingReact.top) { + $scrollingEl.scrollTop = Math.max($focusedEl.offsetTop - overScroll, 0); + } +} +// EXTERNAL MODULE: ./node_modules/lodash/debounce.js +var debounce = __webpack_require__(13); +var debounce_default = /*#__PURE__*/__webpack_require__.n(debounce); + +// CONCATENATED MODULE: ./src/utils/debounce.js + +// CONCATENATED MODULE: ./node_modules/watch-size/index.es.mjs +var index_es_index = (function (element, listener) { + var expand = document.createElement('_'); + var shrink = expand.appendChild(document.createElement('_')); + var expandChild = expand.appendChild(document.createElement('_')); + var shrinkChild = shrink.appendChild(document.createElement('_')); + + var lastWidth = void 0, + lastHeight = void 0; + + shrink.style.cssText = expand.style.cssText = 'height:100%;left:0;opacity:0;overflow:hidden;pointer-events:none;position:absolute;top:0;transition:0s;width:100%;z-index:-1'; + shrinkChild.style.cssText = expandChild.style.cssText = 'display:block;height:100%;transition:0s;width:100%'; + shrinkChild.style.width = shrinkChild.style.height = '200%'; + + element.appendChild(expand); + + test(); + + return stop; + + function test() { + unbind(); + + var width = element.offsetWidth; + var height = element.offsetHeight; + + if (width !== lastWidth || height !== lastHeight) { + lastWidth = width; + lastHeight = height; + + expandChild.style.width = width * 2 + 'px'; + expandChild.style.height = height * 2 + 'px'; + + expand.scrollLeft = expand.scrollWidth; + expand.scrollTop = expand.scrollHeight; + shrink.scrollLeft = shrink.scrollWidth; + shrink.scrollTop = shrink.scrollHeight; + + listener({ width: width, height: height }); + } + + shrink.addEventListener('scroll', test); + expand.addEventListener('scroll', test); + } + + function unbind() { + shrink.removeEventListener('scroll', test); + expand.removeEventListener('scroll', test); + } + + function stop() { + unbind(); + + element.removeChild(expand); + } +}); + +/* harmony default export */ var index_es = (index_es_index); + +// CONCATENATED MODULE: ./src/utils/removeFromArray.js +function removeFromArray(arr, elem) { + var idx = arr.indexOf(elem); + if (idx !== -1) arr.splice(idx, 1); +} +// CONCATENATED MODULE: ./src/utils/watchSize.js + + +var intervalId; +var registered = []; +var INTERVAL_DURATION = 100; + +function run() { + intervalId = setInterval(function () { + registered.forEach(test); + }, INTERVAL_DURATION); +} + +function stop() { + clearInterval(intervalId); + intervalId = null; +} + +function test(item) { + var $el = item.$el, + listener = item.listener, + lastWidth = item.lastWidth, + lastHeight = item.lastHeight; + var width = $el.offsetWidth; + var height = $el.offsetHeight; + + if (lastWidth !== width || lastHeight !== height) { + item.lastWidth = width; + item.lastHeight = height; + listener({ + width: width, + height: height + }); + } +} + +function watchSizeForIE9($el, listener) { + var item = { + $el: $el, + listener: listener, + lastWidth: null, + lastHeight: null + }; + + var unwatch = function unwatch() { + removeFromArray(registered, item); + if (!registered.length) stop(); + }; + + registered.push(item); + test(item); + run(); + return unwatch; +} + +function watchSize($el, listener) { + var isIE9 = document.documentMode === 9; + var locked = true; + + var wrappedListener = function wrappedListener() { + return locked || listener.apply(void 0, arguments); + }; + + var implementation = isIE9 ? watchSizeForIE9 : index_es; + var removeSizeWatcher = implementation($el, wrappedListener); + locked = false; + return removeSizeWatcher; +} +// CONCATENATED MODULE: ./src/utils/setupResizeAndScrollEventListeners.js +function findScrollParents($el) { + var $scrollParents = []; + var $parent = $el.parentNode; + + while ($parent && $parent.nodeName !== 'BODY' && $parent.nodeType === document.ELEMENT_NODE) { + if (isScrollElment($parent)) $scrollParents.push($parent); + $parent = $parent.parentNode; + } + + $scrollParents.push(window); + return $scrollParents; +} + +function isScrollElment($el) { + var _getComputedStyle = getComputedStyle($el), + overflow = _getComputedStyle.overflow, + overflowX = _getComputedStyle.overflowX, + overflowY = _getComputedStyle.overflowY; + + return /(auto|scroll|overlay)/.test(overflow + overflowY + overflowX); +} + +function setupResizeAndScrollEventListeners($el, listener) { + var $scrollParents = findScrollParents($el); + window.addEventListener('resize', listener, { + passive: true + }); + $scrollParents.forEach(function (scrollParent) { + scrollParent.addEventListener('scroll', listener, { + passive: true + }); + }); + return function removeEventListeners() { + window.removeEventListener('resize', listener, { + passive: true + }); + $scrollParents.forEach(function ($scrollParent) { + $scrollParent.removeEventListener('scroll', listener, { + passive: true + }); + }); + }; +} +// CONCATENATED MODULE: ./src/utils/isNaN.js +function isNaN_isNaN(x) { + return x !== x; +} +// EXTERNAL MODULE: ./node_modules/is-promise/index.js +var is_promise = __webpack_require__(28); +var is_promise_default = /*#__PURE__*/__webpack_require__.n(is_promise); + +// CONCATENATED MODULE: ./src/utils/isPromise.js + +// EXTERNAL MODULE: ./node_modules/lodash/once.js +var once = __webpack_require__(29); +var once_default = /*#__PURE__*/__webpack_require__.n(once); + +// CONCATENATED MODULE: ./src/utils/once.js + +// EXTERNAL MODULE: ./node_modules/lodash/identity.js +var identity = __webpack_require__(33); +var identity_default = /*#__PURE__*/__webpack_require__.n(identity); + +// CONCATENATED MODULE: ./src/utils/identity.js + +// EXTERNAL MODULE: ./node_modules/lodash/constant.js +var constant = __webpack_require__(34); +var constant_default = /*#__PURE__*/__webpack_require__.n(constant); + +// CONCATENATED MODULE: ./src/utils/constant.js + +// CONCATENATED MODULE: ./src/utils/createMap.js +var createMap = function createMap() { + return Object.create(null); +}; +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/typeof.js +var helpers_typeof = __webpack_require__(35); +var typeof_default = /*#__PURE__*/__webpack_require__.n(helpers_typeof); + +// CONCATENATED MODULE: ./src/utils/deepExtend.js + + +function isPlainObject(value) { + if (value == null || typeof_default()(value) !== 'object') return false; + return Object.getPrototypeOf(value) === Object.prototype; +} + +function copy(obj, key, value) { + if (isPlainObject(value)) { + obj[key] || (obj[key] = {}); + deepExtend(obj[key], value); + } else { + obj[key] = value; + } +} + +function deepExtend(target, source) { + if (isPlainObject(source)) { + var keys = Object.keys(source); + + for (var i = 0, len = keys.length; i < len; i++) { + copy(target, keys[i], source[keys[i]]); + } + } + + return target; +} +// EXTERNAL MODULE: ./node_modules/lodash/last.js +var lodash_last = __webpack_require__(36); +var last_default = /*#__PURE__*/__webpack_require__.n(lodash_last); + +// CONCATENATED MODULE: ./src/utils/last.js + +// CONCATENATED MODULE: ./src/utils/includes.js +function includes(arrOrStr, elem) { + return arrOrStr.indexOf(elem) !== -1; +} +// CONCATENATED MODULE: ./src/utils/find.js +function find(arr, predicate, ctx) { + for (var i = 0, len = arr.length; i < len; i++) { + if (predicate.call(ctx, arr[i], i, arr)) return arr[i]; + } + + return undefined; +} +// CONCATENATED MODULE: ./src/utils/quickDiff.js +function quickDiff(arrA, arrB) { + if (arrA.length !== arrB.length) return true; + + for (var i = 0; i < arrA.length; i++) { + if (arrA[i] !== arrB[i]) return true; + } + + return false; +} +// CONCATENATED MODULE: ./src/utils/index.js + + + + + + + + + + + + + + + + + + + +// CONCATENATED MODULE: ./src/constants.js +var NO_PARENT_NODE = null; +var UNCHECKED = 0; +var INDETERMINATE = 1; +var CHECKED = 2; +var ALL_CHILDREN = 'ALL_CHILDREN'; +var ALL_DESCENDANTS = 'ALL_DESCENDANTS'; +var LEAF_CHILDREN = 'LEAF_CHILDREN'; +var LEAF_DESCENDANTS = 'LEAF_DESCENDANTS'; +var LOAD_ROOT_OPTIONS = 'LOAD_ROOT_OPTIONS'; +var LOAD_CHILDREN_OPTIONS = 'LOAD_CHILDREN_OPTIONS'; +var ASYNC_SEARCH = 'ASYNC_SEARCH'; +var ALL = 'ALL'; +var BRANCH_PRIORITY = 'BRANCH_PRIORITY'; +var LEAF_PRIORITY = 'LEAF_PRIORITY'; +var ALL_WITH_INDETERMINATE = 'ALL_WITH_INDETERMINATE'; +var ORDER_SELECTED = 'ORDER_SELECTED'; +var LEVEL = 'LEVEL'; +var INDEX = 'INDEX'; +var KEY_CODES = { + BACKSPACE: 8, + ENTER: 13, + ESCAPE: 27, + END: 35, + HOME: 36, + ARROW_LEFT: 37, + ARROW_UP: 38, + ARROW_RIGHT: 39, + ARROW_DOWN: 40, + DELETE: 46 +}; +var INPUT_DEBOUNCE_DELAY = false ? undefined : 200; +var MIN_INPUT_WIDTH = 5; +var MENU_BUFFER = 40; +// CONCATENATED MODULE: ./src/mixins/treeselectMixin.js + + + + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { defineProperty_default()(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + + + + + +function sortValueByIndex(a, b) { + var i = 0; + + do { + if (a.level < i) return -1; + if (b.level < i) return 1; + if (a.index[i] !== b.index[i]) return a.index[i] - b.index[i]; + i++; + } while (true); +} + +function sortValueByLevel(a, b) { + return a.level === b.level ? sortValueByIndex(a, b) : a.level - b.level; +} + +function createAsyncOptionsStates() { + return { + isLoaded: false, + isLoading: false, + loadingError: '' + }; +} + +function stringifyOptionPropValue(value) { + if (typeof value === 'string') return removeAccents(value); + if (typeof value === 'number' && !isNaN_isNaN(value)) return value + ''; + return ''; +} + +function removeAccents(str) { + if (!str) return ''; + return str.normalize('NFD').replace(/[\u0300-\u036F]/g, ''); +} + +function match(enableFuzzyMatch, needle, haystack) { + return enableFuzzyMatch ? fuzzysearch_default()(needle, haystack) : includes(haystack, needle); +} + +function getErrorMessage(err) { + return err.message || String(err); +} + +var instanceId = 0; +/* harmony default export */ var treeselectMixin = ({ + provide: function provide() { + return { + instance: this + }; + }, + props: { + allowClearingDisabled: { + type: Boolean, + default: false + }, + allowSelectingDisabledDescendants: { + type: Boolean, + default: false + }, + alwaysOpen: { + type: Boolean, + default: false + }, + appendToBody: { + type: Boolean, + default: false + }, + async: { + type: Boolean, + default: false + }, + autoFocus: { + type: Boolean, + default: false + }, + autoLoadRootOptions: { + type: Boolean, + default: true + }, + autoDeselectAncestors: { + type: Boolean, + default: false + }, + autoDeselectDescendants: { + type: Boolean, + default: false + }, + autoSelectAncestors: { + type: Boolean, + default: false + }, + autoSelectDescendants: { + type: Boolean, + default: false + }, + backspaceRemoves: { + type: Boolean, + default: true + }, + beforeClearAll: { + type: Function, + default: constant_default()(true) + }, + branchNodesFirst: { + type: Boolean, + default: false + }, + cacheOptions: { + type: Boolean, + default: true + }, + clearable: { + type: Boolean, + default: true + }, + clearAllText: { + type: String, + default: 'Clear all' + }, + clearOnSelect: { + type: Boolean, + default: false + }, + clearValueText: { + type: String, + default: 'Clear value' + }, + closeOnSelect: { + type: Boolean, + default: true + }, + defaultExpandLevel: { + type: Number, + default: 0 + }, + defaultOptions: { + default: false + }, + deleteRemoves: { + type: Boolean, + default: true + }, + delimiter: { + type: String, + default: ',' + }, + flattenSearchResults: { + type: Boolean, + default: false + }, + disableBranchNodes: { + type: Boolean, + default: false + }, + disabled: { + type: Boolean, + default: false + }, + disableFuzzyMatching: { + type: Boolean, + default: false + }, + flat: { + type: Boolean, + default: false + }, + instanceId: { + default: function _default() { + return "".concat(instanceId++, "$$"); + }, + type: [String, Number] + }, + joinValues: { + type: Boolean, + default: false + }, + limit: { + type: Number, + default: Infinity + }, + limitText: { + type: Function, + default: function limitTextDefault(count) { + return "and ".concat(count, " more"); + } + }, + loadingText: { + type: String, + default: 'Loading...' + }, + loadOptions: { + type: Function + }, + matchKeys: { + type: Array, + default: constant_default()(['label']) + }, + maxHeight: { + type: Number, + default: 300 + }, + multiple: { + type: Boolean, + default: false + }, + name: { + type: String + }, + noChildrenText: { + type: String, + default: 'No sub-options.' + }, + noOptionsText: { + type: String, + default: 'No options available.' + }, + noResultsText: { + type: String, + default: 'No results found...' + }, + normalizer: { + type: Function, + default: identity_default.a + }, + openDirection: { + type: String, + default: 'auto', + validator: function validator(value) { + var acceptableValues = ['auto', 'top', 'bottom', 'above', 'below']; + return includes(acceptableValues, value); + } + }, + openOnClick: { + type: Boolean, + default: true + }, + openOnFocus: { + type: Boolean, + default: false + }, + options: { + type: Array + }, + placeholder: { + type: String, + default: 'Select...' + }, + required: { + type: Boolean, + default: false + }, + retryText: { + type: String, + default: 'Retry?' + }, + retryTitle: { + type: String, + default: 'Click to retry' + }, + searchable: { + type: Boolean, + default: true + }, + searchNested: { + type: Boolean, + default: false + }, + searchPromptText: { + type: String, + default: 'Type to search...' + }, + showCount: { + type: Boolean, + default: false + }, + showCountOf: { + type: String, + default: ALL_CHILDREN, + validator: function validator(value) { + var acceptableValues = [ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS]; + return includes(acceptableValues, value); + } + }, + showCountOnSearch: null, + sortValueBy: { + type: String, + default: ORDER_SELECTED, + validator: function validator(value) { + var acceptableValues = [ORDER_SELECTED, LEVEL, INDEX]; + return includes(acceptableValues, value); + } + }, + tabIndex: { + type: Number, + default: 0 + }, + value: null, + valueConsistsOf: { + type: String, + default: BRANCH_PRIORITY, + validator: function validator(value) { + var acceptableValues = [ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE]; + return includes(acceptableValues, value); + } + }, + valueFormat: { + type: String, + default: 'id' + }, + zIndex: { + type: [Number, String], + default: 999 + } + }, + data: function data() { + return { + trigger: { + isFocused: false, + searchQuery: '' + }, + menu: { + isOpen: false, + current: null, + lastScrollPosition: 0, + placement: 'bottom' + }, + forest: { + normalizedOptions: [], + nodeMap: createMap(), + checkedStateMap: createMap(), + selectedNodeIds: this.extractCheckedNodeIdsFromValue(), + selectedNodeMap: createMap() + }, + rootOptionsStates: createAsyncOptionsStates(), + localSearch: { + active: false, + noResults: true, + countMap: createMap() + }, + remoteSearch: createMap() + }; + }, + computed: { + selectedNodes: function selectedNodes() { + return this.forest.selectedNodeIds.map(this.getNode); + }, + internalValue: function internalValue() { + var _this = this; + + var internalValue; + + if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) { + internalValue = this.forest.selectedNodeIds.slice(); + } else if (this.valueConsistsOf === BRANCH_PRIORITY) { + internalValue = this.forest.selectedNodeIds.filter(function (id) { + var node = _this.getNode(id); + + if (node.isRootNode) return true; + return !_this.isSelected(node.parentNode); + }); + } else if (this.valueConsistsOf === LEAF_PRIORITY) { + internalValue = this.forest.selectedNodeIds.filter(function (id) { + var node = _this.getNode(id); + + if (node.isLeaf) return true; + return node.children.length === 0; + }); + } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) { + var _internalValue; + + var indeterminateNodeIds = []; + internalValue = this.forest.selectedNodeIds.slice(); + this.selectedNodes.forEach(function (selectedNode) { + selectedNode.ancestors.forEach(function (ancestor) { + if (includes(indeterminateNodeIds, ancestor.id)) return; + if (includes(internalValue, ancestor.id)) return; + indeterminateNodeIds.push(ancestor.id); + }); + }); + + (_internalValue = internalValue).push.apply(_internalValue, indeterminateNodeIds); + } + + if (this.sortValueBy === LEVEL) { + internalValue.sort(function (a, b) { + return sortValueByLevel(_this.getNode(a), _this.getNode(b)); + }); + } else if (this.sortValueBy === INDEX) { + internalValue.sort(function (a, b) { + return sortValueByIndex(_this.getNode(a), _this.getNode(b)); + }); + } + + return internalValue; + }, + hasValue: function hasValue() { + return this.internalValue.length > 0; + }, + single: function single() { + return !this.multiple; + }, + visibleOptionIds: function visibleOptionIds() { + var _this2 = this; + + var visibleOptionIds = []; + this.traverseAllNodesByIndex(function (node) { + if (!_this2.localSearch.active || _this2.shouldOptionBeIncludedInSearchResult(node)) { + visibleOptionIds.push(node.id); + } + + if (node.isBranch && !_this2.shouldExpand(node)) { + return false; + } + }); + return visibleOptionIds; + }, + hasVisibleOptions: function hasVisibleOptions() { + return this.visibleOptionIds.length !== 0; + }, + showCountOnSearchComputed: function showCountOnSearchComputed() { + return typeof this.showCountOnSearch === 'boolean' ? this.showCountOnSearch : this.showCount; + }, + hasBranchNodes: function hasBranchNodes() { + return this.forest.normalizedOptions.some(function (rootNode) { + return rootNode.isBranch; + }); + }, + shouldFlattenOptions: function shouldFlattenOptions() { + return this.localSearch.active && this.flattenSearchResults; + } + }, + watch: { + alwaysOpen: function alwaysOpen(newValue) { + if (newValue) this.openMenu();else this.closeMenu(); + }, + branchNodesFirst: function branchNodesFirst() { + this.initialize(); + }, + disabled: function disabled(newValue) { + if (newValue && this.menu.isOpen) this.closeMenu();else if (!newValue && !this.menu.isOpen && this.alwaysOpen) this.openMenu(); + }, + flat: function flat() { + this.initialize(); + }, + internalValue: function internalValue(newValue, oldValue) { + var hasChanged = quickDiff(newValue, oldValue); + if (hasChanged) this.$emit('input', this.getValue(), this.getInstanceId()); + }, + matchKeys: function matchKeys() { + this.initialize(); + }, + multiple: function multiple(newValue) { + if (newValue) this.buildForestState(); + }, + options: { + handler: function handler() { + if (this.async) return; + this.initialize(); + this.rootOptionsStates.isLoaded = Array.isArray(this.options); + }, + deep: true, + immediate: true + }, + 'trigger.searchQuery': function triggerSearchQuery() { + if (this.async) { + this.handleRemoteSearch(); + } else { + this.handleLocalSearch(); + } + + this.$emit('search-change', this.trigger.searchQuery, this.getInstanceId()); + }, + value: function value() { + var nodeIdsFromValue = this.extractCheckedNodeIdsFromValue(); + var hasChanged = quickDiff(nodeIdsFromValue, this.internalValue); + if (hasChanged) this.fixSelectedNodeIds(nodeIdsFromValue); + } + }, + methods: { + verifyProps: function verifyProps() { + var _this3 = this; + + warning_warning(function () { + return _this3.async ? _this3.searchable : true; + }, function () { + return 'For async search mode, the value of "searchable" prop must be true.'; + }); + + if (this.options == null && !this.loadOptions) { + warning_warning(function () { + return false; + }, function () { + return 'Are you meant to dynamically load options? You need to use "loadOptions" prop.'; + }); + } + + if (this.flat) { + warning_warning(function () { + return _this3.multiple; + }, function () { + return 'You are using flat mode. But you forgot to add "multiple=true"?'; + }); + } + + if (!this.flat) { + var propNames = ['autoSelectAncestors', 'autoSelectDescendants', 'autoDeselectAncestors', 'autoDeselectDescendants']; + propNames.forEach(function (propName) { + warning_warning(function () { + return !_this3[propName]; + }, function () { + return "\"".concat(propName, "\" only applies to flat mode."); + }); + }); + } + }, + resetFlags: function resetFlags() { + this._blurOnSelect = false; + }, + initialize: function initialize() { + var options = this.async ? this.getRemoteSearchEntry().options : this.options; + + if (Array.isArray(options)) { + var prevNodeMap = this.forest.nodeMap; + this.forest.nodeMap = createMap(); + this.keepDataOfSelectedNodes(prevNodeMap); + this.forest.normalizedOptions = this.normalize(NO_PARENT_NODE, options, prevNodeMap); + this.fixSelectedNodeIds(this.internalValue); + } else { + this.forest.normalizedOptions = []; + } + }, + getInstanceId: function getInstanceId() { + return this.instanceId == null ? this.id : this.instanceId; + }, + getValue: function getValue() { + var _this4 = this; + + if (this.valueFormat === 'id') { + return this.multiple ? this.getUniqChildValues(this.internalValue.slice()) : this.internalValue[0]; + } + + var rawNodes = this.internalValue.map(function (id) { + return _this4.getNode(id).raw; + }); + return this.multiple ? this.getUniqChildValues(rawNodes) : rawNodes[0]; + }, + getUniqChildValues: function getUniqChildValues(ids) { + var _this5 = this; + + if (this.valueConsistsOf !== BRANCH_PRIORITY) return ids; + var values = ids.map(function (id) { + var node = _this5.getNode(id); + + if (node.hasBeenSelected) return node.id; + + if (_this5.hasOneChild(node)) { + var children = []; + + _this5.traverseDescendantsBFS(node, function (descendant) { + if (!descendant.isDisabled || _this5.allowSelectingDisabledDescendants) { + if (descendant.hasBeenSelected) { + children.push(descendant.id); + } + } + }); + + if (children && children.length) return children[0]; + } + + return id; + }); + return values; + }, + hasOneChild: function hasOneChild(node) { + return node && node.children && node.children.length === 1; + }, + getNode: function getNode(nodeId) { + warning_warning(function () { + return nodeId != null; + }, function () { + return "Invalid node id: ".concat(nodeId); + }); + if (nodeId == null) return null; + return nodeId in this.forest.nodeMap ? this.forest.nodeMap[nodeId] : this.createFallbackNode(nodeId); + }, + createFallbackNode: function createFallbackNode(id) { + var raw = this.extractNodeFromValue(id); + var label = this.enhancedNormalizer(raw).label || "".concat(id, " (unknown)"); + var fallbackNode = { + id: id, + label: label, + ancestors: [], + parentNode: NO_PARENT_NODE, + isFallbackNode: true, + isRootNode: true, + isLeaf: true, + isBranch: false, + isDisabled: false, + isNew: false, + index: [-1], + level: 0, + raw: raw + }; + return this.$set(this.forest.nodeMap, id, fallbackNode); + }, + extractCheckedNodeIdsFromValue: function extractCheckedNodeIdsFromValue() { + var _this6 = this; + + if (this.value == null) return []; + + if (this.valueFormat === 'id') { + return this.multiple ? this.value.slice() : [this.value]; + } + + return (this.multiple ? this.value : [this.value]).map(function (node) { + return _this6.enhancedNormalizer(node); + }).map(function (node) { + return node.id; + }); + }, + extractNodeFromValue: function extractNodeFromValue(id) { + var _this7 = this; + + var defaultNode = { + id: id + }; + + if (this.valueFormat === 'id') { + return defaultNode; + } + + var valueArray = this.multiple ? Array.isArray(this.value) ? this.value : [] : this.value ? [this.value] : []; + var matched = find(valueArray, function (node) { + return node && _this7.enhancedNormalizer(node).id === id; + }); + return matched || defaultNode; + }, + fixSelectedNodeIds: function fixSelectedNodeIds(nodeIdListOfPrevValue) { + var _this8 = this; + + var nextSelectedNodeIds = []; + + if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) { + nextSelectedNodeIds = nodeIdListOfPrevValue; + } else if (this.valueConsistsOf === BRANCH_PRIORITY) { + nodeIdListOfPrevValue.forEach(function (nodeId) { + nextSelectedNodeIds.push(nodeId); + + var node = _this8.getNode(nodeId); + + if (node.isBranch) _this8.traverseDescendantsBFS(node, function (descendant) { + nextSelectedNodeIds.push(descendant.id); + }); + }); + } else if (this.valueConsistsOf === LEAF_PRIORITY) { + var map = createMap(); + var queue = nodeIdListOfPrevValue.slice(); + + while (queue.length) { + var nodeId = queue.shift(); + var node = this.getNode(nodeId); + nextSelectedNodeIds.push(nodeId); + if (node.isRootNode) continue; + if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length; + if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id); + } + } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) { + var _map = createMap(); + + var _queue = nodeIdListOfPrevValue.filter(function (nodeId) { + var node = _this8.getNode(nodeId); + + return node.isLeaf || node.children.length === 0; + }); + + while (_queue.length) { + var _nodeId = _queue.shift(); + + var _node = this.getNode(_nodeId); + + nextSelectedNodeIds.push(_nodeId); + if (_node.isRootNode) continue; + if (!(_node.parentNode.id in _map)) _map[_node.parentNode.id] = _node.parentNode.children.length; + if (--_map[_node.parentNode.id] === 0) _queue.push(_node.parentNode.id); + } + } + + var hasChanged = quickDiff(this.forest.selectedNodeIds, nextSelectedNodeIds); + if (hasChanged) this.forest.selectedNodeIds = nextSelectedNodeIds; + this.buildForestState(); + }, + keepDataOfSelectedNodes: function keepDataOfSelectedNodes(prevNodeMap) { + var _this9 = this; + + this.forest.selectedNodeIds.forEach(function (id) { + if (!prevNodeMap[id]) return; + + var node = _objectSpread(_objectSpread({}, prevNodeMap[id]), {}, { + isFallbackNode: true + }); + + _this9.$set(_this9.forest.nodeMap, id, node); + }); + }, + isSelected: function isSelected(node) { + return this.forest.selectedNodeMap[node.id] === true; + }, + traverseDescendantsBFS: function traverseDescendantsBFS(parentNode, callback) { + if (!parentNode.isBranch) return; + var queue = parentNode.children.slice(); + + while (queue.length) { + var currNode = queue[0]; + if (currNode.isBranch) queue.push.apply(queue, toConsumableArray_default()(currNode.children)); + callback(currNode); + queue.shift(); + } + }, + traverseDescendantsDFS: function traverseDescendantsDFS(parentNode, callback) { + var _this10 = this; + + if (!parentNode.isBranch) return; + parentNode.children.forEach(function (child) { + _this10.traverseDescendantsDFS(child, callback); + + callback(child); + }); + }, + traverseAllNodesDFS: function traverseAllNodesDFS(callback) { + var _this11 = this; + + this.forest.normalizedOptions.forEach(function (rootNode) { + _this11.traverseDescendantsDFS(rootNode, callback); + + callback(rootNode); + }); + }, + traverseAllNodesByIndex: function traverseAllNodesByIndex(callback) { + var walk = function walk(parentNode) { + parentNode.children.forEach(function (child) { + if (callback(child) !== false && child.isBranch) { + walk(child); + } + }); + }; + + walk({ + children: this.forest.normalizedOptions + }); + }, + toggleClickOutsideEvent: function toggleClickOutsideEvent(enabled) { + if (enabled) { + document.addEventListener('mousedown', this.handleClickOutside, false); + } else { + document.removeEventListener('mousedown', this.handleClickOutside, false); + } + }, + getValueContainer: function getValueContainer() { + return this.$refs.control.$refs['value-container']; + }, + getInput: function getInput() { + return this.getValueContainer().$refs.input; + }, + focusInput: function focusInput() { + this.getInput().focus(); + }, + blurInput: function blurInput() { + this.getInput().blur(); + }, + handleMouseDown: onLeftClick(function handleMouseDown(evt) { + evt.preventDefault(); + evt.stopPropagation(); + if (this.disabled) return; + var isClickedOnValueContainer = this.getValueContainer().$el.contains(evt.target); + + if (isClickedOnValueContainer && !this.menu.isOpen && (this.openOnClick || this.trigger.isFocused)) { + this.openMenu(); + } + + if (this._blurOnSelect) { + this.blurInput(); + } else { + this.focusInput(); + } + + this.resetFlags(); + }), + handleClickOutside: function handleClickOutside(evt) { + if (this.$refs.wrapper && !this.$refs.wrapper.contains(evt.target)) { + this.blurInput(); + this.closeMenu(); + } + }, + handleLocalSearch: function handleLocalSearch() { + var _this12 = this; + + var searchQuery = this.trigger.searchQuery; + + var done = function done() { + return _this12.resetHighlightedOptionWhenNecessary(true); + }; + + if (!searchQuery) { + this.localSearch.active = false; + return done(); + } + + this.localSearch.active = true; + this.localSearch.noResults = true; + this.traverseAllNodesDFS(function (node) { + if (node.isBranch) { + var _this12$$set; + + node.isExpandedOnSearch = false; + node.showAllChildrenOnSearch = false; + node.isMatched = false; + node.hasMatchedDescendants = false; + + _this12.$set(_this12.localSearch.countMap, node.id, (_this12$$set = {}, defineProperty_default()(_this12$$set, ALL_CHILDREN, 0), defineProperty_default()(_this12$$set, ALL_DESCENDANTS, 0), defineProperty_default()(_this12$$set, LEAF_CHILDREN, 0), defineProperty_default()(_this12$$set, LEAF_DESCENDANTS, 0), _this12$$set)); + } + }); + var lowerCasedSearchQuery = removeAccents(searchQuery).trim().toLocaleLowerCase(); + var splitSearchQuery = lowerCasedSearchQuery.replace(/\s+/g, ' ').split(' '); + this.traverseAllNodesDFS(function (node) { + if (_this12.searchNested && splitSearchQuery.length > 1) { + node.isMatched = splitSearchQuery.every(function (filterValue) { + return match(false, filterValue, node.nestedSearchLabel); + }); + } else { + node.isMatched = _this12.matchKeys.some(function (matchKey) { + return match(!_this12.disableFuzzyMatching, lowerCasedSearchQuery, node.lowerCased[matchKey]); + }); + } + + if (node.isMatched) { + _this12.localSearch.noResults = false; + node.ancestors.forEach(function (ancestor) { + return _this12.localSearch.countMap[ancestor.id][ALL_DESCENDANTS]++; + }); + if (node.isLeaf) node.ancestors.forEach(function (ancestor) { + return _this12.localSearch.countMap[ancestor.id][LEAF_DESCENDANTS]++; + }); + + if (node.parentNode !== NO_PARENT_NODE) { + _this12.localSearch.countMap[node.parentNode.id][ALL_CHILDREN] += 1; + if (node.isLeaf) _this12.localSearch.countMap[node.parentNode.id][LEAF_CHILDREN] += 1; + } + } + + if ((node.isMatched || node.isBranch && node.isExpandedOnSearch) && node.parentNode !== NO_PARENT_NODE) { + node.parentNode.isExpandedOnSearch = true; + node.parentNode.hasMatchedDescendants = true; + } + }); + done(); + }, + handleRemoteSearch: function handleRemoteSearch() { + var _this13 = this; + + var searchQuery = this.trigger.searchQuery; + var entry = this.getRemoteSearchEntry(); + + var done = function done() { + _this13.initialize(); + + _this13.resetHighlightedOptionWhenNecessary(true); + }; + + if ((searchQuery === '' || this.cacheOptions) && entry.isLoaded) { + return done(); + } + + this.callLoadOptionsProp({ + action: ASYNC_SEARCH, + args: { + searchQuery: searchQuery + }, + isPending: function isPending() { + return entry.isLoading; + }, + start: function start() { + entry.isLoading = true; + entry.isLoaded = false; + entry.loadingError = ''; + }, + succeed: function succeed(options) { + entry.isLoaded = true; + entry.options = options; + if (_this13.trigger.searchQuery === searchQuery) done(); + }, + fail: function fail(err) { + entry.loadingError = getErrorMessage(err); + }, + end: function end() { + entry.isLoading = false; + } + }); + }, + getRemoteSearchEntry: function getRemoteSearchEntry() { + var _this14 = this; + + var searchQuery = this.trigger.searchQuery; + + var entry = this.remoteSearch[searchQuery] || _objectSpread(_objectSpread({}, createAsyncOptionsStates()), {}, { + options: [] + }); + + this.$watch(function () { + return entry.options; + }, function () { + if (_this14.trigger.searchQuery === searchQuery) _this14.initialize(); + }, { + deep: true + }); + + if (searchQuery === '') { + if (Array.isArray(this.defaultOptions)) { + entry.options = this.defaultOptions; + entry.isLoaded = true; + return entry; + } else if (this.defaultOptions !== true) { + entry.isLoaded = true; + return entry; + } + } + + if (!this.remoteSearch[searchQuery]) { + this.$set(this.remoteSearch, searchQuery, entry); + } + + return entry; + }, + shouldExpand: function shouldExpand(node) { + return this.localSearch.active ? node.isExpandedOnSearch : node.isExpanded; + }, + shouldOptionBeIncludedInSearchResult: function shouldOptionBeIncludedInSearchResult(node) { + if (node.isMatched) return true; + if (node.isBranch && node.hasMatchedDescendants && !this.flattenSearchResults) return true; + if (!node.isRootNode && node.parentNode.showAllChildrenOnSearch) return true; + return false; + }, + shouldShowOptionInMenu: function shouldShowOptionInMenu(node) { + if (this.localSearch.active && !this.shouldOptionBeIncludedInSearchResult(node)) { + return false; + } + + return true; + }, + getControl: function getControl() { + return this.$refs.control.$el; + }, + getMenu: function getMenu() { + var ref = this.appendToBody ? this.$refs.portal.portalTarget : this; + var $menu = ref.$refs.menu.$refs.menu; + return $menu && $menu.nodeName !== '#comment' ? $menu : null; + }, + setCurrentHighlightedOption: function setCurrentHighlightedOption(node) { + var _this15 = this; + + var scroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var prev = this.menu.current; + + if (prev != null && prev in this.forest.nodeMap) { + this.forest.nodeMap[prev].isHighlighted = false; + } + + this.menu.current = node.id; + node.isHighlighted = true; + + if (this.menu.isOpen && scroll) { + var scrollToOption = function scrollToOption() { + var $menu = _this15.getMenu(); + + var $option = $menu.querySelector(".vue-treeselect__option[data-id=\"".concat(node.id, "\"]")); + if ($option) scrollIntoView($menu, $option); + }; + + if (this.getMenu()) { + scrollToOption(); + } else { + this.$nextTick(scrollToOption); + } + } + }, + resetHighlightedOptionWhenNecessary: function resetHighlightedOptionWhenNecessary() { + var forceReset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var current = this.menu.current; + + if (forceReset || current == null || !(current in this.forest.nodeMap) || !this.shouldShowOptionInMenu(this.getNode(current))) { + this.highlightFirstOption(); + } + }, + highlightFirstOption: function highlightFirstOption() { + if (!this.hasVisibleOptions) return; + var first = this.visibleOptionIds[0]; + this.setCurrentHighlightedOption(this.getNode(first)); + }, + highlightPrevOption: function highlightPrevOption() { + if (!this.hasVisibleOptions) return; + var prev = this.visibleOptionIds.indexOf(this.menu.current) - 1; + if (prev === -1) return this.highlightLastOption(); + this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[prev])); + }, + highlightNextOption: function highlightNextOption() { + if (!this.hasVisibleOptions) return; + var next = this.visibleOptionIds.indexOf(this.menu.current) + 1; + if (next === this.visibleOptionIds.length) return this.highlightFirstOption(); + this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[next])); + }, + highlightLastOption: function highlightLastOption() { + if (!this.hasVisibleOptions) return; + var last = last_default()(this.visibleOptionIds); + this.setCurrentHighlightedOption(this.getNode(last)); + }, + resetSearchQuery: function resetSearchQuery() { + this.trigger.searchQuery = ''; + }, + closeMenu: function closeMenu() { + if (!this.menu.isOpen || !this.disabled && this.alwaysOpen) return; + this.saveMenuScrollPosition(); + this.menu.isOpen = false; + this.toggleClickOutsideEvent(false); + this.resetSearchQuery(); + this.$emit('close', this.getValue(), this.getInstanceId()); + }, + openMenu: function openMenu() { + if (this.disabled || this.menu.isOpen) return; + this.menu.isOpen = true; + this.$nextTick(this.resetHighlightedOptionWhenNecessary); + this.$nextTick(this.restoreMenuScrollPosition); + if (!this.options && !this.async) this.loadRootOptions(); + this.toggleClickOutsideEvent(true); + this.$emit('open', this.getInstanceId()); + }, + toggleMenu: function toggleMenu() { + if (this.menu.isOpen) { + this.closeMenu(); + } else { + this.openMenu(); + } + }, + toggleExpanded: function toggleExpanded(node) { + var nextState; + + if (this.localSearch.active) { + nextState = node.isExpandedOnSearch = !node.isExpandedOnSearch; + if (nextState) node.showAllChildrenOnSearch = true; + } else { + nextState = node.isExpanded = !node.isExpanded; + } + + if (nextState && !node.childrenStates.isLoaded) { + this.loadChildrenOptions(node); + } + }, + buildForestState: function buildForestState() { + var _this16 = this; + + var selectedNodeMap = createMap(); + this.forest.selectedNodeIds.forEach(function (selectedNodeId) { + selectedNodeMap[selectedNodeId] = true; + }); + this.forest.selectedNodeMap = selectedNodeMap; + var checkedStateMap = createMap(); + + if (this.multiple) { + this.traverseAllNodesByIndex(function (node) { + checkedStateMap[node.id] = UNCHECKED; + }); + this.selectedNodes.forEach(function (selectedNode) { + checkedStateMap[selectedNode.id] = CHECKED; + + if (!_this16.flat && !_this16.disableBranchNodes) { + selectedNode.ancestors.forEach(function (ancestorNode) { + if (!_this16.isSelected(ancestorNode)) { + checkedStateMap[ancestorNode.id] = INDETERMINATE; + } + }); + } + }); + } + + this.forest.checkedStateMap = checkedStateMap; + }, + enhancedNormalizer: function enhancedNormalizer(raw) { + return _objectSpread(_objectSpread({}, raw), this.normalizer(raw, this.getInstanceId())); + }, + normalize: function normalize(parentNode, nodes, prevNodeMap) { + var _this17 = this; + + var normalizedOptions = nodes.map(function (node) { + return [_this17.enhancedNormalizer(node), node]; + }).map(function (_ref, index) { + var _ref2 = slicedToArray_default()(_ref, 2), + node = _ref2[0], + raw = _ref2[1]; + + _this17.checkDuplication(node); + + _this17.verifyNodeShape(node); + + var id = node.id, + label = node.label, + children = node.children, + isDefaultExpanded = node.isDefaultExpanded; + var isRootNode = parentNode === NO_PARENT_NODE; + var level = isRootNode ? 0 : parentNode.level + 1; + var isBranch = Array.isArray(children) || children === null; + var isLeaf = !isBranch; + var isDisabled = !!node.isDisabled || !_this17.flat && !isRootNode && parentNode.isDisabled; + var isNew = !!node.isNew; + + var lowerCased = _this17.matchKeys.reduce(function (prev, key) { + return _objectSpread(_objectSpread({}, prev), {}, defineProperty_default()({}, key, stringifyOptionPropValue(node[key]).toLocaleLowerCase())); + }, {}); + + var nestedSearchLabel = isRootNode ? lowerCased.label : parentNode.nestedSearchLabel + ' ' + lowerCased.label; + + var normalized = _this17.$set(_this17.forest.nodeMap, id, createMap()); + + _this17.$set(normalized, 'id', id); + + _this17.$set(normalized, 'label', label); + + _this17.$set(normalized, 'level', level); + + _this17.$set(normalized, 'ancestors', isRootNode ? [] : [parentNode].concat(parentNode.ancestors)); + + _this17.$set(normalized, 'index', (isRootNode ? [] : parentNode.index).concat(index)); + + _this17.$set(normalized, 'parentNode', parentNode); + + _this17.$set(normalized, 'lowerCased', lowerCased); + + _this17.$set(normalized, 'nestedSearchLabel', nestedSearchLabel); + + _this17.$set(normalized, 'isDisabled', isDisabled); + + _this17.$set(normalized, 'isNew', isNew); + + _this17.$set(normalized, 'isMatched', false); + + _this17.$set(normalized, 'isHighlighted', false); + + _this17.$set(normalized, 'isBranch', isBranch); + + _this17.$set(normalized, 'isLeaf', isLeaf); + + _this17.$set(normalized, 'isRootNode', isRootNode); + + _this17.$set(normalized, 'raw', raw); + + if (isBranch) { + var _this17$$set; + + var isLoaded = Array.isArray(children); + + _this17.$set(normalized, 'childrenStates', _objectSpread(_objectSpread({}, createAsyncOptionsStates()), {}, { + isLoaded: isLoaded + })); + + _this17.$set(normalized, 'isExpanded', typeof isDefaultExpanded === 'boolean' ? isDefaultExpanded : level < _this17.defaultExpandLevel); + + _this17.$set(normalized, 'hasMatchedDescendants', false); + + _this17.$set(normalized, 'hasDisabledDescendants', false); + + _this17.$set(normalized, 'isExpandedOnSearch', false); + + _this17.$set(normalized, 'showAllChildrenOnSearch', false); + + _this17.$set(normalized, 'count', (_this17$$set = {}, defineProperty_default()(_this17$$set, ALL_CHILDREN, 0), defineProperty_default()(_this17$$set, ALL_DESCENDANTS, 0), defineProperty_default()(_this17$$set, LEAF_CHILDREN, 0), defineProperty_default()(_this17$$set, LEAF_DESCENDANTS, 0), _this17$$set)); + + _this17.$set(normalized, 'children', isLoaded ? _this17.normalize(normalized, children, prevNodeMap) : []); + + if (isDefaultExpanded === true) normalized.ancestors.forEach(function (ancestor) { + ancestor.isExpanded = true; + }); + + if (!isLoaded && typeof _this17.loadOptions !== 'function') { + warning_warning(function () { + return false; + }, function () { + return 'Unloaded branch node detected. "loadOptions" prop is required to load its children.'; + }); + } else if (!isLoaded && normalized.isExpanded) { + _this17.loadChildrenOptions(normalized); + } + } + + normalized.ancestors.forEach(function (ancestor) { + return ancestor.count[ALL_DESCENDANTS]++; + }); + if (isLeaf) normalized.ancestors.forEach(function (ancestor) { + return ancestor.count[LEAF_DESCENDANTS]++; + }); + + if (!isRootNode) { + parentNode.count[ALL_CHILDREN] += 1; + if (isLeaf) parentNode.count[LEAF_CHILDREN] += 1; + if (isDisabled) parentNode.hasDisabledDescendants = true; + } + + if (prevNodeMap && prevNodeMap[id]) { + var prev = prevNodeMap[id]; + normalized.isMatched = prev.isMatched; + normalized.showAllChildrenOnSearch = prev.showAllChildrenOnSearch; + normalized.isHighlighted = prev.isHighlighted; + + if (prev.isBranch && normalized.isBranch) { + normalized.isExpanded = prev.isExpanded; + normalized.isExpandedOnSearch = prev.isExpandedOnSearch; + + if (prev.childrenStates.isLoaded && !normalized.childrenStates.isLoaded) { + normalized.isExpanded = false; + } else { + normalized.childrenStates = _objectSpread({}, prev.childrenStates); + } + } + } + + return normalized; + }); + + if (this.branchNodesFirst) { + var branchNodes = normalizedOptions.filter(function (option) { + return option.isBranch; + }); + var leafNodes = normalizedOptions.filter(function (option) { + return option.isLeaf; + }); + normalizedOptions = branchNodes.concat(leafNodes); + } + + return normalizedOptions; + }, + loadRootOptions: function loadRootOptions() { + var _this18 = this; + + this.callLoadOptionsProp({ + action: LOAD_ROOT_OPTIONS, + isPending: function isPending() { + return _this18.rootOptionsStates.isLoading; + }, + start: function start() { + _this18.rootOptionsStates.isLoading = true; + _this18.rootOptionsStates.loadingError = ''; + }, + succeed: function succeed() { + _this18.rootOptionsStates.isLoaded = true; + + _this18.$nextTick(function () { + _this18.resetHighlightedOptionWhenNecessary(true); + }); + }, + fail: function fail(err) { + _this18.rootOptionsStates.loadingError = getErrorMessage(err); + }, + end: function end() { + _this18.rootOptionsStates.isLoading = false; + } + }); + }, + loadChildrenOptions: function loadChildrenOptions(parentNode) { + var _this19 = this; + + var id = parentNode.id, + raw = parentNode.raw; + this.callLoadOptionsProp({ + action: LOAD_CHILDREN_OPTIONS, + args: { + parentNode: raw + }, + isPending: function isPending() { + return _this19.getNode(id).childrenStates.isLoading; + }, + start: function start() { + _this19.getNode(id).childrenStates.isLoading = true; + _this19.getNode(id).childrenStates.loadingError = ''; + }, + succeed: function succeed() { + _this19.getNode(id).childrenStates.isLoaded = true; + }, + fail: function fail(err) { + _this19.getNode(id).childrenStates.loadingError = getErrorMessage(err); + }, + end: function end() { + _this19.getNode(id).childrenStates.isLoading = false; + } + }); + }, + callLoadOptionsProp: function callLoadOptionsProp(_ref3) { + var action = _ref3.action, + args = _ref3.args, + isPending = _ref3.isPending, + start = _ref3.start, + succeed = _ref3.succeed, + fail = _ref3.fail, + end = _ref3.end; + + if (!this.loadOptions || isPending()) { + return; + } + + start(); + var callback = once_default()(function (err, result) { + if (err) { + fail(err); + } else { + succeed(result); + } + + end(); + }); + var result = this.loadOptions(_objectSpread(_objectSpread({ + id: this.getInstanceId(), + instanceId: this.getInstanceId(), + action: action + }, args), {}, { + callback: callback + })); + + if (is_promise_default()(result)) { + result.then(function () { + callback(); + }, function (err) { + callback(err); + }).catch(function (err) { + console.error(err); + }); + } + }, + checkDuplication: function checkDuplication(node) { + var _this20 = this; + + warning_warning(function () { + return !(node.id in _this20.forest.nodeMap && !_this20.forest.nodeMap[node.id].isFallbackNode); + }, function () { + return "Detected duplicate presence of node id ".concat(JSON.stringify(node.id), ". ") + "Their labels are \"".concat(_this20.forest.nodeMap[node.id].label, "\" and \"").concat(node.label, "\" respectively."); + }); + }, + verifyNodeShape: function verifyNodeShape(node) { + warning_warning(function () { + return !(node.children === undefined && node.isBranch === true); + }, function () { + return 'Are you meant to declare an unloaded branch node? ' + '`isBranch: true` is no longer supported, please use `children: null` instead.'; + }); + }, + select: function select(node) { + if (this.disabled || node.isDisabled) { + return; + } + + if (this.single) { + this.clear(); + } + + var nextState = this.multiple && !this.flat ? this.forest.checkedStateMap[node.id] === UNCHECKED : !this.isSelected(node); + + if (nextState) { + this._selectNode(node); + } else { + this._deselectNode(node); + } + + this.buildForestState(); + + if (nextState) { + this.$emit('select', node.raw, this.getInstanceId()); + } else { + this.$emit('deselect', node.raw, this.getInstanceId()); + } + + if (this.localSearch.active && nextState && (this.single || this.clearOnSelect)) { + this.resetSearchQuery(); + } + + if (this.single && this.closeOnSelect) { + this.closeMenu(); + + if (this.searchable) { + this._blurOnSelect = true; + } + } + }, + clear: function clear() { + var _this21 = this; + + if (this.hasValue) { + if (this.single || this.allowClearingDisabled) { + this.forest.selectedNodeIds = []; + } else { + this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(function (nodeId) { + return _this21.getNode(nodeId).isDisabled; + }); + } + + this.buildForestState(); + } + }, + _selectNode: function _selectNode(node) { + var _this22 = this; + + node.hasBeenSelected = node.id; + + if (this.single || this.disableBranchNodes) { + return this.addValue(node); + } + + if (this.flat) { + this.addValue(node); + + if (this.autoSelectAncestors) { + node.ancestors.forEach(function (ancestor) { + if (!_this22.isSelected(ancestor) && !ancestor.isDisabled) _this22.addValue(ancestor); + }); + } else if (this.autoSelectDescendants) { + this.traverseDescendantsBFS(node, function (descendant) { + if (!_this22.isSelected(descendant) && !descendant.isDisabled) _this22.addValue(descendant); + }); + } + + return; + } + + var isFullyChecked = node.isLeaf || !node.hasDisabledDescendants || this.allowSelectingDisabledDescendants; + + if (isFullyChecked) { + this.addValue(node); + } + + if (node.isBranch) { + this.traverseDescendantsBFS(node, function (descendant) { + if (!descendant.isDisabled || _this22.allowSelectingDisabledDescendants) { + _this22.addValue(descendant); + } + }); + } + + if (isFullyChecked) { + var curr = node; + + while ((curr = curr.parentNode) !== NO_PARENT_NODE) { + if (curr.children.every(this.isSelected)) this.addValue(curr);else break; + } + } + }, + _deselectNode: function _deselectNode(node) { + var _this23 = this; + + if (this.disableBranchNodes) { + return this.removeValue(node); + } + + if (this.flat) { + this.removeValue(node); + + if (this.autoDeselectAncestors) { + node.ancestors.forEach(function (ancestor) { + if (_this23.isSelected(ancestor) && !ancestor.isDisabled) _this23.removeValue(ancestor); + }); + } else if (this.autoDeselectDescendants) { + this.traverseDescendantsBFS(node, function (descendant) { + if (_this23.isSelected(descendant) && !descendant.isDisabled) _this23.removeValue(descendant); + }); + } + + return; + } + + var hasUncheckedSomeDescendants = false; + + if (node.isBranch) { + this.traverseDescendantsDFS(node, function (descendant) { + if (!descendant.isDisabled || _this23.allowSelectingDisabledDescendants) { + _this23.removeValue(descendant); + + hasUncheckedSomeDescendants = true; + } + }); + } + + if (node.isLeaf || hasUncheckedSomeDescendants || node.children.length === 0) { + this.removeValue(node); + var curr = node; + + while ((curr = curr.parentNode) !== NO_PARENT_NODE) { + if (this.isSelected(curr)) this.removeValue(curr);else break; + } + } + }, + addValue: function addValue(node) { + this.forest.selectedNodeIds.push(node.id); + this.forest.selectedNodeMap[node.id] = true; + }, + removeValue: function removeValue(node) { + delete node.hasBeenSelected; + removeFromArray(this.forest.selectedNodeIds, node.id); + delete this.forest.selectedNodeMap[node.id]; + }, + removeLastValue: function removeLastValue() { + if (!this.hasValue) return; + if (this.single) return this.clear(); + var lastValue = last_default()(this.internalValue); + var lastSelectedNode = this.getNode(lastValue); + this.select(lastSelectedNode); + }, + saveMenuScrollPosition: function saveMenuScrollPosition() { + var $menu = this.getMenu(); + if ($menu) this.menu.lastScrollPosition = $menu.scrollTop; + }, + restoreMenuScrollPosition: function restoreMenuScrollPosition() { + var $menu = this.getMenu(); + if ($menu) $menu.scrollTop = this.menu.lastScrollPosition; + } + }, + created: function created() { + this.verifyProps(); + this.resetFlags(); + }, + mounted: function mounted() { + if (this.autoFocus) this.focusInput(); + if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions(); + if (this.alwaysOpen) this.openMenu(); + if (this.async && this.defaultOptions) this.handleRemoteSearch(); + }, + destroyed: function destroyed() { + this.toggleClickOutsideEvent(false); + } +}); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/HiddenFields.vue?vue&type=script&lang=js& + + +function stringifyValue(value) { + if (typeof value === 'string') return value; + if (value != null && !isNaN_isNaN(value)) return JSON.stringify(value); + return ''; +} + +/* harmony default export */ var HiddenFieldsvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--hidden-fields', + inject: ['instance'], + functional: true, + render: function render(_, context) { + var h = arguments[0]; + var instance = context.injections.instance; + if (!instance.name || instance.disabled || !instance.hasValue) return null; + var stringifiedValues = instance.internalValue.map(stringifyValue); + if (instance.multiple && instance.joinValues) stringifiedValues = [stringifiedValues.join(instance.delimiter)]; + return stringifiedValues.map(function (stringifiedValue, i) { + return h("input", { + attrs: { + type: "hidden", + name: instance.name + }, + domProps: { + "value": stringifiedValue + }, + key: 'hidden-field-' + i + }); + }); + } +}); +// CONCATENATED MODULE: ./src/components/HiddenFields.vue?vue&type=script&lang=js& + /* harmony default export */ var components_HiddenFieldsvue_type_script_lang_js_ = (HiddenFieldsvue_type_script_lang_js_); +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js +/* globals __VUE_SSR_CONTEXT__ */ + +// IMPORTANT: Do NOT use ES2015 features in this file (except for modules). +// This module is a runtime utility for cleaner component module output and will +// be included in the final webpack user bundle. + +function normalizeComponent ( + scriptExports, + render, + staticRenderFns, + functionalTemplate, + injectStyles, + scopeId, + moduleIdentifier, /* server only */ + shadowMode /* vue-cli only */ +) { + // Vue.extend constructor export interop + var options = typeof scriptExports === 'function' + ? scriptExports.options + : scriptExports + + // render functions + if (render) { + options.render = render + options.staticRenderFns = staticRenderFns + options._compiled = true + } + + // functional template + if (functionalTemplate) { + options.functional = true + } + + // scopedId + if (scopeId) { + options._scopeId = 'data-v-' + scopeId + } + + var hook + if (moduleIdentifier) { // server build + hook = function (context) { + // 2.3 injection + context = + context || // cached call + (this.$vnode && this.$vnode.ssrContext) || // stateful + (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional + // 2.2 with runInNewContext: true + if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') { + context = __VUE_SSR_CONTEXT__ + } + // inject component styles + if (injectStyles) { + injectStyles.call(this, context) + } + // register component module identifier for async chunk inferrence + if (context && context._registeredComponents) { + context._registeredComponents.add(moduleIdentifier) + } + } + // used by ssr in case component is cached and beforeCreate + // never gets called + options._ssrRegister = hook + } else if (injectStyles) { + hook = shadowMode + ? function () { + injectStyles.call( + this, + (options.functional ? this.parent : this).$root.$options.shadowRoot + ) + } + : injectStyles + } + + if (hook) { + if (options.functional) { + // for template-only hot-reload because in that case the render fn doesn't + // go through the normalizer + options._injectStyles = hook + // register for functional component in vue file + var originalRender = options.render + options.render = function renderWithStyleInjection (h, context) { + hook.call(context) + return originalRender(h, context) + } + } else { + // inject component registration as beforeCreate hook + var existing = options.beforeCreate + options.beforeCreate = existing + ? [].concat(existing, hook) + : [hook] + } + } + + return { + exports: scriptExports, + options: options + } +} + +// CONCATENATED MODULE: ./src/components/HiddenFields.vue +var HiddenFields_render, staticRenderFns + + + + +/* normalize component */ + +var component = normalizeComponent( + components_HiddenFieldsvue_type_script_lang_js_, + HiddenFields_render, + staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var api; } +component.options.__file = "src/components/HiddenFields.vue" +/* harmony default export */ var HiddenFields = (component.exports); +// EXTERNAL MODULE: ./node_modules/babel-helper-vue-jsx-merge-props/index.js +var babel_helper_vue_jsx_merge_props = __webpack_require__(37); +var babel_helper_vue_jsx_merge_props_default = /*#__PURE__*/__webpack_require__.n(babel_helper_vue_jsx_merge_props); + +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Input.vue?vue&type=script&lang=js& + + + +var keysThatRequireMenuBeingOpen = [KEY_CODES.ENTER, KEY_CODES.END, KEY_CODES.HOME, KEY_CODES.ARROW_LEFT, KEY_CODES.ARROW_UP, KEY_CODES.ARROW_RIGHT, KEY_CODES.ARROW_DOWN]; +/* harmony default export */ var Inputvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--input', + inject: ['instance'], + data: function data() { + return { + inputWidth: MIN_INPUT_WIDTH, + value: '' + }; + }, + computed: { + needAutoSize: function needAutoSize() { + var instance = this.instance; + return instance.searchable && !instance.disabled && instance.multiple; + }, + inputStyle: function inputStyle() { + return { + width: this.needAutoSize ? "".concat(this.inputWidth, "px") : null + }; + } + }, + watch: { + 'instance.trigger.searchQuery': function instanceTriggerSearchQuery(newValue) { + this.value = newValue; + }, + value: function value() { + if (this.needAutoSize) this.$nextTick(this.updateInputWidth); + } + }, + created: function created() { + this.debouncedCallback = debounce_default()(this.updateSearchQuery, INPUT_DEBOUNCE_DELAY, { + leading: true, + trailing: true + }); + }, + methods: { + clear: function clear() { + this.onInput({ + target: { + value: '' + } + }); + }, + focus: function focus() { + var instance = this.instance; + + if (!instance.disabled) { + this.$refs.input && this.$refs.input.focus(); + } + }, + blur: function blur() { + this.$refs.input && this.$refs.input.blur(); + }, + onFocus: function onFocus() { + var instance = this.instance; + instance.trigger.isFocused = true; + if (instance.openOnFocus) instance.openMenu(); + }, + onBlur: function onBlur() { + var instance = this.instance; + var menu = instance.getMenu(); + + if (menu && document.activeElement === menu) { + return this.focus(); + } + + instance.trigger.isFocused = false; + instance.closeMenu(); + }, + onInput: function onInput(evt) { + var value = evt.target.value; + this.value = value; + + if (value) { + this.debouncedCallback(); + } else { + this.debouncedCallback.cancel(); + this.updateSearchQuery(); + } + }, + onKeyDown: function onKeyDown(evt) { + var instance = this.instance; + var key = 'which' in evt ? evt.which : evt.keyCode; + if (evt.ctrlKey || evt.shiftKey || evt.altKey || evt.metaKey) return; + + if (!instance.menu.isOpen && includes(keysThatRequireMenuBeingOpen, key)) { + evt.preventDefault(); + return instance.openMenu(); + } + + switch (key) { + case KEY_CODES.BACKSPACE: + { + if (instance.backspaceRemoves && !this.value.length) { + instance.removeLastValue(); + } + + break; + } + + case KEY_CODES.ENTER: + { + evt.preventDefault(); + if (instance.menu.current === null) return; + var current = instance.getNode(instance.menu.current); + if (current.isBranch && instance.disableBranchNodes) return; + instance.select(current); + break; + } + + case KEY_CODES.ESCAPE: + { + if (this.value.length) { + this.clear(); + } else if (instance.menu.isOpen) { + instance.closeMenu(); + } + + break; + } + + case KEY_CODES.END: + { + evt.preventDefault(); + instance.highlightLastOption(); + break; + } + + case KEY_CODES.HOME: + { + evt.preventDefault(); + instance.highlightFirstOption(); + break; + } + + case KEY_CODES.ARROW_LEFT: + { + var _current = instance.getNode(instance.menu.current); + + if (_current.isBranch && instance.shouldExpand(_current)) { + evt.preventDefault(); + instance.toggleExpanded(_current); + } else if (!_current.isRootNode && (_current.isLeaf || _current.isBranch && !instance.shouldExpand(_current))) { + evt.preventDefault(); + instance.setCurrentHighlightedOption(_current.parentNode); + } + + break; + } + + case KEY_CODES.ARROW_UP: + { + evt.preventDefault(); + instance.highlightPrevOption(); + break; + } + + case KEY_CODES.ARROW_RIGHT: + { + var _current2 = instance.getNode(instance.menu.current); + + if (_current2.isBranch && !instance.shouldExpand(_current2)) { + evt.preventDefault(); + instance.toggleExpanded(_current2); + } + + break; + } + + case KEY_CODES.ARROW_DOWN: + { + evt.preventDefault(); + instance.highlightNextOption(); + break; + } + + case KEY_CODES.DELETE: + { + if (instance.deleteRemoves && !this.value.length) { + instance.removeLastValue(); + } + + break; + } + + default: + { + instance.openMenu(); + } + } + }, + onMouseDown: function onMouseDown(evt) { + if (this.value.length) { + evt.stopPropagation(); + } + }, + renderInputContainer: function renderInputContainer() { + var h = this.$createElement; + var instance = this.instance; + var props = {}; + var children = []; + + if (instance.searchable && !instance.disabled) { + children.push(this.renderInput()); + if (this.needAutoSize) children.push(this.renderSizer()); + } + + if (!instance.searchable) { + deepExtend(props, { + on: { + focus: this.onFocus, + blur: this.onBlur, + keydown: this.onKeyDown + }, + ref: 'input' + }); + } + + if (!instance.searchable && !instance.disabled) { + deepExtend(props, { + attrs: { + tabIndex: instance.tabIndex + } + }); + } + + return h("div", babel_helper_vue_jsx_merge_props_default()([{ + "class": "vue-treeselect__input-container" + }, props]), [children]); + }, + renderInput: function renderInput() { + var h = this.$createElement; + var instance = this.instance; + return h("input", { + ref: "input", + "class": "vue-treeselect__input", + attrs: { + type: "text", + autocomplete: "off", + tabIndex: instance.tabIndex, + required: instance.required && !instance.hasValue + }, + domProps: { + "value": this.value + }, + style: this.inputStyle, + on: { + "focus": this.onFocus, + "input": this.onInput, + "blur": this.onBlur, + "keydown": this.onKeyDown, + "mousedown": this.onMouseDown + } + }); + }, + renderSizer: function renderSizer() { + var h = this.$createElement; + return h("div", { + ref: "sizer", + "class": "vue-treeselect__sizer" + }, [this.value]); + }, + updateInputWidth: function updateInputWidth() { + this.inputWidth = Math.max(MIN_INPUT_WIDTH, this.$refs.sizer.scrollWidth + 15); + }, + updateSearchQuery: function updateSearchQuery() { + var instance = this.instance; + instance.trigger.searchQuery = this.value; + } + }, + render: function render() { + return this.renderInputContainer(); + } +}); +// CONCATENATED MODULE: ./src/components/Input.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Inputvue_type_script_lang_js_ = (Inputvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Input.vue +var Input_render, Input_staticRenderFns + + + + +/* normalize component */ + +var Input_component = normalizeComponent( + components_Inputvue_type_script_lang_js_, + Input_render, + Input_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Input_api; } +Input_component.options.__file = "src/components/Input.vue" +/* harmony default export */ var Input = (Input_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Placeholder.vue?vue&type=script&lang=js& +/* harmony default export */ var Placeholdervue_type_script_lang_js_ = ({ + name: 'vue-treeselect--placeholder', + inject: ['instance'], + render: function render() { + var h = arguments[0]; + var instance = this.instance; + var placeholderClass = { + 'vue-treeselect__placeholder': true, + 'vue-treeselect-helper-zoom-effect-off': true, + 'vue-treeselect-helper-hide': instance.hasValue || instance.trigger.searchQuery + }; + return h("div", { + "class": placeholderClass + }, [instance.placeholder]); + } +}); +// CONCATENATED MODULE: ./src/components/Placeholder.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Placeholdervue_type_script_lang_js_ = (Placeholdervue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Placeholder.vue +var Placeholder_render, Placeholder_staticRenderFns + + + + +/* normalize component */ + +var Placeholder_component = normalizeComponent( + components_Placeholdervue_type_script_lang_js_, + Placeholder_render, + Placeholder_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Placeholder_api; } +Placeholder_component.options.__file = "src/components/Placeholder.vue" +/* harmony default export */ var Placeholder = (Placeholder_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/SingleValue.vue?vue&type=script&lang=js& + + +/* harmony default export */ var SingleValuevue_type_script_lang_js_ = ({ + name: 'vue-treeselect--single-value', + inject: ['instance'], + methods: { + renderSingleValueLabel: function renderSingleValueLabel() { + var instance = this.instance; + var node = instance.selectedNodes[0]; + var customValueLabelRenderer = instance.$scopedSlots['value-label']; + return customValueLabelRenderer ? customValueLabelRenderer({ + node: node + }) : node.label; + } + }, + render: function render() { + var h = arguments[0]; + var instance = this.instance, + renderValueContainer = this.$parent.renderValueContainer; + var shouldShowValue = instance.hasValue && !instance.trigger.searchQuery; + return renderValueContainer([shouldShowValue && h("div", { + "class": "vue-treeselect__single-value" + }, [this.renderSingleValueLabel()]), h(Placeholder), h(Input, { + ref: "input" + })]); + } +}); +// CONCATENATED MODULE: ./src/components/SingleValue.vue?vue&type=script&lang=js& + /* harmony default export */ var components_SingleValuevue_type_script_lang_js_ = (SingleValuevue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/SingleValue.vue +var SingleValue_render, SingleValue_staticRenderFns + + + + +/* normalize component */ + +var SingleValue_component = normalizeComponent( + components_SingleValuevue_type_script_lang_js_, + SingleValue_render, + SingleValue_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var SingleValue_api; } +SingleValue_component.options.__file = "src/components/SingleValue.vue" +/* harmony default export */ var SingleValue = (SingleValue_component.exports); +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/cache-loader/dist/cjs.js!./node_modules/vue-loader/lib??vue-loader-options!./src/components/icons/Delete.vue?vue&type=template&id=364b6320& +var Deletevue_type_template_id_364b6320_render = function () { + var _vm = this + var _h = _vm.$createElement + var _c = _vm._self._c || _h + return _c( + "svg", + { + attrs: { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 348.333 348.333", + }, + }, + [ + _c("path", { + attrs: { + d: "M336.559 68.611L231.016 174.165l105.543 105.549c15.699 15.705 15.699 41.145 0 56.85-7.844 7.844-18.128 11.769-28.407 11.769-10.296 0-20.581-3.919-28.419-11.769L174.167 231.003 68.609 336.563c-7.843 7.844-18.128 11.769-28.416 11.769-10.285 0-20.563-3.919-28.413-11.769-15.699-15.698-15.699-41.139 0-56.85l105.54-105.549L11.774 68.611c-15.699-15.699-15.699-41.145 0-56.844 15.696-15.687 41.127-15.687 56.829 0l105.563 105.554L279.721 11.767c15.705-15.687 41.139-15.687 56.832 0 15.705 15.699 15.705 41.145.006 56.844z", + }, + }), + ] + ) +} +var Deletevue_type_template_id_364b6320_staticRenderFns = [] +Deletevue_type_template_id_364b6320_render._withStripped = true + + +// CONCATENATED MODULE: ./src/components/icons/Delete.vue?vue&type=template&id=364b6320& + +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/icons/Delete.vue?vue&type=script&lang=js& +/* harmony default export */ var Deletevue_type_script_lang_js_ = ({ + name: 'vue-treeselect--x' +}); +// CONCATENATED MODULE: ./src/components/icons/Delete.vue?vue&type=script&lang=js& + /* harmony default export */ var icons_Deletevue_type_script_lang_js_ = (Deletevue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/icons/Delete.vue + + + + + +/* normalize component */ + +var Delete_component = normalizeComponent( + icons_Deletevue_type_script_lang_js_, + Deletevue_type_template_id_364b6320_render, + Deletevue_type_template_id_364b6320_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Delete_api; } +Delete_component.options.__file = "src/components/icons/Delete.vue" +/* harmony default export */ var Delete = (Delete_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/MultiValueItem.vue?vue&type=script&lang=js& + + +/* harmony default export */ var MultiValueItemvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--multi-value-item', + inject: ['instance'], + props: { + node: { + type: Object, + required: true + } + }, + methods: { + handleMouseDown: onLeftClick(function handleMouseDown() { + var instance = this.instance, + node = this.node; + instance.select(node); + }) + }, + render: function render() { + var h = arguments[0]; + var instance = this.instance, + node = this.node; + var itemClass = { + 'vue-treeselect__multi-value-item': true, + 'vue-treeselect__multi-value-item-disabled': node.isDisabled, + 'vue-treeselect__multi-value-item-new': node.isNew + }; + var customValueLabelRenderer = instance.$scopedSlots['value-label']; + var labelRenderer = customValueLabelRenderer ? customValueLabelRenderer({ + node: node + }) : node.label; + return h("div", { + "class": "vue-treeselect__multi-value-item-container" + }, [h("div", { + "class": itemClass, + on: { + "mousedown": this.handleMouseDown + } + }, [h("span", { + "class": "vue-treeselect__multi-value-label" + }, [labelRenderer]), h("span", { + "class": "vue-treeselect__icon vue-treeselect__value-remove" + }, [h(Delete)])])]); + } +}); +// CONCATENATED MODULE: ./src/components/MultiValueItem.vue?vue&type=script&lang=js& + /* harmony default export */ var components_MultiValueItemvue_type_script_lang_js_ = (MultiValueItemvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/MultiValueItem.vue +var MultiValueItem_render, MultiValueItem_staticRenderFns + + + + +/* normalize component */ + +var MultiValueItem_component = normalizeComponent( + components_MultiValueItemvue_type_script_lang_js_, + MultiValueItem_render, + MultiValueItem_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var MultiValueItem_api; } +MultiValueItem_component.options.__file = "src/components/MultiValueItem.vue" +/* harmony default export */ var MultiValueItem = (MultiValueItem_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/MultiValue.vue?vue&type=script&lang=js& + + + + +/* harmony default export */ var MultiValuevue_type_script_lang_js_ = ({ + name: 'vue-treeselect--multi-value', + inject: ['instance'], + methods: { + renderMultiValueItems: function renderMultiValueItems() { + var h = this.$createElement; + var instance = this.instance; + return instance.internalValue.slice(0, instance.limit).map(instance.getNode).map(function (node) { + return h(MultiValueItem, { + key: "multi-value-item-".concat(node.id), + attrs: { + node: node + } + }); + }); + }, + renderExceedLimitTip: function renderExceedLimitTip() { + var h = this.$createElement; + var instance = this.instance; + var count = instance.internalValue.length - instance.limit; + if (count <= 0) return null; + return h("div", { + "class": "vue-treeselect__limit-tip vue-treeselect-helper-zoom-effect-off", + key: "exceed-limit-tip" + }, [h("span", { + "class": "vue-treeselect__limit-tip-text" + }, [instance.limitText(count)])]); + } + }, + render: function render() { + var h = arguments[0]; + var renderValueContainer = this.$parent.renderValueContainer; + var transitionGroupProps = { + props: { + tag: 'div', + name: 'vue-treeselect__multi-value-item--transition', + appear: true + } + }; + return renderValueContainer(h("transition-group", babel_helper_vue_jsx_merge_props_default()([{ + "class": "vue-treeselect__multi-value" + }, transitionGroupProps]), [this.renderMultiValueItems(), this.renderExceedLimitTip(), h(Placeholder, { + key: "placeholder" + }), h(Input, { + ref: "input", + key: "input" + })])); + } +}); +// CONCATENATED MODULE: ./src/components/MultiValue.vue?vue&type=script&lang=js& + /* harmony default export */ var components_MultiValuevue_type_script_lang_js_ = (MultiValuevue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/MultiValue.vue +var MultiValue_render, MultiValue_staticRenderFns + + + + +/* normalize component */ + +var MultiValue_component = normalizeComponent( + components_MultiValuevue_type_script_lang_js_, + MultiValue_render, + MultiValue_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var MultiValue_api; } +MultiValue_component.options.__file = "src/components/MultiValue.vue" +/* harmony default export */ var MultiValue = (MultiValue_component.exports); +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/cache-loader/dist/cjs.js!./node_modules/vue-loader/lib??vue-loader-options!./src/components/icons/Arrow.vue?vue&type=template&id=11186cd4& +var Arrowvue_type_template_id_11186cd4_render = function () { + var _vm = this + var _h = _vm.$createElement + var _c = _vm._self._c || _h + return _c( + "svg", + { + attrs: { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 292.362 292.362", + }, + }, + [ + _c("path", { + attrs: { + d: "M286.935 69.377c-3.614-3.617-7.898-5.424-12.848-5.424H18.274c-4.952 0-9.233 1.807-12.85 5.424C1.807 72.998 0 77.279 0 82.228c0 4.948 1.807 9.229 5.424 12.847l127.907 127.907c3.621 3.617 7.902 5.428 12.85 5.428s9.233-1.811 12.847-5.428L286.935 95.074c3.613-3.617 5.427-7.898 5.427-12.847 0-4.948-1.814-9.229-5.427-12.85z", + }, + }), + ] + ) +} +var Arrowvue_type_template_id_11186cd4_staticRenderFns = [] +Arrowvue_type_template_id_11186cd4_render._withStripped = true + + +// CONCATENATED MODULE: ./src/components/icons/Arrow.vue?vue&type=template&id=11186cd4& + +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/icons/Arrow.vue?vue&type=script&lang=js& +/* harmony default export */ var Arrowvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--arrow' +}); +// CONCATENATED MODULE: ./src/components/icons/Arrow.vue?vue&type=script&lang=js& + /* harmony default export */ var icons_Arrowvue_type_script_lang_js_ = (Arrowvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/icons/Arrow.vue + + + + + +/* normalize component */ + +var Arrow_component = normalizeComponent( + icons_Arrowvue_type_script_lang_js_, + Arrowvue_type_template_id_11186cd4_render, + Arrowvue_type_template_id_11186cd4_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Arrow_api; } +Arrow_component.options.__file = "src/components/icons/Arrow.vue" +/* harmony default export */ var Arrow = (Arrow_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Control.vue?vue&type=script&lang=js& + + + + + +/* harmony default export */ var Controlvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--control', + inject: ['instance'], + computed: { + shouldShowX: function shouldShowX() { + var instance = this.instance; + return instance.clearable && !instance.disabled && instance.hasValue && (this.hasUndisabledValue || instance.allowClearingDisabled); + }, + shouldShowArrow: function shouldShowArrow() { + var instance = this.instance; + if (!instance.alwaysOpen) return true; + return !instance.menu.isOpen; + }, + hasUndisabledValue: function hasUndisabledValue() { + var instance = this.instance; + return instance.hasValue && instance.internalValue.some(function (id) { + return !instance.getNode(id).isDisabled; + }); + } + }, + methods: { + renderX: function renderX() { + var h = this.$createElement; + var instance = this.instance; + var title = instance.multiple ? instance.clearAllText : instance.clearValueText; + if (!this.shouldShowX) return null; + return h("div", { + "class": "vue-treeselect__x-container", + attrs: { + title: title + }, + on: { + "mousedown": this.handleMouseDownOnX + } + }, [h(Delete, { + "class": "vue-treeselect__x" + })]); + }, + renderArrow: function renderArrow() { + var h = this.$createElement; + var instance = this.instance; + var arrowClass = { + 'vue-treeselect__control-arrow': true, + 'vue-treeselect__control-arrow--rotated': instance.menu.isOpen + }; + if (!this.shouldShowArrow) return null; + return h("div", { + "class": "vue-treeselect__control-arrow-container", + on: { + "mousedown": this.handleMouseDownOnArrow + } + }, [h(Arrow, { + "class": arrowClass + })]); + }, + handleMouseDownOnX: onLeftClick(function handleMouseDownOnX(evt) { + evt.stopPropagation(); + evt.preventDefault(); + var instance = this.instance; + var result = instance.beforeClearAll(); + + var handler = function handler(shouldClear) { + if (shouldClear) instance.clear(); + }; + + if (is_promise_default()(result)) { + result.then(handler); + } else { + setTimeout(function () { + return handler(result); + }, 0); + } + }), + handleMouseDownOnArrow: onLeftClick(function handleMouseDownOnArrow(evt) { + evt.preventDefault(); + evt.stopPropagation(); + var instance = this.instance; + instance.focusInput(); + instance.toggleMenu(); + }), + renderValueContainer: function renderValueContainer(children) { + var h = this.$createElement; + return h("div", { + "class": "vue-treeselect__value-container" + }, [children]); + } + }, + render: function render() { + var h = arguments[0]; + var instance = this.instance; + var ValueContainer = instance.single ? SingleValue : MultiValue; + return h("div", { + "class": "vue-treeselect__control", + on: { + "mousedown": instance.handleMouseDown + } + }, [h(ValueContainer, { + ref: "value-container" + }), this.renderX(), this.renderArrow()]); + } +}); +// CONCATENATED MODULE: ./src/components/Control.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Controlvue_type_script_lang_js_ = (Controlvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Control.vue +var Control_render, Control_staticRenderFns + + + + +/* normalize component */ + +var Control_component = normalizeComponent( + components_Controlvue_type_script_lang_js_, + Control_render, + Control_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Control_api; } +Control_component.options.__file = "src/components/Control.vue" +/* harmony default export */ var Control = (Control_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Tip.vue?vue&type=script&lang=js& +/* harmony default export */ var Tipvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--tip', + functional: true, + props: { + type: { + type: String, + required: true + }, + icon: { + type: String, + required: true + } + }, + render: function render(_, context) { + var h = arguments[0]; + var props = context.props, + children = context.children; + return h("div", { + "class": "vue-treeselect__tip vue-treeselect__".concat(props.type, "-tip") + }, [h("div", { + "class": "vue-treeselect__icon-container" + }, [h("span", { + "class": "vue-treeselect__icon-".concat(props.icon) + })]), h("span", { + "class": "vue-treeselect__tip-text vue-treeselect__".concat(props.type, "-tip-text") + }, [children])]); + } +}); +// CONCATENATED MODULE: ./src/components/Tip.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Tipvue_type_script_lang_js_ = (Tipvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Tip.vue +var Tip_render, Tip_staticRenderFns + + + + +/* normalize component */ + +var Tip_component = normalizeComponent( + components_Tipvue_type_script_lang_js_, + Tip_render, + Tip_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Tip_api; } +Tip_component.options.__file = "src/components/Tip.vue" +/* harmony default export */ var Tip = (Tip_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Option.vue?vue&type=script&lang=js& + + + + + +var arrowPlaceholder, checkMark, minusMark; +var Option = { + name: 'vue-treeselect--option', + inject: ['instance'], + props: { + node: { + type: Object, + required: true + } + }, + computed: { + shouldExpand: function shouldExpand() { + var instance = this.instance, + node = this.node; + return node.isBranch && instance.shouldExpand(node); + }, + shouldShow: function shouldShow() { + var instance = this.instance, + node = this.node; + return instance.shouldShowOptionInMenu(node); + } + }, + methods: { + renderOption: function renderOption() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + var optionClass = { + 'vue-treeselect__option': true, + 'vue-treeselect__option--disabled': node.isDisabled, + 'vue-treeselect__option--selected': instance.isSelected(node), + 'vue-treeselect__option--highlight': node.isHighlighted, + 'vue-treeselect__option--matched': instance.localSearch.active && node.isMatched, + 'vue-treeselect__option--hide': !this.shouldShow + }; + return h("div", { + "class": optionClass, + on: { + "mouseenter": this.handleMouseEnterOption + }, + attrs: { + "data-id": node.id + } + }, [this.renderArrow(), this.renderLabelContainer([this.renderCheckboxContainer([this.renderCheckbox()]), this.renderLabel()])]); + }, + renderSubOptionsList: function renderSubOptionsList() { + var h = this.$createElement; + if (!this.shouldExpand) return null; + return h("div", { + "class": "vue-treeselect__list" + }, [this.renderSubOptions(), this.renderNoChildrenTip(), this.renderLoadingChildrenTip(), this.renderLoadingChildrenErrorTip()]); + }, + renderArrow: function renderArrow() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (instance.shouldFlattenOptions && this.shouldShow) return null; + + if (node.isBranch) { + var transitionProps = { + props: { + name: 'vue-treeselect__option-arrow--prepare', + appear: true + } + }; + var arrowClass = { + 'vue-treeselect__option-arrow': true, + 'vue-treeselect__option-arrow--rotated': this.shouldExpand + }; + return h("div", { + "class": "vue-treeselect__option-arrow-container", + on: { + "mousedown": this.handleMouseDownOnArrow + } + }, [h("transition", transitionProps, [h(Arrow, { + "class": arrowClass + })])]); + } + + if (instance.hasBranchNodes) { + if (!arrowPlaceholder) arrowPlaceholder = h("div", { + "class": "vue-treeselect__option-arrow-placeholder" + }, ["\xA0"]); + return arrowPlaceholder; + } + + return null; + }, + renderLabelContainer: function renderLabelContainer(children) { + var h = this.$createElement; + return h("div", { + "class": "vue-treeselect__label-container", + on: { + "mousedown": this.handleMouseDownOnLabelContainer + } + }, [children]); + }, + renderCheckboxContainer: function renderCheckboxContainer(children) { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (instance.single) return null; + if (instance.disableBranchNodes && node.isBranch) return null; + return h("div", { + "class": "vue-treeselect__checkbox-container" + }, [children]); + }, + renderCheckbox: function renderCheckbox() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + var checkedState = instance.forest.checkedStateMap[node.id]; + var checkboxClass = { + 'vue-treeselect__checkbox': true, + 'vue-treeselect__checkbox--checked': checkedState === CHECKED, + 'vue-treeselect__checkbox--indeterminate': checkedState === INDETERMINATE, + 'vue-treeselect__checkbox--unchecked': checkedState === UNCHECKED, + 'vue-treeselect__checkbox--disabled': node.isDisabled + }; + if (!checkMark) checkMark = h("span", { + "class": "vue-treeselect__check-mark" + }); + if (!minusMark) minusMark = h("span", { + "class": "vue-treeselect__minus-mark" + }); + return h("span", { + "class": checkboxClass + }, [checkMark, minusMark]); + }, + renderLabel: function renderLabel() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + var shouldShowCount = node.isBranch && (instance.localSearch.active ? instance.showCountOnSearchComputed : instance.showCount); + var count = shouldShowCount ? instance.localSearch.active ? instance.localSearch.countMap[node.id][instance.showCountOf] : node.count[instance.showCountOf] : NaN; + var labelClassName = 'vue-treeselect__label'; + var countClassName = 'vue-treeselect__count'; + var customLabelRenderer = instance.$scopedSlots['option-label']; + if (customLabelRenderer) return customLabelRenderer({ + node: node, + shouldShowCount: shouldShowCount, + count: count, + labelClassName: labelClassName, + countClassName: countClassName + }); + return h("label", { + "class": labelClassName + }, [node.label, shouldShowCount && h("span", { + "class": countClassName + }, ["(", count, ")"])]); + }, + renderSubOptions: function renderSubOptions() { + var h = this.$createElement; + var node = this.node; + if (!node.childrenStates.isLoaded) return null; + return node.children.map(function (childNode) { + return h(Option, { + attrs: { + node: childNode + }, + key: childNode.id + }); + }); + }, + renderNoChildrenTip: function renderNoChildrenTip() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (!node.childrenStates.isLoaded || node.children.length) return null; + return h(Tip, { + attrs: { + type: "no-children", + icon: "warning" + } + }, [instance.noChildrenText]); + }, + renderLoadingChildrenTip: function renderLoadingChildrenTip() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (!node.childrenStates.isLoading) return null; + return h(Tip, { + attrs: { + type: "loading", + icon: "loader" + } + }, [instance.loadingText]); + }, + renderLoadingChildrenErrorTip: function renderLoadingChildrenErrorTip() { + var h = this.$createElement; + var instance = this.instance, + node = this.node; + if (!node.childrenStates.loadingError) return null; + return h(Tip, { + attrs: { + type: "error", + icon: "error" + } + }, [node.childrenStates.loadingError, h("a", { + "class": "vue-treeselect__retry", + attrs: { + title: instance.retryTitle + }, + on: { + "mousedown": this.handleMouseDownOnRetry + } + }, [instance.retryText])]); + }, + handleMouseEnterOption: function handleMouseEnterOption(evt) { + var instance = this.instance, + node = this.node; + if (evt.target !== evt.currentTarget) return; + instance.setCurrentHighlightedOption(node, false); + }, + handleMouseDownOnArrow: onLeftClick(function handleMouseDownOnOptionArrow() { + var instance = this.instance, + node = this.node; + instance.toggleExpanded(node); + }), + handleMouseDownOnLabelContainer: onLeftClick(function handleMouseDownOnLabelContainer() { + var instance = this.instance, + node = this.node; + + if (node.isBranch && instance.disableBranchNodes) { + instance.toggleExpanded(node); + } else { + instance.select(node); + } + }), + handleMouseDownOnRetry: onLeftClick(function handleMouseDownOnRetry() { + var instance = this.instance, + node = this.node; + instance.loadChildrenOptions(node); + }) + }, + render: function render() { + var h = arguments[0]; + var node = this.node; + var indentLevel = this.instance.shouldFlattenOptions ? 0 : node.level; + + var listItemClass = defineProperty_default()({ + 'vue-treeselect__list-item': true + }, "vue-treeselect__indent-level-".concat(indentLevel), true); + + var transitionProps = { + props: { + name: 'vue-treeselect__list--transition' + } + }; + return h("div", { + "class": listItemClass + }, [this.renderOption(), node.isBranch && h("transition", transitionProps, [this.renderSubOptionsList()])]); + } +}; +/* harmony default export */ var Optionvue_type_script_lang_js_ = (Option); +// CONCATENATED MODULE: ./src/components/Option.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Optionvue_type_script_lang_js_ = (Optionvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Option.vue +var Option_render, Option_staticRenderFns + + + + +/* normalize component */ + +var Option_component = normalizeComponent( + components_Optionvue_type_script_lang_js_, + Option_render, + Option_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Option_api; } +Option_component.options.__file = "src/components/Option.vue" +/* harmony default export */ var components_Option = (Option_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Menu.vue?vue&type=script&lang=js& + + + + +var directionMap = { + top: 'top', + bottom: 'bottom', + above: 'top', + below: 'bottom' +}; +/* harmony default export */ var Menuvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--menu', + inject: ['instance'], + computed: { + menuStyle: function menuStyle() { + var instance = this.instance; + return { + maxHeight: instance.maxHeight + 'px' + }; + }, + menuContainerStyle: function menuContainerStyle() { + var instance = this.instance; + return { + zIndex: instance.appendToBody ? null : instance.zIndex + }; + } + }, + watch: { + 'instance.menu.isOpen': function instanceMenuIsOpen(newValue) { + if (newValue) { + this.$nextTick(this.onMenuOpen); + } else { + this.onMenuClose(); + } + } + }, + created: function created() { + this.menuSizeWatcher = null; + this.menuResizeAndScrollEventListeners = null; + }, + mounted: function mounted() { + var instance = this.instance; + if (instance.menu.isOpen) this.$nextTick(this.onMenuOpen); + }, + destroyed: function destroyed() { + this.onMenuClose(); + }, + methods: { + renderMenu: function renderMenu() { + var h = this.$createElement; + var instance = this.instance; + if (!instance.menu.isOpen) return null; + return h("div", { + ref: "menu", + "class": "vue-treeselect__menu", + on: { + "mousedown": instance.handleMouseDown + }, + style: this.menuStyle + }, [this.renderBeforeList(), instance.async ? this.renderAsyncSearchMenuInner() : instance.localSearch.active ? this.renderLocalSearchMenuInner() : this.renderNormalMenuInner(), this.renderAfterList()]); + }, + renderBeforeList: function renderBeforeList() { + var instance = this.instance; + var beforeListRenderer = instance.$scopedSlots['before-list']; + return beforeListRenderer ? beforeListRenderer() : null; + }, + renderAfterList: function renderAfterList() { + var instance = this.instance; + var afterListRenderer = instance.$scopedSlots['after-list']; + return afterListRenderer ? afterListRenderer() : null; + }, + renderNormalMenuInner: function renderNormalMenuInner() { + var instance = this.instance; + + if (instance.rootOptionsStates.isLoading) { + return this.renderLoadingOptionsTip(); + } else if (instance.rootOptionsStates.loadingError) { + return this.renderLoadingRootOptionsErrorTip(); + } else if (instance.rootOptionsStates.isLoaded && instance.forest.normalizedOptions.length === 0) { + return this.renderNoAvailableOptionsTip(); + } else { + return this.renderOptionList(); + } + }, + renderLocalSearchMenuInner: function renderLocalSearchMenuInner() { + var instance = this.instance; + + if (instance.rootOptionsStates.isLoading) { + return this.renderLoadingOptionsTip(); + } else if (instance.rootOptionsStates.loadingError) { + return this.renderLoadingRootOptionsErrorTip(); + } else if (instance.rootOptionsStates.isLoaded && instance.forest.normalizedOptions.length === 0) { + return this.renderNoAvailableOptionsTip(); + } else if (instance.localSearch.noResults) { + return this.renderNoResultsTip(); + } else { + return this.renderOptionList(); + } + }, + renderAsyncSearchMenuInner: function renderAsyncSearchMenuInner() { + var instance = this.instance; + var entry = instance.getRemoteSearchEntry(); + var shouldShowSearchPromptTip = instance.trigger.searchQuery === '' && !instance.defaultOptions; + var shouldShowNoResultsTip = shouldShowSearchPromptTip ? false : entry.isLoaded && entry.options.length === 0; + + if (shouldShowSearchPromptTip) { + return this.renderSearchPromptTip(); + } else if (entry.isLoading) { + return this.renderLoadingOptionsTip(); + } else if (entry.loadingError) { + return this.renderAsyncSearchLoadingErrorTip(); + } else if (shouldShowNoResultsTip) { + return this.renderNoResultsTip(); + } else { + return this.renderOptionList(); + } + }, + renderOptionList: function renderOptionList() { + var h = this.$createElement; + var instance = this.instance; + return h("div", { + "class": "vue-treeselect__list" + }, [instance.forest.normalizedOptions.map(function (rootNode) { + return h(components_Option, { + attrs: { + node: rootNode + }, + key: rootNode.id + }); + })]); + }, + renderSearchPromptTip: function renderSearchPromptTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "search-prompt", + icon: "warning" + } + }, [instance.searchPromptText]); + }, + renderLoadingOptionsTip: function renderLoadingOptionsTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "loading", + icon: "loader" + } + }, [instance.loadingText]); + }, + renderLoadingRootOptionsErrorTip: function renderLoadingRootOptionsErrorTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "error", + icon: "error" + } + }, [instance.rootOptionsStates.loadingError, h("a", { + "class": "vue-treeselect__retry", + on: { + "click": instance.loadRootOptions + }, + attrs: { + title: instance.retryTitle + } + }, [instance.retryText])]); + }, + renderAsyncSearchLoadingErrorTip: function renderAsyncSearchLoadingErrorTip() { + var h = this.$createElement; + var instance = this.instance; + var entry = instance.getRemoteSearchEntry(); + return h(Tip, { + attrs: { + type: "error", + icon: "error" + } + }, [entry.loadingError, h("a", { + "class": "vue-treeselect__retry", + on: { + "click": instance.handleRemoteSearch + }, + attrs: { + title: instance.retryTitle + } + }, [instance.retryText])]); + }, + renderNoAvailableOptionsTip: function renderNoAvailableOptionsTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "no-options", + icon: "warning" + } + }, [instance.noOptionsText]); + }, + renderNoResultsTip: function renderNoResultsTip() { + var h = this.$createElement; + var instance = this.instance; + return h(Tip, { + attrs: { + type: "no-results", + icon: "warning" + } + }, [instance.noResultsText]); + }, + onMenuOpen: function onMenuOpen() { + this.adjustMenuOpenDirection(); + this.setupMenuSizeWatcher(); + this.setupMenuResizeAndScrollEventListeners(); + }, + onMenuClose: function onMenuClose() { + this.removeMenuSizeWatcher(); + this.removeMenuResizeAndScrollEventListeners(); + }, + adjustMenuOpenDirection: function adjustMenuOpenDirection() { + var instance = this.instance; + if (!instance.menu.isOpen) return; + var $menu = instance.getMenu(); + var $control = instance.getControl(); + var menuRect = $menu.getBoundingClientRect(); + var controlRect = $control.getBoundingClientRect(); + var menuHeight = menuRect.height; + var viewportHeight = window.innerHeight; + var spaceAbove = controlRect.top; + var spaceBelow = window.innerHeight - controlRect.bottom; + var isControlInViewport = controlRect.top >= 0 && controlRect.top <= viewportHeight || controlRect.top < 0 && controlRect.bottom > 0; + var hasEnoughSpaceBelow = spaceBelow > menuHeight + MENU_BUFFER; + var hasEnoughSpaceAbove = spaceAbove > menuHeight + MENU_BUFFER; + + if (!isControlInViewport) { + instance.closeMenu(); + } else if (instance.openDirection !== 'auto') { + instance.menu.placement = directionMap[instance.openDirection]; + } else if (hasEnoughSpaceBelow || !hasEnoughSpaceAbove) { + instance.menu.placement = 'bottom'; + } else { + instance.menu.placement = 'top'; + } + }, + setupMenuSizeWatcher: function setupMenuSizeWatcher() { + var instance = this.instance; + var $menu = instance.getMenu(); + if (this.menuSizeWatcher) return; + this.menuSizeWatcher = { + remove: watchSize($menu, this.adjustMenuOpenDirection) + }; + }, + setupMenuResizeAndScrollEventListeners: function setupMenuResizeAndScrollEventListeners() { + var instance = this.instance; + var $control = instance.getControl(); + if (this.menuResizeAndScrollEventListeners) return; + this.menuResizeAndScrollEventListeners = { + remove: setupResizeAndScrollEventListeners($control, this.adjustMenuOpenDirection) + }; + }, + removeMenuSizeWatcher: function removeMenuSizeWatcher() { + if (!this.menuSizeWatcher) return; + this.menuSizeWatcher.remove(); + this.menuSizeWatcher = null; + }, + removeMenuResizeAndScrollEventListeners: function removeMenuResizeAndScrollEventListeners() { + if (!this.menuResizeAndScrollEventListeners) return; + this.menuResizeAndScrollEventListeners.remove(); + this.menuResizeAndScrollEventListeners = null; + } + }, + render: function render() { + var h = arguments[0]; + return h("div", { + ref: "menu-container", + "class": "vue-treeselect__menu-container", + style: this.menuContainerStyle + }, [h("transition", { + attrs: { + name: "vue-treeselect__menu--transition" + } + }, [this.renderMenu()])]); + } +}); +// CONCATENATED MODULE: ./src/components/Menu.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Menuvue_type_script_lang_js_ = (Menuvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Menu.vue +var Menu_render, Menu_staticRenderFns + + + + +/* normalize component */ + +var Menu_component = normalizeComponent( + components_Menuvue_type_script_lang_js_, + Menu_render, + Menu_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Menu_api; } +Menu_component.options.__file = "src/components/Menu.vue" +/* harmony default export */ var Menu = (Menu_component.exports); +// EXTERNAL MODULE: external "Vue" +var external_Vue_ = __webpack_require__(38); +var external_Vue_default = /*#__PURE__*/__webpack_require__.n(external_Vue_); + +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/MenuPortal.vue?vue&type=script&lang=js& + + +function MenuPortalvue_type_script_lang_js_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function MenuPortalvue_type_script_lang_js_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? MenuPortalvue_type_script_lang_js_ownKeys(Object(source), !0).forEach(function (key) { defineProperty_default()(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : MenuPortalvue_type_script_lang_js_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + + + + +var PortalTarget = { + name: 'vue-treeselect--portal-target', + inject: ['instance'], + watch: { + 'instance.menu.isOpen': function instanceMenuIsOpen(newValue) { + if (newValue) { + this.setupHandlers(); + } else { + this.removeHandlers(); + } + }, + 'instance.menu.placement': function instanceMenuPlacement() { + this.updateMenuContainerOffset(); + } + }, + created: function created() { + this.controlResizeAndScrollEventListeners = null; + this.controlSizeWatcher = null; + }, + mounted: function mounted() { + var instance = this.instance; + if (instance.menu.isOpen) this.setupHandlers(); + }, + methods: { + setupHandlers: function setupHandlers() { + this.updateWidth(); + this.updateMenuContainerOffset(); + this.setupControlResizeAndScrollEventListeners(); + this.setupControlSizeWatcher(); + }, + removeHandlers: function removeHandlers() { + this.removeControlResizeAndScrollEventListeners(); + this.removeControlSizeWatcher(); + }, + setupControlResizeAndScrollEventListeners: function setupControlResizeAndScrollEventListeners() { + var instance = this.instance; + var $control = instance.getControl(); + if (this.controlResizeAndScrollEventListeners) return; + this.controlResizeAndScrollEventListeners = { + remove: setupResizeAndScrollEventListeners($control, this.updateMenuContainerOffset) + }; + }, + setupControlSizeWatcher: function setupControlSizeWatcher() { + var _this = this; + + var instance = this.instance; + var $control = instance.getControl(); + if (this.controlSizeWatcher) return; + this.controlSizeWatcher = { + remove: watchSize($control, function () { + _this.updateWidth(); + + _this.updateMenuContainerOffset(); + }) + }; + }, + removeControlResizeAndScrollEventListeners: function removeControlResizeAndScrollEventListeners() { + if (!this.controlResizeAndScrollEventListeners) return; + this.controlResizeAndScrollEventListeners.remove(); + this.controlResizeAndScrollEventListeners = null; + }, + removeControlSizeWatcher: function removeControlSizeWatcher() { + if (!this.controlSizeWatcher) return; + this.controlSizeWatcher.remove(); + this.controlSizeWatcher = null; + }, + updateWidth: function updateWidth() { + var instance = this.instance; + var $portalTarget = this.$el; + var $control = instance.getControl(); + var controlRect = $control.getBoundingClientRect(); + $portalTarget.style.width = controlRect.width + 'px'; + }, + updateMenuContainerOffset: function updateMenuContainerOffset() { + var instance = this.instance; + var $control = instance.getControl(); + var $portalTarget = this.$el; + var controlRect = $control.getBoundingClientRect(); + var portalTargetRect = $portalTarget.getBoundingClientRect(); + var offsetY = instance.menu.placement === 'bottom' ? controlRect.height : 0; + var left = Math.round(controlRect.left - portalTargetRect.left) + 'px'; + var top = Math.round(controlRect.top - portalTargetRect.top + offsetY) + 'px'; + var menuContainerStyle = this.$refs.menu.$refs['menu-container'].style; + var transformVariations = ['transform', 'webkitTransform', 'MozTransform', 'msTransform']; + var transform = find(transformVariations, function (t) { + return t in document.body.style; + }); + menuContainerStyle[transform] = "translate(".concat(left, ", ").concat(top, ")"); + } + }, + render: function render() { + var h = arguments[0]; + var instance = this.instance; + var portalTargetClass = ['vue-treeselect__portal-target', instance.wrapperClass]; + var portalTargetStyle = { + zIndex: instance.zIndex + }; + return h("div", { + "class": portalTargetClass, + style: portalTargetStyle, + attrs: { + "data-instance-id": instance.getInstanceId() + } + }, [h(Menu, { + ref: "menu" + })]); + }, + destroyed: function destroyed() { + this.removeHandlers(); + } +}; +var placeholder; +/* harmony default export */ var MenuPortalvue_type_script_lang_js_ = ({ + name: 'vue-treeselect--menu-portal', + created: function created() { + this.portalTarget = null; + }, + mounted: function mounted() { + this.setup(); + }, + destroyed: function destroyed() { + this.teardown(); + }, + methods: { + setup: function setup() { + var el = document.createElement('div'); + document.body.appendChild(el); + this.portalTarget = new external_Vue_default.a(MenuPortalvue_type_script_lang_js_objectSpread({ + el: el, + parent: this + }, PortalTarget)); + }, + teardown: function teardown() { + document.body.removeChild(this.portalTarget.$el); + this.portalTarget.$el.innerHTML = ''; + this.portalTarget.$destroy(); + this.portalTarget = null; + } + }, + render: function render() { + var h = arguments[0]; + if (!placeholder) placeholder = h("div", { + "class": "vue-treeselect__menu-placeholder" + }); + return placeholder; + } +}); +// CONCATENATED MODULE: ./src/components/MenuPortal.vue?vue&type=script&lang=js& + /* harmony default export */ var components_MenuPortalvue_type_script_lang_js_ = (MenuPortalvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/MenuPortal.vue +var MenuPortal_render, MenuPortal_staticRenderFns + + + + +/* normalize component */ + +var MenuPortal_component = normalizeComponent( + components_MenuPortalvue_type_script_lang_js_, + MenuPortal_render, + MenuPortal_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var MenuPortal_api; } +MenuPortal_component.options.__file = "src/components/MenuPortal.vue" +/* harmony default export */ var MenuPortal = (MenuPortal_component.exports); +// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/Treeselect.vue?vue&type=script&lang=js& + + + + + +/* harmony default export */ var Treeselectvue_type_script_lang_js_ = ({ + name: 'vue-treeselect', + mixins: [treeselectMixin], + computed: { + wrapperClass: function wrapperClass() { + return { + 'vue-treeselect': true, + 'vue-treeselect--single': this.single, + 'vue-treeselect--multi': this.multiple, + 'vue-treeselect--searchable': this.searchable, + 'vue-treeselect--disabled': this.disabled, + 'vue-treeselect--focused': this.trigger.isFocused, + 'vue-treeselect--has-value': this.hasValue, + 'vue-treeselect--open': this.menu.isOpen, + 'vue-treeselect--open-above': this.menu.placement === 'top', + 'vue-treeselect--open-below': this.menu.placement === 'bottom', + 'vue-treeselect--branch-nodes-disabled': this.disableBranchNodes, + 'vue-treeselect--append-to-body': this.appendToBody + }; + } + }, + render: function render() { + var h = arguments[0]; + return h("div", { + ref: "wrapper", + "class": this.wrapperClass + }, [h(HiddenFields), h(Control, { + ref: "control" + }), this.appendToBody ? h(MenuPortal, { + ref: "portal" + }) : h(Menu, { + ref: "menu" + })]); + } +}); +// CONCATENATED MODULE: ./src/components/Treeselect.vue?vue&type=script&lang=js& + /* harmony default export */ var components_Treeselectvue_type_script_lang_js_ = (Treeselectvue_type_script_lang_js_); +// CONCATENATED MODULE: ./src/components/Treeselect.vue +var Treeselect_render, Treeselect_staticRenderFns + + + + +/* normalize component */ + +var Treeselect_component = normalizeComponent( + components_Treeselectvue_type_script_lang_js_, + Treeselect_render, + Treeselect_staticRenderFns, + false, + null, + null, + null + +) + +/* hot reload */ +if (false) { var Treeselect_api; } +Treeselect_component.options.__file = "src/components/Treeselect.vue" +/* harmony default export */ var Treeselect = (Treeselect_component.exports); +// EXTERNAL MODULE: ./src/style.less +var style = __webpack_require__(39); + +// CONCATENATED MODULE: ./src/index.js + + + +/* harmony default export */ var src = __webpack_exports__["default"] = (Treeselect); + + +var VERSION = "0.4.0"; + +/***/ }) +/******/ ]); +}); +//# sourceMappingURL=vue-treeselect.umd.js.map \ No newline at end of file diff --git a/dist/vue-treeselect.umd.js.map b/dist/vue-treeselect.umd.js.map new file mode 100644 index 00000000..357426d5 --- /dev/null +++ b/dist/vue-treeselect.umd.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["webpack://VueTreeselect/webpack/universalModuleDefinition","webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/iterableToArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://VueTreeselect/./node_modules/fuzzysearch/index.js","webpack://VueTreeselect/./node_modules/lodash/noop.js","webpack://VueTreeselect/./node_modules/lodash/debounce.js","webpack://VueTreeselect/./node_modules/lodash/isObject.js","webpack://VueTreeselect/./node_modules/lodash/now.js","webpack://VueTreeselect/./node_modules/lodash/_root.js","webpack://VueTreeselect/./node_modules/lodash/_freeGlobal.js","webpack://VueTreeselect/(webpack)/buildin/global.js","webpack://VueTreeselect/./node_modules/lodash/toNumber.js","webpack://VueTreeselect/./node_modules/lodash/_baseTrim.js","webpack://VueTreeselect/./node_modules/lodash/_trimmedEndIndex.js","webpack://VueTreeselect/./node_modules/lodash/isSymbol.js","webpack://VueTreeselect/./node_modules/lodash/_baseGetTag.js","webpack://VueTreeselect/./node_modules/lodash/_Symbol.js","webpack://VueTreeselect/./node_modules/lodash/_getRawTag.js","webpack://VueTreeselect/./node_modules/lodash/_objectToString.js","webpack://VueTreeselect/./node_modules/lodash/isObjectLike.js","webpack://VueTreeselect/./node_modules/is-promise/index.js","webpack://VueTreeselect/./node_modules/lodash/once.js","webpack://VueTreeselect/./node_modules/lodash/before.js","webpack://VueTreeselect/./node_modules/lodash/toInteger.js","webpack://VueTreeselect/./node_modules/lodash/toFinite.js","webpack://VueTreeselect/./node_modules/lodash/identity.js","webpack://VueTreeselect/./node_modules/lodash/constant.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/typeof.js","webpack://VueTreeselect/./node_modules/lodash/last.js","webpack://VueTreeselect/./node_modules/babel-helper-vue-jsx-merge-props/index.js","webpack://VueTreeselect/external \"Vue\"","webpack://VueTreeselect/./src/style.less?1f4a","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./node_modules/watch-size/index.es.mjs","webpack://VueTreeselect/./src/utils/removeFromArray.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./src/utils/setupResizeAndScrollEventListeners.js","webpack://VueTreeselect/./src/utils/isNaN.js","webpack://VueTreeselect/./src/utils/createMap.js","webpack://VueTreeselect/./src/utils/deepExtend.js","webpack://VueTreeselect/./src/utils/includes.js","webpack://VueTreeselect/./src/utils/find.js","webpack://VueTreeselect/./src/utils/quickDiff.js","webpack://VueTreeselect/./src/utils/index.js","webpack://VueTreeselect/./src/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","webpack://VueTreeselect/./src/components/HiddenFields.vue?750c","webpack://VueTreeselect/./node_modules/vue-loader/lib/runtime/componentNormalizer.js","webpack://VueTreeselect/./src/components/HiddenFields.vue","webpack://VueTreeselect/src/components/Input.vue","webpack://VueTreeselect/./src/components/Input.vue?449d","webpack://VueTreeselect/./src/components/Input.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/Placeholder.vue?238d","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/SingleValue.vue","webpack://VueTreeselect/./src/components/SingleValue.vue?5aaa","webpack://VueTreeselect/./src/components/SingleValue.vue","webpack://VueTreeselect/./src/components/icons/Delete.vue?2d39","webpack://VueTreeselect/src/components/icons/Delete.vue","webpack://VueTreeselect/./src/components/icons/Delete.vue?ada5","webpack://VueTreeselect/./src/components/icons/Delete.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValueItem.vue?9a1f","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValue.vue","webpack://VueTreeselect/./src/components/MultiValue.vue?6f61","webpack://VueTreeselect/./src/components/MultiValue.vue","webpack://VueTreeselect/./src/components/icons/Arrow.vue?2ad4","webpack://VueTreeselect/src/components/icons/Arrow.vue","webpack://VueTreeselect/./src/components/icons/Arrow.vue?525a","webpack://VueTreeselect/./src/components/icons/Arrow.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Control.vue?57ab","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/./src/components/Tip.vue?5960","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue?0a09","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue?c349","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue?ca92","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/components/Treeselect.vue?85a0","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["warning","process","noop","checker","complainer","message","concat","console","error","onLeftClick","mouseDownHandler","onMouseDown","evt","type","button","args","call","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","Math","min","offsetTop","clientHeight","scrollHeight","top","max","removeFromArray","arr","elem","idx","indexOf","splice","intervalId","registered","INTERVAL_DURATION","run","setInterval","forEach","test","stop","clearInterval","item","$el","listener","lastWidth","lastHeight","width","offsetWidth","height","watchSizeForIE9","unwatch","length","push","watchSize","isIE9","document","documentMode","locked","wrappedListener","implementation","watchSizeForBrowsersOtherThanIE9","removeSizeWatcher","findScrollParents","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","isScrollElment","window","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","addEventListener","passive","scrollParent","removeEventListeners","removeEventListener","$scrollParent","isNaN","x","createMap","Object","create","isPlainObject","value","getPrototypeOf","prototype","copy","obj","key","deepExtend","target","source","keys","i","len","includes","arrOrStr","find","predicate","ctx","undefined","quickDiff","arrA","arrB","NO_PARENT_NODE","UNCHECKED","INDETERMINATE","CHECKED","ALL_CHILDREN","ALL_DESCENDANTS","LEAF_CHILDREN","LEAF_DESCENDANTS","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","ALL","BRANCH_PRIORITY","LEAF_PRIORITY","ALL_WITH_INDETERMINATE","ORDER_SELECTED","LEVEL","INDEX","KEY_CODES","BACKSPACE","ENTER","ESCAPE","END","HOME","ARROW_LEFT","ARROW_UP","ARROW_RIGHT","ARROW_DOWN","DELETE","INPUT_DEBOUNCE_DELAY","MIN_INPUT_WIDTH","MENU_BUFFER","sortValueByIndex","a","b","level","index","sortValueByLevel","createAsyncOptionsStates","isLoaded","isLoading","loadingError","stringifyOptionPropValue","removeAccents","str","normalize","replace","match","enableFuzzyMatch","needle","haystack","fuzzysearch","getErrorMessage","err","String","instanceId","provide","instance","props","allowClearingDisabled","Boolean","default","allowSelectingDisabledDescendants","alwaysOpen","appendToBody","async","autoFocus","autoLoadRootOptions","autoDeselectAncestors","autoDeselectDescendants","autoSelectAncestors","autoSelectDescendants","backspaceRemoves","beforeClearAll","Function","constant","branchNodesFirst","cacheOptions","clearable","clearAllText","clearOnSelect","clearValueText","closeOnSelect","defaultExpandLevel","Number","defaultOptions","deleteRemoves","delimiter","flattenSearchResults","disableBranchNodes","disabled","disableFuzzyMatching","flat","joinValues","limit","Infinity","limitText","limitTextDefault","count","loadingText","loadOptions","matchKeys","Array","maxHeight","multiple","name","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","acceptableValues","openOnClick","openOnFocus","options","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","localSearch","active","noResults","countMap","remoteSearch","computed","selectedNodes","map","getNode","internalValue","single","slice","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","hasBranchNodes","some","rootNode","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","hasChanged","$emit","getValue","getInstanceId","buildForestState","handler","isArray","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propNames","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","getUniqChildValues","rawNodes","raw","ids","values","hasBeenSelected","hasOneChild","traverseDescendantsBFS","descendant","isDisabled","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","isClickedOnValueContainer","contains","wrapper","done","resetHighlightedOptionWhenNecessary","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","split","every","filterValue","nestedSearchLabel","matchKey","lowerCased","entry","callLoadOptionsProp","action","isPending","start","succeed","fail","end","$watch","isExpanded","shouldShowOptionInMenu","getControl","getMenu","ref","portal","portalTarget","$menu","setCurrentHighlightedOption","scroll","prev","isHighlighted","scrollToOption","$option","querySelector","$nextTick","forceReset","highlightFirstOption","first","highlightPrevOption","highlightLastOption","highlightNextOption","next","last","getLast","resetSearchQuery","saveMenuScrollPosition","restoreMenuScrollPosition","loadRootOptions","toggleMenu","toggleExpanded","nextState","childrenStates","loadChildrenOptions","selectedNodeId","ancestorNode","nodes","checkDuplication","verifyNodeShape","isDefaultExpanded","reduce","normalized","hasDisabledDescendants","branchNodes","option","leafNodes","once","result","isPromise","then","catch","JSON","stringify","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","Treeselect","VERSION","PKG_VERSION"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;QCVA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;QAEA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;;;QAGA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA,0CAA0C,gCAAgC;QAC1E;QACA;;QAEA;QACA;QACA;QACA,wDAAwD,kBAAkB;QAC1E;QACA,iDAAiD,cAAc;QAC/D;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,yCAAyC,iCAAiC;QAC1E,gHAAgH,mBAAmB,EAAE;QACrI;QACA;;QAEA;QACA;QACA;QACA,2BAA2B,0BAA0B,EAAE;QACvD,iCAAiC,eAAe;QAChD;QACA;QACA;;QAEA;QACA,sDAAsD,+DAA+D;;QAErH;QACA;;;QAGA;QACA;;;;;;;AClFA,qBAAqB,mBAAO,CAAC,CAAqB;;AAElD,2BAA2B,mBAAO,CAAC,CAA2B;;AAE9D,iCAAiC,mBAAO,CAAC,CAAiC;;AAE1E,sBAAsB,mBAAO,CAAC,CAAsB;;AAEpD;AACA;AACA;;AAEA,8G;;;;;;ACZA;AACA;AACA;;AAEA,+G;;;;;;ACJA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,2BAA2B,+BAA+B;AAC1D;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,qH;;;;;;AC9BA,uBAAuB,mBAAO,CAAC,CAAuB;;AAEtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,2H;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,iH;;;;;;ACVA;AACA;AACA;;AAEA,gH;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAwB;;AAExD,sBAAsB,mBAAO,CAAC,CAAsB;;AAEpD,iCAAiC,mBAAO,CAAC,CAAiC;;AAE1E,wBAAwB,mBAAO,CAAC,CAAwB;;AAExD;AACA;AACA;;AAEA,kH;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAuB;;AAEtD;AACA;AACA;;AAEA,kH;;;;;;ACNA;AACA;AACA;;AAEA,gH;;;;;;ACJA;AACA;AACA;;AAEA,kH;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,+G;;;;;;;ACfa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,UAAU;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChBA,eAAe,mBAAO,CAAC,EAAY;AACnC,UAAU,mBAAO,CAAC,EAAO;AACzB,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,WAAW,OAAO,YAAY;AAC9B,WAAW,QAAQ;AACnB;AACA,WAAW,OAAO;AAClB;AACA,WAAW,QAAQ;AACnB;AACA,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA,8CAA8C,kBAAkB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9BA,WAAW,mBAAO,CAAC,EAAS;;AAE5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACtBA,iBAAiB,mBAAO,CAAC,EAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;;;;;;;ACRA;AACA;;AAEA;;;;;;;;ACHA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C;;;;;;;ACnBA,eAAe,mBAAO,CAAC,EAAa;AACpC,eAAe,mBAAO,CAAC,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC/DA,sBAAsB,mBAAO,CAAC,EAAoB;;AAElD;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AClBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;AClBA,iBAAiB,mBAAO,CAAC,EAAe;AACxC,mBAAmB,mBAAO,CAAC,EAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5BA,aAAa,mBAAO,CAAC,EAAW;AAChC,gBAAgB,mBAAO,CAAC,EAAc;AACtC,qBAAqB,mBAAO,CAAC,EAAmB;;AAEhD;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC3BA,WAAW,mBAAO,CAAC,EAAS;;AAE5B;AACA;;AAEA;;;;;;;ACLA,aAAa,mBAAO,CAAC,EAAW;;AAEhC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7CA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5BA;AACA;;AAEA;AACA;AACA;;;;;;;ACLA,aAAa,mBAAO,CAAC,EAAU;;AAE/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACxBA,gBAAgB,mBAAO,CAAC,EAAa;;AAErC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACvCA,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACnCA,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,EAAE;AACf;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;AACA;AACA;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","file":"vue-treeselect.umd.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"Vue\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"Vue\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"VueTreeselect\"] = factory(require(\"Vue\"));\n\telse\n\t\troot[\"VueTreeselect\"] = factory(root[\"Vue\"]);\n})(window, function(__WEBPACK_EXTERNAL_MODULE__38__) {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 40);\n","var arrayWithHoles = require(\"./arrayWithHoles.js\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableRest = require(\"./nonIterableRest.js\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArrayLimit(arr, i) {\n var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n if (_i == null) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n\n var _s, _e;\n\n try {\n for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n _arr.push(_s.value);\n\n if (i && _arr.length === i) break;\n }\n } catch (err) {\n _d = true;\n _e = err;\n } finally {\n try {\n if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n } finally {\n if (_d) throw _e;\n }\n }\n\n return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n if (!o) return;\n if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n var n = Object.prototype.toString.call(o).slice(8, -1);\n if (n === \"Object\" && o.constructor) n = o.constructor.name;\n if (n === \"Map\" || n === \"Set\") return Array.from(o);\n if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayLikeToArray(arr, len) {\n if (len == null || len > arr.length) len = arr.length;\n\n for (var i = 0, arr2 = new Array(len); i < len; i++) {\n arr2[i] = arr[i];\n }\n\n return arr2;\n}\n\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\n\nvar iterableToArray = require(\"./iterableToArray.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _defineProperty(obj, key, value) {\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n\n return obj;\n}\n\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","'use strict';\n\nfunction fuzzysearch (needle, haystack) {\n var tlen = haystack.length;\n var qlen = needle.length;\n if (qlen > tlen) {\n return false;\n }\n if (qlen === tlen) {\n return needle === haystack;\n }\n outer: for (var i = 0, j = 0; i < qlen; i++) {\n var nch = needle.charCodeAt(i);\n while (j < tlen) {\n if (haystack.charCodeAt(j++) === nch) {\n continue outer;\n }\n }\n return false;\n }\n return true;\n}\n\nmodule.exports = fuzzysearch;\n","/**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\nfunction noop() {\n // No operation performed.\n}\n\nmodule.exports = noop;\n","var isObject = require('./isObject'),\n now = require('./now'),\n toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n * Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n * The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n * Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n * 'leading': true,\n * 'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n var lastArgs,\n lastThis,\n maxWait,\n result,\n timerId,\n lastCallTime,\n lastInvokeTime = 0,\n leading = false,\n maxing = false,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n wait = toNumber(wait) || 0;\n if (isObject(options)) {\n leading = !!options.leading;\n maxing = 'maxWait' in options;\n maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n\n function invokeFunc(time) {\n var args = lastArgs,\n thisArg = lastThis;\n\n lastArgs = lastThis = undefined;\n lastInvokeTime = time;\n result = func.apply(thisArg, args);\n return result;\n }\n\n function leadingEdge(time) {\n // Reset any `maxWait` timer.\n lastInvokeTime = time;\n // Start the timer for the trailing edge.\n timerId = setTimeout(timerExpired, wait);\n // Invoke the leading edge.\n return leading ? invokeFunc(time) : result;\n }\n\n function remainingWait(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime,\n timeWaiting = wait - timeSinceLastCall;\n\n return maxing\n ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n : timeWaiting;\n }\n\n function shouldInvoke(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime;\n\n // Either this is the first call, activity has stopped and we're at the\n // trailing edge, the system time has gone backwards and we're treating\n // it as the trailing edge, or we've hit the `maxWait` limit.\n return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n }\n\n function timerExpired() {\n var time = now();\n if (shouldInvoke(time)) {\n return trailingEdge(time);\n }\n // Restart the timer.\n timerId = setTimeout(timerExpired, remainingWait(time));\n }\n\n function trailingEdge(time) {\n timerId = undefined;\n\n // Only invoke if we have `lastArgs` which means `func` has been\n // debounced at least once.\n if (trailing && lastArgs) {\n return invokeFunc(time);\n }\n lastArgs = lastThis = undefined;\n return result;\n }\n\n function cancel() {\n if (timerId !== undefined) {\n clearTimeout(timerId);\n }\n lastInvokeTime = 0;\n lastArgs = lastCallTime = lastThis = timerId = undefined;\n }\n\n function flush() {\n return timerId === undefined ? result : trailingEdge(now());\n }\n\n function debounced() {\n var time = now(),\n isInvoking = shouldInvoke(time);\n\n lastArgs = arguments;\n lastThis = this;\n lastCallTime = time;\n\n if (isInvoking) {\n if (timerId === undefined) {\n return leadingEdge(lastCallTime);\n }\n if (maxing) {\n // Handle invocations in a tight loop.\n clearTimeout(timerId);\n timerId = setTimeout(timerExpired, wait);\n return invokeFunc(lastCallTime);\n }\n }\n if (timerId === undefined) {\n timerId = setTimeout(timerExpired, wait);\n }\n return result;\n }\n debounced.cancel = cancel;\n debounced.flush = flush;\n return debounced;\n}\n\nmodule.exports = debounce;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n * console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n return root.Date.now();\n};\n\nmodule.exports = now;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","var baseTrim = require('./_baseTrim'),\n isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = baseTrim(value);\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n return string\n ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n : string;\n}\n\nmodule.exports = baseTrim;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n var index = string.length;\n\n while (index-- && reWhitespace.test(string.charAt(index))) {}\n return index;\n}\n\nmodule.exports = trimmedEndIndex;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","var Symbol = require('./_Symbol'),\n getRawTag = require('./_getRawTag'),\n objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","module.exports = isPromise;\nmodule.exports.default = isPromise;\n\nfunction isPromise(obj) {\n return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';\n}\n","var before = require('./before');\n\n/**\n * Creates a function that is restricted to invoking `func` once. Repeat calls\n * to the function return the value of the first invocation. The `func` is\n * invoked with the `this` binding and arguments of the created function.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * var initialize = _.once(createApplication);\n * initialize();\n * initialize();\n * // => `createApplication` is invoked once\n */\nfunction once(func) {\n return before(2, func);\n}\n\nmodule.exports = once;\n","var toInteger = require('./toInteger');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that invokes `func`, with the `this` binding and arguments\n * of the created function, while it's called less than `n` times. Subsequent\n * calls to the created function return the result of the last `func` invocation.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {number} n The number of calls at which `func` is no longer invoked.\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * jQuery(element).on('click', _.before(5, addContactToList));\n * // => Allows adding up to 4 contacts to the list.\n */\nfunction before(n, func) {\n var result;\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n n = toInteger(n);\n return function() {\n if (--n > 0) {\n result = func.apply(this, arguments);\n }\n if (n <= 1) {\n func = undefined;\n }\n return result;\n };\n}\n\nmodule.exports = before;\n","var toFinite = require('./toFinite');\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n var result = toFinite(value),\n remainder = result % 1;\n\n return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\nmodule.exports = toInteger;\n","var toNumber = require('./toNumber');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n MAX_INTEGER = 1.7976931348623157e+308;\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n if (!value) {\n return value === 0 ? value : 0;\n }\n value = toNumber(value);\n if (value === INFINITY || value === -INFINITY) {\n var sign = (value < 0 ? -1 : 1);\n return sign * MAX_INTEGER;\n }\n return value === value ? value : 0;\n}\n\nmodule.exports = toFinite;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\nmodule.exports = identity;\n","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n return function() {\n return value;\n };\n}\n\nmodule.exports = constant;\n","function _typeof(obj) {\n \"@babel/helpers - typeof\";\n\n return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n return typeof obj;\n } : function (obj) {\n return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\n\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n var length = array == null ? 0 : array.length;\n return length ? array[length - 1] : undefined;\n}\n\nmodule.exports = last;\n","var nestRE = /^(attrs|props|on|nativeOn|class|style|hook)$/\n\nmodule.exports = function mergeJSXProps (objs) {\n return objs.reduce(function (a, b) {\n var aa, bb, key, nestedKey, temp\n for (key in b) {\n aa = a[key]\n bb = b[key]\n if (aa && nestRE.test(key)) {\n // normalize class\n if (key === 'class') {\n if (typeof aa === 'string') {\n temp = aa\n a[key] = aa = {}\n aa[temp] = true\n }\n if (typeof bb === 'string') {\n temp = bb\n b[key] = bb = {}\n bb[temp] = true\n }\n }\n if (key === 'on' || key === 'nativeOn' || key === 'hook') {\n // merge functions\n for (nestedKey in bb) {\n aa[nestedKey] = mergeFn(aa[nestedKey], bb[nestedKey])\n }\n } else if (Array.isArray(aa)) {\n a[key] = aa.concat(bb)\n } else if (Array.isArray(bb)) {\n a[key] = [aa].concat(bb)\n } else {\n for (nestedKey in bb) {\n aa[nestedKey] = bb[nestedKey]\n }\n }\n } else {\n a[key] = b[key]\n }\n }\n return a\n }, {})\n}\n\nfunction mergeFn (a, b) {\n return function () {\n a && a.apply(this, arguments)\n b && b.apply(this, arguments)\n }\n}\n","module.exports = __WEBPACK_EXTERNAL_MODULE__38__;","// extracted by mini-css-extract-plugin","import { noop } from './noop'\n\nexport const warning = process.env.NODE_ENV === 'production'\n ? /* istanbul ignore next */ noop\n : function warning(checker, complainer) {\n if (!checker()) {\n const message = [ '[Vue-Treeselect Warning]' ].concat(complainer())\n // eslint-disable-next-line no-console\n console.error(...message)\n }\n }\n","export function onLeftClick(mouseDownHandler) {\n return function onMouseDown(evt, ...args) {\n if (evt.type === 'mousedown' && evt.button === 0) {\n mouseDownHandler.call(this, evt, ...args)\n }\n }\n}\n","// from react-select\nexport function scrollIntoView($scrollingEl, $focusedEl) {\n const scrollingReact = $scrollingEl.getBoundingClientRect()\n const focusedRect = $focusedEl.getBoundingClientRect()\n const overScroll = $focusedEl.offsetHeight / 3\n\n if (focusedRect.bottom + overScroll > scrollingReact.bottom) {\n $scrollingEl.scrollTop = Math.min(\n $focusedEl.offsetTop + $focusedEl.clientHeight - $scrollingEl.offsetHeight + overScroll,\n $scrollingEl.scrollHeight,\n )\n } else if (focusedRect.top - overScroll < scrollingReact.top) {\n $scrollingEl.scrollTop = Math.max($focusedEl.offsetTop - overScroll, 0)\n }\n}\n","var index = (function (element, listener) {\n\tvar expand = document.createElement('_');\n\tvar shrink = expand.appendChild(document.createElement('_'));\n\tvar expandChild = expand.appendChild(document.createElement('_'));\n\tvar shrinkChild = shrink.appendChild(document.createElement('_'));\n\n\tvar lastWidth = void 0,\n\t lastHeight = void 0;\n\n\tshrink.style.cssText = expand.style.cssText = 'height:100%;left:0;opacity:0;overflow:hidden;pointer-events:none;position:absolute;top:0;transition:0s;width:100%;z-index:-1';\n\tshrinkChild.style.cssText = expandChild.style.cssText = 'display:block;height:100%;transition:0s;width:100%';\n\tshrinkChild.style.width = shrinkChild.style.height = '200%';\n\n\telement.appendChild(expand);\n\n\ttest();\n\n\treturn stop;\n\n\tfunction test() {\n\t\tunbind();\n\n\t\tvar width = element.offsetWidth;\n\t\tvar height = element.offsetHeight;\n\n\t\tif (width !== lastWidth || height !== lastHeight) {\n\t\t\tlastWidth = width;\n\t\t\tlastHeight = height;\n\n\t\t\texpandChild.style.width = width * 2 + 'px';\n\t\t\texpandChild.style.height = height * 2 + 'px';\n\n\t\t\texpand.scrollLeft = expand.scrollWidth;\n\t\t\texpand.scrollTop = expand.scrollHeight;\n\t\t\tshrink.scrollLeft = shrink.scrollWidth;\n\t\t\tshrink.scrollTop = shrink.scrollHeight;\n\n\t\t\tlistener({ width: width, height: height });\n\t\t}\n\n\t\tshrink.addEventListener('scroll', test);\n\t\texpand.addEventListener('scroll', test);\n\t}\n\n\tfunction unbind() {\n\t\tshrink.removeEventListener('scroll', test);\n\t\texpand.removeEventListener('scroll', test);\n\t}\n\n\tfunction stop() {\n\t\tunbind();\n\n\t\telement.removeChild(expand);\n\t}\n});\n\nexport default index;\n","export function removeFromArray(arr, elem) {\n const idx = arr.indexOf(elem)\n if (idx !== -1) arr.splice(idx, 1)\n}\n","import watchSizeForBrowsersOtherThanIE9 from 'watch-size'\nimport { removeFromArray } from './removeFromArray'\n\nlet intervalId\nconst registered = []\nconst INTERVAL_DURATION = 100\n\nfunction run() {\n intervalId = setInterval(() => {\n registered.forEach(test)\n }, INTERVAL_DURATION)\n}\n\nfunction stop() {\n clearInterval(intervalId)\n intervalId = null\n}\n\nfunction test(item) {\n const { $el, listener, lastWidth, lastHeight } = item\n const width = $el.offsetWidth\n const height = $el.offsetHeight\n\n if (lastWidth !== width || lastHeight !== height) {\n item.lastWidth = width\n item.lastHeight = height\n\n listener({ width, height })\n }\n}\n\nfunction watchSizeForIE9($el, listener) {\n const item = {\n $el,\n listener,\n lastWidth: null,\n lastHeight: null,\n }\n const unwatch = () => {\n removeFromArray(registered, item)\n if (!registered.length) stop()\n }\n\n registered.push(item)\n // The original watch-size will call the listener on initialization.\n // Keep the same behavior here.\n test(item)\n run()\n\n return unwatch\n}\n\nexport function watchSize($el, listener) {\n // See: https://stackoverflow.com/a/31293352\n const isIE9 = document.documentMode === 9\n // watch-size will call the listener on initialization.\n // Disable this behavior with a lock to achieve a clearer code logic.\n let locked = true\n const wrappedListener = (...args) => locked || listener(...args)\n const implementation = isIE9\n ? watchSizeForIE9\n : watchSizeForBrowsersOtherThanIE9\n const removeSizeWatcher = implementation($el, wrappedListener)\n locked = false // unlock after initialization\n\n return removeSizeWatcher\n}\n","function findScrollParents($el) {\n const $scrollParents = []\n let $parent = $el.parentNode\n\n while ($parent && $parent.nodeName !== 'BODY' && $parent.nodeType === document.ELEMENT_NODE) {\n if (isScrollElment($parent)) $scrollParents.push($parent)\n $parent = $parent.parentNode\n }\n $scrollParents.push(window)\n\n return $scrollParents\n}\n\nfunction isScrollElment($el) {\n // Firefox wants us to check `-x` and `-y` variations as well\n const { overflow, overflowX, overflowY } = getComputedStyle($el)\n return /(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)\n}\n\nexport function setupResizeAndScrollEventListeners($el, listener) {\n const $scrollParents = findScrollParents($el)\n\n window.addEventListener('resize', listener, { passive: true })\n $scrollParents.forEach(scrollParent => {\n scrollParent.addEventListener('scroll', listener, { passive: true })\n })\n\n return function removeEventListeners() {\n window.removeEventListener('resize', listener, { passive: true })\n $scrollParents.forEach($scrollParent => {\n $scrollParent.removeEventListener('scroll', listener, { passive: true })\n })\n }\n}\n","export function isNaN(x) {\n return x !== x\n}\n","export const createMap = () => Object.create(null)\n","function isPlainObject(value) {\n if (value == null || typeof value !== 'object') return false\n return Object.getPrototypeOf(value) === Object.prototype\n}\n\nfunction copy(obj, key, value) {\n if (isPlainObject(value)) {\n obj[key] || (obj[key] = {})\n deepExtend(obj[key], value)\n } else {\n obj[key] = value\n }\n}\n\nexport function deepExtend(target, source) {\n if (isPlainObject(source)) {\n const keys = Object.keys(source)\n\n for (let i = 0, len = keys.length; i < len; i++) {\n copy(target, keys[i], source[keys[i]])\n }\n }\n\n return target\n}\n","export function includes(arrOrStr, elem) {\n return arrOrStr.indexOf(elem) !== -1\n}\n","export function find(arr, predicate, ctx) {\n for (let i = 0, len = arr.length; i < len; i++) {\n if (predicate.call(ctx, arr[i], i, arr)) return arr[i]\n }\n return undefined\n}\n","export function quickDiff(arrA, arrB) {\n if (arrA.length !== arrB.length) return true\n\n for (let i = 0; i < arrA.length; i++) {\n if (arrA[i] !== arrB[i]) return true\n }\n\n return false\n}\n","// ========================\n// Debugging Helpers\n// ========================\n\nexport { warning } from './warning'\n\n// ========================\n// DOM Utilities\n// ========================\n\nexport { onLeftClick } from './onLeftClick'\nexport { scrollIntoView } from './scrollIntoView'\nexport { debounce } from './debounce'\nexport { watchSize } from './watchSize'\nexport { setupResizeAndScrollEventListeners } from './setupResizeAndScrollEventListeners'\n\n// ========================\n// Language Helpers\n// ========================\n\nexport { isNaN } from './isNaN'\nexport { isPromise } from './isPromise'\nexport { once } from './once'\nexport { noop } from './noop'\nexport { identity } from './identity'\nexport { constant } from './constant'\nexport { createMap } from './createMap'\nexport { deepExtend } from './deepExtend'\nexport { last } from './last'\nexport { includes } from './includes'\nexport { find } from './find'\nexport { removeFromArray } from './removeFromArray'\n\n// ========================\n// Other Utilities\n// ========================\n\nexport { quickDiff } from './quickDiff'\n","// Magic value that indicates a root level node.\nexport const NO_PARENT_NODE = null\n\n// Types of checked state.\nexport const UNCHECKED = 0\nexport const INDETERMINATE = 1\nexport const CHECKED = 2\n\n// Types of count number.\nexport const ALL_CHILDREN = 'ALL_CHILDREN'\nexport const ALL_DESCENDANTS = 'ALL_DESCENDANTS'\nexport const LEAF_CHILDREN = 'LEAF_CHILDREN'\nexport const LEAF_DESCENDANTS = 'LEAF_DESCENDANTS'\n\n// Action types of delayed loading.\nexport const LOAD_ROOT_OPTIONS = 'LOAD_ROOT_OPTIONS'\nexport const LOAD_CHILDREN_OPTIONS = 'LOAD_CHILDREN_OPTIONS'\nexport const ASYNC_SEARCH = 'ASYNC_SEARCH'\n\n// Acceptable values of `valueConsistsOf` prop.\nexport const ALL = 'ALL'\nexport const BRANCH_PRIORITY = 'BRANCH_PRIORITY'\nexport const LEAF_PRIORITY = 'LEAF_PRIORITY'\nexport const ALL_WITH_INDETERMINATE = 'ALL_WITH_INDETERMINATE'\n\n// Acceptable values of `sortValueBy` prop.\nexport const ORDER_SELECTED = 'ORDER_SELECTED'\nexport const LEVEL = 'LEVEL'\nexport const INDEX = 'INDEX'\n\n// Key codes look-up table.\nexport const KEY_CODES = {\n BACKSPACE: 8,\n ENTER: 13,\n ESCAPE: 27,\n END: 35,\n HOME: 36,\n ARROW_LEFT: 37,\n ARROW_UP: 38,\n ARROW_RIGHT: 39,\n ARROW_DOWN: 40,\n DELETE: 46,\n}\n\n// Other constants.\nexport const INPUT_DEBOUNCE_DELAY = process.env.NODE_ENV === 'testing'\n ? /* to speed up unit testing */ 10\n : /* istanbul ignore next */ 200\nexport const MIN_INPUT_WIDTH = 5\nexport const MENU_BUFFER = 40\n","import fuzzysearch from 'fuzzysearch'\n\nimport {\n warning,\n onLeftClick, scrollIntoView,\n isNaN, isPromise, once,\n identity, constant, createMap,\n quickDiff, last as getLast, includes, find, removeFromArray,\n} from '../utils'\n\nimport {\n NO_PARENT_NODE,\n UNCHECKED, INDETERMINATE, CHECKED,\n LOAD_ROOT_OPTIONS, LOAD_CHILDREN_OPTIONS, ASYNC_SEARCH,\n ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE,\n ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS,\n ORDER_SELECTED, LEVEL, INDEX,\n} from '../constants'\n\nfunction sortValueByIndex(a, b) {\n let i = 0\n do {\n if (a.level < i) return -1\n if (b.level < i) return 1\n if (a.index[i] !== b.index[i]) return a.index[i] - b.index[i]\n i++\n } while (true)\n}\n\nfunction sortValueByLevel(a, b) {\n return a.level === b.level\n ? sortValueByIndex(a, b)\n : a.level - b.level\n}\n\nfunction createAsyncOptionsStates() {\n return {\n isLoaded: false,\n isLoading: false,\n loadingError: '',\n }\n}\n\nfunction stringifyOptionPropValue(value) {\n if (typeof value === 'string') return removeAccents(value)\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\n}\nfunction removeAccents(str) {\n if (!str) return ''\n return str.normalize('NFD').replace(/[\\u0300-\\u036F]/g, '')\n}\n\nfunction match(enableFuzzyMatch, needle, haystack) {\n return enableFuzzyMatch\n ? fuzzysearch(needle, haystack)\n : includes(haystack, needle)\n}\n\nfunction getErrorMessage(err) {\n return err.message || /* istanbul ignore next */String(err)\n}\n\nlet instanceId = 0\n\nexport default {\n provide() {\n return {\n // Enable access to the instance of root component of vue-treeselect\n // across hierarchy.\n instance: this,\n }\n },\n\n props: {\n /**\n * Whether to allow resetting value even if there are disabled selected nodes.\n */\n allowClearingDisabled: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When an ancestor node is selected/deselected, whether its disabled descendants should be selected/deselected.\n * You may want to use this in conjunction with `allowClearingDisabled` prop.\n */\n allowSelectingDisabledDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether the menu should be always open.\n */\n alwaysOpen: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Append the menu to ?\n */\n appendToBody: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether to enable async search mode.\n */\n async: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Automatically focus the component on mount?\n */\n autoFocus: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Automatically load root options on mount. When set to `false`, root options will be loaded when the menu is opened.\n */\n autoLoadRootOptions: {\n type: Boolean,\n default: true,\n },\n\n /**\n * When user deselects a node, automatically deselect its ancestors. Applies to flat mode only.\n */\n autoDeselectAncestors: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user deselects a node, automatically deselect its descendants. Applies to flat mode only.\n */\n autoDeselectDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user selects a node, automatically select its ancestors. Applies to flat mode only.\n */\n autoSelectAncestors: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user selects a node, automatically select its descendants. Applies to flat mode only.\n */\n autoSelectDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether pressing backspace key removes the last item if there is no text input.\n */\n backspaceRemoves: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Function that processes before clearing all input fields.\n * Return `false` to prevent value from being cleared.\n * @type {function(): (boolean|Promise)}\n */\n beforeClearAll: {\n type: Function,\n default: constant(true),\n },\n\n /**\n * Show branch nodes before leaf nodes?\n */\n branchNodesFirst: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Should cache results of every search request?\n */\n cacheOptions: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Show an \"×\" button that resets value?\n */\n clearable: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Title for the \"×\" button when `multiple: true`.\n */\n clearAllText: {\n type: String,\n default: 'Clear all',\n },\n\n /**\n * Whether to clear the search input after selecting.\n * Use only when `multiple` is `true`.\n * For single-select mode, it **always** clears the input after selecting an option regardless of the prop value.\n */\n clearOnSelect: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Title for the \"×\" button.\n */\n clearValueText: {\n type: String,\n default: 'Clear value',\n },\n\n /**\n * Whether to close the menu after selecting an option?\n * Use only when `multiple` is `true`.\n */\n closeOnSelect: {\n type: Boolean,\n default: true,\n },\n\n /**\n * How many levels of branch nodes should be automatically expanded when loaded.\n * Set `Infinity` to make all branch nodes expanded by default.\n */\n defaultExpandLevel: {\n type: Number,\n default: 0,\n },\n\n /**\n * The default set of options to show before the user starts searching. Used for async search mode.\n * When set to `true`, the results for search query as a empty string will be autoloaded.\n * @type {boolean|node[]}\n */\n defaultOptions: {\n default: false,\n },\n\n /**\n * Whether pressing delete key removes the last item if there is no text input.\n */\n deleteRemoves: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Delimiter to use to join multiple values for the hidden field value.\n */\n delimiter: {\n type: String,\n default: ',',\n },\n\n /**\n * Only show the nodes that match the search value directly, excluding its ancestors.\n *\n * @type {Object}\n */\n flattenSearchResults: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Prevent branch nodes from being selected?\n */\n disableBranchNodes: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Disable the control?\n */\n disabled: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Disable the fuzzy matching functionality?\n */\n disableFuzzyMatching: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether to enable flat mode or not. Non-flat mode (default) means:\n * - Whenever a branch node gets checked, all its children will be checked too\n * - Whenever a branch node has all children checked, the branch node itself will be checked too\n * Set `true` to disable this mechanism\n */\n flat: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Will be passed with all events as the last param.\n * Useful for identifying events origin.\n */\n instanceId: {\n // Add two trailing \"$\" to distinguish from explictly specified ids.\n default: () => `${instanceId++}$$`,\n type: [ String, Number ],\n },\n\n /**\n * Joins multiple values into a single form field with the `delimiter` (legacy mode).\n */\n joinValues: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Limit the display of selected options.\n * The rest will be hidden within the limitText string.\n */\n limit: {\n type: Number,\n default: Infinity,\n },\n\n /**\n * Function that processes the message shown when selected elements pass the defined limit.\n * @type {function(number): string}\n */\n limitText: {\n type: Function,\n default: function limitTextDefault(count) { // eslint-disable-line func-name-matching\n return `and ${count} more`\n },\n },\n\n /**\n * Text displayed when loading options.\n */\n loadingText: {\n type: String,\n default: 'Loading...',\n },\n\n /**\n * Used for dynamically loading options.\n * @type {function({action: string, callback: (function((Error|string)=): void), parentNode: node=, instanceId}): void}\n */\n loadOptions: {\n type: Function,\n },\n\n /**\n * Which node properties to filter on.\n */\n matchKeys: {\n type: Array,\n default: constant([ 'label' ]),\n },\n\n /**\n * Sets `maxHeight` style value of the menu.\n */\n maxHeight: {\n type: Number,\n default: 300,\n },\n\n /**\n * Set `true` to allow selecting multiple options (a.k.a., multi-select mode).\n */\n multiple: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Generates a hidden tag with this field name for html forms.\n */\n name: {\n type: String,\n },\n\n /**\n * Text displayed when a branch node has no children.\n */\n noChildrenText: {\n type: String,\n default: 'No sub-options.',\n },\n\n /**\n * Text displayed when there are no available options.\n */\n noOptionsText: {\n type: String,\n default: 'No options available.',\n },\n\n /**\n * Text displayed when there are no matching search results.\n */\n noResultsText: {\n type: String,\n default: 'No results found...',\n },\n\n /**\n * Used for normalizing source data.\n * @type {function(node, instanceId): node}\n */\n normalizer: {\n type: Function,\n default: identity,\n },\n\n /**\n * By default (`auto`), the menu will open below the control. If there is not\n * enough space, vue-treeselect will automatically flip the menu.\n * You can use one of other four options to force the menu to be always opened\n * to specified direction.\n * Acceptable values:\n * - `\"auto\"`\n * - `\"below\"`\n * - `\"bottom\"`\n * - `\"above\"`\n * - `\"top\"`\n */\n openDirection: {\n type: String,\n default: 'auto',\n validator(value) {\n const acceptableValues = [ 'auto', 'top', 'bottom', 'above', 'below' ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Whether to automatically open the menu when the control is clicked.\n */\n openOnClick: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Whether to automatically open the menu when the control is focused.\n */\n openOnFocus: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Array of available options.\n * @type {node[]}\n */\n options: {\n type: Array,\n },\n\n /**\n * Field placeholder, displayed when there's no value.\n */\n placeholder: {\n type: String,\n default: 'Select...',\n },\n\n /**\n * Applies HTML5 required attribute when needed.\n */\n required: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Text displayed asking user whether to retry loading children options.\n */\n retryText: {\n type: String,\n default: 'Retry?',\n },\n\n /**\n * Title for the retry button.\n */\n retryTitle: {\n type: String,\n default: 'Click to retry',\n },\n\n /**\n * Enable searching feature?\n */\n searchable: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Search in ancestor nodes too.\n */\n searchNested: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Text tip to prompt for async search.\n */\n searchPromptText: {\n type: String,\n default: 'Type to search...',\n },\n\n /**\n * Whether to show a children count next to the label of each branch node.\n */\n showCount: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Used in conjunction with `showCount` to specify which type of count number should be displayed.\n * Acceptable values:\n * - \"ALL_CHILDREN\"\n * - \"ALL_DESCENDANTS\"\n * - \"LEAF_CHILDREN\"\n * - \"LEAF_DESCENDANTS\"\n */\n showCountOf: {\n type: String,\n default: ALL_CHILDREN,\n validator(value) {\n const acceptableValues = [ ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Whether to show children count when searching.\n * Fallbacks to the value of `showCount` when not specified.\n * @type {boolean}\n */\n showCountOnSearch: null,\n\n /**\n * In which order the selected options should be displayed in trigger & sorted in `value` array.\n * Used for multi-select mode only.\n * Acceptable values:\n * - \"ORDER_SELECTED\"\n * - \"LEVEL\"\n * - \"INDEX\"\n */\n sortValueBy: {\n type: String,\n default: ORDER_SELECTED,\n validator(value) {\n const acceptableValues = [ ORDER_SELECTED, LEVEL, INDEX ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Tab index of the control.\n */\n tabIndex: {\n type: Number,\n default: 0,\n },\n\n /**\n * The value of the control.\n * Should be `id` or `node` object for single-select mode, or an array of `id` or `node` object for multi-select mode.\n * Its format depends on the `valueFormat` prop.\n * For most cases, just use `v-model` instead.\n * @type {?Array}\n */\n value: null,\n\n /**\n * Which kind of nodes should be included in the `value` array in multi-select mode.\n * Acceptable values:\n * - \"ALL\" - Any node that is checked will be included in the `value` array\n * - \"BRANCH_PRIORITY\" (default) - If a branch node is checked, all its descendants will be excluded in the `value` array\n * - \"LEAF_PRIORITY\" - If a branch node is checked, this node itself and its branch descendants will be excluded from the `value` array but its leaf descendants will be included\n * - \"ALL_WITH_INDETERMINATE\" - Any node that is checked will be included in the `value` array, plus indeterminate nodes\n */\n valueConsistsOf: {\n type: String,\n default: BRANCH_PRIORITY,\n validator(value) {\n const acceptableValues = [ ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Format of `value` prop.\n * Note that, when set to `\"object\"`, only `id` & `label` properties are required in each `node` object in `value` prop.\n * Acceptable values:\n * - \"id\"\n * - \"object\"\n */\n valueFormat: {\n type: String,\n default: 'id',\n },\n\n /**\n * z-index of the menu.\n */\n zIndex: {\n type: [ Number, String ],\n default: 999,\n },\n },\n\n data() {\n return {\n trigger: {\n // Is the control focused?\n isFocused: false,\n // User entered search query - value of the input.\n searchQuery: '',\n },\n\n menu: {\n // Is the menu opened?\n isOpen: false,\n // Id of current highlighted option.\n current: null,\n // The scroll position before last menu closing.\n lastScrollPosition: 0,\n // Which direction to open the menu.\n placement: 'bottom',\n },\n\n forest: {\n // Normalized options.\n normalizedOptions: [],\n // map for quick look-up.\n nodeMap: createMap(),\n // map, used for multi-select mode.\n checkedStateMap: createMap(),\n // Id list of all selected options.\n selectedNodeIds: this.extractCheckedNodeIdsFromValue(),\n // map for fast checking:\n // if (forest.selectedNodeIds.indexOf(id) !== -1) forest.selectedNodeMap[id] === true\n selectedNodeMap: createMap(),\n },\n\n // States of root options.\n rootOptionsStates: createAsyncOptionsStates(),\n\n localSearch: {\n // Has user entered any query to search local options?\n active: false,\n // Has any options matched the search query?\n noResults: true,\n // map for counting matched children/descendants.\n countMap: createMap(),\n },\n\n // map.\n remoteSearch: createMap(),\n }\n },\n\n computed: {\n /* eslint-disable valid-jsdoc */\n /**\n * Normalized nodes that have been selected.\n * @type {node[]}\n */\n selectedNodes() {\n return this.forest.selectedNodeIds.map(this.getNode)\n },\n /**\n * Id list of selected nodes with `sortValueBy` prop applied.\n * @type {nodeId[]}\n */\n internalValue() {\n let internalValue\n\n // istanbul ignore else\n if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) {\n internalValue = this.forest.selectedNodeIds.slice()\n } else if (this.valueConsistsOf === BRANCH_PRIORITY) {\n internalValue = this.forest.selectedNodeIds.filter(id => {\n const node = this.getNode(id)\n if (node.isRootNode) return true\n return !this.isSelected(node.parentNode)\n })\n } else if (this.valueConsistsOf === LEAF_PRIORITY) {\n internalValue = this.forest.selectedNodeIds.filter(id => {\n const node = this.getNode(id)\n if (node.isLeaf) return true\n return node.children.length === 0\n })\n } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) {\n const indeterminateNodeIds = []\n internalValue = this.forest.selectedNodeIds.slice()\n this.selectedNodes.forEach(selectedNode => {\n selectedNode.ancestors.forEach(ancestor => {\n if (includes(indeterminateNodeIds, ancestor.id)) return\n if (includes(internalValue, ancestor.id)) return\n indeterminateNodeIds.push(ancestor.id)\n })\n })\n internalValue.push(...indeterminateNodeIds)\n }\n\n if (this.sortValueBy === LEVEL) {\n internalValue.sort((a, b) => sortValueByLevel(this.getNode(a), this.getNode(b)))\n } else if (this.sortValueBy === INDEX) {\n internalValue.sort((a, b) => sortValueByIndex(this.getNode(a), this.getNode(b)))\n }\n\n return internalValue\n },\n /**\n * Has any option been selected?\n * @type {boolean}\n */\n hasValue() {\n return this.internalValue.length > 0\n },\n /**\n * Single-select mode?\n * @type {boolean}\n */\n single() {\n return !this.multiple\n },\n /**\n * Id list of nodes displayed in the menu. Nodes that are considered NOT visible:\n * - descendants of a collapsed branch node\n * - in local search mode, nodes that are not matched, unless\n * - it's a branch node and has matched descendants\n * - it's a leaf node and its parent node is explicitly set to show all children\n * @type {id[]}\n */\n visibleOptionIds() {\n const visibleOptionIds = []\n\n this.traverseAllNodesByIndex(node => {\n if (!this.localSearch.active || this.shouldOptionBeIncludedInSearchResult(node)) {\n visibleOptionIds.push(node.id)\n }\n // Skip the traversal of descendants of a branch node if it's not expanded.\n if (node.isBranch && !this.shouldExpand(node)) {\n return false\n }\n })\n\n return visibleOptionIds\n },\n /**\n * Has any option should be displayed in the menu?\n * @type {boolean}\n */\n hasVisibleOptions() {\n return this.visibleOptionIds.length !== 0\n },\n /**\n * Should show children count when searching?\n * @type {boolean}\n */\n showCountOnSearchComputed() {\n // Vue doesn't allow setting default prop value based on another prop value.\n // So use computed property as a workaround.\n // https://github.com/vuejs/vue/issues/6358\n return typeof this.showCountOnSearch === 'boolean'\n ? this.showCountOnSearch\n : this.showCount\n },\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes() {\n return this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\n },\n shouldFlattenOptions() {\n return this.localSearch.active && this.flattenSearchResults\n },\n /* eslint-enable valid-jsdoc */\n },\n\n watch: {\n alwaysOpen(newValue) {\n if (newValue) this.openMenu()\n else this.closeMenu()\n },\n\n branchNodesFirst() {\n this.initialize()\n },\n\n disabled(newValue) {\n // force close the menu after disabling the control\n if (newValue && this.menu.isOpen) this.closeMenu()\n else if (!newValue && !this.menu.isOpen && this.alwaysOpen) this.openMenu()\n },\n\n flat() {\n this.initialize()\n },\n\n internalValue(newValue, oldValue) {\n const hasChanged = quickDiff(newValue, oldValue)\n // #122\n // Vue would trigger this watcher when `newValue` and `oldValue` are shallow-equal.\n // We emit the `input` event only when the value actually changes.\n if (hasChanged) this.$emit('input', this.getValue(), this.getInstanceId())\n },\n\n matchKeys() {\n this.initialize()\n },\n\n multiple(newValue) {\n // We need to rebuild the state when switching from single-select mode\n // to multi-select mode.\n // istanbul ignore else\n if (newValue) this.buildForestState()\n },\n\n options: {\n handler() {\n if (this.async) return\n // Re-initialize options when the `options` prop has changed.\n this.initialize()\n this.rootOptionsStates.isLoaded = Array.isArray(this.options)\n },\n deep: true,\n immediate: true,\n },\n\n 'trigger.searchQuery'() {\n if (this.async) {\n this.handleRemoteSearch()\n } else {\n this.handleLocalSearch()\n }\n\n this.$emit('search-change', this.trigger.searchQuery, this.getInstanceId())\n },\n\n value() {\n const nodeIdsFromValue = this.extractCheckedNodeIdsFromValue()\n const hasChanged = quickDiff(nodeIdsFromValue, this.internalValue)\n if (hasChanged) this.fixSelectedNodeIds(nodeIdsFromValue)\n },\n },\n\n methods: {\n verifyProps() {\n warning(\n () => this.async ? this.searchable : true,\n () => 'For async search mode, the value of \"searchable\" prop must be true.',\n )\n\n if (this.options == null && !this.loadOptions) {\n warning(\n () => false,\n () => 'Are you meant to dynamically load options? You need to use \"loadOptions\" prop.',\n )\n }\n\n if (this.flat) {\n warning(\n () => this.multiple,\n () => 'You are using flat mode. But you forgot to add \"multiple=true\"?',\n )\n }\n\n if (!this.flat) {\n const propNames = [\n 'autoSelectAncestors',\n 'autoSelectDescendants',\n 'autoDeselectAncestors',\n 'autoDeselectDescendants',\n ]\n\n propNames.forEach(propName => {\n warning(\n () => !this[propName],\n () => `\"${propName}\" only applies to flat mode.`,\n )\n })\n }\n },\n\n resetFlags() {\n this._blurOnSelect = false\n },\n\n initialize() {\n const options = this.async\n ? this.getRemoteSearchEntry().options\n : this.options\n\n if (Array.isArray(options)) {\n // In case we are re-initializing options, keep the old state tree temporarily.\n const prevNodeMap = this.forest.nodeMap\n this.forest.nodeMap = createMap()\n this.keepDataOfSelectedNodes(prevNodeMap)\n this.forest.normalizedOptions = this.normalize(NO_PARENT_NODE, options, prevNodeMap)\n // Cases that need fixing `selectedNodeIds`:\n // 1) Children options of a checked node have been delayed loaded,\n // we should also mark these children as checked. (multi-select mode)\n // 2) Root options have been delayed loaded, we need to initialize states\n // of these nodes. (multi-select mode)\n // 3) Async search mode.\n this.fixSelectedNodeIds(this.internalValue)\n } else {\n this.forest.normalizedOptions = []\n }\n },\n\n getInstanceId() {\n return this.instanceId == null ? this.id : this.instanceId\n },\n\n getValue() {\n if (this.valueFormat === 'id') {\n return this.multiple\n ? this.getUniqChildValues(this.internalValue.slice())\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple\n ? this.getUniqChildValues(rawNodes)\n : rawNodes[0]\n },\n\n getUniqChildValues(ids) {\n if (this.valueConsistsOf !== BRANCH_PRIORITY) return ids\n const values = ids.map(id => {\n const node = this.getNode(id)\n if (node.hasBeenSelected) return node.id\n if (this.hasOneChild(node)) {\n const children = []\n this.traverseDescendantsBFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n if (descendant.hasBeenSelected) {\n children.push(descendant.id)\n }\n }\n })\n if (children && children.length) return children[0]\n }\n return id\n })\n return values\n },\n hasOneChild(node) {\n return node && node.children && node.children.length === 1\n },\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) return null\n\n return nodeId in this.forest.nodeMap\n ? this.forest.nodeMap[nodeId]\n : this.createFallbackNode(nodeId)\n },\n\n createFallbackNode(id) {\n // In case there is a default selected node that is not loaded into the tree yet,\n // we create a fallback node to keep the component working.\n // When the real data is loaded, we'll override this fake node.\n\n const raw = this.extractNodeFromValue(id)\n const label = this.enhancedNormalizer(raw).label || `${id} (unknown)`\n const fallbackNode = {\n id,\n label,\n ancestors: [],\n parentNode: NO_PARENT_NODE,\n isFallbackNode: true,\n isRootNode: true,\n isLeaf: true,\n isBranch: false,\n isDisabled: false,\n isNew: false,\n index: [ -1 ],\n level: 0,\n raw,\n }\n\n return this.$set(this.forest.nodeMap, id, fallbackNode)\n },\n\n extractCheckedNodeIdsFromValue() {\n if (this.value == null) return []\n\n if (this.valueFormat === 'id') {\n return this.multiple\n ? this.value.slice()\n : [ this.value ]\n }\n\n return (this.multiple ? this.value : [ this.value ])\n .map(node => this.enhancedNormalizer(node))\n .map(node => node.id)\n },\n\n extractNodeFromValue(id) {\n const defaultNode = { id }\n\n if (this.valueFormat === 'id') {\n return defaultNode\n }\n\n const valueArray = this.multiple\n ? Array.isArray(this.value) ? this.value : []\n : this.value ? [ this.value ] : []\n const matched = find(\n valueArray,\n node => node && this.enhancedNormalizer(node).id === id,\n )\n\n return matched || defaultNode\n },\n\n fixSelectedNodeIds(nodeIdListOfPrevValue) {\n let nextSelectedNodeIds = []\n\n // istanbul ignore else\n if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) {\n nextSelectedNodeIds = nodeIdListOfPrevValue\n } else if (this.valueConsistsOf === BRANCH_PRIORITY) {\n nodeIdListOfPrevValue.forEach(nodeId => {\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n nextSelectedNodeIds.push(descendant.id)\n })\n })\n } else if (this.valueConsistsOf === LEAF_PRIORITY) {\n const map = createMap()\n const queue = nodeIdListOfPrevValue.slice()\n while (queue.length) {\n const nodeId = queue.shift()\n const node = this.getNode(nodeId)\n nextSelectedNodeIds.push(nodeId)\n if (node.isRootNode) continue\n if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length\n if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id)\n }\n } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) {\n const map = createMap()\n const queue = nodeIdListOfPrevValue.filter(nodeId => {\n const node = this.getNode(nodeId)\n return node.isLeaf || node.children.length === 0\n })\n while (queue.length) {\n const nodeId = queue.shift()\n const node = this.getNode(nodeId)\n nextSelectedNodeIds.push(nodeId)\n if (node.isRootNode) continue\n if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length\n if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id)\n }\n }\n\n const hasChanged = quickDiff(this.forest.selectedNodeIds, nextSelectedNodeIds)\n // If `nextSelectedNodeIds` doesn't actually differ from old `selectedNodeIds`,\n // we don't make the assignment to avoid triggering its watchers which may cause\n // unnecessary calculations.\n if (hasChanged) this.forest.selectedNodeIds = nextSelectedNodeIds\n\n this.buildForestState()\n },\n\n keepDataOfSelectedNodes(prevNodeMap) {\n // In case there is any selected node that is not present in the new `options` array.\n // It could be useful for async search mode.\n this.forest.selectedNodeIds.forEach(id => {\n if (!prevNodeMap[id]) return\n const node = {\n ...prevNodeMap[id],\n isFallbackNode: true,\n }\n this.$set(this.forest.nodeMap, id, node)\n })\n },\n\n isSelected(node) {\n // whether a node is selected (single-select mode) or fully-checked (multi-select mode)\n return this.forest.selectedNodeMap[node.id] === true\n },\n\n traverseDescendantsBFS(parentNode, callback) {\n // istanbul ignore if\n if (!parentNode.isBranch) return\n const queue = parentNode.children.slice()\n while (queue.length) {\n const currNode = queue[0]\n if (currNode.isBranch) queue.push(...currNode.children)\n callback(currNode)\n queue.shift()\n }\n },\n\n traverseDescendantsDFS(parentNode, callback) {\n if (!parentNode.isBranch) return\n parentNode.children.forEach(child => {\n // deep-level node first\n this.traverseDescendantsDFS(child, callback)\n callback(child)\n })\n },\n\n traverseAllNodesDFS(callback) {\n this.forest.normalizedOptions.forEach(rootNode => {\n // deep-level node first\n this.traverseDescendantsDFS(rootNode, callback)\n callback(rootNode)\n })\n },\n\n traverseAllNodesByIndex(callback) {\n const walk = parentNode => {\n parentNode.children.forEach(child => {\n if (callback(child) !== false && child.isBranch) {\n walk(child)\n }\n })\n }\n\n // To simplify the code logic of traversal,\n // we create a fake root node that holds all the root options.\n walk({ children: this.forest.normalizedOptions })\n },\n\n toggleClickOutsideEvent(enabled) {\n if (enabled) {\n document.addEventListener('mousedown', this.handleClickOutside, false)\n } else {\n document.removeEventListener('mousedown', this.handleClickOutside, false)\n }\n },\n\n getValueContainer() {\n return this.$refs.control.$refs['value-container']\n },\n\n getInput() {\n return this.getValueContainer().$refs.input\n },\n\n focusInput() {\n this.getInput().focus()\n },\n\n blurInput() {\n this.getInput().blur()\n },\n\n handleMouseDown: onLeftClick(function handleMouseDown(evt) {\n evt.preventDefault()\n evt.stopPropagation()\n\n if (this.disabled) return\n\n const isClickedOnValueContainer = this.getValueContainer().$el.contains(evt.target)\n if (isClickedOnValueContainer && !this.menu.isOpen && (this.openOnClick || this.trigger.isFocused)) {\n this.openMenu()\n }\n\n if (this._blurOnSelect) {\n this.blurInput()\n } else {\n // Focus the input or prevent blurring.\n this.focusInput()\n }\n\n this.resetFlags()\n }),\n\n handleClickOutside(evt) {\n // istanbul ignore else\n if (this.$refs.wrapper && !this.$refs.wrapper.contains(evt.target)) {\n this.blurInput()\n this.closeMenu()\n }\n },\n\n handleLocalSearch() {\n const { searchQuery } = this.trigger\n const done = () => this.resetHighlightedOptionWhenNecessary(true)\n\n if (!searchQuery) {\n // Exit sync search mode.\n this.localSearch.active = false\n return done()\n }\n\n // Enter sync search mode.\n this.localSearch.active = true\n\n // Reset states.\n this.localSearch.noResults = true\n this.traverseAllNodesDFS(node => {\n if (node.isBranch) {\n node.isExpandedOnSearch = false\n node.showAllChildrenOnSearch = false\n node.isMatched = false\n node.hasMatchedDescendants = false\n this.$set(this.localSearch.countMap, node.id, {\n [ALL_CHILDREN]: 0,\n [ALL_DESCENDANTS]: 0,\n [LEAF_CHILDREN]: 0,\n [LEAF_DESCENDANTS]: 0,\n })\n }\n })\n\n const lowerCasedSearchQuery = removeAccents(searchQuery).trim().toLocaleLowerCase()\n const splitSearchQuery = lowerCasedSearchQuery.replace(/\\s+/g, ' ').split(' ')\n this.traverseAllNodesDFS(node => {\n if (this.searchNested && splitSearchQuery.length > 1) {\n node.isMatched = splitSearchQuery.every(filterValue =>\n match(false, filterValue, node.nestedSearchLabel),\n )\n } else {\n node.isMatched = this.matchKeys.some(matchKey =>\n match(!this.disableFuzzyMatching, lowerCasedSearchQuery, node.lowerCased[matchKey]),\n )\n }\n\n if (node.isMatched) {\n this.localSearch.noResults = false\n node.ancestors.forEach(ancestor => this.localSearch.countMap[ancestor.id][ALL_DESCENDANTS]++)\n if (node.isLeaf) node.ancestors.forEach(ancestor => this.localSearch.countMap[ancestor.id][LEAF_DESCENDANTS]++)\n if (node.parentNode !== NO_PARENT_NODE) {\n this.localSearch.countMap[node.parentNode.id][ALL_CHILDREN] += 1\n // istanbul ignore else\n if (node.isLeaf) this.localSearch.countMap[node.parentNode.id][LEAF_CHILDREN] += 1\n }\n }\n\n if (\n (node.isMatched || (node.isBranch && node.isExpandedOnSearch)) &&\n node.parentNode !== NO_PARENT_NODE\n ) {\n node.parentNode.isExpandedOnSearch = true\n node.parentNode.hasMatchedDescendants = true\n }\n })\n\n done()\n },\n\n handleRemoteSearch() {\n const { searchQuery } = this.trigger\n const entry = this.getRemoteSearchEntry()\n const done = () => {\n this.initialize()\n this.resetHighlightedOptionWhenNecessary(true)\n }\n\n if ((searchQuery === '' || this.cacheOptions) && entry.isLoaded) {\n return done()\n }\n\n this.callLoadOptionsProp({\n action: ASYNC_SEARCH,\n args: { searchQuery },\n isPending() {\n return entry.isLoading\n },\n start: () => {\n entry.isLoading = true\n entry.isLoaded = false\n entry.loadingError = ''\n },\n succeed: options => {\n entry.isLoaded = true\n entry.options = options\n // When the request completes, the search query may have changed.\n // We only show these options if they are for the current search query.\n if (this.trigger.searchQuery === searchQuery) done()\n },\n fail: err => {\n entry.loadingError = getErrorMessage(err)\n },\n end: () => {\n entry.isLoading = false\n },\n })\n },\n\n getRemoteSearchEntry() {\n const { searchQuery } = this.trigger\n const entry = this.remoteSearch[searchQuery] || {\n ...createAsyncOptionsStates(),\n options: [],\n }\n\n // Vue doesn't support directly watching on objects.\n this.$watch(\n () => entry.options,\n () => {\n // TODO: potential redundant re-initialization.\n if (this.trigger.searchQuery === searchQuery) this.initialize()\n },\n { deep: true },\n )\n\n if (searchQuery === '') {\n if (Array.isArray(this.defaultOptions)) {\n entry.options = this.defaultOptions\n entry.isLoaded = true\n return entry\n } else if (this.defaultOptions !== true) {\n entry.isLoaded = true\n return entry\n }\n }\n\n if (!this.remoteSearch[searchQuery]) {\n this.$set(this.remoteSearch, searchQuery, entry)\n }\n\n return entry\n },\n\n shouldExpand(node) {\n return this.localSearch.active ? node.isExpandedOnSearch : node.isExpanded\n },\n\n shouldOptionBeIncludedInSearchResult(node) {\n // 1) This option is matched.\n if (node.isMatched) return true\n // 2) This option is not matched, but has matched descendant(s).\n if (node.isBranch && node.hasMatchedDescendants && !this.flattenSearchResults) return true\n // 3) This option's parent has no matched descendants,\n // but after being expanded, all its children should be shown.\n if (!node.isRootNode && node.parentNode.showAllChildrenOnSearch) return true\n // 4) The default case.\n return false\n },\n\n shouldShowOptionInMenu(node) {\n if (this.localSearch.active && !this.shouldOptionBeIncludedInSearchResult(node)) {\n return false\n }\n return true\n },\n\n getControl() {\n return this.$refs.control.$el\n },\n\n getMenu() {\n const ref = this.appendToBody ? this.$refs.portal.portalTarget : this\n const $menu = ref.$refs.menu.$refs.menu\n return $menu && $menu.nodeName !== '#comment' ? $menu : null\n },\n\n setCurrentHighlightedOption(node, scroll = true) {\n const prev = this.menu.current\n if (prev != null && prev in this.forest.nodeMap) {\n this.forest.nodeMap[prev].isHighlighted = false\n }\n\n this.menu.current = node.id\n node.isHighlighted = true\n\n if (this.menu.isOpen && scroll) {\n const scrollToOption = () => {\n const $menu = this.getMenu()\n const $option = $menu.querySelector(`.vue-treeselect__option[data-id=\"${node.id}\"]`)\n if ($option) scrollIntoView($menu, $option)\n }\n\n // In case `openMenu()` is just called and the menu is not rendered yet.\n if (this.getMenu()) {\n scrollToOption()\n } else {\n // istanbul ignore next\n this.$nextTick(scrollToOption)\n }\n }\n },\n\n resetHighlightedOptionWhenNecessary(forceReset = false) {\n const { current } = this.menu\n\n if (\n forceReset || current == null ||\n !(current in this.forest.nodeMap) ||\n !this.shouldShowOptionInMenu(this.getNode(current))\n ) {\n this.highlightFirstOption()\n }\n },\n\n highlightFirstOption() {\n if (!this.hasVisibleOptions) return\n\n const first = this.visibleOptionIds[0]\n this.setCurrentHighlightedOption(this.getNode(first))\n },\n\n highlightPrevOption() {\n if (!this.hasVisibleOptions) return\n\n const prev = this.visibleOptionIds.indexOf(this.menu.current) - 1\n if (prev === -1) return this.highlightLastOption()\n this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[prev]))\n },\n\n highlightNextOption() {\n if (!this.hasVisibleOptions) return\n\n const next = this.visibleOptionIds.indexOf(this.menu.current) + 1\n if (next === this.visibleOptionIds.length) return this.highlightFirstOption()\n this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[next]))\n },\n\n highlightLastOption() {\n if (!this.hasVisibleOptions) return\n\n const last = getLast(this.visibleOptionIds)\n this.setCurrentHighlightedOption(this.getNode(last))\n },\n\n resetSearchQuery() {\n this.trigger.searchQuery = ''\n },\n\n closeMenu() {\n if (!this.menu.isOpen || (!this.disabled && this.alwaysOpen)) return\n this.saveMenuScrollPosition()\n this.menu.isOpen = false\n this.toggleClickOutsideEvent(false)\n this.resetSearchQuery()\n this.$emit('close', this.getValue(), this.getInstanceId())\n },\n\n openMenu() {\n if (this.disabled || this.menu.isOpen) return\n this.menu.isOpen = true\n this.$nextTick(this.resetHighlightedOptionWhenNecessary)\n this.$nextTick(this.restoreMenuScrollPosition)\n if (!this.options && !this.async) this.loadRootOptions()\n this.toggleClickOutsideEvent(true)\n this.$emit('open', this.getInstanceId())\n },\n\n toggleMenu() {\n if (this.menu.isOpen) {\n this.closeMenu()\n } else {\n this.openMenu()\n }\n },\n\n toggleExpanded(node) {\n let nextState\n\n if (this.localSearch.active) {\n nextState = node.isExpandedOnSearch = !node.isExpandedOnSearch\n if (nextState) node.showAllChildrenOnSearch = true\n } else {\n nextState = node.isExpanded = !node.isExpanded\n }\n\n if (nextState && !node.childrenStates.isLoaded) {\n this.loadChildrenOptions(node)\n }\n },\n\n buildForestState() {\n const selectedNodeMap = createMap()\n this.forest.selectedNodeIds.forEach(selectedNodeId => {\n selectedNodeMap[selectedNodeId] = true\n })\n this.forest.selectedNodeMap = selectedNodeMap\n\n const checkedStateMap = createMap()\n if (this.multiple) {\n this.traverseAllNodesByIndex(node => {\n checkedStateMap[node.id] = UNCHECKED\n })\n\n this.selectedNodes.forEach(selectedNode => {\n checkedStateMap[selectedNode.id] = CHECKED\n\n if (!this.flat && !this.disableBranchNodes) {\n selectedNode.ancestors.forEach(ancestorNode => {\n if (!this.isSelected(ancestorNode)) {\n checkedStateMap[ancestorNode.id] = INDETERMINATE\n }\n })\n }\n })\n }\n this.forest.checkedStateMap = checkedStateMap\n },\n\n enhancedNormalizer(raw) {\n return {\n ...raw,\n ...this.normalizer(raw, this.getInstanceId()),\n }\n },\n\n normalize(parentNode, nodes, prevNodeMap) {\n let normalizedOptions = nodes\n .map(node => [ this.enhancedNormalizer(node), node ])\n .map(([ node, raw ], index) => {\n this.checkDuplication(node)\n this.verifyNodeShape(node)\n\n const { id, label, children, isDefaultExpanded } = node\n const isRootNode = parentNode === NO_PARENT_NODE\n const level = isRootNode ? 0 : parentNode.level + 1\n const isBranch = Array.isArray(children) || children === null\n const isLeaf = !isBranch\n const isDisabled = !!node.isDisabled || (!this.flat && !isRootNode && parentNode.isDisabled)\n const isNew = !!node.isNew\n const lowerCased = this.matchKeys.reduce((prev, key) => ({\n ...prev,\n [key]: stringifyOptionPropValue(node[key]).toLocaleLowerCase(),\n }), {})\n const nestedSearchLabel = isRootNode\n ? lowerCased.label\n : parentNode.nestedSearchLabel + ' ' + lowerCased.label\n\n const normalized = this.$set(this.forest.nodeMap, id, createMap())\n this.$set(normalized, 'id', id)\n this.$set(normalized, 'label', label)\n this.$set(normalized, 'level', level)\n this.$set(normalized, 'ancestors', isRootNode ? [] : [ parentNode ].concat(parentNode.ancestors))\n this.$set(normalized, 'index', (isRootNode ? [] : parentNode.index).concat(index))\n this.$set(normalized, 'parentNode', parentNode)\n this.$set(normalized, 'lowerCased', lowerCased)\n this.$set(normalized, 'nestedSearchLabel', nestedSearchLabel)\n this.$set(normalized, 'isDisabled', isDisabled)\n this.$set(normalized, 'isNew', isNew)\n this.$set(normalized, 'isMatched', false)\n this.$set(normalized, 'isHighlighted', false)\n this.$set(normalized, 'isBranch', isBranch)\n this.$set(normalized, 'isLeaf', isLeaf)\n this.$set(normalized, 'isRootNode', isRootNode)\n this.$set(normalized, 'raw', raw)\n\n if (isBranch) {\n const isLoaded = Array.isArray(children)\n\n this.$set(normalized, 'childrenStates', {\n ...createAsyncOptionsStates(),\n isLoaded,\n })\n this.$set(normalized, 'isExpanded', typeof isDefaultExpanded === 'boolean'\n ? isDefaultExpanded\n : level < this.defaultExpandLevel)\n this.$set(normalized, 'hasMatchedDescendants', false)\n this.$set(normalized, 'hasDisabledDescendants', false)\n this.$set(normalized, 'isExpandedOnSearch', false)\n this.$set(normalized, 'showAllChildrenOnSearch', false)\n this.$set(normalized, 'count', {\n [ALL_CHILDREN]: 0,\n [ALL_DESCENDANTS]: 0,\n [LEAF_CHILDREN]: 0,\n [LEAF_DESCENDANTS]: 0,\n })\n this.$set(normalized, 'children', isLoaded\n ? this.normalize(normalized, children, prevNodeMap)\n : [])\n\n if (isDefaultExpanded === true) normalized.ancestors.forEach(ancestor => {\n ancestor.isExpanded = true\n })\n\n if (!isLoaded && typeof this.loadOptions !== 'function') {\n warning(\n () => false,\n () => 'Unloaded branch node detected. \"loadOptions\" prop is required to load its children.',\n )\n } else if (!isLoaded && normalized.isExpanded) {\n this.loadChildrenOptions(normalized)\n }\n }\n\n normalized.ancestors.forEach(ancestor => ancestor.count[ALL_DESCENDANTS]++)\n if (isLeaf) normalized.ancestors.forEach(ancestor => ancestor.count[LEAF_DESCENDANTS]++)\n if (!isRootNode) {\n parentNode.count[ALL_CHILDREN] += 1\n if (isLeaf) parentNode.count[LEAF_CHILDREN] += 1\n if (isDisabled) parentNode.hasDisabledDescendants = true\n }\n\n // Preserve previous states.\n if (prevNodeMap && prevNodeMap[id]) {\n const prev = prevNodeMap[id]\n\n normalized.isMatched = prev.isMatched\n normalized.showAllChildrenOnSearch = prev.showAllChildrenOnSearch\n normalized.isHighlighted = prev.isHighlighted\n\n if (prev.isBranch && normalized.isBranch) {\n normalized.isExpanded = prev.isExpanded\n normalized.isExpandedOnSearch = prev.isExpandedOnSearch\n // #97\n // If `isLoaded` was true, but IS NOT now, we consider this branch node\n // to be reset to unloaded state by the user of this component.\n if (prev.childrenStates.isLoaded && !normalized.childrenStates.isLoaded) {\n // Make sure the node is collapsed, then the user can load its\n // children again (by expanding).\n normalized.isExpanded = false\n // We have reset `childrenStates` and don't want to preserve states here.\n } else {\n normalized.childrenStates = { ...prev.childrenStates }\n }\n }\n }\n\n return normalized\n })\n\n if (this.branchNodesFirst) {\n const branchNodes = normalizedOptions.filter(option => option.isBranch)\n const leafNodes = normalizedOptions.filter(option => option.isLeaf)\n normalizedOptions = branchNodes.concat(leafNodes)\n }\n\n return normalizedOptions\n },\n\n loadRootOptions() {\n this.callLoadOptionsProp({\n action: LOAD_ROOT_OPTIONS,\n isPending: () => {\n return this.rootOptionsStates.isLoading\n },\n start: () => {\n this.rootOptionsStates.isLoading = true\n this.rootOptionsStates.loadingError = ''\n },\n succeed: () => {\n this.rootOptionsStates.isLoaded = true\n // Wait for `options` being re-initialized.\n this.$nextTick(() => {\n this.resetHighlightedOptionWhenNecessary(true)\n })\n },\n fail: err => {\n this.rootOptionsStates.loadingError = getErrorMessage(err)\n },\n end: () => {\n this.rootOptionsStates.isLoading = false\n },\n })\n },\n\n loadChildrenOptions(parentNode) {\n // The options may be re-initialized anytime during the loading process.\n // So `parentNode` can be stale and we use `getNode()` to avoid that.\n\n const { id, raw } = parentNode\n\n this.callLoadOptionsProp({\n action: LOAD_CHILDREN_OPTIONS,\n args: {\n // We always pass the raw node instead of the normalized node to any\n // callback provided by the user of this component.\n // Because the shape of the raw node is more likely to be closing to\n // what the back-end API service of the application needs.\n parentNode: raw,\n },\n isPending: () => {\n return this.getNode(id).childrenStates.isLoading\n },\n start: () => {\n this.getNode(id).childrenStates.isLoading = true\n this.getNode(id).childrenStates.loadingError = ''\n },\n succeed: () => {\n this.getNode(id).childrenStates.isLoaded = true\n },\n fail: err => {\n this.getNode(id).childrenStates.loadingError = getErrorMessage(err)\n },\n end: () => {\n this.getNode(id).childrenStates.isLoading = false\n },\n })\n },\n\n callLoadOptionsProp({ action, args, isPending, start, succeed, fail, end }) {\n if (!this.loadOptions || isPending()) {\n return\n }\n\n start()\n\n const callback = once((err, result) => {\n if (err) {\n fail(err)\n } else {\n succeed(result)\n }\n\n end()\n })\n const result = this.loadOptions({\n id: this.getInstanceId(),\n instanceId: this.getInstanceId(),\n action,\n ...args,\n callback,\n })\n\n if (isPromise(result)) {\n result.then(() => {\n callback()\n }, err => {\n callback(err)\n }).catch(err => {\n // istanbul ignore next\n console.error(err)\n })\n }\n },\n\n checkDuplication(node) {\n warning(\n () => !((node.id in this.forest.nodeMap) && !this.forest.nodeMap[node.id].isFallbackNode),\n () => `Detected duplicate presence of node id ${JSON.stringify(node.id)}. ` +\n `Their labels are \"${this.forest.nodeMap[node.id].label}\" and \"${node.label}\" respectively.`,\n )\n },\n\n verifyNodeShape(node) {\n warning(\n () => !(node.children === undefined && node.isBranch === true),\n () => 'Are you meant to declare an unloaded branch node? ' +\n '`isBranch: true` is no longer supported, please use `children: null` instead.',\n )\n },\n\n select(node) {\n if (this.disabled || node.isDisabled) {\n return\n }\n\n if (this.single) {\n this.clear()\n }\n\n const nextState = this.multiple && !this.flat\n ? this.forest.checkedStateMap[node.id] === UNCHECKED\n : !this.isSelected(node)\n\n if (nextState) {\n this._selectNode(node)\n } else {\n this._deselectNode(node)\n }\n\n this.buildForestState()\n\n if (nextState) {\n this.$emit('select', node.raw, this.getInstanceId())\n } else {\n this.$emit('deselect', node.raw, this.getInstanceId())\n }\n\n if (this.localSearch.active && nextState && (this.single || this.clearOnSelect)) {\n this.resetSearchQuery()\n }\n\n if (this.single && this.closeOnSelect) {\n this.closeMenu()\n\n // istanbul ignore else\n if (this.searchable) {\n this._blurOnSelect = true\n }\n }\n },\n\n clear() {\n if (this.hasValue) {\n if (this.single || this.allowClearingDisabled) {\n this.forest.selectedNodeIds = []\n } else /* if (this.multiple && !this.allowClearingDisabled) */ {\n this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(nodeId =>\n this.getNode(nodeId).isDisabled,\n )\n }\n\n this.buildForestState()\n }\n },\n\n // This is meant to be called only by `select()`.\n _selectNode(node) {\n node.hasBeenSelected = node.id\n if (this.single || this.disableBranchNodes) {\n return this.addValue(node)\n }\n\n if (this.flat) {\n this.addValue(node)\n\n if (this.autoSelectAncestors) {\n node.ancestors.forEach(ancestor => {\n if (!this.isSelected(ancestor) && !ancestor.isDisabled) this.addValue(ancestor)\n })\n } else if (this.autoSelectDescendants) {\n this.traverseDescendantsBFS(node, descendant => {\n if (!this.isSelected(descendant) && !descendant.isDisabled) this.addValue(descendant)\n })\n }\n\n return\n }\n\n const isFullyChecked = (\n node.isLeaf ||\n (/* node.isBranch && */!node.hasDisabledDescendants) ||\n (/* node.isBranch && */this.allowSelectingDisabledDescendants)\n )\n if (isFullyChecked) {\n this.addValue(node)\n }\n\n if (node.isBranch) {\n this.traverseDescendantsBFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n this.addValue(descendant)\n }\n })\n }\n\n if (isFullyChecked) {\n let curr = node\n while ((curr = curr.parentNode) !== NO_PARENT_NODE) {\n if (curr.children.every(this.isSelected)) this.addValue(curr)\n else break\n }\n }\n },\n\n // This is meant to be called only by `select()`.\n _deselectNode(node) {\n if (this.disableBranchNodes) {\n return this.removeValue(node)\n }\n\n if (this.flat) {\n this.removeValue(node)\n\n if (this.autoDeselectAncestors) {\n node.ancestors.forEach(ancestor => {\n if (this.isSelected(ancestor) && !ancestor.isDisabled) this.removeValue(ancestor)\n })\n } else if (this.autoDeselectDescendants) {\n this.traverseDescendantsBFS(node, descendant => {\n if (this.isSelected(descendant) && !descendant.isDisabled) this.removeValue(descendant)\n })\n }\n\n return\n }\n\n let hasUncheckedSomeDescendants = false\n if (node.isBranch) {\n this.traverseDescendantsDFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n this.removeValue(descendant)\n hasUncheckedSomeDescendants = true\n }\n })\n }\n\n if (\n node.isLeaf ||\n /* node.isBranch && */hasUncheckedSomeDescendants ||\n /* node.isBranch && */node.children.length === 0\n ) {\n this.removeValue(node)\n\n let curr = node\n while ((curr = curr.parentNode) !== NO_PARENT_NODE) {\n if (this.isSelected(curr)) this.removeValue(curr)\n else break\n }\n }\n },\n\n addValue(node) {\n this.forest.selectedNodeIds.push(node.id)\n this.forest.selectedNodeMap[node.id] = true\n },\n\n removeValue(node) {\n delete node.hasBeenSelected\n removeFromArray(this.forest.selectedNodeIds, node.id)\n delete this.forest.selectedNodeMap[node.id]\n },\n\n removeLastValue() {\n if (!this.hasValue) return\n if (this.single) return this.clear()\n const lastValue = getLast(this.internalValue)\n const lastSelectedNode = this.getNode(lastValue)\n this.select(lastSelectedNode) // deselect\n },\n\n saveMenuScrollPosition() {\n const $menu = this.getMenu()\n // istanbul ignore else\n if ($menu) this.menu.lastScrollPosition = $menu.scrollTop\n },\n\n restoreMenuScrollPosition() {\n const $menu = this.getMenu()\n // istanbul ignore else\n if ($menu) $menu.scrollTop = this.menu.lastScrollPosition\n },\n },\n\n created() {\n this.verifyProps()\n this.resetFlags()\n },\n\n mounted() {\n if (this.autoFocus) this.focusInput()\n if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions()\n if (this.alwaysOpen) this.openMenu()\n if (this.async && this.defaultOptions) this.handleRemoteSearch()\n },\n\n destroyed() {\n // istanbul ignore next\n this.toggleClickOutsideEvent(false)\n },\n}\n","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./HiddenFields.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./HiddenFields.vue?vue&type=script&lang=js&\"","/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nexport default function normalizeComponent (\n scriptExports,\n render,\n staticRenderFns,\n functionalTemplate,\n injectStyles,\n scopeId,\n moduleIdentifier, /* server only */\n shadowMode /* vue-cli only */\n) {\n // Vue.extend constructor export interop\n var options = typeof scriptExports === 'function'\n ? scriptExports.options\n : scriptExports\n\n // render functions\n if (render) {\n options.render = render\n options.staticRenderFns = staticRenderFns\n options._compiled = true\n }\n\n // functional template\n if (functionalTemplate) {\n options.functional = true\n }\n\n // scopedId\n if (scopeId) {\n options._scopeId = 'data-v-' + scopeId\n }\n\n var hook\n if (moduleIdentifier) { // server build\n hook = function (context) {\n // 2.3 injection\n context =\n context || // cached call\n (this.$vnode && this.$vnode.ssrContext) || // stateful\n (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n // 2.2 with runInNewContext: true\n if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n context = __VUE_SSR_CONTEXT__\n }\n // inject component styles\n if (injectStyles) {\n injectStyles.call(this, context)\n }\n // register component module identifier for async chunk inferrence\n if (context && context._registeredComponents) {\n context._registeredComponents.add(moduleIdentifier)\n }\n }\n // used by ssr in case component is cached and beforeCreate\n // never gets called\n options._ssrRegister = hook\n } else if (injectStyles) {\n hook = shadowMode\n ? function () {\n injectStyles.call(\n this,\n (options.functional ? this.parent : this).$root.$options.shadowRoot\n )\n }\n : injectStyles\n }\n\n if (hook) {\n if (options.functional) {\n // for template-only hot-reload because in that case the render fn doesn't\n // go through the normalizer\n options._injectStyles = hook\n // register for functional component in vue file\n var originalRender = options.render\n options.render = function renderWithStyleInjection (h, context) {\n hook.call(context)\n return originalRender(h, context)\n }\n } else {\n // inject component registration as beforeCreate hook\n var existing = options.beforeCreate\n options.beforeCreate = existing\n ? [].concat(existing, hook)\n : [hook]\n }\n }\n\n return {\n exports: scriptExports,\n options: options\n }\n}\n","var render, staticRenderFns\nimport script from \"./HiddenFields.vue?vue&type=script&lang=js&\"\nexport * from \"./HiddenFields.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('4d48089a')) {\n api.createRecord('4d48089a', component.options)\n } else {\n api.reload('4d48089a', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/HiddenFields.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Input.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Input.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Input.vue?vue&type=script&lang=js&\"\nexport * from \"./Input.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('54844eca')) {\n api.createRecord('54844eca', component.options)\n } else {\n api.reload('54844eca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Input.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Placeholder.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Placeholder.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Placeholder.vue?vue&type=script&lang=js&\"\nexport * from \"./Placeholder.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('5a99d1f3')) {\n api.createRecord('5a99d1f3', component.options)\n } else {\n api.reload('5a99d1f3', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Placeholder.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SingleValue.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./SingleValue.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./SingleValue.vue?vue&type=script&lang=js&\"\nexport * from \"./SingleValue.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('03d19b89')) {\n api.createRecord('03d19b89', component.options)\n } else {\n api.reload('03d19b89', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/SingleValue.vue\"\nexport default component.exports","var render = function () {\n var _vm = this\n var _h = _vm.$createElement\n var _c = _vm._self._c || _h\n return _c(\n \"svg\",\n {\n attrs: {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 348.333 348.333\",\n },\n },\n [\n _c(\"path\", {\n attrs: {\n d: \"M336.559 68.611L231.016 174.165l105.543 105.549c15.699 15.705 15.699 41.145 0 56.85-7.844 7.844-18.128 11.769-28.407 11.769-10.296 0-20.581-3.919-28.419-11.769L174.167 231.003 68.609 336.563c-7.843 7.844-18.128 11.769-28.416 11.769-10.285 0-20.563-3.919-28.413-11.769-15.699-15.698-15.699-41.139 0-56.85l105.54-105.549L11.774 68.611c-15.699-15.699-15.699-41.145 0-56.844 15.696-15.687 41.127-15.687 56.829 0l105.563 105.554L279.721 11.767c15.705-15.687 41.139-15.687 56.832 0 15.705 15.699 15.705 41.145.006 56.844z\",\n },\n }),\n ]\n )\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\nexport { render, staticRenderFns }","\n\n\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Delete.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Delete.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Delete.vue?vue&type=template&id=364b6320&\"\nimport script from \"./Delete.vue?vue&type=script&lang=js&\"\nexport * from \"./Delete.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('364b6320')) {\n api.createRecord('364b6320', component.options)\n } else {\n api.reload('364b6320', component.options)\n }\n module.hot.accept(\"./Delete.vue?vue&type=template&id=364b6320&\", function () {\n api.rerender('364b6320', {\n render: render,\n staticRenderFns: staticRenderFns\n })\n })\n }\n}\ncomponent.options.__file = \"src/components/icons/Delete.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MultiValueItem.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MultiValueItem.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./MultiValueItem.vue?vue&type=script&lang=js&\"\nexport * from \"./MultiValueItem.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('6dd6c8ca')) {\n api.createRecord('6dd6c8ca', component.options)\n } else {\n api.reload('6dd6c8ca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MultiValueItem.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MultiValue.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MultiValue.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./MultiValue.vue?vue&type=script&lang=js&\"\nexport * from \"./MultiValue.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('14fca5e8')) {\n api.createRecord('14fca5e8', component.options)\n } else {\n api.reload('14fca5e8', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MultiValue.vue\"\nexport default component.exports","var render = function () {\n var _vm = this\n var _h = _vm.$createElement\n var _c = _vm._self._c || _h\n return _c(\n \"svg\",\n {\n attrs: {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 292.362 292.362\",\n },\n },\n [\n _c(\"path\", {\n attrs: {\n d: \"M286.935 69.377c-3.614-3.617-7.898-5.424-12.848-5.424H18.274c-4.952 0-9.233 1.807-12.85 5.424C1.807 72.998 0 77.279 0 82.228c0 4.948 1.807 9.229 5.424 12.847l127.907 127.907c3.621 3.617 7.902 5.428 12.85 5.428s9.233-1.811 12.847-5.428L286.935 95.074c3.613-3.617 5.427-7.898 5.427-12.847 0-4.948-1.814-9.229-5.427-12.85z\",\n },\n }),\n ]\n )\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\nexport { render, staticRenderFns }","\n\n\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Arrow.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Arrow.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Arrow.vue?vue&type=template&id=11186cd4&\"\nimport script from \"./Arrow.vue?vue&type=script&lang=js&\"\nexport * from \"./Arrow.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('11186cd4')) {\n api.createRecord('11186cd4', component.options)\n } else {\n api.reload('11186cd4', component.options)\n }\n module.hot.accept(\"./Arrow.vue?vue&type=template&id=11186cd4&\", function () {\n api.rerender('11186cd4', {\n render: render,\n staticRenderFns: staticRenderFns\n })\n })\n }\n}\ncomponent.options.__file = \"src/components/icons/Arrow.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Control.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Control.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Control.vue?vue&type=script&lang=js&\"\nexport * from \"./Control.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('2fa0a0dd')) {\n api.createRecord('2fa0a0dd', component.options)\n } else {\n api.reload('2fa0a0dd', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Control.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Tip.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Tip.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Tip.vue?vue&type=script&lang=js&\"\nexport * from \"./Tip.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('9f31bdca')) {\n api.createRecord('9f31bdca', component.options)\n } else {\n api.reload('9f31bdca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Tip.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Option.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Option.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Option.vue?vue&type=script&lang=js&\"\nexport * from \"./Option.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('3dddec25')) {\n api.createRecord('3dddec25', component.options)\n } else {\n api.reload('3dddec25', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Option.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Menu.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Menu.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Menu.vue?vue&type=script&lang=js&\"\nexport * from \"./Menu.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('9bcc0be2')) {\n api.createRecord('9bcc0be2', component.options)\n } else {\n api.reload('9bcc0be2', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Menu.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MenuPortal.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./MenuPortal.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./MenuPortal.vue?vue&type=script&lang=js&\"\nexport * from \"./MenuPortal.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('4802d94a')) {\n api.createRecord('4802d94a', component.options)\n } else {\n api.reload('4802d94a', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MenuPortal.vue\"\nexport default component.exports","\n","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Treeselect.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Treeselect.vue?vue&type=script&lang=js&\"","var render, staticRenderFns\nimport script from \"./Treeselect.vue?vue&type=script&lang=js&\"\nexport * from \"./Treeselect.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('aebf116c')) {\n api.createRecord('aebf116c', component.options)\n } else {\n api.reload('aebf116c', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Treeselect.vue\"\nexport default component.exports","import Treeselect from './components/Treeselect'\nimport treeselectMixin from './mixins/treeselectMixin'\nimport './style.less'\n\nexport default Treeselect\nexport { Treeselect, treeselectMixin }\nexport {\n // Delayed loading.\n LOAD_ROOT_OPTIONS,\n LOAD_CHILDREN_OPTIONS,\n ASYNC_SEARCH,\n} from './constants'\n\nexport const VERSION = PKG_VERSION\n"],"sourceRoot":""} \ No newline at end of file diff --git a/dist/vue-treeselect.umd.min.js b/dist/vue-treeselect.umd.min.js new file mode 100644 index 00000000..4fb7b16c --- /dev/null +++ b/dist/vue-treeselect.umd.min.js @@ -0,0 +1,7 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2022 Riophae Lee + * Released under the MIT License. + * https://vue-treeselect.js.org/ + */ +!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(require("Vue")):"function"==typeof define&&define.amd?define(["Vue"],t):"object"==typeof exports?exports.VueTreeselect=t(require("Vue")):e.VueTreeselect=t(e.Vue)}(window,(function(e){return function(e){var t={};function n(i){if(t[i])return t[i].exports;var r=t[i]={i:i,l:!1,exports:{}};return e[i].call(r.exports,r,r.exports,n),r.l=!0,r.exports}return n.m=e,n.c=t,n.d=function(e,t,i){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:i})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var i=Object.create(null);if(n.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var r in e)n.d(i,r,function(t){return e[t]}.bind(null,r));return i},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="/",n(n.s=40)}([function(e,t){e.exports=function(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e},e.exports.__esModule=!0,e.exports.default=e.exports},function(e,t){var n=/^(attrs|props|on|nativeOn|class|style|hook)$/;function i(e,t){return function(){e&&e.apply(this,arguments),t&&t.apply(this,arguments)}}e.exports=function(e){return e.reduce((function(e,t){var r,s,o,a,l;for(o in t)if(r=e[o],s=t[o],r&&n.test(o))if("class"===o&&("string"==typeof r&&(l=r,e[o]=r={},r[l]=!0),"string"==typeof s&&(l=s,t[o]=s={},s[l]=!0)),"on"===o||"nativeOn"===o||"hook"===o)for(a in s)r[a]=i(r[a],s[a]);else if(Array.isArray(r))e[o]=r.concat(s);else if(Array.isArray(s))e[o]=[r].concat(s);else for(a in s)r[a]=s[a];else e[o]=t[o];return e}),{})}},function(e,t,n){var i=n(23),r=n(24),s=n(3),o=n(25);e.exports=function(e){return i(e)||r(e)||s(e)||o()},e.exports.__esModule=!0,e.exports.default=e.exports},function(e,t,n){var i=n(4);e.exports=function(e,t){if(e){if("string"==typeof e)return i(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?i(e,t):void 0}},e.exports.__esModule=!0,e.exports.default=e.exports},function(e,t){e.exports=function(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,i=new Array(t);n=t||n<0||m&&e-f>=c}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-p);return m?a(n,c-(e-f)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=u=void 0,d)}function x(){var e=r(),n=b(e);if(l=arguments,u=this,p=e,n){if(void 0===h)return S(p);if(m)return clearTimeout(h),h=setTimeout(O,t),y(p)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,c=(m="maxWait"in n)?o(s(n.maxWait)||0,t):c,g="trailing"in n?!!n.trailing:g),x.cancel=function(){void 0!==h&&clearTimeout(h),f=0,l=p=u=h=void 0},x.flush=function(){return void 0===h?d:_(r())},x}},function(e,t){e.exports=function(e){var t=typeof e;return null!=e&&("object"==t||"function"==t)}},function(e,t,n){var i=n(27),r="object"==typeof self&&self&&self.Object===Object&&self,s=i||r||Function("return this")();e.exports=s},function(e,t,n){var i=n(29),r=n(7),s=n(31),o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,u=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(s(e))return NaN;if(r(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=r(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=i(e);var n=a.test(e);return n||l.test(e)?u(e.slice(2),n?2:8):o.test(e)?NaN:+e}},function(e,t,n){var i=n(8).Symbol;e.exports=i},function(e,t){function n(e){return!!e&&("object"==typeof e||"function"==typeof e)&&"function"==typeof e.then}e.exports=n,e.exports.default=n},function(e,t,n){var i=n(36);e.exports=function(e){return i(2,e)}},function(e,t){e.exports=function(e){return e}},function(e,t){e.exports=function(e){return function(){return e}}},function(e,t){e.exports=function(e){var t=null==e?0:e.length;return t?e[t-1]:void 0}},function(e,t,n){var i=n(20),r=n(21),s=n(3),o=n(22);e.exports=function(e,t){return i(e)||r(e,t)||s(e,t)||o()},e.exports.__esModule=!0,e.exports.default=e.exports},function(e,t,n){"use strict";e.exports=function(e,t){var n=t.length,i=e.length;if(i>n)return!1;if(i===n)return e===t;e:for(var r=0,s=0;r0&&(n=t.apply(this,arguments)),e<=1&&(t=void 0),n}}},function(e,t,n){var i=n(38);e.exports=function(e){var t=i(e),n=t%1;return t==t?n?t-n:t:0}},function(e,t,n){var i=n(9);e.exports=function(e){return e?(e=i(e))===1/0||e===-1/0?17976931348623157e292*(e<0?-1:1):e==e?e:0:0===e?e:0}},function(e,t,n){},function(e,t,n){"use strict";n.r(t),n.d(t,"Treeselect",(function(){return nt})),n.d(t,"treeselectMixin",(function(){return de})),n.d(t,"LOAD_ROOT_OPTIONS",(function(){return Q})),n.d(t,"LOAD_CHILDREN_OPTIONS",(function(){return q})),n.d(t,"ASYNC_SEARCH",(function(){return Y})),n.d(t,"VERSION",(function(){return it}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),u=n(17),c=n.n(u),d=n(5),h=n.n(d).a;function p(e){return function(t){if("mousedown"===t.type&&0===t.button){for(var n=arguments.length,i=new Array(n>1?n-1:0),r=1;rn.bottom?e.scrollTop=Math.min(t.offsetTop+t.clientHeight-e.offsetHeight+r,e.scrollHeight):i.top-r0},single:function(){return!this.multiple},visibleOptionIds:function(){var e=this,t=[];return this.traverseAllNodesByIndex((function(n){if(e.localSearch.active&&!e.shouldOptionBeIncludedInSearchResult(n)||t.push(n.id),n.isBranch&&!e.shouldExpand(n))return!1})),t},hasVisibleOptions:function(){return 0!==this.visibleOptionIds.length},showCountOnSearchComputed:function(){return"boolean"==typeof this.showCountOnSearch?this.showCountOnSearch:this.showCount},hasBranchNodes:function(){return this.forest.normalizedOptions.some((function(e){return e.isBranch}))},shouldFlattenOptions:function(){return this.localSearch.active&&this.flattenSearchResults}},watch:{alwaysOpen:function(e){e?this.openMenu():this.closeMenu()},branchNodesFirst:function(){this.initialize()},disabled:function(e){e&&this.menu.isOpen?this.closeMenu():e||this.menu.isOpen||!this.alwaysOpen||this.openMenu()},flat:function(){this.initialize()},internalValue:function(e,t){W(e,t)&&this.$emit("input",this.getValue(),this.getInstanceId())},matchKeys:function(){this.initialize()},multiple:function(e){e&&this.buildForestState()},options:{handler:function(){this.async||(this.initialize(),this.rootOptionsStates.isLoaded=Array.isArray(this.options))},deep:!0,immediate:!0},"trigger.searchQuery":function(){this.async?this.handleRemoteSearch():this.handleLocalSearch(),this.$emit("search-change",this.trigger.searchQuery,this.getInstanceId())},value:function(){var e=this.extractCheckedNodeIdsFromValue();W(e,this.internalValue)&&this.fixSelectedNodeIds(e)}},methods:{verifyProps:function(){var e=this;if(h((function(){return!e.async||e.searchable}),(function(){return'For async search mode, the value of "searchable" prop must be true.'})),null!=this.options||this.loadOptions||h((function(){return!1}),(function(){return'Are you meant to dynamically load options? You need to use "loadOptions" prop.'})),this.flat&&h((function(){return e.multiple}),(function(){return'You are using flat mode. But you forgot to add "multiple=true"?'})),!this.flat){["autoSelectAncestors","autoSelectDescendants","autoDeselectAncestors","autoDeselectDescendants"].forEach((function(t){h((function(){return!e[t]}),(function(){return'"'.concat(t,'" only applies to flat mode.')}))}))}},resetFlags:function(){this._blurOnSelect=!1},initialize:function(){var e=this.async?this.getRemoteSearchEntry().options:this.options;if(Array.isArray(e)){var t=this.forest.nodeMap;this.forest.nodeMap=B(),this.keepDataOfSelectedNodes(t),this.forest.normalizedOptions=this.normalize(null,e,t),this.fixSelectedNodeIds(this.internalValue)}else this.forest.normalizedOptions=[]},getInstanceId:function(){return null==this.instanceId?this.id:this.instanceId},getValue:function(){var e=this;if("id"===this.valueFormat)return this.multiple?this.getUniqChildValues(this.internalValue.slice()):this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?this.getUniqChildValues(t):t[0]},getUniqChildValues:function(e){var t=this;return"BRANCH_PRIORITY"!==this.valueConsistsOf?e:e.map((function(e){var n=t.getNode(e);if(n.hasBeenSelected)return n.id;if(t.hasOneChild(n)){var i=[];if(t.traverseDescendantsBFS(n,(function(e){e.isDisabled&&!t.allowSelectingDisabledDescendants||e.hasBeenSelected&&i.push(e.id)})),i&&i.length)return i[0]}return e}))},hasOneChild:function(e){return e&&e.children&&1===e.children.length},getNode:function(e){return h((function(){return null!=e}),(function(){return"Invalid node id: ".concat(e)})),null==e?null:e in this.forest.nodeMap?this.forest.nodeMap[e]:this.createFallbackNode(e)},createFallbackNode:function(e){var t=this.extractNodeFromValue(e),n={id:e,label:this.enhancedNormalizer(t).label||"".concat(e," (unknown)"),ancestors:[],parentNode:null,isFallbackNode:!0,isRootNode:!0,isLeaf:!0,isBranch:!1,isDisabled:!1,isNew:!1,index:[-1],level:0,raw:t};return this.$set(this.forest.nodeMap,e,n)},extractCheckedNodeIdsFromValue:function(){var e=this;return null==this.value?[]:"id"===this.valueFormat?this.multiple?this.value.slice():[this.value]:(this.multiple?this.value:[this.value]).map((function(t){return e.enhancedNormalizer(t)})).map((function(e){return e.id}))},extractNodeFromValue:function(e){var t=this,n={id:e};return"id"===this.valueFormat?n:H(this.multiple?Array.isArray(this.value)?this.value:[]:this.value?[this.value]:[],(function(n){return n&&t.enhancedNormalizer(n).id===e}))||n},fixSelectedNodeIds:function(e){var t=this,n=[];if(this.single||this.flat||this.disableBranchNodes||"ALL"===this.valueConsistsOf)n=e;else if("BRANCH_PRIORITY"===this.valueConsistsOf)e.forEach((function(e){n.push(e);var i=t.getNode(e);i.isBranch&&t.traverseDescendantsBFS(i,(function(e){n.push(e.id)}))}));else if("LEAF_PRIORITY"===this.valueConsistsOf)for(var i=B(),r=e.slice();r.length;){var s=r.shift(),o=this.getNode(s);n.push(s),o.isRootNode||(o.parentNode.id in i||(i[o.parentNode.id]=o.parentNode.children.length),0==--i[o.parentNode.id]&&r.push(o.parentNode.id))}else if("ALL_WITH_INDETERMINATE"===this.valueConsistsOf)for(var a=B(),l=e.filter((function(e){var n=t.getNode(e);return n.isLeaf||0===n.children.length}));l.length;){var u=l.shift(),c=this.getNode(u);n.push(u),c.isRootNode||(c.parentNode.id in a||(a[c.parentNode.id]=c.parentNode.children.length),0==--a[c.parentNode.id]&&l.push(c.parentNode.id))}W(this.forest.selectedNodeIds,n)&&(this.forest.selectedNodeIds=n),this.buildForestState()},keepDataOfSelectedNodes:function(e){var t=this;this.forest.selectedNodeIds.forEach((function(n){if(e[n]){var i=se(se({},e[n]),{},{isFallbackNode:!0});t.$set(t.forest.nodeMap,n,i)}}))},isSelected:function(e){return!0===this.forest.selectedNodeMap[e.id]},traverseDescendantsBFS:function(e,t){if(e.isBranch)for(var n=e.children.slice();n.length;){var i=n[0];i.isBranch&&n.push.apply(n,o()(i.children)),t(i),n.shift()}},traverseDescendantsDFS:function(e,t){var n=this;e.isBranch&&e.children.forEach((function(e){n.traverseDescendantsDFS(e,t),t(e)}))},traverseAllNodesDFS:function(e){var t=this;this.forest.normalizedOptions.forEach((function(n){t.traverseDescendantsDFS(n,e),e(n)}))},traverseAllNodesByIndex:function(e){!function t(n){n.children.forEach((function(n){!1!==e(n)&&n.isBranch&&t(n)}))}({children:this.forest.normalizedOptions})},toggleClickOutsideEvent:function(e){e?document.addEventListener("mousedown",this.handleClickOutside,!1):document.removeEventListener("mousedown",this.handleClickOutside,!1)},getValueContainer:function(){return this.$refs.control.$refs["value-container"]},getInput:function(){return this.getValueContainer().$refs.input},focusInput:function(){this.getInput().focus()},blurInput:function(){this.getInput().blur()},handleMouseDown:p((function(e){(e.preventDefault(),e.stopPropagation(),this.disabled)||(this.getValueContainer().$el.contains(e.target)&&!this.menu.isOpen&&(this.openOnClick||this.trigger.isFocused)&&this.openMenu(),this._blurOnSelect?this.blurInput():this.focusInput(),this.resetFlags())})),handleClickOutside:function(e){this.$refs.wrapper&&!this.$refs.wrapper.contains(e.target)&&(this.blurInput(),this.closeMenu())},handleLocalSearch:function(){var e=this,t=this.trigger.searchQuery,n=function(){return e.resetHighlightedOptionWhenNecessary(!0)};if(!t)return this.localSearch.active=!1,n();this.localSearch.active=!0,this.localSearch.noResults=!0,this.traverseAllNodesDFS((function(t){var n;t.isBranch&&(t.isExpandedOnSearch=!1,t.showAllChildrenOnSearch=!1,t.isMatched=!1,t.hasMatchedDescendants=!1,e.$set(e.localSearch.countMap,t.id,(n={},l()(n,"ALL_CHILDREN",0),l()(n,"ALL_DESCENDANTS",0),l()(n,"LEAF_CHILDREN",0),l()(n,"LEAF_DESCENDANTS",0),n)))}));var i=ae(t).trim().toLocaleLowerCase(),r=i.replace(/\s+/g," ").split(" ");this.traverseAllNodesDFS((function(t){e.searchNested&&r.length>1?t.isMatched=r.every((function(e){return le(!1,e,t.nestedSearchLabel)})):t.isMatched=e.matchKeys.some((function(n){return le(!e.disableFuzzyMatching,i,t.lowerCased[n])})),t.isMatched&&(e.localSearch.noResults=!1,t.ancestors.forEach((function(t){return e.localSearch.countMap[t.id].ALL_DESCENDANTS++})),t.isLeaf&&t.ancestors.forEach((function(t){return e.localSearch.countMap[t.id].LEAF_DESCENDANTS++})),null!==t.parentNode&&(e.localSearch.countMap[t.parentNode.id].ALL_CHILDREN+=1,t.isLeaf&&(e.localSearch.countMap[t.parentNode.id].LEAF_CHILDREN+=1))),(t.isMatched||t.isBranch&&t.isExpandedOnSearch)&&null!==t.parentNode&&(t.parentNode.isExpandedOnSearch=!0,t.parentNode.hasMatchedDescendants=!0)})),n()},handleRemoteSearch:function(){var e=this,t=this.trigger.searchQuery,n=this.getRemoteSearchEntry(),i=function(){e.initialize(),e.resetHighlightedOptionWhenNecessary(!0)};if((""===t||this.cacheOptions)&&n.isLoaded)return i();this.callLoadOptionsProp({action:Y,args:{searchQuery:t},isPending:function(){return n.isLoading},start:function(){n.isLoading=!0,n.isLoaded=!1,n.loadingError=""},succeed:function(r){n.isLoaded=!0,n.options=r,e.trigger.searchQuery===t&&i()},fail:function(e){n.loadingError=ue(e)},end:function(){n.isLoading=!1}})},getRemoteSearchEntry:function(){var e=this,t=this.trigger.searchQuery,n=this.remoteSearch[t]||se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{options:[]});if(this.$watch((function(){return n.options}),(function(){e.trigger.searchQuery===t&&e.initialize()}),{deep:!0}),""===t){if(Array.isArray(this.defaultOptions))return n.options=this.defaultOptions,n.isLoaded=!0,n;if(!0!==this.defaultOptions)return n.isLoaded=!0,n}return this.remoteSearch[t]||this.$set(this.remoteSearch,t,n),n},shouldExpand:function(e){return this.localSearch.active?e.isExpandedOnSearch:e.isExpanded},shouldOptionBeIncludedInSearchResult:function(e){return!!e.isMatched||(!(!e.isBranch||!e.hasMatchedDescendants||this.flattenSearchResults)||!(e.isRootNode||!e.parentNode.showAllChildrenOnSearch))},shouldShowOptionInMenu:function(e){return!(this.localSearch.active&&!this.shouldOptionBeIncludedInSearchResult(e))},getControl:function(){return this.$refs.control.$el},getMenu:function(){var e=(this.appendToBody?this.$refs.portal.portalTarget:this).$refs.menu.$refs.menu;return e&&"#comment"!==e.nodeName?e:null},setCurrentHighlightedOption:function(e){var t=this,n=!(arguments.length>1&&void 0!==arguments[1])||arguments[1],i=this.menu.current;if(null!=i&&i in this.forest.nodeMap&&(this.forest.nodeMap[i].isHighlighted=!1),this.menu.current=e.id,e.isHighlighted=!0,this.menu.isOpen&&n){var r=function(){var n=t.getMenu(),i=n.querySelector('.vue-treeselect__option[data-id="'.concat(e.id,'"]'));i&&f(n,i)};this.getMenu()?r():this.$nextTick(r)}},resetHighlightedOptionWhenNecessary:function(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0],t=this.menu.current;!e&&null!=t&&t in this.forest.nodeMap&&this.shouldShowOptionInMenu(this.getNode(t))||this.highlightFirstOption()},highlightFirstOption:function(){if(this.hasVisibleOptions){var e=this.visibleOptionIds[0];this.setCurrentHighlightedOption(this.getNode(e))}},highlightPrevOption:function(){if(this.hasVisibleOptions){var e=this.visibleOptionIds.indexOf(this.menu.current)-1;if(-1===e)return this.highlightLastOption();this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[e]))}},highlightNextOption:function(){if(this.hasVisibleOptions){var e=this.visibleOptionIds.indexOf(this.menu.current)+1;if(e===this.visibleOptionIds.length)return this.highlightFirstOption();this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[e]))}},highlightLastOption:function(){if(this.hasVisibleOptions){var e=j()(this.visibleOptionIds);this.setCurrentHighlightedOption(this.getNode(e))}},resetSearchQuery:function(){this.trigger.searchQuery=""},closeMenu:function(){!this.menu.isOpen||!this.disabled&&this.alwaysOpen||(this.saveMenuScrollPosition(),this.menu.isOpen=!1,this.toggleClickOutsideEvent(!1),this.resetSearchQuery(),this.$emit("close",this.getValue(),this.getInstanceId()))},openMenu:function(){this.disabled||this.menu.isOpen||(this.menu.isOpen=!0,this.$nextTick(this.resetHighlightedOptionWhenNecessary),this.$nextTick(this.restoreMenuScrollPosition),this.options||this.async||this.loadRootOptions(),this.toggleClickOutsideEvent(!0),this.$emit("open",this.getInstanceId()))},toggleMenu:function(){this.menu.isOpen?this.closeMenu():this.openMenu()},toggleExpanded:function(e){var t;this.localSearch.active?(t=e.isExpandedOnSearch=!e.isExpandedOnSearch)&&(e.showAllChildrenOnSearch=!0):t=e.isExpanded=!e.isExpanded,t&&!e.childrenStates.isLoaded&&this.loadChildrenOptions(e)},buildForestState:function(){var e=this,t=B();this.forest.selectedNodeIds.forEach((function(e){t[e]=!0})),this.forest.selectedNodeMap=t;var n=B();this.multiple&&(this.traverseAllNodesByIndex((function(e){n[e.id]=0})),this.selectedNodes.forEach((function(t){n[t.id]=2,e.flat||e.disableBranchNodes||t.ancestors.forEach((function(t){e.isSelected(t)||(n[t.id]=1)}))}))),this.forest.checkedStateMap=n},enhancedNormalizer:function(e){return se(se({},e),this.normalizer(e,this.getInstanceId()))},normalize:function(e,t,n){var i=this,s=t.map((function(e){return[i.enhancedNormalizer(e),e]})).map((function(t,s){var o=r()(t,2),a=o[0],u=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var c=a.id,d=a.label,p=a.children,f=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(p)||null===p,y=!g,S=!!a.isDisabled||!i.flat&&!v&&e.isDisabled,b=!!a.isNew,O=i.matchKeys.reduce((function(e,t){return se(se({},e),{},l()({},t,(n=a[t],"string"==typeof n?ae(n):"number"!=typeof n||L(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,x=i.$set(i.forest.nodeMap,c,B());if(i.$set(x,"id",c),i.$set(x,"label",d),i.$set(x,"level",m),i.$set(x,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(x,"index",(v?[]:e.index).concat(s)),i.$set(x,"parentNode",e),i.$set(x,"lowerCased",O),i.$set(x,"nestedSearchLabel",_),i.$set(x,"isDisabled",S),i.$set(x,"isNew",b),i.$set(x,"isMatched",!1),i.$set(x,"isHighlighted",!1),i.$set(x,"isBranch",g),i.$set(x,"isLeaf",y),i.$set(x,"isRootNode",v),i.$set(x,"raw",u),g){var E,N=Array.isArray(p);i.$set(x,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:N})),i.$set(x,"isExpanded","boolean"==typeof f?f:ms+40,u=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=Qe[e.openDirection]:e.menu.placement=l||!u?"bottom":"top":e.closeMenu()}},setupMenuSizeWatcher:function(){var e=this.instance.getMenu();this.menuSizeWatcher||(this.menuSizeWatcher={remove:x(e,this.adjustMenuOpenDirection)})},setupMenuResizeAndScrollEventListeners:function(){var e=this.instance.getControl();this.menuResizeAndScrollEventListeners||(this.menuResizeAndScrollEventListeners={remove:N(e,this.adjustMenuOpenDirection)})},removeMenuSizeWatcher:function(){this.menuSizeWatcher&&(this.menuSizeWatcher.remove(),this.menuSizeWatcher=null)},removeMenuResizeAndScrollEventListeners:function(){this.menuResizeAndScrollEventListeners&&(this.menuResizeAndScrollEventListeners.remove(),this.menuResizeAndScrollEventListeners=null)}},render:function(){var e=arguments[0];return e("div",{ref:"menu-container",class:"vue-treeselect__menu-container",style:this.menuContainerStyle},[e("transition",{attrs:{name:"vue-treeselect__menu--transition"}},[this.renderMenu()])])}},void 0,void 0,!1,null,null,null);qe.options.__file="src/components/Menu.vue";var Ye=qe.exports,Ke=n(19),Xe=n.n(Ke);function Ue(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var i=Object.getOwnPropertySymbols(e);t&&(i=i.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,i)}return n}var Je,Ge={name:"vue-treeselect--portal-target",inject:["instance"],watch:{"instance.menu.isOpen":function(e){e?this.setupHandlers():this.removeHandlers()},"instance.menu.placement":function(){this.updateMenuContainerOffset()}},created:function(){this.controlResizeAndScrollEventListeners=null,this.controlSizeWatcher=null},mounted:function(){this.instance.menu.isOpen&&this.setupHandlers()},methods:{setupHandlers:function(){this.updateWidth(),this.updateMenuContainerOffset(),this.setupControlResizeAndScrollEventListeners(),this.setupControlSizeWatcher()},removeHandlers:function(){this.removeControlResizeAndScrollEventListeners(),this.removeControlSizeWatcher()},setupControlResizeAndScrollEventListeners:function(){var e=this.instance.getControl();this.controlResizeAndScrollEventListeners||(this.controlResizeAndScrollEventListeners={remove:N(e,this.updateMenuContainerOffset)})},setupControlSizeWatcher:function(){var e=this,t=this.instance.getControl();this.controlSizeWatcher||(this.controlSizeWatcher={remove:x(t,(function(){e.updateWidth(),e.updateMenuContainerOffset()}))})},removeControlResizeAndScrollEventListeners:function(){this.controlResizeAndScrollEventListeners&&(this.controlResizeAndScrollEventListeners.remove(),this.controlResizeAndScrollEventListeners=null)},removeControlSizeWatcher:function(){this.controlSizeWatcher&&(this.controlSizeWatcher.remove(),this.controlSizeWatcher=null)},updateWidth:function(){var e=this.instance,t=this.$el,n=e.getControl().getBoundingClientRect();t.style.width=n.width+"px"},updateMenuContainerOffset:function(){var e=this.instance,t=e.getControl(),n=this.$el,i=t.getBoundingClientRect(),r=n.getBoundingClientRect(),s="bottom"===e.menu.placement?i.height:0,o=Math.round(i.left-r.left)+"px",a=Math.round(i.top-r.top+s)+"px";this.$refs.menu.$refs["menu-container"].style[H(["transform","webkitTransform","MozTransform","msTransform"],(function(e){return e in document.body.style}))]="translate(".concat(o,", ").concat(a,")")}},render:function(){var e=arguments[0],t=this.instance,n=["vue-treeselect__portal-target",t.wrapperClass],i={zIndex:t.zIndex};return e("div",{class:n,style:i,attrs:{"data-instance-id":t.getInstanceId()}},[e(Ye,{ref:"menu"})])},destroyed:function(){this.removeHandlers()}},Ze=pe({name:"vue-treeselect--menu-portal",created:function(){this.portalTarget=null},mounted:function(){this.setup()},destroyed:function(){this.teardown()},methods:{setup:function(){var e=document.createElement("div");document.body.appendChild(e),this.portalTarget=new Xe.a(function(e){for(var t=1;t arr.length) len = arr.length;\n\n for (var i = 0, arr2 = new Array(len); i < len; i++) {\n arr2[i] = arr[i];\n }\n\n return arr2;\n}\n\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\nfunction noop() {\n // No operation performed.\n}\n\nmodule.exports = noop;\n","var isObject = require('./isObject'),\n now = require('./now'),\n toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n * Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n * The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n * Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n * 'leading': true,\n * 'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n var lastArgs,\n lastThis,\n maxWait,\n result,\n timerId,\n lastCallTime,\n lastInvokeTime = 0,\n leading = false,\n maxing = false,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n wait = toNumber(wait) || 0;\n if (isObject(options)) {\n leading = !!options.leading;\n maxing = 'maxWait' in options;\n maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n\n function invokeFunc(time) {\n var args = lastArgs,\n thisArg = lastThis;\n\n lastArgs = lastThis = undefined;\n lastInvokeTime = time;\n result = func.apply(thisArg, args);\n return result;\n }\n\n function leadingEdge(time) {\n // Reset any `maxWait` timer.\n lastInvokeTime = time;\n // Start the timer for the trailing edge.\n timerId = setTimeout(timerExpired, wait);\n // Invoke the leading edge.\n return leading ? invokeFunc(time) : result;\n }\n\n function remainingWait(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime,\n timeWaiting = wait - timeSinceLastCall;\n\n return maxing\n ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n : timeWaiting;\n }\n\n function shouldInvoke(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime;\n\n // Either this is the first call, activity has stopped and we're at the\n // trailing edge, the system time has gone backwards and we're treating\n // it as the trailing edge, or we've hit the `maxWait` limit.\n return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n }\n\n function timerExpired() {\n var time = now();\n if (shouldInvoke(time)) {\n return trailingEdge(time);\n }\n // Restart the timer.\n timerId = setTimeout(timerExpired, remainingWait(time));\n }\n\n function trailingEdge(time) {\n timerId = undefined;\n\n // Only invoke if we have `lastArgs` which means `func` has been\n // debounced at least once.\n if (trailing && lastArgs) {\n return invokeFunc(time);\n }\n lastArgs = lastThis = undefined;\n return result;\n }\n\n function cancel() {\n if (timerId !== undefined) {\n clearTimeout(timerId);\n }\n lastInvokeTime = 0;\n lastArgs = lastCallTime = lastThis = timerId = undefined;\n }\n\n function flush() {\n return timerId === undefined ? result : trailingEdge(now());\n }\n\n function debounced() {\n var time = now(),\n isInvoking = shouldInvoke(time);\n\n lastArgs = arguments;\n lastThis = this;\n lastCallTime = time;\n\n if (isInvoking) {\n if (timerId === undefined) {\n return leadingEdge(lastCallTime);\n }\n if (maxing) {\n // Handle invocations in a tight loop.\n clearTimeout(timerId);\n timerId = setTimeout(timerExpired, wait);\n return invokeFunc(lastCallTime);\n }\n }\n if (timerId === undefined) {\n timerId = setTimeout(timerExpired, wait);\n }\n return result;\n }\n debounced.cancel = cancel;\n debounced.flush = flush;\n return debounced;\n}\n\nmodule.exports = debounce;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","var baseTrim = require('./_baseTrim'),\n isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = baseTrim(value);\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","module.exports = isPromise;\nmodule.exports.default = isPromise;\n\nfunction isPromise(obj) {\n return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';\n}\n","var before = require('./before');\n\n/**\n * Creates a function that is restricted to invoking `func` once. Repeat calls\n * to the function return the value of the first invocation. The `func` is\n * invoked with the `this` binding and arguments of the created function.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * var initialize = _.once(createApplication);\n * initialize();\n * initialize();\n * // => `createApplication` is invoked once\n */\nfunction once(func) {\n return before(2, func);\n}\n\nmodule.exports = once;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\nmodule.exports = identity;\n","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n return function() {\n return value;\n };\n}\n\nmodule.exports = constant;\n","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n var length = array == null ? 0 : array.length;\n return length ? array[length - 1] : undefined;\n}\n\nmodule.exports = last;\n","var arrayWithHoles = require(\"./arrayWithHoles.js\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableRest = require(\"./nonIterableRest.js\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","'use strict';\n\nfunction fuzzysearch (needle, haystack) {\n var tlen = haystack.length;\n var qlen = needle.length;\n if (qlen > tlen) {\n return false;\n }\n if (qlen === tlen) {\n return needle === haystack;\n }\n outer: for (var i = 0, j = 0; i < qlen; i++) {\n var nch = needle.charCodeAt(i);\n while (j < tlen) {\n if (haystack.charCodeAt(j++) === nch) {\n continue outer;\n }\n }\n return false;\n }\n return true;\n}\n\nmodule.exports = fuzzysearch;\n","function _typeof(obj) {\n \"@babel/helpers - typeof\";\n\n return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n return typeof obj;\n } : function (obj) {\n return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\n\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArrayLimit(arr, i) {\n var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n if (_i == null) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n\n var _s, _e;\n\n try {\n for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n _arr.push(_s.value);\n\n if (i && _arr.length === i) break;\n }\n } catch (err) {\n _d = true;\n _e = err;\n } finally {\n try {\n if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n } finally {\n if (_d) throw _e;\n }\n }\n\n return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n * console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n return root.Date.now();\n};\n\nmodule.exports = now;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n return string\n ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n : string;\n}\n\nmodule.exports = baseTrim;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n var index = string.length;\n\n while (index-- && reWhitespace.test(string.charAt(index))) {}\n return index;\n}\n\nmodule.exports = trimmedEndIndex;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","var Symbol = require('./_Symbol'),\n getRawTag = require('./_getRawTag'),\n objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var toInteger = require('./toInteger');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that invokes `func`, with the `this` binding and arguments\n * of the created function, while it's called less than `n` times. Subsequent\n * calls to the created function return the result of the last `func` invocation.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {number} n The number of calls at which `func` is no longer invoked.\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * jQuery(element).on('click', _.before(5, addContactToList));\n * // => Allows adding up to 4 contacts to the list.\n */\nfunction before(n, func) {\n var result;\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n n = toInteger(n);\n return function() {\n if (--n > 0) {\n result = func.apply(this, arguments);\n }\n if (n <= 1) {\n func = undefined;\n }\n return result;\n };\n}\n\nmodule.exports = before;\n","var toFinite = require('./toFinite');\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n var result = toFinite(value),\n remainder = result % 1;\n\n return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\nmodule.exports = toInteger;\n","var toNumber = require('./toNumber');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n MAX_INTEGER = 1.7976931348623157e+308;\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n if (!value) {\n return value === 0 ? value : 0;\n }\n value = toNumber(value);\n if (value === INFINITY || value === -INFINITY) {\n var sign = (value < 0 ? -1 : 1);\n return sign * MAX_INTEGER;\n }\n return value === value ? value : 0;\n}\n\nmodule.exports = toFinite;\n","import { noop } from './noop'\n\nexport const warning = process.env.NODE_ENV === 'production'\n ? /* istanbul ignore next */ noop\n : function warning(checker, complainer) {\n if (!checker()) {\n const message = [ '[Vue-Treeselect Warning]' ].concat(complainer())\n // eslint-disable-next-line no-console\n console.error(...message)\n }\n }\n","export function onLeftClick(mouseDownHandler) {\n return function onMouseDown(evt, ...args) {\n if (evt.type === 'mousedown' && evt.button === 0) {\n mouseDownHandler.call(this, evt, ...args)\n }\n }\n}\n","// from react-select\nexport function scrollIntoView($scrollingEl, $focusedEl) {\n const scrollingReact = $scrollingEl.getBoundingClientRect()\n const focusedRect = $focusedEl.getBoundingClientRect()\n const overScroll = $focusedEl.offsetHeight / 3\n\n if (focusedRect.bottom + overScroll > scrollingReact.bottom) {\n $scrollingEl.scrollTop = Math.min(\n $focusedEl.offsetTop + $focusedEl.clientHeight - $scrollingEl.offsetHeight + overScroll,\n $scrollingEl.scrollHeight,\n )\n } else if (focusedRect.top - overScroll < scrollingReact.top) {\n $scrollingEl.scrollTop = Math.max($focusedEl.offsetTop - overScroll, 0)\n }\n}\n","import watchSizeForBrowsersOtherThanIE9 from 'watch-size'\nimport { removeFromArray } from './removeFromArray'\n\nlet intervalId\nconst registered = []\nconst INTERVAL_DURATION = 100\n\nfunction run() {\n intervalId = setInterval(() => {\n registered.forEach(test)\n }, INTERVAL_DURATION)\n}\n\nfunction stop() {\n clearInterval(intervalId)\n intervalId = null\n}\n\nfunction test(item) {\n const { $el, listener, lastWidth, lastHeight } = item\n const width = $el.offsetWidth\n const height = $el.offsetHeight\n\n if (lastWidth !== width || lastHeight !== height) {\n item.lastWidth = width\n item.lastHeight = height\n\n listener({ width, height })\n }\n}\n\nfunction watchSizeForIE9($el, listener) {\n const item = {\n $el,\n listener,\n lastWidth: null,\n lastHeight: null,\n }\n const unwatch = () => {\n removeFromArray(registered, item)\n if (!registered.length) stop()\n }\n\n registered.push(item)\n // The original watch-size will call the listener on initialization.\n // Keep the same behavior here.\n test(item)\n run()\n\n return unwatch\n}\n\nexport function watchSize($el, listener) {\n // See: https://stackoverflow.com/a/31293352\n const isIE9 = document.documentMode === 9\n // watch-size will call the listener on initialization.\n // Disable this behavior with a lock to achieve a clearer code logic.\n let locked = true\n const wrappedListener = (...args) => locked || listener(...args)\n const implementation = isIE9\n ? watchSizeForIE9\n : watchSizeForBrowsersOtherThanIE9\n const removeSizeWatcher = implementation($el, wrappedListener)\n locked = false // unlock after initialization\n\n return removeSizeWatcher\n}\n","var index = (function (element, listener) {\n\tvar expand = document.createElement('_');\n\tvar shrink = expand.appendChild(document.createElement('_'));\n\tvar expandChild = expand.appendChild(document.createElement('_'));\n\tvar shrinkChild = shrink.appendChild(document.createElement('_'));\n\n\tvar lastWidth = void 0,\n\t lastHeight = void 0;\n\n\tshrink.style.cssText = expand.style.cssText = 'height:100%;left:0;opacity:0;overflow:hidden;pointer-events:none;position:absolute;top:0;transition:0s;width:100%;z-index:-1';\n\tshrinkChild.style.cssText = expandChild.style.cssText = 'display:block;height:100%;transition:0s;width:100%';\n\tshrinkChild.style.width = shrinkChild.style.height = '200%';\n\n\telement.appendChild(expand);\n\n\ttest();\n\n\treturn stop;\n\n\tfunction test() {\n\t\tunbind();\n\n\t\tvar width = element.offsetWidth;\n\t\tvar height = element.offsetHeight;\n\n\t\tif (width !== lastWidth || height !== lastHeight) {\n\t\t\tlastWidth = width;\n\t\t\tlastHeight = height;\n\n\t\t\texpandChild.style.width = width * 2 + 'px';\n\t\t\texpandChild.style.height = height * 2 + 'px';\n\n\t\t\texpand.scrollLeft = expand.scrollWidth;\n\t\t\texpand.scrollTop = expand.scrollHeight;\n\t\t\tshrink.scrollLeft = shrink.scrollWidth;\n\t\t\tshrink.scrollTop = shrink.scrollHeight;\n\n\t\t\tlistener({ width: width, height: height });\n\t\t}\n\n\t\tshrink.addEventListener('scroll', test);\n\t\texpand.addEventListener('scroll', test);\n\t}\n\n\tfunction unbind() {\n\t\tshrink.removeEventListener('scroll', test);\n\t\texpand.removeEventListener('scroll', test);\n\t}\n\n\tfunction stop() {\n\t\tunbind();\n\n\t\telement.removeChild(expand);\n\t}\n});\n\nexport default index;\n","export function removeFromArray(arr, elem) {\n const idx = arr.indexOf(elem)\n if (idx !== -1) arr.splice(idx, 1)\n}\n","function findScrollParents($el) {\n const $scrollParents = []\n let $parent = $el.parentNode\n\n while ($parent && $parent.nodeName !== 'BODY' && $parent.nodeType === document.ELEMENT_NODE) {\n if (isScrollElment($parent)) $scrollParents.push($parent)\n $parent = $parent.parentNode\n }\n $scrollParents.push(window)\n\n return $scrollParents\n}\n\nfunction isScrollElment($el) {\n // Firefox wants us to check `-x` and `-y` variations as well\n const { overflow, overflowX, overflowY } = getComputedStyle($el)\n return /(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)\n}\n\nexport function setupResizeAndScrollEventListeners($el, listener) {\n const $scrollParents = findScrollParents($el)\n\n window.addEventListener('resize', listener, { passive: true })\n $scrollParents.forEach(scrollParent => {\n scrollParent.addEventListener('scroll', listener, { passive: true })\n })\n\n return function removeEventListeners() {\n window.removeEventListener('resize', listener, { passive: true })\n $scrollParents.forEach($scrollParent => {\n $scrollParent.removeEventListener('scroll', listener, { passive: true })\n })\n }\n}\n","export function isNaN(x) {\n return x !== x\n}\n","export const createMap = () => Object.create(null)\n","function isPlainObject(value) {\n if (value == null || typeof value !== 'object') return false\n return Object.getPrototypeOf(value) === Object.prototype\n}\n\nfunction copy(obj, key, value) {\n if (isPlainObject(value)) {\n obj[key] || (obj[key] = {})\n deepExtend(obj[key], value)\n } else {\n obj[key] = value\n }\n}\n\nexport function deepExtend(target, source) {\n if (isPlainObject(source)) {\n const keys = Object.keys(source)\n\n for (let i = 0, len = keys.length; i < len; i++) {\n copy(target, keys[i], source[keys[i]])\n }\n }\n\n return target\n}\n","export function includes(arrOrStr, elem) {\n return arrOrStr.indexOf(elem) !== -1\n}\n","export function find(arr, predicate, ctx) {\n for (let i = 0, len = arr.length; i < len; i++) {\n if (predicate.call(ctx, arr[i], i, arr)) return arr[i]\n }\n return undefined\n}\n","export function quickDiff(arrA, arrB) {\n if (arrA.length !== arrB.length) return true\n\n for (let i = 0; i < arrA.length; i++) {\n if (arrA[i] !== arrB[i]) return true\n }\n\n return false\n}\n","// Magic value that indicates a root level node.\nexport const NO_PARENT_NODE = null\n\n// Types of checked state.\nexport const UNCHECKED = 0\nexport const INDETERMINATE = 1\nexport const CHECKED = 2\n\n// Types of count number.\nexport const ALL_CHILDREN = 'ALL_CHILDREN'\nexport const ALL_DESCENDANTS = 'ALL_DESCENDANTS'\nexport const LEAF_CHILDREN = 'LEAF_CHILDREN'\nexport const LEAF_DESCENDANTS = 'LEAF_DESCENDANTS'\n\n// Action types of delayed loading.\nexport const LOAD_ROOT_OPTIONS = 'LOAD_ROOT_OPTIONS'\nexport const LOAD_CHILDREN_OPTIONS = 'LOAD_CHILDREN_OPTIONS'\nexport const ASYNC_SEARCH = 'ASYNC_SEARCH'\n\n// Acceptable values of `valueConsistsOf` prop.\nexport const ALL = 'ALL'\nexport const BRANCH_PRIORITY = 'BRANCH_PRIORITY'\nexport const LEAF_PRIORITY = 'LEAF_PRIORITY'\nexport const ALL_WITH_INDETERMINATE = 'ALL_WITH_INDETERMINATE'\n\n// Acceptable values of `sortValueBy` prop.\nexport const ORDER_SELECTED = 'ORDER_SELECTED'\nexport const LEVEL = 'LEVEL'\nexport const INDEX = 'INDEX'\n\n// Key codes look-up table.\nexport const KEY_CODES = {\n BACKSPACE: 8,\n ENTER: 13,\n ESCAPE: 27,\n END: 35,\n HOME: 36,\n ARROW_LEFT: 37,\n ARROW_UP: 38,\n ARROW_RIGHT: 39,\n ARROW_DOWN: 40,\n DELETE: 46,\n}\n\n// Other constants.\nexport const INPUT_DEBOUNCE_DELAY = process.env.NODE_ENV === 'testing'\n ? /* to speed up unit testing */ 10\n : /* istanbul ignore next */ 200\nexport const MIN_INPUT_WIDTH = 5\nexport const MENU_BUFFER = 40\n","import fuzzysearch from 'fuzzysearch'\n\nimport {\n warning,\n onLeftClick, scrollIntoView,\n isNaN, isPromise, once,\n identity, constant, createMap,\n quickDiff, last as getLast, includes, find, removeFromArray,\n} from '../utils'\n\nimport {\n NO_PARENT_NODE,\n UNCHECKED, INDETERMINATE, CHECKED,\n LOAD_ROOT_OPTIONS, LOAD_CHILDREN_OPTIONS, ASYNC_SEARCH,\n ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE,\n ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS,\n ORDER_SELECTED, LEVEL, INDEX,\n} from '../constants'\n\nfunction sortValueByIndex(a, b) {\n let i = 0\n do {\n if (a.level < i) return -1\n if (b.level < i) return 1\n if (a.index[i] !== b.index[i]) return a.index[i] - b.index[i]\n i++\n } while (true)\n}\n\nfunction sortValueByLevel(a, b) {\n return a.level === b.level\n ? sortValueByIndex(a, b)\n : a.level - b.level\n}\n\nfunction createAsyncOptionsStates() {\n return {\n isLoaded: false,\n isLoading: false,\n loadingError: '',\n }\n}\n\nfunction stringifyOptionPropValue(value) {\n if (typeof value === 'string') return removeAccents(value)\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\n}\nfunction removeAccents(str) {\n if (!str) return ''\n return str.normalize('NFD').replace(/[\\u0300-\\u036F]/g, '')\n}\n\nfunction match(enableFuzzyMatch, needle, haystack) {\n return enableFuzzyMatch\n ? fuzzysearch(needle, haystack)\n : includes(haystack, needle)\n}\n\nfunction getErrorMessage(err) {\n return err.message || /* istanbul ignore next */String(err)\n}\n\nlet instanceId = 0\n\nexport default {\n provide() {\n return {\n // Enable access to the instance of root component of vue-treeselect\n // across hierarchy.\n instance: this,\n }\n },\n\n props: {\n /**\n * Whether to allow resetting value even if there are disabled selected nodes.\n */\n allowClearingDisabled: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When an ancestor node is selected/deselected, whether its disabled descendants should be selected/deselected.\n * You may want to use this in conjunction with `allowClearingDisabled` prop.\n */\n allowSelectingDisabledDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether the menu should be always open.\n */\n alwaysOpen: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Append the menu to ?\n */\n appendToBody: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether to enable async search mode.\n */\n async: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Automatically focus the component on mount?\n */\n autoFocus: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Automatically load root options on mount. When set to `false`, root options will be loaded when the menu is opened.\n */\n autoLoadRootOptions: {\n type: Boolean,\n default: true,\n },\n\n /**\n * When user deselects a node, automatically deselect its ancestors. Applies to flat mode only.\n */\n autoDeselectAncestors: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user deselects a node, automatically deselect its descendants. Applies to flat mode only.\n */\n autoDeselectDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user selects a node, automatically select its ancestors. Applies to flat mode only.\n */\n autoSelectAncestors: {\n type: Boolean,\n default: false,\n },\n\n /**\n * When user selects a node, automatically select its descendants. Applies to flat mode only.\n */\n autoSelectDescendants: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether pressing backspace key removes the last item if there is no text input.\n */\n backspaceRemoves: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Function that processes before clearing all input fields.\n * Return `false` to prevent value from being cleared.\n * @type {function(): (boolean|Promise)}\n */\n beforeClearAll: {\n type: Function,\n default: constant(true),\n },\n\n /**\n * Show branch nodes before leaf nodes?\n */\n branchNodesFirst: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Should cache results of every search request?\n */\n cacheOptions: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Show an \"×\" button that resets value?\n */\n clearable: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Title for the \"×\" button when `multiple: true`.\n */\n clearAllText: {\n type: String,\n default: 'Clear all',\n },\n\n /**\n * Whether to clear the search input after selecting.\n * Use only when `multiple` is `true`.\n * For single-select mode, it **always** clears the input after selecting an option regardless of the prop value.\n */\n clearOnSelect: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Title for the \"×\" button.\n */\n clearValueText: {\n type: String,\n default: 'Clear value',\n },\n\n /**\n * Whether to close the menu after selecting an option?\n * Use only when `multiple` is `true`.\n */\n closeOnSelect: {\n type: Boolean,\n default: true,\n },\n\n /**\n * How many levels of branch nodes should be automatically expanded when loaded.\n * Set `Infinity` to make all branch nodes expanded by default.\n */\n defaultExpandLevel: {\n type: Number,\n default: 0,\n },\n\n /**\n * The default set of options to show before the user starts searching. Used for async search mode.\n * When set to `true`, the results for search query as a empty string will be autoloaded.\n * @type {boolean|node[]}\n */\n defaultOptions: {\n default: false,\n },\n\n /**\n * Whether pressing delete key removes the last item if there is no text input.\n */\n deleteRemoves: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Delimiter to use to join multiple values for the hidden field value.\n */\n delimiter: {\n type: String,\n default: ',',\n },\n\n /**\n * Only show the nodes that match the search value directly, excluding its ancestors.\n *\n * @type {Object}\n */\n flattenSearchResults: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Prevent branch nodes from being selected?\n */\n disableBranchNodes: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Disable the control?\n */\n disabled: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Disable the fuzzy matching functionality?\n */\n disableFuzzyMatching: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Whether to enable flat mode or not. Non-flat mode (default) means:\n * - Whenever a branch node gets checked, all its children will be checked too\n * - Whenever a branch node has all children checked, the branch node itself will be checked too\n * Set `true` to disable this mechanism\n */\n flat: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Will be passed with all events as the last param.\n * Useful for identifying events origin.\n */\n instanceId: {\n // Add two trailing \"$\" to distinguish from explictly specified ids.\n default: () => `${instanceId++}$$`,\n type: [ String, Number ],\n },\n\n /**\n * Joins multiple values into a single form field with the `delimiter` (legacy mode).\n */\n joinValues: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Limit the display of selected options.\n * The rest will be hidden within the limitText string.\n */\n limit: {\n type: Number,\n default: Infinity,\n },\n\n /**\n * Function that processes the message shown when selected elements pass the defined limit.\n * @type {function(number): string}\n */\n limitText: {\n type: Function,\n default: function limitTextDefault(count) { // eslint-disable-line func-name-matching\n return `and ${count} more`\n },\n },\n\n /**\n * Text displayed when loading options.\n */\n loadingText: {\n type: String,\n default: 'Loading...',\n },\n\n /**\n * Used for dynamically loading options.\n * @type {function({action: string, callback: (function((Error|string)=): void), parentNode: node=, instanceId}): void}\n */\n loadOptions: {\n type: Function,\n },\n\n /**\n * Which node properties to filter on.\n */\n matchKeys: {\n type: Array,\n default: constant([ 'label' ]),\n },\n\n /**\n * Sets `maxHeight` style value of the menu.\n */\n maxHeight: {\n type: Number,\n default: 300,\n },\n\n /**\n * Set `true` to allow selecting multiple options (a.k.a., multi-select mode).\n */\n multiple: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Generates a hidden tag with this field name for html forms.\n */\n name: {\n type: String,\n },\n\n /**\n * Text displayed when a branch node has no children.\n */\n noChildrenText: {\n type: String,\n default: 'No sub-options.',\n },\n\n /**\n * Text displayed when there are no available options.\n */\n noOptionsText: {\n type: String,\n default: 'No options available.',\n },\n\n /**\n * Text displayed when there are no matching search results.\n */\n noResultsText: {\n type: String,\n default: 'No results found...',\n },\n\n /**\n * Used for normalizing source data.\n * @type {function(node, instanceId): node}\n */\n normalizer: {\n type: Function,\n default: identity,\n },\n\n /**\n * By default (`auto`), the menu will open below the control. If there is not\n * enough space, vue-treeselect will automatically flip the menu.\n * You can use one of other four options to force the menu to be always opened\n * to specified direction.\n * Acceptable values:\n * - `\"auto\"`\n * - `\"below\"`\n * - `\"bottom\"`\n * - `\"above\"`\n * - `\"top\"`\n */\n openDirection: {\n type: String,\n default: 'auto',\n validator(value) {\n const acceptableValues = [ 'auto', 'top', 'bottom', 'above', 'below' ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Whether to automatically open the menu when the control is clicked.\n */\n openOnClick: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Whether to automatically open the menu when the control is focused.\n */\n openOnFocus: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Array of available options.\n * @type {node[]}\n */\n options: {\n type: Array,\n },\n\n /**\n * Field placeholder, displayed when there's no value.\n */\n placeholder: {\n type: String,\n default: 'Select...',\n },\n\n /**\n * Applies HTML5 required attribute when needed.\n */\n required: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Text displayed asking user whether to retry loading children options.\n */\n retryText: {\n type: String,\n default: 'Retry?',\n },\n\n /**\n * Title for the retry button.\n */\n retryTitle: {\n type: String,\n default: 'Click to retry',\n },\n\n /**\n * Enable searching feature?\n */\n searchable: {\n type: Boolean,\n default: true,\n },\n\n /**\n * Search in ancestor nodes too.\n */\n searchNested: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Text tip to prompt for async search.\n */\n searchPromptText: {\n type: String,\n default: 'Type to search...',\n },\n\n /**\n * Whether to show a children count next to the label of each branch node.\n */\n showCount: {\n type: Boolean,\n default: false,\n },\n\n /**\n * Used in conjunction with `showCount` to specify which type of count number should be displayed.\n * Acceptable values:\n * - \"ALL_CHILDREN\"\n * - \"ALL_DESCENDANTS\"\n * - \"LEAF_CHILDREN\"\n * - \"LEAF_DESCENDANTS\"\n */\n showCountOf: {\n type: String,\n default: ALL_CHILDREN,\n validator(value) {\n const acceptableValues = [ ALL_CHILDREN, ALL_DESCENDANTS, LEAF_CHILDREN, LEAF_DESCENDANTS ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Whether to show children count when searching.\n * Fallbacks to the value of `showCount` when not specified.\n * @type {boolean}\n */\n showCountOnSearch: null,\n\n /**\n * In which order the selected options should be displayed in trigger & sorted in `value` array.\n * Used for multi-select mode only.\n * Acceptable values:\n * - \"ORDER_SELECTED\"\n * - \"LEVEL\"\n * - \"INDEX\"\n */\n sortValueBy: {\n type: String,\n default: ORDER_SELECTED,\n validator(value) {\n const acceptableValues = [ ORDER_SELECTED, LEVEL, INDEX ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Tab index of the control.\n */\n tabIndex: {\n type: Number,\n default: 0,\n },\n\n /**\n * The value of the control.\n * Should be `id` or `node` object for single-select mode, or an array of `id` or `node` object for multi-select mode.\n * Its format depends on the `valueFormat` prop.\n * For most cases, just use `v-model` instead.\n * @type {?Array}\n */\n value: null,\n\n /**\n * Which kind of nodes should be included in the `value` array in multi-select mode.\n * Acceptable values:\n * - \"ALL\" - Any node that is checked will be included in the `value` array\n * - \"BRANCH_PRIORITY\" (default) - If a branch node is checked, all its descendants will be excluded in the `value` array\n * - \"LEAF_PRIORITY\" - If a branch node is checked, this node itself and its branch descendants will be excluded from the `value` array but its leaf descendants will be included\n * - \"ALL_WITH_INDETERMINATE\" - Any node that is checked will be included in the `value` array, plus indeterminate nodes\n */\n valueConsistsOf: {\n type: String,\n default: BRANCH_PRIORITY,\n validator(value) {\n const acceptableValues = [ ALL, BRANCH_PRIORITY, LEAF_PRIORITY, ALL_WITH_INDETERMINATE ]\n return includes(acceptableValues, value)\n },\n },\n\n /**\n * Format of `value` prop.\n * Note that, when set to `\"object\"`, only `id` & `label` properties are required in each `node` object in `value` prop.\n * Acceptable values:\n * - \"id\"\n * - \"object\"\n */\n valueFormat: {\n type: String,\n default: 'id',\n },\n\n /**\n * z-index of the menu.\n */\n zIndex: {\n type: [ Number, String ],\n default: 999,\n },\n },\n\n data() {\n return {\n trigger: {\n // Is the control focused?\n isFocused: false,\n // User entered search query - value of the input.\n searchQuery: '',\n },\n\n menu: {\n // Is the menu opened?\n isOpen: false,\n // Id of current highlighted option.\n current: null,\n // The scroll position before last menu closing.\n lastScrollPosition: 0,\n // Which direction to open the menu.\n placement: 'bottom',\n },\n\n forest: {\n // Normalized options.\n normalizedOptions: [],\n // map for quick look-up.\n nodeMap: createMap(),\n // map, used for multi-select mode.\n checkedStateMap: createMap(),\n // Id list of all selected options.\n selectedNodeIds: this.extractCheckedNodeIdsFromValue(),\n // map for fast checking:\n // if (forest.selectedNodeIds.indexOf(id) !== -1) forest.selectedNodeMap[id] === true\n selectedNodeMap: createMap(),\n },\n\n // States of root options.\n rootOptionsStates: createAsyncOptionsStates(),\n\n localSearch: {\n // Has user entered any query to search local options?\n active: false,\n // Has any options matched the search query?\n noResults: true,\n // map for counting matched children/descendants.\n countMap: createMap(),\n },\n\n // map.\n remoteSearch: createMap(),\n }\n },\n\n computed: {\n /* eslint-disable valid-jsdoc */\n /**\n * Normalized nodes that have been selected.\n * @type {node[]}\n */\n selectedNodes() {\n return this.forest.selectedNodeIds.map(this.getNode)\n },\n /**\n * Id list of selected nodes with `sortValueBy` prop applied.\n * @type {nodeId[]}\n */\n internalValue() {\n let internalValue\n\n // istanbul ignore else\n if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) {\n internalValue = this.forest.selectedNodeIds.slice()\n } else if (this.valueConsistsOf === BRANCH_PRIORITY) {\n internalValue = this.forest.selectedNodeIds.filter(id => {\n const node = this.getNode(id)\n if (node.isRootNode) return true\n return !this.isSelected(node.parentNode)\n })\n } else if (this.valueConsistsOf === LEAF_PRIORITY) {\n internalValue = this.forest.selectedNodeIds.filter(id => {\n const node = this.getNode(id)\n if (node.isLeaf) return true\n return node.children.length === 0\n })\n } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) {\n const indeterminateNodeIds = []\n internalValue = this.forest.selectedNodeIds.slice()\n this.selectedNodes.forEach(selectedNode => {\n selectedNode.ancestors.forEach(ancestor => {\n if (includes(indeterminateNodeIds, ancestor.id)) return\n if (includes(internalValue, ancestor.id)) return\n indeterminateNodeIds.push(ancestor.id)\n })\n })\n internalValue.push(...indeterminateNodeIds)\n }\n\n if (this.sortValueBy === LEVEL) {\n internalValue.sort((a, b) => sortValueByLevel(this.getNode(a), this.getNode(b)))\n } else if (this.sortValueBy === INDEX) {\n internalValue.sort((a, b) => sortValueByIndex(this.getNode(a), this.getNode(b)))\n }\n\n return internalValue\n },\n /**\n * Has any option been selected?\n * @type {boolean}\n */\n hasValue() {\n return this.internalValue.length > 0\n },\n /**\n * Single-select mode?\n * @type {boolean}\n */\n single() {\n return !this.multiple\n },\n /**\n * Id list of nodes displayed in the menu. Nodes that are considered NOT visible:\n * - descendants of a collapsed branch node\n * - in local search mode, nodes that are not matched, unless\n * - it's a branch node and has matched descendants\n * - it's a leaf node and its parent node is explicitly set to show all children\n * @type {id[]}\n */\n visibleOptionIds() {\n const visibleOptionIds = []\n\n this.traverseAllNodesByIndex(node => {\n if (!this.localSearch.active || this.shouldOptionBeIncludedInSearchResult(node)) {\n visibleOptionIds.push(node.id)\n }\n // Skip the traversal of descendants of a branch node if it's not expanded.\n if (node.isBranch && !this.shouldExpand(node)) {\n return false\n }\n })\n\n return visibleOptionIds\n },\n /**\n * Has any option should be displayed in the menu?\n * @type {boolean}\n */\n hasVisibleOptions() {\n return this.visibleOptionIds.length !== 0\n },\n /**\n * Should show children count when searching?\n * @type {boolean}\n */\n showCountOnSearchComputed() {\n // Vue doesn't allow setting default prop value based on another prop value.\n // So use computed property as a workaround.\n // https://github.com/vuejs/vue/issues/6358\n return typeof this.showCountOnSearch === 'boolean'\n ? this.showCountOnSearch\n : this.showCount\n },\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes() {\n return this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\n },\n shouldFlattenOptions() {\n return this.localSearch.active && this.flattenSearchResults\n },\n /* eslint-enable valid-jsdoc */\n },\n\n watch: {\n alwaysOpen(newValue) {\n if (newValue) this.openMenu()\n else this.closeMenu()\n },\n\n branchNodesFirst() {\n this.initialize()\n },\n\n disabled(newValue) {\n // force close the menu after disabling the control\n if (newValue && this.menu.isOpen) this.closeMenu()\n else if (!newValue && !this.menu.isOpen && this.alwaysOpen) this.openMenu()\n },\n\n flat() {\n this.initialize()\n },\n\n internalValue(newValue, oldValue) {\n const hasChanged = quickDiff(newValue, oldValue)\n // #122\n // Vue would trigger this watcher when `newValue` and `oldValue` are shallow-equal.\n // We emit the `input` event only when the value actually changes.\n if (hasChanged) this.$emit('input', this.getValue(), this.getInstanceId())\n },\n\n matchKeys() {\n this.initialize()\n },\n\n multiple(newValue) {\n // We need to rebuild the state when switching from single-select mode\n // to multi-select mode.\n // istanbul ignore else\n if (newValue) this.buildForestState()\n },\n\n options: {\n handler() {\n if (this.async) return\n // Re-initialize options when the `options` prop has changed.\n this.initialize()\n this.rootOptionsStates.isLoaded = Array.isArray(this.options)\n },\n deep: true,\n immediate: true,\n },\n\n 'trigger.searchQuery'() {\n if (this.async) {\n this.handleRemoteSearch()\n } else {\n this.handleLocalSearch()\n }\n\n this.$emit('search-change', this.trigger.searchQuery, this.getInstanceId())\n },\n\n value() {\n const nodeIdsFromValue = this.extractCheckedNodeIdsFromValue()\n const hasChanged = quickDiff(nodeIdsFromValue, this.internalValue)\n if (hasChanged) this.fixSelectedNodeIds(nodeIdsFromValue)\n },\n },\n\n methods: {\n verifyProps() {\n warning(\n () => this.async ? this.searchable : true,\n () => 'For async search mode, the value of \"searchable\" prop must be true.',\n )\n\n if (this.options == null && !this.loadOptions) {\n warning(\n () => false,\n () => 'Are you meant to dynamically load options? You need to use \"loadOptions\" prop.',\n )\n }\n\n if (this.flat) {\n warning(\n () => this.multiple,\n () => 'You are using flat mode. But you forgot to add \"multiple=true\"?',\n )\n }\n\n if (!this.flat) {\n const propNames = [\n 'autoSelectAncestors',\n 'autoSelectDescendants',\n 'autoDeselectAncestors',\n 'autoDeselectDescendants',\n ]\n\n propNames.forEach(propName => {\n warning(\n () => !this[propName],\n () => `\"${propName}\" only applies to flat mode.`,\n )\n })\n }\n },\n\n resetFlags() {\n this._blurOnSelect = false\n },\n\n initialize() {\n const options = this.async\n ? this.getRemoteSearchEntry().options\n : this.options\n\n if (Array.isArray(options)) {\n // In case we are re-initializing options, keep the old state tree temporarily.\n const prevNodeMap = this.forest.nodeMap\n this.forest.nodeMap = createMap()\n this.keepDataOfSelectedNodes(prevNodeMap)\n this.forest.normalizedOptions = this.normalize(NO_PARENT_NODE, options, prevNodeMap)\n // Cases that need fixing `selectedNodeIds`:\n // 1) Children options of a checked node have been delayed loaded,\n // we should also mark these children as checked. (multi-select mode)\n // 2) Root options have been delayed loaded, we need to initialize states\n // of these nodes. (multi-select mode)\n // 3) Async search mode.\n this.fixSelectedNodeIds(this.internalValue)\n } else {\n this.forest.normalizedOptions = []\n }\n },\n\n getInstanceId() {\n return this.instanceId == null ? this.id : this.instanceId\n },\n\n getValue() {\n if (this.valueFormat === 'id') {\n return this.multiple\n ? this.getUniqChildValues(this.internalValue.slice())\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple\n ? this.getUniqChildValues(rawNodes)\n : rawNodes[0]\n },\n\n getUniqChildValues(ids) {\n if (this.valueConsistsOf !== BRANCH_PRIORITY) return ids\n const values = ids.map(id => {\n const node = this.getNode(id)\n if (node.hasBeenSelected) return node.id\n if (this.hasOneChild(node)) {\n const children = []\n this.traverseDescendantsBFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n if (descendant.hasBeenSelected) {\n children.push(descendant.id)\n }\n }\n })\n if (children && children.length) return children[0]\n }\n return id\n })\n return values\n },\n hasOneChild(node) {\n return node && node.children && node.children.length === 1\n },\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) return null\n\n return nodeId in this.forest.nodeMap\n ? this.forest.nodeMap[nodeId]\n : this.createFallbackNode(nodeId)\n },\n\n createFallbackNode(id) {\n // In case there is a default selected node that is not loaded into the tree yet,\n // we create a fallback node to keep the component working.\n // When the real data is loaded, we'll override this fake node.\n\n const raw = this.extractNodeFromValue(id)\n const label = this.enhancedNormalizer(raw).label || `${id} (unknown)`\n const fallbackNode = {\n id,\n label,\n ancestors: [],\n parentNode: NO_PARENT_NODE,\n isFallbackNode: true,\n isRootNode: true,\n isLeaf: true,\n isBranch: false,\n isDisabled: false,\n isNew: false,\n index: [ -1 ],\n level: 0,\n raw,\n }\n\n return this.$set(this.forest.nodeMap, id, fallbackNode)\n },\n\n extractCheckedNodeIdsFromValue() {\n if (this.value == null) return []\n\n if (this.valueFormat === 'id') {\n return this.multiple\n ? this.value.slice()\n : [ this.value ]\n }\n\n return (this.multiple ? this.value : [ this.value ])\n .map(node => this.enhancedNormalizer(node))\n .map(node => node.id)\n },\n\n extractNodeFromValue(id) {\n const defaultNode = { id }\n\n if (this.valueFormat === 'id') {\n return defaultNode\n }\n\n const valueArray = this.multiple\n ? Array.isArray(this.value) ? this.value : []\n : this.value ? [ this.value ] : []\n const matched = find(\n valueArray,\n node => node && this.enhancedNormalizer(node).id === id,\n )\n\n return matched || defaultNode\n },\n\n fixSelectedNodeIds(nodeIdListOfPrevValue) {\n let nextSelectedNodeIds = []\n\n // istanbul ignore else\n if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === ALL) {\n nextSelectedNodeIds = nodeIdListOfPrevValue\n } else if (this.valueConsistsOf === BRANCH_PRIORITY) {\n nodeIdListOfPrevValue.forEach(nodeId => {\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n nextSelectedNodeIds.push(descendant.id)\n })\n })\n } else if (this.valueConsistsOf === LEAF_PRIORITY) {\n const map = createMap()\n const queue = nodeIdListOfPrevValue.slice()\n while (queue.length) {\n const nodeId = queue.shift()\n const node = this.getNode(nodeId)\n nextSelectedNodeIds.push(nodeId)\n if (node.isRootNode) continue\n if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length\n if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id)\n }\n } else if (this.valueConsistsOf === ALL_WITH_INDETERMINATE) {\n const map = createMap()\n const queue = nodeIdListOfPrevValue.filter(nodeId => {\n const node = this.getNode(nodeId)\n return node.isLeaf || node.children.length === 0\n })\n while (queue.length) {\n const nodeId = queue.shift()\n const node = this.getNode(nodeId)\n nextSelectedNodeIds.push(nodeId)\n if (node.isRootNode) continue\n if (!(node.parentNode.id in map)) map[node.parentNode.id] = node.parentNode.children.length\n if (--map[node.parentNode.id] === 0) queue.push(node.parentNode.id)\n }\n }\n\n const hasChanged = quickDiff(this.forest.selectedNodeIds, nextSelectedNodeIds)\n // If `nextSelectedNodeIds` doesn't actually differ from old `selectedNodeIds`,\n // we don't make the assignment to avoid triggering its watchers which may cause\n // unnecessary calculations.\n if (hasChanged) this.forest.selectedNodeIds = nextSelectedNodeIds\n\n this.buildForestState()\n },\n\n keepDataOfSelectedNodes(prevNodeMap) {\n // In case there is any selected node that is not present in the new `options` array.\n // It could be useful for async search mode.\n this.forest.selectedNodeIds.forEach(id => {\n if (!prevNodeMap[id]) return\n const node = {\n ...prevNodeMap[id],\n isFallbackNode: true,\n }\n this.$set(this.forest.nodeMap, id, node)\n })\n },\n\n isSelected(node) {\n // whether a node is selected (single-select mode) or fully-checked (multi-select mode)\n return this.forest.selectedNodeMap[node.id] === true\n },\n\n traverseDescendantsBFS(parentNode, callback) {\n // istanbul ignore if\n if (!parentNode.isBranch) return\n const queue = parentNode.children.slice()\n while (queue.length) {\n const currNode = queue[0]\n if (currNode.isBranch) queue.push(...currNode.children)\n callback(currNode)\n queue.shift()\n }\n },\n\n traverseDescendantsDFS(parentNode, callback) {\n if (!parentNode.isBranch) return\n parentNode.children.forEach(child => {\n // deep-level node first\n this.traverseDescendantsDFS(child, callback)\n callback(child)\n })\n },\n\n traverseAllNodesDFS(callback) {\n this.forest.normalizedOptions.forEach(rootNode => {\n // deep-level node first\n this.traverseDescendantsDFS(rootNode, callback)\n callback(rootNode)\n })\n },\n\n traverseAllNodesByIndex(callback) {\n const walk = parentNode => {\n parentNode.children.forEach(child => {\n if (callback(child) !== false && child.isBranch) {\n walk(child)\n }\n })\n }\n\n // To simplify the code logic of traversal,\n // we create a fake root node that holds all the root options.\n walk({ children: this.forest.normalizedOptions })\n },\n\n toggleClickOutsideEvent(enabled) {\n if (enabled) {\n document.addEventListener('mousedown', this.handleClickOutside, false)\n } else {\n document.removeEventListener('mousedown', this.handleClickOutside, false)\n }\n },\n\n getValueContainer() {\n return this.$refs.control.$refs['value-container']\n },\n\n getInput() {\n return this.getValueContainer().$refs.input\n },\n\n focusInput() {\n this.getInput().focus()\n },\n\n blurInput() {\n this.getInput().blur()\n },\n\n handleMouseDown: onLeftClick(function handleMouseDown(evt) {\n evt.preventDefault()\n evt.stopPropagation()\n\n if (this.disabled) return\n\n const isClickedOnValueContainer = this.getValueContainer().$el.contains(evt.target)\n if (isClickedOnValueContainer && !this.menu.isOpen && (this.openOnClick || this.trigger.isFocused)) {\n this.openMenu()\n }\n\n if (this._blurOnSelect) {\n this.blurInput()\n } else {\n // Focus the input or prevent blurring.\n this.focusInput()\n }\n\n this.resetFlags()\n }),\n\n handleClickOutside(evt) {\n // istanbul ignore else\n if (this.$refs.wrapper && !this.$refs.wrapper.contains(evt.target)) {\n this.blurInput()\n this.closeMenu()\n }\n },\n\n handleLocalSearch() {\n const { searchQuery } = this.trigger\n const done = () => this.resetHighlightedOptionWhenNecessary(true)\n\n if (!searchQuery) {\n // Exit sync search mode.\n this.localSearch.active = false\n return done()\n }\n\n // Enter sync search mode.\n this.localSearch.active = true\n\n // Reset states.\n this.localSearch.noResults = true\n this.traverseAllNodesDFS(node => {\n if (node.isBranch) {\n node.isExpandedOnSearch = false\n node.showAllChildrenOnSearch = false\n node.isMatched = false\n node.hasMatchedDescendants = false\n this.$set(this.localSearch.countMap, node.id, {\n [ALL_CHILDREN]: 0,\n [ALL_DESCENDANTS]: 0,\n [LEAF_CHILDREN]: 0,\n [LEAF_DESCENDANTS]: 0,\n })\n }\n })\n\n const lowerCasedSearchQuery = removeAccents(searchQuery).trim().toLocaleLowerCase()\n const splitSearchQuery = lowerCasedSearchQuery.replace(/\\s+/g, ' ').split(' ')\n this.traverseAllNodesDFS(node => {\n if (this.searchNested && splitSearchQuery.length > 1) {\n node.isMatched = splitSearchQuery.every(filterValue =>\n match(false, filterValue, node.nestedSearchLabel),\n )\n } else {\n node.isMatched = this.matchKeys.some(matchKey =>\n match(!this.disableFuzzyMatching, lowerCasedSearchQuery, node.lowerCased[matchKey]),\n )\n }\n\n if (node.isMatched) {\n this.localSearch.noResults = false\n node.ancestors.forEach(ancestor => this.localSearch.countMap[ancestor.id][ALL_DESCENDANTS]++)\n if (node.isLeaf) node.ancestors.forEach(ancestor => this.localSearch.countMap[ancestor.id][LEAF_DESCENDANTS]++)\n if (node.parentNode !== NO_PARENT_NODE) {\n this.localSearch.countMap[node.parentNode.id][ALL_CHILDREN] += 1\n // istanbul ignore else\n if (node.isLeaf) this.localSearch.countMap[node.parentNode.id][LEAF_CHILDREN] += 1\n }\n }\n\n if (\n (node.isMatched || (node.isBranch && node.isExpandedOnSearch)) &&\n node.parentNode !== NO_PARENT_NODE\n ) {\n node.parentNode.isExpandedOnSearch = true\n node.parentNode.hasMatchedDescendants = true\n }\n })\n\n done()\n },\n\n handleRemoteSearch() {\n const { searchQuery } = this.trigger\n const entry = this.getRemoteSearchEntry()\n const done = () => {\n this.initialize()\n this.resetHighlightedOptionWhenNecessary(true)\n }\n\n if ((searchQuery === '' || this.cacheOptions) && entry.isLoaded) {\n return done()\n }\n\n this.callLoadOptionsProp({\n action: ASYNC_SEARCH,\n args: { searchQuery },\n isPending() {\n return entry.isLoading\n },\n start: () => {\n entry.isLoading = true\n entry.isLoaded = false\n entry.loadingError = ''\n },\n succeed: options => {\n entry.isLoaded = true\n entry.options = options\n // When the request completes, the search query may have changed.\n // We only show these options if they are for the current search query.\n if (this.trigger.searchQuery === searchQuery) done()\n },\n fail: err => {\n entry.loadingError = getErrorMessage(err)\n },\n end: () => {\n entry.isLoading = false\n },\n })\n },\n\n getRemoteSearchEntry() {\n const { searchQuery } = this.trigger\n const entry = this.remoteSearch[searchQuery] || {\n ...createAsyncOptionsStates(),\n options: [],\n }\n\n // Vue doesn't support directly watching on objects.\n this.$watch(\n () => entry.options,\n () => {\n // TODO: potential redundant re-initialization.\n if (this.trigger.searchQuery === searchQuery) this.initialize()\n },\n { deep: true },\n )\n\n if (searchQuery === '') {\n if (Array.isArray(this.defaultOptions)) {\n entry.options = this.defaultOptions\n entry.isLoaded = true\n return entry\n } else if (this.defaultOptions !== true) {\n entry.isLoaded = true\n return entry\n }\n }\n\n if (!this.remoteSearch[searchQuery]) {\n this.$set(this.remoteSearch, searchQuery, entry)\n }\n\n return entry\n },\n\n shouldExpand(node) {\n return this.localSearch.active ? node.isExpandedOnSearch : node.isExpanded\n },\n\n shouldOptionBeIncludedInSearchResult(node) {\n // 1) This option is matched.\n if (node.isMatched) return true\n // 2) This option is not matched, but has matched descendant(s).\n if (node.isBranch && node.hasMatchedDescendants && !this.flattenSearchResults) return true\n // 3) This option's parent has no matched descendants,\n // but after being expanded, all its children should be shown.\n if (!node.isRootNode && node.parentNode.showAllChildrenOnSearch) return true\n // 4) The default case.\n return false\n },\n\n shouldShowOptionInMenu(node) {\n if (this.localSearch.active && !this.shouldOptionBeIncludedInSearchResult(node)) {\n return false\n }\n return true\n },\n\n getControl() {\n return this.$refs.control.$el\n },\n\n getMenu() {\n const ref = this.appendToBody ? this.$refs.portal.portalTarget : this\n const $menu = ref.$refs.menu.$refs.menu\n return $menu && $menu.nodeName !== '#comment' ? $menu : null\n },\n\n setCurrentHighlightedOption(node, scroll = true) {\n const prev = this.menu.current\n if (prev != null && prev in this.forest.nodeMap) {\n this.forest.nodeMap[prev].isHighlighted = false\n }\n\n this.menu.current = node.id\n node.isHighlighted = true\n\n if (this.menu.isOpen && scroll) {\n const scrollToOption = () => {\n const $menu = this.getMenu()\n const $option = $menu.querySelector(`.vue-treeselect__option[data-id=\"${node.id}\"]`)\n if ($option) scrollIntoView($menu, $option)\n }\n\n // In case `openMenu()` is just called and the menu is not rendered yet.\n if (this.getMenu()) {\n scrollToOption()\n } else {\n // istanbul ignore next\n this.$nextTick(scrollToOption)\n }\n }\n },\n\n resetHighlightedOptionWhenNecessary(forceReset = false) {\n const { current } = this.menu\n\n if (\n forceReset || current == null ||\n !(current in this.forest.nodeMap) ||\n !this.shouldShowOptionInMenu(this.getNode(current))\n ) {\n this.highlightFirstOption()\n }\n },\n\n highlightFirstOption() {\n if (!this.hasVisibleOptions) return\n\n const first = this.visibleOptionIds[0]\n this.setCurrentHighlightedOption(this.getNode(first))\n },\n\n highlightPrevOption() {\n if (!this.hasVisibleOptions) return\n\n const prev = this.visibleOptionIds.indexOf(this.menu.current) - 1\n if (prev === -1) return this.highlightLastOption()\n this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[prev]))\n },\n\n highlightNextOption() {\n if (!this.hasVisibleOptions) return\n\n const next = this.visibleOptionIds.indexOf(this.menu.current) + 1\n if (next === this.visibleOptionIds.length) return this.highlightFirstOption()\n this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[next]))\n },\n\n highlightLastOption() {\n if (!this.hasVisibleOptions) return\n\n const last = getLast(this.visibleOptionIds)\n this.setCurrentHighlightedOption(this.getNode(last))\n },\n\n resetSearchQuery() {\n this.trigger.searchQuery = ''\n },\n\n closeMenu() {\n if (!this.menu.isOpen || (!this.disabled && this.alwaysOpen)) return\n this.saveMenuScrollPosition()\n this.menu.isOpen = false\n this.toggleClickOutsideEvent(false)\n this.resetSearchQuery()\n this.$emit('close', this.getValue(), this.getInstanceId())\n },\n\n openMenu() {\n if (this.disabled || this.menu.isOpen) return\n this.menu.isOpen = true\n this.$nextTick(this.resetHighlightedOptionWhenNecessary)\n this.$nextTick(this.restoreMenuScrollPosition)\n if (!this.options && !this.async) this.loadRootOptions()\n this.toggleClickOutsideEvent(true)\n this.$emit('open', this.getInstanceId())\n },\n\n toggleMenu() {\n if (this.menu.isOpen) {\n this.closeMenu()\n } else {\n this.openMenu()\n }\n },\n\n toggleExpanded(node) {\n let nextState\n\n if (this.localSearch.active) {\n nextState = node.isExpandedOnSearch = !node.isExpandedOnSearch\n if (nextState) node.showAllChildrenOnSearch = true\n } else {\n nextState = node.isExpanded = !node.isExpanded\n }\n\n if (nextState && !node.childrenStates.isLoaded) {\n this.loadChildrenOptions(node)\n }\n },\n\n buildForestState() {\n const selectedNodeMap = createMap()\n this.forest.selectedNodeIds.forEach(selectedNodeId => {\n selectedNodeMap[selectedNodeId] = true\n })\n this.forest.selectedNodeMap = selectedNodeMap\n\n const checkedStateMap = createMap()\n if (this.multiple) {\n this.traverseAllNodesByIndex(node => {\n checkedStateMap[node.id] = UNCHECKED\n })\n\n this.selectedNodes.forEach(selectedNode => {\n checkedStateMap[selectedNode.id] = CHECKED\n\n if (!this.flat && !this.disableBranchNodes) {\n selectedNode.ancestors.forEach(ancestorNode => {\n if (!this.isSelected(ancestorNode)) {\n checkedStateMap[ancestorNode.id] = INDETERMINATE\n }\n })\n }\n })\n }\n this.forest.checkedStateMap = checkedStateMap\n },\n\n enhancedNormalizer(raw) {\n return {\n ...raw,\n ...this.normalizer(raw, this.getInstanceId()),\n }\n },\n\n normalize(parentNode, nodes, prevNodeMap) {\n let normalizedOptions = nodes\n .map(node => [ this.enhancedNormalizer(node), node ])\n .map(([ node, raw ], index) => {\n this.checkDuplication(node)\n this.verifyNodeShape(node)\n\n const { id, label, children, isDefaultExpanded } = node\n const isRootNode = parentNode === NO_PARENT_NODE\n const level = isRootNode ? 0 : parentNode.level + 1\n const isBranch = Array.isArray(children) || children === null\n const isLeaf = !isBranch\n const isDisabled = !!node.isDisabled || (!this.flat && !isRootNode && parentNode.isDisabled)\n const isNew = !!node.isNew\n const lowerCased = this.matchKeys.reduce((prev, key) => ({\n ...prev,\n [key]: stringifyOptionPropValue(node[key]).toLocaleLowerCase(),\n }), {})\n const nestedSearchLabel = isRootNode\n ? lowerCased.label\n : parentNode.nestedSearchLabel + ' ' + lowerCased.label\n\n const normalized = this.$set(this.forest.nodeMap, id, createMap())\n this.$set(normalized, 'id', id)\n this.$set(normalized, 'label', label)\n this.$set(normalized, 'level', level)\n this.$set(normalized, 'ancestors', isRootNode ? [] : [ parentNode ].concat(parentNode.ancestors))\n this.$set(normalized, 'index', (isRootNode ? [] : parentNode.index).concat(index))\n this.$set(normalized, 'parentNode', parentNode)\n this.$set(normalized, 'lowerCased', lowerCased)\n this.$set(normalized, 'nestedSearchLabel', nestedSearchLabel)\n this.$set(normalized, 'isDisabled', isDisabled)\n this.$set(normalized, 'isNew', isNew)\n this.$set(normalized, 'isMatched', false)\n this.$set(normalized, 'isHighlighted', false)\n this.$set(normalized, 'isBranch', isBranch)\n this.$set(normalized, 'isLeaf', isLeaf)\n this.$set(normalized, 'isRootNode', isRootNode)\n this.$set(normalized, 'raw', raw)\n\n if (isBranch) {\n const isLoaded = Array.isArray(children)\n\n this.$set(normalized, 'childrenStates', {\n ...createAsyncOptionsStates(),\n isLoaded,\n })\n this.$set(normalized, 'isExpanded', typeof isDefaultExpanded === 'boolean'\n ? isDefaultExpanded\n : level < this.defaultExpandLevel)\n this.$set(normalized, 'hasMatchedDescendants', false)\n this.$set(normalized, 'hasDisabledDescendants', false)\n this.$set(normalized, 'isExpandedOnSearch', false)\n this.$set(normalized, 'showAllChildrenOnSearch', false)\n this.$set(normalized, 'count', {\n [ALL_CHILDREN]: 0,\n [ALL_DESCENDANTS]: 0,\n [LEAF_CHILDREN]: 0,\n [LEAF_DESCENDANTS]: 0,\n })\n this.$set(normalized, 'children', isLoaded\n ? this.normalize(normalized, children, prevNodeMap)\n : [])\n\n if (isDefaultExpanded === true) normalized.ancestors.forEach(ancestor => {\n ancestor.isExpanded = true\n })\n\n if (!isLoaded && typeof this.loadOptions !== 'function') {\n warning(\n () => false,\n () => 'Unloaded branch node detected. \"loadOptions\" prop is required to load its children.',\n )\n } else if (!isLoaded && normalized.isExpanded) {\n this.loadChildrenOptions(normalized)\n }\n }\n\n normalized.ancestors.forEach(ancestor => ancestor.count[ALL_DESCENDANTS]++)\n if (isLeaf) normalized.ancestors.forEach(ancestor => ancestor.count[LEAF_DESCENDANTS]++)\n if (!isRootNode) {\n parentNode.count[ALL_CHILDREN] += 1\n if (isLeaf) parentNode.count[LEAF_CHILDREN] += 1\n if (isDisabled) parentNode.hasDisabledDescendants = true\n }\n\n // Preserve previous states.\n if (prevNodeMap && prevNodeMap[id]) {\n const prev = prevNodeMap[id]\n\n normalized.isMatched = prev.isMatched\n normalized.showAllChildrenOnSearch = prev.showAllChildrenOnSearch\n normalized.isHighlighted = prev.isHighlighted\n\n if (prev.isBranch && normalized.isBranch) {\n normalized.isExpanded = prev.isExpanded\n normalized.isExpandedOnSearch = prev.isExpandedOnSearch\n // #97\n // If `isLoaded` was true, but IS NOT now, we consider this branch node\n // to be reset to unloaded state by the user of this component.\n if (prev.childrenStates.isLoaded && !normalized.childrenStates.isLoaded) {\n // Make sure the node is collapsed, then the user can load its\n // children again (by expanding).\n normalized.isExpanded = false\n // We have reset `childrenStates` and don't want to preserve states here.\n } else {\n normalized.childrenStates = { ...prev.childrenStates }\n }\n }\n }\n\n return normalized\n })\n\n if (this.branchNodesFirst) {\n const branchNodes = normalizedOptions.filter(option => option.isBranch)\n const leafNodes = normalizedOptions.filter(option => option.isLeaf)\n normalizedOptions = branchNodes.concat(leafNodes)\n }\n\n return normalizedOptions\n },\n\n loadRootOptions() {\n this.callLoadOptionsProp({\n action: LOAD_ROOT_OPTIONS,\n isPending: () => {\n return this.rootOptionsStates.isLoading\n },\n start: () => {\n this.rootOptionsStates.isLoading = true\n this.rootOptionsStates.loadingError = ''\n },\n succeed: () => {\n this.rootOptionsStates.isLoaded = true\n // Wait for `options` being re-initialized.\n this.$nextTick(() => {\n this.resetHighlightedOptionWhenNecessary(true)\n })\n },\n fail: err => {\n this.rootOptionsStates.loadingError = getErrorMessage(err)\n },\n end: () => {\n this.rootOptionsStates.isLoading = false\n },\n })\n },\n\n loadChildrenOptions(parentNode) {\n // The options may be re-initialized anytime during the loading process.\n // So `parentNode` can be stale and we use `getNode()` to avoid that.\n\n const { id, raw } = parentNode\n\n this.callLoadOptionsProp({\n action: LOAD_CHILDREN_OPTIONS,\n args: {\n // We always pass the raw node instead of the normalized node to any\n // callback provided by the user of this component.\n // Because the shape of the raw node is more likely to be closing to\n // what the back-end API service of the application needs.\n parentNode: raw,\n },\n isPending: () => {\n return this.getNode(id).childrenStates.isLoading\n },\n start: () => {\n this.getNode(id).childrenStates.isLoading = true\n this.getNode(id).childrenStates.loadingError = ''\n },\n succeed: () => {\n this.getNode(id).childrenStates.isLoaded = true\n },\n fail: err => {\n this.getNode(id).childrenStates.loadingError = getErrorMessage(err)\n },\n end: () => {\n this.getNode(id).childrenStates.isLoading = false\n },\n })\n },\n\n callLoadOptionsProp({ action, args, isPending, start, succeed, fail, end }) {\n if (!this.loadOptions || isPending()) {\n return\n }\n\n start()\n\n const callback = once((err, result) => {\n if (err) {\n fail(err)\n } else {\n succeed(result)\n }\n\n end()\n })\n const result = this.loadOptions({\n id: this.getInstanceId(),\n instanceId: this.getInstanceId(),\n action,\n ...args,\n callback,\n })\n\n if (isPromise(result)) {\n result.then(() => {\n callback()\n }, err => {\n callback(err)\n }).catch(err => {\n // istanbul ignore next\n console.error(err)\n })\n }\n },\n\n checkDuplication(node) {\n warning(\n () => !((node.id in this.forest.nodeMap) && !this.forest.nodeMap[node.id].isFallbackNode),\n () => `Detected duplicate presence of node id ${JSON.stringify(node.id)}. ` +\n `Their labels are \"${this.forest.nodeMap[node.id].label}\" and \"${node.label}\" respectively.`,\n )\n },\n\n verifyNodeShape(node) {\n warning(\n () => !(node.children === undefined && node.isBranch === true),\n () => 'Are you meant to declare an unloaded branch node? ' +\n '`isBranch: true` is no longer supported, please use `children: null` instead.',\n )\n },\n\n select(node) {\n if (this.disabled || node.isDisabled) {\n return\n }\n\n if (this.single) {\n this.clear()\n }\n\n const nextState = this.multiple && !this.flat\n ? this.forest.checkedStateMap[node.id] === UNCHECKED\n : !this.isSelected(node)\n\n if (nextState) {\n this._selectNode(node)\n } else {\n this._deselectNode(node)\n }\n\n this.buildForestState()\n\n if (nextState) {\n this.$emit('select', node.raw, this.getInstanceId())\n } else {\n this.$emit('deselect', node.raw, this.getInstanceId())\n }\n\n if (this.localSearch.active && nextState && (this.single || this.clearOnSelect)) {\n this.resetSearchQuery()\n }\n\n if (this.single && this.closeOnSelect) {\n this.closeMenu()\n\n // istanbul ignore else\n if (this.searchable) {\n this._blurOnSelect = true\n }\n }\n },\n\n clear() {\n if (this.hasValue) {\n if (this.single || this.allowClearingDisabled) {\n this.forest.selectedNodeIds = []\n } else /* if (this.multiple && !this.allowClearingDisabled) */ {\n this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(nodeId =>\n this.getNode(nodeId).isDisabled,\n )\n }\n\n this.buildForestState()\n }\n },\n\n // This is meant to be called only by `select()`.\n _selectNode(node) {\n node.hasBeenSelected = node.id\n if (this.single || this.disableBranchNodes) {\n return this.addValue(node)\n }\n\n if (this.flat) {\n this.addValue(node)\n\n if (this.autoSelectAncestors) {\n node.ancestors.forEach(ancestor => {\n if (!this.isSelected(ancestor) && !ancestor.isDisabled) this.addValue(ancestor)\n })\n } else if (this.autoSelectDescendants) {\n this.traverseDescendantsBFS(node, descendant => {\n if (!this.isSelected(descendant) && !descendant.isDisabled) this.addValue(descendant)\n })\n }\n\n return\n }\n\n const isFullyChecked = (\n node.isLeaf ||\n (/* node.isBranch && */!node.hasDisabledDescendants) ||\n (/* node.isBranch && */this.allowSelectingDisabledDescendants)\n )\n if (isFullyChecked) {\n this.addValue(node)\n }\n\n if (node.isBranch) {\n this.traverseDescendantsBFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n this.addValue(descendant)\n }\n })\n }\n\n if (isFullyChecked) {\n let curr = node\n while ((curr = curr.parentNode) !== NO_PARENT_NODE) {\n if (curr.children.every(this.isSelected)) this.addValue(curr)\n else break\n }\n }\n },\n\n // This is meant to be called only by `select()`.\n _deselectNode(node) {\n if (this.disableBranchNodes) {\n return this.removeValue(node)\n }\n\n if (this.flat) {\n this.removeValue(node)\n\n if (this.autoDeselectAncestors) {\n node.ancestors.forEach(ancestor => {\n if (this.isSelected(ancestor) && !ancestor.isDisabled) this.removeValue(ancestor)\n })\n } else if (this.autoDeselectDescendants) {\n this.traverseDescendantsBFS(node, descendant => {\n if (this.isSelected(descendant) && !descendant.isDisabled) this.removeValue(descendant)\n })\n }\n\n return\n }\n\n let hasUncheckedSomeDescendants = false\n if (node.isBranch) {\n this.traverseDescendantsDFS(node, descendant => {\n if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) {\n this.removeValue(descendant)\n hasUncheckedSomeDescendants = true\n }\n })\n }\n\n if (\n node.isLeaf ||\n /* node.isBranch && */hasUncheckedSomeDescendants ||\n /* node.isBranch && */node.children.length === 0\n ) {\n this.removeValue(node)\n\n let curr = node\n while ((curr = curr.parentNode) !== NO_PARENT_NODE) {\n if (this.isSelected(curr)) this.removeValue(curr)\n else break\n }\n }\n },\n\n addValue(node) {\n this.forest.selectedNodeIds.push(node.id)\n this.forest.selectedNodeMap[node.id] = true\n },\n\n removeValue(node) {\n delete node.hasBeenSelected\n removeFromArray(this.forest.selectedNodeIds, node.id)\n delete this.forest.selectedNodeMap[node.id]\n },\n\n removeLastValue() {\n if (!this.hasValue) return\n if (this.single) return this.clear()\n const lastValue = getLast(this.internalValue)\n const lastSelectedNode = this.getNode(lastValue)\n this.select(lastSelectedNode) // deselect\n },\n\n saveMenuScrollPosition() {\n const $menu = this.getMenu()\n // istanbul ignore else\n if ($menu) this.menu.lastScrollPosition = $menu.scrollTop\n },\n\n restoreMenuScrollPosition() {\n const $menu = this.getMenu()\n // istanbul ignore else\n if ($menu) $menu.scrollTop = this.menu.lastScrollPosition\n },\n },\n\n created() {\n this.verifyProps()\n this.resetFlags()\n },\n\n mounted() {\n if (this.autoFocus) this.focusInput()\n if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions()\n if (this.alwaysOpen) this.openMenu()\n if (this.async && this.defaultOptions) this.handleRemoteSearch()\n },\n\n destroyed() {\n // istanbul ignore next\n this.toggleClickOutsideEvent(false)\n },\n}\n","\n","/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nexport default function normalizeComponent (\n scriptExports,\n render,\n staticRenderFns,\n functionalTemplate,\n injectStyles,\n scopeId,\n moduleIdentifier, /* server only */\n shadowMode /* vue-cli only */\n) {\n // Vue.extend constructor export interop\n var options = typeof scriptExports === 'function'\n ? scriptExports.options\n : scriptExports\n\n // render functions\n if (render) {\n options.render = render\n options.staticRenderFns = staticRenderFns\n options._compiled = true\n }\n\n // functional template\n if (functionalTemplate) {\n options.functional = true\n }\n\n // scopedId\n if (scopeId) {\n options._scopeId = 'data-v-' + scopeId\n }\n\n var hook\n if (moduleIdentifier) { // server build\n hook = function (context) {\n // 2.3 injection\n context =\n context || // cached call\n (this.$vnode && this.$vnode.ssrContext) || // stateful\n (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n // 2.2 with runInNewContext: true\n if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n context = __VUE_SSR_CONTEXT__\n }\n // inject component styles\n if (injectStyles) {\n injectStyles.call(this, context)\n }\n // register component module identifier for async chunk inferrence\n if (context && context._registeredComponents) {\n context._registeredComponents.add(moduleIdentifier)\n }\n }\n // used by ssr in case component is cached and beforeCreate\n // never gets called\n options._ssrRegister = hook\n } else if (injectStyles) {\n hook = shadowMode\n ? function () {\n injectStyles.call(\n this,\n (options.functional ? this.parent : this).$root.$options.shadowRoot\n )\n }\n : injectStyles\n }\n\n if (hook) {\n if (options.functional) {\n // for template-only hot-reload because in that case the render fn doesn't\n // go through the normalizer\n options._injectStyles = hook\n // register for functional component in vue file\n var originalRender = options.render\n options.render = function renderWithStyleInjection (h, context) {\n hook.call(context)\n return originalRender(h, context)\n }\n } else {\n // inject component registration as beforeCreate hook\n var existing = options.beforeCreate\n options.beforeCreate = existing\n ? [].concat(existing, hook)\n : [hook]\n }\n }\n\n return {\n exports: scriptExports,\n options: options\n }\n}\n","var render, staticRenderFns\nimport script from \"./HiddenFields.vue?vue&type=script&lang=js&\"\nexport * from \"./HiddenFields.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('4d48089a')) {\n api.createRecord('4d48089a', component.options)\n } else {\n api.reload('4d48089a', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/HiddenFields.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./Input.vue?vue&type=script&lang=js&\"\nexport * from \"./Input.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('54844eca')) {\n api.createRecord('54844eca', component.options)\n } else {\n api.reload('54844eca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Input.vue\"\nexport default component.exports","var render, staticRenderFns\nimport script from \"./Placeholder.vue?vue&type=script&lang=js&\"\nexport * from \"./Placeholder.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('5a99d1f3')) {\n api.createRecord('5a99d1f3', component.options)\n } else {\n api.reload('5a99d1f3', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Placeholder.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./SingleValue.vue?vue&type=script&lang=js&\"\nexport * from \"./SingleValue.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('03d19b89')) {\n api.createRecord('03d19b89', component.options)\n } else {\n api.reload('03d19b89', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/SingleValue.vue\"\nexport default component.exports","\n","var render = function () {\n var _vm = this\n var _h = _vm.$createElement\n var _c = _vm._self._c || _h\n return _c(\n \"svg\",\n {\n attrs: {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 348.333 348.333\",\n },\n },\n [\n _c(\"path\", {\n attrs: {\n d: \"M336.559 68.611L231.016 174.165l105.543 105.549c15.699 15.705 15.699 41.145 0 56.85-7.844 7.844-18.128 11.769-28.407 11.769-10.296 0-20.581-3.919-28.419-11.769L174.167 231.003 68.609 336.563c-7.843 7.844-18.128 11.769-28.416 11.769-10.285 0-20.563-3.919-28.413-11.769-15.699-15.698-15.699-41.139 0-56.85l105.54-105.549L11.774 68.611c-15.699-15.699-15.699-41.145 0-56.844 15.696-15.687 41.127-15.687 56.829 0l105.563 105.554L279.721 11.767c15.705-15.687 41.139-15.687 56.832 0 15.705 15.699 15.705 41.145.006 56.844z\",\n },\n }),\n ]\n )\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\nexport { render, staticRenderFns }","\n\n\n","import { render, staticRenderFns } from \"./Delete.vue?vue&type=template&id=364b6320&\"\nimport script from \"./Delete.vue?vue&type=script&lang=js&\"\nexport * from \"./Delete.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('364b6320')) {\n api.createRecord('364b6320', component.options)\n } else {\n api.reload('364b6320', component.options)\n }\n module.hot.accept(\"./Delete.vue?vue&type=template&id=364b6320&\", function () {\n api.rerender('364b6320', {\n render: render,\n staticRenderFns: staticRenderFns\n })\n })\n }\n}\ncomponent.options.__file = \"src/components/icons/Delete.vue\"\nexport default component.exports","var render, staticRenderFns\nimport script from \"./MultiValueItem.vue?vue&type=script&lang=js&\"\nexport * from \"./MultiValueItem.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('6dd6c8ca')) {\n api.createRecord('6dd6c8ca', component.options)\n } else {\n api.reload('6dd6c8ca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MultiValueItem.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./MultiValue.vue?vue&type=script&lang=js&\"\nexport * from \"./MultiValue.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('14fca5e8')) {\n api.createRecord('14fca5e8', component.options)\n } else {\n api.reload('14fca5e8', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MultiValue.vue\"\nexport default component.exports","\n","var render = function () {\n var _vm = this\n var _h = _vm.$createElement\n var _c = _vm._self._c || _h\n return _c(\n \"svg\",\n {\n attrs: {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 292.362 292.362\",\n },\n },\n [\n _c(\"path\", {\n attrs: {\n d: \"M286.935 69.377c-3.614-3.617-7.898-5.424-12.848-5.424H18.274c-4.952 0-9.233 1.807-12.85 5.424C1.807 72.998 0 77.279 0 82.228c0 4.948 1.807 9.229 5.424 12.847l127.907 127.907c3.621 3.617 7.902 5.428 12.85 5.428s9.233-1.811 12.847-5.428L286.935 95.074c3.613-3.617 5.427-7.898 5.427-12.847 0-4.948-1.814-9.229-5.427-12.85z\",\n },\n }),\n ]\n )\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\nexport { render, staticRenderFns }","\n\n\n","import { render, staticRenderFns } from \"./Arrow.vue?vue&type=template&id=11186cd4&\"\nimport script from \"./Arrow.vue?vue&type=script&lang=js&\"\nexport * from \"./Arrow.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('11186cd4')) {\n api.createRecord('11186cd4', component.options)\n } else {\n api.reload('11186cd4', component.options)\n }\n module.hot.accept(\"./Arrow.vue?vue&type=template&id=11186cd4&\", function () {\n api.rerender('11186cd4', {\n render: render,\n staticRenderFns: staticRenderFns\n })\n })\n }\n}\ncomponent.options.__file = \"src/components/icons/Arrow.vue\"\nexport default component.exports","var render, staticRenderFns\nimport script from \"./Control.vue?vue&type=script&lang=js&\"\nexport * from \"./Control.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('2fa0a0dd')) {\n api.createRecord('2fa0a0dd', component.options)\n } else {\n api.reload('2fa0a0dd', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Control.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./Tip.vue?vue&type=script&lang=js&\"\nexport * from \"./Tip.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('9f31bdca')) {\n api.createRecord('9f31bdca', component.options)\n } else {\n api.reload('9f31bdca', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Tip.vue\"\nexport default component.exports","\n","\n","var render, staticRenderFns\nimport script from \"./Option.vue?vue&type=script&lang=js&\"\nexport * from \"./Option.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('3dddec25')) {\n api.createRecord('3dddec25', component.options)\n } else {\n api.reload('3dddec25', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Option.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./Menu.vue?vue&type=script&lang=js&\"\nexport * from \"./Menu.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('9bcc0be2')) {\n api.createRecord('9bcc0be2', component.options)\n } else {\n api.reload('9bcc0be2', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Menu.vue\"\nexport default component.exports","\n","var render, staticRenderFns\nimport script from \"./MenuPortal.vue?vue&type=script&lang=js&\"\nexport * from \"./MenuPortal.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('4802d94a')) {\n api.createRecord('4802d94a', component.options)\n } else {\n api.reload('4802d94a', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/MenuPortal.vue\"\nexport default component.exports","var render, staticRenderFns\nimport script from \"./Treeselect.vue?vue&type=script&lang=js&\"\nexport * from \"./Treeselect.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\n/* hot reload */\nif (module.hot) {\n var api = require(\"/home/law/repo/adage/vue-treeselect/node_modules/vue-hot-reload-api/dist/index.js\")\n api.install(require('vue'))\n if (api.compatible) {\n module.hot.accept()\n if (!api.isRecorded('aebf116c')) {\n api.createRecord('aebf116c', component.options)\n } else {\n api.reload('aebf116c', component.options)\n }\n \n }\n}\ncomponent.options.__file = \"src/components/Treeselect.vue\"\nexport default component.exports","\n","import Treeselect from './components/Treeselect'\nimport treeselectMixin from './mixins/treeselectMixin'\nimport './style.less'\n\nexport default Treeselect\nexport { Treeselect, treeselectMixin }\nexport {\n // Delayed loading.\n LOAD_ROOT_OPTIONS,\n LOAD_CHILDREN_OPTIONS,\n ASYNC_SEARCH,\n} from './constants'\n\nexport const VERSION = PKG_VERSION\n"],"sourceRoot":""} \ No newline at end of file diff --git a/docs/components/BasicFeatures.vue b/docs/components/BasicFeatures.vue index 504b0030..6a4576c7 100644 --- a/docs/components/BasicFeatures.vue +++ b/docs/components/BasicFeatures.vue @@ -24,6 +24,9 @@ }, { id: 'grapes', label: 'Grapes 🍇', + }, { + id: 'bete', + label: 'bêtes', }, { id: 'pear', label: 'Pear 🍐', diff --git a/docs/components/PreventValueCombining.vue b/docs/components/PreventValueCombining.vue index 013e5dd2..a60321a7 100644 --- a/docs/components/PreventValueCombining.vue +++ b/docs/components/PreventValueCombining.vue @@ -3,6 +3,7 @@ @@ -20,36 +21,51 @@ diff --git a/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index c9de00b5..936348db 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -42,11 +42,15 @@ function createAsyncOptionsStates() { } function stringifyOptionPropValue(value) { - if (typeof value === 'string') return value + if (typeof value === 'string') return removeAccents(value) if (typeof value === 'number' && !isNaN(value)) return value + '' // istanbul ignore next return '' } +function removeAccents(str) { + if (!str) return '' + return str.normalize('NFD').replace(/[\u0300-\u036F]/g, '') +} function match(enableFuzzyMatch, needle, haystack) { return enableFuzzyMatch @@ -949,14 +953,39 @@ export default { getValue() { if (this.valueFormat === 'id') { return this.multiple - ? this.internalValue.slice() + ? this.getUniqChildValues(this.internalValue.slice()) : this.internalValue[0] } const rawNodes = this.internalValue.map(id => this.getNode(id).raw) - return this.multiple ? rawNodes : rawNodes[0] + return this.multiple + ? this.getUniqChildValues(rawNodes) + : rawNodes[0] + }, + + getUniqChildValues(ids) { + if (this.valueConsistsOf !== BRANCH_PRIORITY) return ids + const values = ids.map(id => { + const node = this.getNode(id) + if (node.hasBeenSelected) return node.id + if (this.hasOneChild(node)) { + const children = [] + this.traverseDescendantsBFS(node, descendant => { + if (!descendant.isDisabled || this.allowSelectingDisabledDescendants) { + if (descendant.hasBeenSelected) { + children.push(descendant.id) + } + } + }) + if (children && children.length) return children[0] + } + return id + }) + return values + }, + hasOneChild(node) { + return node && node.children && node.children.length === 1 }, - getNode(nodeId) { warning( () => nodeId != null, @@ -1222,7 +1251,7 @@ export default { } }) - const lowerCasedSearchQuery = searchQuery.trim().toLocaleLowerCase() + const lowerCasedSearchQuery = removeAccents(searchQuery).trim().toLocaleLowerCase() const splitSearchQuery = lowerCasedSearchQuery.replace(/\s+/g, ' ').split(' ') this.traverseAllNodesDFS(node => { if (this.searchNested && splitSearchQuery.length > 1) { @@ -1806,6 +1835,7 @@ export default { // This is meant to be called only by `select()`. _selectNode(node) { + node.hasBeenSelected = node.id if (this.single || this.disableBranchNodes) { return this.addValue(node) } @@ -1905,6 +1935,7 @@ export default { }, removeValue(node) { + delete node.hasBeenSelected removeFromArray(this.forest.selectedNodeIds, node.id) delete this.forest.selectedNodeMap[node.id] },