From 534c8e1c9316b11afb68d891b0264b20f5816430 Mon Sep 17 00:00:00 2001 From: "Davaadorj.U" Date: Sat, 5 Dec 2020 11:48:03 +0800 Subject: [PATCH 01/20] 2 props added for search permormance improvement when large amount of options. --- src/mixins/treeselectMixin.js | 61 ++++++++++++++++++++++++++++++++++- 1 file changed, 60 insertions(+), 1 deletion(-) diff --git a/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index c9de00b5..1cd20a56 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -542,6 +542,25 @@ export default { default: false, }, + /** + * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well. + * default: 1 + */ + startSearchLength: { + type: Number, + default: 1 + }, + + /** + * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there. + * default: 0 + * time measurement: millisecond + */ + waitSearchFinishTime: { + type: Number, + default: 0 + }, + /** * Used in conjunction with `showCount` to specify which type of count number should be displayed. * Acceptable values: @@ -684,6 +703,8 @@ export default { countMap: createMap(), }, + lastSearchInput: null, + // map. remoteSearch: createMap(), } @@ -1192,16 +1213,52 @@ export default { } }, - handleLocalSearch() { + handleLocalSearch(retry) { const { searchQuery } = this.trigger const done = () => this.resetHighlightedOptionWhenNecessary(true) if (!searchQuery) { // Exit sync search mode. this.localSearch.active = false + this.lastSearchInput = null return done() } + if (searchQuery.length < this.startSearchLength) { + // Ignore. + return + } + + if (this.waitSearchFinishTime > 0) { + // If waitSearchFinishTime configured. + const now = new Date() + if (!this.lastSearchInput) { + // First time. + setTimeout(() => { + this.handleLocalSearch(true) + }, this.waitSearchFinishTime); + + this.lastSearchInput = now + return + } + + const diff = now - this.lastSearchInput + if (diff < this.waitSearchFinishTime && !retry) { + setTimeout(() => { + this.handleLocalSearch(true) + }, this.waitSearchFinishTime); + + this.lastSearchInput = now + return + } + + if (retry && diff < this.waitSearchFinishTime) { + return + } + + this.lastSearchInput = now + } + // Enter sync search mode. this.localSearch.active = true @@ -1256,6 +1313,8 @@ export default { }) done() + // Reset time + this.lastSearchInput = null }, handleRemoteSearch() { From 263919bf2cc23b3e1b7827790de18c499f73c70c Mon Sep 17 00:00:00 2001 From: "Davaadorj.U" Date: Sat, 5 Dec 2020 11:56:26 +0800 Subject: [PATCH 02/20] Added dist for npm install. --- .gitignore | 2 +- dist/vue-treeselect.cjs.js | 3955 +++++++++++++++++++++ dist/vue-treeselect.cjs.js.map | 1 + dist/vue-treeselect.cjs.min.js | 7 + dist/vue-treeselect.cjs.min.js.map | 1 + dist/vue-treeselect.css | 952 ++++++ dist/vue-treeselect.css.map | 1 + dist/vue-treeselect.min.css | 5 + dist/vue-treeselect.umd.js | 5089 ++++++++++++++++++++++++++++ dist/vue-treeselect.umd.js.map | 1 + dist/vue-treeselect.umd.min.js | 7 + dist/vue-treeselect.umd.min.js.map | 1 + 12 files changed, 10021 insertions(+), 1 deletion(-) create mode 100644 dist/vue-treeselect.cjs.js create mode 100644 dist/vue-treeselect.cjs.js.map create mode 100644 dist/vue-treeselect.cjs.min.js create mode 100644 dist/vue-treeselect.cjs.min.js.map create mode 100644 dist/vue-treeselect.css create mode 100644 dist/vue-treeselect.css.map create mode 100644 dist/vue-treeselect.min.css create mode 100644 dist/vue-treeselect.umd.js create mode 100644 dist/vue-treeselect.umd.js.map create mode 100644 dist/vue-treeselect.umd.min.js create mode 100644 dist/vue-treeselect.umd.min.js.map 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..81039717 --- /dev/null +++ b/dist/vue-treeselect.cjs.js @@ -0,0 +1,3955 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2020 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); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { defineProperty_default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 value; + if (typeof value === 'number' && !isNaN_isNaN(value)) return value + ''; + return ''; +} + +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 + }, + startSearchLength: { + type: Number, + default: 1 + }, + waitSearchFinishTime: { + type: Number, + default: 0 + }, + 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() + }, + lastSearchInput: null, + 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.internalValue.slice() : this.internalValue[0]; + } + + var rawNodes = this.internalValue.map(function (id) { + return _this4.getNode(id).raw; + }); + return this.multiple ? rawNodes : rawNodes[0]; + }, + 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 _this5 = 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 _this5.enhancedNormalizer(node); + }).map(function (node) { + return node.id; + }); + }, + extractNodeFromValue: function extractNodeFromValue(id) { + var _this6 = 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 && _this6.enhancedNormalizer(node).id === id; + }); + return matched || defaultNode; + }, + fixSelectedNodeIds: function fixSelectedNodeIds(nodeIdListOfPrevValue) { + var _this7 = 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 = _this7.getNode(nodeId); + + if (node.isBranch) _this7.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 = _this7.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 _this8 = this; + + this.forest.selectedNodeIds.forEach(function (id) { + if (!prevNodeMap[id]) return; + + var node = _objectSpread(_objectSpread({}, prevNodeMap[id]), {}, { + isFallbackNode: true + }); + + _this8.$set(_this8.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 _this9 = this; + + if (!parentNode.isBranch) return; + parentNode.children.forEach(function (child) { + _this9.traverseDescendantsDFS(child, callback); + + callback(child); + }); + }, + traverseAllNodesDFS: function traverseAllNodesDFS(callback) { + var _this10 = this; + + this.forest.normalizedOptions.forEach(function (rootNode) { + _this10.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(retry) { + var _this11 = this; + + var searchQuery = this.trigger.searchQuery; + + var done = function done() { + return _this11.resetHighlightedOptionWhenNecessary(true); + }; + + if (!searchQuery) { + this.localSearch.active = false; + this.lastSearchInput = null; + return done(); + } + + if (searchQuery.length < this.startSearchLength) { + return; + } + + if (this.waitSearchFinishTime > 0) { + var now = new Date(); + + if (!this.lastSearchInput) { + setTimeout(function () { + _this11.handleLocalSearch(true); + }, this.waitSearchFinishTime); + this.lastSearchInput = now; + return; + } + + var diff = now - this.lastSearchInput; + + if (diff < this.waitSearchFinishTime && !retry) { + setTimeout(function () { + _this11.handleLocalSearch(true); + }, this.waitSearchFinishTime); + this.lastSearchInput = now; + return; + } + + if (retry && diff < this.waitSearchFinishTime) { + return; + } + + this.lastSearchInput = now; + } + + this.localSearch.active = true; + this.localSearch.noResults = true; + this.traverseAllNodesDFS(function (node) { + if (node.isBranch) { + var _this11$$set; + + node.isExpandedOnSearch = false; + node.showAllChildrenOnSearch = false; + node.isMatched = false; + node.hasMatchedDescendants = false; + + _this11.$set(_this11.localSearch.countMap, node.id, (_this11$$set = {}, defineProperty_default()(_this11$$set, ALL_CHILDREN, 0), defineProperty_default()(_this11$$set, ALL_DESCENDANTS, 0), defineProperty_default()(_this11$$set, LEAF_CHILDREN, 0), defineProperty_default()(_this11$$set, LEAF_DESCENDANTS, 0), _this11$$set)); + } + }); + var lowerCasedSearchQuery = searchQuery.trim().toLocaleLowerCase(); + var splitSearchQuery = lowerCasedSearchQuery.replace(/\s+/g, ' ').split(' '); + this.traverseAllNodesDFS(function (node) { + if (_this11.searchNested && splitSearchQuery.length > 1) { + node.isMatched = splitSearchQuery.every(function (filterValue) { + return match(false, filterValue, node.nestedSearchLabel); + }); + } else { + node.isMatched = _this11.matchKeys.some(function (matchKey) { + return match(!_this11.disableFuzzyMatching, lowerCasedSearchQuery, node.lowerCased[matchKey]); + }); + } + + if (node.isMatched) { + _this11.localSearch.noResults = false; + node.ancestors.forEach(function (ancestor) { + return _this11.localSearch.countMap[ancestor.id][ALL_DESCENDANTS]++; + }); + if (node.isLeaf) node.ancestors.forEach(function (ancestor) { + return _this11.localSearch.countMap[ancestor.id][LEAF_DESCENDANTS]++; + }); + + if (node.parentNode !== NO_PARENT_NODE) { + _this11.localSearch.countMap[node.parentNode.id][ALL_CHILDREN] += 1; + if (node.isLeaf) _this11.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(); + this.lastSearchInput = null; + }, + handleRemoteSearch: function handleRemoteSearch() { + var _this12 = this; + + var searchQuery = this.trigger.searchQuery; + var entry = this.getRemoteSearchEntry(); + + var done = function done() { + _this12.initialize(); + + _this12.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 (_this12.trigger.searchQuery === searchQuery) done(); + }, + fail: function fail(err) { + entry.loadingError = getErrorMessage(err); + }, + end: function end() { + entry.isLoading = false; + } + }); + }, + getRemoteSearchEntry: function getRemoteSearchEntry() { + var _this13 = this; + + var searchQuery = this.trigger.searchQuery; + + var entry = this.remoteSearch[searchQuery] || _objectSpread(_objectSpread({}, createAsyncOptionsStates()), {}, { + options: [] + }); + + this.$watch(function () { + return entry.options; + }, function () { + if (_this13.trigger.searchQuery === searchQuery) _this13.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 _this14 = 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 = _this14.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 _this15 = 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 (!_this15.flat && !_this15.disableBranchNodes) { + selectedNode.ancestors.forEach(function (ancestorNode) { + if (!_this15.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 _this16 = this; + + var normalizedOptions = nodes.map(function (node) { + return [_this16.enhancedNormalizer(node), node]; + }).map(function (_ref, index) { + var _ref2 = slicedToArray_default()(_ref, 2), + node = _ref2[0], + raw = _ref2[1]; + + _this16.checkDuplication(node); + + _this16.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 || !_this16.flat && !isRootNode && parentNode.isDisabled; + var isNew = !!node.isNew; + + var lowerCased = _this16.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 = _this16.$set(_this16.forest.nodeMap, id, createMap()); + + _this16.$set(normalized, 'id', id); + + _this16.$set(normalized, 'label', label); + + _this16.$set(normalized, 'level', level); + + _this16.$set(normalized, 'ancestors', isRootNode ? [] : [parentNode].concat(parentNode.ancestors)); + + _this16.$set(normalized, 'index', (isRootNode ? [] : parentNode.index).concat(index)); + + _this16.$set(normalized, 'parentNode', parentNode); + + _this16.$set(normalized, 'lowerCased', lowerCased); + + _this16.$set(normalized, 'nestedSearchLabel', nestedSearchLabel); + + _this16.$set(normalized, 'isDisabled', isDisabled); + + _this16.$set(normalized, 'isNew', isNew); + + _this16.$set(normalized, 'isMatched', false); + + _this16.$set(normalized, 'isHighlighted', false); + + _this16.$set(normalized, 'isBranch', isBranch); + + _this16.$set(normalized, 'isLeaf', isLeaf); + + _this16.$set(normalized, 'isRootNode', isRootNode); + + _this16.$set(normalized, 'raw', raw); + + if (isBranch) { + var _this16$$set; + + var isLoaded = Array.isArray(children); + + _this16.$set(normalized, 'childrenStates', _objectSpread(_objectSpread({}, createAsyncOptionsStates()), {}, { + isLoaded: isLoaded + })); + + _this16.$set(normalized, 'isExpanded', typeof isDefaultExpanded === 'boolean' ? isDefaultExpanded : level < _this16.defaultExpandLevel); + + _this16.$set(normalized, 'hasMatchedDescendants', false); + + _this16.$set(normalized, 'hasDisabledDescendants', false); + + _this16.$set(normalized, 'isExpandedOnSearch', false); + + _this16.$set(normalized, 'showAllChildrenOnSearch', false); + + _this16.$set(normalized, 'count', (_this16$$set = {}, defineProperty_default()(_this16$$set, ALL_CHILDREN, 0), defineProperty_default()(_this16$$set, ALL_DESCENDANTS, 0), defineProperty_default()(_this16$$set, LEAF_CHILDREN, 0), defineProperty_default()(_this16$$set, LEAF_DESCENDANTS, 0), _this16$$set)); + + _this16.$set(normalized, 'children', isLoaded ? _this16.normalize(normalized, children, prevNodeMap) : []); + + if (isDefaultExpanded === true) normalized.ancestors.forEach(function (ancestor) { + ancestor.isExpanded = true; + }); + + if (!isLoaded && typeof _this16.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) { + _this16.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 _this17 = this; + + this.callLoadOptionsProp({ + action: LOAD_ROOT_OPTIONS, + isPending: function isPending() { + return _this17.rootOptionsStates.isLoading; + }, + start: function start() { + _this17.rootOptionsStates.isLoading = true; + _this17.rootOptionsStates.loadingError = ''; + }, + succeed: function succeed() { + _this17.rootOptionsStates.isLoaded = true; + + _this17.$nextTick(function () { + _this17.resetHighlightedOptionWhenNecessary(true); + }); + }, + fail: function fail(err) { + _this17.rootOptionsStates.loadingError = getErrorMessage(err); + }, + end: function end() { + _this17.rootOptionsStates.isLoading = false; + } + }); + }, + loadChildrenOptions: function loadChildrenOptions(parentNode) { + var _this18 = this; + + var id = parentNode.id, + raw = parentNode.raw; + this.callLoadOptionsProp({ + action: LOAD_CHILDREN_OPTIONS, + args: { + parentNode: raw + }, + isPending: function isPending() { + return _this18.getNode(id).childrenStates.isLoading; + }, + start: function start() { + _this18.getNode(id).childrenStates.isLoading = true; + _this18.getNode(id).childrenStates.loadingError = ''; + }, + succeed: function succeed() { + _this18.getNode(id).childrenStates.isLoaded = true; + }, + fail: function fail(err) { + _this18.getNode(id).childrenStates.loadingError = getErrorMessage(err); + }, + end: function end() { + _this18.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 _this19 = this; + + warning_warning(function () { + return !(node.id in _this19.forest.nodeMap && !_this19.forest.nodeMap[node.id].isFallbackNode); + }, function () { + return "Detected duplicate presence of node id ".concat(JSON.stringify(node.id), ". ") + "Their labels are \"".concat(_this19.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 _this20 = this; + + if (this.hasValue) { + if (this.single || this.allowClearingDisabled) { + this.forest.selectedNodeIds = []; + } else { + this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(function (nodeId) { + return _this20.getNode(nodeId).isDisabled; + }); + } + + this.buildForestState(); + } + }, + _selectNode: function _selectNode(node) { + var _this21 = this; + + if (this.single || this.disableBranchNodes) { + return this.addValue(node); + } + + if (this.flat) { + this.addValue(node); + + if (this.autoSelectAncestors) { + node.ancestors.forEach(function (ancestor) { + if (!_this21.isSelected(ancestor) && !ancestor.isDisabled) _this21.addValue(ancestor); + }); + } else if (this.autoSelectDescendants) { + this.traverseDescendantsBFS(node, function (descendant) { + if (!_this21.isSelected(descendant) && !descendant.isDisabled) _this21.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 || _this21.allowSelectingDisabledDescendants) { + _this21.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 _this22 = this; + + if (this.disableBranchNodes) { + return this.removeValue(node); + } + + if (this.flat) { + this.removeValue(node); + + if (this.autoDeselectAncestors) { + node.ancestors.forEach(function (ancestor) { + if (_this22.isSelected(ancestor) && !ancestor.isDisabled) _this22.removeValue(ancestor); + }); + } else if (this.autoDeselectDescendants) { + this.traverseDescendantsBFS(node, function (descendant) { + if (_this22.isSelected(descendant) && !descendant.isDisabled) _this22.removeValue(descendant); + }); + } + + return; + } + + var hasUncheckedSomeDescendants = false; + + if (node.isBranch) { + this.traverseDescendantsDFS(node, function (descendant) { + if (!descendant.isDisabled || _this22.allowSelectingDisabledDescendants) { + _this22.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) { + 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); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { MenuPortalvue_type_script_lang_js_ownKeys(Object(source), true).forEach(function (key) { defineProperty_default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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..ef13e82d --- /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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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":"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CA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyE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A,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;;AACA;AACA;AADA,8CAEA,WAFA,GAEA,IAFA;;AAIA;AACA;AACA;AADA;AADA;AAMA,WACA;AAAA;AAAA,QACA,mBADA,EAEA,iBACA,kCACA,2BADA,EAHA,EADA;AAUA;AA9RA;AAkSA,2E;;AC1SkN,CAAgB,4GAAG,EAAC,C;;ACAtO,IAAI,aAAM,EAAE,sBAAe;AAC+B;AACL;;;AAGrD;AAC0F;AAC1F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,yCAAM;AACR,EAAE,aAAM;AACR,EAAE,sBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAYf;AACD,gBAAS;AACM,sEAAS,Q;;AChCxB;AACA;AACA;AACA;AAEA;AACA,YADA;AAEA,kBAFA;AAGA,cAHA;AAIA;AAJA;AAOA;AACA,8BADA;AAEA,sBAFA;AAIA;AACA,aADA,uBACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA,KAPA;AASA,sBATA,gCASA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA;AAfA,GAJA;AAsBA;AACA,0BADA,8BACA,QADA,EACA;AACA;AAEA;AACA,OAHA,MAGA;AACA;AACA;AACA;AARA,GAtBA;AAiCA,SAjCA,qBAiCA;AACA;AACA;AACA,GApCA;AAsCA,SAtCA,qBAsCA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA1CA;AA4CA,WA5CA,uBA4CA;AACA;AACA,GA9CA;AAgDA;AACA,cADA,wBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uBADA,EAEA,iBACA,iCADA,GAEA,8BACA,iCADA,GAEA,4BANA,EAOA,sBAPA,EADA;AAWA,KAjBA;AAmBA,oBAnBA,8BAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,kCACA,oBADA,GAEA,IAFA;AAGA,KA1BA;AA4BA,mBA5BA,6BA4BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,iCACA,mBADA,GAEA,IAFA;AAGA,KAnCA;AAqCA,yBArCA,mCAqCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjDA;AAmDA,8BAnDA,wCAmDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA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ACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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..cde67b28 --- /dev/null +++ b/dist/vue-treeselect.cjs.min.js @@ -0,0 +1,7 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2020 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 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 Y})),n.d(t,"ASYNC_SEARCH",(function(){return K})),n.d(t,"VERSION",(function(){return it}));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=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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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=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 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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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=ce(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=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 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?n:"number"!=typeof n||C(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?b.label:e.nestedSearchLabel+" "+b.label,E=i.$set(i.forest.nodeMap,u,B());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",b),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",O),i.$set(E,"isNew",y),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",S),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(p);i.$set(E,"childrenStates",oe(oe({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"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:N(e,this.adjustMenuOpenDirection)})},setupMenuResizeAndScrollEventListeners:function(){var e=this.instance.getControl();this.menuResizeAndScrollEventListeners||(this.menuResizeAndScrollEventListeners={remove:w(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(14),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:w(e,this.updateMenuContainerOffset)})},setupControlSizeWatcher:function(){var e=this,t=this.instance.getControl();this.controlSizeWatcher||(this.controlSizeWatcher={remove:N(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(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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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..c84d2a6c --- /dev/null +++ b/dist/vue-treeselect.css @@ -0,0 +1,952 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2020 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..85a02786 --- /dev/null +++ b/dist/vue-treeselect.min.css @@ -0,0 +1,5 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2020 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..a20b6abb --- /dev/null +++ b/dist/vue-treeselect.umd.js @@ -0,0 +1,5089 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2020 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__36__) { +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 = 38); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 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; + +/***/ }), +/* 1 */ +/***/ (function(module, exports) { + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +module.exports = _arrayWithHoles; + +/***/ }), +/* 2 */ +/***/ (function(module, exports) { + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_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; + +/***/ }), +/* 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; + +/***/ }), +/* 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; + +/***/ }), +/* 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; + +/***/ }), +/* 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; + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + +var arrayLikeToArray = __webpack_require__(4); + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return arrayLikeToArray(arr); +} + +module.exports = _arrayWithoutHoles; + +/***/ }), +/* 8 */ +/***/ (function(module, exports) { + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +module.exports = _iterableToArray; + +/***/ }), +/* 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; + +/***/ }), +/* 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; + +/***/ }), +/* 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 isObject = __webpack_require__(14), + isSymbol = __webpack_require__(20); + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** Used to match leading and trailing whitespace. */ +var reTrim = /^\s+|\s+$/g; + +/** 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 = value.replace(reTrim, ''); + 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 baseGetTag = __webpack_require__(21), + isObjectLike = __webpack_require__(25); + +/** `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; + + +/***/ }), +/* 21 */ +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__(22), + getRawTag = __webpack_require__(23), + objectToString = __webpack_require__(24); + +/** `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; + + +/***/ }), +/* 22 */ +/***/ (function(module, exports, __webpack_require__) { + +var root = __webpack_require__(16); + +/** Built-in value references. */ +var Symbol = root.Symbol; + +module.exports = Symbol; + + +/***/ }), +/* 23 */ +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__(22); + +/** 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; + + +/***/ }), +/* 24 */ +/***/ (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; + + +/***/ }), +/* 25 */ +/***/ (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; + + +/***/ }), +/* 26 */ +/***/ (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'; +} + + +/***/ }), +/* 27 */ +/***/ (function(module, exports, __webpack_require__) { + +var before = __webpack_require__(28); + +/** + * 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; + + +/***/ }), +/* 28 */ +/***/ (function(module, exports, __webpack_require__) { + +var toInteger = __webpack_require__(29); + +/** 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; + + +/***/ }), +/* 29 */ +/***/ (function(module, exports, __webpack_require__) { + +var toFinite = __webpack_require__(30); + +/** + * 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; + + +/***/ }), +/* 30 */ +/***/ (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; + + +/***/ }), +/* 31 */ +/***/ (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; + + +/***/ }), +/* 32 */ +/***/ (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; + + +/***/ }), +/* 33 */ +/***/ (function(module, exports) { + +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + module.exports = _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + module.exports = _typeof = function _typeof(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); +} + +module.exports = _typeof; + +/***/ }), +/* 34 */ +/***/ (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; + + +/***/ }), +/* 35 */ +/***/ (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) + } +} + + +/***/ }), +/* 36 */ +/***/ (function(module, exports) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__36__; + +/***/ }), +/* 37 */ +/***/ (function(module, exports, __webpack_require__) { + +// extracted by mini-css-extract-plugin + +/***/ }), +/* 38 */ +/***/ (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__(26); +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__(27); +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__(31); +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__(32); +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__(33); +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__(34); +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); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { defineProperty_default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 value; + if (typeof value === 'number' && !isNaN_isNaN(value)) return value + ''; + return ''; +} + +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 + }, + startSearchLength: { + type: Number, + default: 1 + }, + waitSearchFinishTime: { + type: Number, + default: 0 + }, + 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() + }, + lastSearchInput: null, + 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.internalValue.slice() : this.internalValue[0]; + } + + var rawNodes = this.internalValue.map(function (id) { + return _this4.getNode(id).raw; + }); + return this.multiple ? rawNodes : rawNodes[0]; + }, + 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 _this5 = 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 _this5.enhancedNormalizer(node); + }).map(function (node) { + return node.id; + }); + }, + extractNodeFromValue: function extractNodeFromValue(id) { + var _this6 = 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 && _this6.enhancedNormalizer(node).id === id; + }); + return matched || defaultNode; + }, + fixSelectedNodeIds: function fixSelectedNodeIds(nodeIdListOfPrevValue) { + var _this7 = 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 = _this7.getNode(nodeId); + + if (node.isBranch) _this7.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 = _this7.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 _this8 = this; + + this.forest.selectedNodeIds.forEach(function (id) { + if (!prevNodeMap[id]) return; + + var node = _objectSpread(_objectSpread({}, prevNodeMap[id]), {}, { + isFallbackNode: true + }); + + _this8.$set(_this8.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 _this9 = this; + + if (!parentNode.isBranch) return; + parentNode.children.forEach(function (child) { + _this9.traverseDescendantsDFS(child, callback); + + callback(child); + }); + }, + traverseAllNodesDFS: function traverseAllNodesDFS(callback) { + var _this10 = this; + + this.forest.normalizedOptions.forEach(function (rootNode) { + _this10.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(retry) { + var _this11 = this; + + var searchQuery = this.trigger.searchQuery; + + var done = function done() { + return _this11.resetHighlightedOptionWhenNecessary(true); + }; + + if (!searchQuery) { + this.localSearch.active = false; + this.lastSearchInput = null; + return done(); + } + + if (searchQuery.length < this.startSearchLength) { + return; + } + + if (this.waitSearchFinishTime > 0) { + var now = new Date(); + + if (!this.lastSearchInput) { + setTimeout(function () { + _this11.handleLocalSearch(true); + }, this.waitSearchFinishTime); + this.lastSearchInput = now; + return; + } + + var diff = now - this.lastSearchInput; + + if (diff < this.waitSearchFinishTime && !retry) { + setTimeout(function () { + _this11.handleLocalSearch(true); + }, this.waitSearchFinishTime); + this.lastSearchInput = now; + return; + } + + if (retry && diff < this.waitSearchFinishTime) { + return; + } + + this.lastSearchInput = now; + } + + this.localSearch.active = true; + this.localSearch.noResults = true; + this.traverseAllNodesDFS(function (node) { + if (node.isBranch) { + var _this11$$set; + + node.isExpandedOnSearch = false; + node.showAllChildrenOnSearch = false; + node.isMatched = false; + node.hasMatchedDescendants = false; + + _this11.$set(_this11.localSearch.countMap, node.id, (_this11$$set = {}, defineProperty_default()(_this11$$set, ALL_CHILDREN, 0), defineProperty_default()(_this11$$set, ALL_DESCENDANTS, 0), defineProperty_default()(_this11$$set, LEAF_CHILDREN, 0), defineProperty_default()(_this11$$set, LEAF_DESCENDANTS, 0), _this11$$set)); + } + }); + var lowerCasedSearchQuery = searchQuery.trim().toLocaleLowerCase(); + var splitSearchQuery = lowerCasedSearchQuery.replace(/\s+/g, ' ').split(' '); + this.traverseAllNodesDFS(function (node) { + if (_this11.searchNested && splitSearchQuery.length > 1) { + node.isMatched = splitSearchQuery.every(function (filterValue) { + return match(false, filterValue, node.nestedSearchLabel); + }); + } else { + node.isMatched = _this11.matchKeys.some(function (matchKey) { + return match(!_this11.disableFuzzyMatching, lowerCasedSearchQuery, node.lowerCased[matchKey]); + }); + } + + if (node.isMatched) { + _this11.localSearch.noResults = false; + node.ancestors.forEach(function (ancestor) { + return _this11.localSearch.countMap[ancestor.id][ALL_DESCENDANTS]++; + }); + if (node.isLeaf) node.ancestors.forEach(function (ancestor) { + return _this11.localSearch.countMap[ancestor.id][LEAF_DESCENDANTS]++; + }); + + if (node.parentNode !== NO_PARENT_NODE) { + _this11.localSearch.countMap[node.parentNode.id][ALL_CHILDREN] += 1; + if (node.isLeaf) _this11.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(); + this.lastSearchInput = null; + }, + handleRemoteSearch: function handleRemoteSearch() { + var _this12 = this; + + var searchQuery = this.trigger.searchQuery; + var entry = this.getRemoteSearchEntry(); + + var done = function done() { + _this12.initialize(); + + _this12.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 (_this12.trigger.searchQuery === searchQuery) done(); + }, + fail: function fail(err) { + entry.loadingError = getErrorMessage(err); + }, + end: function end() { + entry.isLoading = false; + } + }); + }, + getRemoteSearchEntry: function getRemoteSearchEntry() { + var _this13 = this; + + var searchQuery = this.trigger.searchQuery; + + var entry = this.remoteSearch[searchQuery] || _objectSpread(_objectSpread({}, createAsyncOptionsStates()), {}, { + options: [] + }); + + this.$watch(function () { + return entry.options; + }, function () { + if (_this13.trigger.searchQuery === searchQuery) _this13.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 _this14 = 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 = _this14.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 _this15 = 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 (!_this15.flat && !_this15.disableBranchNodes) { + selectedNode.ancestors.forEach(function (ancestorNode) { + if (!_this15.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 _this16 = this; + + var normalizedOptions = nodes.map(function (node) { + return [_this16.enhancedNormalizer(node), node]; + }).map(function (_ref, index) { + var _ref2 = slicedToArray_default()(_ref, 2), + node = _ref2[0], + raw = _ref2[1]; + + _this16.checkDuplication(node); + + _this16.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 || !_this16.flat && !isRootNode && parentNode.isDisabled; + var isNew = !!node.isNew; + + var lowerCased = _this16.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 = _this16.$set(_this16.forest.nodeMap, id, createMap()); + + _this16.$set(normalized, 'id', id); + + _this16.$set(normalized, 'label', label); + + _this16.$set(normalized, 'level', level); + + _this16.$set(normalized, 'ancestors', isRootNode ? [] : [parentNode].concat(parentNode.ancestors)); + + _this16.$set(normalized, 'index', (isRootNode ? [] : parentNode.index).concat(index)); + + _this16.$set(normalized, 'parentNode', parentNode); + + _this16.$set(normalized, 'lowerCased', lowerCased); + + _this16.$set(normalized, 'nestedSearchLabel', nestedSearchLabel); + + _this16.$set(normalized, 'isDisabled', isDisabled); + + _this16.$set(normalized, 'isNew', isNew); + + _this16.$set(normalized, 'isMatched', false); + + _this16.$set(normalized, 'isHighlighted', false); + + _this16.$set(normalized, 'isBranch', isBranch); + + _this16.$set(normalized, 'isLeaf', isLeaf); + + _this16.$set(normalized, 'isRootNode', isRootNode); + + _this16.$set(normalized, 'raw', raw); + + if (isBranch) { + var _this16$$set; + + var isLoaded = Array.isArray(children); + + _this16.$set(normalized, 'childrenStates', _objectSpread(_objectSpread({}, createAsyncOptionsStates()), {}, { + isLoaded: isLoaded + })); + + _this16.$set(normalized, 'isExpanded', typeof isDefaultExpanded === 'boolean' ? isDefaultExpanded : level < _this16.defaultExpandLevel); + + _this16.$set(normalized, 'hasMatchedDescendants', false); + + _this16.$set(normalized, 'hasDisabledDescendants', false); + + _this16.$set(normalized, 'isExpandedOnSearch', false); + + _this16.$set(normalized, 'showAllChildrenOnSearch', false); + + _this16.$set(normalized, 'count', (_this16$$set = {}, defineProperty_default()(_this16$$set, ALL_CHILDREN, 0), defineProperty_default()(_this16$$set, ALL_DESCENDANTS, 0), defineProperty_default()(_this16$$set, LEAF_CHILDREN, 0), defineProperty_default()(_this16$$set, LEAF_DESCENDANTS, 0), _this16$$set)); + + _this16.$set(normalized, 'children', isLoaded ? _this16.normalize(normalized, children, prevNodeMap) : []); + + if (isDefaultExpanded === true) normalized.ancestors.forEach(function (ancestor) { + ancestor.isExpanded = true; + }); + + if (!isLoaded && typeof _this16.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) { + _this16.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 _this17 = this; + + this.callLoadOptionsProp({ + action: LOAD_ROOT_OPTIONS, + isPending: function isPending() { + return _this17.rootOptionsStates.isLoading; + }, + start: function start() { + _this17.rootOptionsStates.isLoading = true; + _this17.rootOptionsStates.loadingError = ''; + }, + succeed: function succeed() { + _this17.rootOptionsStates.isLoaded = true; + + _this17.$nextTick(function () { + _this17.resetHighlightedOptionWhenNecessary(true); + }); + }, + fail: function fail(err) { + _this17.rootOptionsStates.loadingError = getErrorMessage(err); + }, + end: function end() { + _this17.rootOptionsStates.isLoading = false; + } + }); + }, + loadChildrenOptions: function loadChildrenOptions(parentNode) { + var _this18 = this; + + var id = parentNode.id, + raw = parentNode.raw; + this.callLoadOptionsProp({ + action: LOAD_CHILDREN_OPTIONS, + args: { + parentNode: raw + }, + isPending: function isPending() { + return _this18.getNode(id).childrenStates.isLoading; + }, + start: function start() { + _this18.getNode(id).childrenStates.isLoading = true; + _this18.getNode(id).childrenStates.loadingError = ''; + }, + succeed: function succeed() { + _this18.getNode(id).childrenStates.isLoaded = true; + }, + fail: function fail(err) { + _this18.getNode(id).childrenStates.loadingError = getErrorMessage(err); + }, + end: function end() { + _this18.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 _this19 = this; + + warning_warning(function () { + return !(node.id in _this19.forest.nodeMap && !_this19.forest.nodeMap[node.id].isFallbackNode); + }, function () { + return "Detected duplicate presence of node id ".concat(JSON.stringify(node.id), ". ") + "Their labels are \"".concat(_this19.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 _this20 = this; + + if (this.hasValue) { + if (this.single || this.allowClearingDisabled) { + this.forest.selectedNodeIds = []; + } else { + this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(function (nodeId) { + return _this20.getNode(nodeId).isDisabled; + }); + } + + this.buildForestState(); + } + }, + _selectNode: function _selectNode(node) { + var _this21 = this; + + if (this.single || this.disableBranchNodes) { + return this.addValue(node); + } + + if (this.flat) { + this.addValue(node); + + if (this.autoSelectAncestors) { + node.ancestors.forEach(function (ancestor) { + if (!_this21.isSelected(ancestor) && !ancestor.isDisabled) _this21.addValue(ancestor); + }); + } else if (this.autoSelectDescendants) { + this.traverseDescendantsBFS(node, function (descendant) { + if (!_this21.isSelected(descendant) && !descendant.isDisabled) _this21.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 || _this21.allowSelectingDisabledDescendants) { + _this21.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 _this22 = this; + + if (this.disableBranchNodes) { + return this.removeValue(node); + } + + if (this.flat) { + this.removeValue(node); + + if (this.autoDeselectAncestors) { + node.ancestors.forEach(function (ancestor) { + if (_this22.isSelected(ancestor) && !ancestor.isDisabled) _this22.removeValue(ancestor); + }); + } else if (this.autoDeselectDescendants) { + this.traverseDescendantsBFS(node, function (descendant) { + if (_this22.isSelected(descendant) && !descendant.isDisabled) _this22.removeValue(descendant); + }); + } + + return; + } + + var hasUncheckedSomeDescendants = false; + + if (node.isBranch) { + this.traverseDescendantsDFS(node, function (descendant) { + if (!descendant.isDisabled || _this22.allowSelectingDisabledDescendants) { + _this22.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) { + 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__(35); +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__(36); +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); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { MenuPortalvue_type_script_lang_js_ownKeys(Object(source), true).forEach(function (key) { defineProperty_default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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__(37); + +// 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..88d99454 --- /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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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BAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA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;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;;AACA;AACA;AADA,8CAEA,WAFA,GAEA,IAFA;;AAIA;AACA;AACA;AADA;AADA;AAMA,WACA;AAAA;AAAA,QACA,mBADA,EAEA,iBACA,kCACA,2BADA,EAHA,EADA;AAUA;AA9RA;AAkSA,2E;;AC1SkN,CAAgB,4GAAG,EAAC,C;;ACAtO,IAAI,aAAM,EAAE,sBAAe;AAC+B;AACL;;;AAGrD;AAC0F;AAC1F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,yCAAM;AACR,EAAE,aAAM;AACR,EAAE,sBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAYf;AACD,gBAAS;AACM,sEAAS,Q;;AChCxB;AACA;AACA;AACA;AAEA;AACA,YADA;AAEA,kBAFA;AAGA,cAHA;AAIA;AAJA;AAOA;AACA,8BADA;AAEA,sBAFA;AAIA;AACA,aADA,uBACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA,KAPA;AASA,sBATA,gCASA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA;AAfA,GAJA;AAsBA;AACA,0BADA,8BACA,QADA,EACA;AACA;AAEA;AACA,OAHA,MAGA;AACA;AACA;AACA;AARA,GAtBA;AAiCA,SAjCA,qBAiCA;AACA;AACA;AACA,GApCA;AAsCA,SAtCA,qBAsCA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA1CA;AA4CA,WA5CA,uBA4CA;AACA;AACA,GA9CA;AAgDA;AACA,cADA,wBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uBADA,EAEA,iBACA,iCADA,GAEA,8BACA,iCADA,GAEA,4BANA,EAOA,sBAPA,EADA;AAWA,KAjBA;AAmBA,oBAnBA,8BAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,kCACA,oBADA,GAEA,IAFA;AAGA,KA1BA;AA4BA,mBA5BA,6BA4BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,iCACA,mBADA,GAEA,IAFA;AAGA,KAnCA;AAqCA,yBArCA,mCAqCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjDA;AAmDA,8BAnDA,wCAmDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjEA;AAmEA,8BAnEA,wCAmEA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA,+DACA,KADA,GAEA,4CAFA;;AAIA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAtFA;AAwFA,oBAxFA,8BAwFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA,UACA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA,QADA,EADA;AAOA,KAlGA;AAoGA,yBApGA,mCAoGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,qCADA;AAGA,KA1GA;AA4GA,2BA5GA,qCA4GA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KAlHA;AAoHA,oCApHA,8CAoHA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA/HA;AAiIA,oCAjIA,8CAiIA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAIA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA/IA;AAiJA,+BAjJA,yCAiJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,kCADA;AAGA,KAvJA;AAyJA,sBAzJA,gCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,kCADA;AAGA,KA/JA;AAiKA,cAjKA,wBAiKA;AACA;AACA;AACA;AACA,KArKA;AAuKA,eAvKA,yBAuKA;AACA;AACA;AACA,KA1KA;AA4KA,2BA5KA,qCA4KA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCACA,6DACA,6CAFA;AAIA;AACA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAxMA;AA0MA,wBA1MA,kCA0MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KApNA;AAsNA,0CAtNA,oDAsNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAhOA;AAkOA,yBAlOA,mCAkOA;AACA;AAEA;AACA;AACA,KAvOA;AAyOA,2CAzOA,qDAyOA;AACA;AAEA;AACA;AACA;AA9OA,GAhDA;AAiSA,QAjSA,oBAiSA;AAAA;AACA,WACA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA;AAAA;AAAA,QACA,iBADA,EADA,EADA;AAOA;AAzSA,G;;ACbgN,CAAgB,wGAAG,EAAC,C;;ACApO,IAAI,WAAM,EAAE,oBAAe;AAC6B;AACL;;;AAGnD;AAC0F;AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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..47319f64 --- /dev/null +++ b/dist/vue-treeselect.umd.min.js @@ -0,0 +1,7 @@ +/*! + * vue-treeselect v0.4.0 | (c) 2017-2020 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=38)}([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}},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()}},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}}},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-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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=$(),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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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=$(),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))}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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[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()}},Ge=he({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 Ke.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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 From 984584475058748d8797d205af3631c0f521eec2 Mon Sep 17 00:00:00 2001 From: "Davaadorj.U" Date: Sun, 6 Dec 2020 14:30:15 +0800 Subject: [PATCH 03/20] fix: Added debugging log and null check. --- dist/vue-treeselect.cjs.js | 22 ++++++++++++++++++++-- dist/vue-treeselect.cjs.js.map | 2 +- dist/vue-treeselect.cjs.min.js | 2 +- dist/vue-treeselect.cjs.min.js.map | 2 +- dist/vue-treeselect.umd.js | 22 ++++++++++++++++++++-- dist/vue-treeselect.umd.js.map | 2 +- dist/vue-treeselect.umd.min.js | 2 +- dist/vue-treeselect.umd.min.js.map | 2 +- src/mixins/treeselectMixin.js | 16 ++++++++++++++-- 9 files changed, 60 insertions(+), 12 deletions(-) diff --git a/dist/vue-treeselect.cjs.js b/dist/vue-treeselect.cjs.js index 81039717..d6995f91 100644 --- a/dist/vue-treeselect.cjs.js +++ b/dist/vue-treeselect.cjs.js @@ -1101,7 +1101,15 @@ var instanceId = 0; }, function () { return "Invalid node id: ".concat(nodeId); }); - if (nodeId == null) return null; + + if (nodeId == null) { + if (process.env.NODE_ENV !== 'production') { + console.error(this.options); + } + + return null; + } + return nodeId in this.forest.nodeMap ? this.forest.nodeMap[nodeId] : this.createFallbackNode(nodeId); }, createFallbackNode: function createFallbackNode(id) { @@ -1170,7 +1178,9 @@ var instanceId = 0; var node = _this7.getNode(nodeId); if (node.isBranch) _this7.traverseDescendantsBFS(node, function (descendant) { - nextSelectedNodeIds.push(descendant.id); + if (descendant) { + nextSelectedNodeIds.push(descendant.id); + } }); }); } else if (this.valueConsistsOf === LEAF_PRIORITY) { @@ -1182,6 +1192,7 @@ var instanceId = 0; var node = this.getNode(nodeId); nextSelectedNodeIds.push(nodeId); if (node.isRootNode) continue; + if (!node.parentNode) 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); } @@ -1201,6 +1212,7 @@ var instanceId = 0; nextSelectedNodeIds.push(_nodeId); if (_node.isRootNode) continue; + if (!_node.parentNode) 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); } @@ -2071,6 +2083,12 @@ var instanceId = 0; this.resetFlags(); }, mounted: function mounted() { + if (this.options) { + this.options = this.options.filter(function (o) { + return o; + }); + } + if (this.autoFocus) this.focusInput(); if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions(); if (this.alwaysOpen) this.openMenu(); diff --git a/dist/vue-treeselect.cjs.js.map b/dist/vue-treeselect.cjs.js.map index ef13e82d..078cd68e 100644 --- a/dist/vue-treeselect.cjs.js.map +++ b/dist/vue-treeselect.cjs.js.map @@ -1 +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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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":"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CA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyE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A,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;;AACA;AACA;AADA,8CAEA,WAFA,GAEA,IAFA;;AAIA;AACA;AACA;AADA;AADA;AAMA,WACA;AAAA;AAAA,QACA,mBADA,EAEA,iBACA,kCACA,2BADA,EAHA,EADA;AAUA;AA9RA;AAkSA,2E;;AC1SkN,CAAgB,4GAAG,EAAC,C;;ACAtO,IAAI,aAAM,EAAE,sBAAe;AAC+B;AACL;;;AAGrD;AAC0F;AAC1F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,yCAAM;AACR,EAAE,aAAM;AACR,EAAE,sBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAYf;AACD,gBAAS;AACM,sEAAS,Q;;AChCxB;AACA;AACA;AACA;AAEA;AACA,YADA;AAEA,kBAFA;AAGA,cAHA;AAIA;AAJA;AAOA;AACA,8BADA;AAEA,sBAFA;AAIA;AACA,aADA,uBACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA,KAPA;AASA,sBATA,gCASA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA;AAfA,GAJA;AAsBA;AACA,0BADA,8BACA,QADA,EACA;AACA;AAEA;AACA,OAHA,MAGA;AACA;AACA;AACA;AARA,GAtBA;AAiCA,SAjCA,qBAiCA;AACA;AACA;AACA,GApCA;AAsCA,SAtCA,qBAsCA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA1CA;AA4CA,WA5CA,uBA4CA;AACA;AACA,GA9CA;AAgDA;AACA,cADA,wBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uBADA,EAEA,iBACA,iCADA,GAEA,8BACA,iCADA,GAEA,4BANA,EAOA,sBAPA,EADA;AAWA,KAjBA;AAmBA,oBAnBA,8BAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,kCACA,oBADA,GAEA,IAFA;AAGA,KA1BA;AA4BA,mBA5BA,6BA4BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,iCACA,mBADA,GAEA,IAFA;AAGA,KAnCA;AAqCA,yBArCA,mCAqCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjDA;AAmDA,8BAnDA,wCAmDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA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ACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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","o","destroyed","Treeselect","VERSION","PKG_VERSION"],"mappings":"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AACD;;AACD,QAAI,KAAKtS,SAAT,EAAoB,KAAK0L,UAAL;AACpB,QAAI,CAAC,KAAKxI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK8P,eAAL;AAC9D,QAAI,KAAKlQ,UAAT,EAAqB,KAAK+H,QAAL;AACrB,QAAI,KAAK7H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKsH,kBAAL;AACxC,GA/5DY;AAi6Db8J,WAj6Da,uBAi6DD;AAEV,SAAKrH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/NA,+BA+NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AAnOA,GA9CA;AAoRA,QApRA,oBAoRA;AACA;AACA;AAtRA,G;;ACdiN,CAAgB,0GAAG,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A;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;;AACA;AACA;AADA,8CAEA,WAFA,GAEA,IAFA;;AAIA;AACA;AACA;AADA;AADA;AAMA,WACA;AAAA;AAAA,QACA,mBADA,EAEA,iBACA,kCACA,2BADA,EAHA,EADA;AAUA;AA9RA;AAkSA,2E;;AC1SkN,CAAgB,4GAAG,EAAC,C;;ACAtO,IAAI,aAAM,EAAE,sBAAe;AAC+B;AACL;;;AAGrD;AAC0F;AAC1F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,yCAAM;AACR,EAAE,aAAM;AACR,EAAE,sBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAYf;AACD,gBAAS;AACM,sEAAS,Q;;AChCxB;AACA;AACA;AACA;AAEA;AACA,YADA;AAEA,kBAFA;AAGA,cAHA;AAIA;AAJA;AAOA;AACA,8BADA;AAEA,sBAFA;AAIA;AACA,aADA,uBACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA,KAPA;AASA,sBATA,gCASA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA;AAfA,GAJA;AAsBA;AACA,0BADA,8BACA,QADA,EACA;AACA;AAEA;AACA,OAHA,MAGA;AACA;AACA;AACA;AARA,GAtBA;AAiCA,SAjCA,qBAiCA;AACA;AACA;AACA,GApCA;AAsCA,SAtCA,qBAsCA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA1CA;AA4CA,WA5CA,uBA4CA;AACA;AACA,GA9CA;AAgDA;AACA,cADA,wBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uBADA,EAEA,iBACA,iCADA,GAEA,8BACA,iCADA,GAEA,4BANA,EAOA,sBAPA,EADA;AAWA,KAjBA;AAmBA,oBAnBA,8BAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,kCACA,oBADA,GAEA,IAFA;AAGA,KA1BA;AA4BA,mBA5BA,6BA4BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,iCACA,mBADA,GAEA,IAFA;AAGA,KAnCA;AAqCA,yBArCA,mCAqCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjDA;AAmDA,8BAnDA,wCAmDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjEA;AAmEA,8BAnEA,wCAmEA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA,+DACA,KADA,GAEA,4CAFA;;AAIA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAtFA;AAwFA,oBAxFA,8BAwFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA,UACA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA,QADA,EADA;AAOA,KAlGA;AAoGA,yBApGA,mCAoGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,qCADA;AAGA,KA1GA;AA4GA,2BA5GA,qCA4GA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KAlHA;AAoHA,oCApHA,8CAoHA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA/HA;AAiIA,oCAjIA,8CAiIA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAIA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA/IA;AAiJA,+BAjJA,yCAiJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,kCADA;AAGA,KAvJA;AAyJA,sBAzJA,gCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,kCADA;AAGA,KA/JA;AAiKA,cAjKA,wBAiKA;AACA;AACA;AACA;AACA,KArKA;AAuKA,eAvKA,yBAuKA;AACA;AACA;AACA,KA1KA;AA4KA,2BA5KA,qCA4KA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCACA,6DACA,6CAFA;AAIA;AACA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAxMA;AA0MA,wBA1MA,kCA0MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KApNA;AAsNA,0CAtNA,oDAsNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAhOA;AAkOA,yBAlOA,mCAkOA;AACA;AAEA;AACA;AACA,KAvOA;AAyOA,2CAzOA,qDAyOA;AACA;AAEA;AACA;AACA;AA9OA,GAhDA;AAiSA,QAjSA,oBAiSA;AAAA;AACA,WACA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA;AAAA;AAAA,QACA,iBADA,EADA,EADA;AAOA;AAzSA,G;;ACbgN,CAAgB,wGAAG,EAAC,C;;ACApO,IAAI,WAAM,EAAE,oBAAe;AAC6B;AACL;;;AAGnD;AAC0F;AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEesH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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.options) {\n this.options = this.options.filter(o => o)\n }\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 index cde67b28..8408b503 100644 --- a/dist/vue-treeselect.cjs.min.js +++ b/dist/vue-treeselect.cjs.min.js @@ -3,5 +3,5 @@ * 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 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 Y})),n.d(t,"ASYNC_SEARCH",(function(){return K})),n.d(t,"VERSION",(function(){return it}));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=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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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=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 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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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=ce(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=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 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?n:"number"!=typeof n||C(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?b.label:e.nestedSearchLabel+" "+b.label,E=i.$set(i.forest.nodeMap,u,B());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",b),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",O),i.$set(E,"isNew",y),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",S),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(p);i.$set(E,"childrenStates",oe(oe({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"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:N(e,this.adjustMenuOpenDirection)})},setupMenuResizeAndScrollEventListeners:function(){var e=this.instance.getControl();this.menuResizeAndScrollEventListeners||(this.menuResizeAndScrollEventListeners={remove:w(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(14),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:w(e,this.updateMenuContainerOffset)})},setupControlSizeWatcher:function(){var e=this,t=this.instance.getControl();this.controlSizeWatcher||(this.controlSizeWatcher={remove:N(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(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;t1?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=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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){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&&(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 c=l.shift(),u=this.getNode(c);n.push(c),u.isRootNode||u.parentNode&&(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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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=ce(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=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 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?n:"number"!=typeof n||C(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?b.label:e.nestedSearchLabel+" "+b.label,N=i.$set(i.forest.nodeMap,u,B());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:w(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(14),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:w(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(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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"version":3,"sources":["webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/external \"@babel/runtime/helpers/defineProperty\"","webpack://VueTreeselect/external \"babel-helper-vue-jsx-merge-props\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/toConsumableArray\"","webpack://VueTreeselect/external \"lodash/noop\"","webpack://VueTreeselect/external \"lodash/debounce\"","webpack://VueTreeselect/external \"is-promise\"","webpack://VueTreeselect/external \"lodash/once\"","webpack://VueTreeselect/external \"lodash/identity\"","webpack://VueTreeselect/external \"lodash/constant\"","webpack://VueTreeselect/external \"lodash/last\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/slicedToArray\"","webpack://VueTreeselect/external \"fuzzysearch\"","webpack://VueTreeselect/external \"watch-size\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/typeof\"","webpack://VueTreeselect/external \"vue\"","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./src/utils/removeFromArray.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/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","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","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/SingleValue.vue","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","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValue.vue","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","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","require","warning","noop","onLeftClick","mouseDownHandler","evt","type","button","args","this","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","Math","min","offsetTop","clientHeight","scrollHeight","top","max","intervalId","removeFromArray","arr","elem","idx","indexOf","splice","registered","test","item","$el","listener","lastWidth","lastHeight","width","offsetWidth","height","watchSizeForIE9","push","setInterval","forEach","length","clearInterval","watchSize","isIE9","document","documentMode","locked","removeSizeWatcher","watchSizeForBrowsersOtherThanIE9","isScrollElment","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","window","findScrollParents","addEventListener","passive","scrollParent","removeEventListener","$scrollParent","isNaN","x","createMap","isPlainObject","getPrototypeOf","deepExtend","target","source","keys","len","obj","includes","arrOrStr","find","predicate","ctx","quickDiff","arrA","arrB","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","KEY_CODES","sortValueByIndex","a","b","level","index","match","enableFuzzyMatch","needle","haystack","fuzzysearch","getErrorMessage","err","message","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","count","loadingText","loadOptions","matchKeys","Array","maxHeight","multiple","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","openOnClick","openOnFocus","options","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","startSearchLength","waitSearchFinishTime","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","isLoaded","isLoading","loadingError","localSearch","active","noResults","countMap","lastSearchInput","remoteSearch","computed","selectedNodes","map","getNode","internalValue","single","slice","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","sortValueByLevel","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","hasBranchNodes","some","rootNode","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","$emit","getValue","getInstanceId","buildForestState","handler","isArray","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","fallbackNode","label","enhancedNormalizer","isFallbackNode","isDisabled","isNew","$set","defaultNode","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","contains","wrapper","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","split","every","filterValue","nestedSearchLabel","matchKey","lowerCased","entry","callLoadOptionsProp","action","isPending","start","succeed","fail","end","$watch","isExpanded","shouldShowOptionInMenu","getControl","getMenu","$menu","portal","portalTarget","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","concat","hasDisabledDescendants","branchNodes","option","leafNodes","once","result","isPromise","then","catch","console","error","JSON","stringify","undefined","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","component","__file","inputWidth","_h","$createElement","_c","_self","attrs","xmlns","viewBox","_withStripped","VERSION","Treeselect","PKG_VERSION"],"mappings":"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","file":"vue-treeselect.cjs.min.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/defineProperty\");","module.exports = require(\"babel-helper-vue-jsx-merge-props\");","module.exports = require(\"@babel/runtime/helpers/toConsumableArray\");","module.exports = require(\"lodash/noop\");","module.exports = require(\"lodash/debounce\");","module.exports = require(\"is-promise\");","module.exports = require(\"lodash/once\");","module.exports = require(\"lodash/identity\");","module.exports = require(\"lodash/constant\");","module.exports = require(\"lodash/last\");","module.exports = require(\"@babel/runtime/helpers/slicedToArray\");","module.exports = require(\"fuzzysearch\");","module.exports = require(\"watch-size\");","module.exports = require(\"@babel/runtime/helpers/typeof\");","module.exports = require(\"vue\");","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","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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.options) {\n this.options = this.options.filter(o => o)\n }\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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.umd.js b/dist/vue-treeselect.umd.js index a20b6abb..96e2dd8a 100644 --- a/dist/vue-treeselect.umd.js +++ b/dist/vue-treeselect.umd.js @@ -2234,7 +2234,15 @@ var instanceId = 0; }, function () { return "Invalid node id: ".concat(nodeId); }); - if (nodeId == null) return null; + + if (nodeId == null) { + if (true) { + console.error(this.options); + } + + return null; + } + return nodeId in this.forest.nodeMap ? this.forest.nodeMap[nodeId] : this.createFallbackNode(nodeId); }, createFallbackNode: function createFallbackNode(id) { @@ -2303,7 +2311,9 @@ var instanceId = 0; var node = _this7.getNode(nodeId); if (node.isBranch) _this7.traverseDescendantsBFS(node, function (descendant) { - nextSelectedNodeIds.push(descendant.id); + if (descendant) { + nextSelectedNodeIds.push(descendant.id); + } }); }); } else if (this.valueConsistsOf === LEAF_PRIORITY) { @@ -2315,6 +2325,7 @@ var instanceId = 0; var node = this.getNode(nodeId); nextSelectedNodeIds.push(nodeId); if (node.isRootNode) continue; + if (!node.parentNode) 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); } @@ -2334,6 +2345,7 @@ var instanceId = 0; nextSelectedNodeIds.push(_nodeId); if (_node.isRootNode) continue; + if (!_node.parentNode) 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); } @@ -3204,6 +3216,12 @@ var instanceId = 0; this.resetFlags(); }, mounted: function mounted() { + if (this.options) { + this.options = this.options.filter(function (o) { + return o; + }); + } + if (this.autoFocus) this.focusInput(); if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions(); if (this.alwaysOpen) this.openMenu(); diff --git a/dist/vue-treeselect.umd.js.map b/dist/vue-treeselect.umd.js.map index 88d99454..53d3a7d7 100644 --- a/dist/vue-treeselect.umd.js.map +++ b/dist/vue-treeselect.umd.js.map @@ -1 +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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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BAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/NA,+BA+NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AAnOA,GA9CA;AAoRA,QApRA,oBAoRA;AACA;AACA;AAtRA,G;;ACdiN,CAAgB,0GAAG,EAAC,C;;ACArO,IAAI,YAAM,EAAE,qBAAe;AAC8B;AACL;;;AAGpD;AAC0F;AAC1F,IAAI,eAAS,GAAG,kBAAU;AAC1B,EAAE,wCAAM;AACR,EAAE,YAAM;AACR,EAAE,qBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,kBAYf;AACD,eAAS;AACM,yDAAS,Q;;AChCxB;AACA,qCADA;AAEA,sBAFA;AAIA,QAJA,oBAIA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA,yCADA;AAEA,mDAFA;AAGA;AAHA;AAMA,WACA;AAAA;AAAA,QACA,oBADA,EADA;AAKA;AAjBA,G;;ACDuN,CAAgB,sHAAG,EAAC,C;;ACA3O,IAAI,kBAAM,EAAE,2BAAe;AACoC;AACL;;;AAG1D;AAC0F;AAC1F,IAAI,qBAAS,GAAG,kBAAU;AAC1B,EAAE,8CAAM;AACR,EAAE,kBAAM;AACR,EAAE,2BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,wBAYf;AACD,qBAAS;AACM,qEAAS,Q;;AChCxB;AACA;AAEA;AACA,sCADA;AAEA,sBAFA;AAGA;AACA,0BADA,oCACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AACA,wCACA;AAAA;AAAA,QADA,GAEA,UAFA;AAGA;AATA,GAHA;AAcA,QAdA,oBAcA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAAA,QACA,oBADA,GACA,IADA,CACA,OADA,CACA,oBADA;AAEA;AAEA,iCACA,mBACA;AAAA;AAAA,QACA,6BADA,EAFA,EAMA,cANA,EAOA;AAAA;AAAA,MAPA;AASA;AA3BA,G;;ACJuN,CAAgB,sHAAG,EAAC,C;;ACA3O,IAAI,kBAAM,EAAE,2BAAe;AACoC;AACL;;;AAG1D;AAC0F;AAC1F,IAAI,qBAAS,GAAG,kBAAU;AAC1B,EAAE,8CAAM;AACR,EAAE,kBAAM;AACR,EAAE,2BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,wBAYf;AACD,qBAAS;AACM,qEAAS,Q;;ACjCxB,IAAI,0CAAM;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,IAAI,mDAAe;AACnB,0CAAM;;;;;;AChBN;AACA;AADA,G;;ACP2N,CAAgB,uGAAG,EAAC,C;;ACA1J;AAC3B;AACL;;;AAGrD;AAC6F;AAC7F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,oCAAM;AACR,EAAE,0CAAM;AACR,EAAE,mDAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAiBf;AACD,gBAAS;AACM,2DAAS,Q;;ACrCxB;AACA;AAEA;AACA,0CADA;AAEA,sBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA;AADA,GAJA;AAWA;AACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAIA;AACA,KALA;AADA,GAXA;AAoBA,QApBA,oBAoBA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA,8CADA;AAEA,kEAFA;AAGA;AAHA;AAKA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA,QACA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,uBADA,EAEA;AAAA;AAAA,mBAFA,EADA,EADA;AAQA;AAtCA,G;;ACJ0N,CAAgB,4HAAG,EAAC,C;;ACA9O,IAAI,qBAAM,EAAE,8BAAe;AACuC;AACL;;;AAG7D;AAC0F;AAC1F,IAAI,wBAAS,GAAG,kBAAU;AAC1B,EAAE,iDAAM;AACR,EAAE,qBAAM;AACR,EAAE,8BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,2BAYf;AACD,wBAAS;AACM,2EAAS,Q;;;AChCxB;AACA;AACA;AAEA;AACA,qCADA;AAEA,sBAFA;AAIA;AACA,yBADA,mCACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,oCACA,KADA,CACA,CADA,EACA,cADA,EAEA,GAFA,CAEA,gBAFA,EAGA,GAHA,CAGA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA,OAHA;AAMA,KAVA;AAYA,wBAZA,kCAYA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AAEA,aACA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,qCADA,EADA;AAKA;AAvBA,GAJA;AA8BA,QA9BA,oBA8BA;AAAA;AAAA,QACA,oBADA,GACA,YADA,CACA,oBADA;AAEA;AACA;AACA,kBADA;AAEA,4DAFA;AAGA;AAHA;AADA;AAQA,gCACA;AAAA;AAAA,gCACA,4BADA,EAEA,2BAFA,EAGA;AAAA;AAAA,MAHA,EAIA;AAAA;AAAA;AAAA,MAJA,EADA;AAQA;AAhDA,G;;ACLsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;ACjCxB,IAAI,yCAAM;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,IAAI,kDAAe;AACnB,yCAAM;;;;;;AChBN;AACA;AADA,G;;ACP0N,CAAgB,qGAAG,EAAC,C;;ACA1J;AAC3B;AACL;;;AAGpD;AAC6F;AAC7F,IAAI,eAAS,GAAG,kBAAU;AAC1B,EAAE,mCAAM;AACR,EAAE,yCAAM;AACR,EAAE,kDAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,kBAiBf;AACD,eAAS;AACM,yDAAS,Q;;ACrCxB;AACA;AACA;AACA;AACA;AAEA;AACA,iCADA;AAEA,sBAFA;AAIA;AAMA,eANA,yBAMA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA,sBACA,kBADA,IAEA,iBAFA,KAGA,yDAHA,CADA;AAMA,KAfA;AAqBA,mBArBA,6BAqBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAGA;AACA,KA5BA;AAkCA,sBAlCA,gCAkCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA,qBACA;AAAA;AAAA,QAFA;AAIA;AAzCA,GAJA;AAiDA;AACA,WADA,qBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,QADA,EADA;AAKA,KAZA;AAcA,eAdA,yBAcA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA,6CADA;AAEA;AAFA;AAKA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,QADA,EADA;AAKA,KA5BA;AA8BA;AAUA;AACA;AAXA,UAaA,QAbA,GAaA,IAbA,CAaA,QAbA;AAcA;;AACA;AACA;AACA,OAFA;;AAIA;AAEA;AACA,OAHA,MAGA;AAEA;AAAA;AAAA;AAKA;AACA,KA9BA,CA9BA;AA8DA;AACA;AACA;AAFA,UAIA,QAJA,GAIA,IAJA,CAIA,QAJA;AAOA;AACA;AACA,KATA,CA9DA;AA0EA,wBA1EA,gCA0EA,QA1EA,EA0EA;AAAA;AACA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA;AAhFA,GAjDA;AAoIA,QApIA,oBAoIA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EAEA,cAFA,EAGA,kBAHA,EADA;AAOA;AA/IA,G;;ACPmN,CAAgB,8GAAG,EAAC,C;;ACAvO,IAAI,cAAM,EAAE,uBAAe;AACgC;AACL;;;AAGtD;AAC0F;AAC1F,IAAI,iBAAS,GAAG,kBAAU;AAC1B,EAAE,0CAAM;AACR,EAAE,cAAM;AACR,EAAE,uBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,oBAYf;AACD,iBAAS;AACM,6DAAS,Q;;AChCxB;AACA,6BADA;AAEA,kBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA,KADA;AAKA;AACA,kBADA;AAEA;AAFA;AALA,GAJA;AAeA,QAfA,kBAeA,CAfA,EAeA,OAfA,EAeA;AAAA;AAAA,QACA,KADA,GACA,OADA,CACA,KADA;AAAA,QACA,QADA,GACA,OADA,CACA,QADA;AAGA,WACA;AAAA;AAAA,QACA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA,EAIA;AAAA;AAAA,QACA,QADA,EAJA,EADA;AAUA;AA5BA,G;;ACD+M,CAAgB,sGAAG,EAAC,C;;ACAnO,IAAI,UAAM,EAAE,mBAAe;AAC4B;AACL;;;AAGlD;AAC0F;AAC1F,IAAI,aAAS,GAAG,kBAAU;AAC1B,EAAE,sCAAM;AACR,EAAE,UAAM;AACR,EAAE,mBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,gBAYf;AACD,aAAS;AACM,qDAAS,Q;;;AChCxB;AACA;AACA;AACA;AAEA;AAEA;AACA,gCADA;AAEA,sBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA;AADA,GAJA;AAWA;AACA,gBADA,0BACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KALA;AAOA,cAPA,wBAOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAXA,GAXA;AAyBA;AACA,gBADA,0BACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA,sCADA;AAEA,2DAFA;AAGA,qEAHA;AAIA,+DAJA;AAKA,wFALA;AAMA;AANA;AASA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAEA,2BACA,8BACA,qBADA,EADA,EAIA,kBAJA,EAFA,EADA;AAWA,KAvBA;AAyBA,wBAzBA,kCAyBA;AAAA;AACA;AAEA,aACA;AAAA;AAAA,UACA,uBADA,EAEA,0BAFA,EAGA,+BAHA,EAIA,oCAJA,EADA;AAQA,KApCA;AAsCA,eAtCA,yBAsCA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;;AAEA;AACA;AACA;AACA,yDADA;AAEA;AAFA;AADA;AAMA;AACA,8CADA;AAEA;AAFA;AAKA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,YACA,kCACA;AAAA;AAAA,UADA,EADA,EADA;AAOA;;AAKA;AACA,kDACA;AAAA;AAAA,oBADA;AAIA;AACA;;AAEA;AACA,KA5EA;AA8EA,wBA9EA,gCA8EA,QA9EA,EA8EA;AAAA;AACA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KApFA;AAsFA,2BAtFA,mCAsFA,QAtFA,EAsFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAEA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KAjGA;AAmGA,kBAnGA,4BAmGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA;AACA,wCADA;AAEA,qEAFA;AAGA,iFAHA;AAIA,yEAJA;AAKA;AALA;AAQA,kCACA;AAAA;AAAA,QADA;AAGA,kCACA;AAAA;AAAA,QADA;AAIA,aACA;AAAA;AAAA,UACA,SADA,EAEA,SAFA,EADA;AAMA,KA3HA;AA6HA,eA7HA,yBA6HA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA,4BACA,gDACA,kCADA,GAEA,kBAFA,CADA;AAMA,oCACA,8BACA,4DADA,GAEA,gCAHA,GAIA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;;AACA;AACA;AADA,8CAEA,WAFA,GAEA,IAFA;;AAIA;AACA;AACA;AADA;AADA;AAMA,WACA;AAAA;AAAA,QACA,mBADA,EAEA,iBACA,kCACA,2BADA,EAHA,EADA;AAUA;AA9RA;AAkSA,2E;;AC1SkN,CAAgB,4GAAG,EAAC,C;;ACAtO,IAAI,aAAM,EAAE,sBAAe;AAC+B;AACL;;;AAGrD;AAC0F;AAC1F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,yCAAM;AACR,EAAE,aAAM;AACR,EAAE,sBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAYf;AACD,gBAAS;AACM,sEAAS,Q;;AChCxB;AACA;AACA;AACA;AAEA;AACA,YADA;AAEA,kBAFA;AAGA,cAHA;AAIA;AAJA;AAOA;AACA,8BADA;AAEA,sBAFA;AAIA;AACA,aADA,uBACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA,KAPA;AASA,sBATA,gCASA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA;AAfA,GAJA;AAsBA;AACA,0BADA,8BACA,QADA,EACA;AACA;AAEA;AACA,OAHA,MAGA;AACA;AACA;AACA;AARA,GAtBA;AAiCA,SAjCA,qBAiCA;AACA;AACA;AACA,GApCA;AAsCA,SAtCA,qBAsCA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA1CA;AA4CA,WA5CA,uBA4CA;AACA;AACA,GA9CA;AAgDA;AACA,cADA,wBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uBADA,EAEA,iBACA,iCADA,GAEA,8BACA,iCADA,GAEA,4BANA,EAOA,sBAPA,EADA;AAWA,KAjBA;AAmBA,oBAnBA,8BAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,kCACA,oBADA,GAEA,IAFA;AAGA,KA1BA;AA4BA,mBA5BA,6BA4BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,iCACA,mBADA,GAEA,IAFA;AAGA,KAnCA;AAqCA,yBArCA,mCAqCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjDA;AAmDA,8BAnDA,wCAmDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA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SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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","o","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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C,KAAKxI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK8P,eAAL;AAC9D,QAAI,KAAKlQ,UAAT,EAAqB,KAAK+H,QAAL;AACrB,QAAI,KAAK7H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKsH,kBAAL;AACxC,GA/5DY;AAi6Db8J,WAj6Da,uBAi6DD;AAEV,SAAKrH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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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;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAA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;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEesH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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.options) {\n this.options = this.options.filter(o => o)\n }\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 index 47319f64..156957b7 100644 --- a/dist/vue-treeselect.umd.min.js +++ b/dist/vue-treeselect.umd.min.js @@ -3,5 +3,5 @@ * 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=38)}([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}},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()}},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}}},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-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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=$(),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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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=$(),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))}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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[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()}},Ge=he({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 Ke.a(function(e){for(var t=1;te.length)&&(t=e.length);for(var n=0,i=new Array(t);n=t||n<0||m&&e-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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=$(),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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){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&&(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&&(u.parentNode.id in a||(a[u.parentNode.id]=u.parentNode.children.length),0==--a[u.parentNode.id]&&l.push(u.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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[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()}},Ge=he({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 Ke.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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"version":3,"sources":["webpack://VueTreeselect/webpack/universalModuleDefinition","webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://VueTreeselect/./node_modules/babel-helper-vue-jsx-merge-props/index.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/arrayLikeToArray.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/_root.js","webpack://VueTreeselect/./node_modules/lodash/toNumber.js","webpack://VueTreeselect/./node_modules/lodash/_Symbol.js","webpack://VueTreeselect/./node_modules/is-promise/index.js","webpack://VueTreeselect/./node_modules/lodash/once.js","webpack://VueTreeselect/./node_modules/lodash/identity.js","webpack://VueTreeselect/./node_modules/lodash/constant.js","webpack://VueTreeselect/./node_modules/lodash/last.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack://VueTreeselect/./node_modules/fuzzysearch/index.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/typeof.js","webpack://VueTreeselect/external \"Vue\"","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/nonIterableRest.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/lodash/now.js","webpack://VueTreeselect/./node_modules/lodash/_freeGlobal.js","webpack://VueTreeselect/(webpack)/buildin/global.js","webpack://VueTreeselect/./node_modules/lodash/isSymbol.js","webpack://VueTreeselect/./node_modules/lodash/_baseGetTag.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/lodash/before.js","webpack://VueTreeselect/./node_modules/lodash/toInteger.js","webpack://VueTreeselect/./node_modules/lodash/toFinite.js","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./node_modules/watch-size/index.es.mjs","webpack://VueTreeselect/./src/utils/removeFromArray.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/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","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","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/SingleValue.vue","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","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValue.vue","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","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["root","factory","exports","module","require","define","amd","window","__WEBPACK_EXTERNAL_MODULE__19__","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","obj","configurable","writable","nestRE","mergeFn","a","b","apply","this","arguments","objs","reduce","aa","bb","nestedKey","temp","test","Array","isArray","concat","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","arr","arrayLikeToArray","minLen","toString","slice","constructor","from","len","length","arr2","isObject","now","toNumber","nativeMax","Math","max","nativeMin","min","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","clearTimeout","cancel","flush","type","freeGlobal","freeSelf","self","Function","isSymbol","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","replace","isBinary","isPromise","then","default","before","array","arrayWithHoles","iterableToArrayLimit","nonIterableRest","needle","haystack","tlen","qlen","outer","j","nch","charCodeAt","_typeof","iterator","_arr","_n","_d","_e","_s","_i","next","done","push","err","iter","Date","global","g","e","baseGetTag","isObjectLike","getRawTag","objectToString","symToStringTag","objectProto","nativeObjectToString","isOwn","tag","unmasked","toInteger","toFinite","remainder","warning","noop","onLeftClick","mouseDownHandler","evt","button","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","offsetTop","clientHeight","scrollHeight","top","intervalId","element","listener","expand","document","createElement","shrink","appendChild","expandChild","shrinkChild","lastWidth","lastHeight","style","cssText","width","height","unbind","removeChild","offsetWidth","scrollLeft","scrollWidth","addEventListener","removeEventListener","removeFromArray","elem","idx","indexOf","splice","registered","item","$el","watchSizeForIE9","setInterval","forEach","clearInterval","watchSize","isIE9","documentMode","locked","removeSizeWatcher","watchSizeForBrowsersOtherThanIE9","isScrollElment","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","findScrollParents","passive","scrollParent","$scrollParent","isNaN","x","createMap","isPlainObject","getPrototypeOf","deepExtend","target","source","keys","includes","arrOrStr","find","predicate","ctx","quickDiff","arrA","arrB","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","KEY_CODES","sortValueByIndex","level","index","match","enableFuzzyMatch","fuzzysearch","getErrorMessage","message","String","instanceId","provide","instance","props","allowClearingDisabled","Boolean","allowSelectingDisabledDescendants","alwaysOpen","appendToBody","async","autoFocus","autoLoadRootOptions","autoDeselectAncestors","autoDeselectDescendants","autoSelectAncestors","autoSelectDescendants","backspaceRemoves","beforeClearAll","constant","branchNodesFirst","cacheOptions","clearable","clearAllText","clearOnSelect","clearValueText","closeOnSelect","defaultExpandLevel","Number","defaultOptions","deleteRemoves","delimiter","flattenSearchResults","disableBranchNodes","disabled","disableFuzzyMatching","flat","joinValues","limit","Infinity","limitText","count","loadingText","loadOptions","matchKeys","maxHeight","multiple","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","openOnClick","openOnFocus","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","startSearchLength","waitSearchFinishTime","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","isLoaded","isLoading","loadingError","localSearch","active","noResults","countMap","lastSearchInput","remoteSearch","computed","selectedNodes","map","getNode","internalValue","single","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","sortValueByLevel","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","hasBranchNodes","some","rootNode","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","$emit","getValue","getInstanceId","buildForestState","handler","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","fallbackNode","label","enhancedNormalizer","isFallbackNode","isDisabled","isNew","$set","defaultNode","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","contains","wrapper","retry","resetHighlightedOptionWhenNecessary","diff","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","$menu","portal","portalTarget","setCurrentHighlightedOption","scroll","prev","isHighlighted","scrollToOption","$option","querySelector","$nextTick","forceReset","highlightFirstOption","first","highlightPrevOption","highlightLastOption","highlightNextOption","last","getLast","resetSearchQuery","saveMenuScrollPosition","restoreMenuScrollPosition","loadRootOptions","toggleMenu","toggleExpanded","nextState","childrenStates","loadChildrenOptions","selectedNodeId","ancestorNode","nodes","checkDuplication","verifyNodeShape","isDefaultExpanded","normalized","hasDisabledDescendants","branchNodes","option","leafNodes","once","catch","console","error","JSON","stringify","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","component","__file","inputWidth","_h","$createElement","_c","_self","attrs","xmlns","viewBox","_withStripped","VERSION","Treeselect","PKG_VERSION"],"mappings":"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","file":"vue-treeselect.umd.min.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__19__) {\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 = 38);\n","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;","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","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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.options) {\n this.options = this.options.filter(o => o)\n }\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index 1cd20a56..a9f56854 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -984,7 +984,12 @@ export default { () => `Invalid node id: ${nodeId}`, ) - if (nodeId == null) return null + if (nodeId == null) { + if (process.env.NODE_ENV !== 'production') { + console.error(this.options) + } + return null + } return nodeId in this.forest.nodeMap ? this.forest.nodeMap[nodeId] @@ -1060,7 +1065,9 @@ export default { nextSelectedNodeIds.push(nodeId) const node = this.getNode(nodeId) if (node.isBranch) this.traverseDescendantsBFS(node, descendant => { - nextSelectedNodeIds.push(descendant.id) + if (descendant) { + nextSelectedNodeIds.push(descendant.id) + } }) }) } else if (this.valueConsistsOf === LEAF_PRIORITY) { @@ -1071,6 +1078,7 @@ export default { const node = this.getNode(nodeId) nextSelectedNodeIds.push(nodeId) if (node.isRootNode) continue + if (!node.parentNode) 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) } @@ -1085,6 +1093,7 @@ export default { const node = this.getNode(nodeId) nextSelectedNodeIds.push(nodeId) if (node.isRootNode) continue + if (!node.parentNode) 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) } @@ -1995,6 +2004,9 @@ export default { }, mounted() { + if (this.options) { + this.options = this.options.filter(o => o) + } if (this.autoFocus) this.focusInput() if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions() if (this.alwaysOpen) this.openMenu() From e89f6b7ba22f34868c9ab82aed9a4d0787067143 Mon Sep 17 00:00:00 2001 From: "Davaadorj.U" Date: Sun, 6 Dec 2020 15:34:03 +0800 Subject: [PATCH 04/20] fix: Null node fix --- dist/vue-treeselect.cjs.js | 16 ++++++++-------- dist/vue-treeselect.cjs.js.map | 2 +- dist/vue-treeselect.cjs.min.js | 2 +- dist/vue-treeselect.cjs.min.js.map | 2 +- dist/vue-treeselect.umd.js | 16 ++++++++-------- dist/vue-treeselect.umd.js.map | 2 +- dist/vue-treeselect.umd.min.js | 2 +- dist/vue-treeselect.umd.min.js.map | 2 +- src/mixins/treeselectMixin.js | 10 +++++----- 9 files changed, 27 insertions(+), 27 deletions(-) diff --git a/dist/vue-treeselect.cjs.js b/dist/vue-treeselect.cjs.js index d6995f91..15893a69 100644 --- a/dist/vue-treeselect.cjs.js +++ b/dist/vue-treeselect.cjs.js @@ -1068,7 +1068,9 @@ var instanceId = 0; this._blurOnSelect = false; }, initialize: function initialize() { - var options = this.async ? this.getRemoteSearchEntry().options : this.options; + var options = this.async ? this.getRemoteSearchEntry().options : this.options.filter(function (o) { + return o; + }); if (Array.isArray(options)) { var prevNodeMap = this.forest.nodeMap; @@ -1173,11 +1175,15 @@ var instanceId = 0; nextSelectedNodeIds = nodeIdListOfPrevValue; } else if (this.valueConsistsOf === BRANCH_PRIORITY) { nodeIdListOfPrevValue.forEach(function (nodeId) { + if (!nodeId) { + return; + } + nextSelectedNodeIds.push(nodeId); var node = _this7.getNode(nodeId); - if (node.isBranch) _this7.traverseDescendantsBFS(node, function (descendant) { + if (node && node.isBranch) _this7.traverseDescendantsBFS(node, function (descendant) { if (descendant) { nextSelectedNodeIds.push(descendant.id); } @@ -2083,12 +2089,6 @@ var instanceId = 0; this.resetFlags(); }, mounted: function mounted() { - if (this.options) { - this.options = this.options.filter(function (o) { - return o; - }); - } - if (this.autoFocus) this.focusInput(); if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions(); if (this.alwaysOpen) this.openMenu(); diff --git a/dist/vue-treeselect.cjs.js.map b/dist/vue-treeselect.cjs.js.map index 078cd68e..7e309eb8 100644 --- a/dist/vue-treeselect.cjs.js.map +++ b/dist/vue-treeselect.cjs.js.map @@ -1 +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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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","o","destroyed","Treeselect","VERSION","PKG_VERSION"],"mappings":"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AACD;;AACD,QAAI,KAAKtS,SAAT,EAAoB,KAAK0L,UAAL;AACpB,QAAI,CAAC,KAAKxI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK8P,eAAL;AAC9D,QAAI,KAAKlQ,UAAT,EAAqB,KAAK+H,QAAL;AACrB,QAAI,KAAK7H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKsH,kBAAL;AACxC,GA/5DY;AAi6Db8J,WAj6Da,uBAi6DD;AAEV,SAAKrH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/NA,+BA+NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AAnOA,GA9CA;AAoRA,QApRA,oBAoRA;AACA;AACA;AAtRA,G;;ACdiN,CAAgB,0GAAG,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A;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA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CL;;;AAGnD;AAC0F;AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEesH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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.options) {\n this.options = this.options.filter(o => o)\n }\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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":"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AAKtS,SAAT,EAAoB,KAAK2L,UAAL;AACpB,QAAI,CAAC,KAAKzI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK+P,eAAL;AAC9D,QAAI,KAAKnQ,UAAT,EAAqB,KAAK+H,QAAL;AACrB,QAAI,KAAK7H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKsH,kBAAL;AACxC,GA/5DY;AAi6Db8J,WAj6Da,uBAi6DD;AAEV,SAAKpH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/NA,+BA+NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AAnOA,GA9CA;AAoRA,QApRA,oBAoRA;AACA;AACA;AAtRA,G;;ACdiN,CAAgB,0GAAG,EAAC,C;;ACArO,IAA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CA,8BACA,qBADA,EADA,EAIA,kBAJA,EAFA,EADA;AAWA,KAvBA;AAyBA,wBAzBA,kCAyBA;AAAA;AACA;AAEA,aACA;AAAA;AAAA,UACA,uBADA,EAEA,0BAFA,EAGA,+BAHA,EAIA,oCAJA,EADA;AAQA,KApCA;AAsCA,eAtCA,yBAsCA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;;AAEA;AACA;AACA;AACA,yDADA;AAEA;AAFA;AADA;AAMA;AACA,8CADA;AAEA;AAFA;AAKA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,YACA,kCACA;AAAA;AAAA,UADA,EADA,EADA;AAOA;;AAKA;AACA,kDACA;AAAA;AAAA,oBADA;AAIA;AACA;;AAEA;AACA,KA5EA;AA8EA,wBA9EA,gCA8EA,QA9EA,EA8EA;AAAA;AACA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KApFA;AAsFA,2BAtFA,mCAsFA,QAtFA,EAsFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAEA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KAjGA;AAmGA,kBAnGA,4BAmGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA;AACA,wCADA;AAEA,qEAFA;AAGA,iFAHA;AAIA,yEAJA;AAKA;AALA;AAQA,kCACA;AAAA;AAAA,QADA;AAGA,kCACA;AAAA;AAAA,QADA;AAIA,aACA;AAAA;AAAA,UACA,SADA,EAEA,SAFA,EADA;AAMA,KA3HA;AA6HA,eA7HA,yBA6HA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA,4BACA,gDACA,kCADA,GAEA,kBAFA,CADA;AAMA,oCACA,8BACA,4DADA,GAEA,gCAHA,GAIA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;A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AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.filter(o => o)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 index 8408b503..f5c09de8 100644 --- a/dist/vue-treeselect.cjs.min.js +++ b/dist/vue-treeselect.cjs.min.js @@ -3,5 +3,5 @@ * 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 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 Y})),n.d(t,"ASYNC_SEARCH",(function(){return K})),n.d(t,"VERSION",(function(){return it}));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=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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){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&&(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 c=l.shift(),u=this.getNode(c);n.push(c),u.isRootNode||u.parentNode&&(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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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=ce(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=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 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?n:"number"!=typeof n||C(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?b.label:e.nestedSearchLabel+" "+b.label,N=i.$set(i.forest.nodeMap,u,B());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:w(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(14),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:w(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(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;t1?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.filter((function(e){return e}));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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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 c=l.shift(),u=this.getNode(c);n.push(c),u.isRootNode||u.parentNode&&(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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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=ce(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=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 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?n:"number"!=typeof n||C(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?b.label:e.nestedSearchLabel+" "+b.label,N=i.$set(i.forest.nodeMap,u,B());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:w(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(14),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:w(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(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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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.options) {\n this.options = this.options.filter(o => o)\n }\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"version":3,"sources":["webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/external \"@babel/runtime/helpers/defineProperty\"","webpack://VueTreeselect/external \"babel-helper-vue-jsx-merge-props\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/toConsumableArray\"","webpack://VueTreeselect/external \"lodash/noop\"","webpack://VueTreeselect/external \"lodash/debounce\"","webpack://VueTreeselect/external \"is-promise\"","webpack://VueTreeselect/external \"lodash/once\"","webpack://VueTreeselect/external \"lodash/identity\"","webpack://VueTreeselect/external \"lodash/constant\"","webpack://VueTreeselect/external \"lodash/last\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/slicedToArray\"","webpack://VueTreeselect/external \"fuzzysearch\"","webpack://VueTreeselect/external \"watch-size\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/typeof\"","webpack://VueTreeselect/external \"vue\"","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./src/utils/removeFromArray.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/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","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","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/SingleValue.vue","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","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValue.vue","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","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","require","warning","noop","onLeftClick","mouseDownHandler","evt","type","button","args","this","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","Math","min","offsetTop","clientHeight","scrollHeight","top","max","intervalId","removeFromArray","arr","elem","idx","indexOf","splice","registered","test","item","$el","listener","lastWidth","lastHeight","width","offsetWidth","height","watchSizeForIE9","push","setInterval","forEach","length","clearInterval","watchSize","isIE9","document","documentMode","locked","removeSizeWatcher","watchSizeForBrowsersOtherThanIE9","isScrollElment","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","window","findScrollParents","addEventListener","passive","scrollParent","removeEventListener","$scrollParent","isNaN","x","createMap","isPlainObject","getPrototypeOf","deepExtend","target","source","keys","len","obj","includes","arrOrStr","find","predicate","ctx","quickDiff","arrA","arrB","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","KEY_CODES","sortValueByIndex","a","b","level","index","match","enableFuzzyMatch","needle","haystack","fuzzysearch","getErrorMessage","err","message","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","count","loadingText","loadOptions","matchKeys","Array","maxHeight","multiple","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","openOnClick","openOnFocus","options","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","startSearchLength","waitSearchFinishTime","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","isLoaded","isLoading","loadingError","localSearch","active","noResults","countMap","lastSearchInput","remoteSearch","computed","selectedNodes","map","getNode","internalValue","single","slice","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","sortValueByLevel","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","hasBranchNodes","some","rootNode","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","$emit","getValue","getInstanceId","buildForestState","handler","isArray","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","fallbackNode","label","enhancedNormalizer","isFallbackNode","isDisabled","isNew","$set","defaultNode","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","contains","wrapper","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","split","every","filterValue","nestedSearchLabel","matchKey","lowerCased","entry","callLoadOptionsProp","action","isPending","start","succeed","fail","end","$watch","isExpanded","shouldShowOptionInMenu","getControl","getMenu","$menu","portal","portalTarget","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","concat","hasDisabledDescendants","branchNodes","option","leafNodes","once","result","isPromise","then","catch","console","error","JSON","stringify","undefined","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","component","__file","inputWidth","_h","$createElement","_c","_self","attrs","xmlns","viewBox","_withStripped","VERSION","Treeselect","PKG_VERSION"],"mappings":"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","file":"vue-treeselect.cjs.min.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/defineProperty\");","module.exports = require(\"babel-helper-vue-jsx-merge-props\");","module.exports = require(\"@babel/runtime/helpers/toConsumableArray\");","module.exports = require(\"lodash/noop\");","module.exports = require(\"lodash/debounce\");","module.exports = require(\"is-promise\");","module.exports = require(\"lodash/once\");","module.exports = require(\"lodash/identity\");","module.exports = require(\"lodash/constant\");","module.exports = require(\"lodash/last\");","module.exports = require(\"@babel/runtime/helpers/slicedToArray\");","module.exports = require(\"fuzzysearch\");","module.exports = require(\"watch-size\");","module.exports = require(\"@babel/runtime/helpers/typeof\");","module.exports = require(\"vue\");","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","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.filter(o => o)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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.umd.js b/dist/vue-treeselect.umd.js index 96e2dd8a..a0088004 100644 --- a/dist/vue-treeselect.umd.js +++ b/dist/vue-treeselect.umd.js @@ -2201,7 +2201,9 @@ var instanceId = 0; this._blurOnSelect = false; }, initialize: function initialize() { - var options = this.async ? this.getRemoteSearchEntry().options : this.options; + var options = this.async ? this.getRemoteSearchEntry().options : this.options.filter(function (o) { + return o; + }); if (Array.isArray(options)) { var prevNodeMap = this.forest.nodeMap; @@ -2306,11 +2308,15 @@ var instanceId = 0; nextSelectedNodeIds = nodeIdListOfPrevValue; } else if (this.valueConsistsOf === BRANCH_PRIORITY) { nodeIdListOfPrevValue.forEach(function (nodeId) { + if (!nodeId) { + return; + } + nextSelectedNodeIds.push(nodeId); var node = _this7.getNode(nodeId); - if (node.isBranch) _this7.traverseDescendantsBFS(node, function (descendant) { + if (node && node.isBranch) _this7.traverseDescendantsBFS(node, function (descendant) { if (descendant) { nextSelectedNodeIds.push(descendant.id); } @@ -3216,12 +3222,6 @@ var instanceId = 0; this.resetFlags(); }, mounted: function mounted() { - if (this.options) { - this.options = this.options.filter(function (o) { - return o; - }); - } - if (this.autoFocus) this.focusInput(); if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions(); if (this.alwaysOpen) this.openMenu(); diff --git a/dist/vue-treeselect.umd.js.map b/dist/vue-treeselect.umd.js.map index 53d3a7d7..472e4d19 100644 --- a/dist/vue-treeselect.umd.js.map +++ b/dist/vue-treeselect.umd.js.map @@ -1 +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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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","o","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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C,KAAKxI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK8P,eAAL;AAC9D,QAAI,KAAKlQ,UAAT,EAAqB,KAAK+H,QAAL;AACrB,QAAI,KAAK7H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKsH,kBAAL;AACxC,GA/5DY;AAi6Db8J,WAj6Da,uBAi6DD;AAEV,SAAKrH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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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;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAA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;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEesH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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.options) {\n this.options = this.options.filter(o => o)\n }\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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iB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK+P,eAAL;AAC9D,QAAI,KAAKnQ,UAAT,EAAqB,KAAK+H,QAAL;AACrB,QAAI,KAAK7H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKsH,kBAAL;AACxC,GA/5DY;AAi6Db8J,WAj6Da,uBAi6DD;AAEV,SAAKpH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;A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AAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;;AACA;AACA;AADA,8CAEA,WAFA,GAEA,IAFA;;AAIA;AACA;AACA;AADA;AADA;AAMA,WACA;AAAA;AAAA,QACA,mBADA,EAEA,iBACA,kCACA,2BADA,EAHA,EADA;AAUA;AA9RA;AAkSA,2E;;AC1SkN,CAAgB,4GAAG,EAAC,C;;ACAtO,IAAI,aAAM,EAAE,sBAAe;AAC+B;AACL;;;AAGrD;AAC0F;AAC1F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,yCAAM;AACR,EAAE,aAAM;AACR,EAAE,sBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAYf;AACD,gBAAS;AACM,sEAAS,Q;;AChCxB;AACA;AACA;AACA;AAEA;AACA,YADA;AAEA,kBAFA;AAGA,cAHA;AAIA;AAJA;AAOA;AACA,8BADA;AAEA,sBAFA;AAIA;AACA,aADA,uBACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA,KAPA;AASA,sBATA,gCASA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA;AAfA,GAJA;AAsBA;AACA,0BADA,8BACA,QADA,EACA;AACA;AAEA;AACA,OAHA,MAGA;AACA;AACA;AACA;AARA,GAtBA;AAiCA,SAjCA,qBAiCA;AACA;AACA;AACA,GApCA;AAsCA,SAtCA,qBAsCA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA1CA;AA4CA,WA5CA,uBA4CA;AACA;AACA,GA9CA;AAgDA;AACA,cADA,wBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uBADA,EAEA,iBACA,iCADA,GAEA,8BACA,iCADA,GAEA,4BANA,EAOA,sBAPA,EADA;AAWA,KAjBA;AAmBA,oBAnBA,8BAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,kCACA,oBADA,GAEA,IAFA;AAGA,KA1BA;AA4BA,mBA5BA,6BA4BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,iCACA,mBADA,GAEA,IAFA;AAGA,KAnCA;AAqCA,yBArCA,mCAqCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjDA;AAmDA,8BAnDA,wCAmDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjEA;AAmEA,8BAnEA,wCAmEA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA,+DACA,KADA,GAEA,4CAFA;;AAIA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAtFA;AAwFA,oBAxFA,8BAwFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA,UACA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA,QADA,EADA;AAOA,KAlGA;AAoGA,yBApGA,mCAoGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,qCADA;AAGA,KA1GA;AA4GA,2BA5GA,qCA4GA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KAlHA;AAoHA,oCApHA,8CAoHA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA/HA;AAiIA,oCAjIA,8CAiIA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAIA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA/IA;AAiJA,+BAjJA,yCAiJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,kCADA;AAGA,KAvJA;AAyJA,sBAzJA,gCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,kCADA;AAGA,KA/JA;AAiKA,cAjKA,wBAiKA;AACA;AACA;AACA;AACA,KArKA;AAuKA,eAvKA,yBAuKA;AACA;AACA;AACA,KA1KA;AA4KA,2BA5KA,qCA4KA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCACA,6DACA,6CAFA;AAIA;AACA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAxMA;AA0MA,wBA1MA,kCA0MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KApNA;AAsNA,0CAtNA,oDAsNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAhOA;AAkOA,yBAlOA,mCAkOA;AACA;AAEA;AACA;AACA,KAvOA;AAyOA,2CAzOA,qDAyOA;AACA;AAEA;AACA;AACA;AA9OA,GAhDA;AAiSA,QAjSA,oBAiSA;AAAA;AACA,WACA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA;AAAA;AAAA,QACA,iBADA,EADA,EADA;AAOA;AAzSA,G;;ACbgN,CAAgB,wGAAG,EAAC,C;;ACApO,IAAI,WAAM,EAAE,oBAAe;AAC6B;AACL;;;AAGnD;AAC0F;AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.filter(o => o)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 index 156957b7..8c26fa1f 100644 --- a/dist/vue-treeselect.umd.min.js +++ b/dist/vue-treeselect.umd.min.js @@ -3,5 +3,5 @@ * 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=38)}([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}},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()}},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}}},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-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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=$(),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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){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&&(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&&(u.parentNode.id in a||(a[u.parentNode.id]=u.parentNode.children.length),0==--a[u.parentNode.id]&&l.push(u.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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[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()}},Ge=he({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 Ke.a(function(e){for(var t=1;te.length)&&(t=e.length);for(var n=0,i=new Array(t);n=t||n<0||m&&e-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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.filter((function(e){return e}));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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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&&(u.parentNode.id in a||(a[u.parentNode.id]=u.parentNode.children.length),0==--a[u.parentNode.id]&&l.push(u.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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[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()}},Ge=he({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 Ke.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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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.options) {\n this.options = this.options.filter(o => o)\n }\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"version":3,"sources":["webpack://VueTreeselect/webpack/universalModuleDefinition","webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://VueTreeselect/./node_modules/babel-helper-vue-jsx-merge-props/index.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/arrayLikeToArray.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/_root.js","webpack://VueTreeselect/./node_modules/lodash/toNumber.js","webpack://VueTreeselect/./node_modules/lodash/_Symbol.js","webpack://VueTreeselect/./node_modules/is-promise/index.js","webpack://VueTreeselect/./node_modules/lodash/once.js","webpack://VueTreeselect/./node_modules/lodash/identity.js","webpack://VueTreeselect/./node_modules/lodash/constant.js","webpack://VueTreeselect/./node_modules/lodash/last.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack://VueTreeselect/./node_modules/fuzzysearch/index.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/typeof.js","webpack://VueTreeselect/external \"Vue\"","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/nonIterableRest.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/lodash/now.js","webpack://VueTreeselect/./node_modules/lodash/_freeGlobal.js","webpack://VueTreeselect/(webpack)/buildin/global.js","webpack://VueTreeselect/./node_modules/lodash/isSymbol.js","webpack://VueTreeselect/./node_modules/lodash/_baseGetTag.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/lodash/before.js","webpack://VueTreeselect/./node_modules/lodash/toInteger.js","webpack://VueTreeselect/./node_modules/lodash/toFinite.js","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./node_modules/watch-size/index.es.mjs","webpack://VueTreeselect/./src/utils/removeFromArray.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/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","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","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/SingleValue.vue","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","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValue.vue","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","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["root","factory","exports","module","require","define","amd","window","__WEBPACK_EXTERNAL_MODULE__19__","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","obj","configurable","writable","nestRE","mergeFn","a","b","apply","this","arguments","objs","reduce","aa","bb","nestedKey","temp","test","Array","isArray","concat","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","arr","arrayLikeToArray","minLen","toString","slice","constructor","from","len","length","arr2","isObject","now","toNumber","nativeMax","Math","max","nativeMin","min","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","clearTimeout","cancel","flush","type","freeGlobal","freeSelf","self","Function","isSymbol","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","replace","isBinary","isPromise","then","default","before","array","arrayWithHoles","iterableToArrayLimit","nonIterableRest","needle","haystack","tlen","qlen","outer","j","nch","charCodeAt","_typeof","iterator","_arr","_n","_d","_e","_s","_i","next","done","push","err","iter","Date","global","g","e","baseGetTag","isObjectLike","getRawTag","objectToString","symToStringTag","objectProto","nativeObjectToString","isOwn","tag","unmasked","toInteger","toFinite","remainder","warning","noop","onLeftClick","mouseDownHandler","evt","button","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","offsetTop","clientHeight","scrollHeight","top","intervalId","element","listener","expand","document","createElement","shrink","appendChild","expandChild","shrinkChild","lastWidth","lastHeight","style","cssText","width","height","unbind","removeChild","offsetWidth","scrollLeft","scrollWidth","addEventListener","removeEventListener","removeFromArray","elem","idx","indexOf","splice","registered","item","$el","watchSizeForIE9","setInterval","forEach","clearInterval","watchSize","isIE9","documentMode","locked","removeSizeWatcher","watchSizeForBrowsersOtherThanIE9","isScrollElment","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","findScrollParents","passive","scrollParent","$scrollParent","isNaN","x","createMap","isPlainObject","getPrototypeOf","deepExtend","target","source","keys","includes","arrOrStr","find","predicate","ctx","quickDiff","arrA","arrB","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","KEY_CODES","sortValueByIndex","level","index","match","enableFuzzyMatch","fuzzysearch","getErrorMessage","message","String","instanceId","provide","instance","props","allowClearingDisabled","Boolean","allowSelectingDisabledDescendants","alwaysOpen","appendToBody","async","autoFocus","autoLoadRootOptions","autoDeselectAncestors","autoDeselectDescendants","autoSelectAncestors","autoSelectDescendants","backspaceRemoves","beforeClearAll","constant","branchNodesFirst","cacheOptions","clearable","clearAllText","clearOnSelect","clearValueText","closeOnSelect","defaultExpandLevel","Number","defaultOptions","deleteRemoves","delimiter","flattenSearchResults","disableBranchNodes","disabled","disableFuzzyMatching","flat","joinValues","limit","Infinity","limitText","count","loadingText","loadOptions","matchKeys","maxHeight","multiple","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","openOnClick","openOnFocus","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","startSearchLength","waitSearchFinishTime","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","isLoaded","isLoading","loadingError","localSearch","active","noResults","countMap","lastSearchInput","remoteSearch","computed","selectedNodes","map","getNode","internalValue","single","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","sortValueByLevel","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","hasBranchNodes","some","rootNode","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","$emit","getValue","getInstanceId","buildForestState","handler","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","fallbackNode","label","enhancedNormalizer","isFallbackNode","isDisabled","isNew","$set","defaultNode","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","contains","wrapper","retry","resetHighlightedOptionWhenNecessary","diff","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","$menu","portal","portalTarget","setCurrentHighlightedOption","scroll","prev","isHighlighted","scrollToOption","$option","querySelector","$nextTick","forceReset","highlightFirstOption","first","highlightPrevOption","highlightLastOption","highlightNextOption","last","getLast","resetSearchQuery","saveMenuScrollPosition","restoreMenuScrollPosition","loadRootOptions","toggleMenu","toggleExpanded","nextState","childrenStates","loadChildrenOptions","selectedNodeId","ancestorNode","nodes","checkDuplication","verifyNodeShape","isDefaultExpanded","normalized","hasDisabledDescendants","branchNodes","option","leafNodes","once","catch","console","error","JSON","stringify","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","component","__file","inputWidth","_h","$createElement","_c","_self","attrs","xmlns","viewBox","_withStripped","VERSION","Treeselect","PKG_VERSION"],"mappings":"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","file":"vue-treeselect.umd.min.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__19__) {\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 = 38);\n","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;","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","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.filter(o => o)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index a9f56854..e94aa4c2 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -943,7 +943,7 @@ export default { initialize() { const options = this.async ? this.getRemoteSearchEntry().options - : this.options + : this.options.filter(o => o) if (Array.isArray(options)) { // In case we are re-initializing options, keep the old state tree temporarily. @@ -1062,9 +1062,12 @@ export default { nextSelectedNodeIds = nodeIdListOfPrevValue } else if (this.valueConsistsOf === BRANCH_PRIORITY) { nodeIdListOfPrevValue.forEach(nodeId => { + if (!nodeId) { + return + } nextSelectedNodeIds.push(nodeId) const node = this.getNode(nodeId) - if (node.isBranch) this.traverseDescendantsBFS(node, descendant => { + if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => { if (descendant) { nextSelectedNodeIds.push(descendant.id) } @@ -2004,9 +2007,6 @@ export default { }, mounted() { - if (this.options) { - this.options = this.options.filter(o => o) - } if (this.autoFocus) this.focusInput() if (!this.options && !this.async && this.autoLoadRootOptions) this.loadRootOptions() if (this.alwaysOpen) this.openMenu() From ca49f4c108acac743dcb3687db1e3fdda6679420 Mon Sep 17 00:00:00 2001 From: Almas Date: Sun, 8 Aug 2021 20:21:47 +0800 Subject: [PATCH 05/20] refactor: lint fix --- src/mixins/treeselectMixin.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index e94aa4c2..4446920e 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -548,7 +548,7 @@ export default { */ startSearchLength: { type: Number, - default: 1 + default: 1, }, /** @@ -558,7 +558,7 @@ export default { */ waitSearchFinishTime: { type: Number, - default: 0 + default: 0, }, /** @@ -1248,7 +1248,7 @@ export default { // First time. setTimeout(() => { this.handleLocalSearch(true) - }, this.waitSearchFinishTime); + }, this.waitSearchFinishTime) this.lastSearchInput = now return @@ -1258,7 +1258,7 @@ export default { if (diff < this.waitSearchFinishTime && !retry) { setTimeout(() => { this.handleLocalSearch(true) - }, this.waitSearchFinishTime); + }, this.waitSearchFinishTime) this.lastSearchInput = now return From 7c0041e3b15a6f849c3e880c402cac2556ea56e4 Mon Sep 17 00:00:00 2001 From: Almas Date: Sun, 8 Aug 2021 20:32:59 +0800 Subject: [PATCH 06/20] fix: Changed hasBranchNodes from computed to data for permormance. MichalWi's permormance suggestion in https://github.com/riophae/vue-treeselect/issues/116 --- src/mixins/treeselectMixin.js | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index 4446920e..1f7a3bb7 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -707,6 +707,11 @@ export default { // map. remoteSearch: createMap(), + /** + * Is there any branch node? + * @type {boolean} + */ + hasBranchNodes: null, } }, @@ -818,13 +823,6 @@ export default { ? this.showCountOnSearch : this.showCount }, - /** - * Is there any branch node? - * @type {boolean} - */ - hasBranchNodes() { - return this.forest.normalizedOptions.some(rootNode => rootNode.isBranch) - }, shouldFlattenOptions() { return this.localSearch.active && this.flattenSearchResults }, @@ -961,6 +959,8 @@ export default { } else { this.forest.normalizedOptions = [] } + + this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch) }, getInstanceId() { From 20bc4e8669365a49434b333ad9689cf745ab84b1 Mon Sep 17 00:00:00 2001 From: Almas Date: Sun, 8 Aug 2021 21:06:10 +0800 Subject: [PATCH 07/20] fix: null options fix. --- dist/vue-treeselect.cjs.js | 18 +++++++++--------- dist/vue-treeselect.cjs.js.map | 2 +- dist/vue-treeselect.cjs.min.js | 4 ++-- dist/vue-treeselect.cjs.min.js.map | 2 +- dist/vue-treeselect.css | 2 +- dist/vue-treeselect.min.css | 2 +- dist/vue-treeselect.umd.js | 18 +++++++++--------- dist/vue-treeselect.umd.js.map | 2 +- dist/vue-treeselect.umd.min.js | 4 ++-- dist/vue-treeselect.umd.min.js.map | 2 +- src/mixins/treeselectMixin.js | 2 +- test/unit/specs/Basic.spec.js | 8 ++++---- test/unit/specs/DynamicalLoading.spec.js | 4 ++-- test/unit/specs/Methods.spec.js | 2 +- test/unit/specs/Props.spec.js | 6 +++--- test/unit/specs/utils.spec.js | 2 +- 16 files changed, 40 insertions(+), 40 deletions(-) diff --git a/dist/vue-treeselect.cjs.js b/dist/vue-treeselect.cjs.js index 15893a69..72411e8f 100644 --- a/dist/vue-treeselect.cjs.js +++ b/dist/vue-treeselect.cjs.js @@ -1,5 +1,5 @@ /*! - * vue-treeselect v0.4.0 | (c) 2017-2020 Riophae Lee + * vue-treeselect v0.4.0 | (c) 2017-2021 Riophae Lee * Released under the MIT License. * https://vue-treeselect.js.org/ */ @@ -888,7 +888,8 @@ var instanceId = 0; countMap: createMap() }, lastSearchInput: null, - remoteSearch: createMap() + remoteSearch: createMap(), + hasBranchNodes: null }; }, computed: { @@ -971,11 +972,6 @@ var instanceId = 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; } @@ -1068,9 +1064,9 @@ var instanceId = 0; this._blurOnSelect = false; }, initialize: function initialize() { - var options = this.async ? this.getRemoteSearchEntry().options : this.options.filter(function (o) { + var options = this.async ? this.getRemoteSearchEntry().options : this.options ? this.options.filter(function (o) { return o; - }); + }) : {}; if (Array.isArray(options)) { var prevNodeMap = this.forest.nodeMap; @@ -1081,6 +1077,10 @@ var instanceId = 0; } else { this.forest.normalizedOptions = []; } + + this.hasBranchNodes = this.forest.normalizedOptions.some(function (rootNode) { + return rootNode.isBranch; + }); }, getInstanceId: function getInstanceId() { return this.instanceId == null ? this.id : this.instanceId; diff --git a/dist/vue-treeselect.cjs.js.map b/dist/vue-treeselect.cjs.js.map index 7e309eb8..e7aa0f73 100644 --- a/dist/vue-treeselect.cjs.js.map +++ b/dist/vue-treeselect.cjs.js.map @@ -1 +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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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":"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AAKtS,SAAT,EAAoB,KAAK2L,UAAL;AACpB,QAAI,CAAC,KAAKzI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK+P,eAAL;AAC9D,QAAI,KAAKnQ,UAAT,EAAqB,KAAK+H,QAAL;AACrB,QAAI,KAAK7H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKsH,kBAAL;AACxC,GA/5DY;AAi6Db8J,WAj6Da,uBAi6DD;AAEV,SAAKpH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/NA,+BA+NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AAnOA,GA9CA;AAoRA,QApRA,oBAoRA;AACA;AACA;AAtRA,G;;ACdiN,CAAgB,0GAAG,EAAC,C;;ACArO,IAA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CA,8BACA,qBADA,EADA,EAIA,kBAJA,EAFA,EADA;AAWA,KAvBA;AAyBA,wBAzBA,kCAyBA;AAAA;AACA;AAEA,aACA;AAAA;AAAA,UACA,uBADA,EAEA,0BAFA,EAGA,+BAHA,EAIA,oCAJA,EADA;AAQA,KApCA;AAsCA,eAtCA,yBAsCA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;;AAEA;AACA;AACA;AACA,yDADA;AAEA;AAFA;AADA;AAMA;AACA,8CADA;AAEA;AAFA;AAKA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,YACA,kCACA;AAAA;AAAA,UADA,EADA,EADA;AAOA;;AAKA;AACA,kDACA;AAAA;AAAA,oBADA;AAIA;AACA;;AAEA;AACA,KA5EA;AA8EA,wBA9EA,gCA8EA,QA9EA,EA8EA;AAAA;AACA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KApFA;AAsFA,2BAtFA,mCAsFA,QAtFA,EAsFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAEA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KAjGA;AAmGA,kBAnGA,4BAmGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA;AACA,wCADA;AAEA,qEAFA;AAGA,iFAHA;AAIA,yEAJA;AAKA;AALA;AAQA,kCACA;AAAA;AAAA,QADA;AAGA,kCACA;AAAA;AAAA,QADA;AAIA,aACA;AAAA;AAAA,UACA,SADA,EAEA,SAFA,EADA;AAMA,KA3HA;AA6HA,eA7HA,yBA6HA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA,4BACA,gDACA,kCADA,GAEA,kBAFA,CADA;AAMA,oCACA,8BACA,4DADA,GAEA,gCAHA,GAIA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;A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AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.filter(o => o)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","remoteSearch","hasBranchNodes","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","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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;AAAA,MACVC,GADU,GAC+BD,IAD/B,CACVC,GADU;AAAA,MACLC,QADK,GAC+BF,IAD/B,CACLE,QADK;AAAA,MACKC,SADL,GAC+BH,IAD/B,CACKG,SADL;AAAA,MACgBC,UADhB,GAC+BJ,IAD/B,CACgBI,UADhB;AAElB,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;AAAA,0BAEgB6B,gBAAgB,CAAC7B,GAAD,CAFhC;AAAA,MAEnB8B,QAFmB,qBAEnBA,QAFmB;AAAA,MAETC,SAFS,qBAETA,SAFS;AAAA,MAEEC,SAFF,qBAEEA,SAFF;;AAG3B,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,OAAOA,KAAP;AAC/B,MAAI,OAAOA,KAAP,KAAiB,QAAjB,IAA6B,CAACN,WAAK,CAACM,KAAD,CAAvC,EAAgD,OAAOA,KAAK,GAAG,EAAf;AAEhD,SAAO,EAAP;AACD;;AAED,SAASgE,KAAT,CAAeC,gBAAf,EAAiCC,MAAjC,EAAyCC,QAAzC,EAAmD;AACjD,SAAOF,gBAAgB,GACnBG,8BAAW,CAACF,MAAD,EAASC,QAAT,CADQ,GAEnBvD,QAAQ,CAACuD,QAAD,EAAWD,MAAX,CAFZ;AAGD;;AAED,SAASG,eAAT,CAAyBC,GAAzB,EAA8B;AAC5B,SAAOA,GAAG,CAACjK,OAAJ,IAAyCkK,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;AACrB/J,UAAI,EAAEgK,OADe;AAErBC,aAAO,EAAE;AAFY,KAJlB;AAaLC,qCAAiC,EAAE;AACjClK,UAAI,EAAEgK,OAD2B;AAEjCC,aAAO,EAAE;AAFwB,KAb9B;AAqBLE,cAAU,EAAE;AACVnK,UAAI,EAAEgK,OADI;AAEVC,aAAO,EAAE;AAFC,KArBP;AA6BLG,gBAAY,EAAE;AACZpK,UAAI,EAAEgK,OADM;AAEZC,aAAO,EAAE;AAFG,KA7BT;AAqCLI,SAAK,EAAE;AACLrK,UAAI,EAAEgK,OADD;AAELC,aAAO,EAAE;AAFJ,KArCF;AA6CLK,aAAS,EAAE;AACTtK,UAAI,EAAEgK,OADG;AAETC,aAAO,EAAE;AAFA,KA7CN;AAqDLM,uBAAmB,EAAE;AACnBvK,UAAI,EAAEgK,OADa;AAEnBC,aAAO,EAAE;AAFU,KArDhB;AA6DLO,yBAAqB,EAAE;AACrBxK,UAAI,EAAEgK,OADe;AAErBC,aAAO,EAAE;AAFY,KA7DlB;AAqELQ,2BAAuB,EAAE;AACvBzK,UAAI,EAAEgK,OADiB;AAEvBC,aAAO,EAAE;AAFc,KArEpB;AA6ELS,uBAAmB,EAAE;AACnB1K,UAAI,EAAEgK,OADa;AAEnBC,aAAO,EAAE;AAFU,KA7EhB;AAqFLU,yBAAqB,EAAE;AACrB3K,UAAI,EAAEgK,OADe;AAErBC,aAAO,EAAE;AAFY,KArFlB;AA6FLW,oBAAgB,EAAE;AAChB5K,UAAI,EAAEgK,OADU;AAEhBC,aAAO,EAAE;AAFO,KA7Fb;AAuGLY,kBAAc,EAAE;AACd7K,UAAI,EAAE8K,QADQ;AAEdb,aAAO,EAAEc,kBAAQ,CAAC,IAAD;AAFH,KAvGX;AA+GLC,oBAAgB,EAAE;AAChBhL,UAAI,EAAEgK,OADU;AAEhBC,aAAO,EAAE;AAFO,KA/Gb;AAuHLgB,gBAAY,EAAE;AACZjL,UAAI,EAAEgK,OADM;AAEZC,aAAO,EAAE;AAFG,KAvHT;AA+HLiB,aAAS,EAAE;AACTlL,UAAI,EAAEgK,OADG;AAETC,aAAO,EAAE;AAFA,KA/HN;AAuILkB,gBAAY,EAAE;AACZnL,UAAI,EAAE0J,MADM;AAEZO,aAAO,EAAE;AAFG,KAvIT;AAiJLmB,iBAAa,EAAE;AACbpL,UAAI,EAAEgK,OADO;AAEbC,aAAO,EAAE;AAFI,KAjJV;AAyJLoB,kBAAc,EAAE;AACdrL,UAAI,EAAE0J,MADQ;AAEdO,aAAO,EAAE;AAFK,KAzJX;AAkKLqB,iBAAa,EAAE;AACbtL,UAAI,EAAEgK,OADO;AAEbC,aAAO,EAAE;AAFI,KAlKV;AA2KLsB,sBAAkB,EAAE;AAClBvL,UAAI,EAAEwL,MADY;AAElBvB,aAAO,EAAE;AAFS,KA3Kf;AAqLLwB,kBAAc,EAAE;AACdxB,aAAO,EAAE;AADK,KArLX;AA4LLyB,iBAAa,EAAE;AACb1L,UAAI,EAAEgK,OADO;AAEbC,aAAO,EAAE;AAFI,KA5LV;AAoML0B,aAAS,EAAE;AACT3L,UAAI,EAAE0J,MADG;AAETO,aAAO,EAAE;AAFA,KApMN;AA8ML2B,wBAAoB,EAAE;AACpB5L,UAAI,EAAEgK,OADc;AAEpBC,aAAO,EAAE;AAFW,KA9MjB;AAsNL4B,sBAAkB,EAAE;AAClB7L,UAAI,EAAEgK,OADY;AAElBC,aAAO,EAAE;AAFS,KAtNf;AA8NL6B,YAAQ,EAAE;AACR9L,UAAI,EAAEgK,OADE;AAERC,aAAO,EAAE;AAFD,KA9NL;AAsOL8B,wBAAoB,EAAE;AACpB/L,UAAI,EAAEgK,OADc;AAEpBC,aAAO,EAAE;AAFW,KAtOjB;AAiPL+B,QAAI,EAAE;AACJhM,UAAI,EAAEgK,OADF;AAEJC,aAAO,EAAE;AAFL,KAjPD;AA0PLN,cAAU,EAAE;AAEVM,aAAO,EAAE;AAAA,yBAASN,UAAU,EAAnB;AAAA,OAFC;AAGV3J,UAAI,EAAE,CAAE0J,MAAF,EAAU8B,MAAV;AAHI,KA1PP;AAmQLS,cAAU,EAAE;AACVjM,UAAI,EAAEgK,OADI;AAEVC,aAAO,EAAE;AAFC,KAnQP;AA4QLiC,SAAK,EAAE;AACLlM,UAAI,EAAEwL,MADD;AAELvB,aAAO,EAAEkC;AAFJ,KA5QF;AAqRLC,aAAS,EAAE;AACTpM,UAAI,EAAE8K,QADG;AAETb,aAAO,EAAE,SAASoC,gBAAT,CAA0BC,KAA1B,EAAiC;AACxC,6BAAcA,KAAd;AACD;AAJQ,KArRN;AA+RLC,eAAW,EAAE;AACXvM,UAAI,EAAE0J,MADK;AAEXO,aAAO,EAAE;AAFE,KA/RR;AAwSLuC,eAAW,EAAE;AACXxM,UAAI,EAAE8K;AADK,KAxSR;AA+SL2B,aAAS,EAAE;AACTzM,UAAI,EAAE0M,KADG;AAETzC,aAAO,EAAEc,kBAAQ,CAAC,CAAE,OAAF,CAAD;AAFR,KA/SN;AAuTL4B,aAAS,EAAE;AACT3M,UAAI,EAAEwL,MADG;AAETvB,aAAO,EAAE;AAFA,KAvTN;AA+TL2C,YAAQ,EAAE;AACR5M,UAAI,EAAEgK,OADE;AAERC,aAAO,EAAE;AAFD,KA/TL;AAuUL4C,QAAI,EAAE;AACJ7M,UAAI,EAAE0J;AADF,KAvUD;AA8ULoD,kBAAc,EAAE;AACd9M,UAAI,EAAE0J,MADQ;AAEdO,aAAO,EAAE;AAFK,KA9UX;AAsVL8C,iBAAa,EAAE;AACb/M,UAAI,EAAE0J,MADO;AAEbO,aAAO,EAAE;AAFI,KAtVV;AA8VL+C,iBAAa,EAAE;AACbhN,UAAI,EAAE0J,MADO;AAEbO,aAAO,EAAE;AAFI,KA9VV;AAuWLgD,cAAU,EAAE;AACVjN,UAAI,EAAE8K,QADI;AAEVb,aAAO,EAAEiD,kBAAQA;AAFP,KAvWP;AAwXLC,iBAAa,EAAE;AACbnN,UAAI,EAAE0J,MADO;AAEbO,aAAO,EAAE,MAFI;AAGbmD,eAHa,qBAGHjI,KAHG,EAGI;AACf,YAAMkI,gBAAgB,GAAG,CAAE,MAAF,EAAU,KAAV,EAAiB,QAAjB,EAA2B,OAA3B,EAAoC,OAApC,CAAzB;AACA,eAAOtH,QAAQ,CAACsH,gBAAD,EAAmBlI,KAAnB,CAAf;AACD;AANY,KAxXV;AAoYLmI,eAAW,EAAE;AACXtN,UAAI,EAAEgK,OADK;AAEXC,aAAO,EAAE;AAFE,KApYR;AA4YLsD,eAAW,EAAE;AACXvN,UAAI,EAAEgK,OADK;AAEXC,aAAO,EAAE;AAFE,KA5YR;AAqZLuD,WAAO,EAAE;AACPxN,UAAI,EAAE0M;AADC,KArZJ;AA4ZLe,eAAW,EAAE;AACXzN,UAAI,EAAE0J,MADK;AAEXO,aAAO,EAAE;AAFE,KA5ZR;AAoaLyD,YAAQ,EAAE;AACR1N,UAAI,EAAEgK,OADE;AAERC,aAAO,EAAE;AAFD,KApaL;AA4aL0D,aAAS,EAAE;AACT3N,UAAI,EAAE0J,MADG;AAETO,aAAO,EAAE;AAFA,KA5aN;AAobL2D,cAAU,EAAE;AACV5N,UAAI,EAAE0J,MADI;AAEVO,aAAO,EAAE;AAFC,KApbP;AA4bL4D,cAAU,EAAE;AACV7N,UAAI,EAAEgK,OADI;AAEVC,aAAO,EAAE;AAFC,KA5bP;AAocL6D,gBAAY,EAAE;AACZ9N,UAAI,EAAEgK,OADM;AAEZC,aAAO,EAAE;AAFG,KApcT;AA4cL8D,oBAAgB,EAAE;AAChB/N,UAAI,EAAE0J,MADU;AAEhBO,aAAO,EAAE;AAFO,KA5cb;AAodL+D,aAAS,EAAE;AACThO,UAAI,EAAEgK,OADG;AAETC,aAAO,EAAE;AAFA,KApdN;AA6dLgE,qBAAiB,EAAE;AACjBjO,UAAI,EAAEwL,MADW;AAEjBvB,aAAO,EAAE;AAFQ,KA7dd;AAueLiE,wBAAoB,EAAE;AACpBlO,UAAI,EAAEwL,MADc;AAEpBvB,aAAO,EAAE;AAFW,KAvejB;AAofLkE,eAAW,EAAE;AACXnO,UAAI,EAAE0J,MADK;AAEXO,aAAO,EAAErD,YAFE;AAGXwG,eAHW,qBAGDjI,KAHC,EAGM;AACf,YAAMkI,gBAAgB,GAAG,CAAEzG,YAAF,EAAgBC,eAAhB,EAAiCC,aAAjC,EAAgDC,gBAAhD,CAAzB;AACA,eAAOhB,QAAQ,CAACsH,gBAAD,EAAmBlI,KAAnB,CAAf;AACD;AANU,KApfR;AAkgBLiJ,qBAAiB,EAAE,IAlgBd;AA4gBLC,eAAW,EAAE;AACXrO,UAAI,EAAE0J,MADK;AAEXO,aAAO,EAAE1C,cAFE;AAGX6F,eAHW,qBAGDjI,KAHC,EAGM;AACf,YAAMkI,gBAAgB,GAAG,CAAE9F,cAAF,EAAkBC,KAAlB,EAAyBC,KAAzB,CAAzB;AACA,eAAO1B,QAAQ,CAACsH,gBAAD,EAAmBlI,KAAnB,CAAf;AACD;AANU,KA5gBR;AAwhBLmJ,YAAQ,EAAE;AACRtO,UAAI,EAAEwL,MADE;AAERvB,aAAO,EAAE;AAFD,KAxhBL;AAoiBL9E,SAAK,EAAE,IApiBF;AA8iBLoJ,mBAAe,EAAE;AACfvO,UAAI,EAAE0J,MADS;AAEfO,aAAO,EAAE7C,eAFM;AAGfgG,eAHe,qBAGLjI,KAHK,EAGE;AACf,YAAMkI,gBAAgB,GAAG,CAAElG,GAAF,EAAOC,eAAP,EAAwBC,aAAxB,EAAuCC,sBAAvC,CAAzB;AACA,eAAOvB,QAAQ,CAACsH,gBAAD,EAAmBlI,KAAnB,CAAf;AACD;AANc,KA9iBZ;AA8jBLqJ,eAAW,EAAE;AACXxO,UAAI,EAAE0J,MADK;AAEXO,aAAO,EAAE;AAFE,KA9jBR;AAskBLwE,UAAM,EAAE;AACNzO,UAAI,EAAE,CAAEwL,MAAF,EAAU9B,MAAV,CADA;AAENO,aAAO,EAAE;AAFH;AAtkBH,GATM;AAqlBbyE,MArlBa,kBAqlBN;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,EAAEtK,SAAS,EAJZ;AAMNuK,uBAAe,EAAEvK,SAAS,EANpB;AAQNwK,uBAAe,EAAE,KAAKC,8BAAL,EARX;AAWNC,uBAAe,EAAE1K,SAAS;AAXpB,OAnBH;AAkCL2K,uBAAiB,EAAE5G,wBAAwB,EAlCtC;AAoCL6G,iBAAW,EAAE;AAEXC,cAAM,EAAE,KAFG;AAIXC,iBAAS,EAAE,IAJA;AAMXC,gBAAQ,EAAE/K,SAAS;AANR,OApCR;AA6CLgL,qBAAe,EAAE,IA7CZ;AAgDLC,kBAAY,EAAEjL,SAAS,EAhDlB;AAqDLkL,oBAAc,EAAE;AArDX,KAAP;AAuDD,GA7oBY;AA+oBbC,UAAQ,EAAE;AAMRC,iBANQ,2BAMQ;AACd,aAAO,KAAKhB,MAAL,CAAYI,eAAZ,CAA4Ba,GAA5B,CAAgC,KAAKC,OAArC,CAAP;AACD,KARO;AAaRC,iBAbQ,2BAaQ;AAAA;;AACd,UAAIA,aAAJ;;AAGA,UAAI,KAAKC,MAAL,IAAe,KAAKvE,IAApB,IAA4B,KAAKH,kBAAjC,IAAuD,KAAK0C,eAAL,KAAyBpH,GAApF,EAAyF;AACvFmJ,qBAAa,GAAG,KAAKnB,MAAL,CAAYI,eAAZ,CAA4BiB,KAA5B,EAAhB;AACD,OAFD,MAEO,IAAI,KAAKjC,eAAL,KAAyBnH,eAA7B,EAA8C;AACnDkJ,qBAAa,GAAG,KAAKnB,MAAL,CAAYI,eAAZ,CAA4BkB,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,KAAK2K,eAAL,KAAyBlH,aAA7B,EAA4C;AACjDiJ,qBAAa,GAAG,KAAKnB,MAAL,CAAYI,eAAZ,CAA4BkB,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,KAAKyL,eAAL,KAAyBjH,sBAA7B,EAAqD;AAAA;;AAC1D,YAAM0J,oBAAoB,GAAG,EAA7B;AACAV,qBAAa,GAAG,KAAKnB,MAAL,CAAYI,eAAZ,CAA4BiB,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,KAAK3C,WAAL,KAAqB7G,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,KAAK2F,WAAL,KAAqB5G,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,KAAK3D,QAAb;AACD,KAjEO;AA0ER0E,oBA1EQ,8BA0EW;AAAA;;AACjB,UAAMA,gBAAgB,GAAG,EAAzB;AAEA,WAAKC,uBAAL,CAA6B,UAAAZ,IAAI,EAAI;AACnC,YAAI,CAAC,MAAI,CAAChB,WAAL,CAAiBC,MAAlB,IAA4B,MAAI,CAAC4B,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,KAAKxD,iBAAZ,KAAkC,SAAlC,GACH,KAAKA,iBADF,GAEH,KAAKJ,SAFT;AAGD,KA3GO;AA4GR6D,wBA5GQ,kCA4Ge;AACrB,aAAO,KAAKlC,WAAL,CAAiBC,MAAjB,IAA2B,KAAKhE,oBAAvC;AACD;AA9GO,GA/oBG;AAiwBbkG,OAAK,EAAE;AACL3H,cADK,sBACM4H,QADN,EACgB;AACnB,UAAIA,QAAJ,EAAc,KAAKC,QAAL,GAAd,KACK,KAAKC,SAAL;AACN,KAJI;AAMLjH,oBANK,8BAMc;AACjB,WAAKkH,UAAL;AACD,KARI;AAULpG,YAVK,oBAUIiG,QAVJ,EAUc;AAEjB,UAAIA,QAAQ,IAAI,KAAKjD,IAAL,CAAUC,MAA1B,EAAkC,KAAKkD,SAAL,GAAlC,KACK,IAAI,CAACF,QAAD,IAAa,CAAC,KAAKjD,IAAL,CAAUC,MAAxB,IAAkC,KAAK5E,UAA3C,EAAuD,KAAK6H,QAAL;AAC7D,KAdI;AAgBLhG,QAhBK,kBAgBE;AACL,WAAKkG,UAAL;AACD,KAlBI;AAoBL5B,iBApBK,yBAoBSyB,QApBT,EAoBmBI,QApBnB,EAoB6B;AAChC,UAAMC,UAAU,GAAG/L,SAAS,CAAC0L,QAAD,EAAWI,QAAX,CAA5B;AAIA,UAAIC,UAAJ,EAAgB,KAAKC,KAAL,CAAW,OAAX,EAAoB,KAAKC,QAAL,EAApB,EAAqC,KAAKC,aAAL,EAArC;AACjB,KA1BI;AA4BL9F,aA5BK,uBA4BO;AACV,WAAKyF,UAAL;AACD,KA9BI;AAgCLtF,YAhCK,oBAgCImF,QAhCJ,EAgCc;AAIjB,UAAIA,QAAJ,EAAc,KAAKS,gBAAL;AACf,KArCI;AAuCLhF,WAAO,EAAE;AACPiF,aADO,qBACG;AACR,YAAI,KAAKpI,KAAT,EAAgB;AAEhB,aAAK6H,UAAL;AACA,aAAKxC,iBAAL,CAAuB3G,QAAvB,GAAkC2D,KAAK,CAACgG,OAAN,CAAc,KAAKlF,OAAnB,CAAlC;AACD,OANM;AAOPmF,UAAI,EAAE,IAPC;AAQPC,eAAS,EAAE;AARJ,KAvCJ;AAkDL,yBAlDK,gCAkDmB;AACtB,UAAI,KAAKvI,KAAT,EAAgB;AACd,aAAKwI,kBAAL;AACD,OAFD,MAEO;AACL,aAAKC,iBAAL;AACD;;AAED,WAAKT,KAAL,CAAW,eAAX,EAA4B,KAAK1D,OAAL,CAAaE,WAAzC,EAAsD,KAAK0D,aAAL,EAAtD;AACD,KA1DI;AA4DLpN,SA5DK,mBA4DG;AACN,UAAM4N,gBAAgB,GAAG,KAAKvD,8BAAL,EAAzB;AACA,UAAM4C,UAAU,GAAG/L,SAAS,CAAC0M,gBAAD,EAAmB,KAAKzC,aAAxB,CAA5B;AACA,UAAI8B,UAAJ,EAAgB,KAAKY,kBAAL,CAAwBD,gBAAxB;AACjB;AAhEI,GAjwBM;AAo0BbE,SAAO,EAAE;AACPC,eADO,yBACO;AAAA;;AACZjU,qBAAO,CACL;AAAA,eAAM,MAAI,CAACoL,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;AAC7CvN,uBAAO,CACL;AAAA,iBAAM,KAAN;AAAA,SADK,EAEL;AAAA,iBAAM,gFAAN;AAAA,SAFK,CAAP;AAID;;AAED,UAAI,KAAK+M,IAAT,EAAe;AACb/M,uBAAO,CACL;AAAA,iBAAM,MAAI,CAAC2N,QAAX;AAAA,SADK,EAEL;AAAA,iBAAM,iEAAN;AAAA,SAFK,CAAP;AAID;;AAED,UAAI,CAAC,KAAKZ,IAAV,EAAgB;AACd,YAAMmH,SAAS,GAAG,CAChB,qBADgB,EAEhB,uBAFgB,EAGhB,uBAHgB,EAIhB,yBAJgB,CAAlB;AAOAA,iBAAS,CAACnR,OAAV,CAAkB,UAAAoR,QAAQ,EAAI;AAC5BnU,yBAAO,CACL;AAAA,mBAAM,CAAC,MAAI,CAACmU,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,UAAM1E,OAAO,GAAG,KAAKnD,KAAL,GACZ,KAAKkJ,oBAAL,GAA4B/F,OADhB,GAEZ,KAAKA,OAAL,GAAe,KAAKA,OAAL,CAAaiD,MAAb,CAAoB,UAAA+C,CAAC;AAAA,eAAIA,CAAJ;AAAA,OAArB,CAAf,GAA6C,EAFjD;;AAIA,UAAI9G,KAAK,CAACgG,OAAN,CAAclF,OAAd,CAAJ,EAA4B;AAE1B,YAAMiG,WAAW,GAAG,KAAKtE,MAAL,CAAYE,OAAhC;AACA,aAAKF,MAAL,CAAYE,OAAZ,GAAsBtK,SAAS,EAA/B;AACA,aAAK2O,uBAAL,CAA6BD,WAA7B;AACA,aAAKtE,MAAL,CAAYC,iBAAZ,GAAgC,KAAKuE,SAAL,CAAenN,cAAf,EAA+BgH,OAA/B,EAAwCiG,WAAxC,CAAhC;AAOA,aAAKT,kBAAL,CAAwB,KAAK1C,aAA7B;AACD,OAbD,MAaO;AACL,aAAKnB,MAAL,CAAYC,iBAAZ,GAAgC,EAAhC;AACD;;AAED,WAAKa,cAAL,GAAsB,KAAKd,MAAL,CAAYC,iBAAZ,CAA8BwE,IAA9B,CAAmC,UAAAC,QAAQ;AAAA,eAAIA,QAAQ,CAACpC,QAAb;AAAA,OAA3C,CAAtB;AACD,KAjEM;AAmEPc,iBAnEO,2BAmES;AACd,aAAO,KAAK5I,UAAL,IAAmB,IAAnB,GAA0B,KAAK+G,EAA/B,GAAoC,KAAK/G,UAAhD;AACD,KArEM;AAuEP2I,YAvEO,sBAuEI;AAAA;;AACT,UAAI,KAAK9D,WAAL,KAAqB,IAAzB,EAA+B;AAC7B,eAAO,KAAK5B,QAAL,GACH,KAAK0D,aAAL,CAAmBE,KAAnB,EADG,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,KAAKnH,QAAL,GAAgBkH,QAAhB,GAA2BA,QAAQ,CAAC,CAAD,CAA1C;AACD,KAhFM;AAkFPzD,WAlFO,mBAkFC2D,MAlFD,EAkFS;AACd/U,qBAAO,CACL;AAAA,eAAM+U,MAAM,IAAI,IAAhB;AAAA,OADK,EAEL;AAAA,0CAA0BA,MAA1B;AAAA,OAFK,CAAP;;AAKA,UAAIA,MAAM,IAAI,IAAd,EAAoB;AAClB,YAAI9U,OAAO,CAACC,GAAR,CAAYC,QAAZ,KAAyB,YAA7B,EAA2C;AACzCM,iBAAO,CAACC,KAAR,CAAc,KAAK6N,OAAnB;AACD;;AACD,eAAO,IAAP;AACD;;AAED,aAAOwG,MAAM,IAAI,KAAK7E,MAAL,CAAYE,OAAtB,GACH,KAAKF,MAAL,CAAYE,OAAZ,CAAoB2E,MAApB,CADG,GAEH,KAAKC,kBAAL,CAAwBD,MAAxB,CAFJ;AAGD,KAlGM;AAoGPC,sBApGO,8BAoGYvD,EApGZ,EAoGgB;AAKrB,UAAMqD,GAAG,GAAG,KAAKG,oBAAL,CAA0BxD,EAA1B,CAAZ;AACA,UAAMyD,KAAK,GAAG,KAAKC,kBAAL,CAAwBL,GAAxB,EAA6BI,KAA7B,cAAyCzD,EAAzC,eAAd;AACA,UAAM2D,YAAY,GAAG;AACnB3D,UAAE,EAAFA,EADmB;AAEnByD,aAAK,EAALA,KAFmB;AAGnBjD,iBAAS,EAAE,EAHQ;AAInBtN,kBAAU,EAAE4C,cAJO;AAKnB8N,sBAAc,EAAE,IALG;AAMnB1D,kBAAU,EAAE,IANO;AAOnBE,cAAM,EAAE,IAPW;AAQnBW,gBAAQ,EAAE,KARS;AASnB8C,kBAAU,EAAE,KATO;AAUnBC,aAAK,EAAE,KAVY;AAWnB5L,aAAK,EAAE,CAAE,CAAC,CAAH,CAXY;AAYnBD,aAAK,EAAE,CAZY;AAanBoL,WAAG,EAAHA;AAbmB,OAArB;AAgBA,aAAO,KAAKU,IAAL,CAAU,KAAKtF,MAAL,CAAYE,OAAtB,EAA+BqB,EAA/B,EAAmC2D,YAAnC,CAAP;AACD,KA5HM;AA8HP7E,kCA9HO,4CA8H0B;AAAA;;AAC/B,UAAI,KAAKrK,KAAL,IAAc,IAAlB,EAAwB,OAAO,EAAP;;AAExB,UAAI,KAAKqJ,WAAL,KAAqB,IAAzB,EAA+B;AAC7B,eAAO,KAAK5B,QAAL,GACH,KAAKzH,KAAL,CAAWqL,KAAX,EADG,GAEH,CAAE,KAAKrL,KAAP,CAFJ;AAGD;;AAED,aAAO,CAAC,KAAKyH,QAAL,GAAgB,KAAKzH,KAArB,GAA6B,CAAE,KAAKA,KAAP,CAA9B,EACJiL,GADI,CACA,UAAAO,IAAI;AAAA,eAAI,MAAI,CAACyD,kBAAL,CAAwBzD,IAAxB,CAAJ;AAAA,OADJ,EAEJP,GAFI,CAEA,UAAAO,IAAI;AAAA,eAAIA,IAAI,CAACD,EAAT;AAAA,OAFJ,CAAP;AAGD,KA1IM;AA4IPwD,wBA5IO,gCA4IcxD,EA5Id,EA4IkB;AAAA;;AACvB,UAAMgE,WAAW,GAAG;AAAEhE,UAAE,EAAFA;AAAF,OAApB;;AAEA,UAAI,KAAKlC,WAAL,KAAqB,IAAzB,EAA+B;AAC7B,eAAOkG,WAAP;AACD;;AAED,UAAMC,UAAU,GAAG,KAAK/H,QAAL,GACfF,KAAK,CAACgG,OAAN,CAAc,KAAKvN,KAAnB,IAA4B,KAAKA,KAAjC,GAAyC,EAD1B,GAEf,KAAKA,KAAL,GAAa,CAAE,KAAKA,KAAP,CAAb,GAA8B,EAFlC;AAGA,UAAMyP,OAAO,GAAG3O,IAAI,CAClB0O,UADkB,EAElB,UAAAhE,IAAI;AAAA,eAAIA,IAAI,IAAI,MAAI,CAACyD,kBAAL,CAAwBzD,IAAxB,EAA8BD,EAA9B,KAAqCA,EAAjD;AAAA,OAFc,CAApB;AAKA,aAAOkE,OAAO,IAAIF,WAAlB;AACD,KA5JM;AA8JP1B,sBA9JO,8BA8JY6B,qBA9JZ,EA8JmC;AAAA;;AACxC,UAAIC,mBAAmB,GAAG,EAA1B;;AAGA,UAAI,KAAKvE,MAAL,IAAe,KAAKvE,IAApB,IAA4B,KAAKH,kBAAjC,IAAuD,KAAK0C,eAAL,KAAyBpH,GAApF,EAAyF;AACvF2N,2BAAmB,GAAGD,qBAAtB;AACD,OAFD,MAEO,IAAI,KAAKtG,eAAL,KAAyBnH,eAA7B,EAA8C;AACnDyN,6BAAqB,CAAC7S,OAAtB,CAA8B,UAAAgS,MAAM,EAAI;AACtC,cAAI,CAACA,MAAL,EAAa;AACX;AACD;;AACDc,6BAAmB,CAAC/R,IAApB,CAAyBiR,MAAzB;;AACA,cAAMrD,IAAI,GAAG,MAAI,CAACN,OAAL,CAAa2D,MAAb,CAAb;;AACA,cAAIrD,IAAI,IAAIA,IAAI,CAACc,QAAjB,EAA2B,MAAI,CAACsD,sBAAL,CAA4BpE,IAA5B,EAAkC,UAAAqE,UAAU,EAAI;AACzE,gBAAIA,UAAJ,EAAgB;AACdF,iCAAmB,CAAC/R,IAApB,CAAyBiS,UAAU,CAACtE,EAApC;AACD;AACF,WAJ0B;AAK5B,SAXD;AAYD,OAbM,MAaA,IAAI,KAAKnC,eAAL,KAAyBlH,aAA7B,EAA4C;AACjD,YAAM+I,GAAG,GAAGrL,SAAS,EAArB;AACA,YAAMkQ,KAAK,GAAGJ,qBAAqB,CAACrE,KAAtB,EAAd;;AACA,eAAOyE,KAAK,CAACnS,MAAb,EAAqB;AACnB,cAAMkR,MAAM,GAAGiB,KAAK,CAACC,KAAN,EAAf;AACA,cAAMvE,IAAI,GAAG,KAAKN,OAAL,CAAa2D,MAAb,CAAb;AACAc,6BAAmB,CAAC/R,IAApB,CAAyBiR,MAAzB;AACA,cAAIrD,IAAI,CAACC,UAAT,EAAqB;AACrB,cAAI,CAACD,IAAI,CAAC/M,UAAV,EAAsB;AACtB,cAAI,EAAE+M,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,EAAqCuE,KAAK,CAAClS,IAAN,CAAW4N,IAAI,CAAC/M,UAAL,CAAgB8M,EAA3B;AACtC;AACF,OAZM,MAYA,IAAI,KAAKnC,eAAL,KAAyBjH,sBAA7B,EAAqD;AAC1D,YAAM8I,IAAG,GAAGrL,SAAS,EAArB;;AACA,YAAMkQ,MAAK,GAAGJ,qBAAqB,CAACpE,MAAtB,CAA6B,UAAAuD,MAAM,EAAI;AACnD,cAAMrD,IAAI,GAAG,MAAI,CAACN,OAAL,CAAa2D,MAAb,CAAb;;AACA,iBAAOrD,IAAI,CAACG,MAAL,IAAeH,IAAI,CAACI,QAAL,CAAcjO,MAAd,KAAyB,CAA/C;AACD,SAHa,CAAd;;AAIA,eAAOmS,MAAK,CAACnS,MAAb,EAAqB;AACnB,cAAMkR,OAAM,GAAGiB,MAAK,CAACC,KAAN,EAAf;;AACA,cAAMvE,KAAI,GAAG,KAAKN,OAAL,CAAa2D,OAAb,CAAb;;AACAc,6BAAmB,CAAC/R,IAApB,CAAyBiR,OAAzB;AACA,cAAIrD,KAAI,CAACC,UAAT,EAAqB;AACrB,cAAI,CAACD,KAAI,CAAC/M,UAAV,EAAsB;AACtB,cAAI,EAAE+M,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,EAAqCuE,MAAK,CAAClS,IAAN,CAAW4N,KAAI,CAAC/M,UAAL,CAAgB8M,EAA3B;AACtC;AACF;;AAED,UAAM0B,UAAU,GAAG/L,SAAS,CAAC,KAAK8I,MAAL,CAAYI,eAAb,EAA8BuF,mBAA9B,CAA5B;AAIA,UAAI1C,UAAJ,EAAgB,KAAKjD,MAAL,CAAYI,eAAZ,GAA8BuF,mBAA9B;AAEhB,WAAKtC,gBAAL;AACD,KArNM;AAuNPkB,2BAvNO,mCAuNiBD,WAvNjB,EAuN8B;AAAA;;AAGnC,WAAKtE,MAAL,CAAYI,eAAZ,CAA4BvN,OAA5B,CAAoC,UAAA0O,EAAE,EAAI;AACxC,YAAI,CAAC+C,WAAW,CAAC/C,EAAD,CAAhB,EAAsB;;AACtB,YAAMC,IAAI,mCACL8C,WAAW,CAAC/C,EAAD,CADN;AAER4D,wBAAc,EAAE;AAFR,UAAV;;AAIA,cAAI,CAACG,IAAL,CAAU,MAAI,CAACtF,MAAL,CAAYE,OAAtB,EAA+BqB,EAA/B,EAAmCC,IAAnC;AACD,OAPD;AAQD,KAlOM;AAoOPE,cApOO,sBAoOIF,IApOJ,EAoOU;AAEf,aAAO,KAAKxB,MAAL,CAAYM,eAAZ,CAA4BkB,IAAI,CAACD,EAAjC,MAAyC,IAAhD;AACD,KAvOM;AAyOPqE,0BAzOO,kCAyOgBnR,UAzOhB,EAyO4BuR,QAzO5B,EAyOsC;AAE3C,UAAI,CAACvR,UAAU,CAAC6N,QAAhB,EAA0B;AAC1B,UAAMwD,KAAK,GAAGrR,UAAU,CAACmN,QAAX,CAAoBP,KAApB,EAAd;;AACA,aAAOyE,KAAK,CAACnS,MAAb,EAAqB;AACnB,YAAMsS,QAAQ,GAAGH,KAAK,CAAC,CAAD,CAAtB;AACA,YAAIG,QAAQ,CAAC3D,QAAb,EAAuBwD,KAAK,CAAClS,IAAN,OAAAkS,KAAK,8BAASG,QAAQ,CAACrE,QAAlB,EAAL;AACvBoE,gBAAQ,CAACC,QAAD,CAAR;AACAH,aAAK,CAACC,KAAN;AACD;AACF,KAnPM;AAqPPG,0BArPO,kCAqPgBzR,UArPhB,EAqP4BuR,QArP5B,EAqPsC;AAAA;;AAC3C,UAAI,CAACvR,UAAU,CAAC6N,QAAhB,EAA0B;AAC1B7N,gBAAU,CAACmN,QAAX,CAAoB/O,OAApB,CAA4B,UAAAsT,KAAK,EAAI;AAEnC,cAAI,CAACD,sBAAL,CAA4BC,KAA5B,EAAmCH,QAAnC;;AACAA,gBAAQ,CAACG,KAAD,CAAR;AACD,OAJD;AAKD,KA5PM;AA8PPC,uBA9PO,+BA8PaJ,QA9Pb,EA8PuB;AAAA;;AAC5B,WAAKhG,MAAL,CAAYC,iBAAZ,CAA8BpN,OAA9B,CAAsC,UAAA6R,QAAQ,EAAI;AAEhD,eAAI,CAACwB,sBAAL,CAA4BxB,QAA5B,EAAsCsB,QAAtC;;AACAA,gBAAQ,CAACtB,QAAD,CAAR;AACD,OAJD;AAKD,KApQM;AAsQPtC,2BAtQO,mCAsQiB4D,QAtQjB,EAsQ2B;AAChC,UAAMK,IAAI,GAAG,SAAPA,IAAO,CAAA5R,UAAU,EAAI;AACzBA,kBAAU,CAACmN,QAAX,CAAoB/O,OAApB,CAA4B,UAAAsT,KAAK,EAAI;AACnC,cAAIH,QAAQ,CAACG,KAAD,CAAR,KAAoB,KAApB,IAA6BA,KAAK,CAAC7D,QAAvC,EAAiD;AAC/C+D,gBAAI,CAACF,KAAD,CAAJ;AACD;AACF,SAJD;AAKD,OAND;;AAUAE,UAAI,CAAC;AAAEzE,gBAAQ,EAAE,KAAK5B,MAAL,CAAYC;AAAxB,OAAD,CAAJ;AACD,KAlRM;AAoRPqG,2BApRO,mCAoRiBC,OApRjB,EAoR0B;AAC/B,UAAIA,OAAJ,EAAa;AACXxS,gBAAQ,CAACqB,gBAAT,CAA0B,WAA1B,EAAuC,KAAKoR,kBAA5C,EAAgE,KAAhE;AACD,OAFD,MAEO;AACLzS,gBAAQ,CAACyB,mBAAT,CAA6B,WAA7B,EAA0C,KAAKgR,kBAA/C,EAAmE,KAAnE;AACD;AACF,KA1RM;AA4RPC,qBA5RO,+BA4Ra;AAClB,aAAO,KAAKC,KAAL,CAAWC,OAAX,CAAmBD,KAAnB,CAAyB,iBAAzB,CAAP;AACD,KA9RM;AAgSPE,YAhSO,sBAgSI;AACT,aAAO,KAAKH,iBAAL,GAAyBC,KAAzB,CAA+BG,KAAtC;AACD,KAlSM;AAoSPC,cApSO,wBAoSM;AACX,WAAKF,QAAL,GAAgBG,KAAhB;AACD,KAtSM;AAwSPC,aAxSO,uBAwSK;AACV,WAAKJ,QAAL,GAAgBK,IAAhB;AACD,KA1SM;AA4SPC,mBAAe,EAAEzW,WAAW,CAAC,SAASyW,eAAT,CAAyBtW,GAAzB,EAA8B;AACzDA,SAAG,CAACuW,cAAJ;AACAvW,SAAG,CAACwW,eAAJ;AAEA,UAAI,KAAKzK,QAAT,EAAmB;AAEnB,UAAM0K,yBAAyB,GAAG,KAAKZ,iBAAL,GAAyBvT,GAAzB,CAA6BoU,QAA7B,CAAsC1W,GAAG,CAAC2F,MAA1C,CAAlC;;AACA,UAAI8Q,yBAAyB,IAAI,CAAC,KAAK1H,IAAL,CAAUC,MAAxC,KAAmD,KAAKzB,WAAL,IAAoB,KAAKqB,OAAL,CAAaC,SAApF,CAAJ,EAAoG;AAClG,aAAKoD,QAAL;AACD;;AAED,UAAI,KAAKsB,aAAT,EAAwB;AACtB,aAAK6C,SAAL;AACD,OAFD,MAEO;AAEL,aAAKF,UAAL;AACD;;AAED,WAAK5C,UAAL;AACD,KAnB2B,CA5SrB;AAiUPsC,sBAjUO,8BAiUY5V,GAjUZ,EAiUiB;AAEtB,UAAI,KAAK8V,KAAL,CAAWa,OAAX,IAAsB,CAAC,KAAKb,KAAL,CAAWa,OAAX,CAAmBD,QAAnB,CAA4B1W,GAAG,CAAC2F,MAAhC,CAA3B,EAAoE;AAClE,aAAKyQ,SAAL;AACA,aAAKlE,SAAL;AACD;AACF,KAvUM;AAyUPa,qBAzUO,6BAyUW6D,KAzUX,EAyUkB;AAAA;;AAAA,UACf9H,WADe,GACC,KAAKF,OADN,CACfE,WADe;;AAEvB,UAAM+H,IAAI,GAAG,SAAPA,IAAO;AAAA,eAAM,OAAI,CAACC,mCAAL,CAAyC,IAAzC,CAAN;AAAA,OAAb;;AAEA,UAAI,CAAChI,WAAL,EAAkB;AAEhB,aAAKc,WAAL,CAAiBC,MAAjB,GAA0B,KAA1B;AACA,aAAKG,eAAL,GAAuB,IAAvB;AACA,eAAO6G,IAAI,EAAX;AACD;;AAED,UAAI/H,WAAW,CAAC/L,MAAZ,GAAqB,KAAKmL,iBAA9B,EAAiD;AAE/C;AACD;;AAED,UAAI,KAAKC,oBAAL,GAA4B,CAAhC,EAAmC;AAEjC,YAAM4I,GAAG,GAAG,IAAIC,IAAJ,EAAZ;;AACA,YAAI,CAAC,KAAKhH,eAAV,EAA2B;AAEzBiH,oBAAU,CAAC,YAAM;AACf,mBAAI,CAAClE,iBAAL,CAAuB,IAAvB;AACD,WAFS,EAEP,KAAK5E,oBAFE,CAAV;AAIA,eAAK6B,eAAL,GAAuB+G,GAAvB;AACA;AACD;;AAED,YAAMG,IAAI,GAAGH,GAAG,GAAG,KAAK/G,eAAxB;;AACA,YAAIkH,IAAI,GAAG,KAAK/I,oBAAZ,IAAoC,CAACyI,KAAzC,EAAgD;AAC9CK,oBAAU,CAAC,YAAM;AACf,mBAAI,CAAClE,iBAAL,CAAuB,IAAvB;AACD,WAFS,EAEP,KAAK5E,oBAFE,CAAV;AAIA,eAAK6B,eAAL,GAAuB+G,GAAvB;AACA;AACD;;AAED,YAAIH,KAAK,IAAIM,IAAI,GAAG,KAAK/I,oBAAzB,EAA+C;AAC7C;AACD;;AAED,aAAK6B,eAAL,GAAuB+G,GAAvB;AACD;;AAGD,WAAKnH,WAAL,CAAiBC,MAAjB,GAA0B,IAA1B;AAGA,WAAKD,WAAL,CAAiBE,SAAjB,GAA6B,IAA7B;AACA,WAAK0F,mBAAL,CAAyB,UAAA5E,IAAI,EAAI;AAC/B,YAAIA,IAAI,CAACc,QAAT,EAAmB;AAAA;;AACjBd,cAAI,CAACuG,kBAAL,GAA0B,KAA1B;AACAvG,cAAI,CAACwG,uBAAL,GAA+B,KAA/B;AACAxG,cAAI,CAACyG,SAAL,GAAiB,KAAjB;AACAzG,cAAI,CAAC0G,qBAAL,GAA6B,KAA7B;;AACA,iBAAI,CAAC5C,IAAL,CAAU,OAAI,CAAC9E,WAAL,CAAiBG,QAA3B,EAAqCa,IAAI,CAACD,EAA1C,6DACG9J,YADH,EACkB,CADlB,0CAEGC,eAFH,EAEqB,CAFrB,0CAGGC,aAHH,EAGmB,CAHnB,0CAIGC,gBAJH,EAIsB,CAJtB;AAMD;AACF,OAbD;AAeA,UAAMuQ,qBAAqB,GAAGzI,WAAW,CAAC0I,IAAZ,GAAmBC,iBAAnB,EAA9B;AACA,UAAMC,gBAAgB,GAAGH,qBAAqB,CAACI,OAAtB,CAA8B,MAA9B,EAAsC,GAAtC,EAA2CC,KAA3C,CAAiD,GAAjD,CAAzB;AACA,WAAKpC,mBAAL,CAAyB,UAAA5E,IAAI,EAAI;AAC/B,YAAI,OAAI,CAAC7C,YAAL,IAAqB2J,gBAAgB,CAAC3U,MAAjB,GAA0B,CAAnD,EAAsD;AACpD6N,cAAI,CAACyG,SAAL,GAAiBK,gBAAgB,CAACG,KAAjB,CAAuB,UAAAC,WAAW;AAAA,mBACjD1O,KAAK,CAAC,KAAD,EAAQ0O,WAAR,EAAqBlH,IAAI,CAACmH,iBAA1B,CAD4C;AAAA,WAAlC,CAAjB;AAGD,SAJD,MAIO;AACLnH,cAAI,CAACyG,SAAL,GAAiB,OAAI,CAAC3K,SAAL,CAAemH,IAAf,CAAoB,UAAAmE,QAAQ;AAAA,mBAC3C5O,KAAK,CAAC,CAAC,OAAI,CAAC4C,oBAAP,EAA6BuL,qBAA7B,EAAoD3G,IAAI,CAACqH,UAAL,CAAgBD,QAAhB,CAApD,CADsC;AAAA,WAA5B,CAAjB;AAGD;;AAED,YAAIpH,IAAI,CAACyG,SAAT,EAAoB;AAClB,iBAAI,CAACzH,WAAL,CAAiBE,SAAjB,GAA6B,KAA7B;AACAc,cAAI,CAACO,SAAL,CAAelP,OAAf,CAAuB,UAAAmP,QAAQ;AAAA,mBAAI,OAAI,CAACxB,WAAL,CAAiBG,QAAjB,CAA0BqB,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,CAACxB,WAAL,CAAiBG,QAAjB,CAA0BqB,QAAQ,CAACT,EAAnC,EAAuC3J,gBAAvC,GAAJ;AAAA,WAA/B;;AACjB,cAAI4J,IAAI,CAAC/M,UAAL,KAAoB4C,cAAxB,EAAwC;AACtC,mBAAI,CAACmJ,WAAL,CAAiBG,QAAjB,CAA0Ba,IAAI,CAAC/M,UAAL,CAAgB8M,EAA1C,EAA8C9J,YAA9C,KAA+D,CAA/D;AAEA,gBAAI+J,IAAI,CAACG,MAAT,EAAiB,OAAI,CAACnB,WAAL,CAAiBG,QAAjB,CAA0Ba,IAAI,CAAC/M,UAAL,CAAgB8M,EAA1C,EAA8C5J,aAA9C,KAAgE,CAAhE;AAClB;AACF;;AAED,YACE,CAAC6J,IAAI,CAACyG,SAAL,IAAmBzG,IAAI,CAACc,QAAL,IAAiBd,IAAI,CAACuG,kBAA1C,KACAvG,IAAI,CAAC/M,UAAL,KAAoB4C,cAFtB,EAGE;AACAmK,cAAI,CAAC/M,UAAL,CAAgBsT,kBAAhB,GAAqC,IAArC;AACAvG,cAAI,CAAC/M,UAAL,CAAgByT,qBAAhB,GAAwC,IAAxC;AACD;AACF,OA7BD;AA+BAT,UAAI;AAEJ,WAAK7G,eAAL,GAAuB,IAAvB;AACD,KA/aM;AAibP8C,sBAjbO,gCAibc;AAAA;;AAAA,UACXhE,WADW,GACK,KAAKF,OADV,CACXE,WADW;AAEnB,UAAMoJ,KAAK,GAAG,KAAK1E,oBAAL,EAAd;;AACA,UAAMqD,IAAI,GAAG,SAAPA,IAAO,GAAM;AACjB,eAAI,CAAC1E,UAAL;;AACA,eAAI,CAAC2E,mCAAL,CAAyC,IAAzC;AACD,OAHD;;AAKA,UAAI,CAAChI,WAAW,KAAK,EAAhB,IAAsB,KAAK5D,YAA5B,KAA6CgN,KAAK,CAAClP,QAAvD,EAAiE;AAC/D,eAAO6N,IAAI,EAAX;AACD;;AAED,WAAKsB,mBAAL,CAAyB;AACvBC,cAAM,EAAEjR,YADe;AAEvBhH,YAAI,EAAE;AAAE2O,qBAAW,EAAXA;AAAF,SAFiB;AAGvBuJ,iBAHuB,uBAGX;AACV,iBAAOH,KAAK,CAACjP,SAAb;AACD,SALsB;AAMvBqP,aAAK,EAAE,iBAAM;AACXJ,eAAK,CAACjP,SAAN,GAAkB,IAAlB;AACAiP,eAAK,CAAClP,QAAN,GAAiB,KAAjB;AACAkP,eAAK,CAAChP,YAAN,GAAqB,EAArB;AACD,SAVsB;AAWvBqP,eAAO,EAAE,iBAAA9K,OAAO,EAAI;AAClByK,eAAK,CAAClP,QAAN,GAAiB,IAAjB;AACAkP,eAAK,CAACzK,OAAN,GAAgBA,OAAhB;AAGA,cAAI,OAAI,CAACmB,OAAL,CAAaE,WAAb,KAA6BA,WAAjC,EAA8C+H,IAAI;AACnD,SAjBsB;AAkBvB2B,YAAI,EAAE,cAAA9O,GAAG,EAAI;AACXwO,eAAK,CAAChP,YAAN,GAAqBO,eAAe,CAACC,GAAD,CAApC;AACD,SApBsB;AAqBvB+O,WAAG,EAAE,eAAM;AACTP,eAAK,CAACjP,SAAN,GAAkB,KAAlB;AACD;AAvBsB,OAAzB;AAyBD,KAtdM;AAwdPuK,wBAxdO,kCAwdgB;AAAA;;AAAA,UACb1E,WADa,GACG,KAAKF,OADR,CACbE,WADa;;AAErB,UAAMoJ,KAAK,GAAG,KAAKjI,YAAL,CAAkBnB,WAAlB,qCACT/F,wBAAwB,EADf;AAEZ0E,eAAO,EAAE;AAFG,QAAd;;AAMA,WAAKiL,MAAL,CACE;AAAA,eAAMR,KAAK,CAACzK,OAAZ;AAAA,OADF,EAEE,YAAM;AAEJ,YAAI,OAAI,CAACmB,OAAL,CAAaE,WAAb,KAA6BA,WAAjC,EAA8C,OAAI,CAACqD,UAAL;AAC/C,OALH,EAME;AAAES,YAAI,EAAE;AAAR,OANF;;AASA,UAAI9D,WAAW,KAAK,EAApB,EAAwB;AACtB,YAAInC,KAAK,CAACgG,OAAN,CAAc,KAAKjH,cAAnB,CAAJ,EAAwC;AACtCwM,eAAK,CAACzK,OAAN,GAAgB,KAAK/B,cAArB;AACAwM,eAAK,CAAClP,QAAN,GAAiB,IAAjB;AACA,iBAAOkP,KAAP;AACD,SAJD,MAIO,IAAI,KAAKxM,cAAL,KAAwB,IAA5B,EAAkC;AACvCwM,eAAK,CAAClP,QAAN,GAAiB,IAAjB;AACA,iBAAOkP,KAAP;AACD;AACF;;AAED,UAAI,CAAC,KAAKjI,YAAL,CAAkBnB,WAAlB,CAAL,EAAqC;AACnC,aAAK4F,IAAL,CAAU,KAAKzE,YAAf,EAA6BnB,WAA7B,EAA0CoJ,KAA1C;AACD;;AAED,aAAOA,KAAP;AACD,KAzfM;AA2fPvG,gBA3fO,wBA2fMf,IA3fN,EA2fY;AACjB,aAAO,KAAKhB,WAAL,CAAiBC,MAAjB,GAA0Be,IAAI,CAACuG,kBAA/B,GAAoDvG,IAAI,CAAC+H,UAAhE;AACD,KA7fM;AA+fPlH,wCA/fO,gDA+f8Bb,IA/f9B,EA+foC;AAEzC,UAAIA,IAAI,CAACyG,SAAT,EAAoB,OAAO,IAAP;AAEpB,UAAIzG,IAAI,CAACc,QAAL,IAAiBd,IAAI,CAAC0G,qBAAtB,IAA+C,CAAC,KAAKzL,oBAAzD,EAA+E,OAAO,IAAP;AAG/E,UAAI,CAAC+E,IAAI,CAACC,UAAN,IAAoBD,IAAI,CAAC/M,UAAL,CAAgBuT,uBAAxC,EAAiE,OAAO,IAAP;AAEjE,aAAO,KAAP;AACD,KAzgBM;AA2gBPwB,0BA3gBO,kCA2gBgBhI,IA3gBhB,EA2gBsB;AAC3B,UAAI,KAAKhB,WAAL,CAAiBC,MAAjB,IAA2B,CAAC,KAAK4B,oCAAL,CAA0Cb,IAA1C,CAAhC,EAAiF;AAC/E,eAAO,KAAP;AACD;;AACD,aAAO,IAAP;AACD,KAhhBM;AAkhBPiI,cAlhBO,wBAkhBM;AACX,aAAO,KAAK/C,KAAL,CAAWC,OAAX,CAAmBzT,GAA1B;AACD,KAphBM;AAshBPwW,WAthBO,qBAshBG;AACR,UAAMC,GAAG,GAAG,KAAK1O,YAAL,GAAoB,KAAKyL,KAAL,CAAWkD,MAAX,CAAkBC,YAAtC,GAAqD,IAAjE;AACA,UAAMC,KAAK,GAAGH,GAAG,CAACjD,KAAJ,CAAU/G,IAAV,CAAe+G,KAAf,CAAqB/G,IAAnC;AACA,aAAOmK,KAAK,IAAIA,KAAK,CAACpV,QAAN,KAAmB,UAA5B,GAAyCoV,KAAzC,GAAiD,IAAxD;AACD,KA1hBM;AA4hBPC,+BA5hBO,uCA4hBqBvI,IA5hBrB,EA4hB0C;AAAA;;AAAA,UAAfwI,MAAe,uEAAN,IAAM;AAC/C,UAAMC,IAAI,GAAG,KAAKtK,IAAL,CAAUE,OAAvB;;AACA,UAAIoK,IAAI,IAAI,IAAR,IAAgBA,IAAI,IAAI,KAAKjK,MAAL,CAAYE,OAAxC,EAAiD;AAC/C,aAAKF,MAAL,CAAYE,OAAZ,CAAoB+J,IAApB,EAA0BC,aAA1B,GAA0C,KAA1C;AACD;;AAED,WAAKvK,IAAL,CAAUE,OAAV,GAAoB2B,IAAI,CAACD,EAAzB;AACAC,UAAI,CAAC0I,aAAL,GAAqB,IAArB;;AAEA,UAAI,KAAKvK,IAAL,CAAUC,MAAV,IAAoBoK,MAAxB,EAAgC;AAC9B,YAAMG,cAAc,GAAG,SAAjBA,cAAiB,GAAM;AAC3B,cAAML,KAAK,GAAG,OAAI,CAACJ,OAAL,EAAd;;AACA,cAAMU,OAAO,GAAGN,KAAK,CAACO,aAAN,6CAAwD7I,IAAI,CAACD,EAA7D,SAAhB;AACA,cAAI6I,OAAJ,EAAanZ,cAAc,CAAC6Y,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,KApjBM;AAsjBPzC,uCAtjBO,iDAsjBiD;AAAA,UAApB6C,UAAoB,uEAAP,KAAO;AAAA,UAC9C1K,OAD8C,GAClC,KAAKF,IAD6B,CAC9CE,OAD8C;;AAGtD,UACE0K,UAAU,IAAI1K,OAAO,IAAI,IAAzB,IACA,EAAEA,OAAO,IAAI,KAAKG,MAAL,CAAYE,OAAzB,CADA,IAEA,CAAC,KAAKsJ,sBAAL,CAA4B,KAAKtI,OAAL,CAAarB,OAAb,CAA5B,CAHH,EAIE;AACA,aAAK2K,oBAAL;AACD;AACF,KAhkBM;AAkkBPA,wBAlkBO,kCAkkBgB;AACrB,UAAI,CAAC,KAAKhI,iBAAV,EAA6B;AAE7B,UAAMiI,KAAK,GAAG,KAAKtI,gBAAL,CAAsB,CAAtB,CAAd;AACA,WAAK4H,2BAAL,CAAiC,KAAK7I,OAAL,CAAauJ,KAAb,CAAjC;AACD,KAvkBM;AAykBPC,uBAzkBO,iCAykBe;AACpB,UAAI,CAAC,KAAKlI,iBAAV,EAA6B;AAE7B,UAAMyH,IAAI,GAAG,KAAK9H,gBAAL,CAAsB7P,OAAtB,CAA8B,KAAKqN,IAAL,CAAUE,OAAxC,IAAmD,CAAhE;AACA,UAAIoK,IAAI,KAAK,CAAC,CAAd,EAAiB,OAAO,KAAKU,mBAAL,EAAP;AACjB,WAAKZ,2BAAL,CAAiC,KAAK7I,OAAL,CAAa,KAAKiB,gBAAL,CAAsB8H,IAAtB,CAAb,CAAjC;AACD,KA/kBM;AAilBPW,uBAjlBO,iCAilBe;AACpB,UAAI,CAAC,KAAKpI,iBAAV,EAA6B;AAE7B,UAAMqI,IAAI,GAAG,KAAK1I,gBAAL,CAAsB7P,OAAtB,CAA8B,KAAKqN,IAAL,CAAUE,OAAxC,IAAmD,CAAhE;AACA,UAAIgL,IAAI,KAAK,KAAK1I,gBAAL,CAAsBxO,MAAnC,EAA2C,OAAO,KAAK6W,oBAAL,EAAP;AAC3C,WAAKT,2BAAL,CAAiC,KAAK7I,OAAL,CAAa,KAAKiB,gBAAL,CAAsB0I,IAAtB,CAAb,CAAjC;AACD,KAvlBM;AAylBPF,uBAzlBO,iCAylBe;AACpB,UAAI,CAAC,KAAKnI,iBAAV,EAA6B;AAE7B,UAAMsI,IAAI,GAAGC,cAAO,CAAC,KAAK5I,gBAAN,CAApB;AACA,WAAK4H,2BAAL,CAAiC,KAAK7I,OAAL,CAAa4J,IAAb,CAAjC;AACD,KA9lBM;AAgmBPE,oBAhmBO,8BAgmBY;AACjB,WAAKxL,OAAL,CAAaE,WAAb,GAA2B,EAA3B;AACD,KAlmBM;AAomBPoD,aApmBO,uBAomBK;AACV,UAAI,CAAC,KAAKnD,IAAL,CAAUC,MAAX,IAAsB,CAAC,KAAKjD,QAAN,IAAkB,KAAK3B,UAAjD,EAA8D;AAC9D,WAAKiQ,sBAAL;AACA,WAAKtL,IAAL,CAAUC,MAAV,GAAmB,KAAnB;AACA,WAAK0G,uBAAL,CAA6B,KAA7B;AACA,WAAK0E,gBAAL;AACA,WAAK9H,KAAL,CAAW,OAAX,EAAoB,KAAKC,QAAL,EAApB,EAAqC,KAAKC,aAAL,EAArC;AACD,KA3mBM;AA6mBPP,YA7mBO,sBA6mBI;AACT,UAAI,KAAKlG,QAAL,IAAiB,KAAKgD,IAAL,CAAUC,MAA/B,EAAuC;AACvC,WAAKD,IAAL,CAAUC,MAAV,GAAmB,IAAnB;AACA,WAAK0K,SAAL,CAAe,KAAK5C,mCAApB;AACA,WAAK4C,SAAL,CAAe,KAAKY,yBAApB;AACA,UAAI,CAAC,KAAK7M,OAAN,IAAiB,CAAC,KAAKnD,KAA3B,EAAkC,KAAKiQ,eAAL;AAClC,WAAK7E,uBAAL,CAA6B,IAA7B;AACA,WAAKpD,KAAL,CAAW,MAAX,EAAmB,KAAKE,aAAL,EAAnB;AACD,KArnBM;AAunBPgI,cAvnBO,wBAunBM;AACX,UAAI,KAAKzL,IAAL,CAAUC,MAAd,EAAsB;AACpB,aAAKkD,SAAL;AACD,OAFD,MAEO;AACL,aAAKD,QAAL;AACD;AACF,KA7nBM;AA+nBPwI,kBA/nBO,0BA+nBQ7J,IA/nBR,EA+nBc;AACnB,UAAI8J,SAAJ;;AAEA,UAAI,KAAK9K,WAAL,CAAiBC,MAArB,EAA6B;AAC3B6K,iBAAS,GAAG9J,IAAI,CAACuG,kBAAL,GAA0B,CAACvG,IAAI,CAACuG,kBAA5C;AACA,YAAIuD,SAAJ,EAAe9J,IAAI,CAACwG,uBAAL,GAA+B,IAA/B;AAChB,OAHD,MAGO;AACLsD,iBAAS,GAAG9J,IAAI,CAAC+H,UAAL,GAAkB,CAAC/H,IAAI,CAAC+H,UAApC;AACD;;AAED,UAAI+B,SAAS,IAAI,CAAC9J,IAAI,CAAC+J,cAAL,CAAoB3R,QAAtC,EAAgD;AAC9C,aAAK4R,mBAAL,CAAyBhK,IAAzB;AACD;AACF,KA5oBM;AA8oBP6B,oBA9oBO,8BA8oBY;AAAA;;AACjB,UAAM/C,eAAe,GAAG1K,SAAS,EAAjC;AACA,WAAKoK,MAAL,CAAYI,eAAZ,CAA4BvN,OAA5B,CAAoC,UAAA4Y,cAAc,EAAI;AACpDnL,uBAAe,CAACmL,cAAD,CAAf,GAAkC,IAAlC;AACD,OAFD;AAGA,WAAKzL,MAAL,CAAYM,eAAZ,GAA8BA,eAA9B;AAEA,UAAMH,eAAe,GAAGvK,SAAS,EAAjC;;AACA,UAAI,KAAK6H,QAAT,EAAmB;AACjB,aAAK2E,uBAAL,CAA6B,UAAAZ,IAAI,EAAI;AACnCrB,yBAAe,CAACqB,IAAI,CAACD,EAAN,CAAf,GAA2BjK,SAA3B;AACD,SAFD;AAIA,aAAK0J,aAAL,CAAmBnO,OAAnB,CAA2B,UAAAiP,YAAY,EAAI;AACzC3B,yBAAe,CAAC2B,YAAY,CAACP,EAAd,CAAf,GAAmC/J,OAAnC;;AAEA,cAAI,CAAC,OAAI,CAACqF,IAAN,IAAc,CAAC,OAAI,CAACH,kBAAxB,EAA4C;AAC1CoF,wBAAY,CAACC,SAAb,CAAuBlP,OAAvB,CAA+B,UAAA6Y,YAAY,EAAI;AAC7C,kBAAI,CAAC,OAAI,CAAChK,UAAL,CAAgBgK,YAAhB,CAAL,EAAoC;AAClCvL,+BAAe,CAACuL,YAAY,CAACnK,EAAd,CAAf,GAAmChK,aAAnC;AACD;AACF,aAJD;AAKD;AACF,SAVD;AAWD;;AACD,WAAKyI,MAAL,CAAYG,eAAZ,GAA8BA,eAA9B;AACD,KAxqBM;AA0qBP8E,sBA1qBO,8BA0qBYL,GA1qBZ,EA0qBiB;AACtB,6CACKA,GADL,GAEK,KAAK9G,UAAL,CAAgB8G,GAAhB,EAAqB,KAAKxB,aAAL,EAArB,CAFL;AAID,KA/qBM;AAirBPoB,aAjrBO,qBAirBG/P,UAjrBH,EAirBekX,KAjrBf,EAirBsBrH,WAjrBtB,EAirBmC;AAAA;;AACxC,UAAIrE,iBAAiB,GAAG0L,KAAK,CAC1B1K,GADqB,CACjB,UAAAO,IAAI;AAAA,eAAI,CAAE,OAAI,CAACyD,kBAAL,CAAwBzD,IAAxB,CAAF,EAAiCA,IAAjC,CAAJ;AAAA,OADa,EAErBP,GAFqB,CAEjB,gBAAgBxH,KAAhB,EAA0B;AAAA;AAAA,YAAvB+H,IAAuB;AAAA,YAAjBoD,GAAiB;;AAC7B,eAAI,CAACgH,gBAAL,CAAsBpK,IAAtB;;AACA,eAAI,CAACqK,eAAL,CAAqBrK,IAArB;;AAF6B,YAIrBD,EAJqB,GAIsBC,IAJtB,CAIrBD,EAJqB;AAAA,YAIjByD,KAJiB,GAIsBxD,IAJtB,CAIjBwD,KAJiB;AAAA,YAIVpD,QAJU,GAIsBJ,IAJtB,CAIVI,QAJU;AAAA,YAIAkK,iBAJA,GAIsBtK,IAJtB,CAIAsK,iBAJA;AAK7B,YAAMrK,UAAU,GAAGhN,UAAU,KAAK4C,cAAlC;AACA,YAAMmC,KAAK,GAAGiI,UAAU,GAAG,CAAH,GAAOhN,UAAU,CAAC+E,KAAX,GAAmB,CAAlD;AACA,YAAM8I,QAAQ,GAAG/E,KAAK,CAACgG,OAAN,CAAc3B,QAAd,KAA2BA,QAAQ,KAAK,IAAzD;AACA,YAAMD,MAAM,GAAG,CAACW,QAAhB;AACA,YAAM8C,UAAU,GAAG,CAAC,CAAC5D,IAAI,CAAC4D,UAAP,IAAsB,CAAC,OAAI,CAACvI,IAAN,IAAc,CAAC4E,UAAf,IAA6BhN,UAAU,CAAC2Q,UAAjF;AACA,YAAMC,KAAK,GAAG,CAAC,CAAC7D,IAAI,CAAC6D,KAArB;;AACA,YAAMwD,UAAU,GAAG,OAAI,CAACvL,SAAL,CAAeyO,MAAf,CAAsB,UAAC9B,IAAD,EAAO5T,GAAP;AAAA,iDACpC4T,IADoC,oCAEtC5T,GAFsC,EAEhC0D,wBAAwB,CAACyH,IAAI,CAACnL,GAAD,CAAL,CAAxB,CAAoCgS,iBAApC,EAFgC;AAAA,SAAtB,EAGf,EAHe,CAAnB;;AAIA,YAAMM,iBAAiB,GAAGlH,UAAU,GAChCoH,UAAU,CAAC7D,KADqB,GAEhCvQ,UAAU,CAACkU,iBAAX,GAA+B,GAA/B,GAAqCE,UAAU,CAAC7D,KAFpD;;AAIA,YAAMgH,UAAU,GAAG,OAAI,CAAC1G,IAAL,CAAU,OAAI,CAACtF,MAAL,CAAYE,OAAtB,EAA+BqB,EAA/B,EAAmC3L,SAAS,EAA5C,CAAnB;;AACA,eAAI,CAAC0P,IAAL,CAAU0G,UAAV,EAAsB,IAAtB,EAA4BzK,EAA5B;;AACA,eAAI,CAAC+D,IAAL,CAAU0G,UAAV,EAAsB,OAAtB,EAA+BhH,KAA/B;;AACA,eAAI,CAACM,IAAL,CAAU0G,UAAV,EAAsB,OAAtB,EAA+BxS,KAA/B;;AACA,eAAI,CAAC8L,IAAL,CAAU0G,UAAV,EAAsB,WAAtB,EAAmCvK,UAAU,GAAG,EAAH,GAAQ,CAAEhN,UAAF,EAAenE,MAAf,CAAsBmE,UAAU,CAACsN,SAAjC,CAArD;;AACA,eAAI,CAACuD,IAAL,CAAU0G,UAAV,EAAsB,OAAtB,EAA+B,CAACvK,UAAU,GAAG,EAAH,GAAQhN,UAAU,CAACgF,KAA9B,EAAqCnJ,MAArC,CAA4CmJ,KAA5C,CAA/B;;AACA,eAAI,CAAC6L,IAAL,CAAU0G,UAAV,EAAsB,YAAtB,EAAoCvX,UAApC;;AACA,eAAI,CAAC6Q,IAAL,CAAU0G,UAAV,EAAsB,YAAtB,EAAoCnD,UAApC;;AACA,eAAI,CAACvD,IAAL,CAAU0G,UAAV,EAAsB,mBAAtB,EAA2CrD,iBAA3C;;AACA,eAAI,CAACrD,IAAL,CAAU0G,UAAV,EAAsB,YAAtB,EAAoC5G,UAApC;;AACA,eAAI,CAACE,IAAL,CAAU0G,UAAV,EAAsB,OAAtB,EAA+B3G,KAA/B;;AACA,eAAI,CAACC,IAAL,CAAU0G,UAAV,EAAsB,WAAtB,EAAmC,KAAnC;;AACA,eAAI,CAAC1G,IAAL,CAAU0G,UAAV,EAAsB,eAAtB,EAAuC,KAAvC;;AACA,eAAI,CAAC1G,IAAL,CAAU0G,UAAV,EAAsB,UAAtB,EAAkC1J,QAAlC;;AACA,eAAI,CAACgD,IAAL,CAAU0G,UAAV,EAAsB,QAAtB,EAAgCrK,MAAhC;;AACA,eAAI,CAAC2D,IAAL,CAAU0G,UAAV,EAAsB,YAAtB,EAAoCvK,UAApC;;AACA,eAAI,CAAC6D,IAAL,CAAU0G,UAAV,EAAsB,KAAtB,EAA6BpH,GAA7B;;AAEA,YAAItC,QAAJ,EAAc;AAAA;;AACZ,cAAM1I,QAAQ,GAAG2D,KAAK,CAACgG,OAAN,CAAc3B,QAAd,CAAjB;;AAEA,iBAAI,CAAC0D,IAAL,CAAU0G,UAAV,EAAsB,gBAAtB,kCACKrS,wBAAwB,EAD7B;AAEEC,oBAAQ,EAARA;AAFF;;AAIA,iBAAI,CAAC0L,IAAL,CAAU0G,UAAV,EAAsB,YAAtB,EAAoC,OAAOF,iBAAP,KAA6B,SAA7B,GAChCA,iBADgC,GAEhCtS,KAAK,GAAG,OAAI,CAAC4C,kBAFjB;;AAGA,iBAAI,CAACkJ,IAAL,CAAU0G,UAAV,EAAsB,uBAAtB,EAA+C,KAA/C;;AACA,iBAAI,CAAC1G,IAAL,CAAU0G,UAAV,EAAsB,wBAAtB,EAAgD,KAAhD;;AACA,iBAAI,CAAC1G,IAAL,CAAU0G,UAAV,EAAsB,oBAAtB,EAA4C,KAA5C;;AACA,iBAAI,CAAC1G,IAAL,CAAU0G,UAAV,EAAsB,yBAAtB,EAAiD,KAAjD;;AACA,iBAAI,CAAC1G,IAAL,CAAU0G,UAAV,EAAsB,OAAtB,6DACGvU,YADH,EACkB,CADlB,0CAEGC,eAFH,EAEqB,CAFrB,0CAGGC,aAHH,EAGmB,CAHnB,0CAIGC,gBAJH,EAIsB,CAJtB;;AAMA,iBAAI,CAAC0N,IAAL,CAAU0G,UAAV,EAAsB,UAAtB,EAAkCpS,QAAQ,GACtC,OAAI,CAAC4K,SAAL,CAAewH,UAAf,EAA2BpK,QAA3B,EAAqC0C,WAArC,CADsC,GAEtC,EAFJ;;AAIA,cAAIwH,iBAAiB,KAAK,IAA1B,EAAgCE,UAAU,CAACjK,SAAX,CAAqBlP,OAArB,CAA6B,UAAAmP,QAAQ,EAAI;AACvEA,oBAAQ,CAACuH,UAAT,GAAsB,IAAtB;AACD,WAF+B;;AAIhC,cAAI,CAAC3P,QAAD,IAAa,OAAO,OAAI,CAACyD,WAAZ,KAA4B,UAA7C,EAAyD;AACvDvN,2BAAO,CACL;AAAA,qBAAM,KAAN;AAAA,aADK,EAEL;AAAA,qBAAM,qFAAN;AAAA,aAFK,CAAP;AAID,WALD,MAKO,IAAI,CAAC8J,QAAD,IAAaoS,UAAU,CAACzC,UAA5B,EAAwC;AAC7C,mBAAI,CAACiC,mBAAL,CAAyBQ,UAAzB;AACD;AACF;;AAEDA,kBAAU,CAACjK,SAAX,CAAqBlP,OAArB,CAA6B,UAAAmP,QAAQ;AAAA,iBAAIA,QAAQ,CAAC7E,KAAT,CAAezF,eAAf,GAAJ;AAAA,SAArC;AACA,YAAIiK,MAAJ,EAAYqK,UAAU,CAACjK,SAAX,CAAqBlP,OAArB,CAA6B,UAAAmP,QAAQ;AAAA,iBAAIA,QAAQ,CAAC7E,KAAT,CAAevF,gBAAf,GAAJ;AAAA,SAArC;;AACZ,YAAI,CAAC6J,UAAL,EAAiB;AACfhN,oBAAU,CAAC0I,KAAX,CAAiB1F,YAAjB,KAAkC,CAAlC;AACA,cAAIkK,MAAJ,EAAYlN,UAAU,CAAC0I,KAAX,CAAiBxF,aAAjB,KAAmC,CAAnC;AACZ,cAAIyN,UAAJ,EAAgB3Q,UAAU,CAACwX,sBAAX,GAAoC,IAApC;AACjB;;AAGD,YAAI3H,WAAW,IAAIA,WAAW,CAAC/C,EAAD,CAA9B,EAAoC;AAClC,cAAM0I,IAAI,GAAG3F,WAAW,CAAC/C,EAAD,CAAxB;AAEAyK,oBAAU,CAAC/D,SAAX,GAAuBgC,IAAI,CAAChC,SAA5B;AACA+D,oBAAU,CAAChE,uBAAX,GAAqCiC,IAAI,CAACjC,uBAA1C;AACAgE,oBAAU,CAAC9B,aAAX,GAA2BD,IAAI,CAACC,aAAhC;;AAEA,cAAID,IAAI,CAAC3H,QAAL,IAAiB0J,UAAU,CAAC1J,QAAhC,EAA0C;AACxC0J,sBAAU,CAACzC,UAAX,GAAwBU,IAAI,CAACV,UAA7B;AACAyC,sBAAU,CAACjE,kBAAX,GAAgCkC,IAAI,CAAClC,kBAArC;;AAIA,gBAAIkC,IAAI,CAACsB,cAAL,CAAoB3R,QAApB,IAAgC,CAACoS,UAAU,CAACT,cAAX,CAA0B3R,QAA/D,EAAyE;AAGvEoS,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,KAAKnQ,gBAAT,EAA2B;AACzB,YAAMqQ,WAAW,GAAGjM,iBAAiB,CAACqB,MAAlB,CAAyB,UAAA6K,MAAM;AAAA,iBAAIA,MAAM,CAAC7J,QAAX;AAAA,SAA/B,CAApB;AACA,YAAM8J,SAAS,GAAGnM,iBAAiB,CAACqB,MAAlB,CAAyB,UAAA6K,MAAM;AAAA,iBAAIA,MAAM,CAACxK,MAAX;AAAA,SAA/B,CAAlB;AACA1B,yBAAiB,GAAGiM,WAAW,CAAC5b,MAAZ,CAAmB8b,SAAnB,CAApB;AACD;;AAED,aAAOnM,iBAAP;AACD,KA1yBM;AA4yBPkL,mBA5yBO,6BA4yBW;AAAA;;AAChB,WAAKpC,mBAAL,CAAyB;AACvBC,cAAM,EAAEnR,iBADe;AAEvBoR,iBAAS,EAAE,qBAAM;AACf,iBAAO,OAAI,CAAC1I,iBAAL,CAAuB1G,SAA9B;AACD,SAJsB;AAKvBqP,aAAK,EAAE,iBAAM;AACX,iBAAI,CAAC3I,iBAAL,CAAuB1G,SAAvB,GAAmC,IAAnC;AACA,iBAAI,CAAC0G,iBAAL,CAAuBzG,YAAvB,GAAsC,EAAtC;AACD,SARsB;AASvBqP,eAAO,EAAE,mBAAM;AACb,iBAAI,CAAC5I,iBAAL,CAAuB3G,QAAvB,GAAkC,IAAlC;;AAEA,iBAAI,CAAC0Q,SAAL,CAAe,YAAM;AACnB,mBAAI,CAAC5C,mCAAL,CAAyC,IAAzC;AACD,WAFD;AAGD,SAfsB;AAgBvB0B,YAAI,EAAE,cAAA9O,GAAG,EAAI;AACX,iBAAI,CAACiG,iBAAL,CAAuBzG,YAAvB,GAAsCO,eAAe,CAACC,GAAD,CAArD;AACD,SAlBsB;AAmBvB+O,WAAG,EAAE,eAAM;AACT,iBAAI,CAAC9I,iBAAL,CAAuB1G,SAAvB,GAAmC,KAAnC;AACD;AArBsB,OAAzB;AAuBD,KAp0BM;AAs0BP2R,uBAt0BO,+BAs0Ba/W,UAt0Bb,EAs0ByB;AAAA;;AAAA,UAItB8M,EAJsB,GAIV9M,UAJU,CAItB8M,EAJsB;AAAA,UAIlBqD,GAJkB,GAIVnQ,UAJU,CAIlBmQ,GAJkB;AAM9B,WAAKmE,mBAAL,CAAyB;AACvBC,cAAM,EAAElR,qBADe;AAEvB/G,YAAI,EAAE;AAKJ0D,oBAAU,EAAEmQ;AALR,SAFiB;AASvBqE,iBAAS,EAAE,qBAAM;AACf,iBAAO,OAAI,CAAC/H,OAAL,CAAaK,EAAb,EAAiBgK,cAAjB,CAAgC1R,SAAvC;AACD,SAXsB;AAYvBqP,aAAK,EAAE,iBAAM;AACX,iBAAI,CAAChI,OAAL,CAAaK,EAAb,EAAiBgK,cAAjB,CAAgC1R,SAAhC,GAA4C,IAA5C;AACA,iBAAI,CAACqH,OAAL,CAAaK,EAAb,EAAiBgK,cAAjB,CAAgCzR,YAAhC,GAA+C,EAA/C;AACD,SAfsB;AAgBvBqP,eAAO,EAAE,mBAAM;AACb,iBAAI,CAACjI,OAAL,CAAaK,EAAb,EAAiBgK,cAAjB,CAAgC3R,QAAhC,GAA2C,IAA3C;AACD,SAlBsB;AAmBvBwP,YAAI,EAAE,cAAA9O,GAAG,EAAI;AACX,iBAAI,CAAC4G,OAAL,CAAaK,EAAb,EAAiBgK,cAAjB,CAAgCzR,YAAhC,GAA+CO,eAAe,CAACC,GAAD,CAA9D;AACD,SArBsB;AAsBvB+O,WAAG,EAAE,eAAM;AACT,iBAAI,CAACnI,OAAL,CAAaK,EAAb,EAAiBgK,cAAjB,CAAgC1R,SAAhC,GAA4C,KAA5C;AACD;AAxBsB,OAAzB;AA0BD,KAt2BM;AAw2BPkP,uBAx2BO,sCAw2BqE;AAAA,UAAtDC,MAAsD,SAAtDA,MAAsD;AAAA,UAA9CjY,IAA8C,SAA9CA,IAA8C;AAAA,UAAxCkY,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,KAAKhM,WAAN,IAAqB4L,SAAS,EAAlC,EAAsC;AACpC;AACD;;AAEDC,WAAK;AAEL,UAAMlD,QAAQ,GAAGqG,cAAI,CAAC,UAAC/R,GAAD,EAAMgS,MAAN,EAAiB;AACrC,YAAIhS,GAAJ,EAAS;AACP8O,cAAI,CAAC9O,GAAD,CAAJ;AACD,SAFD,MAEO;AACL6O,iBAAO,CAACmD,MAAD,CAAP;AACD;;AAEDjD,WAAG;AACJ,OARoB,CAArB;AASA,UAAMiD,MAAM,GAAG,KAAKjP,WAAL;AACbkE,UAAE,EAAE,KAAK6B,aAAL,EADS;AAEb5I,kBAAU,EAAE,KAAK4I,aAAL,EAFC;AAGb4F,cAAM,EAANA;AAHa,SAIVjY,IAJU;AAKbiV,gBAAQ,EAARA;AALa,SAAf;;AAQA,UAAIuG,6BAAS,CAACD,MAAD,CAAb,EAAuB;AACrBA,cAAM,CAACE,IAAP,CAAY,YAAM;AAChBxG,kBAAQ;AACT,SAFD,EAEG,UAAA1L,GAAG,EAAI;AACR0L,kBAAQ,CAAC1L,GAAD,CAAR;AACD,SAJD,EAIGmS,KAJH,CAIS,UAAAnS,GAAG,EAAI;AAEd/J,iBAAO,CAACC,KAAR,CAAc8J,GAAd;AACD,SAPD;AAQD;AACF,KA14BM;AA44BPsR,oBA54BO,4BA44BUpK,IA54BV,EA44BgB;AAAA;;AACrB1R,qBAAO,CACL;AAAA,eAAM,EAAG0R,IAAI,CAACD,EAAL,IAAW,OAAI,CAACvB,MAAL,CAAYE,OAAxB,IAAoC,CAAC,OAAI,CAACF,MAAL,CAAYE,OAAZ,CAAoBsB,IAAI,CAACD,EAAzB,EAA6B4D,cAApE,CAAN;AAAA,OADK,EAEL;AAAA,eAAM,iDAA0CuH,IAAI,CAACC,SAAL,CAAenL,IAAI,CAACD,EAApB,CAA1C,uCACiB,OAAI,CAACvB,MAAL,CAAYE,OAAZ,CAAoBsB,IAAI,CAACD,EAAzB,EAA6ByD,KAD9C,sBAC6DxD,IAAI,CAACwD,KADlE,qBAAN;AAAA,OAFK,CAAP;AAKD,KAl5BM;AAo5BP6G,mBAp5BO,2BAo5BSrK,IAp5BT,EAo5Be;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,KA15BM;AA45BPsK,UA55BO,kBA45BApL,IA55BA,EA45BM;AACX,UAAI,KAAK7E,QAAL,IAAiB6E,IAAI,CAAC4D,UAA1B,EAAsC;AACpC;AACD;;AAED,UAAI,KAAKhE,MAAT,EAAiB;AACf,aAAKyL,KAAL;AACD;;AAED,UAAMvB,SAAS,GAAG,KAAK7N,QAAL,IAAiB,CAAC,KAAKZ,IAAvB,GACd,KAAKmD,MAAL,CAAYG,eAAZ,CAA4BqB,IAAI,CAACD,EAAjC,MAAyCjK,SAD3B,GAEd,CAAC,KAAKoK,UAAL,CAAgBF,IAAhB,CAFL;;AAIA,UAAI8J,SAAJ,EAAe;AACb,aAAKwB,WAAL,CAAiBtL,IAAjB;AACD,OAFD,MAEO;AACL,aAAKuL,aAAL,CAAmBvL,IAAnB;AACD;;AAED,WAAK6B,gBAAL;;AAEA,UAAIiI,SAAJ,EAAe;AACb,aAAKpI,KAAL,CAAW,QAAX,EAAqB1B,IAAI,CAACoD,GAA1B,EAA+B,KAAKxB,aAAL,EAA/B;AACD,OAFD,MAEO;AACL,aAAKF,KAAL,CAAW,UAAX,EAAuB1B,IAAI,CAACoD,GAA5B,EAAiC,KAAKxB,aAAL,EAAjC;AACD;;AAED,UAAI,KAAK5C,WAAL,CAAiBC,MAAjB,IAA2B6K,SAA3B,KAAyC,KAAKlK,MAAL,IAAe,KAAKnF,aAA7D,CAAJ,EAAiF;AAC/E,aAAK+O,gBAAL;AACD;;AAED,UAAI,KAAK5J,MAAL,IAAe,KAAKjF,aAAxB,EAAuC;AACrC,aAAK2G,SAAL;;AAGA,YAAI,KAAKpE,UAAT,EAAqB;AACnB,eAAKyF,aAAL,GAAqB,IAArB;AACD;AACF;AACF,KAn8BM;AAq8BP0I,SAr8BO,mBAq8BC;AAAA;;AACN,UAAI,KAAK3K,QAAT,EAAmB;AACjB,YAAI,KAAKd,MAAL,IAAe,KAAKxG,qBAAxB,EAA+C;AAC7C,eAAKoF,MAAL,CAAYI,eAAZ,GAA8B,EAA9B;AACD,SAFD,MAE+D;AAC7D,iBAAKJ,MAAL,CAAYI,eAAZ,GAA8B,KAAKJ,MAAL,CAAYI,eAAZ,CAA4BkB,MAA5B,CAAmC,UAAAuD,MAAM;AAAA,qBACrE,OAAI,CAAC3D,OAAL,CAAa2D,MAAb,EAAqBO,UADgD;AAAA,aAAzC,CAA9B;AAGD;;AAED,aAAK/B,gBAAL;AACD;AACF,KAj9BM;AAo9BPyJ,eAp9BO,uBAo9BKtL,IAp9BL,EAo9BW;AAAA;;AAChB,UAAI,KAAKJ,MAAL,IAAe,KAAK1E,kBAAxB,EAA4C;AAC1C,eAAO,KAAKsQ,QAAL,CAAcxL,IAAd,CAAP;AACD;;AAED,UAAI,KAAK3E,IAAT,EAAe;AACb,aAAKmQ,QAAL,CAAcxL,IAAd;;AAEA,YAAI,KAAKjG,mBAAT,EAA8B;AAC5BiG,cAAI,CAACO,SAAL,CAAelP,OAAf,CAAuB,UAAAmP,QAAQ,EAAI;AACjC,gBAAI,CAAC,OAAI,CAACN,UAAL,CAAgBM,QAAhB,CAAD,IAA8B,CAACA,QAAQ,CAACoD,UAA5C,EAAwD,OAAI,CAAC4H,QAAL,CAAchL,QAAd;AACzD,WAFD;AAGD,SAJD,MAIO,IAAI,KAAKxG,qBAAT,EAAgC;AACrC,eAAKoK,sBAAL,CAA4BpE,IAA5B,EAAkC,UAAAqE,UAAU,EAAI;AAC9C,gBAAI,CAAC,OAAI,CAACnE,UAAL,CAAgBmE,UAAhB,CAAD,IAAgC,CAACA,UAAU,CAACT,UAAhD,EAA4D,OAAI,CAAC4H,QAAL,CAAcnH,UAAd;AAC7D,WAFD;AAGD;;AAED;AACD;;AAED,UAAMoH,cAAc,GAClBzL,IAAI,CAACG,MAAL,IACuB,CAACH,IAAI,CAACyK,sBAD7B,IAEuB,KAAKlR,iCAH9B;;AAKA,UAAIkS,cAAJ,EAAoB;AAClB,aAAKD,QAAL,CAAcxL,IAAd;AACD;;AAED,UAAIA,IAAI,CAACc,QAAT,EAAmB;AACjB,aAAKsD,sBAAL,CAA4BpE,IAA5B,EAAkC,UAAAqE,UAAU,EAAI;AAC9C,cAAI,CAACA,UAAU,CAACT,UAAZ,IAA0B,OAAI,CAACrK,iCAAnC,EAAsE;AACpE,mBAAI,CAACiS,QAAL,CAAcnH,UAAd;AACD;AACF,SAJD;AAKD;;AAED,UAAIoH,cAAJ,EAAoB;AAClB,YAAIC,IAAI,GAAG1L,IAAX;;AACA,eAAO,CAAC0L,IAAI,GAAGA,IAAI,CAACzY,UAAb,MAA6B4C,cAApC,EAAoD;AAClD,cAAI6V,IAAI,CAACtL,QAAL,CAAc6G,KAAd,CAAoB,KAAK/G,UAAzB,CAAJ,EAA0C,KAAKsL,QAAL,CAAcE,IAAd,EAA1C,KACK;AACN;AACF;AACF,KAjgCM;AAogCPH,iBApgCO,yBAogCOvL,IApgCP,EAogCa;AAAA;;AAClB,UAAI,KAAK9E,kBAAT,EAA6B;AAC3B,eAAO,KAAKyQ,WAAL,CAAiB3L,IAAjB,CAAP;AACD;;AAED,UAAI,KAAK3E,IAAT,EAAe;AACb,aAAKsQ,WAAL,CAAiB3L,IAAjB;;AAEA,YAAI,KAAKnG,qBAAT,EAAgC;AAC9BmG,cAAI,CAACO,SAAL,CAAelP,OAAf,CAAuB,UAAAmP,QAAQ,EAAI;AACjC,gBAAI,OAAI,CAACN,UAAL,CAAgBM,QAAhB,KAA6B,CAACA,QAAQ,CAACoD,UAA3C,EAAuD,OAAI,CAAC+H,WAAL,CAAiBnL,QAAjB;AACxD,WAFD;AAGD,SAJD,MAIO,IAAI,KAAK1G,uBAAT,EAAkC;AACvC,eAAKsK,sBAAL,CAA4BpE,IAA5B,EAAkC,UAAAqE,UAAU,EAAI;AAC9C,gBAAI,OAAI,CAACnE,UAAL,CAAgBmE,UAAhB,KAA+B,CAACA,UAAU,CAACT,UAA/C,EAA2D,OAAI,CAAC+H,WAAL,CAAiBtH,UAAjB;AAC5D,WAFD;AAGD;;AAED;AACD;;AAED,UAAIuH,2BAA2B,GAAG,KAAlC;;AACA,UAAI5L,IAAI,CAACc,QAAT,EAAmB;AACjB,aAAK4D,sBAAL,CAA4B1E,IAA5B,EAAkC,UAAAqE,UAAU,EAAI;AAC9C,cAAI,CAACA,UAAU,CAACT,UAAZ,IAA0B,OAAI,CAACrK,iCAAnC,EAAsE;AACpE,mBAAI,CAACoS,WAAL,CAAiBtH,UAAjB;;AACAuH,uCAA2B,GAAG,IAA9B;AACD;AACF,SALD;AAMD;;AAED,UACE5L,IAAI,CAACG,MAAL,IACsByL,2BADtB,IAEsB5L,IAAI,CAACI,QAAL,CAAcjO,MAAd,KAAyB,CAHjD,EAIE;AACA,aAAKwZ,WAAL,CAAiB3L,IAAjB;AAEA,YAAI0L,IAAI,GAAG1L,IAAX;;AACA,eAAO,CAAC0L,IAAI,GAAGA,IAAI,CAACzY,UAAb,MAA6B4C,cAApC,EAAoD;AAClD,cAAI,KAAKqK,UAAL,CAAgBwL,IAAhB,CAAJ,EAA2B,KAAKC,WAAL,CAAiBD,IAAjB,EAA3B,KACK;AACN;AACF;AACF,KAhjCM;AAkjCPF,YAljCO,oBAkjCExL,IAljCF,EAkjCQ;AACb,WAAKxB,MAAL,CAAYI,eAAZ,CAA4BxM,IAA5B,CAAiC4N,IAAI,CAACD,EAAtC;AACA,WAAKvB,MAAL,CAAYM,eAAZ,CAA4BkB,IAAI,CAACD,EAAjC,IAAuC,IAAvC;AACD,KArjCM;AAujCP4L,eAvjCO,uBAujCK3L,IAvjCL,EAujCW;AAChBtP,qBAAe,CAAC,KAAK8N,MAAL,CAAYI,eAAb,EAA8BoB,IAAI,CAACD,EAAnC,CAAf;AACA,aAAO,KAAKvB,MAAL,CAAYM,eAAZ,CAA4BkB,IAAI,CAACD,EAAjC,CAAP;AACD,KA1jCM;AA4jCP8L,mBA5jCO,6BA4jCW;AAChB,UAAI,CAAC,KAAKnL,QAAV,EAAoB;AACpB,UAAI,KAAKd,MAAT,EAAiB,OAAO,KAAKyL,KAAL,EAAP;AACjB,UAAMS,SAAS,GAAGvC,cAAO,CAAC,KAAK5J,aAAN,CAAzB;AACA,UAAMoM,gBAAgB,GAAG,KAAKrM,OAAL,CAAaoM,SAAb,CAAzB;AACA,WAAKV,MAAL,CAAYW,gBAAZ;AACD,KAlkCM;AAokCPtC,0BApkCO,oCAokCkB;AACvB,UAAMnB,KAAK,GAAG,KAAKJ,OAAL,EAAd;AAEA,UAAII,KAAJ,EAAW,KAAKnK,IAAL,CAAUG,kBAAV,GAA+BgK,KAAK,CAACpY,SAArC;AACZ,KAxkCM;AA0kCPwZ,6BA1kCO,uCA0kCqB;AAC1B,UAAMpB,KAAK,GAAG,KAAKJ,OAAL,EAAd;AAEA,UAAII,KAAJ,EAAWA,KAAK,CAACpY,SAAN,GAAkB,KAAKiO,IAAL,CAAUG,kBAA5B;AACZ;AA9kCM,GAp0BI;AAq5Db0N,SAr5Da,qBAq5DH;AACR,SAAKzJ,WAAL;AACA,SAAKG,UAAL;AACD,GAx5DY;AA05DbuJ,SA15Da,qBA05DH;AACR,QAAI,KAAKtS,SAAT,EAAoB,KAAK2L,UAAL;AACpB,QAAI,CAAC,KAAKzI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK+P,eAAL;AAC9D,QAAI,KAAKnQ,UAAT,EAAqB,KAAK6H,QAAL;AACrB,QAAI,KAAK3H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKoH,kBAAL;AACxC,GA/5DY;AAi6DbgK,WAj6Da,uBAi6DD;AAEV,SAAKpH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/NA,+BA+NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AAnOA,GA9CA;AAoRA,QApRA,oBAoRA;AACA;AACA;AAtRA,G;;ACdiN,CAAgB,0GAAG,EAAC,C;;ACArO,IAAI,YAAM,EAAE,qBAAe;AAC8B;AACL;;;AAGpD;AAC0F;AAC1F,IAAI,eAAS,GAAG,kBAAU;AAC1B,EAAE,wCAAM;AACR,EAAE,YAAM;AACR,EAAE,qBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,kBAYf;AACD,eAAS;AACM,yDAAS,Q;;AChCxB;AACA,qCADA;AAEA,sBAFA;AAIA,QAJA,oBAIA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA,yCADA;AAEA,mDAFA;AAGA;AAHA;AAMA,WACA;AAAA;AAAA,QACA,oBADA,EADA;AAKA;AAjBA,G;;ACDuN,CAAgB,sHAAG,EAAC,C;;ACA3O,IAAI,kBAAM,EAAE,2BAAe;AACoC;AACL;;;AAG1D;AAC0F;AAC1F,IAAI,qBAAS,GAAG,kBAAU;AAC1B,EAAE,8CAAM;AACR,EAAE,kBAAM;AACR,EAAE,2BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,wBAYf;AACD,qBAAS;AACM,qEAAS,Q;;AChCxB;AACA;AAEA;AACA,sCADA;AAEA,sBAFA;AAGA;AACA,0BADA,oCACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AACA,wCACA;AAAA;AAAA,QADA,GAEA,UAFA;AAGA;AATA,GAHA;AAcA,QAdA,oBAcA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAAA,QACA,oBADA,GACA,IADA,CACA,OADA,CACA,oBADA;AAEA;AAEA,iCACA,mBACA;AAAA;AAAA,QACA,6BADA,EAFA,EAMA,cANA,EAOA;AAAA;AAAA,MAPA;AASA;AA3BA,G;;ACJuN,CAAgB,sHAAG,EAAC,C;;ACA3O,IAAI,kBAAM,EAAE,2BAAe;AACoC;AACL;;;AAG1D;AAC0F;AAC1F,IAAI,qBAAS,GAAG,kBAAU;AAC1B,EAAE,8CAAM;AACR,EAAE,kBAAM;AACR,EAAE,2BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,wBAYf;AACD,qBAAS;AACM,qEAAS,Q;;ACjCxB,IAAI,0CAAM;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,IAAI,mDAAe;AACnB,0CAAM;;;;;;AChBN;AACA;AADA,G;;ACP2N,CAAgB,uGAAG,EAAC,C;;ACA1J;AAC3B;AACL;;;AAGrD;AAC6F;AAC7F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,oCAAM;AACR,EAAE,0CAAM;AACR,EAAE,mDAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAiBf;AACD,gBAAS;AACM,2DAAS,Q;;ACrCxB;AACA;AAEA;AACA,0CADA;AAEA,sBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA;AADA,GAJA;AAWA;AACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAIA;AACA,KALA;AADA,GAXA;AAoBA,QApBA,oBAoBA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA,8CADA;AAEA,kEAFA;AAGA;AAHA;AAKA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA,QACA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,uBADA,EAEA;AAAA;AAAA,mBAFA,EADA,EADA;AAQA;AAtCA,G;;ACJ0N,CAAgB,4HAAG,EAAC,C;;ACA9O,IAAI,qBAAM,EAAE,8BAAe;AACuC;AACL;;;AAG7D;AAC0F;AAC1F,IAAI,wBAAS,GAAG,kBAAU;AAC1B,EAAE,iDAAM;AACR,EAAE,qBAAM;AACR,EAAE,8BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,2BAYf;AACD,wBAAS;AACM,2EAAS,Q;;;AChCxB;AACA;AACA;AAEA;AACA,qCADA;AAEA,sBAFA;AAIA;AACA,yBADA,mCACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,oCACA,KADA,CACA,CADA,EACA,cADA,EAEA,GAFA,CAEA,gBAFA,EAGA,GAHA,CAGA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA,OAHA;AAMA,KAVA;AAYA,wBAZA,kCAYA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AAEA,aACA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,qCADA,EADA;AAKA;AAvBA,GAJA;AA8BA,QA9BA,oBA8BA;AAAA;AAAA,QACA,oBADA,GACA,YADA,CACA,oBADA;AAEA;AACA;AACA,kBADA;AAEA,4DAFA;AAGA;AAHA;AADA;AAQA,gCACA;AAAA;AAAA,gCACA,4BADA,EAEA,2BAFA,EAGA;AAAA;AAAA,MAHA,EAIA;AAAA;AAAA;AAAA,MAJA,EADA;AAQA;AAhDA,G;;ACLsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;ACjCxB,IAAI,yCAAM;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,IAAI,kDAAe;AACnB,yCAAM;;;;;;AChBN;AACA;AADA,G;;ACP0N,CAAgB,qGAAG,EAAC,C;;ACA1J;AAC3B;AACL;;;AAGpD;AAC6F;AAC7F,IAAI,eAAS,GAAG,kBAAU;AAC1B,EAAE,mCAAM;AACR,EAAE,yCAAM;AACR,EAAE,kDAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,kBAiBf;AACD,eAAS;AACM,yDAAS,Q;;ACrCxB;AACA;AACA;AACA;AACA;AAEA;AACA,iCADA;AAEA,sBAFA;AAIA;AAMA,eANA,yBAMA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA,sBACA,kBADA,IAEA,iBAFA,KAGA,yDAHA,CADA;AAMA,KAfA;AAqBA,mBArBA,6BAqBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAGA;AACA,KA5BA;AAkCA,sBAlCA,gCAkCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA,qBACA;AAAA;AAAA,QAFA;AAIA;AAzCA,GAJA;AAiDA;AACA,WADA,qBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,QADA,EADA;AAKA,KAZA;AAcA,eAdA,yBAcA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA,6CADA;AAEA;AAFA;AAKA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,QADA,EADA;AAKA,KA5BA;AA8BA;AAUA;AACA;AAXA,UAaA,QAbA,GAaA,IAbA,CAaA,QAbA;AAcA;;AACA;AACA;AACA,OAFA;;AAIA;AAEA;AACA,OAHA,MAGA;AAEA;AAAA;AAAA;AAKA;AACA,KA9BA,CA9BA;AA8DA;AACA;AACA;AAFA,UAIA,QAJA,GAIA,IAJA,CAIA,QAJA;AAOA;AACA;AACA,KATA,CA9DA;AA0EA,wBA1EA,gCA0EA,QA1EA,EA0EA;AAAA;AACA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA;AAhFA,GAjDA;AAoIA,QApIA,oBAoIA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EAEA,cAFA,EAGA,kBAHA,EADA;AAOA;AA/IA,G;;ACPmN,CAAgB,8GAAG,EAAC,C;;ACAvO,IAAI,cAAM,EAAE,uBAAe;AACgC;AACL;;;AAGtD;AAC0F;AAC1F,IAAI,iBAAS,GAAG,kBAAU;AAC1B,EAAE,0CAAM;AACR,EAAE,cAAM;AACR,EAAE,uBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,oBAYf;AACD,iBAAS;AACM,6DAAS,Q;;AChCxB;AACA,6BADA;AAEA,kBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA,KADA;AAKA;AACA,kBADA;AAEA;AAFA;AALA,GAJA;AAeA,QAfA,kBAeA,CAfA,EAeA,OAfA,EAeA;AAAA;AAAA,QACA,KADA,GACA,OADA,CACA,KADA;AAAA,QACA,QADA,GACA,OADA,CACA,QADA;AAGA,WACA;AAAA;AAAA,QACA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA,EAIA;AAAA;AAAA,QACA,QADA,EAJA,EADA;AAUA;AA5BA,G;;ACD+M,CAAgB,sGAAG,EAAC,C;;ACAnO,IAAI,UAAM,EAAE,mBAAe;AAC4B;AACL;;;AAGlD;AAC0F;AAC1F,IAAI,aAAS,GAAG,kBAAU;AAC1B,EAAE,sCAAM;AACR,EAAE,UAAM;AACR,EAAE,mBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,gBAYf;AACD,aAAS;AACM,qDAAS,Q;;;AChCxB;AACA;AACA;AACA;AAEA;AAEA;AACA,gCADA;AAEA,sBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA;AADA,GAJA;AAWA;AACA,gBADA,0BACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KALA;AAOA,cAPA,wBAOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAXA,GAXA;AAyBA;AACA,gBADA,0BACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA,sCADA;AAEA,2DAFA;AAGA,qEAHA;AAIA,+DAJA;AAKA,wFALA;AAMA;AANA;AASA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAEA,2BACA,8BACA,qBADA,EADA,EAIA,kBAJA,EAFA,EADA;AAWA,KAvBA;AAyBA,wBAzBA,kCAyBA;AAAA;AACA;AAEA,aACA;AAAA;AAAA,UACA,uBADA,EAEA,0BAFA,EAGA,+BAHA,EAIA,oCAJA,EADA;AAQA,KApCA;AAsCA,eAtCA,yBAsCA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;;AAEA;AACA;AACA;AACA,yDADA;AAEA;AAFA;AADA;AAMA;AACA,8CADA;AAEA;AAFA;AAKA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,YACA,kCACA;AAAA;AAAA,UADA,EADA,EADA;AAOA;;AAKA;AACA,kDACA;AAAA;AAAA,oBADA;AAIA;AACA;;AAEA;AACA,KA5EA;AA8EA,wBA9EA,gCA8EA,QA9EA,EA8EA;AAAA;AACA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KApFA;AAsFA,2BAtFA,mCAsFA,QAtFA,EAsFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAEA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KAjGA;AAmGA,kBAnGA,4BAmGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA;AACA,wCADA;AAEA,qEAFA;AAGA,iFAHA;AAIA,yEAJA;AAKA;AALA;AAQA,kCACA;AAAA;AAAA,QADA;AAGA,kCACA;AAAA;AAAA,QADA;AAIA,aACA;AAAA;AAAA,UACA,SADA,EAEA,SAFA,EADA;AAMA,KA3HA;AA6HA,eA7HA,yBA6HA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA,4BACA,gDACA,kCADA,GAEA,kBAFA,CADA;AAMA,oCACA,8BACA,4DADA,GAEA,gCAHA,GAIA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAA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M,EAAE,oBAAe;AAC6B;AACL;;;AAGnD;AAC0F;AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 index f5c09de8..46fb725f 100644 --- a/dist/vue-treeselect.cjs.min.js +++ b/dist/vue-treeselect.cjs.min.js @@ -1,7 +1,7 @@ /*! - * vue-treeselect v0.4.0 | (c) 2017-2020 Riophae Lee + * vue-treeselect v0.4.0 | (c) 2017-2021 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 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 Y})),n.d(t,"ASYNC_SEARCH",(function(){return K})),n.d(t,"VERSION",(function(){return it}));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.filter((function(e){return e}));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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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 c=l.shift(),u=this.getNode(c);n.push(c),u.isRootNode||u.parentNode&&(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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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=ce(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=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 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?n:"number"!=typeof n||C(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?b.label:e.nestedSearchLabel+" "+b.label,N=i.$set(i.forest.nodeMap,u,B());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:w(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(14),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:w(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(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;t1?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},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?this.options.filter((function(e){return e})):{};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=[];this.hasBranchNodes=this.forest.normalizedOptions.some((function(e){return e.isBranch}))},getInstanceId:function(){return null==this.instanceId?this.id:this.instanceId},getValue:function(){var e=this;if("id"===this.valueFormat)return this.multiple?this.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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&&(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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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=ce(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?n:"number"!=typeof n||C(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:w(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(14),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:w(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(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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.filter(o => o)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"version":3,"sources":["webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/external \"@babel/runtime/helpers/defineProperty\"","webpack://VueTreeselect/external \"babel-helper-vue-jsx-merge-props\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/toConsumableArray\"","webpack://VueTreeselect/external \"lodash/noop\"","webpack://VueTreeselect/external \"lodash/debounce\"","webpack://VueTreeselect/external \"is-promise\"","webpack://VueTreeselect/external \"lodash/once\"","webpack://VueTreeselect/external \"lodash/identity\"","webpack://VueTreeselect/external \"lodash/constant\"","webpack://VueTreeselect/external \"lodash/last\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/slicedToArray\"","webpack://VueTreeselect/external \"fuzzysearch\"","webpack://VueTreeselect/external \"watch-size\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/typeof\"","webpack://VueTreeselect/external \"vue\"","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./src/utils/removeFromArray.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/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","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","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/SingleValue.vue","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","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValue.vue","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","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","require","warning","noop","onLeftClick","mouseDownHandler","evt","type","button","args","this","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","Math","min","offsetTop","clientHeight","scrollHeight","top","max","intervalId","removeFromArray","arr","elem","idx","indexOf","splice","registered","test","item","$el","listener","lastWidth","lastHeight","width","offsetWidth","height","watchSizeForIE9","push","setInterval","forEach","length","clearInterval","watchSize","isIE9","document","documentMode","locked","removeSizeWatcher","watchSizeForBrowsersOtherThanIE9","isScrollElment","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","window","findScrollParents","addEventListener","passive","scrollParent","removeEventListener","$scrollParent","isNaN","x","createMap","isPlainObject","getPrototypeOf","deepExtend","target","source","keys","len","obj","includes","arrOrStr","find","predicate","ctx","quickDiff","arrA","arrB","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","KEY_CODES","sortValueByIndex","a","b","level","index","match","enableFuzzyMatch","needle","haystack","fuzzysearch","getErrorMessage","err","message","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","count","loadingText","loadOptions","matchKeys","Array","maxHeight","multiple","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","openOnClick","openOnFocus","options","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","startSearchLength","waitSearchFinishTime","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","isLoaded","isLoading","loadingError","localSearch","active","noResults","countMap","lastSearchInput","remoteSearch","hasBranchNodes","computed","selectedNodes","map","getNode","internalValue","single","slice","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","sortValueByLevel","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","$emit","getValue","getInstanceId","buildForestState","handler","isArray","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","fallbackNode","label","enhancedNormalizer","isFallbackNode","isDisabled","isNew","$set","defaultNode","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","contains","wrapper","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","split","every","filterValue","nestedSearchLabel","matchKey","lowerCased","entry","callLoadOptionsProp","action","isPending","start","succeed","fail","end","$watch","isExpanded","shouldShowOptionInMenu","getControl","getMenu","$menu","portal","portalTarget","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","concat","hasDisabledDescendants","branchNodes","option","leafNodes","once","result","isPromise","then","catch","console","error","JSON","stringify","undefined","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","component","__file","inputWidth","_h","$createElement","_c","_self","attrs","xmlns","viewBox","_withStripped","VERSION","Treeselect","PKG_VERSION"],"mappings":";;;;;2BACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QA0Df,OArDAF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,oBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,iBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,IAIjBlC,EAAoBA,EAAoBmC,EAAI,I,gBClFrDhC,EAAOD,QAAUkC,QAAQ,0C,cCAzBjC,EAAOD,QAAUkC,QAAQ,qC,cCAzBjC,EAAOD,QAAUkC,QAAQ,6C,cCAzBjC,EAAOD,QAAUkC,QAAQ,gB,cCAzBjC,EAAOD,QAAUkC,QAAQ,oB,cCAzBjC,EAAOD,QAAUkC,QAAQ,e,cCAzBjC,EAAOD,QAAUkC,QAAQ,gB,cCAzBjC,EAAOD,QAAUkC,QAAQ,oB,cCAzBjC,EAAOD,QAAUkC,QAAQ,oB,cCAzBjC,EAAOD,QAAUkC,QAAQ,gB,cCAzBjC,EAAOD,QAAUkC,QAAQ,yC,cCAzBjC,EAAOD,QAAUkC,QAAQ,gB,cCAzBjC,EAAOD,QAAUkC,QAAQ,e,cCAzBjC,EAAOD,QAAUkC,QAAQ,kC,cCAzBjC,EAAOD,QAAUkC,QAAQ,Q,8ZCEZC,E,OACkBC,ECHxB,SAASC,EAAYC,GAC1B,OAAO,SAAqBC,GAC1B,GAAiB,cAAbA,EAAIC,MAAuC,IAAfD,EAAIE,OAAc,4BADhBC,EACgB,iCADhBA,EACgB,kBAChDJ,EAAiBjC,KAAjB,MAAAiC,EAAgB,CAAMK,KAAMJ,GAAZ,OAAoBG,MCFnC,SAASE,EAAeC,EAAcC,GAC3C,IAAMC,EAAiBF,EAAaG,wBAC9BC,EAAcH,EAAWE,wBACzBE,EAAaJ,EAAWK,aAAe,EAEzCF,EAAYG,OAASF,EAAaH,EAAeK,OACnDP,EAAaQ,UAAYC,KAAKC,IAC5BT,EAAWU,UAAYV,EAAWW,aAAeZ,EAAaM,aAAeD,EAC7EL,EAAaa,cAENT,EAAYU,IAAMT,EAAaH,EAAeY,MACvDd,EAAaQ,UAAYC,KAAKM,IAAId,EAAWU,UAAYN,EAAY,I,ICTrEW,E,iCCHG,SAASC,EAAgBC,EAAKC,GACnC,IAAMC,EAAMF,EAAIG,QAAQF,IACX,IAATC,GAAYF,EAAII,OAAOF,EAAK,GDElC,IAAMG,EAAa,GAcnB,SAASC,EAAKC,GAAM,IACVC,EAAyCD,EAAzCC,IAAKC,EAAoCF,EAApCE,SAAUC,EAA0BH,EAA1BG,UAAWC,EAAeJ,EAAfI,WAC5BC,EAAQJ,EAAIK,YACZC,EAASN,EAAIpB,aAEfsB,IAAcE,GAASD,IAAeG,IACxCP,EAAKG,UAAYE,EACjBL,EAAKI,WAAaG,EAElBL,EAAS,CAAEG,QAAOE,YAItB,SAASC,EAAgBP,EAAKC,GAC5B,IAAMF,EAAO,CACXC,MACAC,WACAC,UAAW,KACXC,WAAY,MAad,OANAN,EAAWW,KAAKT,GAGhBD,EAAKC,GAtCLT,EAAamB,aAAY,WACvBZ,EAAWa,QAAQZ,KAJG,KAiCR,WACdP,EAAgBM,EAAYE,GACvBF,EAAWc,SA1BlBC,cAActB,GACdA,EAAa,OAqCR,SAASuB,EAAUb,EAAKC,GAE7B,IAAMa,EAAkC,IAA1BC,SAASC,aAGnBC,GAAS,EAKPC,GAHiBJ,EACnBP,EACAY,KACqCnB,GAJjB,kBAAaiB,GAAUhB,EAAQ,WAAR,gBAO/C,OAFAgB,GAAS,EAEFC,EEpDT,SAASE,EAAepB,GAAK,MAEgBqB,iBAAiBrB,GAApDsB,EAFmB,EAEnBA,SAAUC,EAFS,EAETA,UAAWC,EAFF,EAEEA,UAC7B,MAAO,wBAAwB1B,KAAKwB,EAAWE,EAAYD,GAGtD,SAASE,EAAmCzB,EAAKC,GACtD,IAAMyB,EApBR,SAA2B1B,GAIzB,IAHA,IAAM0B,EAAiB,GACnBC,EAAU3B,EAAI4B,WAEXD,GAAgC,SAArBA,EAAQE,UAAuBF,EAAQG,WAAaf,SAASgB,cACzEX,EAAeO,IAAUD,EAAelB,KAAKmB,GACjDA,EAAUA,EAAQC,WAIpB,OAFAF,EAAelB,KAAKwB,QAEbN,EAUgBO,CAAkBjC,GAOzC,OALAgC,OAAOE,iBAAiB,SAAUjC,EAAU,CAAEkC,SAAS,IACvDT,EAAehB,SAAQ,SAAA0B,GACrBA,EAAaF,iBAAiB,SAAUjC,EAAU,CAAEkC,SAAS,OAGxD,WACLH,OAAOK,oBAAoB,SAAUpC,EAAU,CAAEkC,SAAS,IAC1DT,EAAehB,SAAQ,SAAA4B,GACrBA,EAAcD,oBAAoB,SAAUpC,EAAU,CAAEkC,SAAS,QC9BhE,SAASI,EAAMC,GACpB,OAAOA,GAAMA,E,oECDFC,EAAY,kBAAMpG,OAAOY,OAAO,O,iBCA7C,SAASyF,EAAc9F,GACrB,OAAa,MAATA,GAAkC,WAAjB,IAAOA,IACrBP,OAAOsG,eAAe/F,KAAWP,OAAOkB,UAY1C,SAASqF,EAAWC,EAAQC,GACjC,GAAIJ,EAAcI,GAGhB,IAFA,IAAMC,EAAO1G,OAAO0G,KAAKD,GAEhBnH,EAAI,EAAGqH,EAAMD,EAAKpC,OAAQhF,EAAIqH,EAAKrH,IAblCsH,EAcHJ,EAdQ3F,EAcA6F,EAAKpH,GAblB+G,EADkB9F,EAcIkG,EAAOC,EAAKpH,MAZpCsH,EAAI/F,KAAS+F,EAAI/F,GAAO,IACxB0F,EAAWK,EAAI/F,GAAMN,IAErBqG,EAAI/F,GAAON,EALf,IAAcqG,EAAK/F,EAAKN,EAkBtB,OAAOiG,E,oBCvBF,SAASK,EAASC,EAAU1D,GACjC,OAAmC,IAA5B0D,EAASxD,QAAQF,GCDnB,SAAS2D,EAAK5D,EAAK6D,EAAWC,GACnC,IAAK,IAAI3H,EAAI,EAAGqH,EAAMxD,EAAImB,OAAQhF,EAAIqH,EAAKrH,IACzC,GAAI0H,EAAUvH,KAAKwH,EAAK9D,EAAI7D,GAAIA,EAAG6D,GAAM,OAAOA,EAAI7D,GCFjD,SAAS4H,EAAUC,EAAMC,GAC9B,GAAID,EAAK7C,SAAW8C,EAAK9C,OAAQ,OAAO,EAExC,IAAK,IAAIhF,EAAI,EAAGA,EAAI6H,EAAK7C,OAAQhF,IAC/B,GAAI6H,EAAK7H,KAAO8H,EAAK9H,GAAI,OAAO,EAGlC,OAAO,ECNF,IAcM+H,EAAoB,oBACpBC,EAAwB,wBACxBC,EAAe,eAcfC,EACA,EADAA,EAEJ,GAFIA,EAGH,GAHGA,EAIN,GAJMA,EAKL,GALKA,GAMC,GANDA,GAOD,GAPCA,GAQE,GARFA,GASC,GATDA,GAUH,G,qkBCtBV,SAASC,GAAiBC,EAAGC,GAE3B,IADA,IAAIrI,EAAI,IACL,CACD,GAAIoI,EAAEE,MAAQtI,EAAG,OAAQ,EACzB,GAAIqI,EAAEC,MAAQtI,EAAG,OAAO,EACxB,GAAIoI,EAAEG,MAAMvI,KAAOqI,EAAEE,MAAMvI,GAAI,OAAOoI,EAAEG,MAAMvI,GAAKqI,EAAEE,MAAMvI,GAC3DA,KAyBJ,SAASwI,GAAMC,EAAkBC,EAAQC,GACvC,OAAOF,EACHG,IAAYF,EAAQC,GACpBpB,EAASoB,EAAUD,GAGzB,SAASG,GAAgBC,GACvB,OAAOA,EAAIC,SAAqCC,OAAOF,GAGzD,IAAIG,GAAa,EAEF,IACbC,QADa,WAEX,MAAO,CAGLC,SAAU1G,OAId2G,MAAO,CAILC,sBAAuB,CACrB/G,KAAMgH,QACNC,SAAS,GAOXC,kCAAmC,CACjClH,KAAMgH,QACNC,SAAS,GAMXE,WAAY,CACVnH,KAAMgH,QACNC,SAAS,GAMXG,aAAc,CACZpH,KAAMgH,QACNC,SAAS,GAMXI,MAAO,CACLrH,KAAMgH,QACNC,SAAS,GAMXK,UAAW,CACTtH,KAAMgH,QACNC,SAAS,GAMXM,oBAAqB,CACnBvH,KAAMgH,QACNC,SAAS,GAMXO,sBAAuB,CACrBxH,KAAMgH,QACNC,SAAS,GAMXQ,wBAAyB,CACvBzH,KAAMgH,QACNC,SAAS,GAMXS,oBAAqB,CACnB1H,KAAMgH,QACNC,SAAS,GAMXU,sBAAuB,CACrB3H,KAAMgH,QACNC,SAAS,GAMXW,iBAAkB,CAChB5H,KAAMgH,QACNC,SAAS,GAQXY,eAAgB,CACd7H,KAAM8H,SACNb,QAASc,KAAS,IAMpBC,iBAAkB,CAChBhI,KAAMgH,QACNC,SAAS,GAMXgB,aAAc,CACZjI,KAAMgH,QACNC,SAAS,GAMXiB,UAAW,CACTlI,KAAMgH,QACNC,SAAS,GAMXkB,aAAc,CACZnI,KAAM0G,OACNO,QAAS,aAQXmB,cAAe,CACbpI,KAAMgH,QACNC,SAAS,GAMXoB,eAAgB,CACdrI,KAAM0G,OACNO,QAAS,eAOXqB,cAAe,CACbtI,KAAMgH,QACNC,SAAS,GAOXsB,mBAAoB,CAClBvI,KAAMwI,OACNvB,QAAS,GAQXwB,eAAgB,CACdxB,SAAS,GAMXyB,cAAe,CACb1I,KAAMgH,QACNC,SAAS,GAMX0B,UAAW,CACT3I,KAAM0G,OACNO,QAAS,KAQX2B,qBAAsB,CACpB5I,KAAMgH,QACNC,SAAS,GAMX4B,mBAAoB,CAClB7I,KAAMgH,QACNC,SAAS,GAMX6B,SAAU,CACR9I,KAAMgH,QACNC,SAAS,GAMX8B,qBAAsB,CACpB/I,KAAMgH,QACNC,SAAS,GASX+B,KAAM,CACJhJ,KAAMgH,QACNC,SAAS,GAOXN,WAAY,CAEVM,QAAS,2BAASN,KAAT,OACT3G,KAAM,CAAE0G,OAAQ8B,SAMlBS,WAAY,CACVjJ,KAAMgH,QACNC,SAAS,GAOXiC,MAAO,CACLlJ,KAAMwI,OACNvB,QAASkC,KAOXC,UAAW,CACTpJ,KAAM8H,SACNb,QAAS,SAA0BoC,GACjC,oBAAcA,EAAd,WAOJC,YAAa,CACXtJ,KAAM0G,OACNO,QAAS,cAOXsC,YAAa,CACXvJ,KAAM8H,UAMR0B,UAAW,CACTxJ,KAAMyJ,MACNxC,QAASc,IAAS,CAAE,WAMtB2B,UAAW,CACT1J,KAAMwI,OACNvB,QAAS,KAMX0C,SAAU,CACR3J,KAAMgH,QACNC,SAAS,GAMXhJ,KAAM,CACJ+B,KAAM0G,QAMRkD,eAAgB,CACd5J,KAAM0G,OACNO,QAAS,mBAMX4C,cAAe,CACb7J,KAAM0G,OACNO,QAAS,yBAMX6C,cAAe,CACb9J,KAAM0G,OACNO,QAAS,uBAOX8C,WAAY,CACV/J,KAAM8H,SACNb,QAAS+C,KAeXC,cAAe,CACbjK,KAAM0G,OACNO,QAAS,OACTiD,UAHa,SAGHvL,GAER,OAAOsG,EADkB,CAAE,OAAQ,MAAO,SAAU,QAAS,SAC3BtG,KAOtCwL,YAAa,CACXnK,KAAMgH,QACNC,SAAS,GAMXmD,YAAa,CACXpK,KAAMgH,QACNC,SAAS,GAOXoD,QAAS,CACPrK,KAAMyJ,OAMRa,YAAa,CACXtK,KAAM0G,OACNO,QAAS,aAMXsD,SAAU,CACRvK,KAAMgH,QACNC,SAAS,GAMXuD,UAAW,CACTxK,KAAM0G,OACNO,QAAS,UAMXwD,WAAY,CACVzK,KAAM0G,OACNO,QAAS,kBAMXyD,WAAY,CACV1K,KAAMgH,QACNC,SAAS,GAMX0D,aAAc,CACZ3K,KAAMgH,QACNC,SAAS,GAMX2D,iBAAkB,CAChB5K,KAAM0G,OACNO,QAAS,qBAMX4D,UAAW,CACT7K,KAAMgH,QACNC,SAAS,GAOX6D,kBAAmB,CACjB9K,KAAMwI,OACNvB,QAAS,GAQX8D,qBAAsB,CACpB/K,KAAMwI,OACNvB,QAAS,GAWX+D,YAAa,CACXhL,KAAM0G,OACNO,QDpjBsB,eCqjBtBiD,UAHW,SAGDvL,GAER,OAAOsG,EADkB,CDtjBL,eACG,kBACF,gBACG,oBCojBUtG,KAStCsM,kBAAmB,KAUnBC,YAAa,CACXlL,KAAM0G,OACNO,QD3jBwB,iBC4jBxBiD,UAHW,SAGDvL,GAER,OAAOsG,EADkB,CD7jBH,iBACT,QACA,SC4jBqBtG,KAOtCwM,SAAU,CACRnL,KAAMwI,OACNvB,QAAS,GAUXtI,MAAO,KAUPyM,gBAAiB,CACfpL,KAAM0G,OACNO,QDlmByB,kBCmmBzBiD,UAHe,SAGLvL,GAER,OAAOsG,EADkB,CDrmBd,MACY,kBACF,gBACS,0BCmmBItG,KAWtC0M,YAAa,CACXrL,KAAM0G,OACNO,QAAS,MAMXqE,OAAQ,CACNtL,KAAM,CAAEwI,OAAQ9B,QAChBO,QAAS,MAIbsE,KArlBa,WAslBX,MAAO,CACLC,QAAS,CAEPC,WAAW,EAEXC,YAAa,IAGfC,KAAM,CAEJC,QAAQ,EAERC,QAAS,KAETC,mBAAoB,EAEpBC,UAAW,UAGbC,OAAQ,CAENC,kBAAmB,GAEnBC,QAAS1H,IAET2H,gBAAiB3H,IAEjB4H,gBAAiBjM,KAAKkM,iCAGtBC,gBAAiB9H,KAInB+H,kBAlpBG,CACLC,UAAU,EACVC,WAAW,EACXC,aAAc,IAipBZC,YAAa,CAEXC,QAAQ,EAERC,WAAW,EAEXC,SAAUtI,KAGZuI,gBAAiB,KAGjBC,aAAcxI,IAKdyI,eAAgB,OAIpBC,SAAU,CAMRC,cANQ,WAON,OAAOhN,KAAK6L,OAAOI,gBAAgBgB,IAAIjN,KAAKkN,UAM9CC,cAbQ,WAaQ,IACVA,EADU,OAId,GAAInN,KAAKoN,QAAUpN,KAAK6I,MAAQ7I,KAAK0I,oBD1sBxB,QC0sB8C1I,KAAKiL,gBAC9DkC,EAAgBnN,KAAK6L,OAAOI,gBAAgBoB,aACvC,GD3sBkB,oBC2sBdrN,KAAKiL,gBACdkC,EAAgBnN,KAAK6L,OAAOI,gBAAgBqB,QAAO,SAAAC,GACjD,IAAMC,EAAO,EAAKN,QAAQK,GAC1B,QAAIC,EAAKC,aACD,EAAKC,WAAWF,EAAKhK,oBAE1B,GDhtBgB,kBCgtBZxD,KAAKiL,gBACdkC,EAAgBnN,KAAK6L,OAAOI,gBAAgBqB,QAAO,SAAAC,GACjD,IAAMC,EAAO,EAAKN,QAAQK,GAC1B,QAAIC,EAAKG,QACuB,IAAzBH,EAAKI,SAASrL,eAElB,GDrtByB,2BCqtBrBvC,KAAKiL,gBAA4C,OACpD4C,EAAuB,GAC7BV,EAAgBnN,KAAK6L,OAAOI,gBAAgBoB,QAC5CrN,KAAKgN,cAAc1K,SAAQ,SAAAwL,GACzBA,EAAaC,UAAUzL,SAAQ,SAAA0L,GACzBlJ,EAAS+I,EAAsBG,EAAST,KACxCzI,EAASqI,EAAea,EAAST,KACrCM,EAAqBzL,KAAK4L,EAAST,WAGvC,EAAAJ,GAAc/K,KAAd,QAAsByL,GASxB,MDpuBe,UC8tBX7N,KAAK+K,YACPoC,EAAcc,MAAK,SAACtI,EAAGC,GAAJ,OA7tB3B,SAA0BD,EAAGC,GAC3B,OAAOD,EAAEE,QAAUD,EAAEC,MACjBH,GAAiBC,EAAGC,GACpBD,EAAEE,MAAQD,EAAEC,MA0tBmBqI,CAAiB,EAAKhB,QAAQvH,GAAI,EAAKuH,QAAQtH,OD9tB/D,UC+tBJ5F,KAAK+K,aACdoC,EAAcc,MAAK,SAACtI,EAAGC,GAAJ,OAAUF,GAAiB,EAAKwH,QAAQvH,GAAI,EAAKuH,QAAQtH,OAGvEuH,GAMTgB,SAxDQ,WAyDN,OAAOnO,KAAKmN,cAAc5K,OAAS,GAMrC6K,OA/DQ,WAgEN,OAAQpN,KAAKwJ,UAUf4E,iBA1EQ,WA0EW,WACXA,EAAmB,GAYzB,OAVApO,KAAKqO,yBAAwB,SAAAb,GAK3B,GAJK,EAAKhB,YAAYC,SAAU,EAAK6B,qCAAqCd,IACxEY,EAAiBhM,KAAKoL,EAAKD,IAGzBC,EAAKe,WAAa,EAAKC,aAAahB,GACtC,OAAO,KAIJY,GAMTK,kBA7FQ,WA8FN,OAAwC,IAAjCzO,KAAKoO,iBAAiB7L,QAM/BmM,0BApGQ,WAwGN,MAAyC,kBAA3B1O,KAAK8K,kBACf9K,KAAK8K,kBACL9K,KAAK0K,WAEXiE,qBA5GQ,WA6GN,OAAO3O,KAAKwM,YAAYC,QAAUzM,KAAKyI,uBAK3CmG,MAAO,CACL5H,WADK,SACM6H,GACLA,EAAU7O,KAAK8O,WACd9O,KAAK+O,aAGZlH,iBANK,WAOH7H,KAAKgP,cAGPrG,SAVK,SAUIkG,GAEHA,GAAY7O,KAAKwL,KAAKC,OAAQzL,KAAK+O,YAC7BF,GAAa7O,KAAKwL,KAAKC,SAAUzL,KAAKgH,YAAYhH,KAAK8O,YAGnEjG,KAhBK,WAiBH7I,KAAKgP,cAGP7B,cApBK,SAoBS0B,EAAUI,GACH9J,EAAU0J,EAAUI,IAIvBjP,KAAKkP,MAAM,QAASlP,KAAKmP,WAAYnP,KAAKoP,kBAG5D/F,UA5BK,WA6BHrJ,KAAKgP,cAGPxF,SAhCK,SAgCIqF,GAIHA,GAAU7O,KAAKqP,oBAGrBnF,QAAS,CACPoF,QADO,WAEDtP,KAAKkH,QAETlH,KAAKgP,aACLhP,KAAKoM,kBAAkBC,SAAW/C,MAAMiG,QAAQvP,KAAKkK,WAEvDsF,MAAM,EACNC,WAAW,GAGb,sBAlDK,WAmDCzP,KAAKkH,MACPlH,KAAK0P,qBAEL1P,KAAK2P,oBAGP3P,KAAKkP,MAAM,gBAAiBlP,KAAKqL,QAAQE,YAAavL,KAAKoP,kBAG7D5Q,MA5DK,WA6DH,IAAMoR,EAAmB5P,KAAKkM,iCACX/G,EAAUyK,EAAkB5P,KAAKmN,gBACpCnN,KAAK6P,mBAAmBD,KAI5CE,QAAS,CACPC,YADO,WACO,WAoBZ,GAnBAvQ,GACE,kBAAM,EAAK0H,OAAQ,EAAKqD,cACxB,iBAAM,yEAGY,MAAhBvK,KAAKkK,SAAoBlK,KAAKoJ,aAChC5J,GACE,kBAAM,KACN,iBAAM,oFAINQ,KAAK6I,MACPrJ,GACE,kBAAM,EAAKgK,YACX,iBAAM,sEAILxJ,KAAK6I,KAAM,CACI,CAChB,sBACA,wBACA,wBACA,2BAGQvG,SAAQ,SAAA0N,GAChBxQ,GACE,kBAAO,EAAKwQ,MACZ,4BAAUA,EAAV,wCAMRC,WAtCO,WAuCLjQ,KAAKkQ,eAAgB,GAGvBlB,WA1CO,WA2CL,IAAM9E,EAAUlK,KAAKkH,MACjBlH,KAAKmQ,uBAAuBjG,QAC5BlK,KAAKkK,QAAUlK,KAAKkK,QAAQoD,QAAO,SAAAtP,GAAC,OAAIA,KAAK,GAEjD,GAAIsL,MAAMiG,QAAQrF,GAAU,CAE1B,IAAMkG,EAAcpQ,KAAK6L,OAAOE,QAChC/L,KAAK6L,OAAOE,QAAU1H,IACtBrE,KAAKqQ,wBAAwBD,GAC7BpQ,KAAK6L,OAAOC,kBAAoB9L,KAAKsQ,UDr7Bf,KCq7ByCpG,EAASkG,GAOxEpQ,KAAK6P,mBAAmB7P,KAAKmN,oBAE7BnN,KAAK6L,OAAOC,kBAAoB,GAGlC9L,KAAK8M,eAAiB9M,KAAK6L,OAAOC,kBAAkByE,MAAK,SAAAC,GAAQ,OAAIA,EAASjC,aAGhFa,cAnEO,WAoEL,OAA0B,MAAnBpP,KAAKwG,WAAqBxG,KAAKuN,GAAKvN,KAAKwG,YAGlD2I,SAvEO,WAuEI,WACT,GAAyB,OAArBnP,KAAKkL,YACP,OAAOlL,KAAKwJ,SACRxJ,KAAKmN,cAAcE,QACnBrN,KAAKmN,cAAc,GAGzB,IAAMsD,EAAWzQ,KAAKmN,cAAcF,KAAI,SAAAM,GAAE,OAAI,EAAKL,QAAQK,GAAImD,OAC/D,OAAO1Q,KAAKwJ,SAAWiH,EAAWA,EAAS,IAG7CvD,QAlFO,SAkFCyD,GAMN,OALAnR,GACE,kBAAgB,MAAVmR,KACN,4CAA0BA,MAGd,MAAVA,EAIK,KAGFA,KAAU3Q,KAAK6L,OAAOE,QACzB/L,KAAK6L,OAAOE,QAAQ4E,GACpB3Q,KAAK4Q,mBAAmBD,IAG9BC,mBApGO,SAoGYrD,GAKjB,IAAMmD,EAAM1Q,KAAK6Q,qBAAqBtD,GAEhCuD,EAAe,CACnBvD,KACAwD,MAHY/Q,KAAKgR,mBAAmBN,GAAKK,OAA7B,UAAyCxD,EAAzC,cAIZQ,UAAW,GACXvK,WDh/BsB,KCi/BtByN,gBAAgB,EAChBxD,YAAY,EACZE,QAAQ,EACRY,UAAU,EACV2C,YAAY,EACZC,OAAO,EACPrL,MAAO,EAAG,GACVD,MAAO,EACP6K,OAGF,OAAO1Q,KAAKoR,KAAKpR,KAAK6L,OAAOE,QAASwB,EAAIuD,IAG5C5E,+BA9HO,WA8H0B,WAC/B,OAAkB,MAAdlM,KAAKxB,MAAsB,GAEN,OAArBwB,KAAKkL,YACAlL,KAAKwJ,SACRxJ,KAAKxB,MAAM6O,QACX,CAAErN,KAAKxB,QAGLwB,KAAKwJ,SAAWxJ,KAAKxB,MAAQ,CAAEwB,KAAKxB,QACzCyO,KAAI,SAAAO,GAAI,OAAI,EAAKwD,mBAAmBxD,MACpCP,KAAI,SAAAO,GAAI,OAAIA,EAAKD,OAGtBsD,qBA5IO,SA4IctD,GAAI,WACjB8D,EAAc,CAAE9D,MAEtB,MAAyB,OAArBvN,KAAKkL,YACAmG,EAMOrM,EAHGhF,KAAKwJ,SACpBF,MAAMiG,QAAQvP,KAAKxB,OAASwB,KAAKxB,MAAQ,GACzCwB,KAAKxB,MAAQ,CAAEwB,KAAKxB,OAAU,IAGhC,SAAAgP,GAAI,OAAIA,GAAQ,EAAKwD,mBAAmBxD,GAAMD,KAAOA,MAGrC8D,GAGpBxB,mBA9JO,SA8JYyB,GAAuB,WACpCC,EAAsB,GAG1B,GAAIvR,KAAKoN,QAAUpN,KAAK6I,MAAQ7I,KAAK0I,oBDhhCxB,QCghC8C1I,KAAKiL,gBAC9DsG,EAAsBD,OACjB,GDjhCkB,oBCihCdtR,KAAKiL,gBACdqG,EAAsBhP,SAAQ,SAAAqO,GAC5B,GAAKA,EAAL,CAGAY,EAAoBnP,KAAKuO,GACzB,IAAMnD,EAAO,EAAKN,QAAQyD,GACtBnD,GAAQA,EAAKe,UAAU,EAAKiD,uBAAuBhE,GAAM,SAAAiE,GACvDA,GACFF,EAAoBnP,KAAKqP,EAAWlE,gBAIrC,GD7hCgB,kBC6hCZvN,KAAKiL,gBAGd,IAFA,IAAMgC,EAAM5I,IACNqN,EAAQJ,EAAsBjE,QAC7BqE,EAAMnP,QAAQ,CACnB,IAAMoO,EAASe,EAAMC,QACfnE,EAAOxN,KAAKkN,QAAQyD,GAC1BY,EAAoBnP,KAAKuO,GACrBnD,EAAKC,YACJD,EAAKhK,aACJgK,EAAKhK,WAAW+J,MAAMN,IAAMA,EAAIO,EAAKhK,WAAW+J,IAAMC,EAAKhK,WAAWoK,SAASrL,QACnD,KAA5B0K,EAAIO,EAAKhK,WAAW+J,KAAWmE,EAAMtP,KAAKoL,EAAKhK,WAAW+J,UAE7D,GDxiCyB,2BCwiCrBvN,KAAKiL,gBAMd,IALA,IAAMgC,EAAM5I,IACNqN,EAAQJ,EAAsBhE,QAAO,SAAAqD,GACzC,IAAMnD,EAAO,EAAKN,QAAQyD,GAC1B,OAAOnD,EAAKG,QAAmC,IAAzBH,EAAKI,SAASrL,UAE/BmP,EAAMnP,QAAQ,CACnB,IAAMoO,EAASe,EAAMC,QACfnE,EAAOxN,KAAKkN,QAAQyD,GAC1BY,EAAoBnP,KAAKuO,GACrBnD,EAAKC,YACJD,EAAKhK,aACJgK,EAAKhK,WAAW+J,MAAMN,IAAMA,EAAIO,EAAKhK,WAAW+J,IAAMC,EAAKhK,WAAWoK,SAASrL,QACnD,KAA5B0K,EAAIO,EAAKhK,WAAW+J,KAAWmE,EAAMtP,KAAKoL,EAAKhK,WAAW+J,KAIjDpI,EAAUnF,KAAK6L,OAAOI,gBAAiBsF,KAI1CvR,KAAK6L,OAAOI,gBAAkBsF,GAE9CvR,KAAKqP,oBAGPgB,wBAvNO,SAuNiBD,GAAa,WAGnCpQ,KAAK6L,OAAOI,gBAAgB3J,SAAQ,SAAAiL,GAClC,GAAK6C,EAAY7C,GAAjB,CACA,IAAMC,EAAO,GAAH,MACL4C,EAAY7C,IADP,IAER0D,gBAAgB,IAElB,EAAKG,KAAK,EAAKvF,OAAOE,QAASwB,EAAIC,QAIvCE,WApOO,SAoOIF,GAET,OAAgD,IAAzCxN,KAAK6L,OAAOM,gBAAgBqB,EAAKD,KAG1CiE,uBAzOO,SAyOgBhO,EAAYoO,GAEjC,GAAKpO,EAAW+K,SAEhB,IADA,IAAMmD,EAAQlO,EAAWoK,SAASP,QAC3BqE,EAAMnP,QAAQ,CACnB,IAAMsP,EAAWH,EAAM,GACnBG,EAAStD,UAAUmD,EAAMtP,KAAN,MAAAsP,EAAK,IAASG,EAASjE,WAC9CgE,EAASC,GACTH,EAAMC,UAIVG,uBArPO,SAqPgBtO,EAAYoO,GAAU,WACtCpO,EAAW+K,UAChB/K,EAAWoK,SAAStL,SAAQ,SAAAyP,GAE1B,EAAKD,uBAAuBC,EAAOH,GACnCA,EAASG,OAIbC,oBA9PO,SA8PaJ,GAAU,WAC5B5R,KAAK6L,OAAOC,kBAAkBxJ,SAAQ,SAAAkO,GAEpC,EAAKsB,uBAAuBtB,EAAUoB,GACtCA,EAASpB,OAIbnC,wBAtQO,SAsQiBuD,IACT,SAAPK,EAAOzO,GACXA,EAAWoK,SAAStL,SAAQ,SAAAyP,IACF,IAApBH,EAASG,IAAoBA,EAAMxD,UACrC0D,EAAKF,MAOXE,CAAK,CAAErE,SAAU5N,KAAK6L,OAAOC,qBAG/BoG,wBApRO,SAoRiBC,GAClBA,EACFxP,SAASmB,iBAAiB,YAAa9D,KAAKoS,oBAAoB,GAEhEzP,SAASsB,oBAAoB,YAAajE,KAAKoS,oBAAoB,IAIvEC,kBA5RO,WA6RL,OAAOrS,KAAKsS,MAAMC,QAAQD,MAAM,oBAGlCE,SAhSO,WAiSL,OAAOxS,KAAKqS,oBAAoBC,MAAMG,OAGxCC,WApSO,WAqSL1S,KAAKwS,WAAWG,SAGlBC,UAxSO,WAySL5S,KAAKwS,WAAWK,QAGlBC,gBAAiBpT,GAAY,SAAyBE,IACpDA,EAAImT,iBACJnT,EAAIoT,kBAEAhT,KAAK2I,YAEyB3I,KAAKqS,oBAAoBzQ,IAAIqR,SAASrT,EAAI6E,UAC1CzE,KAAKwL,KAAKC,SAAWzL,KAAKgK,aAAehK,KAAKqL,QAAQC,YACtFtL,KAAK8O,WAGH9O,KAAKkQ,cACPlQ,KAAK4S,YAGL5S,KAAK0S,aAGP1S,KAAKiQ,iBAGPmC,mBAjUO,SAiUYxS,GAEbI,KAAKsS,MAAMY,UAAYlT,KAAKsS,MAAMY,QAAQD,SAASrT,EAAI6E,UACzDzE,KAAK4S,YACL5S,KAAK+O,cAITY,kBAzUO,SAyUWwD,GAAO,WACf5H,EAAgBvL,KAAKqL,QAArBE,YACF6H,EAAO,kBAAM,EAAKC,qCAAoC,IAE5D,IAAK9H,EAIH,OAFAvL,KAAKwM,YAAYC,QAAS,EAC1BzM,KAAK4M,gBAAkB,KAChBwG,IAGT,KAAI7H,EAAYhJ,OAASvC,KAAK2K,mBAA9B,CAKA,GAAI3K,KAAK4K,qBAAuB,EAAG,CAEjC,IAAM0I,EAAM,IAAIC,KAChB,IAAKvT,KAAK4M,gBAOR,OALA4G,YAAW,WACT,EAAK7D,mBAAkB,KACtB3P,KAAK4K,2BAER5K,KAAK4M,gBAAkB0G,GAIzB,IAAMG,EAAOH,EAAMtT,KAAK4M,gBACxB,GAAI6G,EAAOzT,KAAK4K,uBAAyBuI,EAMvC,OALAK,YAAW,WACT,EAAK7D,mBAAkB,KACtB3P,KAAK4K,2BAER5K,KAAK4M,gBAAkB0G,GAIzB,GAAIH,GAASM,EAAOzT,KAAK4K,qBACvB,OAGF5K,KAAK4M,gBAAkB0G,EAIzBtT,KAAKwM,YAAYC,QAAS,EAG1BzM,KAAKwM,YAAYE,WAAY,EAC7B1M,KAAKgS,qBAAoB,SAAAxE,GACJ,MAAfA,EAAKe,WACPf,EAAKkG,oBAAqB,EAC1BlG,EAAKmG,yBAA0B,EAC/BnG,EAAKoG,WAAY,EACjBpG,EAAKqG,uBAAwB,EAC7B,EAAKzC,KAAK,EAAK5E,YAAYG,SAAUa,EAAKD,IAA1C,WD3vCkB,eC4vCA,GADlB,MD1vCqB,kBC4vCA,GAFrB,MDzvCmB,gBC4vCA,GAHnB,MDxvCsB,mBC4vCA,GAJtB,QASJ,IAAMuG,EAAwBvI,EAAYwI,OAAOC,oBAC3CC,EAAmBH,EAAsBI,QAAQ,OAAQ,KAAKC,MAAM,KAC1EnU,KAAKgS,qBAAoB,SAAAxE,GACnB,EAAKhD,cAAgByJ,EAAiB1R,OAAS,EACjDiL,EAAKoG,UAAYK,EAAiBG,OAAM,SAAAC,GAAW,OACjDtO,IAAM,EAAOsO,EAAa7G,EAAK8G,sBAGjC9G,EAAKoG,UAAY,EAAKvK,UAAUkH,MAAK,SAAAgE,GAAQ,OAC3CxO,IAAO,EAAK6C,qBAAsBkL,EAAuBtG,EAAKgH,WAAWD,OAIzE/G,EAAKoG,YACP,EAAKpH,YAAYE,WAAY,EAC7Bc,EAAKO,UAAUzL,SAAQ,SAAA0L,GAAQ,OAAI,EAAKxB,YAAYG,SAASqB,EAAST,IAAnC,qBAC/BC,EAAKG,QAAQH,EAAKO,UAAUzL,SAAQ,SAAA0L,GAAQ,OAAI,EAAKxB,YAAYG,SAASqB,EAAST,IAAnC,sBD5xChC,OC6xChBC,EAAKhK,aACP,EAAKgJ,YAAYG,SAASa,EAAKhK,WAAW+J,IAA1C,cAA+D,EAE3DC,EAAKG,SAAQ,EAAKnB,YAAYG,SAASa,EAAKhK,WAAW+J,IAA1C,eAAgE,MAKlFC,EAAKoG,WAAcpG,EAAKe,UAAYf,EAAKkG,qBDryCtB,OCsyCpBlG,EAAKhK,aAELgK,EAAKhK,WAAWkQ,oBAAqB,EACrClG,EAAKhK,WAAWqQ,uBAAwB,MAI5CT,IAEApT,KAAK4M,gBAAkB,OAGzB8C,mBAjbO,WAibc,WACXnE,EAAgBvL,KAAKqL,QAArBE,YACFkJ,EAAQzU,KAAKmQ,uBACbiD,EAAO,WACX,EAAKpE,aACL,EAAKqE,qCAAoC,IAG3C,IAAqB,KAAhB9H,GAAsBvL,KAAK8H,eAAiB2M,EAAMpI,SACrD,OAAO+G,IAGTpT,KAAK0U,oBAAoB,CACvBC,OAAQnP,EACRzF,KAAM,CAAEwL,eACRqJ,UAHuB,WAIrB,OAAOH,EAAMnI,WAEfuI,MAAO,WACLJ,EAAMnI,WAAY,EAClBmI,EAAMpI,UAAW,EACjBoI,EAAMlI,aAAe,IAEvBuI,QAAS,SAAA5K,GACPuK,EAAMpI,UAAW,EACjBoI,EAAMvK,QAAUA,EAGZ,EAAKmB,QAAQE,cAAgBA,GAAa6H,KAEhD2B,KAAM,SAAA1O,GACJoO,EAAMlI,aAAenG,GAAgBC,IAEvC2O,IAAK,WACHP,EAAMnI,WAAY,MAKxB6D,qBAxdO,WAwdgB,WACb5E,EAAgBvL,KAAKqL,QAArBE,YACFkJ,EAAQzU,KAAK6M,aAAatB,IAAlB,SAxzCX,CACLc,UAAU,EACVC,WAAW,EACXC,aAAc,KAqzCE,IAEZrC,QAAS,KAaX,GATAlK,KAAKiV,QACH,kBAAMR,EAAMvK,WACZ,WAEM,EAAKmB,QAAQE,cAAgBA,GAAa,EAAKyD,eAErD,CAAEQ,MAAM,IAGU,KAAhBjE,EAAoB,CACtB,GAAIjC,MAAMiG,QAAQvP,KAAKsI,gBAGrB,OAFAmM,EAAMvK,QAAUlK,KAAKsI,eACrBmM,EAAMpI,UAAW,EACVoI,EACF,IAA4B,IAAxBzU,KAAKsI,eAEd,OADAmM,EAAMpI,UAAW,EACVoI,EAQX,OAJKzU,KAAK6M,aAAatB,IACrBvL,KAAKoR,KAAKpR,KAAK6M,aAActB,EAAakJ,GAGrCA,GAGTjG,aA3fO,SA2fMhB,GACX,OAAOxN,KAAKwM,YAAYC,OAASe,EAAKkG,mBAAqBlG,EAAK0H,YAGlE5G,qCA/fO,SA+f8Bd,GAEnC,QAAIA,EAAKoG,eAELpG,EAAKe,WAAYf,EAAKqG,uBAA0B7T,KAAKyI,yBAGpD+E,EAAKC,aAAcD,EAAKhK,WAAWmQ,2BAK1CwB,uBA3gBO,SA2gBgB3H,GACrB,QAAIxN,KAAKwM,YAAYC,SAAWzM,KAAKsO,qCAAqCd,KAM5E4H,WAlhBO,WAmhBL,OAAOpV,KAAKsS,MAAMC,QAAQ3Q,KAG5ByT,QAthBO,WAuhBL,IACMC,GADMtV,KAAKiH,aAAejH,KAAKsS,MAAMiD,OAAOC,aAAexV,MAC/CsS,MAAM9G,KAAK8G,MAAM9G,KACnC,OAAO8J,GAA4B,aAAnBA,EAAM7R,SAA0B6R,EAAQ,MAG1DG,4BA5hBO,SA4hBqBjI,GAAqB,WAAfkI,IAAe,yDACzCC,EAAO3V,KAAKwL,KAAKE,QAQvB,GAPY,MAARiK,GAAgBA,KAAQ3V,KAAK6L,OAAOE,UACtC/L,KAAK6L,OAAOE,QAAQ4J,GAAMC,eAAgB,GAG5C5V,KAAKwL,KAAKE,QAAU8B,EAAKD,GACzBC,EAAKoI,eAAgB,EAEjB5V,KAAKwL,KAAKC,QAAUiK,EAAQ,CAC9B,IAAMG,EAAiB,WACrB,IAAMP,EAAQ,EAAKD,UACbS,EAAUR,EAAMS,cAAN,2CAAwDvI,EAAKD,GAA7D,OACZuI,GAAS7V,EAAeqV,EAAOQ,IAIjC9V,KAAKqV,UACPQ,IAGA7V,KAAKgW,UAAUH,KAKrBxC,oCAtjBO,WAsjBiD,IAApB4C,EAAoB,wDAC9CvK,EAAY1L,KAAKwL,KAAjBE,SAGNuK,GAAyB,MAAXvK,GACZA,KAAW1L,KAAK6L,OAAOE,SACxB/L,KAAKmV,uBAAuBnV,KAAKkN,QAAQxB,KAE1C1L,KAAKkW,wBAITA,qBAlkBO,WAmkBL,GAAKlW,KAAKyO,kBAAV,CAEA,IAAM0H,EAAQnW,KAAKoO,iBAAiB,GACpCpO,KAAKyV,4BAA4BzV,KAAKkN,QAAQiJ,MAGhDC,oBAzkBO,WA0kBL,GAAKpW,KAAKyO,kBAAV,CAEA,IAAMkH,EAAO3V,KAAKoO,iBAAiB7M,QAAQvB,KAAKwL,KAAKE,SAAW,EAChE,IAAc,IAAViK,EAAa,OAAO3V,KAAKqW,sBAC7BrW,KAAKyV,4BAA4BzV,KAAKkN,QAAQlN,KAAKoO,iBAAiBuH,OAGtEW,oBAjlBO,WAklBL,GAAKtW,KAAKyO,kBAAV,CAEA,IAAM8H,EAAOvW,KAAKoO,iBAAiB7M,QAAQvB,KAAKwL,KAAKE,SAAW,EAChE,GAAI6K,IAASvW,KAAKoO,iBAAiB7L,OAAQ,OAAOvC,KAAKkW,uBACvDlW,KAAKyV,4BAA4BzV,KAAKkN,QAAQlN,KAAKoO,iBAAiBmI,OAGtEF,oBAzlBO,WA0lBL,GAAKrW,KAAKyO,kBAAV,CAEA,IAAM+H,EAAOC,IAAQzW,KAAKoO,kBAC1BpO,KAAKyV,4BAA4BzV,KAAKkN,QAAQsJ,MAGhDE,iBAhmBO,WAimBL1W,KAAKqL,QAAQE,YAAc,IAG7BwD,UApmBO,YAqmBA/O,KAAKwL,KAAKC,SAAYzL,KAAK2I,UAAY3I,KAAKgH,aACjDhH,KAAK2W,yBACL3W,KAAKwL,KAAKC,QAAS,EACnBzL,KAAKkS,yBAAwB,GAC7BlS,KAAK0W,mBACL1W,KAAKkP,MAAM,QAASlP,KAAKmP,WAAYnP,KAAKoP,mBAG5CN,SA7mBO,WA8mBD9O,KAAK2I,UAAY3I,KAAKwL,KAAKC,SAC/BzL,KAAKwL,KAAKC,QAAS,EACnBzL,KAAKgW,UAAUhW,KAAKqT,qCACpBrT,KAAKgW,UAAUhW,KAAK4W,2BACf5W,KAAKkK,SAAYlK,KAAKkH,OAAOlH,KAAK6W,kBACvC7W,KAAKkS,yBAAwB,GAC7BlS,KAAKkP,MAAM,OAAQlP,KAAKoP,mBAG1B0H,WAvnBO,WAwnBD9W,KAAKwL,KAAKC,OACZzL,KAAK+O,YAEL/O,KAAK8O,YAITiI,eA/nBO,SA+nBQvJ,GACb,IAAIwJ,EAEAhX,KAAKwM,YAAYC,QACnBuK,EAAYxJ,EAAKkG,oBAAsBlG,EAAKkG,sBAC7BlG,EAAKmG,yBAA0B,GAE9CqD,EAAYxJ,EAAK0H,YAAc1H,EAAK0H,WAGlC8B,IAAcxJ,EAAKyJ,eAAe5K,UACpCrM,KAAKkX,oBAAoB1J,IAI7B6B,iBA9oBO,WA8oBY,WACXlD,EAAkB9H,IACxBrE,KAAK6L,OAAOI,gBAAgB3J,SAAQ,SAAA6U,GAClChL,EAAgBgL,IAAkB,KAEpCnX,KAAK6L,OAAOM,gBAAkBA,EAE9B,IAAMH,EAAkB3H,IACpBrE,KAAKwJ,WACPxJ,KAAKqO,yBAAwB,SAAAb,GAC3BxB,EAAgBwB,EAAKD,IDthDN,KCyhDjBvN,KAAKgN,cAAc1K,SAAQ,SAAAwL,GACzB9B,EAAgB8B,EAAaP,IDxhDhB,EC0hDR,EAAK1E,MAAS,EAAKH,oBACtBoF,EAAaC,UAAUzL,SAAQ,SAAA8U,GACxB,EAAK1J,WAAW0J,KACnBpL,EAAgBoL,EAAa7J,ID9hDhB,UCoiDvBvN,KAAK6L,OAAOG,gBAAkBA,GAGhCgF,mBA1qBO,SA0qBYN,GACjB,gBACKA,GACA1Q,KAAK4J,WAAW8G,EAAK1Q,KAAKoP,mBAIjCkB,UAjrBO,SAirBG9M,EAAY6T,EAAOjH,GAAa,WACpCtE,EAAoBuL,EACrBpK,KAAI,SAAAO,GAAI,MAAI,CAAE,EAAKwD,mBAAmBxD,GAAOA,MAC7CP,KAAI,WAAgBnH,GAAU,eAAvB0H,EAAuB,KAAjBkD,EAAiB,KAC7B,EAAK4G,iBAAiB9J,GACtB,EAAK+J,gBAAgB/J,GAFQ,IAIrBD,EAA2CC,EAA3CD,GAAIwD,EAAuCvD,EAAvCuD,MAAOnD,EAAgCJ,EAAhCI,SAAU4J,EAAsBhK,EAAtBgK,kBACvB/J,ED1jDc,OC0jDDjK,EACbqC,EAAQ4H,EAAa,EAAIjK,EAAWqC,MAAQ,EAC5C0I,EAAWjF,MAAMiG,QAAQ3B,IAA0B,OAAbA,EACtCD,GAAUY,EACV2C,IAAe1D,EAAK0D,aAAgB,EAAKrI,OAAS4E,GAAcjK,EAAW0N,WAC3EC,IAAU3D,EAAK2D,MACfqD,EAAa,EAAKnL,UAAUoO,QAAO,SAAC9B,EAAM7W,GAAP,gBACpC6W,GADoC,UAEtC7W,GAxhDqBN,EAwhDUgP,EAAK1O,GAvhD1B,iBAAVN,EAA2BA,EACjB,iBAAVA,GAAuB2F,EAAM3F,GAEjC,GAFgDA,EAAQ,IAshDVwV,sBAxhDvD,IAAkCxV,IAyhDpB,IACE8V,EAAoB7G,EACtB+G,EAAWzD,MACXvN,EAAW8Q,kBAAoB,IAAME,EAAWzD,MAE9C2G,EAAa,EAAKtG,KAAK,EAAKvF,OAAOE,QAASwB,EAAIlJ,KAkBtD,GAjBA,EAAK+M,KAAKsG,EAAY,KAAMnK,GAC5B,EAAK6D,KAAKsG,EAAY,QAAS3G,GAC/B,EAAKK,KAAKsG,EAAY,QAAS7R,GAC/B,EAAKuL,KAAKsG,EAAY,YAAajK,EAAa,GAAK,CAAEjK,GAAamU,OAAOnU,EAAWuK,YACtF,EAAKqD,KAAKsG,EAAY,SAAUjK,EAAa,GAAKjK,EAAWsC,OAAO6R,OAAO7R,IAC3E,EAAKsL,KAAKsG,EAAY,aAAclU,GACpC,EAAK4N,KAAKsG,EAAY,aAAclD,GACpC,EAAKpD,KAAKsG,EAAY,oBAAqBpD,GAC3C,EAAKlD,KAAKsG,EAAY,aAAcxG,GACpC,EAAKE,KAAKsG,EAAY,QAASvG,GAC/B,EAAKC,KAAKsG,EAAY,aAAa,GACnC,EAAKtG,KAAKsG,EAAY,iBAAiB,GACvC,EAAKtG,KAAKsG,EAAY,WAAYnJ,GAClC,EAAK6C,KAAKsG,EAAY,SAAU/J,GAChC,EAAKyD,KAAKsG,EAAY,aAAcjK,GACpC,EAAK2D,KAAKsG,EAAY,MAAOhH,GAEzBnC,EAAU,OACNlC,EAAW/C,MAAMiG,QAAQ3B,GAE/B,EAAKwD,KAAKsG,EAAY,iBAAtB,SA1jDH,CACLrL,UAAU,EACVC,WAAW,EACXC,aAAc,KAujDN,IAEEF,cAEF,EAAK+E,KAAKsG,EAAY,aAA2C,kBAAtBF,EACvCA,EACA3R,EAAQ,EAAKuC,oBACjB,EAAKgJ,KAAKsG,EAAY,yBAAyB,GAC/C,EAAKtG,KAAKsG,EAAY,0BAA0B,GAChD,EAAKtG,KAAKsG,EAAY,sBAAsB,GAC5C,EAAKtG,KAAKsG,EAAY,2BAA2B,GACjD,EAAKtG,KAAKsG,EAAY,SAAtB,WDhmDgB,eCimDE,GADlB,MD/lDmB,kBCimDE,GAFrB,MD9lDiB,gBCimDE,GAHnB,MD7lDoB,mBCimDE,GAJtB,IAMA,EAAKtG,KAAKsG,EAAY,WAAYrL,EAC9B,EAAKiE,UAAUoH,EAAY9J,EAAUwC,GACrC,KAEsB,IAAtBoH,GAA4BE,EAAW3J,UAAUzL,SAAQ,SAAA0L,GAC3DA,EAASkH,YAAa,KAGnB7I,GAAwC,mBAArB,EAAKjD,aAKjBiD,GAAYqL,EAAWxC,YACjC,EAAKgC,oBAAoBQ,GALzBlY,GACE,kBAAM,KACN,iBAAM,yFAgBZ,GATAkY,EAAW3J,UAAUzL,SAAQ,SAAA0L,GAAQ,OAAIA,EAAS9E,MAAT,qBACrCyE,GAAQ+J,EAAW3J,UAAUzL,SAAQ,SAAA0L,GAAQ,OAAIA,EAAS9E,MAAT,sBAChDuE,IACHjK,EAAW0F,MAAX,cAAkC,EAC9ByE,IAAQnK,EAAW0F,MAAX,eAAmC,GAC3CgI,IAAY1N,EAAWoU,wBAAyB,IAIlDxH,GAAeA,EAAY7C,GAAK,CAClC,IAAMoI,EAAOvF,EAAY7C,GAEzBmK,EAAW9D,UAAY+B,EAAK/B,UAC5B8D,EAAW/D,wBAA0BgC,EAAKhC,wBAC1C+D,EAAW9B,cAAgBD,EAAKC,cAE5BD,EAAKpH,UAAYmJ,EAAWnJ,WAC9BmJ,EAAWxC,WAAaS,EAAKT,WAC7BwC,EAAWhE,mBAAqBiC,EAAKjC,mBAIjCiC,EAAKsB,eAAe5K,WAAaqL,EAAWT,eAAe5K,SAG7DqL,EAAWxC,YAAa,EAGxBwC,EAAWT,eAAX,MAAiCtB,EAAKsB,iBAK5C,OAAOS,KAGX,GAAI1X,KAAK6H,iBAAkB,CACzB,IAAMgQ,EAAc/L,EAAkBwB,QAAO,SAAAwK,GAAM,OAAIA,EAAOvJ,YACxDwJ,EAAYjM,EAAkBwB,QAAO,SAAAwK,GAAM,OAAIA,EAAOnK,UAC5D7B,EAAoB+L,EAAYF,OAAOI,GAGzC,OAAOjM,GAGT+K,gBA5yBO,WA4yBW,WAChB7W,KAAK0U,oBAAoB,CACvBC,OAAQrP,EACRsP,UAAW,WACT,OAAO,EAAKxI,kBAAkBE,WAEhCuI,MAAO,WACL,EAAKzI,kBAAkBE,WAAY,EACnC,EAAKF,kBAAkBG,aAAe,IAExCuI,QAAS,WACP,EAAK1I,kBAAkBC,UAAW,EAElC,EAAK2J,WAAU,WACb,EAAK3C,qCAAoC,OAG7C0B,KAAM,SAAA1O,GACJ,EAAK+F,kBAAkBG,aAAenG,GAAgBC,IAExD2O,IAAK,WACH,EAAK5I,kBAAkBE,WAAY,MAKzC4K,oBAt0BO,SAs0Ba1T,GAAY,WAItB+J,EAAY/J,EAAZ+J,GAAImD,EAAQlN,EAARkN,IAEZ1Q,KAAK0U,oBAAoB,CACvBC,OAAQpP,EACRxF,KAAM,CAKJyD,WAAYkN,GAEdkE,UAAW,WACT,OAAO,EAAK1H,QAAQK,GAAI0J,eAAe3K,WAEzCuI,MAAO,WACL,EAAK3H,QAAQK,GAAI0J,eAAe3K,WAAY,EAC5C,EAAKY,QAAQK,GAAI0J,eAAe1K,aAAe,IAEjDuI,QAAS,WACP,EAAK5H,QAAQK,GAAI0J,eAAe5K,UAAW,GAE7C0I,KAAM,SAAA1O,GACJ,EAAK6G,QAAQK,GAAI0J,eAAe1K,aAAenG,GAAgBC,IAEjE2O,IAAK,WACH,EAAK9H,QAAQK,GAAI0J,eAAe3K,WAAY,MAKlDoI,oBAx2BO,YAw2BqE,IAAtDC,EAAsD,EAAtDA,OAAQ5U,EAA8C,EAA9CA,KAAM6U,EAAwC,EAAxCA,UAAWC,EAA6B,EAA7BA,MAAOC,EAAsB,EAAtBA,QAASC,EAAa,EAAbA,KAAMC,EAAO,EAAPA,IACnE,GAAKhV,KAAKoJ,cAAewL,IAAzB,CAIAC,IAEA,IAAMjD,EAAWoG,KAAK,SAAC3R,EAAK4R,GACtB5R,EACF0O,EAAK1O,GAELyO,EAAQmD,GAGVjD,OAEIiD,EAASjY,KAAKoJ,YAAL,OACbmE,GAAIvN,KAAKoP,gBACT5I,WAAYxG,KAAKoP,gBACjBuF,UACG5U,GAJU,IAKb6R,cAGEsG,IAAUD,IACZA,EAAOE,MAAK,WACVvG,OACC,SAAAvL,GACDuL,EAASvL,MACR+R,OAAM,SAAA/R,GAEPgS,QAAQC,MAAMjS,QAKpBiR,iBA54BO,SA44BU9J,GAAM,WACrBhO,GACE,mBAASgO,EAAKD,MAAM,EAAK1B,OAAOE,UAAa,EAAKF,OAAOE,QAAQyB,EAAKD,IAAI0D,mBAC1E,iBAAM,iDAA0CsH,KAAKC,UAAUhL,EAAKD,IAA9D,kCACiB,EAAK1B,OAAOE,QAAQyB,EAAKD,IAAIwD,MAD9C,kBAC6DvD,EAAKuD,MADlE,uBAKVwG,gBAp5BO,SAo5BS/J,GACdhO,GACE,wBAA0BiZ,IAAlBjL,EAAKI,WAA4C,IAAlBJ,EAAKe,aAC5C,iBAAM,sIAKVmK,OA55BO,SA45BAlL,GACL,IAAIxN,KAAK2I,WAAY6E,EAAK0D,WAA1B,CAIIlR,KAAKoN,QACPpN,KAAK2Y,QAGP,IAAM3B,EAAYhX,KAAKwJ,WAAaxJ,KAAK6I,KDnyDtB,ICoyDf7I,KAAK6L,OAAOG,gBAAgBwB,EAAKD,KAChCvN,KAAK0N,WAAWF,GAEjBwJ,EACFhX,KAAK4Y,YAAYpL,GAEjBxN,KAAK6Y,cAAcrL,GAGrBxN,KAAKqP,mBAED2H,EACFhX,KAAKkP,MAAM,SAAU1B,EAAKkD,IAAK1Q,KAAKoP,iBAEpCpP,KAAKkP,MAAM,WAAY1B,EAAKkD,IAAK1Q,KAAKoP,iBAGpCpP,KAAKwM,YAAYC,QAAUuK,IAAchX,KAAKoN,QAAUpN,KAAKiI,gBAC/DjI,KAAK0W,mBAGH1W,KAAKoN,QAAUpN,KAAKmI,gBACtBnI,KAAK+O,YAGD/O,KAAKuK,aACPvK,KAAKkQ,eAAgB,MAK3ByI,MAr8BO,WAq8BC,WACF3Y,KAAKmO,WACHnO,KAAKoN,QAAUpN,KAAK4G,sBACtB5G,KAAK6L,OAAOI,gBAAkB,GAE9BjM,KAAK6L,OAAOI,gBAAkBjM,KAAK6L,OAAOI,gBAAgBqB,QAAO,SAAAqD,GAAM,OACrE,EAAKzD,QAAQyD,GAAQO,cAIzBlR,KAAKqP,qBAKTuJ,YAp9BO,SAo9BKpL,GAAM,WAChB,GAAIxN,KAAKoN,QAAUpN,KAAK0I,mBACtB,OAAO1I,KAAK8Y,SAAStL,GAGvB,GAAIxN,KAAK6I,KAaP,OAZA7I,KAAK8Y,SAAStL,QAEVxN,KAAKuH,oBACPiG,EAAKO,UAAUzL,SAAQ,SAAA0L,GAChB,EAAKN,WAAWM,IAAcA,EAASkD,YAAY,EAAK4H,SAAS9K,MAE/DhO,KAAKwH,uBACdxH,KAAKwR,uBAAuBhE,GAAM,SAAAiE,GAC3B,EAAK/D,WAAW+D,IAAgBA,EAAWP,YAAY,EAAK4H,SAASrH,OAOhF,IAAMsH,EACJvL,EAAKG,SACmBH,EAAKoK,wBACN5X,KAAK+G,kCAc9B,GAZIgS,GACF/Y,KAAK8Y,SAAStL,GAGZA,EAAKe,UACPvO,KAAKwR,uBAAuBhE,GAAM,SAAAiE,GAC3BA,EAAWP,aAAc,EAAKnK,mCACjC,EAAK+R,SAASrH,MAKhBsH,EAEF,IADA,IAAIC,EAAOxL,ED53DW,QC63DdwL,EAAOA,EAAKxV,aACdwV,EAAKpL,SAASwG,MAAMpU,KAAK0N,aAAa1N,KAAK8Y,SAASE,IAO9DH,cApgCO,SAogCOrL,GAAM,WAClB,GAAIxN,KAAK0I,mBACP,OAAO1I,KAAKiZ,YAAYzL,GAG1B,GAAIxN,KAAK6I,KAaP,OAZA7I,KAAKiZ,YAAYzL,QAEbxN,KAAKqH,sBACPmG,EAAKO,UAAUzL,SAAQ,SAAA0L,GACjB,EAAKN,WAAWM,KAAcA,EAASkD,YAAY,EAAK+H,YAAYjL,MAEjEhO,KAAKsH,yBACdtH,KAAKwR,uBAAuBhE,GAAM,SAAAiE,GAC5B,EAAK/D,WAAW+D,KAAgBA,EAAWP,YAAY,EAAK+H,YAAYxH,OAOlF,IAAIyH,GAA8B,EAUlC,GATI1L,EAAKe,UACPvO,KAAK8R,uBAAuBtE,GAAM,SAAAiE,GAC3BA,EAAWP,aAAc,EAAKnK,oCACjC,EAAKkS,YAAYxH,GACjByH,GAA8B,MAMlC1L,EAAKG,QACiBuL,GACyB,IAAzB1L,EAAKI,SAASrL,OACpC,CACAvC,KAAKiZ,YAAYzL,GAGjB,IADA,IAAIwL,EAAOxL,ED36DW,QC46DdwL,EAAOA,EAAKxV,aACdxD,KAAK0N,WAAWsL,IAAOhZ,KAAKiZ,YAAYD,KAMlDF,SAljCO,SAkjCEtL,GACPxN,KAAK6L,OAAOI,gBAAgB7J,KAAKoL,EAAKD,IACtCvN,KAAK6L,OAAOM,gBAAgBqB,EAAKD,KAAM,GAGzC0L,YAvjCO,SAujCKzL,GACVrM,EAAgBnB,KAAK6L,OAAOI,gBAAiBuB,EAAKD,WAC3CvN,KAAK6L,OAAOM,gBAAgBqB,EAAKD,KAG1C4L,gBA5jCO,WA6jCL,GAAKnZ,KAAKmO,SAAV,CACA,GAAInO,KAAKoN,OAAQ,OAAOpN,KAAK2Y,QAC7B,IAAMS,EAAY3C,IAAQzW,KAAKmN,eACzBkM,EAAmBrZ,KAAKkN,QAAQkM,GACtCpZ,KAAK0Y,OAAOW,KAGd1C,uBApkCO,WAqkCL,IAAMrB,EAAQtV,KAAKqV,UAEfC,IAAOtV,KAAKwL,KAAKG,mBAAqB2J,EAAM5U,YAGlDkW,0BA1kCO,WA2kCL,IAAMtB,EAAQtV,KAAKqV,UAEfC,IAAOA,EAAM5U,UAAYV,KAAKwL,KAAKG,sBAI3C2N,QAr5Da,WAs5DXtZ,KAAK+P,cACL/P,KAAKiQ,cAGPsJ,QA15Da,WA25DPvZ,KAAKmH,WAAWnH,KAAK0S,aACpB1S,KAAKkK,SAAYlK,KAAKkH,QAASlH,KAAKoH,qBAAqBpH,KAAK6W,kBAC/D7W,KAAKgH,YAAYhH,KAAK8O,WACtB9O,KAAKkH,OAASlH,KAAKsI,gBAAgBtI,KAAK0P,sBAG9C8J,UAj6Da,WAm6DXxZ,KAAKkS,yBAAwB,KC99DjC,eACE,MAAF,qBAEA,cAEA,GAFA,kBCAe,SAASuH,GACtBC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,GAGA,IAqBIC,EArBAhQ,EAAmC,mBAAlBwP,EACjBA,EAAcxP,QACdwP,EAsDJ,GAnDIC,IACFzP,EAAQyP,OAASA,EACjBzP,EAAQ0P,gBAAkBA,EAC1B1P,EAAQiQ,WAAY,GAIlBN,IACF3P,EAAQkQ,YAAa,GAInBL,IACF7P,EAAQmQ,SAAW,UAAYN,GAI7BC,GACFE,EAAO,SAAUI,IAEfA,EACEA,GACCta,KAAKua,QAAUva,KAAKua,OAAOC,YAC3Bxa,KAAKya,QAAUza,KAAKya,OAAOF,QAAUva,KAAKya,OAAOF,OAAOC,aAEZ,oBAAxBE,sBACrBJ,EAAUI,qBAGRZ,GACFA,EAAapc,KAAKsC,KAAMsa,GAGtBA,GAAWA,EAAQK,uBACrBL,EAAQK,sBAAsBC,IAAIZ,IAKtC9P,EAAQ2Q,aAAeX,GACdJ,IACTI,EAAOD,EACH,WACAH,EAAapc,KACXsC,MACCkK,EAAQkQ,WAAapa,KAAKya,OAASza,MAAM8a,MAAMC,SAASC,aAG3DlB,GAGFI,EACF,GAAIhQ,EAAQkQ,WAAY,CAGtBlQ,EAAQ+Q,cAAgBf,EAExB,IAAIgB,EAAiBhR,EAAQyP,OAC7BzP,EAAQyP,OAAS,SAAmCwB,EAAGb,GAErD,OADAJ,EAAKxc,KAAK4c,GACHY,EAAeC,EAAGb,QAEtB,CAEL,IAAIc,EAAWlR,EAAQmR,aACvBnR,EAAQmR,aAAeD,EACnB,GAAGzD,OAAOyD,EAAUlB,GACpB,CAACA,GAIT,MAAO,CACL7c,QAASqc,EACTxP,QAASA,GCxFb,IAAIoR,GAAY,GFIhB,CACE,KAAF,gCACE,OAAF,aACE,YAAF,EAEE,OALF,SAKA,KAAI,IAAJ,eACA,wBAEI,IAAJ,4CAEI,IAAJ,0BAMI,OAJJ,8BACA,sBAGA,qBAAM,OACN,WAAQ,MAAR,eACUxd,KAAV,QADQ,SAAR,OAEA,GACQ,IAAR,8BE/BI,OAAQ8b,GAWV,EACA,KACA,KACA,MAkBF0B,GAAUpR,QAAQqR,OAAS,kCACZ,OAAAD,G,2BC7Bf,IACA,EACA,EACA,EACA,GACA,GACA,GACA,ICJI,GAAY,GDOhB,CACE,KAAF,wBACE,OAAF,aAEE,KAAF,WAAI,MAAJ,CACME,WL6ByB,EK5BzBhd,MAAO,KAGX,SAAF,CACI,aADJ,WACM,IACN,gBAEM,OACN,eACA,YACA,YAII,WAXJ,WAYM,MAAN,CACQ,MAAR,0DAKE,MAAF,CACI,+BADJ,SACA,GACM,KAAN,SAGI,MALJ,WAOA,2DAIE,QAtCF,WAuCI,KAAJ,sBACA,uBLP+B,IKS/B,CAAM,SAAN,EAAM,UAAN,KAIE,QAAF,CACI,MADJ,WAEM,KAAN,SACQ,OAAR,CAAU,MAAV,OAII,MAPJ,WAQA,cAEA,UACQ,KAAR,uCAII,KAfJ,WAgBM,KAAN,sCAGI,QAnBJ,WAmBM,IACN,gBAEM,EAAN,qBAEA,6BAGI,OA3BJ,WA2BM,IACN,gBACA,cAIM,GAAN,8BACQ,OAAR,aAGM,EAAN,qBACM,EAAN,aAGI,QAzCJ,SAyCA,GAAM,IACN,iBAEM,KAAN,QAEA,EACQ,KAAR,qBAEQ,KAAR,2BACQ,KAAR,sBAKI,UAvDJ,SAuDA,GAAM,IACN,gBAGA,gCAEM,KAAN,4CAAM,CAGA,IAAN,uBAEQ,OADA,EAAR,iBACA,aAGM,OAAN,GACQ,KAAKiH,EACb,wCACA,oBAEA,MAEQ,KAAKA,EAEb,GADA,mBACA,6BACA,gCACA,2CACA,YACA,MAEQ,KAAKA,EACb,kBACA,aACA,eACA,cAEA,MAEQ,KAAKA,EACb,mBACA,wBACA,MAEQ,KAAKA,EACb,mBACA,yBACA,MAEQ,KAAKA,GACb,gCACA,+BACA,mBACA,sBACA,2DACA,mBACA,6CAEA,MAEQ,KAAKA,GACb,mBACA,wBACA,MAEQ,KAAKA,GACb,gCACA,iCACA,mBACA,qBAEA,MAEQ,KAAKA,GACb,mBACA,wBACA,MAEQ,KAAKA,GACb,qCACA,oBAEA,MAEQ,QAER,gBAKI,YAhJJ,SAgJA,GAEA,mBAGQ,EAAR,mBAII,qBAzJJ,WAyJM,IAAN,sBACA,gBACA,KACA,KA0BM,OAxBN,4BACQ,EAAR,yBACA,+CAGA,cACQ,EAAR,GACU,GAAV,CACY,MAAZ,aACY,KAAZ,YACY,QAAZ,gBAEU,IAAV,UAIA,0BACQ,EAAR,GACU,MAAV,CACY,SAAZ,cAMA,eAAQ,MAAR,wCACA,KAKI,YA7LJ,WA6LM,IAAN,sBACA,gBAEM,OACN,WAAQ,IAAR,QACQ,MAAR,wBADQ,MAAR,CAEU,KAAV,OACU,aAAV,MACU,SAAV,WACU,SAAV,yBALQ,SAAR,CAAU,MAMV,YACQ,MAAR,gBAPQ,GAAR,CAAU,MAQV,aARU,MASV,aATU,KAUV,YAVU,QAWV,eAXU,UAYV,qBAKI,YAlNJ,WAmNM,OACN,EAFA,qBAEA,OAAQ,IAAR,QAAQ,MAAR,wCAII,iBAxNJ,WAyNM,KAAN,oBLrO+B,EKuO/B,kCAII,kBA/NJ,WAgOA,cAEA,iCAIE,OApRF,WAqRI,OAAJ,mCCnSI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUyE,QAAQqR,OAAS,2BACZ,U,QC1BX,GAAY,GCNhB,CACE,KAAF,8BACE,OAAF,aAEE,OAJF,WAII,IAAJ,eACA,gBACA,GACM,+BAAN,EACM,yCAAN,EACM,6BAAN,mCAGI,OACJ,SAAM,MAAN,IACA,uBDfI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,iCACZ,U,QE1BX,GAAY,GCHhB,CACE,KAAF,+BACE,OAAF,aACE,QAAF,CACI,uBADJ,WACM,IACN,gBACA,qBAEA,gCACM,OAAN,EACA,GAAQ,KAAR,IACA,UAGE,OAdF,WAcI,IAAJ,eACA,oDACA,qCAEI,OAAJ,GACA,GACA,SAAM,MAAN,iCACA,gCAGA,MACA,MAAM,IAAN,mBD7BI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,iCACZ,U,QEjCX,GAAS,WACX,IACIE,EADMzb,KACG0b,eACTC,EAFM3b,KAEG4b,MAAMD,IAAMF,EACzB,OAAOE,EACL,MACA,CACEE,MAAO,CACLC,MAAO,6BACPC,QAAS,wBAGb,CACEJ,EAAG,OAAQ,CACTE,MAAO,CACLhe,EACE,4gBAOZ,GAAOme,eAAgB,EChBvB,ICAI,GAAY,GDAhB,CACE,KAAF,qBCCE,GFaoB,IEXpB,EACA,KACA,KACA,MAuBF,GAAU9R,QAAQqR,OAAS,kCACZ,U,QC/BX,GAAY,GCHhB,CACE,KAAF,mCACE,OAAF,aAEE,MAAF,CACI,KAAJ,CACM,KAAN,OACM,UAAN,IAIE,QAAF,CACI,gBAAJ,cAAM,IACN,4BAGM,EAAN,cAIE,OApBF,WAoBI,IAAJ,eACA,4BACA,GACM,oCAAN,EACM,4CAAN,aACM,uCAAN,SAEA,gCACA,OAAM,KAAN,YAEI,OACJ,SAAM,MAAN,+CACA,SAAM,MAAN,EAAM,GAAN,CAAQ,UAAR,wBACA,UAAM,MAAN,0CACA,UAAM,MAAN,yEDtCI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,oCACZ,U,QE1BX,GAAY,GCFhB,CACE,KAAF,8BACE,OAAF,aAEE,QAAF,CACI,sBADJ,WACM,IAAN,sBACA,gBAEM,OAAN,gBACA,iBACA,eACA,iBAAQ,OACR,MAAU,IAAV,iCAAU,MAAV,CAAY,KAAZ,SAII,qBAZJ,WAYM,IAAN,sBACA,gBACA,iCAEM,OAAN,UAGA,SAAQ,MAAR,kEAAQ,IAAR,qBACA,UAAQ,MAAR,wDAME,OA9BF,WA8BI,IAAJ,eACA,oCACA,GACM,MAAN,CACQ,IAAR,MACQ,KAAR,+CACQ,QAAR,IAII,OAAJ,EACA,4BAAM,MAAN,oCACA,6BACA,4BACA,MAAM,IAAN,gBACA,MAAM,IAAN,QAAM,IAAN,oBDlDI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,gCACZ,U,QEjCX,GAAS,WACX,IACIE,EADMzb,KACG0b,eACTC,EAFM3b,KAEG4b,MAAMD,IAAMF,EACzB,OAAOE,EACL,MACA,CACEE,MAAO,CACLC,MAAO,6BACPC,QAAS,wBAGb,CACEJ,EAAG,OAAQ,CACTE,MAAO,CACLhe,EACE,wUAOZ,GAAOme,eAAgB,EChBvB,ICAI,GAAY,GDAhB,CACE,KAAF,yBCCE,GFaoB,IEXpB,EACA,KACA,KACA,MAuBF,GAAU9R,QAAQqR,OAAS,iCACZ,U,QC/BX,GAAY,GCAhB,CACE,KAAF,0BACE,OAAF,aAEE,SAAF,CAMI,YANJ,WAMM,IACN,gBAEM,OACN,cACA,YACA,aACA,mDAQI,gBArBJ,WAqBM,IACN,gBAEM,OAAN,eAGA,eAOI,mBAlCJ,WAkCM,IACN,gBAEM,OACN,YACA,kCAAQ,OAAR,6BAME,QAAF,CACI,QADJ,WACM,IAAN,sBACA,gBACA,6CAEM,OAAN,iBAGA,SAAQ,MAAR,8BAAQ,MAAR,CAAU,MAAV,GAAQ,GAAR,CAAU,UAAV,2BACA,MAAQ,MAAR,wBAJA,MASI,YAdJ,WAcM,IAAN,sBAEA,GACQ,iCAAR,EACQ,yCAHR,cAGA,aAGM,OAAN,qBAGA,SAAQ,MAAR,0CAAQ,GAAR,CAAU,UAAV,+BACA,MAAQ,MAAR,MAJA,MASI,mBAAJ,eAUM,EAAN,kBACM,EAAN,iBAXM,IAaN,gBACA,qBACA,cACA,cAGA,OAEQ,EAAR,QAGQ,YAAR,WAAU,OAAV,aAQI,uBAAJ,eACM,EAAN,iBACM,EAAN,kBAFM,IAIN,gBAGM,EAAN,aACM,EAAN,gBAII,qBA1EJ,SA0EA,GACM,OACN,EAFA,qBAEA,OAAQ,MAAR,oCACA,MAME,OApIF,WAoII,IAAJ,eACA,gBACA,iBAEI,OACJ,SAAM,MAAN,0BAAM,GAAN,CAAQ,UAAR,qBACA,KAAM,IAAN,oBACA,eACA,4BDnJI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,6BACZ,U,QE1BX,GAAY,GCNhB,CACE,KAAF,sBACE,YAAF,EAEE,MAAF,CACI,KAAJ,CACM,KAAN,OACM,UAAN,GAEI,KAAJ,CACM,KAAN,OACM,UAAN,IAIE,OAfF,SAeA,KAAI,IAAJ,eACA,uBAEI,OACJ,SAAM,MAAN,+DACA,SAAM,MAAN,mCACA,UAAM,MAAN,2CAEA,UAAM,MAAN,yEACA,aDzBI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,yBACZ,IE3Bf,SF2Be,M,QEzBf,IACE,KAAF,yBACE,OAAF,aAEE,MAAF,CACI,KAAJ,CACM,KAAN,OACM,UAAN,IAIE,SAAF,CACI,aADJ,WACM,IACN,4BAEM,OAAN,+BAGI,WAPJ,WAOM,IACN,4BAEM,OAAN,8BAIE,QAAF,CACI,aADJ,WACM,IAAN,sBACA,4BAUM,OACN,SAAQ,MAVR,CACQ,0BAAR,EACQ,mCAAR,aACQ,mCAAR,gBACQ,oCAAR,gBACQ,kCAAR,kCACQ,gCAAR,iBAIQ,GAAR,CAAU,WAAV,6BAAQ,MAAR,CAAU,UAAV,QACA,mBACA,2BACA,8BACA,wBAEA,wBAMI,qBAzBJ,WAyBM,IAAN,sBACM,OAAN,kBAGA,SAAQ,MAAR,yBACA,wBACA,2BACA,gCACA,uCAPA,MAYI,YAtCJ,WAsCM,IAAN,sBACA,4BAEM,GAAN,oDAEM,GAAN,YACQ,IAMR,GACU,gCAAV,EACU,wCAAV,mBAGQ,OACR,SAAU,MAAV,yCAAU,GAAV,CAAY,UAAZ,+BACA,eAbA,CACU,MAAV,CACY,KAAZ,wCACY,QAAZ,IAUA,CACA,MAAU,MAAV,QASM,OAAN,kBACA,QACA,SAAU,MAAV,oDAGA,IAGA,MAGI,qBA9EJ,SA8EA,GACM,OACN,EAFA,qBAEA,OAAQ,MAAR,kCAAQ,GAAR,CAAU,UAAV,wCACA,KAKI,wBAtFJ,SAsFA,GAAM,IAAN,sBACA,4BAEM,OAAN,UACA,iCADA,KAIA,SAAQ,MAAR,uCACA,KAKI,eAnGJ,WAmGM,IAAN,sBACA,4BACA,iCACA,GACQ,4BAAR,EACQ,oCzBnIe,IyBmIvB,EACQ,0CzBrIqB,IyBqI7B,EACQ,sCzBvIiB,IyBuIzB,EACQ,qCAAR,cAUM,OAPN,QACA,UAAQ,MAAR,gCAEA,QACA,UAAQ,MAAR,gCAIA,UAAQ,MAAR,IACA,GACA,MAKI,YA7HJ,WA6HM,IAAN,sBACA,4BACA,EACA,kCACA,4BACA,aAGA,IACA,qBACA,4CACA,uBACA,IAGA,iCAEM,OAAN,KACQ,KAAR,EACQ,gBAAR,EACQ,MAAR,EACQ,eARR,wBASQ,eARR,0BAYA,WAAQ,MAbR,yBAaA,CACA,QACA,GACA,UAAQ,MAfR,yBAeA,gBAMI,iBAhKJ,WAgKM,IAAN,sBACA,YAEM,OAAN,0BAEA,4BAAQ,OACR,MAAU,MAAV,SAAU,IAAV,UAHA,MAOI,oBA1KJ,WA0KM,IAAN,sBACA,4BAEM,OAAN,kDAGA,MAAQ,MAAR,CAAU,KAAV,cAAU,KAAV,iCAII,yBApLJ,WAoLM,IAAN,sBACA,gBAEM,OAFN,UAEA,yBAGA,MAAQ,MAAR,CAAU,KAAV,UAAU,KAAV,4BAHA,MAOI,8BA9LJ,WA8LM,IAAN,sBACA,4BAEM,OAAN,8BAGA,MAAQ,MAAR,CAAU,KAAV,QAAU,KAAV,WACA,8BACA,OAAQ,MAAR,wBAAQ,MAAR,CAAU,MAAV,cAAQ,GAAR,CAAU,UAAV,+BACA,gBANA,MAYI,uBA7MJ,SA6MA,GAAM,IACN,4BAIA,4BAEM,EAAN,mCAGI,uBAAJ,cAAM,IACN,4BAEM,EAAN,qBAGI,gCAAJ,cAAM,IACN,4BAEA,iCACQ,EAAR,kBAEQ,EAAR,aAII,uBAAJ,cAAM,IACN,4BAEM,EAAN,2BAIE,OAvQF,WAuQI,IAAJ,eACA,YACA,+CACA,OACM,6BAAN,GADA,uCAEA,OAEA,GACM,MAAN,CACQ,KAAR,qCAII,OACJ,SAAM,MAAN,IACA,oBACA,YACA,kBACA,kCC1RI,GAAY,GDmShB,QC1SI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,4BACZ,U,QC3Bf,IACE,IAAF,MACE,OAAF,SACE,MAAF,MACE,MAAF,UCHI,GAAY,GDMhB,CACE,KAAF,uBACE,OAAF,aAEE,SAAF,CACI,UADJ,WAIM,MAAN,CACQ,UAHR,cAGA,iBAII,mBATJ,WASM,IACN,gBAEM,MAAN,CACQ,OAAR,gCAKE,MAAF,CACI,uBADJ,SACA,GACA,EAEQ,KAAR,2BAEQ,KAAR,gBAKE,QAjCF,WAkCI,KAAJ,qBACI,KAAJ,wCAGE,QAtCF,WAuCA,cAEA,8CAGE,UA5CF,WA6CI,KAAJ,eAGE,QAAF,CACI,WADJ,WACM,IAAN,sBACA,gBAEM,OAAN,cAGA,SAAQ,IAAR,OAAQ,MAAR,uBAAQ,GAAR,CAAU,UAAV,mBAAQ,MAAR,iBACA,wBACA,QACA,kCACA,qBACA,kCACA,6BACA,yBAVA,MAeI,iBAnBJ,WAmBM,IAEN,EADA,cACA,4BAEM,OAAN,EACA,IACA,MAGI,gBA5BJ,WA4BM,IAEN,EADA,cACA,2BAEM,OAAN,EACA,IACA,MAGI,sBArCJ,WAqCM,IACN,gBAEM,OAAN,8BACA,+BACA,iCACA,wCACA,oEACA,mCAEA,yBAII,2BAnDJ,WAmDM,IACN,gBAEM,OAAN,8BACA,+BACA,iCACA,wCACA,oEACA,mCACA,wBACA,0BAEA,yBAII,2BAnEJ,WAmEM,IACN,gBACA,2BACA,gDACA,OAEA,kCAEM,OAAN,EACA,6BACA,YACA,+BACA,eACA,wCACA,EACA,0BAEA,yBAII,iBAxFJ,WAwFM,IAAN,sBACA,gBAEM,OACN,SAAQ,MAAR,yBACA,4CAAQ,OACR,MAAU,MAAV,CAAY,KAAZ,GAAU,IAAV,aAMI,sBApGJ,WAoGM,IAAN,sBACA,gBAEM,OACN,MAAQ,MAAR,CAAU,KAAV,gBAAU,KAAV,mCAII,wBA5GJ,WA4GM,IAAN,sBACA,gBAEM,OACN,MAAQ,MAAR,CAAU,KAAV,UAAU,KAAV,6BAII,iCApHJ,WAoHM,IAAN,sBACA,gBAEM,OACN,MAAQ,MAAR,CAAU,KAAV,QAAU,KAAV,WACA,iCACA,OAAQ,MAAR,wBAAQ,GAAR,CAAU,MAAV,mBAAQ,MAAR,CAAU,MAAV,gBACA,iBAMI,iCAjIJ,WAiIM,IAAN,sBACA,gBACA,2BAIM,OACN,MAAQ,MAAR,CAAU,KAAV,QAAU,KAAV,WACA,eACA,OAAQ,MAAR,wBAAQ,GAAR,CAAU,MAAV,sBAAQ,MAAR,CAAU,MAAV,gBACA,iBAMI,4BAjJJ,WAiJM,IAAN,sBACA,gBAEM,OACN,MAAQ,MAAR,CAAU,KAAV,aAAU,KAAV,gCAII,mBAzJJ,WAyJM,IAAN,sBACA,gBAEM,OACN,MAAQ,MAAR,CAAU,KAAV,aAAU,KAAV,gCAII,WAjKJ,WAkKM,KAAN,0BACM,KAAN,uBACM,KAAN,0CAGI,YAvKJ,WAwKM,KAAN,wBACM,KAAN,2CAGI,wBA5KJ,WA4KM,IACN,gBACM,GAAN,cAAM,CAEA,IAAN,cACA,iBACA,4BACA,4BACA,WACA,qBACA,QAMA,EALA,4BAKA,E3BxM2B,G2ByM3B,M3BzM2B,G2BqM3B,oBACA,oBAOA,yBACQ,EAAR,mCAEQ,EAAR,eADA,MACA,SAEA,MANQ,EAAR,cAUI,qBA1MJ,WA0MM,IAEN,EADA,cACA,UAGA,uBAEM,KAAN,iBACQ,OAAR,qCAII,uCAtNJ,WAsNM,IAEN,EADA,cACA,aAGA,yCAEM,KAAN,mCACQ,OAAR,qCAII,sBAlOJ,WAmOA,uBAEM,KAAN,yBACM,KAAN,uBAGI,wCAzOJ,WA0OA,yCAEM,KAAN,2CACM,KAAN,0CAIE,OAjSF,WAiSI,IAAJ,eACI,OACJ,SAAM,IAAN,iBAAM,MAAN,iCAAM,MAAN,0BACA,gBAAM,MAAN,CAAQ,KAAR,sCACA,6BClTI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,0BACZ,U,2PC5Bf,IA+HA,GA/HA,IACE,KAAF,gCACE,OAAF,aAEE,MAAF,CACI,uBADJ,SACA,GACA,EACQ,KAAR,gBAEQ,KAAR,kBAII,0BATJ,WAUM,KAAN,8BAIE,QAlBF,WAmBI,KAAJ,0CACI,KAAJ,yBAGE,QAvBF,WAwBA,cAEA,mCAGE,QAAF,CACI,cADJ,WAEM,KAAN,cACM,KAAN,4BACM,KAAN,4CACM,KAAN,2BAGI,eARJ,WASM,KAAN,6CACM,KAAN,4BAGI,0CAbJ,WAaM,IAEN,EADA,cACA,aAGA,4CAEM,KAAN,sCACQ,OAAR,uCAII,wBAzBJ,WAyBM,IAAN,OAEA,EADA,cACA,aAGA,0BAEM,KAAN,oBACQ,OAAR,gBACU,EAAV,cACU,EAAV,kCAKI,2CAxCJ,WAyCA,4CAEM,KAAN,8CACM,KAAN,4CAGI,yBA/CJ,WAgDA,0BAEM,KAAN,4BACM,KAAN,0BAGI,YAtDJ,WAsDM,IACN,gBACA,WAEA,EADA,eACA,wBAEM,EAAN,0BAGI,0BA/DJ,WA+DM,IACN,gBACA,iBACA,WACA,4BACA,4BACA,yCACA,iCACA,iCACA,8CAEA,EADA,8DACA,YAAQ,OAAR,6BAGA,4CAIE,OA9GF,WA8GI,IAAJ,eACA,gBACA,mDACA,GAAM,OAAN,UAEI,OACJ,SAAM,MAAN,EAAM,MAAN,EAAM,MAAN,CAAQ,mBAAR,qBACA,MAAM,IAAN,YAKE,UA1HF,WA2HI,KAAJ,mBCzHI,GAAY,GD+HhB,CACE,KAAF,8BAEE,QAHF,WAII,KAAJ,mBAGE,QAPF,WAQI,KAAJ,SAGE,UAXF,WAYI,KAAJ,YAGE,QAAF,CACI,MADJ,WAEM,IAAN,gCACM,SAAN,oBAEM,KAAN,sB,mWAAA,EACQ,GAAR,EACQ,OAAR,MACA,MAII,SAZJ,WAaM,SAAN,wCACM,KAAN,8BAEM,KAAN,wBACM,KAAN,oBAIE,OApCF,WAoCI,IAAJ,eAKI,OAJJ,QACA,SAAM,MAAN,sCAGA,UC/KI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,gCACZ,U,QC1BX,GAAY,GCAhB,CACE,KAAF,iBACE,OAAF,KAEE,SAAF,CACI,aADJ,WAEM,MAAN,CACQ,kBAAR,EACQ,yBAAR,YACQ,wBAAR,cACQ,6BAAR,gBACQ,2BAAR,cACQ,0BAAR,uBACQ,4BAAR,cACQ,uBAAR,iBACQ,6BAAR,4BACQ,6BAAR,+BACQ,wCAAR,wBACQ,iCAAR,qBAKE,OAvBF,WAuBI,IAAJ,eACI,OACJ,SAAM,IAAN,UAAM,MAAN,oBACA,MACA,MAAM,IAAN,YACA,wBAAM,IAAN,iBAAM,IAAN,kBDnCI,OAAQ,GAWV,EACA,KACA,KACA,MAkBF,GAAUrR,QAAQqR,OAAS,gCACZ,U,QEpBFU,I,MATEC,aASQC","file":"vue-treeselect.cjs.min.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/defineProperty\");","module.exports = require(\"babel-helper-vue-jsx-merge-props\");","module.exports = require(\"@babel/runtime/helpers/toConsumableArray\");","module.exports = require(\"lodash/noop\");","module.exports = require(\"lodash/debounce\");","module.exports = require(\"is-promise\");","module.exports = require(\"lodash/once\");","module.exports = require(\"lodash/identity\");","module.exports = require(\"lodash/constant\");","module.exports = require(\"lodash/last\");","module.exports = require(\"@babel/runtime/helpers/slicedToArray\");","module.exports = require(\"fuzzysearch\");","module.exports = require(\"watch-size\");","module.exports = require(\"@babel/runtime/helpers/typeof\");","module.exports = require(\"vue\");","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","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 index c84d2a6c..5a49be59 100644 --- a/dist/vue-treeselect.css +++ b/dist/vue-treeselect.css @@ -1,5 +1,5 @@ /*! - * vue-treeselect v0.4.0 | (c) 2017-2020 Riophae Lee + * vue-treeselect v0.4.0 | (c) 2017-2021 Riophae Lee * Released under the MIT License. * https://vue-treeselect.js.org/ */ diff --git a/dist/vue-treeselect.min.css b/dist/vue-treeselect.min.css index 85a02786..fa28e14f 100644 --- a/dist/vue-treeselect.min.css +++ b/dist/vue-treeselect.min.css @@ -1,5 +1,5 @@ /*! - * vue-treeselect v0.4.0 | (c) 2017-2020 Riophae Lee + * vue-treeselect v0.4.0 | (c) 2017-2021 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 index a0088004..e33f8f16 100644 --- a/dist/vue-treeselect.umd.js +++ b/dist/vue-treeselect.umd.js @@ -1,5 +1,5 @@ /*! - * vue-treeselect v0.4.0 | (c) 2017-2020 Riophae Lee + * vue-treeselect v0.4.0 | (c) 2017-2021 Riophae Lee * Released under the MIT License. * https://vue-treeselect.js.org/ */ @@ -2021,7 +2021,8 @@ var instanceId = 0; countMap: createMap() }, lastSearchInput: null, - remoteSearch: createMap() + remoteSearch: createMap(), + hasBranchNodes: null }; }, computed: { @@ -2104,11 +2105,6 @@ var instanceId = 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; } @@ -2201,9 +2197,9 @@ var instanceId = 0; this._blurOnSelect = false; }, initialize: function initialize() { - var options = this.async ? this.getRemoteSearchEntry().options : this.options.filter(function (o) { + var options = this.async ? this.getRemoteSearchEntry().options : this.options ? this.options.filter(function (o) { return o; - }); + }) : {}; if (Array.isArray(options)) { var prevNodeMap = this.forest.nodeMap; @@ -2214,6 +2210,10 @@ var instanceId = 0; } else { this.forest.normalizedOptions = []; } + + this.hasBranchNodes = this.forest.normalizedOptions.some(function (rootNode) { + return rootNode.isBranch; + }); }, getInstanceId: function getInstanceId() { return this.instanceId == null ? this.id : this.instanceId; diff --git a/dist/vue-treeselect.umd.js.map b/dist/vue-treeselect.umd.js.map index 472e4d19..1241857a 100644 --- a/dist/vue-treeselect.umd.js.map +++ b/dist/vue-treeselect.umd.js.map @@ -1 +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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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iB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK+P,eAAL;AAC9D,QAAI,KAAKnQ,UAAT,EAAqB,KAAK+H,QAAL;AACrB,QAAI,KAAK7H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKsH,kBAAL;AACxC,GA/5DY;AAi6Db8J,WAj6Da,uBAi6DD;AAEV,SAAKpH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;A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AAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,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ACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.filter(o => o)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","remoteSearch","hasBranchNodes","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","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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L,UAAL;AACpB,QAAI,CAAC,KAAKzI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK+P,eAAL;AAC9D,QAAI,KAAKnQ,UAAT,EAAqB,KAAK6H,QAAL;AACrB,QAAI,KAAK3H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKoH,kBAAL;AACxC,GA/5DY;AAi6DbgK,WAj6Da,uBAi6DD;AAEV,SAAKpH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;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A;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,oBAYf;AACD,iBAAS;AACM,6DAAS,Q;;AChCxB;AACA,6BADA;AAEA,kBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA,KADA;AAKA;AACA,kBADA;AAEA;AAFA;AALA,GAJA;AAeA,QAfA,kBAeA,CAfA,EAeA,OAfA,EAeA;AAAA;AAAA,QACA,KADA,GACA,OADA,CACA,KADA;AAAA,QACA,QADA,GACA,OADA,CACA,QADA;AAGA,WACA;AAAA;AAAA,QACA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA,EAIA;AAAA;AAAA,QACA,QADA,EAJA,EADA;AAUA;AA5BA,G;;ACD+M,CAAgB,sGAAG,EAAC,C;;ACAnO,IAAI,UAAM,EAAE,mBAAe;AAC4B;AACL;;;AAGlD;AAC0F;AAC1F,IAAI,aAAS,GAAG,kBAAU;AAC1B,EAAE,sCAAM;AACR,EAAE,UAAM;AACR,EAAE,mBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,gBAYf;AACD,aAAS;AACM,qDAAS,Q;;;AChCxB;AACA;AACA;AACA;AAEA;AAEA;AACA,gCADA;AAEA,sBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA;AADA,GAJA;AAWA;AACA,gBADA,0BACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KALA;AAOA,cAPA,wBAOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAXA,GAXA;AAyBA;AACA,gBADA,0BACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA,sCADA;AAEA,2DAFA;AAGA,qEAHA;AAIA,+DAJA;AAKA,wFALA;AAMA;AANA;AASA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAEA,2BACA,8BACA,qBADA,EADA,EAIA,kBAJA,EAFA,EADA;AAWA,KAvBA;AAyBA,wBAzBA,kCAyBA;AAAA;AACA;AAEA,aACA;AAAA;AAAA,UACA,uBADA,EAEA,0BAFA,EAGA,+BAHA,EAIA,oCAJA,EADA;AAQA,KApCA;AAsCA,eAtCA,yBAsCA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;;AAEA;AACA;AACA;AACA,yDADA;AAEA;AAFA;AADA;AAMA;AACA,8CADA;AAEA;AAFA;AAKA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,YACA,kCACA;AAAA;AAAA,UADA,EADA,EADA;AAOA;;AAKA;AACA,kDACA;AAAA;AAAA,oBADA;AAIA;AACA;;AAEA;AACA,KA5EA;AA8EA,wBA9EA,gCA8EA,QA9EA,EA8EA;AAAA;AACA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KApFA;AAsFA,2BAtFA,mCAsFA,QAtFA,EAsFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAEA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KAjGA;AAmGA,kBAnGA,4BAmGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA;AACA,wCADA;AAEA,qEAFA;AAGA,iFAHA;AAIA,yEAJA;AAKA;AALA;AAQA,kCACA;AAAA;AAAA,QADA;AAGA,kCACA;AAAA;AAAA,QADA;AAIA,aACA;AAAA;AAAA,UACA,SADA,EAEA,SAFA,EADA;AAMA,KA3HA;AA6HA,eA7HA,yBA6HA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA,4BACA,gDACA,kCADA,GAEA,kBAFA,CADA;AAMA,oCACA,8BACA,4DADA,GAEA,gCAHA,GAIA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;A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BAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 index 8c26fa1f..22876272 100644 --- a/dist/vue-treeselect.umd.min.js +++ b/dist/vue-treeselect.umd.min.js @@ -1,7 +1,7 @@ /*! - * vue-treeselect v0.4.0 | (c) 2017-2020 Riophae Lee + * vue-treeselect v0.4.0 | (c) 2017-2021 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=38)}([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}},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()}},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}}},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-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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.filter((function(e){return e}));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.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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&&(u.parentNode.id in a||(a[u.parentNode.id]=u.parentNode.children.length),0==--a[u.parentNode.id]&&l.push(u.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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[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()}},Ge=he({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 Ke.a(function(e){for(var t=1;te.length)&&(t=e.length);for(var n=0,i=new Array(t);n=t||n<0||m&&e-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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},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?this.options.filter((function(e){return e})):{};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=[];this.hasBranchNodes=this.forest.normalizedOptions.some((function(e){return e.isBranch}))},getInstanceId:function(){return null==this.instanceId?this.id:this.instanceId},getValue:function(){var e=this;if("id"===this.valueFormat)return this.multiple?this.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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&&(u.parentNode.id in a||(a[u.parentNode.id]=u.parentNode.children.length),0==--a[u.parentNode.id]&&l.push(u.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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[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()}},Ge=he({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 Ke.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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0\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 lastSearchInput: null,\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.filter(o => o)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime);\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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:\n \"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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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(\"D:\\\\Projects\\\\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 +{"version":3,"sources":["webpack://VueTreeselect/webpack/universalModuleDefinition","webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://VueTreeselect/./node_modules/babel-helper-vue-jsx-merge-props/index.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/arrayLikeToArray.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/_root.js","webpack://VueTreeselect/./node_modules/lodash/toNumber.js","webpack://VueTreeselect/./node_modules/lodash/_Symbol.js","webpack://VueTreeselect/./node_modules/is-promise/index.js","webpack://VueTreeselect/./node_modules/lodash/once.js","webpack://VueTreeselect/./node_modules/lodash/identity.js","webpack://VueTreeselect/./node_modules/lodash/constant.js","webpack://VueTreeselect/./node_modules/lodash/last.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack://VueTreeselect/./node_modules/fuzzysearch/index.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/typeof.js","webpack://VueTreeselect/external \"Vue\"","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/nonIterableRest.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/lodash/now.js","webpack://VueTreeselect/./node_modules/lodash/_freeGlobal.js","webpack://VueTreeselect/(webpack)/buildin/global.js","webpack://VueTreeselect/./node_modules/lodash/isSymbol.js","webpack://VueTreeselect/./node_modules/lodash/_baseGetTag.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/lodash/before.js","webpack://VueTreeselect/./node_modules/lodash/toInteger.js","webpack://VueTreeselect/./node_modules/lodash/toFinite.js","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./node_modules/watch-size/index.es.mjs","webpack://VueTreeselect/./src/utils/removeFromArray.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/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","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","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/SingleValue.vue","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","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValue.vue","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","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["root","factory","exports","module","require","define","amd","window","__WEBPACK_EXTERNAL_MODULE__19__","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","obj","configurable","writable","nestRE","mergeFn","a","b","apply","this","arguments","objs","reduce","aa","bb","nestedKey","temp","test","Array","isArray","concat","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","arr","arrayLikeToArray","minLen","toString","slice","constructor","from","len","length","arr2","isObject","now","toNumber","nativeMax","Math","max","nativeMin","min","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","clearTimeout","cancel","flush","type","freeGlobal","freeSelf","self","Function","isSymbol","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","replace","isBinary","isPromise","then","default","before","array","arrayWithHoles","iterableToArrayLimit","nonIterableRest","needle","haystack","tlen","qlen","outer","j","nch","charCodeAt","_typeof","iterator","_arr","_n","_d","_e","_s","_i","next","done","push","err","iter","Date","global","g","e","baseGetTag","isObjectLike","getRawTag","objectToString","symToStringTag","objectProto","nativeObjectToString","isOwn","tag","unmasked","toInteger","toFinite","remainder","warning","noop","onLeftClick","mouseDownHandler","evt","button","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","offsetTop","clientHeight","scrollHeight","top","intervalId","element","listener","expand","document","createElement","shrink","appendChild","expandChild","shrinkChild","lastWidth","lastHeight","style","cssText","width","height","unbind","removeChild","offsetWidth","scrollLeft","scrollWidth","addEventListener","removeEventListener","removeFromArray","elem","idx","indexOf","splice","registered","item","$el","watchSizeForIE9","setInterval","forEach","clearInterval","watchSize","isIE9","documentMode","locked","removeSizeWatcher","watchSizeForBrowsersOtherThanIE9","isScrollElment","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","findScrollParents","passive","scrollParent","$scrollParent","isNaN","x","createMap","isPlainObject","getPrototypeOf","deepExtend","target","source","keys","includes","arrOrStr","find","predicate","ctx","quickDiff","arrA","arrB","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","KEY_CODES","sortValueByIndex","level","index","match","enableFuzzyMatch","fuzzysearch","getErrorMessage","message","String","instanceId","provide","instance","props","allowClearingDisabled","Boolean","allowSelectingDisabledDescendants","alwaysOpen","appendToBody","async","autoFocus","autoLoadRootOptions","autoDeselectAncestors","autoDeselectDescendants","autoSelectAncestors","autoSelectDescendants","backspaceRemoves","beforeClearAll","constant","branchNodesFirst","cacheOptions","clearable","clearAllText","clearOnSelect","clearValueText","closeOnSelect","defaultExpandLevel","Number","defaultOptions","deleteRemoves","delimiter","flattenSearchResults","disableBranchNodes","disabled","disableFuzzyMatching","flat","joinValues","limit","Infinity","limitText","count","loadingText","loadOptions","matchKeys","maxHeight","multiple","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","openOnClick","openOnFocus","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","startSearchLength","waitSearchFinishTime","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","isLoaded","isLoading","loadingError","localSearch","active","noResults","countMap","lastSearchInput","remoteSearch","hasBranchNodes","computed","selectedNodes","map","getNode","internalValue","single","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","sortValueByLevel","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","$emit","getValue","getInstanceId","buildForestState","handler","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","fallbackNode","label","enhancedNormalizer","isFallbackNode","isDisabled","isNew","$set","defaultNode","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","contains","wrapper","retry","resetHighlightedOptionWhenNecessary","diff","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","$menu","portal","portalTarget","setCurrentHighlightedOption","scroll","prev","isHighlighted","scrollToOption","$option","querySelector","$nextTick","forceReset","highlightFirstOption","first","highlightPrevOption","highlightLastOption","highlightNextOption","last","getLast","resetSearchQuery","saveMenuScrollPosition","restoreMenuScrollPosition","loadRootOptions","toggleMenu","toggleExpanded","nextState","childrenStates","loadChildrenOptions","selectedNodeId","ancestorNode","nodes","checkDuplication","verifyNodeShape","isDefaultExpanded","normalized","hasDisabledDescendants","branchNodes","option","leafNodes","once","catch","console","error","JSON","stringify","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","component","__file","inputWidth","_h","$createElement","_c","_self","attrs","xmlns","viewBox","_withStripped","VERSION","Treeselect","PKG_VERSION"],"mappings":"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","file":"vue-treeselect.umd.min.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__19__) {\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 = 38);\n","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;","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","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index 1f7a3bb7..54d168f7 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -941,7 +941,7 @@ export default { initialize() { const options = this.async ? this.getRemoteSearchEntry().options - : this.options.filter(o => o) + : this.options ? this.options.filter(o => o) : {} if (Array.isArray(options)) { // In case we are re-initializing options, keep the old state tree temporarily. diff --git a/test/unit/specs/Basic.spec.js b/test/unit/specs/Basic.spec.js index 21a08c97..eb970164 100644 --- a/test/unit/specs/Basic.spec.js +++ b/test/unit/specs/Basic.spec.js @@ -625,7 +625,7 @@ describe('Basic', () => { }) it('declaring branch nodes by `isBranch: true` should raise a warning', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() mount(Treeselect, { propsData: { @@ -646,7 +646,7 @@ describe('Basic', () => { describe('should warn about duplicate node ids', () => { it('case #1', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() mount(Treeselect, { propsData: { @@ -668,7 +668,7 @@ describe('Basic', () => { }) it('case #2', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() mount(Treeselect, { propsData: { @@ -692,7 +692,7 @@ describe('Basic', () => { }) it('fallback nodes should not be considered duplicate', async () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() const DELAY = 10 const app = new Vue({ diff --git a/test/unit/specs/DynamicalLoading.spec.js b/test/unit/specs/DynamicalLoading.spec.js index 24746308..bde14e5a 100644 --- a/test/unit/specs/DynamicalLoading.spec.js +++ b/test/unit/specs/DynamicalLoading.spec.js @@ -15,7 +15,7 @@ import { CHECKED } from '@src/constants' describe('Dynamical Loading', () => { describe('Verify props', () => { it('should warn about absense of `loadOptions` prop when options=null', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() mount(Treeselect, { propsData: { @@ -30,7 +30,7 @@ describe('Dynamical Loading', () => { }) it('should warn about absense of `loadOptions` prop when unloaded branch nodes detected', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() mount(Treeselect, { propsData: { diff --git a/test/unit/specs/Methods.spec.js b/test/unit/specs/Methods.spec.js index 374cfca2..f7c13cbc 100644 --- a/test/unit/specs/Methods.spec.js +++ b/test/unit/specs/Methods.spec.js @@ -209,7 +209,7 @@ describe('Methods', () => { }) it('should warn about invalid node id', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() wrapper.vm.getNode(null) expect(console.error).toHaveBeenCalledWith( '[Vue-Treeselect Warning]', diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index 776567f5..5a9738d8 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -446,7 +446,7 @@ describe('Props', () => { describe('async', () => { it('must be with searchable=true', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() mount(Treeselect, { propsData: { @@ -613,7 +613,7 @@ describe('Props', () => { }) it('must be used in conjunction with `flat=true`', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() function test(propName) { mount(Treeselect, { @@ -1429,7 +1429,7 @@ describe('Props', () => { describe('flat', () => { it('must be used in conjunction with `multiple=true`', () => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() mount(Treeselect, { propsData: { diff --git a/test/unit/specs/utils.spec.js b/test/unit/specs/utils.spec.js index 869ac57f..01bd910d 100644 --- a/test/unit/specs/utils.spec.js +++ b/test/unit/specs/utils.spec.js @@ -10,7 +10,7 @@ describe('Utils', () => { const WARNING_MSG = '$MESSAGE$' beforeEach(() => { - spyOn(console, 'error') + spyOn(console, 'error').and.callThrough() }) it('when true', () => { From aaa68b797f1bc9a0f088b62cac428a7344564b29 Mon Sep 17 00:00:00 2001 From: Almas Date: Sun, 8 Aug 2021 21:30:40 +0800 Subject: [PATCH 08/20] fix: Codecov check fix. --- dist/vue-treeselect.cjs.js | 12 ++++++++---- dist/vue-treeselect.cjs.js.map | 2 +- dist/vue-treeselect.cjs.min.js | 2 +- dist/vue-treeselect.cjs.min.js.map | 2 +- dist/vue-treeselect.umd.js | 12 ++++++++---- dist/vue-treeselect.umd.js.map | 2 +- dist/vue-treeselect.umd.min.js | 2 +- dist/vue-treeselect.umd.min.js.map | 2 +- src/mixins/treeselectMixin.js | 9 +++++---- 9 files changed, 27 insertions(+), 18 deletions(-) diff --git a/dist/vue-treeselect.cjs.js b/dist/vue-treeselect.cjs.js index 72411e8f..d8f29903 100644 --- a/dist/vue-treeselect.cjs.js +++ b/dist/vue-treeselect.cjs.js @@ -1339,6 +1339,10 @@ var instanceId = 0; return _this11.resetHighlightedOptionWhenNecessary(true); }; + var ignore = function ignore() { + return _this11.resetHighlightedOptionWhenNecessary(false); + }; + if (!searchQuery) { this.localSearch.active = false; this.lastSearchInput = null; @@ -1346,7 +1350,7 @@ var instanceId = 0; } if (searchQuery.length < this.startSearchLength) { - return; + return ignore(); } if (this.waitSearchFinishTime > 0) { @@ -1357,7 +1361,7 @@ var instanceId = 0; _this11.handleLocalSearch(true); }, this.waitSearchFinishTime); this.lastSearchInput = now; - return; + return ignore(); } var diff = now - this.lastSearchInput; @@ -1367,11 +1371,11 @@ var instanceId = 0; _this11.handleLocalSearch(true); }, this.waitSearchFinishTime); this.lastSearchInput = now; - return; + return ignore(); } if (retry && diff < this.waitSearchFinishTime) { - return; + return ignore(); } this.lastSearchInput = now; diff --git a/dist/vue-treeselect.cjs.js.map b/dist/vue-treeselect.cjs.js.map index e7aa0f73..29383817 100644 --- a/dist/vue-treeselect.cjs.js.map +++ b/dist/vue-treeselect.cjs.js.map @@ -1 +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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","remoteSearch","hasBranchNodes","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","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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":"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E,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/NA,+BA+NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AAnOA,GA9CA;AAoRA,QApRA,oBAoRA;AACA;AACA;AAtRA,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IA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAA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M,EAAE,oBAAe;AAC6B;AACL;;;AAGnD;AAC0F;AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 +{"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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","remoteSearch","hasBranchNodes","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","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","ignore","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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":"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CA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/NA,+BA+NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AAnOA,GA9CA;AAoRA,QApRA,oBAoRA;AACA;AACA;AAtRA,G;;ACdiN,CAAgB,0GAAG,EAAC,C;;ACArO,IAAI,YAAM,EAAE,qBAAe;AAC8B;AACL;;;AAGpD;AAC0F;AAC1F,IAAI,eAAS,GAAG,kBAAU;AAC1B,EAAE,wCAAM;AACR,EAAE,YAAM;AACR,EAAE,qBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,kBAYf;AACD,eAAS;AACM,yDAAS,Q;;AChCxB;AACA,qCADA;AAEA,sBAFA;AAIA,QAJA,oBAIA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA,yCADA;AAEA,mDAFA;AAGA;AAHA;AAMA,WACA;AAAA;AAAA,QACA,oBADA,EADA;AAKA;AAjBA,G;;ACDuN,CAAgB,sHAAG,EAAC,C;;ACA3O,IAAI,kBAAM,EAAE,2BAAe;AACoC;AACL;;;AAG1D;AAC0F;AAC1F,IAAI,qBAAS,GAAG,kBAAU;AAC1B,EAAE,8CAAM;AACR,EAAE,kBAAM;AACR,EAAE,2BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,wBAYf;AACD,qBAAS;AACM,qEAAS,Q;;AChCxB;AACA;AAEA;AACA,sCADA;AAEA,sBAFA;AAGA;AACA,0BADA,oCACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AACA,wCACA;AAAA;AAAA,QADA,GAEA,UAFA;AAGA;AATA,GAHA;AAcA,QAdA,oBAcA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAAA,QACA,oBADA,GACA,IADA,CACA,OADA,CACA,oBADA;AAEA;AAEA,iCACA,mBACA;AAAA;AAAA,QACA,6BADA,EAFA,EAMA,cANA,EAOA;AAAA;AAAA,MAPA;AASA;AA3BA,G;;ACJuN,CAAgB,sHAAG,EAAC,C;;ACA3O,IAAI,kBAAM,EAAE,2BAAe;AACoC;AACL;;;AAG1D;AAC0F;AAC1F,IAAI,qBAAS,GAAG,kBAAU;AAC1B,EAAE,8CAAM;AACR,EAAE,kBAAM;AACR,EAAE,2BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,wBAYf;AACD,qBAAS;AACM,qEAAS,Q;;ACjCxB,IAAI,0CAAM;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,IAAI,mDAAe;AACnB,0CAAM;;;;;;AChBN;AACA;AADA,G;;ACP2N,CAAgB,uGAAG,EAAC,C;;ACA1J;AAC3B;AACL;;;AAGrD;AAC6F;AAC7F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,oCAAM;AACR,EAAE,0CAAM;AACR,EAAE,mDAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAiBf;AACD,gBAAS;AACM,2DAAS,Q;;ACrCxB;AACA;AAEA;AACA,0CADA;AAEA,sBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA;AADA,GAJA;AAWA;AACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAIA;AACA,KALA;AADA,GAXA;AAoBA,QApBA,oBAoBA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA,8CADA;AAEA,kEAFA;AAGA;AAHA;AAKA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA,QACA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,uBADA,EAEA;AAAA;AAAA,mBAFA,EADA,EADA;AAQA;AAtCA,G;;ACJ0N,CAAgB,4HAAG,EAAC,C;;ACA9O,IAAI,qBAAM,EAAE,8BAAe;AACuC;AACL;;;AAG7D;AAC0F;AAC1F,IAAI,wBAAS,GAAG,kBAAU;AAC1B,EAAE,iDAAM;AACR,EAAE,qBAAM;AACR,EAAE,8BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,2BAYf;AACD,wBAAS;AACM,2EAAS,Q;;;AChCxB;AACA;AACA;AAEA;AACA,qCADA;AAEA,sBAFA;AAIA;AACA,yBADA,mCACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,oCACA,KADA,CACA,CADA,EACA,cADA,EAEA,GAFA,CAEA,gBAFA,EAGA,GAHA,CAGA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA,OAHA;AAMA,KAVA;AAYA,wBAZA,kCAYA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AAEA,aACA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,qCADA,EADA;AAKA;AAvBA,GAJA;AA8BA,QA9BA,oBA8BA;AAAA;AAAA,QACA,oBADA,GACA,YADA,CACA,oBADA;AAEA;AACA;AACA,kBADA;AAEA,4DAFA;AAGA;AAHA;AADA;AAQA,gCACA;AAAA;AAAA,gCACA,4BADA,EAEA,2BAFA,EAGA;AAAA;AAAA,MAHA,EAIA;AAAA;AAAA;AAAA,MAJA,EADA;AAQA;AAhDA,G;;ACLsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;ACjCxB,IAAI,yCAAM;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,IAAI,kDAAe;AACnB,yCAAM;;;;;;AChBN;AACA;AADA,G;;ACP0N,CAAgB,qGAAG,EAAC,C;;ACA1J;AAC3B;AACL;;;AAGpD;AAC6F;AAC7F,IAAI,eAAS,GAAG,kBAAU;AAC1B,EAAE,mCAAM;AACR,EAAE,yCAAM;AACR,EAAE,kDAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,kBAiBf;AACD,eAAS;AACM,yDAAS,Q;;ACrCxB;AACA;AACA;AACA;AACA;AAEA;AACA,iCADA;AAEA,sBAFA;AAIA;AAMA,eANA,yBAMA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA,sBACA,kBADA,IAEA,iBAFA,KAGA,yDAHA,CADA;AAMA,KAfA;AAqBA,mBArBA,6BAqBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAGA;AACA,KA5BA;AAkCA,sBAlCA,gCAkCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA,qBACA;AAAA;AAAA,QAFA;AAIA;AAzCA,GAJA;AAiDA;AACA,WADA,qBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,QADA,EADA;AAKA,KAZA;AAcA,eAdA,yBAcA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA,6CADA;AAEA;AAFA;AAKA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA;AAAA;AAAA,QADA,EADA;AAKA,KA5BA;AA8BA;AAUA;AACA;AAXA,UAaA,QAbA,GAaA,IAbA,CAaA,QAbA;AAcA;;AACA;AACA;AACA,OAFA;;AAIA;AAEA;AACA,OAHA,MAGA;AAEA;AAAA;AAAA;AAKA;AACA,KA9BA,CA9BA;AA8DA;AACA;AACA;AAFA,UAIA,QAJA,GAIA,IAJA,CAIA,QAJA;AAOA;AACA;AACA,KATA,CA9DA;AA0EA,wBA1EA,gCA0EA,QA1EA,EA0EA;AAAA;AACA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA;AAhFA,GAjDA;AAoIA,QApIA,oBAoIA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EAEA,cAFA,EAGA,kBAHA,EADA;AAOA;AA/IA,G;;ACPmN,CAAgB,8GAAG,EAAC,C;;ACAvO,IAAI,cAAM,EAAE,uBAAe;AACgC;AACL;;;AAGtD;AAC0F;AAC1F,IAAI,iBAAS,GAAG,kBAAU;AAC1B,EAAE,0CAAM;AACR,EAAE,cAAM;AACR,EAAE,uBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,oBAYf;AACD,iBAAS;AACM,6DAAS,Q;;AChCxB;AACA,6BADA;AAEA,kBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA,KADA;AAKA;AACA,kBADA;AAEA;AAFA;AALA,GAJA;AAeA,QAfA,kBAeA,CAfA,EAeA,OAfA,EAeA;AAAA;AAAA,QACA,KADA,GACA,OADA,CACA,KADA;AAAA,QACA,QADA,GACA,OADA,CACA,QADA;AAGA,WACA;AAAA;AAAA,QACA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA,EAIA;AAAA;AAAA,QACA,QADA,EAJA,EADA;AAUA;AA5BA,G;;ACD+M,CAAgB,sGAAG,EAAC,C;;ACAnO,IAAI,UAAM,EAAE,mBAAe;AAC4B;AACL;;;AAGlD;AAC0F;AAC1F,IAAI,aAAS,GAAG,kBAAU;AAC1B,EAAE,sCAAM;AACR,EAAE,UAAM;AACR,EAAE,mBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,gBAYf;AACD,aAAS;AACM,qDAAS,Q;;;AChCxB;AACA;AACA;AACA;AAEA;AAEA;AACA,gCADA;AAEA,sBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA;AADA,GAJA;AAWA;AACA,gBADA,0BACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KALA;AAOA,cAPA,wBAOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAXA,GAXA;AAyBA;AACA,gBADA,0BACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA,sCADA;AAEA,2DAFA;AAGA,qEAHA;AAIA,+DAJA;AAKA,wFALA;AAMA;AANA;AASA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAEA,2BACA,8BACA,qBADA,EADA,EAIA,kBAJA,EAFA,EADA;AAWA,KAvBA;AAyBA,wBAzBA,kCAyBA;AAAA;AACA;AAEA,aACA;AAAA;AAAA,UACA,uBADA,EAEA,0BAFA,EAGA,+BAHA,EAIA,oCAJA,EADA;AAQA,KApCA;AAsCA,eAtCA,yBAsCA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;;AAEA;AACA;AACA;AACA,yDADA;AAEA;AAFA;AADA;AAMA;AACA,8CADA;AAEA;AAFA;AAKA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,YACA,kCACA;AAAA;AAAA,UADA,EADA,EADA;AAOA;;AAKA;AACA,kDACA;AAAA;AAAA,oBADA;AAIA;AACA;;AAEA;AACA,KA5EA;AA8EA,wBA9EA,gCA8EA,QA9EA,EA8EA;AAAA;AACA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KApFA;AAsFA,2BAtFA,mCAsFA,QAtFA,EAsFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAEA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KAjGA;AAmGA,kBAnGA,4BAmGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA;AACA,wCADA;AAEA,qEAFA;AAGA,iFAHA;AAIA,yEAJA;AAKA;AALA;AAQA,kCACA;AAAA;AAAA,QADA;AAGA,kCACA;AAAA;AAAA,QADA;AAIA,aACA;AAAA;AAAA,UACA,SADA,EAEA,SAFA,EADA;AAMA,KA3HA;AA6HA,eA7HA,yBA6HA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA,4BACA,gDACA,kCADA,GAEA,kBAFA,CADA;AAMA,oCACA,8BACA,4DADA,GAEA,gCAHA,GAIA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;;AACA;AACA;AADA,8CAEA,WAFA,GAEA,IAFA;;AAIA;AACA;AACA;AADA;AADA;AAMA,WACA;AAAA;AAAA,QACA,mBADA,EAEA,iBACA,kCACA,2BADA,EAHA,EADA;AAUA;AA9RA;AAkSA,2E;;AC1SkN,CAAgB,4GAAG,EAAC,C;;ACAtO,IAAI,aAAM,EAAE,sBAAe;AAC+B;AACL;;;AAGrD;AAC0F;AAC1F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,yCAAM;AACR,EAAE,aAAM;AACR,EAAE,sBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAYf;AACD,gBAAS;AACM,sEAAS,Q;;AChCxB;AACA;AACA;AACA;AAEA;AACA,YADA;AAEA,kBAFA;AAGA,cAHA;AAIA;AAJA;AAOA;AACA,8BADA;AAEA,sBAFA;AAIA;AACA,aADA,uBACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA,KAPA;AASA,sBATA,gCASA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA;AAfA,GAJA;AAsBA;AACA,0BADA,8BACA,QADA,EACA;AACA;AAEA;AACA,OAHA,MAGA;AACA;AACA;AACA;AARA,GAtBA;AAiCA,SAjCA,qBAiCA;AACA;AACA;AACA,GApCA;AAsCA,SAtCA,qBAsCA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA1CA;AA4CA,WA5CA,uBA4CA;AACA;AACA,GA9CA;AAgDA;AACA,cADA,wBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,uBADA,EAEA,iBACA,iCADA,GAEA,8BACA,iCADA,GAEA,4BANA,EAOA,sBAPA,EADA;AAWA,KAjBA;AAmBA,oBAnBA,8BAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,kCACA,oBADA,GAEA,IAFA;AAGA,KA1BA;AA4BA,mBA5BA,6BA4BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAEA,iCACA,mBADA,GAEA,IAFA;AAGA,KAnCA;AAqCA,yBArCA,mCAqCA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjDA;AAmDA,8BAnDA,wCAmDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAjEA;AAmEA,8BAnEA,wCAmEA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA,+DACA,KADA,GAEA,4CAFA;;AAIA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAtFA;AAwFA,oBAxFA,8BAwFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA,UACA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA,QADA,EADA;AAOA,KAlGA;AAoGA,yBApGA,mCAoGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,qCADA;AAGA,KA1GA;AA4GA,2BA5GA,qCA4GA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AAAA;AAAA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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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\n const { searchQuery } = this.trigger\n const done = () => this.resetHighlightedOptionWhenNecessary(true)\n const ignore = () => this.resetHighlightedOptionWhenNecessary(false)\n\n if (!searchQuery) {\n // Exit sync search mode.\n this.localSearch.active = false\n this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return ignore()\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return ignore()\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return ignore()\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return ignore()\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 index 46fb725f..ea9b979b 100644 --- a/dist/vue-treeselect.cjs.min.js +++ b/dist/vue-treeselect.cjs.min.js @@ -3,5 +3,5 @@ * 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 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 Y})),n.d(t,"ASYNC_SEARCH",(function(){return K})),n.d(t,"VERSION",(function(){return it}));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},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?this.options.filter((function(e){return e})):{};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=[];this.hasBranchNodes=this.forest.normalizedOptions.some((function(e){return e.isBranch}))},getInstanceId:function(){return null==this.instanceId?this.id:this.instanceId},getValue:function(){var e=this;if("id"===this.valueFormat)return this.multiple?this.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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&&(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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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=ce(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?n:"number"!=typeof n||C(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:w(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(14),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:w(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(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;t1?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},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?this.options.filter((function(e){return e})):{};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=[];this.hasBranchNodes=this.forest.normalizedOptions.some((function(e){return e.isBranch}))},getInstanceId:function(){return null==this.instanceId?this.id:this.instanceId},getValue:function(){var e=this;if("id"===this.valueFormat)return this.multiple?this.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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&&(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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)},r=function(){return t.resetHighlightedOptionWhenNecessary(!1)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(n.length0){var s=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),this.lastSearchInput=s,r();var o=s-this.lastSearchInput;if(o1?e.isMatched=c.every((function(t){return le(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return le(!t.disableFuzzyMatching,a,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null},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=ce(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?n:"number"!=typeof n||C(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:w(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(14),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:w(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(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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 +{"version":3,"sources":["webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/external \"@babel/runtime/helpers/defineProperty\"","webpack://VueTreeselect/external \"babel-helper-vue-jsx-merge-props\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/toConsumableArray\"","webpack://VueTreeselect/external \"lodash/noop\"","webpack://VueTreeselect/external \"lodash/debounce\"","webpack://VueTreeselect/external \"is-promise\"","webpack://VueTreeselect/external \"lodash/once\"","webpack://VueTreeselect/external \"lodash/identity\"","webpack://VueTreeselect/external \"lodash/constant\"","webpack://VueTreeselect/external \"lodash/last\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/slicedToArray\"","webpack://VueTreeselect/external \"fuzzysearch\"","webpack://VueTreeselect/external \"watch-size\"","webpack://VueTreeselect/external \"@babel/runtime/helpers/typeof\"","webpack://VueTreeselect/external \"vue\"","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./src/utils/removeFromArray.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/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","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","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/SingleValue.vue","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","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValue.vue","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","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","require","warning","noop","onLeftClick","mouseDownHandler","evt","type","button","args","this","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","Math","min","offsetTop","clientHeight","scrollHeight","top","max","intervalId","removeFromArray","arr","elem","idx","indexOf","splice","registered","test","item","$el","listener","lastWidth","lastHeight","width","offsetWidth","height","watchSizeForIE9","push","setInterval","forEach","length","clearInterval","watchSize","isIE9","document","documentMode","locked","removeSizeWatcher","watchSizeForBrowsersOtherThanIE9","isScrollElment","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","window","findScrollParents","addEventListener","passive","scrollParent","removeEventListener","$scrollParent","isNaN","x","createMap","isPlainObject","getPrototypeOf","deepExtend","target","source","keys","len","obj","includes","arrOrStr","find","predicate","ctx","quickDiff","arrA","arrB","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","KEY_CODES","sortValueByIndex","a","b","level","index","match","enableFuzzyMatch","needle","haystack","fuzzysearch","getErrorMessage","err","message","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","count","loadingText","loadOptions","matchKeys","Array","maxHeight","multiple","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","openOnClick","openOnFocus","options","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","startSearchLength","waitSearchFinishTime","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","isLoaded","isLoading","loadingError","localSearch","active","noResults","countMap","lastSearchInput","remoteSearch","hasBranchNodes","computed","selectedNodes","map","getNode","internalValue","single","slice","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","sortValueByLevel","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","$emit","getValue","getInstanceId","buildForestState","handler","isArray","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","fallbackNode","label","enhancedNormalizer","isFallbackNode","isDisabled","isNew","$set","defaultNode","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","contains","wrapper","retry","done","resetHighlightedOptionWhenNecessary","ignore","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","split","every","filterValue","nestedSearchLabel","matchKey","lowerCased","entry","callLoadOptionsProp","action","isPending","start","succeed","fail","end","$watch","isExpanded","shouldShowOptionInMenu","getControl","getMenu","$menu","portal","portalTarget","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","concat","hasDisabledDescendants","branchNodes","option","leafNodes","once","result","isPromise","then","catch","console","error","JSON","stringify","undefined","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","component","__file","inputWidth","_h","$createElement","_c","_self","attrs","xmlns","viewBox","_withStripped","VERSION","Treeselect","PKG_VERSION"],"mappings":"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","file":"vue-treeselect.cjs.min.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/defineProperty\");","module.exports = require(\"babel-helper-vue-jsx-merge-props\");","module.exports = require(\"@babel/runtime/helpers/toConsumableArray\");","module.exports = require(\"lodash/noop\");","module.exports = require(\"lodash/debounce\");","module.exports = require(\"is-promise\");","module.exports = require(\"lodash/once\");","module.exports = require(\"lodash/identity\");","module.exports = require(\"lodash/constant\");","module.exports = require(\"lodash/last\");","module.exports = require(\"@babel/runtime/helpers/slicedToArray\");","module.exports = require(\"fuzzysearch\");","module.exports = require(\"watch-size\");","module.exports = require(\"@babel/runtime/helpers/typeof\");","module.exports = require(\"vue\");","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","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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\n const { searchQuery } = this.trigger\n const done = () => this.resetHighlightedOptionWhenNecessary(true)\n const ignore = () => this.resetHighlightedOptionWhenNecessary(false)\n\n if (!searchQuery) {\n // Exit sync search mode.\n this.localSearch.active = false\n this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return ignore()\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return ignore()\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return ignore()\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return ignore()\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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.umd.js b/dist/vue-treeselect.umd.js index e33f8f16..18b70f4c 100644 --- a/dist/vue-treeselect.umd.js +++ b/dist/vue-treeselect.umd.js @@ -2472,6 +2472,10 @@ var instanceId = 0; return _this11.resetHighlightedOptionWhenNecessary(true); }; + var ignore = function ignore() { + return _this11.resetHighlightedOptionWhenNecessary(false); + }; + if (!searchQuery) { this.localSearch.active = false; this.lastSearchInput = null; @@ -2479,7 +2483,7 @@ var instanceId = 0; } if (searchQuery.length < this.startSearchLength) { - return; + return ignore(); } if (this.waitSearchFinishTime > 0) { @@ -2490,7 +2494,7 @@ var instanceId = 0; _this11.handleLocalSearch(true); }, this.waitSearchFinishTime); this.lastSearchInput = now; - return; + return ignore(); } var diff = now - this.lastSearchInput; @@ -2500,11 +2504,11 @@ var instanceId = 0; _this11.handleLocalSearch(true); }, this.waitSearchFinishTime); this.lastSearchInput = now; - return; + return ignore(); } if (retry && diff < this.waitSearchFinishTime) { - return; + return ignore(); } this.lastSearchInput = now; diff --git a/dist/vue-treeselect.umd.js.map b/dist/vue-treeselect.umd.js.map index 1241857a..d2f7655e 100644 --- a/dist/vue-treeselect.umd.js.map +++ b/dist/vue-treeselect.umd.js.map @@ -1 +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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","remoteSearch","hasBranchNodes","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","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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L,UAAL;AACpB,QAAI,CAAC,KAAKzI,OAAN,IAAiB,CAAC,KAAKnD,KAAvB,IAAgC,KAAKE,mBAAzC,EAA8D,KAAK+P,eAAL;AAC9D,QAAI,KAAKnQ,UAAT,EAAqB,KAAK6H,QAAL;AACrB,QAAI,KAAK3H,KAAL,IAAc,KAAKoB,cAAvB,EAAuC,KAAKoH,kBAAL;AACxC,GA/5DY;AAi6DbgK,WAj6Da,uBAi6DD;AAEV,SAAKpH,uBAAL,CAA6B,KAA7B;AACD;AAp6DY,CAAf,E;;AC7DA;;AAEA;AACA;AAEA;AAEA;AACA;;AAEA;AACA,uCADA;AAEA,sBAFA;AAGA,kBAHA;AAKA,QALA,kBAKA,CALA,EAKA,OALA,EAKA;AAAA;AAAA,QACA,QADA,GACA,kBADA,CACA,QADA;AAGA;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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,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;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;;AAGA;AACA;AACA;AACA,KAbA;AAeA,QAfA,kBAeA;AACA;AACA,KAjBA;AAmBA,WAnBA,qBAmBA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA;AACA,KAzBA;AA2BA,UA3BA,oBA2BA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;;AAIA;AACA;AACA;;AAEA;AACA;AACA,KAvCA;AAyCA,WAzCA,mBAyCA,GAzCA,EAyCA;AAAA,UACA,KADA,GACA,UADA,CACA,KADA;AAGA;;AAEA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA;AACA,KApDA;AAuDA,aAvDA,qBAuDA,GAvDA,EAuDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAIA;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;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A;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,oBAYf;AACD,iBAAS;AACM,6DAAS,Q;;AChCxB;AACA,6BADA;AAEA,kBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA,KADA;AAKA;AACA,kBADA;AAEA;AAFA;AALA,GAJA;AAeA,QAfA,kBAeA,CAfA,EAeA,OAfA,EAeA;AAAA;AAAA,QACA,KADA,GACA,OADA,CACA,KADA;AAAA,QACA,QADA,GACA,OADA,CACA,QADA;AAGA,WACA;AAAA;AAAA,QACA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA,EAIA;AAAA;AAAA,QACA,QADA,EAJA,EADA;AAUA;AA5BA,G;;ACD+M,CAAgB,sGAAG,EAAC,C;;ACAnO,IAAI,UAAM,EAAE,mBAAe;AAC4B;AACL;;;AAGlD;AAC0F;AAC1F,IAAI,aAAS,GAAG,kBAAU;AAC1B,EAAE,sCAAM;AACR,EAAE,UAAM;AACR,EAAE,mBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,gBAYf;AACD,aAAS;AACM,qDAAS,Q;;;AChCxB;AACA;AACA;AACA;AAEA;AAEA;AACA,gCADA;AAEA,sBAFA;AAIA;AACA;AACA,kBADA;AAEA;AAFA;AADA,GAJA;AAWA;AACA,gBADA,0BACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KALA;AAOA,cAPA,wBAOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAXA,GAXA;AAyBA;AACA,gBADA,0BACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA,sCADA;AAEA,2DAFA;AAGA,qEAHA;AAIA,+DAJA;AAKA,wFALA;AAMA;AANA;AASA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAEA,2BACA,8BACA,qBADA,EADA,EAIA,kBAJA,EAFA,EADA;AAWA,KAvBA;AAyBA,wBAzBA,kCAyBA;AAAA;AACA;AAEA,aACA;AAAA;AAAA,UACA,uBADA,EAEA,0BAFA,EAGA,+BAHA,EAIA,oCAJA,EADA;AAQA,KApCA;AAsCA,eAtCA,yBAsCA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;;AAEA;AACA;AACA;AACA,yDADA;AAEA;AAFA;AADA;AAMA;AACA,8CADA;AAEA;AAFA;AAKA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,YACA,kCACA;AAAA;AAAA,UADA,EADA,EADA;AAOA;;AAKA;AACA,kDACA;AAAA;AAAA,oBADA;AAIA;AACA;;AAEA;AACA,KA5EA;AA8EA,wBA9EA,gCA8EA,QA9EA,EA8EA;AAAA;AACA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KApFA;AAsFA,2BAtFA,mCAsFA,QAtFA,EAsFA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA;AAEA,aACA;AAAA;AAAA,UACA,QADA,EADA;AAKA,KAjGA;AAmGA,kBAnGA,4BAmGA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA;AACA;AACA,wCADA;AAEA,qEAFA;AAGA,iFAHA;AAIA,yEAJA;AAKA;AALA;AAQA,kCACA;AAAA;AAAA,QADA;AAGA,kCACA;AAAA;AAAA,QADA;AAIA,aACA;AAAA;AAAA,UACA,SADA,EAEA,SAFA,EADA;AAMA,KA3HA;AA6HA,eA7HA,yBA6HA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAEA,4BACA,gDACA,kCADA,GAEA,kBAFA,CADA;AAMA,oCACA,8BACA,4DADA,GAEA,gCAHA,GAIA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;A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BAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEeqH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 +{"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/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","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","startSearchLength","waitSearchFinishTime","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","lastSearchInput","remoteSearch","hasBranchNodes","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","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","o","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","label","enhancedNormalizer","fallbackNode","isFallbackNode","isDisabled","isNew","$set","defaultNode","valueArray","matched","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","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","retry","done","resetHighlightedOptionWhenNecessary","ignore","now","Date","setTimeout","diff","isExpandedOnSearch","showAllChildrenOnSearch","isMatched","hasMatchedDescendants","lowerCasedSearchQuery","trim","toLocaleLowerCase","splitSearchQuery","replace","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,CAAkB;;AAE/C,2BAA2B,mBAAO,CAAC,CAAwB;;AAE3D,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD;AACA;AACA;;AAEA,gC;;;;;;ACZA;AACA;AACA;;AAEA,iC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA,uC;;;;;;AC3BA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6C;;;;;;ACXA;AACA;;AAEA,wCAAwC,SAAS;AACjD;AACA;;AAEA;AACA;;AAEA,mC;;;;;;ACVA;AACA;AACA;;AAEA,kC;;;;;;ACJA,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD,sBAAsB,mBAAO,CAAC,CAAmB;;AAEjD,iCAAiC,mBAAO,CAAC,CAA8B;;AAEvE,wBAAwB,mBAAO,CAAC,CAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;ACZA,uBAAuB,mBAAO,CAAC,CAAoB;;AAEnD;AACA;AACA;;AAEA,oC;;;;;;ACNA;AACA;AACA;;AAEA,kC;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;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,EAAY;AACnC,eAAe,mBAAO,CAAC,EAAY;;AAEnC;AACA;;AAEA;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;;;;;;;ACjEA,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;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;AChBA;AACA;AACA;AA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,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;AACA;AACA;;AACA;AACA;;AACA;AAAA;AAEA;AACA;AAvEA;AAyEA,KA9IA;AAgJA,eAhJA,uBAgJA,GAhJA,EAgJA;AAEA;AAGA;AACA;AACA,KAvJA;AAyJA,wBAzJA,kCAyJA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BADA;AAEA,6BAFA;AAGA;AAHA,WADA;AAMA;AANA;AAQA;;AAEA;AACA;AACA;AACA;AADA;AADA;AAKA;;AAEA,aACA;AAAA;AAAA,mBACA,QADA,EADA;AAKA,KA3LA;AA6LA,eA7LA,yBA6LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA,aACA;AAAA;AACA,wCADA;AAAA;AAEA,sBAFA;AAGA,6BAHA;AAIA,qCAJA;AAKA;AALA;AAAA;AAAA,mBAMA;AANA;AAOA,8BAPA;AAAA;AAAA,mBAQA,YARA;AAAA,mBASA,YATA;AAAA,kBAUA,WAVA;AAAA,qBAWA,cAXA;AAAA,uBAYA;AAZA;AAAA,QADA;AAgBA,KAhNA;AAkNA,eAlNA,yBAkNA;AAAA;AACA,aACA;AAAA;AAAA;AAAA,sBADA;AAGA,KAtNA;AAwNA,oBAxNA,8BAwNA;AACA,iCACA,eADA,EAEA,iCAFA;AAIA,KA7NA;AA+NA,qBA/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A,IADA,GACA,IADA,CACA,IADA;AAEA,4BACA,gDACA,kCADA,GAEA,kBAFA,CADA;AAMA,oCACA,8BACA,4DADA,GAEA,gCAHA,GAIA,GAJA;AAKA;AACA;AACA;AAEA;AACA,kBADA;AAEA,wCAFA;AAGA,oBAHA;AAIA,sCAJA;AAKA;AALA;AAQA,aACA;AAAA;AAAA,UACA,UADA,EAEA,mBACA;AAAA;AAAA,2BAHA,EADA;AAQA,KA9JA;AAgKA,oBAhKA,8BAgKA;AAAA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA;AAAA,eACA;AAAA;AAAA;AAAA;AAAA;AAAA,UADA;AAAA;AAGA,KAxKA;AA0KA,uBA1KA,iCA0KA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,mCADA;AAGA,KAlLA;AAoLA,4BApLA,sCAoLA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,gCADA;AAGA,KA5LA;AA8LA,iCA9LA,2CA8LA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,gCADA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UACA,kBADA,EAFA,EADA;AAQA,KA3MA;AA6MA,0BA7MA,kCA6MA,GA7MA,EA6MA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAKA;AAEA;AACA,KArNA;AAuNA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA,CAvNA;AA6NA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;;AAGA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KARA,CA7NA;AAuOA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAAA,UACA,IADA,GACA,IADA,CACA,IADA;AAGA;AACA,KAJA;AAvOA,GAzBA;AAuQA,QAvQA,oBAuQA;AAAA;AAAA,QACA,IADA,GACA,IADA,CACA,IADA;AAEA;;AACA;AACA;AADA,8CAEA,WAFA,GAEA,IAFA;;AAIA;AACA;AACA;AADA;AADA;AAMA,WACA;AAAA;AAAA,QACA,mBADA,EAEA,iBACA,kCACA,2BADA,EAHA,EADA;AAUA;AA9RA;AAkSA,2E;;AC1SkN,CAAgB,4GAAG,EAAC,C;;ACAtO,IAAI,aAAM,EAAE,sBAAe;AAC+B;AACL;;;AAGrD;AAC0F;AAC1F,IAAI,gBAAS,GAAG,kBAAU;AAC1B,EAAE,yCAAM;AACR,EAAE,aAAM;AACR,EAAE,sBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,mBAYf;AACD,gBAAS;AACM,sEAAS,Q;;AChCxB;AACA;AACA;AACA;AAEA;AACA,YADA;AAEA,kBAFA;AAGA,cAHA;AAIA;AAJA;AAOA;AACA,8BADA;AAEA,sBAFA;AAIA;AACA,aADA,uBACA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA,KAPA;AASA,sBATA,gCASA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA;AADA;AAGA;AAfA,GAJA;AAsBA;AACA,0BADA,8BACA,QADA,EACA;AACA;AAEA;AACA,OAHA,MAGA;AACA;AACA;AACA;AARA,GAtBA;AAiCA,SAjCA,qBAiCA;AACA;AACA;AACA,GApCA;AAsCA,SAtCA,qBAsCA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA1CA;AA4CA,WA5CA,uBA4CA;AACA;AACA,GA9CA;AAgDA;AACA,cADA,wBACA;AAAA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAGA;AAEA,aACA;AAAA;AAAA;AAAA;AAAA;AAAA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A,QACA;AAAA;AAAA;AAAA;AAAA,QACA,iBADA,EADA,EADA;AAOA;AAzSA,G;;ACbgN,CAAgB,wGAAG,EAAC,C;;ACApO,IAAI,WAAM,EAAE,oBAAe;AAC6B;AACL;;;AAGnD;AAC0F;AAC1F,IAAI,cAAS,GAAG,kBAAU;AAC1B,EAAE,uCAAM;AACR,EAAE,WAAM;AACR,EAAE,oBAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,iBAYf;AACD,cAAS;AACM,uDAAS,Q;;;;;;;;;;;;AChCxB;AACA;AACA;AAEA;AACA,uCADA;AAEA,sBAFA;AAIA;AACA,0BADA,8BACA,QADA,EACA;AACA;AACA;AACA,OAFA,MAEA;AACA;AACA;AACA,KAPA;AASA,6BATA,mCASA;AACA;AACA;AAXA,GAJA;AAkBA,SAlBA,qBAkBA;AACA;AACA;AACA,GArBA;AAuBA,SAvBA,qBAuBA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAGA;AACA,GA3BA;AA6BA;AACA,iBADA,2BACA;AACA;AACA;AACA;AACA;AACA,KANA;AAQA,kBARA,4BAQA;AACA;AACA;AACA,KAXA;AAaA,6CAbA,uDAaA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AADA;AAGA,KAvBA;AAyBA,2BAzBA,qCAyBA;AAAA;;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AAGA;AAEA;AACA;AACA;;AACA;AACA,SAHA;AADA;AAMA,KAtCA;AAwCA,8CAxCA,wDAwCA;AACA;AAEA;AACA;AACA,KA7CA;AA+CA,4BA/CA,sCA+CA;AACA;AAEA;AACA;AACA,KApDA;AAsDA,eAtDA,yBAsDA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AAEA;AACA,KA7DA;AA+DA,6BA/DA,uCA+DA;AAAA,UACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AA9EA,GA7BA;AA8GA,QA9GA,oBA8GA;AAAA;AAAA,QACA,QADA,GACA,IADA,CACA,QADA;AAEA;AACA;AAAA;AAAA;AAEA,WACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QACA;AAAA;AAAA,MADA,EADA;AAKA,GAxHA;AA0HA,WA1HA,uBA0HA;AACA;AACA;AA5HA;AA+HA;AAEA;AACA,qCADA;AAGA,SAHA,qBAGA;AACA;AACA,GALA;AAOA,SAPA,qBAOA;AACA;AACA,GATA;AAWA,WAXA,uBAWA;AACA;AACA,GAbA;AAeA;AACA,SADA,mBACA;AACA;AACA;AAEA;AACA,cADA;AAEA;AAFA,SAGA,YAHA;AAKA,KAVA;AAYA,YAZA,sBAYA;AACA;AACA;AAEA;AACA;AACA;AAlBA,GAfA;AAoCA,QApCA,oBAoCA;AAAA;AACA,oCACA;AAAA;AAAA,MADA;AAIA;AACA;AA1CA,G;;ACtIsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;AChCxB;AACA;AACA;AACA;AACA;AAEA;AACA,wBADA;AAEA,2BAFA;AAIA;AACA,gBADA,0BACA;AACA;AACA,8BADA;AAEA,6CAFA;AAGA,8CAHA;AAIA,qDAJA;AAKA,iDALA;AAMA,yDANA;AAOA,kDAPA;AAQA,gDARA;AASA,mEATA;AAUA,sEAVA;AAWA,wEAXA;AAYA;AAZA;AAcA;AAhBA,GAJA;AAuBA,QAvBA,oBAuBA;AAAA;AACA,WACA;AAAA;AAAA;AAAA,QACA,eADA,EAEA;AAAA;AAAA,MAFA,EAGA;AAAA;AAAA;AAAA;AAAA,MAHA,EADA;AAOA;AA/BA,G;;ACPsN,CAAgB,oHAAG,EAAC,C;;ACA1O,IAAI,iBAAM,EAAE,0BAAe;AACmC;AACL;;;AAGzD;AAC0F;AAC1F,IAAI,oBAAS,GAAG,kBAAU;AAC1B,EAAE,6CAAM;AACR,EAAE,iBAAM;AACR,EAAE,0BAAe;AACjB;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAI,KAAU,EAAE,uBAYf;AACD,oBAAS;AACM,mEAAS,Q;;;;;ACjCxB;AACA;AACA;AAEesH,mFAAf;AACA;AACA;AAOO,IAAMC,OAAO,GAAGC,OAAhB,C","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__36__) {\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 = 38);\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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;","'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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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 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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","/**\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__36__;","// 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\n const { searchQuery } = this.trigger\n const done = () => this.resetHighlightedOptionWhenNecessary(true)\n const ignore = () => this.resetHighlightedOptionWhenNecessary(false)\n\n if (!searchQuery) {\n // Exit sync search mode.\n this.localSearch.active = false\n this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return ignore()\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return ignore()\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return ignore()\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return ignore()\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 index 22876272..d34048ed 100644 --- a/dist/vue-treeselect.umd.min.js +++ b/dist/vue-treeselect.umd.min.js @@ -3,5 +3,5 @@ * 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=38)}([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}},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()}},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}}},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-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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},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?this.options.filter((function(e){return e})):{};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=[];this.hasBranchNodes=this.forest.normalizedOptions.some((function(e){return e.isBranch}))},getInstanceId:function(){return null==this.instanceId?this.id:this.instanceId},getValue:function(){var e=this;if("id"===this.valueFormat)return this.multiple?this.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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&&(u.parentNode.id in a||(a[u.parentNode.id]=u.parentNode.children.length),0==--a[u.parentNode.id]&&l.push(u.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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(!(n.length0){var r=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),void(this.lastSearchInput=r);var s=r-this.lastSearchInput;if(s1?e.isMatched=a.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,o,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null}},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[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()}},Ge=he({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 Ke.a(function(e){for(var t=1;te.length)&&(t=e.length);for(var n=0,i=new Array(t);n=t||n<0||m&&e-p>=u}function O(){var e=r();if(b(e))return _(e);h=setTimeout(O,function(e){var n=t-(e-f);return m?a(n,u-(e-p)):n}(e))}function _(e){return h=void 0,g&&l?y(e):(l=c=void 0,d)}function E(){var e=r(),n=b(e);if(l=arguments,c=this,f=e,n){if(void 0===h)return S(f);if(m)return clearTimeout(h),h=setTimeout(O,t),y(f)}return void 0===h&&(h=setTimeout(O,t)),d}return t=s(t)||0,i(n)&&(v=!!n.leading,u=(m="maxWait"in n)?o(s(n.maxWait)||0,t):u,g="trailing"in n?!!n.trailing:g),E.cancel=function(){void 0!==h&&clearTimeout(h),p=0,l=f=c=h=void 0},E.flush=function(){return void 0===h?d:_(r())},E}},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(7),r=n(29),s=/^\s+|\s+$/g,o=/^[-+]0x[0-9a-f]+$/i,a=/^0b[01]+$/i,l=/^0o[0-7]+$/i,c=parseInt;e.exports=function(e){if("number"==typeof e)return e;if(r(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(s,"");var n=a.test(e);return n||l.test(e)?c(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(34);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()}},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(36);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 tt})),n.d(t,"treeselectMixin",(function(){return ue})),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 q})),n.d(t,"VERSION",(function(){return nt}));var i=n(16),r=n.n(i),s=n(2),o=n.n(s),a=n(0),l=n.n(a),c=n(17),u=n.n(c),d=n(5),h=n.n(d).a;function f(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},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?this.options.filter((function(e){return e})):{};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=[];this.hasBranchNodes=this.forest.normalizedOptions.some((function(e){return e.isBranch}))},getInstanceId:function(){return null==this.instanceId?this.id:this.instanceId},getValue:function(){var e=this;if("id"===this.valueFormat)return this.multiple?this.internalValue.slice():this.internalValue[0];var t=this.internalValue.map((function(t){return e.getNode(t).raw}));return this.multiple?t:t[0]},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:P(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){if(e){n.push(e);var i=t.getNode(e);i&&i.isBranch&&t.traverseDescendantsBFS(i,(function(e){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&&(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&&(u.parentNode.id in a||(a[u.parentNode.id]=u.parentNode.children.length),0==--a[u.parentNode.id]&&l.push(u.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:f((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(e){var t=this,n=this.trigger.searchQuery,i=function(){return t.resetHighlightedOptionWhenNecessary(!0)},r=function(){return t.resetHighlightedOptionWhenNecessary(!1)};if(!n)return this.localSearch.active=!1,this.lastSearchInput=null,i();if(n.length0){var s=new Date;if(!this.lastSearchInput)return setTimeout((function(){t.handleLocalSearch(!0)}),this.waitSearchFinishTime),this.lastSearchInput=s,r();var o=s-this.lastSearchInput;if(o1?e.isMatched=c.every((function(t){return ae(!1,t,e.nestedSearchLabel)})):e.isMatched=t.matchKeys.some((function(n){return ae(!t.disableFuzzyMatching,a,e.lowerCased[n])})),e.isMatched&&(t.localSearch.noResults=!1,e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].ALL_DESCENDANTS++})),e.isLeaf&&e.ancestors.forEach((function(e){return t.localSearch.countMap[e.id].LEAF_DESCENDANTS++})),null!==e.parentNode&&(t.localSearch.countMap[e.parentNode.id].ALL_CHILDREN+=1,e.isLeaf&&(t.localSearch.countMap[e.parentNode.id].LEAF_CHILDREN+=1))),(e.isMatched||e.isBranch&&e.isExpandedOnSearch)&&null!==e.parentNode&&(e.parentNode.isExpandedOnSearch=!0,e.parentNode.hasMatchedDescendants=!0)})),i(),this.lastSearchInput=null},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:q,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=le(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&&p(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=$();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 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],c=o[1];i.checkDuplication(a),i.verifyNodeShape(a);var u=a.id,d=a.label,f=a.children,p=a.isDefaultExpanded,v=null===e,m=v?0:e.level+1,g=Array.isArray(f)||null===f,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?n:"number"!=typeof n||w(n)?"":n+"").toLocaleLowerCase()));var n}),{}),_=v?O.label:e.nestedSearchLabel+" "+O.label,E=i.$set(i.forest.nodeMap,u,$());if(i.$set(E,"id",u),i.$set(E,"label",d),i.$set(E,"level",m),i.$set(E,"ancestors",v?[]:[e].concat(e.ancestors)),i.$set(E,"index",(v?[]:e.index).concat(s)),i.$set(E,"parentNode",e),i.$set(E,"lowerCased",O),i.$set(E,"nestedSearchLabel",_),i.$set(E,"isDisabled",S),i.$set(E,"isNew",b),i.$set(E,"isMatched",!1),i.$set(E,"isHighlighted",!1),i.$set(E,"isBranch",g),i.$set(E,"isLeaf",y),i.$set(E,"isRootNode",v),i.$set(E,"raw",c),g){var N,L=Array.isArray(f);i.$set(E,"childrenStates",se(se({},{isLoaded:!1,isLoading:!1,loadingError:""}),{},{isLoaded:L})),i.$set(E,"isExpanded","boolean"==typeof p?p:ms+40,c=a>s+40;r.top>=0&&r.top<=o||r.top<0&&r.bottom>0?"auto"!==e.openDirection?e.menu.placement=We[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:L(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,qe=n(19),Ke=n.n(qe);function Xe(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 Ue,Je={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:L(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[P(["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()}},Ge=he({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 Ke.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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\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 this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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 +{"version":3,"sources":["webpack://VueTreeselect/webpack/universalModuleDefinition","webpack://VueTreeselect/webpack/bootstrap","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://VueTreeselect/./node_modules/babel-helper-vue-jsx-merge-props/index.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/arrayLikeToArray.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/_root.js","webpack://VueTreeselect/./node_modules/lodash/toNumber.js","webpack://VueTreeselect/./node_modules/lodash/_Symbol.js","webpack://VueTreeselect/./node_modules/is-promise/index.js","webpack://VueTreeselect/./node_modules/lodash/once.js","webpack://VueTreeselect/./node_modules/lodash/identity.js","webpack://VueTreeselect/./node_modules/lodash/constant.js","webpack://VueTreeselect/./node_modules/lodash/last.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack://VueTreeselect/./node_modules/fuzzysearch/index.js","webpack://VueTreeselect/./node_modules/@babel/runtime/helpers/typeof.js","webpack://VueTreeselect/external \"Vue\"","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/nonIterableRest.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/lodash/now.js","webpack://VueTreeselect/./node_modules/lodash/_freeGlobal.js","webpack://VueTreeselect/(webpack)/buildin/global.js","webpack://VueTreeselect/./node_modules/lodash/isSymbol.js","webpack://VueTreeselect/./node_modules/lodash/_baseGetTag.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/lodash/before.js","webpack://VueTreeselect/./node_modules/lodash/toInteger.js","webpack://VueTreeselect/./node_modules/lodash/toFinite.js","webpack://VueTreeselect/./src/utils/warning.js","webpack://VueTreeselect/./src/utils/onLeftClick.js","webpack://VueTreeselect/./src/utils/scrollIntoView.js","webpack://VueTreeselect/./src/utils/watchSize.js","webpack://VueTreeselect/./node_modules/watch-size/index.es.mjs","webpack://VueTreeselect/./src/utils/removeFromArray.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/constants.js","webpack://VueTreeselect/./src/mixins/treeselectMixin.js","webpack://VueTreeselect/src/components/HiddenFields.vue","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","webpack://VueTreeselect/./src/components/Placeholder.vue","webpack://VueTreeselect/src/components/Placeholder.vue","webpack://VueTreeselect/./src/components/SingleValue.vue","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","webpack://VueTreeselect/./src/components/MultiValueItem.vue","webpack://VueTreeselect/src/components/MultiValueItem.vue","webpack://VueTreeselect/./src/components/MultiValue.vue","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","webpack://VueTreeselect/./src/components/Control.vue","webpack://VueTreeselect/src/components/Control.vue","webpack://VueTreeselect/./src/components/Tip.vue","webpack://VueTreeselect/src/components/Tip.vue","webpack://VueTreeselect/src/components/Option.vue","webpack://VueTreeselect/./src/components/Option.vue","webpack://VueTreeselect/src/components/Menu.vue","webpack://VueTreeselect/./src/components/Menu.vue","webpack://VueTreeselect/src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/MenuPortal.vue","webpack://VueTreeselect/./src/components/Treeselect.vue","webpack://VueTreeselect/src/components/Treeselect.vue","webpack://VueTreeselect/./src/index.js"],"names":["root","factory","exports","module","require","define","amd","window","__WEBPACK_EXTERNAL_MODULE__19__","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","obj","configurable","writable","nestRE","mergeFn","a","b","apply","this","arguments","objs","reduce","aa","bb","nestedKey","temp","test","Array","isArray","concat","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","arr","arrayLikeToArray","minLen","toString","slice","constructor","from","len","length","arr2","isObject","now","toNumber","nativeMax","Math","max","nativeMin","min","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","clearTimeout","cancel","flush","type","freeGlobal","freeSelf","self","Function","isSymbol","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","replace","isBinary","isPromise","then","default","before","array","arrayWithHoles","iterableToArrayLimit","nonIterableRest","needle","haystack","tlen","qlen","outer","j","nch","charCodeAt","_typeof","iterator","_arr","_n","_d","_e","_s","_i","next","done","push","err","iter","Date","global","g","e","baseGetTag","isObjectLike","getRawTag","objectToString","symToStringTag","objectProto","nativeObjectToString","isOwn","tag","unmasked","toInteger","toFinite","remainder","warning","noop","onLeftClick","mouseDownHandler","evt","button","scrollIntoView","$scrollingEl","$focusedEl","scrollingReact","getBoundingClientRect","focusedRect","overScroll","offsetHeight","bottom","scrollTop","offsetTop","clientHeight","scrollHeight","top","intervalId","element","listener","expand","document","createElement","shrink","appendChild","expandChild","shrinkChild","lastWidth","lastHeight","style","cssText","width","height","unbind","removeChild","offsetWidth","scrollLeft","scrollWidth","addEventListener","removeEventListener","removeFromArray","elem","idx","indexOf","splice","registered","item","$el","watchSizeForIE9","setInterval","forEach","clearInterval","watchSize","isIE9","documentMode","locked","removeSizeWatcher","watchSizeForBrowsersOtherThanIE9","isScrollElment","getComputedStyle","overflow","overflowX","overflowY","setupResizeAndScrollEventListeners","$scrollParents","$parent","parentNode","nodeName","nodeType","ELEMENT_NODE","findScrollParents","passive","scrollParent","$scrollParent","isNaN","x","createMap","isPlainObject","getPrototypeOf","deepExtend","target","source","keys","includes","arrOrStr","find","predicate","ctx","quickDiff","arrA","arrB","LOAD_ROOT_OPTIONS","LOAD_CHILDREN_OPTIONS","ASYNC_SEARCH","KEY_CODES","sortValueByIndex","level","index","match","enableFuzzyMatch","fuzzysearch","getErrorMessage","message","String","instanceId","provide","instance","props","allowClearingDisabled","Boolean","allowSelectingDisabledDescendants","alwaysOpen","appendToBody","async","autoFocus","autoLoadRootOptions","autoDeselectAncestors","autoDeselectDescendants","autoSelectAncestors","autoSelectDescendants","backspaceRemoves","beforeClearAll","constant","branchNodesFirst","cacheOptions","clearable","clearAllText","clearOnSelect","clearValueText","closeOnSelect","defaultExpandLevel","Number","defaultOptions","deleteRemoves","delimiter","flattenSearchResults","disableBranchNodes","disabled","disableFuzzyMatching","flat","joinValues","limit","Infinity","limitText","count","loadingText","loadOptions","matchKeys","maxHeight","multiple","noChildrenText","noOptionsText","noResultsText","normalizer","identity","openDirection","validator","openOnClick","openOnFocus","placeholder","required","retryText","retryTitle","searchable","searchNested","searchPromptText","showCount","startSearchLength","waitSearchFinishTime","showCountOf","showCountOnSearch","sortValueBy","tabIndex","valueConsistsOf","valueFormat","zIndex","data","trigger","isFocused","searchQuery","menu","isOpen","current","lastScrollPosition","placement","forest","normalizedOptions","nodeMap","checkedStateMap","selectedNodeIds","extractCheckedNodeIdsFromValue","selectedNodeMap","rootOptionsStates","isLoaded","isLoading","loadingError","localSearch","active","noResults","countMap","lastSearchInput","remoteSearch","hasBranchNodes","computed","selectedNodes","map","getNode","internalValue","single","filter","id","node","isRootNode","isSelected","isLeaf","children","indeterminateNodeIds","selectedNode","ancestors","ancestor","sort","sortValueByLevel","hasValue","visibleOptionIds","traverseAllNodesByIndex","shouldOptionBeIncludedInSearchResult","isBranch","shouldExpand","hasVisibleOptions","showCountOnSearchComputed","shouldFlattenOptions","watch","newValue","openMenu","closeMenu","initialize","oldValue","$emit","getValue","getInstanceId","buildForestState","handler","deep","immediate","handleRemoteSearch","handleLocalSearch","nodeIdsFromValue","fixSelectedNodeIds","methods","verifyProps","propName","resetFlags","_blurOnSelect","getRemoteSearchEntry","prevNodeMap","keepDataOfSelectedNodes","normalize","some","rootNode","rawNodes","raw","nodeId","createFallbackNode","extractNodeFromValue","fallbackNode","label","enhancedNormalizer","isFallbackNode","isDisabled","isNew","$set","defaultNode","nodeIdListOfPrevValue","nextSelectedNodeIds","traverseDescendantsBFS","descendant","queue","shift","callback","currNode","traverseDescendantsDFS","child","traverseAllNodesDFS","walk","toggleClickOutsideEvent","enabled","handleClickOutside","getValueContainer","$refs","control","getInput","input","focusInput","focus","blurInput","blur","handleMouseDown","preventDefault","stopPropagation","contains","wrapper","retry","resetHighlightedOptionWhenNecessary","ignore","diff","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","$menu","portal","portalTarget","setCurrentHighlightedOption","scroll","prev","isHighlighted","scrollToOption","$option","querySelector","$nextTick","forceReset","highlightFirstOption","first","highlightPrevOption","highlightLastOption","highlightNextOption","last","getLast","resetSearchQuery","saveMenuScrollPosition","restoreMenuScrollPosition","loadRootOptions","toggleMenu","toggleExpanded","nextState","childrenStates","loadChildrenOptions","selectedNodeId","ancestorNode","nodes","checkDuplication","verifyNodeShape","isDefaultExpanded","normalized","hasDisabledDescendants","branchNodes","option","leafNodes","once","catch","console","error","JSON","stringify","select","clear","_selectNode","_deselectNode","addValue","isFullyChecked","curr","removeValue","hasUncheckedSomeDescendants","removeLastValue","lastValue","lastSelectedNode","created","mounted","destroyed","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","component","__file","inputWidth","_h","$createElement","_c","_self","attrs","xmlns","viewBox","_withStripped","VERSION","Treeselect","PKG_VERSION"],"mappings":"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","file":"vue-treeselect.umd.min.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__19__) {\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 = 38);\n","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;","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","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\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;","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;","/**\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 isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\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 = value.replace(reTrim, '');\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\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","'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 if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n module.exports = _typeof = function _typeof(obj) {\n return typeof obj;\n };\n } else {\n module.exports = _typeof = function _typeof(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_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;","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;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","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;","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 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 value\n if (typeof value === 'number' && !isNaN(value)) return value + ''\n // istanbul ignore next\n return ''\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 * For performance we can set a start search length. It doesn't run search until sat length. If there are thounds of options then this helps well.\n * default: 1\n */\n startSearchLength: {\n type: Number,\n default: 1,\n },\n\n /**\n * For performance we can set a wait time for search. It wait between characters sat time and run search on time only last. It helps much options there.\n * default: 0\n * time measurement: millisecond\n */\n waitSearchFinishTime: {\n type: Number,\n default: 0,\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 lastSearchInput: null,\n\n // map.\n remoteSearch: createMap(),\n /**\n * Is there any branch node?\n * @type {boolean}\n */\n hasBranchNodes: null,\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 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 ? this.options.filter(o => o) : {}\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 this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch)\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.internalValue.slice()\n : this.internalValue[0]\n }\n\n const rawNodes = this.internalValue.map(id => this.getNode(id).raw)\n return this.multiple ? rawNodes : rawNodes[0]\n },\n\n getNode(nodeId) {\n warning(\n () => nodeId != null,\n () => `Invalid node id: ${nodeId}`,\n )\n\n if (nodeId == null) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(this.options)\n }\n return null\n }\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 if (!nodeId) {\n return\n }\n nextSelectedNodeIds.push(nodeId)\n const node = this.getNode(nodeId)\n if (node && node.isBranch) this.traverseDescendantsBFS(node, descendant => {\n if (descendant) {\n nextSelectedNodeIds.push(descendant.id)\n }\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) 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) 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(retry) {\n const { searchQuery } = this.trigger\n const done = () => this.resetHighlightedOptionWhenNecessary(true)\n const ignore = () => this.resetHighlightedOptionWhenNecessary(false)\n\n if (!searchQuery) {\n // Exit sync search mode.\n this.localSearch.active = false\n this.lastSearchInput = null\n return done()\n }\n\n if (searchQuery.length < this.startSearchLength) {\n // Ignore.\n return ignore()\n }\n\n if (this.waitSearchFinishTime > 0) {\n // If waitSearchFinishTime configured.\n const now = new Date()\n if (!this.lastSearchInput) {\n // First time.\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return ignore()\n }\n\n const diff = now - this.lastSearchInput\n if (diff < this.waitSearchFinishTime && !retry) {\n setTimeout(() => {\n this.handleLocalSearch(true)\n }, this.waitSearchFinishTime)\n\n this.lastSearchInput = now\n return ignore()\n }\n\n if (retry && diff < this.waitSearchFinishTime) {\n return ignore()\n }\n\n this.lastSearchInput = now\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 = 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 // Reset time\n this.lastSearchInput = null\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 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 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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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:\n \"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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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(\"C:\\\\Users\\\\dd\\\\Works\\\\Projects\\\\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/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index 54d168f7..fa712a0f 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -1228,6 +1228,7 @@ export default { handleLocalSearch(retry) { const { searchQuery } = this.trigger const done = () => this.resetHighlightedOptionWhenNecessary(true) + const ignore = () => this.resetHighlightedOptionWhenNecessary(false) if (!searchQuery) { // Exit sync search mode. @@ -1238,7 +1239,7 @@ export default { if (searchQuery.length < this.startSearchLength) { // Ignore. - return + return ignore() } if (this.waitSearchFinishTime > 0) { @@ -1251,7 +1252,7 @@ export default { }, this.waitSearchFinishTime) this.lastSearchInput = now - return + return ignore() } const diff = now - this.lastSearchInput @@ -1261,11 +1262,11 @@ export default { }, this.waitSearchFinishTime) this.lastSearchInput = now - return + return ignore() } if (retry && diff < this.waitSearchFinishTime) { - return + return ignore() } this.lastSearchInput = now From b88b272597a9b716e15de4b630427ea2cb6a3c67 Mon Sep 17 00:00:00 2001 From: Almas Date: Sun, 8 Aug 2021 21:59:37 +0800 Subject: [PATCH 09/20] test: added tests --- test/unit/specs/Searching.spec.js | 91 +++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) diff --git a/test/unit/specs/Searching.spec.js b/test/unit/specs/Searching.spec.js index 3a4c634f..58a5a068 100644 --- a/test/unit/specs/Searching.spec.js +++ b/test/unit/specs/Searching.spec.js @@ -221,6 +221,97 @@ describe('Searching', () => { await typeSearchText(wrapper, '') expect(vm.menu.current).toBe('a') }) + + it('ignore when set startSearchLength', async () => { + const wrapper = mount(Treeselect, { + propsData: { + options: [ { + id: 'a', + label: 'a', + }, { + id: 'b', + label: 'b', + children: [ { + id: 'ba', + label: 'ba', + }, { + id: 'bb', + label: 'bb', + } ], + }, + { + id: 'cccccc', + label: 'cccccc', + } ], + startSearchLength: 3, + }, + }) + const { vm } = wrapper + + vm.openMenu() + await vm.$nextTick() + + expect(vm.menu.current).toBe('a') + + await typeSearchText(wrapper, 'c') + expect(vm.menu.current).toBe('a') + + await typeSearchText(wrapper, 'cc') + expect(vm.menu.current).toBe('a') + + await typeSearchText(wrapper, 'ccc') + expect(vm.menu.current).toBe('cccccc') + + await typeSearchText(wrapper, 'cccc') + expect(vm.menu.current).toBe('cccccc') + }) + + it('ignore when set waitSearchFinishTime between chars', async () => { + const wrapper = mount(Treeselect, { + propsData: { + options: [ { + id: 'a', + label: 'a', + }, { + id: 'b', + label: 'b', + children: [ { + id: 'ba', + label: 'ba', + }, { + id: 'bb', + label: 'bb', + } ], + }, + { + id: 'cccccc', + label: 'cccccc', + } ], + waitSearchFinishTime: 100, + }, + }) + const { vm } = wrapper + + vm.openMenu() + await vm.$nextTick() + + expect(vm.menu.current).toBe('a') + + await typeSearchText(wrapper, 'c') + expect(vm.menu.current).toBe('a') + + await sleep(10) + await typeSearchText(wrapper, 'cc') + expect(vm.menu.current).toBe('a') + + await sleep(101) + await typeSearchText(wrapper, 'ccc') + expect(vm.menu.current).toBe('cccccc') + + await sleep(102) + await typeSearchText(wrapper, 'cccc') + expect(vm.menu.current).toBe('cccccc') + }) }) describe('fuzzy search', () => { From 43be7696207fddaaa5d05e8b37105333b297d532 Mon Sep 17 00:00:00 2001 From: Chris Morison Date: Wed, 24 Feb 2021 21:57:45 +1300 Subject: [PATCH 10/20] pressing enter after invalid search should be noop. Fixes #442 --- src/components/Input.vue | 2 +- test/unit/specs/KeyboardSupport.spec.js | 29 +++++++++++++++++++++++++ 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/src/components/Input.vue b/src/components/Input.vue index 89860404..eb6056bb 100644 --- a/src/components/Input.vue +++ b/src/components/Input.vue @@ -138,7 +138,7 @@ evt.preventDefault() if (instance.menu.current === null) return const current = instance.getNode(instance.menu.current) - if (current.isBranch && instance.disableBranchNodes) return + if ((current.isBranch && instance.disableBranchNodes) || !current.isMatched) return instance.select(current) break } diff --git a/test/unit/specs/KeyboardSupport.spec.js b/test/unit/specs/KeyboardSupport.spec.js index 97b94cd4..2e0922f1 100644 --- a/test/unit/specs/KeyboardSupport.spec.js +++ b/test/unit/specs/KeyboardSupport.spec.js @@ -123,11 +123,13 @@ describe('Keyboard Support', () => { wrapper.setProps({ multiple: false }) + await typeSearchText(wrapper, 'a') pressEnterKey(wrapper) expect(vm.internalValue).toEqual([ 'a' ]) pressEnterKey(wrapper) expect(vm.internalValue).toEqual([ 'a' ]) + await typeSearchText(wrapper, 'b') vm.setCurrentHighlightedOption(vm.forest.nodeMap.b) expect(vm.menu.current).toBe('b') pressEnterKey(wrapper) @@ -139,17 +141,44 @@ describe('Keyboard Support', () => { wrapper.setProps({ multiple: true }) + await typeSearchText(wrapper, 'a') pressEnterKey(wrapper) expect(vm.internalValue).toEqual([ 'a' ]) pressEnterKey(wrapper) expect(vm.internalValue).toEqual([]) + await typeSearchText(wrapper, 'b') vm.setCurrentHighlightedOption(vm.forest.nodeMap.b) expect(vm.menu.current).toBe('b') pressEnterKey(wrapper) expect(vm.internalValue).toEqual([ 'b' ]) }) + // https://github.com/riophae/vue-treeselect/issues/442 + it('pressing enter after invalid search should be a no-op (single-select)', async () => { + const { wrapper, vm } = await createInstance() + + wrapper.setProps({ multiple: false }) + + await typeSearchText(wrapper, 'a') + await typeSearchText(wrapper, 'ab') + pressEnterKey(wrapper) + expect(vm.internalValue).toEqual([]) + pressEnterKey(wrapper) + expect(vm.internalValue).toEqual([]) + }) + + it('pressing enter after invalid search should be a no-op (multi-select)', async () => { + const { wrapper, vm } = await createInstance() + + wrapper.setProps({ multiple: true }) + + await typeSearchText(wrapper, 'a') + await typeSearchText(wrapper, 'ab') + pressEnterKey(wrapper) + expect(vm.internalValue).toEqual([]) + }) + it('pressing enter key on a disabled option should be no-op', async () => { const { wrapper, vm } = await createInstance() From 8b6a1f1ce9a8995b197dc7008d91fa287d2608cf Mon Sep 17 00:00:00 2001 From: Almas Date: Sun, 8 Aug 2021 22:45:37 +0800 Subject: [PATCH 11/20] fix: Expand parent nodes of selected item. #310 Scroll menu to selected item, by center. Pull request by varlamov88. --- src/mixins/treeselectMixin.js | 36 +++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index fa712a0f..cee94130 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -655,6 +655,14 @@ export default { type: [ Number, String ], default: 999, }, + + /** + * Set selected option to the center of the menu, if possible + */ + scrollPositionOnCenter: { + type: Boolean, + default: false + } }, data() { @@ -961,6 +969,7 @@ export default { } this.hasBranchNodes = this.forest.normalizedOptions.some(rootNode => rootNode.isBranch) + this.expandParentNodes() }, getInstanceId() { @@ -1525,6 +1534,9 @@ export default { this.$nextTick(this.restoreMenuScrollPosition) if (!this.options && !this.async) this.loadRootOptions() this.toggleClickOutsideEvent(true) + if (this.scrollPositionOnCenter) { + this.$nextTick(this.scrollMenuOnCenter); + } this.$emit('open', this.getInstanceId()) }, @@ -1843,12 +1855,16 @@ export default { this.buildForestState() if (nextState) { + this.expandParentNodes(); this.$emit('select', node.raw, this.getInstanceId()) } else { this.$emit('deselect', node.raw, this.getInstanceId()) } if (this.localSearch.active && nextState && (this.single || this.clearOnSelect)) { + if (this.scrollPositionOnCenter) { + this.$nextTick(this.scrollMenuOnCenter); + } this.resetSearchQuery() } @@ -1990,16 +2006,36 @@ export default { }, saveMenuScrollPosition() { + if (this.scrollPositionOnCenter) return; const $menu = this.getMenu() // istanbul ignore else if ($menu) this.menu.lastScrollPosition = $menu.scrollTop }, restoreMenuScrollPosition() { + if (this.scrollPositionOnCenter) return; const $menu = this.getMenu() // istanbul ignore else if ($menu) $menu.scrollTop = this.menu.lastScrollPosition }, + + scrollMenuOnCenter() { + const $option = document.querySelector(".vue-treeselect__option--selected"); + const $menu = this.getMenu(); + + if ($option && $menu) { + const position = Math.max($option.offsetTop - (($menu.offsetHeight - $option.offsetHeight) / 2), 0); + $menu.scrollTop = position; + } + }, + + expandParentNodes() { + for (const id of this.forest.selectedNodeIds) { + for (const ancestor of this.forest.nodeMap[id].ancestors) { + ancestor.isExpanded = true; + } + } + } }, created() { From 22ad9f80c8aecea41d0c42afe1d3db82a78e6fa7 Mon Sep 17 00:00:00 2001 From: Almas Date: Sun, 8 Aug 2021 22:52:57 +0800 Subject: [PATCH 12/20] lint: Fixed lint problems. --- src/mixins/treeselectMixin.js | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index cee94130..07ee30b6 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -661,8 +661,8 @@ export default { */ scrollPositionOnCenter: { type: Boolean, - default: false - } + default: false, + }, }, data() { @@ -1535,7 +1535,7 @@ export default { if (!this.options && !this.async) this.loadRootOptions() this.toggleClickOutsideEvent(true) if (this.scrollPositionOnCenter) { - this.$nextTick(this.scrollMenuOnCenter); + this.$nextTick(this.scrollMenuOnCenter) } this.$emit('open', this.getInstanceId()) }, @@ -1855,7 +1855,7 @@ export default { this.buildForestState() if (nextState) { - this.expandParentNodes(); + this.expandParentNodes() this.$emit('select', node.raw, this.getInstanceId()) } else { this.$emit('deselect', node.raw, this.getInstanceId()) @@ -1863,7 +1863,7 @@ export default { if (this.localSearch.active && nextState && (this.single || this.clearOnSelect)) { if (this.scrollPositionOnCenter) { - this.$nextTick(this.scrollMenuOnCenter); + this.$nextTick(this.scrollMenuOnCenter) } this.resetSearchQuery() } @@ -2006,36 +2006,36 @@ export default { }, saveMenuScrollPosition() { - if (this.scrollPositionOnCenter) return; + if (this.scrollPositionOnCenter) return const $menu = this.getMenu() // istanbul ignore else if ($menu) this.menu.lastScrollPosition = $menu.scrollTop }, restoreMenuScrollPosition() { - if (this.scrollPositionOnCenter) return; + if (this.scrollPositionOnCenter) return const $menu = this.getMenu() // istanbul ignore else if ($menu) $menu.scrollTop = this.menu.lastScrollPosition }, scrollMenuOnCenter() { - const $option = document.querySelector(".vue-treeselect__option--selected"); - const $menu = this.getMenu(); + const $option = document.querySelector('.vue-treeselect__option--selected') + const $menu = this.getMenu() if ($option && $menu) { - const position = Math.max($option.offsetTop - (($menu.offsetHeight - $option.offsetHeight) / 2), 0); - $menu.scrollTop = position; + const position = Math.max($option.offsetTop - (($menu.offsetHeight - $option.offsetHeight) / 2), 0) + $menu.scrollTop = position } }, expandParentNodes() { for (const id of this.forest.selectedNodeIds) { for (const ancestor of this.forest.nodeMap[id].ancestors) { - ancestor.isExpanded = true; + ancestor.isExpanded = true } } - } + }, }, created() { From 32bf4c93e3ef9db36e115d5b0772d0ca969210a4 Mon Sep 17 00:00:00 2001 From: Almas Date: Sun, 8 Aug 2021 23:16:39 +0800 Subject: [PATCH 13/20] fix: lint & undefined node & test --- src/mixins/treeselectMixin.js | 6 +++++- test/unit/specs/Props.spec.js | 1 - 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index 07ee30b6..30b7fea5 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -2031,7 +2031,11 @@ export default { expandParentNodes() { for (const id of this.forest.selectedNodeIds) { - for (const ancestor of this.forest.nodeMap[id].ancestors) { + const node = this.getNode(id) + if (!node) { + continue + } + for (const ancestor of node.ancestors) { ancestor.isExpanded = true } } diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index 5a9738d8..68adf77f 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -1875,7 +1875,6 @@ describe('Props', () => { vm.toggleExpanded(vm.forest.nodeMap.a) expect(vm.isSelected(vm.forest.nodeMap.a)).toBe(true) - expect(vm.forest.nodeMap.a.isExpanded).toBe(true) expect(vm.forest.checkedStateMap).toEqual({ a: CHECKED, aa: CHECKED, From ed625a67df20f018977a3907193f1e918bbd5302 Mon Sep 17 00:00:00 2001 From: Almas Date: Mon, 9 Aug 2021 00:04:56 +0800 Subject: [PATCH 14/20] test: Added scrollPositionOnCenter test. --- test/unit/specs/Props.spec.js | 37 +++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index 68adf77f..89769cab 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -8,6 +8,7 @@ import { typeSearchText, findInputContainer, findInput, + findMenu, findMenuContainer, findOptionByNodeId, findLabelContainerByNodeId, @@ -1933,6 +1934,42 @@ describe('Props', () => { expect(vm.forest.nodeMap.a.label).toBe('a') expect(vm.forest.nodeMap.a.isFallbackNode).toBe(true) }) + + it('scrollPositionOnCenter check', async () => { + const wrapper = mount(Treeselect, { + propsData: { + options: [ { + id: 'a', + label: 'a', + }, + { + id: 'b', + label: 'b', + }, + { + id: 'c', + label: 'c', + }, + { + id: 'd', + label: 'd', + } ], + value: 'd', + scrollPositionOnCenter: true, + }, + }) + const { vm } = wrapper + + vm.openMenu() + await vm.$nextTick() + sleep(100) + const menu = findMenu(wrapper) + if (wrapper.contains('.vue-treeselect__option--selected') && menu.element.scrollHeight > menu.element.clientHeight) { + expect(menu.element.scrollTop).toBeGreaterThan(0) + } + vm.closeMenu() + await vm.$nextTick() + }) }) }) From 6aa455e37e7c0aac586d101ea2cc7b79b76c7cd6 Mon Sep 17 00:00:00 2001 From: Almas Date: Mon, 9 Aug 2021 00:15:36 +0800 Subject: [PATCH 15/20] test: improved test scrollMenuOnCenter --- test/unit/specs/Props.spec.js | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index 89769cab..bb7c3494 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -1941,6 +1941,20 @@ describe('Props', () => { options: [ { id: 'a', label: 'a', + children: [ { + id: 'aa', + label: 'aa', + }, { + id: 'ab', + label: 'ab', + children: [ { + id: 'aba', + label: 'aba', + }, { + id: 'abbb', + label: 'abbb', + } ], + } ], }, { id: 'b', @@ -1954,8 +1968,9 @@ describe('Props', () => { id: 'd', label: 'd', } ], - value: 'd', + value: 'abbb', scrollPositionOnCenter: true, + clearOnSelect: true, }, }) const { vm } = wrapper From dbfc79398558c81e80da9a339b272dc8fc198f1e Mon Sep 17 00:00:00 2001 From: Almas Date: Mon, 9 Aug 2021 00:23:26 +0800 Subject: [PATCH 16/20] test: trying to cover test scrollPositionOnCenter --- test/unit/specs/Props.spec.js | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index bb7c3494..6304db7b 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -1977,11 +1977,20 @@ describe('Props', () => { vm.openMenu() await vm.$nextTick() - sleep(100) + sleep(50) const menu = findMenu(wrapper) if (wrapper.contains('.vue-treeselect__option--selected') && menu.element.scrollHeight > menu.element.clientHeight) { expect(menu.element.scrollTop).toBeGreaterThan(0) } + + wrapper.setProps({ value: null }) + vm.localSearch.active = true + sleep(50) + + if (wrapper.contains('.vue-treeselect__option--selected') && menu.element.scrollHeight > menu.element.clientHeight) { + expect(menu.element.scrollTop).toBeGreaterThan(0) + } + vm.closeMenu() await vm.$nextTick() }) From 3f91e917e6c8d28b120133d60d4544d6a5fb4d43 Mon Sep 17 00:00:00 2001 From: Almas Date: Mon, 9 Aug 2021 00:30:43 +0800 Subject: [PATCH 17/20] test: trying to cover test scrollPositionOnCenter --- src/mixins/treeselectMixin.js | 3 --- test/unit/specs/Props.spec.js | 8 +++----- 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/src/mixins/treeselectMixin.js b/src/mixins/treeselectMixin.js index 30b7fea5..754dd504 100644 --- a/src/mixins/treeselectMixin.js +++ b/src/mixins/treeselectMixin.js @@ -2032,9 +2032,6 @@ export default { expandParentNodes() { for (const id of this.forest.selectedNodeIds) { const node = this.getNode(id) - if (!node) { - continue - } for (const ancestor of node.ancestors) { ancestor.isExpanded = true } diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index 6304db7b..00c99ed2 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -1970,7 +1970,6 @@ describe('Props', () => { } ], value: 'abbb', scrollPositionOnCenter: true, - clearOnSelect: true, }, }) const { vm } = wrapper @@ -1983,13 +1982,12 @@ describe('Props', () => { expect(menu.element.scrollTop).toBeGreaterThan(0) } - wrapper.setProps({ value: null }) + wrapper.setProps({ value: null, + clearOnSelect: true }) vm.localSearch.active = true sleep(50) - if (wrapper.contains('.vue-treeselect__option--selected') && menu.element.scrollHeight > menu.element.clientHeight) { - expect(menu.element.scrollTop).toBeGreaterThan(0) - } + vm.select(vm.forest.nodeMap.aa) vm.closeMenu() await vm.$nextTick() From 5b1c18bf8b5902f4b4e08041051d6be30c76b705 Mon Sep 17 00:00:00 2001 From: Almas Date: Mon, 9 Aug 2021 00:34:16 +0800 Subject: [PATCH 18/20] test: trying to cover test scrollPositionOnCenter --- test/unit/specs/Props.spec.js | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index 00c99ed2..c5d569e3 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -1991,6 +1991,9 @@ describe('Props', () => { vm.closeMenu() await vm.$nextTick() + sleep(50) + vm.openMenu() + await vm.$nextTick() }) }) }) From b979c6e446e98e554c373cfff1f3e48779ff5abe Mon Sep 17 00:00:00 2001 From: Almas Date: Mon, 9 Aug 2021 00:50:57 +0800 Subject: [PATCH 19/20] test: trying to cover test scrollPositionOnCenter --- test/unit/specs/Props.spec.js | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index c5d569e3..2587a16e 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -1953,6 +1953,15 @@ describe('Props', () => { }, { id: 'abbb', label: 'abbb', + }, { + id: 'abbc', + label: 'abbc', + }, { + id: 'abbd', + label: 'abbd', + }, { + id: 'abbe', + label: 'abbe', } ], } ], }, @@ -1968,7 +1977,7 @@ describe('Props', () => { id: 'd', label: 'd', } ], - value: 'abbb', + value: 'd', scrollPositionOnCenter: true, }, }) @@ -1987,13 +1996,16 @@ describe('Props', () => { vm.localSearch.active = true sleep(50) - vm.select(vm.forest.nodeMap.aa) + vm.select(vm.forest.nodeMap.abbb) vm.closeMenu() await vm.$nextTick() - sleep(50) + sleep(100) vm.openMenu() await vm.$nextTick() + wrapper.setProps({ clearOnSelect: false }) + sleep(50) + vm.select(vm.forest.nodeMap.abbe) }) }) }) From 0809e4be0c34a334f223da05f908f4023d418217 Mon Sep 17 00:00:00 2001 From: Almas Date: Mon, 9 Aug 2021 01:07:43 +0800 Subject: [PATCH 20/20] test: trying to cover test scrollPositionOnCenter --- test/unit/specs/Props.spec.js | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/test/unit/specs/Props.spec.js b/test/unit/specs/Props.spec.js index 2587a16e..0aa81e99 100644 --- a/test/unit/specs/Props.spec.js +++ b/test/unit/specs/Props.spec.js @@ -1985,7 +1985,7 @@ describe('Props', () => { vm.openMenu() await vm.$nextTick() - sleep(50) + sleep(51) const menu = findMenu(wrapper) if (wrapper.contains('.vue-treeselect__option--selected') && menu.element.scrollHeight > menu.element.clientHeight) { expect(menu.element.scrollTop).toBeGreaterThan(0) @@ -1994,18 +1994,15 @@ describe('Props', () => { wrapper.setProps({ value: null, clearOnSelect: true }) vm.localSearch.active = true - sleep(50) + sleep(51) vm.select(vm.forest.nodeMap.abbb) + sleep(51) + vm.select(vm.forest.nodeMap.abbe) + sleep(51) vm.closeMenu() await vm.$nextTick() - sleep(100) - vm.openMenu() - await vm.$nextTick() - wrapper.setProps({ clearOnSelect: false }) - sleep(50) - vm.select(vm.forest.nodeMap.abbe) }) }) })