antd3-esm 1.0.1

package/dist/tree.js

@@ -0,0 +1,3017 @@
+import * as React from 'react';
+import React__default, { Children } from 'react';
+import { e as requireReactIs, g as getDefaultExportFromCjs, f as requireWarning, a as commonjsGlobal, h as createReactContext, P as PropTypes, c as classNames, C as ConfigConsumer } from './config-provider.js';
+import { p as polyfill, O as OriginCSSMotion } from './menu.js';
+import { o as omit } from './input.js';
+import { I as Icon } from './icon.js';
+
+var reactIsExports = requireReactIs();
+
+function toArray(children) {
+  var ret = [];
+  React__default.Children.forEach(children, function (child) {
+    if (child === undefined || child === null) {
+      return;
+    }
+
+    if (Array.isArray(child)) {
+      ret = ret.concat(toArray(child));
+    } else if (reactIsExports.isFragment(child) && child.props) {
+      ret = ret.concat(toArray(child.props.children));
+    } else {
+      ret.push(child);
+    }
+  });
+  return ret;
+}
+
+var warningExports = requireWarning();
+var warning = /*@__PURE__*/getDefaultExportFromCjs(warningExports);
+
+// ================== Collapse Motion ==================
+var getCollapsedHeight = function getCollapsedHeight() {
+  return {
+    height: 0,
+    opacity: 0
+  };
+};
+
+var getRealHeight = function getRealHeight(node) {
+  return {
+    height: node.scrollHeight,
+    opacity: 1
+  };
+};
+
+var getCurrentHeight = function getCurrentHeight(node) {
+  return {
+    height: node.offsetHeight
+  };
+};
+
+var collapseMotion = {
+  motionName: 'ant-motion-collapse',
+  onAppearStart: getCollapsedHeight,
+  onEnterStart: getCollapsedHeight,
+  onAppearActive: getRealHeight,
+  onEnterActive: getRealHeight,
+  onLeaveStart: getCurrentHeight,
+  onLeaveActive: getCollapsedHeight
+};
+
+/**
+ * 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
+ */
+
+var isObject_1;
+var hasRequiredIsObject;
+
+function requireIsObject () {
+	if (hasRequiredIsObject) return isObject_1;
+	hasRequiredIsObject = 1;
+	function isObject(value) {
+	  var type = typeof value;
+	  return value != null && (type == 'object' || type == 'function');
+	}
+
+	isObject_1 = isObject;
+	return isObject_1;
+}
+
+/** Detect free variable `global` from Node.js. */
+
+var _freeGlobal;
+var hasRequired_freeGlobal;
+
+function require_freeGlobal () {
+	if (hasRequired_freeGlobal) return _freeGlobal;
+	hasRequired_freeGlobal = 1;
+	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+	_freeGlobal = freeGlobal;
+	return _freeGlobal;
+}
+
+var _root;
+var hasRequired_root;
+
+function require_root () {
+	if (hasRequired_root) return _root;
+	hasRequired_root = 1;
+	var freeGlobal = require_freeGlobal();
+
+	/** 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')();
+
+	_root = root;
+	return _root;
+}
+
+var now_1;
+var hasRequiredNow;
+
+function requireNow () {
+	if (hasRequiredNow) return now_1;
+	hasRequiredNow = 1;
+	var root = require_root();
+
+	/**
+	 * 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();
+	};
+
+	now_1 = now;
+	return now_1;
+}
+
+/** Used to match a single whitespace character. */
+
+var _trimmedEndIndex;
+var hasRequired_trimmedEndIndex;
+
+function require_trimmedEndIndex () {
+	if (hasRequired_trimmedEndIndex) return _trimmedEndIndex;
+	hasRequired_trimmedEndIndex = 1;
+	var reWhitespace = /\s/;
+
+	/**
+	 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+	 * character of `string`.
+	 *
+	 * @private
+	 * @param {string} string The string to inspect.
+	 * @returns {number} Returns the index of the last non-whitespace character.
+	 */
+	function trimmedEndIndex(string) {
+	  var index = string.length;
+
+	  while (index-- && reWhitespace.test(string.charAt(index))) {}
+	  return index;
+	}
+
+	_trimmedEndIndex = trimmedEndIndex;
+	return _trimmedEndIndex;
+}
+
+var _baseTrim;
+var hasRequired_baseTrim;
+
+function require_baseTrim () {
+	if (hasRequired_baseTrim) return _baseTrim;
+	hasRequired_baseTrim = 1;
+	var trimmedEndIndex = require_trimmedEndIndex();
+
+	/** Used to match leading whitespace. */
+	var reTrimStart = /^\s+/;
+
+	/**
+	 * The base implementation of `_.trim`.
+	 *
+	 * @private
+	 * @param {string} string The string to trim.
+	 * @returns {string} Returns the trimmed string.
+	 */
+	function baseTrim(string) {
+	  return string
+	    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+	    : string;
+	}
+
+	_baseTrim = baseTrim;
+	return _baseTrim;
+}
+
+var _Symbol;
+var hasRequired_Symbol;
+
+function require_Symbol () {
+	if (hasRequired_Symbol) return _Symbol;
+	hasRequired_Symbol = 1;
+	var root = require_root();
+
+	/** Built-in value references. */
+	var Symbol = root.Symbol;
+
+	_Symbol = Symbol;
+	return _Symbol;
+}
+
+var _getRawTag;
+var hasRequired_getRawTag;
+
+function require_getRawTag () {
+	if (hasRequired_getRawTag) return _getRawTag;
+	hasRequired_getRawTag = 1;
+	var Symbol = require_Symbol();
+
+	/** 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;
+	}
+
+	_getRawTag = getRawTag;
+	return _getRawTag;
+}
+
+/** Used for built-in method references. */
+
+var _objectToString;
+var hasRequired_objectToString;
+
+function require_objectToString () {
+	if (hasRequired_objectToString) return _objectToString;
+	hasRequired_objectToString = 1;
+	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);
+	}
+
+	_objectToString = objectToString;
+	return _objectToString;
+}
+
+var _baseGetTag;
+var hasRequired_baseGetTag;
+
+function require_baseGetTag () {
+	if (hasRequired_baseGetTag) return _baseGetTag;
+	hasRequired_baseGetTag = 1;
+	var Symbol = require_Symbol(),
+	    getRawTag = require_getRawTag(),
+	    objectToString = require_objectToString();
+
+	/** `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);
+	}
+
+	_baseGetTag = baseGetTag;
+	return _baseGetTag;
+}
+
+/**
+ * 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
+ */
+
+var isObjectLike_1;
+var hasRequiredIsObjectLike;
+
+function requireIsObjectLike () {
+	if (hasRequiredIsObjectLike) return isObjectLike_1;
+	hasRequiredIsObjectLike = 1;
+	function isObjectLike(value) {
+	  return value != null && typeof value == 'object';
+	}
+
+	isObjectLike_1 = isObjectLike;
+	return isObjectLike_1;
+}
+
+var isSymbol_1;
+var hasRequiredIsSymbol;
+
+function requireIsSymbol () {
+	if (hasRequiredIsSymbol) return isSymbol_1;
+	hasRequiredIsSymbol = 1;
+	var baseGetTag = require_baseGetTag(),
+	    isObjectLike = requireIsObjectLike();
+
+	/** `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);
+	}
+
+	isSymbol_1 = isSymbol;
+	return isSymbol_1;
+}
+
+var toNumber_1;
+var hasRequiredToNumber;
+
+function requireToNumber () {
+	if (hasRequiredToNumber) return toNumber_1;
+	hasRequiredToNumber = 1;
+	var baseTrim = require_baseTrim(),
+	    isObject = requireIsObject(),
+	    isSymbol = requireIsSymbol();
+
+	/** Used as references for various `Number` constants. */
+	var NAN = 0 / 0;
+
+	/** Used to detect bad signed hexadecimal string values. */
+	var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+	/** Used to detect binary string values. */
+	var reIsBinary = /^0b[01]+$/i;
+
+	/** Used to detect octal string values. */
+	var reIsOctal = /^0o[0-7]+$/i;
+
+	/** Built-in method references without a dependency on `root`. */
+	var freeParseInt = parseInt;
+
+	/**
+	 * Converts `value` to a number.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to process.
+	 * @returns {number} Returns the number.
+	 * @example
+	 *
+	 * _.toNumber(3.2);
+	 * // => 3.2
+	 *
+	 * _.toNumber(Number.MIN_VALUE);
+	 * // => 5e-324
+	 *
+	 * _.toNumber(Infinity);
+	 * // => Infinity
+	 *
+	 * _.toNumber('3.2');
+	 * // => 3.2
+	 */
+	function toNumber(value) {
+	  if (typeof value == 'number') {
+	    return value;
+	  }
+	  if (isSymbol(value)) {
+	    return NAN;
+	  }
+	  if (isObject(value)) {
+	    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+	    value = isObject(other) ? (other + '') : other;
+	  }
+	  if (typeof value != 'string') {
+	    return value === 0 ? value : +value;
+	  }
+	  value = baseTrim(value);
+	  var isBinary = reIsBinary.test(value);
+	  return (isBinary || reIsOctal.test(value))
+	    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+	    : (reIsBadHex.test(value) ? NAN : +value);
+	}
+
+	toNumber_1 = toNumber;
+	return toNumber_1;
+}
+
+var debounce_1;
+var hasRequiredDebounce;
+
+function requireDebounce () {
+	if (hasRequiredDebounce) return debounce_1;
+	hasRequiredDebounce = 1;
+	var isObject = requireIsObject(),
+	    now = requireNow(),
+	    toNumber = requireToNumber();
+
+	/** 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;
+	}
+
+	debounce_1 = debounce;
+	return debounce_1;
+}
+
+var debounceExports = requireDebounce();
+var debounce = /*@__PURE__*/getDefaultExportFromCjs(debounceExports);
+
+var TreeContext = createReactContext(null);
+
+function _typeof$4(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$4 = function _typeof(obj) { return typeof obj; }; } else { _typeof$4 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$4(obj); }
+
+function _objectWithoutProperties$1(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$1(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose$1(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+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$2(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 _defineProperty$2(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; }
+
+function _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$3(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$3(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$3(Constructor.prototype, protoProps); return Constructor; }
+
+function _inherits$3(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$3(subClass, superClass); }
+
+function _setPrototypeOf$3(o, p) { _setPrototypeOf$3 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$3(o, p); }
+
+function _createSuper$3(Derived) { return function () { var Super = _getPrototypeOf$3(Derived), result; if (_isNativeReflectConstruct$3()) { var NewTarget = _getPrototypeOf$3(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$3(this, result); }; }
+
+function _possibleConstructorReturn$3(self, call) { if (call && (_typeof$4(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$3(self); }
+
+function _assertThisInitialized$3(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct$3() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf$3(o) { _getPrototypeOf$3 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$3(o); }
+var ICON_OPEN = 'open';
+var ICON_CLOSE = 'close';
+var defaultTitle = '---';
+
+var TreeNode = /*#__PURE__*/function (_React$Component) {
+  _inherits$3(TreeNode, _React$Component);
+
+  var _super = _createSuper$3(TreeNode);
+
+  function TreeNode() {
+    var _this;
+
+    _classCallCheck$3(this, TreeNode);
+
+    _this = _super.apply(this, arguments);
+    _this.state = {
+      dragNodeHighlight: false
+    };
+
+    _this.onSelectorClick = function (e) {
+      // Click trigger before select/check operation
+      var onNodeClick = _this.props.context.onNodeClick;
+      onNodeClick(e, _assertThisInitialized$3(_this));
+
+      if (_this.isSelectable()) {
+        _this.onSelect(e);
+      } else {
+        _this.onCheck(e);
+      }
+    };
+
+    _this.onSelectorDoubleClick = function (e) {
+      var onNodeDoubleClick = _this.props.context.onNodeDoubleClick;
+      onNodeDoubleClick(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onSelect = function (e) {
+      if (_this.isDisabled()) return;
+      var onNodeSelect = _this.props.context.onNodeSelect;
+      e.preventDefault();
+      onNodeSelect(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onCheck = function (e) {
+      if (_this.isDisabled()) return;
+      var _this$props = _this.props,
+          disableCheckbox = _this$props.disableCheckbox,
+          checked = _this$props.checked;
+      var onNodeCheck = _this.props.context.onNodeCheck;
+      if (!_this.isCheckable() || disableCheckbox) return;
+      e.preventDefault();
+      var targetChecked = !checked;
+      onNodeCheck(e, _assertThisInitialized$3(_this), targetChecked);
+    };
+
+    _this.onMouseEnter = function (e) {
+      var onNodeMouseEnter = _this.props.context.onNodeMouseEnter;
+      onNodeMouseEnter(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onMouseLeave = function (e) {
+      var onNodeMouseLeave = _this.props.context.onNodeMouseLeave;
+      onNodeMouseLeave(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onContextMenu = function (e) {
+      var onNodeContextMenu = _this.props.context.onNodeContextMenu;
+      onNodeContextMenu(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onDragStart = function (e) {
+      var onNodeDragStart = _this.props.context.onNodeDragStart;
+      e.stopPropagation();
+
+      _this.setState({
+        dragNodeHighlight: true
+      });
+
+      onNodeDragStart(e, _assertThisInitialized$3(_this));
+
+      try {
+        // ie throw error
+        // firefox-need-it
+        e.dataTransfer.setData('text/plain', '');
+      } catch (error) {// empty
+      }
+    };
+
+    _this.onDragEnter = function (e) {
+      var onNodeDragEnter = _this.props.context.onNodeDragEnter;
+      e.preventDefault();
+      e.stopPropagation();
+      onNodeDragEnter(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onDragOver = function (e) {
+      var onNodeDragOver = _this.props.context.onNodeDragOver;
+      e.preventDefault();
+      e.stopPropagation();
+      onNodeDragOver(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onDragLeave = function (e) {
+      var onNodeDragLeave = _this.props.context.onNodeDragLeave;
+      e.stopPropagation();
+      onNodeDragLeave(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onDragEnd = function (e) {
+      var onNodeDragEnd = _this.props.context.onNodeDragEnd;
+      e.stopPropagation();
+
+      _this.setState({
+        dragNodeHighlight: false
+      });
+
+      onNodeDragEnd(e, _assertThisInitialized$3(_this));
+    };
+
+    _this.onDrop = function (e) {
+      var onNodeDrop = _this.props.context.onNodeDrop;
+      e.preventDefault();
+      e.stopPropagation();
+
+      _this.setState({
+        dragNodeHighlight: false
+      });
+
+      onNodeDrop(e, _assertThisInitialized$3(_this));
+    }; // Disabled item still can be switch
+
+
+    _this.onExpand = function (e) {
+      var onNodeExpand = _this.props.context.onNodeExpand;
+      onNodeExpand(e, _assertThisInitialized$3(_this));
+    }; // Drag usage
+
+
+    _this.setSelectHandle = function (node) {
+      _this.selectHandle = node;
+    };
+
+    _this.getNodeChildren = function () {
+      var children = _this.props.children;
+      var originList = toArray(children).filter(function (node) {
+        return node;
+      });
+      var targetList = getNodeChildren(originList);
+
+      if (originList.length !== targetList.length) {
+        warnOnlyTreeNode();
+      }
+
+      return targetList;
+    };
+
+    _this.getNodeState = function () {
+      var expanded = _this.props.expanded;
+
+      if (_this.isLeaf()) {
+        return null;
+      }
+
+      return expanded ? ICON_OPEN : ICON_CLOSE;
+    };
+
+    _this.isLeaf = function () {
+      var _this$props2 = _this.props,
+          isLeaf = _this$props2.isLeaf,
+          loaded = _this$props2.loaded;
+      var loadData = _this.props.context.loadData;
+      var hasChildren = _this.getNodeChildren().length !== 0;
+
+      if (isLeaf === false) {
+        return false;
+      }
+
+      return isLeaf || !loadData && !hasChildren || loadData && loaded && !hasChildren;
+    };
+
+    _this.isDisabled = function () {
+      var disabled = _this.props.disabled;
+      var treeDisabled = _this.props.context.disabled; // Follow the logic of Selectable
+
+      if (disabled === false) {
+        return false;
+      }
+
+      return !!(treeDisabled || disabled);
+    };
+
+    _this.isCheckable = function () {
+      var checkable = _this.props.checkable;
+      var treeCheckable = _this.props.context.checkable; // Return false if tree or treeNode is not checkable
+
+      if (!treeCheckable || checkable === false) return false;
+      return treeCheckable;
+    }; // Load data to avoid default expanded tree without data
+
+
+    _this.syncLoadData = function (props) {
+      var expanded = props.expanded,
+          loading = props.loading,
+          loaded = props.loaded;
+      var _this$props$context = _this.props.context,
+          loadData = _this$props$context.loadData,
+          onNodeLoad = _this$props$context.onNodeLoad;
+      if (loading) return; // read from state to avoid loadData at same time
+
+      if (loadData && expanded && !_this.isLeaf()) {
+        // We needn't reload data when has children in sync logic
+        // It's only needed in node expanded
+        var hasChildren = _this.getNodeChildren().length !== 0;
+
+        if (!hasChildren && !loaded) {
+          onNodeLoad(_assertThisInitialized$3(_this));
+        }
+      }
+    }; // Switcher
+
+
+    _this.renderSwitcher = function () {
+      var _this$props3 = _this.props,
+          expanded = _this$props3.expanded,
+          switcherIconFromProps = _this$props3.switcherIcon;
+      var _this$props$context2 = _this.props.context,
+          prefixCls = _this$props$context2.prefixCls,
+          switcherIconFromCtx = _this$props$context2.switcherIcon;
+      var switcherIcon = switcherIconFromProps || switcherIconFromCtx;
+
+      if (_this.isLeaf()) {
+        return React.createElement("span", {
+          className: classNames("".concat(prefixCls, "-switcher"), "".concat(prefixCls, "-switcher-noop"))
+        }, typeof switcherIcon === 'function' ? switcherIcon(_objectSpread({}, _this.props, {
+          isLeaf: true
+        })) : switcherIcon);
+      }
+
+      var switcherCls = classNames("".concat(prefixCls, "-switcher"), "".concat(prefixCls, "-switcher_").concat(expanded ? ICON_OPEN : ICON_CLOSE));
+      return React.createElement("span", {
+        onClick: _this.onExpand,
+        className: switcherCls
+      }, typeof switcherIcon === 'function' ? switcherIcon(_objectSpread({}, _this.props, {
+        isLeaf: false
+      })) : switcherIcon);
+    }; // Checkbox
+
+
+    _this.renderCheckbox = function () {
+      var _this$props4 = _this.props,
+          checked = _this$props4.checked,
+          halfChecked = _this$props4.halfChecked,
+          disableCheckbox = _this$props4.disableCheckbox;
+      var prefixCls = _this.props.context.prefixCls;
+
+      var disabled = _this.isDisabled();
+
+      var checkable = _this.isCheckable();
+
+      if (!checkable) return null; // [Legacy] Custom element should be separate with `checkable` in future
+
+      var $custom = typeof checkable !== 'boolean' ? checkable : null;
+      return React.createElement("span", {
+        className: classNames("".concat(prefixCls, "-checkbox"), checked && "".concat(prefixCls, "-checkbox-checked"), !checked && halfChecked && "".concat(prefixCls, "-checkbox-indeterminate"), (disabled || disableCheckbox) && "".concat(prefixCls, "-checkbox-disabled")),
+        onClick: _this.onCheck
+      }, $custom);
+    };
+
+    _this.renderIcon = function () {
+      var loading = _this.props.loading;
+      var prefixCls = _this.props.context.prefixCls;
+      return React.createElement("span", {
+        className: classNames("".concat(prefixCls, "-iconEle"), "".concat(prefixCls, "-icon__").concat(_this.getNodeState() || 'docu'), loading && "".concat(prefixCls, "-icon_loading"))
+      });
+    }; // Icon + Title
+
+
+    _this.renderSelector = function () {
+      var dragNodeHighlight = _this.state.dragNodeHighlight;
+      var _this$props5 = _this.props,
+          title = _this$props5.title,
+          selected = _this$props5.selected,
+          icon = _this$props5.icon,
+          loading = _this$props5.loading;
+      var _this$props$context3 = _this.props.context,
+          prefixCls = _this$props$context3.prefixCls,
+          showIcon = _this$props$context3.showIcon,
+          treeIcon = _this$props$context3.icon,
+          draggable = _this$props$context3.draggable,
+          loadData = _this$props$context3.loadData;
+
+      var disabled = _this.isDisabled();
+
+      var wrapClass = "".concat(prefixCls, "-node-content-wrapper"); // Icon - Still show loading icon when loading without showIcon
+
+      var $icon;
+
+      if (showIcon) {
+        var currentIcon = icon || treeIcon;
+        $icon = currentIcon ? React.createElement("span", {
+          className: classNames("".concat(prefixCls, "-iconEle"), "".concat(prefixCls, "-icon__customize"))
+        }, typeof currentIcon === 'function' ? currentIcon(_this.props) : currentIcon) : _this.renderIcon();
+      } else if (loadData && loading) {
+        $icon = _this.renderIcon();
+      } // Title
+
+
+      var $title = React.createElement("span", {
+        className: "".concat(prefixCls, "-title")
+      }, title);
+      return React.createElement("span", {
+        ref: _this.setSelectHandle,
+        title: typeof title === 'string' ? title : '',
+        className: classNames("".concat(wrapClass), "".concat(wrapClass, "-").concat(_this.getNodeState() || 'normal'), !disabled && (selected || dragNodeHighlight) && "".concat(prefixCls, "-node-selected"), !disabled && draggable && 'draggable'),
+        draggable: !disabled && draggable || undefined,
+        "aria-grabbed": !disabled && draggable || undefined,
+        onMouseEnter: _this.onMouseEnter,
+        onMouseLeave: _this.onMouseLeave,
+        onContextMenu: _this.onContextMenu,
+        onClick: _this.onSelectorClick,
+        onDoubleClick: _this.onSelectorDoubleClick,
+        onDragStart: draggable ? _this.onDragStart : undefined
+      }, $icon, $title);
+    }; // Children list wrapped with `Animation`
+
+
+    _this.renderChildren = function () {
+      var _this$props6 = _this.props,
+          expanded = _this$props6.expanded,
+          pos = _this$props6.pos;
+      var _this$props$context4 = _this.props.context,
+          prefixCls = _this$props$context4.prefixCls,
+          motion = _this$props$context4.motion,
+          renderTreeNode = _this$props$context4.renderTreeNode; // Children TreeNode
+
+      var nodeList = _this.getNodeChildren();
+
+      if (nodeList.length === 0) {
+        return null;
+      }
+
+      return React.createElement(OriginCSSMotion, Object.assign({
+        visible: expanded
+      }, motion), function (_ref) {
+        var style = _ref.style,
+            className = _ref.className;
+        return React.createElement("ul", {
+          className: classNames(className, "".concat(prefixCls, "-child-tree"), expanded && "".concat(prefixCls, "-child-tree-open")),
+          style: style,
+          "data-expanded": expanded,
+          role: "group"
+        }, mapChildren(nodeList, function (node, index) {
+          return renderTreeNode(node, index, pos);
+        }));
+      });
+    };
+
+    return _this;
+  } // Isomorphic needn't load data in server side
+
+
+  _createClass$3(TreeNode, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this$props7 = this.props,
+          eventKey = _this$props7.eventKey,
+          registerTreeNode = _this$props7.context.registerTreeNode;
+      this.syncLoadData(this.props);
+      registerTreeNode(eventKey, this);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this.syncLoadData(this.props);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      var _this$props8 = this.props,
+          eventKey = _this$props8.eventKey,
+          registerTreeNode = _this$props8.context.registerTreeNode;
+      registerTreeNode(eventKey, null);
+    }
+  }, {
+    key: "isSelectable",
+    value: function isSelectable() {
+      var selectable = this.props.selectable;
+      var treeSelectable = this.props.context.selectable; // Ignore when selectable is undefined or null
+
+      if (typeof selectable === 'boolean') {
+        return selectable;
+      }
+
+      return treeSelectable;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _classNames;
+
+      var loading = this.props.loading;
+
+      var _this$props9 = this.props,
+          className = _this$props9.className,
+          style = _this$props9.style,
+          dragOver = _this$props9.dragOver,
+          dragOverGapTop = _this$props9.dragOverGapTop,
+          dragOverGapBottom = _this$props9.dragOverGapBottom,
+          isLeaf = _this$props9.isLeaf,
+          expanded = _this$props9.expanded,
+          selected = _this$props9.selected,
+          checked = _this$props9.checked,
+          halfChecked = _this$props9.halfChecked,
+          otherProps = _objectWithoutProperties$1(_this$props9, ["className", "style", "dragOver", "dragOverGapTop", "dragOverGapBottom", "isLeaf", "expanded", "selected", "checked", "halfChecked"]);
+
+      var _this$props$context5 = this.props.context,
+          prefixCls = _this$props$context5.prefixCls,
+          filterTreeNode = _this$props$context5.filterTreeNode,
+          draggable = _this$props$context5.draggable;
+      var disabled = this.isDisabled();
+      var dataOrAriaAttributeProps = getDataAndAria(otherProps);
+      return React.createElement("li", Object.assign({
+        className: classNames(className, (_classNames = {}, _defineProperty$2(_classNames, "".concat(prefixCls, "-treenode-disabled"), disabled), _defineProperty$2(_classNames, "".concat(prefixCls, "-treenode-switcher-").concat(expanded ? 'open' : 'close'), !isLeaf), _defineProperty$2(_classNames, "".concat(prefixCls, "-treenode-checkbox-checked"), checked), _defineProperty$2(_classNames, "".concat(prefixCls, "-treenode-checkbox-indeterminate"), halfChecked), _defineProperty$2(_classNames, "".concat(prefixCls, "-treenode-selected"), selected), _defineProperty$2(_classNames, "".concat(prefixCls, "-treenode-loading"), loading), _defineProperty$2(_classNames, 'drag-over', !disabled && dragOver), _defineProperty$2(_classNames, 'drag-over-gap-top', !disabled && dragOverGapTop), _defineProperty$2(_classNames, 'drag-over-gap-bottom', !disabled && dragOverGapBottom), _defineProperty$2(_classNames, 'filter-node', filterTreeNode && filterTreeNode(this)), _classNames)),
+        style: style,
+        role: "treeitem",
+        onDragEnter: draggable ? this.onDragEnter : undefined,
+        onDragOver: draggable ? this.onDragOver : undefined,
+        onDragLeave: draggable ? this.onDragLeave : undefined,
+        onDrop: draggable ? this.onDrop : undefined,
+        onDragEnd: draggable ? this.onDragEnd : undefined
+      }, dataOrAriaAttributeProps), this.renderSwitcher(), this.renderCheckbox(), this.renderSelector(), this.renderChildren());
+    }
+  }]);
+
+  return TreeNode;
+}(React.Component);
+
+TreeNode.propTypes = {
+  eventKey: PropTypes.string,
+  prefixCls: PropTypes.string,
+  className: PropTypes.string,
+  style: PropTypes.object,
+  onSelect: PropTypes.func,
+  // By parent
+  expanded: PropTypes.bool,
+  selected: PropTypes.bool,
+  checked: PropTypes.bool,
+  loaded: PropTypes.bool,
+  loading: PropTypes.bool,
+  halfChecked: PropTypes.bool,
+  children: PropTypes.node,
+  title: PropTypes.node,
+  pos: PropTypes.string,
+  dragOver: PropTypes.bool,
+  dragOverGapTop: PropTypes.bool,
+  dragOverGapBottom: PropTypes.bool,
+  // By user
+  isLeaf: PropTypes.bool,
+  checkable: PropTypes.bool,
+  selectable: PropTypes.bool,
+  disabled: PropTypes.bool,
+  disableCheckbox: PropTypes.bool,
+  icon: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+  switcherIcon: PropTypes.oneOfType([PropTypes.node, PropTypes.func])
+};
+polyfill(TreeNode);
+
+var ContextTreeNode = function ContextTreeNode(props) {
+  return React.createElement(TreeContext.Consumer, null, function (context) {
+    return React.createElement(TreeNode, Object.assign({}, props, {
+      context: context
+    }));
+  });
+};
+
+ContextTreeNode.defaultProps = {
+  title: defaultTitle
+};
+ContextTreeNode.isTreeNode = 1;
+
+function _typeof$3(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$3 = function _typeof(obj) { return typeof obj; }; } else { _typeof$3 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$3(obj); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+var DRAG_SIDE_RANGE = 0.25;
+var DRAG_MIN_GAP = 2;
+var onlyTreeNodeWarned = false;
+function warnOnlyTreeNode() {
+  if (onlyTreeNodeWarned) return;
+  onlyTreeNodeWarned = true;
+  warning(false, 'Tree only accept TreeNode as children.');
+}
+function arrDel(list, value) {
+  var clone = list.slice();
+  var index = clone.indexOf(value);
+
+  if (index >= 0) {
+    clone.splice(index, 1);
+  }
+
+  return clone;
+}
+function arrAdd(list, value) {
+  var clone = list.slice();
+
+  if (clone.indexOf(value) === -1) {
+    clone.push(value);
+  }
+
+  return clone;
+}
+function posToArr(pos) {
+  return pos.split('-');
+}
+function getPosition(level, index) {
+  return "".concat(level, "-").concat(index);
+}
+function isTreeNode(node) {
+  return node && node.type && node.type.isTreeNode;
+}
+function getNodeChildren(children) {
+  return toArray(children).filter(isTreeNode);
+}
+function isCheckDisabled(node) {
+  var _ref = node.props || {},
+      disabled = _ref.disabled,
+      disableCheckbox = _ref.disableCheckbox,
+      checkable = _ref.checkable;
+
+  return !!(disabled || disableCheckbox) || checkable === false;
+}
+function traverseTreeNodes(treeNodes, callback) {
+  function processNode(node, index, parent) {
+    var children = node ? node.props.children : treeNodes;
+    var pos = node ? getPosition(parent.pos, index) : 0; // Filter children
+
+    var childList = getNodeChildren(children); // Process node if is not root
+
+    if (node) {
+      var data = {
+        node: node,
+        index: index,
+        pos: pos,
+        key: node.key || pos,
+        parentPos: parent.node ? parent.pos : null
+      };
+      callback(data);
+    } // Process children node
+
+
+    Children.forEach(childList, function (subNode, subIndex) {
+      processNode(subNode, subIndex, {
+        node: node,
+        pos: pos
+      });
+    });
+  }
+
+  processNode(null);
+}
+/**
+ * Use `rc-util` `toArray` to get the children list which keeps the key.
+ * And return single node if children is only one(This can avoid `key` missing check).
+ */
+
+function mapChildren(children, func) {
+  var list = toArray(children).map(func);
+
+  if (list.length === 1) {
+    return list[0];
+  }
+
+  return list;
+}
+function getDragNodesKeys(treeNodes, node) {
+  var _node$props = node.props,
+      eventKey = _node$props.eventKey,
+      pos = _node$props.pos;
+  var dragNodesKeys = [];
+  traverseTreeNodes(treeNodes, function (_ref2) {
+    var key = _ref2.key;
+    dragNodesKeys.push(key);
+  });
+  dragNodesKeys.push(eventKey || pos);
+  return dragNodesKeys;
+} // Only used when drag, not affect SSR.
+
+function calcDropPosition(event, treeNode) {
+  var clientY = event.clientY;
+
+  var _treeNode$selectHandl = treeNode.selectHandle.getBoundingClientRect(),
+      top = _treeNode$selectHandl.top,
+      bottom = _treeNode$selectHandl.bottom,
+      height = _treeNode$selectHandl.height;
+
+  var des = Math.max(height * DRAG_SIDE_RANGE, DRAG_MIN_GAP);
+
+  if (clientY <= top + des) {
+    return -1;
+  }
+
+  if (clientY >= bottom - des) {
+    return 1;
+  }
+
+  return 0;
+}
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
+
+function calcSelectedKeys(selectedKeys, props) {
+  if (!selectedKeys) return undefined;
+  var multiple = props.multiple;
+
+  if (multiple) {
+    return selectedKeys.slice();
+  }
+
+  if (selectedKeys.length) {
+    return [selectedKeys[0]];
+  }
+
+  return selectedKeys;
+}
+/**
+ * Since React internal will convert key to string,
+ * we need do this to avoid `checkStrictly` use number match
+ */
+
+function keyListToString(keyList) {
+  if (!keyList) return keyList;
+  return keyList.map(function (key) {
+    return String(key);
+  });
+}
+
+var internalProcessProps = function internalProcessProps(props) {
+  return props;
+};
+
+function convertDataToTree(treeData, processor) {
+  if (!treeData) return [];
+
+  var _ref3 = {},
+      _ref3$processProps = _ref3.processProps,
+      processProps = _ref3$processProps === void 0 ? internalProcessProps : _ref3$processProps;
+
+  var list = Array.isArray(treeData) ? treeData : [treeData];
+  return list.map(function (_ref4) {
+    var children = _ref4.children,
+        props = _objectWithoutProperties(_ref4, ["children"]);
+
+    var childrenNodes = convertDataToTree(children);
+    return React__default.createElement(ContextTreeNode, Object.assign({}, processProps(props)), childrenNodes);
+  });
+}
+/**
+ * Calculate treeNodes entities. `processTreeEntity` is used for `rc-tree-select`
+ * @param treeNodes
+ * @param processTreeEntity  User can customize the entity
+ */
+
+function convertTreeToEntities(treeNodes) {
+  var _ref5 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      initWrapper = _ref5.initWrapper,
+      processEntity = _ref5.processEntity,
+      onProcessFinished = _ref5.onProcessFinished;
+
+  var posEntities = {};
+  var keyEntities = {};
+  var wrapper = {
+    posEntities: posEntities,
+    keyEntities: keyEntities
+  };
+
+  if (initWrapper) {
+    wrapper = initWrapper(wrapper) || wrapper;
+  }
+
+  traverseTreeNodes(treeNodes, function (item) {
+    var node = item.node,
+        index = item.index,
+        pos = item.pos,
+        key = item.key,
+        parentPos = item.parentPos;
+    var entity = {
+      node: node,
+      index: index,
+      key: key,
+      pos: pos
+    };
+    posEntities[pos] = entity;
+    keyEntities[key] = entity; // Fill children
+
+    entity.parent = posEntities[parentPos];
+
+    if (entity.parent) {
+      entity.parent.children = entity.parent.children || [];
+      entity.parent.children.push(entity);
+    }
+
+    if (processEntity) {
+      processEntity(entity, wrapper);
+    }
+  });
+
+  if (onProcessFinished) {
+    onProcessFinished(wrapper);
+  }
+
+  return wrapper;
+}
+/**
+ * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
+ */
+
+function parseCheckedKeys(keys) {
+  if (!keys) {
+    return null;
+  } // Convert keys to object format
+
+
+  var keyProps;
+
+  if (Array.isArray(keys)) {
+    // [Legacy] Follow the api doc
+    keyProps = {
+      checkedKeys: keys,
+      halfCheckedKeys: undefined
+    };
+  } else if (_typeof$3(keys) === 'object') {
+    keyProps = {
+      checkedKeys: keys.checked || undefined,
+      halfCheckedKeys: keys.halfChecked || undefined
+    };
+  } else {
+    warning(false, '`checkedKeys` is not an array or an object');
+    return null;
+  }
+
+  keyProps.checkedKeys = keyListToString(keyProps.checkedKeys);
+  keyProps.halfCheckedKeys = keyListToString(keyProps.halfCheckedKeys);
+  return keyProps;
+}
+/**
+ * Conduct check state by the keyList. It will conduct up & from the provided key.
+ * If the conduct path reach the disabled or already checked / unchecked node will stop conduct.
+ */
+
+function conductCheck(
+/** list of keys */
+keyList,
+/** is check the node or not */
+isCheck,
+/** parsed by `convertTreeToEntities` function in Tree */
+keyEntities) {
+  var checkStatus = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var checkedKeys = {};
+  var halfCheckedKeys = {}; // Record the key has some child checked (include child half checked)
+
+  (checkStatus.checkedKeys || []).forEach(function (key) {
+    checkedKeys[key] = true;
+  });
+  (checkStatus.halfCheckedKeys || []).forEach(function (key) {
+    halfCheckedKeys[key] = true;
+  }); // Conduct up
+
+  function conductUp(key) {
+    if (checkedKeys[key] === isCheck) return;
+    var entity = keyEntities[key];
+    if (!entity) return;
+    var children = entity.children,
+        parent = entity.parent,
+        node = entity.node;
+    if (isCheckDisabled(node)) return; // Check child node checked status
+
+    var everyChildChecked = true;
+    var someChildChecked = false; // Child checked or half checked
+
+    (children || []).filter(function (child) {
+      return !isCheckDisabled(child.node);
+    }).forEach(function (_ref6) {
+      var childKey = _ref6.key;
+      var childChecked = checkedKeys[childKey];
+      var childHalfChecked = halfCheckedKeys[childKey];
+      if (childChecked || childHalfChecked) someChildChecked = true;
+      if (!childChecked) everyChildChecked = false;
+    }); // Update checked status
+
+    if (isCheck) {
+      checkedKeys[key] = everyChildChecked;
+    } else {
+      checkedKeys[key] = false;
+    }
+
+    halfCheckedKeys[key] = someChildChecked;
+
+    if (parent) {
+      conductUp(parent.key);
+    }
+  } // Conduct down
+
+
+  function conductDown(key) {
+    if (checkedKeys[key] === isCheck) return;
+    var entity = keyEntities[key];
+    if (!entity) return;
+    var children = entity.children,
+        node = entity.node;
+    if (isCheckDisabled(node)) return;
+    checkedKeys[key] = isCheck;
+    (children || []).forEach(function (child) {
+      conductDown(child.key);
+    });
+  }
+
+  function conduct(key) {
+    var entity = keyEntities[key];
+
+    if (!entity) {
+      warning(false, "'".concat(key, "' does not exist in the tree."));
+      return;
+    }
+
+    var children = entity.children,
+        parent = entity.parent,
+        node = entity.node;
+    checkedKeys[key] = isCheck;
+    if (isCheckDisabled(node)) return; // Conduct down
+
+    (children || []).filter(function (child) {
+      return !isCheckDisabled(child.node);
+    }).forEach(function (child) {
+      conductDown(child.key);
+    }); // Conduct up
+
+    if (parent) {
+      conductUp(parent.key);
+    }
+  }
+
+  (keyList || []).forEach(function (key) {
+    conduct(key);
+  });
+  var checkedKeyList = [];
+  var halfCheckedKeyList = []; // Fill checked list
+
+  Object.keys(checkedKeys).forEach(function (key) {
+    if (checkedKeys[key]) {
+      checkedKeyList.push(key);
+    }
+  }); // Fill half checked list
+
+  Object.keys(halfCheckedKeys).forEach(function (key) {
+    if (!checkedKeys[key] && halfCheckedKeys[key]) {
+      halfCheckedKeyList.push(key);
+    }
+  });
+  return {
+    checkedKeys: checkedKeyList,
+    halfCheckedKeys: halfCheckedKeyList
+  };
+}
+/**
+ * If user use `autoExpandParent` we should get the list of parent node
+ * @param keyList
+ * @param keyEntities
+ */
+
+function conductExpandParent(keyList, keyEntities) {
+  var expandedKeys = {};
+
+  function conductUp(key) {
+    if (expandedKeys[key]) return;
+    var entity = keyEntities[key];
+    if (!entity) return;
+    expandedKeys[key] = true;
+    var parent = entity.parent,
+        node = entity.node;
+    if (node.props && node.props.disabled) return;
+
+    if (parent) {
+      conductUp(parent.key);
+    }
+  }
+
+  (keyList || []).forEach(function (key) {
+    conductUp(key);
+  });
+  return Object.keys(expandedKeys);
+}
+/**
+ * Returns only the data- and aria- key/value pairs
+ */
+
+function getDataAndAria(props) {
+  return Object.keys(props).reduce(function (prev, key) {
+    if (key.substr(0, 5) === 'data-' || key.substr(0, 5) === 'aria-') {
+      prev[key] = props[key];
+    }
+
+    return prev;
+  }, {});
+}
+
+function _typeof$2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(obj); }
+
+function _defineProperty$1(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; }
+
+function _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$2(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }
+
+function _inherits$2(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$2(subClass, superClass); }
+
+function _setPrototypeOf$2(o, p) { _setPrototypeOf$2 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$2(o, p); }
+
+function _createSuper$2(Derived) { return function () { var Super = _getPrototypeOf$2(Derived), result; if (_isNativeReflectConstruct$2()) { var NewTarget = _getPrototypeOf$2(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$2(this, result); }; }
+
+function _possibleConstructorReturn$2(self, call) { if (call && (_typeof$2(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$2(self); }
+
+function _assertThisInitialized$2(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct$2() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf$2(o) { _getPrototypeOf$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$2(o); }
+
+var Tree$2 = /*#__PURE__*/function (_React$Component) {
+  _inherits$2(Tree, _React$Component);
+
+  var _super = _createSuper$2(Tree);
+
+  function Tree() {
+    var _this;
+
+    _classCallCheck$2(this, Tree);
+
+    _this = _super.apply(this, arguments);
+    /** Internal usage for `rc-tree-select`, we don't promise it will not change. */
+
+    _this.domTreeNodes = {};
+    _this.state = {
+      keyEntities: {},
+      selectedKeys: [],
+      checkedKeys: [],
+      halfCheckedKeys: [],
+      loadedKeys: [],
+      loadingKeys: [],
+      expandedKeys: [],
+      dragNodesKeys: [],
+      dragOverNodeKey: null,
+      dropPosition: null,
+      treeNode: [],
+      prevProps: null
+    };
+
+    _this.onNodeDragStart = function (event, node) {
+      var expandedKeys = _this.state.expandedKeys;
+      var onDragStart = _this.props.onDragStart;
+      var _node$props = node.props,
+          eventKey = _node$props.eventKey,
+          children = _node$props.children;
+      _this.dragNode = node;
+
+      _this.setState({
+        dragNodesKeys: getDragNodesKeys(children, node),
+        expandedKeys: arrDel(expandedKeys, eventKey)
+      });
+
+      if (onDragStart) {
+        onDragStart({
+          event: event,
+          node: node
+        });
+      }
+    };
+    /**
+     * [Legacy] Select handler is less small than node,
+     * so that this will trigger when drag enter node or select handler.
+     * This is a little tricky if customize css without padding.
+     * Better for use mouse move event to refresh drag state.
+     * But let's just keep it to avoid event trigger logic change.
+     */
+
+
+    _this.onNodeDragEnter = function (event, node) {
+      var _this$state = _this.state,
+          expandedKeys = _this$state.expandedKeys,
+          dragNodesKeys = _this$state.dragNodesKeys;
+      var onDragEnter = _this.props.onDragEnter;
+      var _node$props2 = node.props,
+          pos = _node$props2.pos,
+          eventKey = _node$props2.eventKey;
+      if (!_this.dragNode || dragNodesKeys.indexOf(eventKey) !== -1) return;
+      var dropPosition = calcDropPosition(event, node); // Skip if drag node is self
+
+      if (_this.dragNode.props.eventKey === eventKey && dropPosition === 0) {
+        _this.setState({
+          dragOverNodeKey: '',
+          dropPosition: null
+        });
+
+        return;
+      } // Ref: https://github.com/react-component/tree/issues/132
+      // Add timeout to let onDragLevel fire before onDragEnter,
+      // so that we can clean drag props for onDragLeave node.
+      // Macro task for this:
+      // https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-script
+
+
+      setTimeout(function () {
+        // Update drag over node
+        _this.setState({
+          dragOverNodeKey: eventKey,
+          dropPosition: dropPosition
+        }); // Side effect for delay drag
+
+
+        if (!_this.delayedDragEnterLogic) {
+          _this.delayedDragEnterLogic = {};
+        }
+
+        Object.keys(_this.delayedDragEnterLogic).forEach(function (key) {
+          clearTimeout(_this.delayedDragEnterLogic[key]);
+        });
+        _this.delayedDragEnterLogic[pos] = window.setTimeout(function () {
+          var newExpandedKeys = arrAdd(expandedKeys, eventKey);
+
+          if (!('expandedKeys' in _this.props)) {
+            _this.setState({
+              expandedKeys: newExpandedKeys
+            });
+          }
+
+          if (onDragEnter) {
+            onDragEnter({
+              event: event,
+              node: node,
+              expandedKeys: newExpandedKeys
+            });
+          }
+        }, 400);
+      }, 0);
+    };
+
+    _this.onNodeDragOver = function (event, node) {
+      var dragNodesKeys = _this.state.dragNodesKeys;
+      var onDragOver = _this.props.onDragOver;
+      var eventKey = node.props.eventKey;
+
+      if (dragNodesKeys.indexOf(eventKey) !== -1) {
+        return;
+      } // Update drag position
+
+
+      if (_this.dragNode && eventKey === _this.state.dragOverNodeKey) {
+        var dropPosition = calcDropPosition(event, node);
+        if (dropPosition === _this.state.dropPosition) return;
+
+        _this.setState({
+          dropPosition: dropPosition
+        });
+      }
+
+      if (onDragOver) {
+        onDragOver({
+          event: event,
+          node: node
+        });
+      }
+    };
+
+    _this.onNodeDragLeave = function (event, node) {
+      var onDragLeave = _this.props.onDragLeave;
+
+      _this.setState({
+        dragOverNodeKey: ''
+      });
+
+      if (onDragLeave) {
+        onDragLeave({
+          event: event,
+          node: node
+        });
+      }
+    };
+
+    _this.onNodeDragEnd = function (event, node) {
+      var onDragEnd = _this.props.onDragEnd;
+
+      _this.setState({
+        dragOverNodeKey: ''
+      });
+
+      if (onDragEnd) {
+        onDragEnd({
+          event: event,
+          node: node
+        });
+      }
+
+      _this.dragNode = null;
+    };
+
+    _this.onNodeDrop = function (event, node) {
+      var _this$state2 = _this.state,
+          _this$state2$dragNode = _this$state2.dragNodesKeys,
+          dragNodesKeys = _this$state2$dragNode === void 0 ? [] : _this$state2$dragNode,
+          dropPosition = _this$state2.dropPosition;
+      var onDrop = _this.props.onDrop;
+      var _node$props3 = node.props,
+          eventKey = _node$props3.eventKey,
+          pos = _node$props3.pos;
+
+      _this.setState({
+        dragOverNodeKey: ''
+      });
+
+      if (dragNodesKeys.indexOf(eventKey) !== -1) {
+        warning(false, "Can not drop to dragNode(include it's children node)");
+        return;
+      }
+
+      var posArr = posToArr(pos);
+      var dropResult = {
+        event: event,
+        node: node,
+        dragNode: _this.dragNode,
+        dragNodesKeys: dragNodesKeys.slice(),
+        dropPosition: dropPosition + Number(posArr[posArr.length - 1]),
+        dropToGap: false
+      };
+
+      if (dropPosition !== 0) {
+        dropResult.dropToGap = true;
+      }
+
+      if (onDrop) {
+        onDrop(dropResult);
+      }
+
+      _this.dragNode = null;
+    };
+
+    _this.onNodeClick = function (e, treeNode) {
+      var onClick = _this.props.onClick;
+
+      if (onClick) {
+        onClick(e, treeNode);
+      }
+    };
+
+    _this.onNodeDoubleClick = function (e, treeNode) {
+      var onDoubleClick = _this.props.onDoubleClick;
+
+      if (onDoubleClick) {
+        onDoubleClick(e, treeNode);
+      }
+    };
+
+    _this.onNodeSelect = function (e, treeNode) {
+      var selectedKeys = _this.state.selectedKeys;
+      var keyEntities = _this.state.keyEntities;
+      var _this$props = _this.props,
+          onSelect = _this$props.onSelect,
+          multiple = _this$props.multiple;
+      var _treeNode$props = treeNode.props,
+          selected = _treeNode$props.selected,
+          eventKey = _treeNode$props.eventKey;
+      var targetSelected = !selected; // Update selected keys
+
+      if (!targetSelected) {
+        selectedKeys = arrDel(selectedKeys, eventKey);
+      } else if (!multiple) {
+        selectedKeys = [eventKey];
+      } else {
+        selectedKeys = arrAdd(selectedKeys, eventKey);
+      } // [Legacy] Not found related usage in doc or upper libs
+
+
+      var selectedNodes = selectedKeys.map(function (key) {
+        var entity = keyEntities[key];
+        if (!entity) return null;
+        return entity.node;
+      }).filter(function (node) {
+        return node;
+      });
+
+      _this.setUncontrolledState({
+        selectedKeys: selectedKeys
+      });
+
+      if (onSelect) {
+        onSelect(selectedKeys, {
+          event: 'select',
+          selected: targetSelected,
+          node: treeNode,
+          selectedNodes: selectedNodes,
+          nativeEvent: e.nativeEvent
+        });
+      }
+    };
+
+    _this.onNodeCheck = function (e, treeNode, checked) {
+      var _this$state3 = _this.state,
+          keyEntities = _this$state3.keyEntities,
+          oriCheckedKeys = _this$state3.checkedKeys,
+          oriHalfCheckedKeys = _this$state3.halfCheckedKeys;
+      var _this$props2 = _this.props,
+          checkStrictly = _this$props2.checkStrictly,
+          onCheck = _this$props2.onCheck;
+      var eventKey = treeNode.props.eventKey; // Prepare trigger arguments
+
+      var checkedObj;
+      var eventObj = {
+        event: 'check',
+        node: treeNode,
+        checked: checked,
+        nativeEvent: e.nativeEvent
+      };
+
+      if (checkStrictly) {
+        var checkedKeys = checked ? arrAdd(oriCheckedKeys, eventKey) : arrDel(oriCheckedKeys, eventKey);
+        var halfCheckedKeys = arrDel(oriHalfCheckedKeys, eventKey);
+        checkedObj = {
+          checked: checkedKeys,
+          halfChecked: halfCheckedKeys
+        };
+        eventObj.checkedNodes = checkedKeys.map(function (key) {
+          return keyEntities[key];
+        }).filter(function (entity) {
+          return entity;
+        }).map(function (entity) {
+          return entity.node;
+        });
+
+        _this.setUncontrolledState({
+          checkedKeys: checkedKeys
+        });
+      } else {
+        var _conductCheck = conductCheck([eventKey], checked, keyEntities, {
+          checkedKeys: oriCheckedKeys,
+          halfCheckedKeys: oriHalfCheckedKeys
+        }),
+            _checkedKeys = _conductCheck.checkedKeys,
+            _halfCheckedKeys = _conductCheck.halfCheckedKeys;
+
+        checkedObj = _checkedKeys; // [Legacy] This is used for `rc-tree-select`
+
+        eventObj.checkedNodes = [];
+        eventObj.checkedNodesPositions = [];
+        eventObj.halfCheckedKeys = _halfCheckedKeys;
+
+        _checkedKeys.forEach(function (key) {
+          var entity = keyEntities[key];
+          if (!entity) return;
+          var node = entity.node,
+              pos = entity.pos;
+          eventObj.checkedNodes.push(node);
+          eventObj.checkedNodesPositions.push({
+            node: node,
+            pos: pos
+          });
+        });
+
+        _this.setUncontrolledState({
+          checkedKeys: _checkedKeys,
+          halfCheckedKeys: _halfCheckedKeys
+        });
+      }
+
+      if (onCheck) {
+        onCheck(checkedObj, eventObj);
+      }
+    };
+
+    _this.onNodeLoad = function (treeNode) {
+      return new Promise(function (resolve) {
+        // We need to get the latest state of loading/loaded keys
+        _this.setState(function (_ref) {
+          var _ref$loadedKeys = _ref.loadedKeys,
+              loadedKeys = _ref$loadedKeys === void 0 ? [] : _ref$loadedKeys,
+              _ref$loadingKeys = _ref.loadingKeys,
+              loadingKeys = _ref$loadingKeys === void 0 ? [] : _ref$loadingKeys;
+          var _this$props3 = _this.props,
+              loadData = _this$props3.loadData,
+              onLoad = _this$props3.onLoad;
+          var eventKey = treeNode.props.eventKey;
+
+          if (!loadData || loadedKeys.indexOf(eventKey) !== -1 || loadingKeys.indexOf(eventKey) !== -1) {
+            // react 15 will warn if return null
+            return {};
+          } // Process load data
+
+
+          var promise = loadData(treeNode);
+          promise.then(function () {
+            var _this$state4 = _this.state,
+                currentLoadedKeys = _this$state4.loadedKeys,
+                currentLoadingKeys = _this$state4.loadingKeys;
+            var newLoadedKeys = arrAdd(currentLoadedKeys, eventKey);
+            var newLoadingKeys = arrDel(currentLoadingKeys, eventKey); // onLoad should trigger before internal setState to avoid `loadData` trigger twice.
+            // https://github.com/ant-design/ant-design/issues/12464
+
+            if (onLoad) {
+              onLoad(newLoadedKeys, {
+                event: 'load',
+                node: treeNode
+              });
+            }
+
+            _this.setUncontrolledState({
+              loadedKeys: newLoadedKeys
+            });
+
+            _this.setState({
+              loadingKeys: newLoadingKeys
+            });
+
+            resolve();
+          });
+          return {
+            loadingKeys: arrAdd(loadingKeys, eventKey)
+          };
+        });
+      });
+    };
+
+    _this.onNodeExpand = function (e, treeNode) {
+      var expandedKeys = _this.state.expandedKeys;
+      var _this$props4 = _this.props,
+          onExpand = _this$props4.onExpand,
+          loadData = _this$props4.loadData;
+      var _treeNode$props2 = treeNode.props,
+          eventKey = _treeNode$props2.eventKey,
+          expanded = _treeNode$props2.expanded; // Update selected keys
+
+      var index = expandedKeys.indexOf(eventKey);
+      var targetExpanded = !expanded;
+      warning(expanded && index !== -1 || !expanded && index === -1, 'Expand state not sync with index check');
+
+      if (targetExpanded) {
+        expandedKeys = arrAdd(expandedKeys, eventKey);
+      } else {
+        expandedKeys = arrDel(expandedKeys, eventKey);
+      }
+
+      _this.setUncontrolledState({
+        expandedKeys: expandedKeys
+      });
+
+      if (onExpand) {
+        onExpand(expandedKeys, {
+          node: treeNode,
+          expanded: targetExpanded,
+          nativeEvent: e.nativeEvent
+        });
+      } // Async Load data
+
+
+      if (targetExpanded && loadData) {
+        var loadPromise = _this.onNodeLoad(treeNode);
+
+        return loadPromise ? loadPromise.then(function () {
+          // [Legacy] Refresh logic
+          _this.setUncontrolledState({
+            expandedKeys: expandedKeys
+          });
+        }) : null;
+      }
+
+      return null;
+    };
+
+    _this.onNodeMouseEnter = function (event, node) {
+      var onMouseEnter = _this.props.onMouseEnter;
+
+      if (onMouseEnter) {
+        onMouseEnter({
+          event: event,
+          node: node
+        });
+      }
+    };
+
+    _this.onNodeMouseLeave = function (event, node) {
+      var onMouseLeave = _this.props.onMouseLeave;
+
+      if (onMouseLeave) {
+        onMouseLeave({
+          event: event,
+          node: node
+        });
+      }
+    };
+
+    _this.onNodeContextMenu = function (event, node) {
+      var onRightClick = _this.props.onRightClick;
+
+      if (onRightClick) {
+        event.preventDefault();
+        onRightClick({
+          event: event,
+          node: node
+        });
+      }
+    };
+    /**
+     * Only update the value which is not in props
+     */
+
+
+    _this.setUncontrolledState = function (state) {
+      var needSync = false;
+      var newState = {};
+      Object.keys(state).forEach(function (name) {
+        if (name in _this.props) return;
+        needSync = true;
+        newState[name] = state[name];
+      });
+
+      if (needSync) {
+        _this.setState(newState);
+      }
+    };
+
+    _this.registerTreeNode = function (key, node) {
+      if (node) {
+        _this.domTreeNodes[key] = node;
+      } else {
+        delete _this.domTreeNodes[key];
+      }
+    };
+
+    _this.isKeyChecked = function (key) {
+      var _this$state$checkedKe = _this.state.checkedKeys,
+          checkedKeys = _this$state$checkedKe === void 0 ? [] : _this$state$checkedKe;
+      return checkedKeys.indexOf(key) !== -1;
+    };
+    /**
+     * [Legacy] Original logic use `key` as tracking clue.
+     * We have to use `cloneElement` to pass `key`.
+     */
+
+
+    _this.renderTreeNode = function (child, index) {
+      var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      var _this$state5 = _this.state,
+          keyEntities = _this$state5.keyEntities,
+          _this$state5$expanded = _this$state5.expandedKeys,
+          expandedKeys = _this$state5$expanded === void 0 ? [] : _this$state5$expanded,
+          _this$state5$selected = _this$state5.selectedKeys,
+          selectedKeys = _this$state5$selected === void 0 ? [] : _this$state5$selected,
+          _this$state5$halfChec = _this$state5.halfCheckedKeys,
+          halfCheckedKeys = _this$state5$halfChec === void 0 ? [] : _this$state5$halfChec,
+          _this$state5$loadedKe = _this$state5.loadedKeys,
+          loadedKeys = _this$state5$loadedKe === void 0 ? [] : _this$state5$loadedKe,
+          _this$state5$loadingK = _this$state5.loadingKeys,
+          loadingKeys = _this$state5$loadingK === void 0 ? [] : _this$state5$loadingK,
+          dragOverNodeKey = _this$state5.dragOverNodeKey,
+          dropPosition = _this$state5.dropPosition;
+      var pos = getPosition(level, index);
+      var key = child.key || pos;
+
+      if (!keyEntities[key]) {
+        warnOnlyTreeNode();
+        return null;
+      }
+
+      return React.cloneElement(child, {
+        key: key,
+        eventKey: key,
+        expanded: expandedKeys.indexOf(key) !== -1,
+        selected: selectedKeys.indexOf(key) !== -1,
+        loaded: loadedKeys.indexOf(key) !== -1,
+        loading: loadingKeys.indexOf(key) !== -1,
+        checked: _this.isKeyChecked(key),
+        halfChecked: halfCheckedKeys.indexOf(key) !== -1,
+        pos: pos,
+        // [Legacy] Drag props
+        dragOver: dragOverNodeKey === key && dropPosition === 0,
+        dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
+        dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1
+      });
+    };
+
+    return _this;
+  }
+
+  _createClass$2(Tree, [{
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var treeNode = this.state.treeNode;
+      var _this$props5 = this.props,
+          prefixCls = _this$props5.prefixCls,
+          className = _this$props5.className,
+          focusable = _this$props5.focusable,
+          style = _this$props5.style,
+          showLine = _this$props5.showLine,
+          _this$props5$tabIndex = _this$props5.tabIndex,
+          tabIndex = _this$props5$tabIndex === void 0 ? 0 : _this$props5$tabIndex,
+          selectable = _this$props5.selectable,
+          showIcon = _this$props5.showIcon,
+          icon = _this$props5.icon,
+          switcherIcon = _this$props5.switcherIcon,
+          draggable = _this$props5.draggable,
+          checkable = _this$props5.checkable,
+          checkStrictly = _this$props5.checkStrictly,
+          disabled = _this$props5.disabled,
+          motion = _this$props5.motion,
+          loadData = _this$props5.loadData,
+          filterTreeNode = _this$props5.filterTreeNode;
+      var domProps = getDataAndAria(this.props);
+
+      if (focusable) {
+        domProps.tabIndex = tabIndex;
+      }
+
+      return React.createElement(TreeContext.Provider, {
+        value: {
+          prefixCls: prefixCls,
+          selectable: selectable,
+          showIcon: showIcon,
+          icon: icon,
+          switcherIcon: switcherIcon,
+          draggable: draggable,
+          checkable: checkable,
+          checkStrictly: checkStrictly,
+          disabled: disabled,
+          motion: motion,
+          loadData: loadData,
+          filterTreeNode: filterTreeNode,
+          renderTreeNode: this.renderTreeNode,
+          isKeyChecked: this.isKeyChecked,
+          onNodeClick: this.onNodeClick,
+          onNodeDoubleClick: this.onNodeDoubleClick,
+          onNodeExpand: this.onNodeExpand,
+          onNodeSelect: this.onNodeSelect,
+          onNodeCheck: this.onNodeCheck,
+          onNodeLoad: this.onNodeLoad,
+          onNodeMouseEnter: this.onNodeMouseEnter,
+          onNodeMouseLeave: this.onNodeMouseLeave,
+          onNodeContextMenu: this.onNodeContextMenu,
+          onNodeDragStart: this.onNodeDragStart,
+          onNodeDragEnter: this.onNodeDragEnter,
+          onNodeDragOver: this.onNodeDragOver,
+          onNodeDragLeave: this.onNodeDragLeave,
+          onNodeDragEnd: this.onNodeDragEnd,
+          onNodeDrop: this.onNodeDrop,
+          registerTreeNode: this.registerTreeNode
+        }
+      }, React.createElement("ul", Object.assign({}, domProps, {
+        className: classNames(prefixCls, className, _defineProperty$1({}, "".concat(prefixCls, "-show-line"), showLine)),
+        style: style,
+        role: "tree",
+        unselectable: "on"
+      }), mapChildren(treeNode, function (node, index) {
+        return _this2.renderTreeNode(node, index);
+      })));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, prevState) {
+      var prevProps = prevState.prevProps;
+      var newState = {
+        prevProps: props
+      };
+
+      function needSync(name) {
+        return !prevProps && name in props || prevProps && prevProps[name] !== props[name];
+      } // ================== Tree Node ==================
+
+
+      var treeNode = null; // Check if `treeData` or `children` changed and save into the state.
+
+      if (needSync('treeData')) {
+        treeNode = convertDataToTree(props.treeData);
+      } else if (needSync('children')) {
+        treeNode = toArray(props.children);
+      } // Tree support filter function which will break the tree structure in the vdm.
+      // We cache the treeNodes in state so that we can return the treeNode in event trigger.
+
+
+      if (treeNode) {
+        newState.treeNode = treeNode; // Calculate the entities data for quick match
+
+        var entitiesMap = convertTreeToEntities(treeNode);
+        newState.keyEntities = entitiesMap.keyEntities;
+      }
+
+      var keyEntities = newState.keyEntities || prevState.keyEntities; // ================ expandedKeys =================
+
+      if (needSync('expandedKeys') || prevProps && needSync('autoExpandParent')) {
+        newState.expandedKeys = props.autoExpandParent || !prevProps && props.defaultExpandParent ? conductExpandParent(props.expandedKeys, keyEntities) : props.expandedKeys;
+      } else if (!prevProps && props.defaultExpandAll) {
+        newState.expandedKeys = Object.keys(keyEntities);
+      } else if (!prevProps && props.defaultExpandedKeys) {
+        newState.expandedKeys = props.autoExpandParent || props.defaultExpandParent ? conductExpandParent(props.defaultExpandedKeys, keyEntities) : props.defaultExpandedKeys;
+      } // ================ selectedKeys =================
+
+
+      if (props.selectable) {
+        if (needSync('selectedKeys')) {
+          newState.selectedKeys = calcSelectedKeys(props.selectedKeys, props);
+        } else if (!prevProps && props.defaultSelectedKeys) {
+          newState.selectedKeys = calcSelectedKeys(props.defaultSelectedKeys, props);
+        }
+      } // ================= checkedKeys =================
+
+
+      if (props.checkable) {
+        var checkedKeyEntity;
+
+        if (needSync('checkedKeys')) {
+          checkedKeyEntity = parseCheckedKeys(props.checkedKeys) || {};
+        } else if (!prevProps && props.defaultCheckedKeys) {
+          checkedKeyEntity = parseCheckedKeys(props.defaultCheckedKeys) || {};
+        } else if (treeNode) {
+          // If treeNode changed, we also need check it
+          checkedKeyEntity = parseCheckedKeys(props.checkedKeys) || {
+            checkedKeys: prevState.checkedKeys,
+            halfCheckedKeys: prevState.halfCheckedKeys
+          };
+        }
+
+        if (checkedKeyEntity) {
+          var _checkedKeyEntity = checkedKeyEntity,
+              _checkedKeyEntity$che = _checkedKeyEntity.checkedKeys,
+              checkedKeys = _checkedKeyEntity$che === void 0 ? [] : _checkedKeyEntity$che,
+              _checkedKeyEntity$hal = _checkedKeyEntity.halfCheckedKeys,
+              halfCheckedKeys = _checkedKeyEntity$hal === void 0 ? [] : _checkedKeyEntity$hal;
+
+          if (!props.checkStrictly) {
+            var conductKeys = conductCheck(checkedKeys, true, keyEntities);
+            checkedKeys = conductKeys.checkedKeys;
+            halfCheckedKeys = conductKeys.halfCheckedKeys;
+          }
+
+          newState.checkedKeys = checkedKeys;
+          newState.halfCheckedKeys = halfCheckedKeys;
+        }
+      } // ================= loadedKeys ==================
+
+
+      if (needSync('loadedKeys')) {
+        newState.loadedKeys = props.loadedKeys;
+      }
+
+      return newState;
+    }
+  }]);
+
+  return Tree;
+}(React.Component);
+
+Tree$2.propTypes = {
+  prefixCls: PropTypes.string,
+  className: PropTypes.string,
+  style: PropTypes.object,
+  tabIndex: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  children: PropTypes.any,
+  treeData: PropTypes.array,
+  showLine: PropTypes.bool,
+  showIcon: PropTypes.bool,
+  icon: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+  focusable: PropTypes.bool,
+  selectable: PropTypes.bool,
+  disabled: PropTypes.bool,
+  multiple: PropTypes.bool,
+  checkable: PropTypes.oneOfType([PropTypes.bool, PropTypes.node]),
+  checkStrictly: PropTypes.bool,
+  draggable: PropTypes.bool,
+  defaultExpandParent: PropTypes.bool,
+  autoExpandParent: PropTypes.bool,
+  defaultExpandAll: PropTypes.bool,
+  defaultExpandedKeys: PropTypes.arrayOf(PropTypes.string),
+  expandedKeys: PropTypes.arrayOf(PropTypes.string),
+  defaultCheckedKeys: PropTypes.arrayOf(PropTypes.string),
+  checkedKeys: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.string, PropTypes.number])), PropTypes.object]),
+  defaultSelectedKeys: PropTypes.arrayOf(PropTypes.string),
+  selectedKeys: PropTypes.arrayOf(PropTypes.string),
+  onClick: PropTypes.func,
+  onDoubleClick: PropTypes.func,
+  onExpand: PropTypes.func,
+  onCheck: PropTypes.func,
+  onSelect: PropTypes.func,
+  onLoad: PropTypes.func,
+  loadData: PropTypes.func,
+  loadedKeys: PropTypes.arrayOf(PropTypes.string),
+  onMouseEnter: PropTypes.func,
+  onMouseLeave: PropTypes.func,
+  onRightClick: PropTypes.func,
+  onDragStart: PropTypes.func,
+  onDragEnter: PropTypes.func,
+  onDragOver: PropTypes.func,
+  onDragLeave: PropTypes.func,
+  onDragEnd: PropTypes.func,
+  onDrop: PropTypes.func,
+  filterTreeNode: PropTypes.func,
+  motion: PropTypes.object,
+  switcherIcon: PropTypes.oneOfType([PropTypes.node, PropTypes.func])
+};
+Tree$2.defaultProps = {
+  prefixCls: 'rc-tree',
+  showLine: false,
+  showIcon: true,
+  selectable: true,
+  multiple: false,
+  checkable: false,
+  disabled: false,
+  checkStrictly: false,
+  draggable: false,
+  defaultExpandParent: true,
+  autoExpandParent: false,
+  defaultExpandAll: false,
+  defaultExpandedKeys: [],
+  defaultCheckedKeys: [],
+  defaultSelectedKeys: []
+};
+polyfill(Tree$2);
+
+var Tree$1 = Tree$2;
+Tree$1.TreeNode = ContextTreeNode;
+
+function _toConsumableArray$1(arr) { return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread$1(); }
+
+function _nonIterableSpread$1() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(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$1(o, minLen); }
+
+function _iterableToArray$1(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles$1(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$1(arr); }
+
+function _arrayLikeToArray$1(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; }
+var Record;
+
+(function (Record) {
+  Record[Record["None"] = 0] = "None";
+  Record[Record["Start"] = 1] = "Start";
+  Record[Record["End"] = 2] = "End";
+})(Record || (Record = {})); // TODO: Move this logic into `rc-tree`
+
+
+function traverseNodesKey(rootChildren, callback) {
+  var nodeList = getNodeChildren(rootChildren) || [];
+
+  function processNode(node) {
+    var key = node.key,
+        children = node.props.children;
+
+    if (callback(key, node) !== false) {
+      traverseNodesKey(children, callback);
+    }
+  }
+
+  nodeList.forEach(processNode);
+}
+
+function getFullKeyList(children) {
+  var _convertTreeToEntitie = convertTreeToEntities(children),
+      keyEntities = _convertTreeToEntitie.keyEntities;
+
+  return Object.keys(keyEntities);
+}
+/** 计算选中范围，只考虑expanded情况以优化性能 */
+
+function calcRangeKeys(rootChildren, expandedKeys, startKey, endKey) {
+  var keys = [];
+  var record = Record.None;
+
+  if (startKey && startKey === endKey) {
+    return [startKey];
+  }
+
+  if (!startKey || !endKey) {
+    return [];
+  }
+
+  function matchKey(key) {
+    return key === startKey || key === endKey;
+  }
+
+  traverseNodesKey(rootChildren, function (key) {
+    if (record === Record.End) {
+      return false;
+    }
+
+    if (matchKey(key)) {
+      // Match test
+      keys.push(key);
+
+      if (record === Record.None) {
+        record = Record.Start;
+      } else if (record === Record.Start) {
+        record = Record.End;
+        return false;
+      }
+    } else if (record === Record.Start) {
+      // Append selection
+      keys.push(key);
+    }
+
+    if (expandedKeys.indexOf(key) === -1) {
+      return false;
+    }
+
+    return true;
+  });
+  return keys;
+}
+function convertDirectoryKeysToNodes(rootChildren, keys) {
+  var restKeys = _toConsumableArray$1(keys);
+
+  var nodes = [];
+  traverseNodesKey(rootChildren, function (key, node) {
+    var index = restKeys.indexOf(key);
+
+    if (index !== -1) {
+      nodes.push(node);
+      restKeys.splice(index, 1);
+    }
+
+    return !!restKeys.length;
+  });
+  return nodes;
+}
+function getFullKeyListByTreeData(treeData) {
+  var keys = [];
+  (treeData || []).forEach(function (item) {
+    keys.push(item.key);
+
+    if (item.children) {
+      keys = [].concat(_toConsumableArray$1(keys), _toConsumableArray$1(getFullKeyListByTreeData(item.children)));
+    }
+  });
+  return keys;
+}
+
+function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+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."); }
+
+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); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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; }
+
+function _extends$1() { _extends$1 = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$1.apply(this, arguments); }
+
+function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }
+
+function _inherits$1(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1(subClass, superClass); }
+
+function _setPrototypeOf$1(o, p) { _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1(o, p); }
+
+function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf$1(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1(this, result); }; }
+
+function _possibleConstructorReturn$1(self, call) { if (call && (_typeof$1(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1(self); }
+
+function _assertThisInitialized$1(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct$1() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf$1(o) { _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1(o); }
+
+var __rest = undefined && undefined.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+function getIcon(props) {
+  var isLeaf = props.isLeaf,
+      expanded = props.expanded;
+
+  if (isLeaf) {
+    return /*#__PURE__*/React.createElement(Icon, {
+      type: "file"
+    });
+  }
+
+  return /*#__PURE__*/React.createElement(Icon, {
+    type: expanded ? 'folder-open' : 'folder'
+  });
+}
+
+var DirectoryTree = /*#__PURE__*/function (_React$Component) {
+  _inherits$1(DirectoryTree, _React$Component);
+
+  var _super = _createSuper$1(DirectoryTree);
+
+  function DirectoryTree(props) {
+    var _this;
+
+    _classCallCheck$1(this, DirectoryTree);
+
+    _this = _super.call(this, props);
+
+    _this.onExpand = function (expandedKeys, info) {
+      var onExpand = _this.props.onExpand;
+
+      _this.setUncontrolledState({
+        expandedKeys: expandedKeys
+      }); // Call origin function
+
+
+      if (onExpand) {
+        return onExpand(expandedKeys, info);
+      }
+
+      return undefined;
+    };
+
+    _this.onClick = function (event, node) {
+      var _this$props = _this.props,
+          onClick = _this$props.onClick,
+          expandAction = _this$props.expandAction; // Expand the tree
+
+      if (expandAction === 'click') {
+        _this.onDebounceExpand(event, node);
+      }
+
+      if (onClick) {
+        onClick(event, node);
+      }
+    };
+
+    _this.onDoubleClick = function (event, node) {
+      var _this$props2 = _this.props,
+          onDoubleClick = _this$props2.onDoubleClick,
+          expandAction = _this$props2.expandAction; // Expand the tree
+
+      if (expandAction === 'doubleClick') {
+        _this.onDebounceExpand(event, node);
+      }
+
+      if (onDoubleClick) {
+        onDoubleClick(event, node);
+      }
+    };
+
+    _this.onSelect = function (keys, event) {
+      var _this$props3 = _this.props,
+          onSelect = _this$props3.onSelect,
+          multiple = _this$props3.multiple,
+          children = _this$props3.children;
+      var _this$state$expandedK = _this.state.expandedKeys,
+          expandedKeys = _this$state$expandedK === void 0 ? [] : _this$state$expandedK;
+      var node = event.node,
+          nativeEvent = event.nativeEvent;
+      var _node$props$eventKey = node.props.eventKey,
+          eventKey = _node$props$eventKey === void 0 ? '' : _node$props$eventKey;
+      var newState = {}; // We need wrap this event since some value is not same
+
+      var newEvent = _extends$1(_extends$1({}, event), {
+        selected: true
+      }); // Windows / Mac single pick
+
+
+      var ctrlPick = nativeEvent.ctrlKey || nativeEvent.metaKey;
+      var shiftPick = nativeEvent.shiftKey; // Generate new selected keys
+
+      var newSelectedKeys;
+
+      if (multiple && ctrlPick) {
+        // Control click
+        newSelectedKeys = keys;
+        _this.lastSelectedKey = eventKey;
+        _this.cachedSelectedKeys = newSelectedKeys;
+        newEvent.selectedNodes = convertDirectoryKeysToNodes(children, newSelectedKeys);
+      } else if (multiple && shiftPick) {
+        // Shift click
+        newSelectedKeys = Array.from(new Set([].concat(_toConsumableArray(_this.cachedSelectedKeys || []), _toConsumableArray(calcRangeKeys(children, expandedKeys, eventKey, _this.lastSelectedKey)))));
+        newEvent.selectedNodes = convertDirectoryKeysToNodes(children, newSelectedKeys);
+      } else {
+        // Single click
+        newSelectedKeys = [eventKey];
+        _this.lastSelectedKey = eventKey;
+        _this.cachedSelectedKeys = newSelectedKeys;
+        newEvent.selectedNodes = [event.node];
+      }
+
+      newState.selectedKeys = newSelectedKeys;
+
+      if (onSelect) {
+        onSelect(newSelectedKeys, newEvent);
+      }
+
+      _this.setUncontrolledState(newState);
+    };
+
+    _this.setTreeRef = function (node) {
+      _this.tree = node;
+    };
+
+    _this.expandFolderNode = function (event, node) {
+      var isLeaf = node.props.isLeaf;
+
+      if (isLeaf || event.shiftKey || event.metaKey || event.ctrlKey) {
+        return;
+      } // Get internal rc-tree
+
+
+      var internalTree = _this.tree.tree; // Call internal rc-tree expand function
+      // https://github.com/ant-design/ant-design/issues/12567
+
+      internalTree.onNodeExpand(event, node);
+    };
+
+    _this.setUncontrolledState = function (state) {
+      var newState = omit(state, Object.keys(_this.props));
+
+      if (Object.keys(newState).length) {
+        _this.setState(newState);
+      }
+    };
+
+    _this.renderDirectoryTree = function (_ref) {
+      var getPrefixCls = _ref.getPrefixCls;
+
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          className = _a.className,
+          props = __rest(_a, ["prefixCls", "className"]);
+
+      var _this$state = _this.state,
+          expandedKeys = _this$state.expandedKeys,
+          selectedKeys = _this$state.selectedKeys;
+      var prefixCls = getPrefixCls('tree', customizePrefixCls);
+      var connectClassName = classNames("".concat(prefixCls, "-directory"), className);
+      return /*#__PURE__*/React.createElement(Tree, _extends$1({
+        icon: getIcon,
+        ref: _this.setTreeRef
+      }, props, {
+        prefixCls: prefixCls,
+        className: connectClassName,
+        expandedKeys: expandedKeys,
+        selectedKeys: selectedKeys,
+        onSelect: _this.onSelect,
+        onClick: _this.onClick,
+        onDoubleClick: _this.onDoubleClick,
+        onExpand: _this.onExpand
+      }));
+    };
+
+    var defaultExpandAll = props.defaultExpandAll,
+        defaultExpandParent = props.defaultExpandParent,
+        expandedKeys = props.expandedKeys,
+        defaultExpandedKeys = props.defaultExpandedKeys,
+        children = props.children;
+
+    var _convertTreeToEntitie = convertTreeToEntities(children),
+        keyEntities = _convertTreeToEntitie.keyEntities; // Selected keys
+
+
+    _this.state = {
+      selectedKeys: props.selectedKeys || props.defaultSelectedKeys || []
+    }; // Expanded keys
+
+    if (defaultExpandAll) {
+      if (props.treeData) {
+        _this.state.expandedKeys = getFullKeyListByTreeData(props.treeData);
+      } else {
+        _this.state.expandedKeys = getFullKeyList(props.children);
+      }
+    } else if (defaultExpandParent) {
+      _this.state.expandedKeys = conductExpandParent(expandedKeys || defaultExpandedKeys, keyEntities);
+    } else {
+      _this.state.expandedKeys = expandedKeys || defaultExpandedKeys;
+    }
+
+    _this.onDebounceExpand = debounce(_this.expandFolderNode, 200, {
+      leading: true
+    });
+    return _this;
+  }
+
+  _createClass$1(DirectoryTree, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderDirectoryTree);
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps) {
+      var newState = {};
+
+      if ('expandedKeys' in nextProps) {
+        newState.expandedKeys = nextProps.expandedKeys;
+      }
+
+      if ('selectedKeys' in nextProps) {
+        newState.selectedKeys = nextProps.selectedKeys;
+      }
+
+      return newState;
+    }
+  }]);
+
+  return DirectoryTree;
+}(React.Component);
+
+DirectoryTree.defaultProps = {
+  showIcon: true,
+  expandAction: 'click'
+};
+polyfill(DirectoryTree);
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+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; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var Tree = /*#__PURE__*/function (_React$Component) {
+  _inherits(Tree, _React$Component);
+
+  var _super = _createSuper(Tree);
+
+  function Tree() {
+    var _this;
+
+    _classCallCheck(this, Tree);
+
+    _this = _super.apply(this, arguments);
+
+    _this.renderSwitcherIcon = function (prefixCls, switcherIcon, _ref) {
+      var isLeaf = _ref.isLeaf,
+          expanded = _ref.expanded,
+          loading = _ref.loading;
+      var showLine = _this.props.showLine;
+
+      if (loading) {
+        return /*#__PURE__*/React.createElement(Icon, {
+          type: "loading",
+          className: "".concat(prefixCls, "-switcher-loading-icon")
+        });
+      }
+
+      if (isLeaf) {
+        return showLine ? /*#__PURE__*/React.createElement(Icon, {
+          type: "file",
+          className: "".concat(prefixCls, "-switcher-line-icon")
+        }) : null;
+      }
+
+      var switcherCls = "".concat(prefixCls, "-switcher-icon");
+
+      if (switcherIcon) {
+        return /*#__PURE__*/React.cloneElement(switcherIcon, {
+          className: classNames(switcherIcon.props.className || '', switcherCls)
+        });
+      }
+
+      return showLine ? /*#__PURE__*/React.createElement(Icon, {
+        type: expanded ? 'minus-square' : 'plus-square',
+        className: "".concat(prefixCls, "-switcher-line-icon"),
+        theme: "outlined"
+      }) : /*#__PURE__*/React.createElement(Icon, {
+        type: "caret-down",
+        className: switcherCls,
+        theme: "filled"
+      });
+    };
+
+    _this.setTreeRef = function (node) {
+      _this.tree = node;
+    };
+
+    _this.renderTree = function (_ref2) {
+      var _classNames;
+
+      var getPrefixCls = _ref2.getPrefixCls;
+
+      var _assertThisInitialize = _assertThisInitialized(_this),
+          props = _assertThisInitialize.props;
+
+      var customizePrefixCls = props.prefixCls,
+          className = props.className,
+          showIcon = props.showIcon,
+          _switcherIcon = props.switcherIcon,
+          blockNode = props.blockNode,
+          children = props.children;
+      var checkable = props.checkable;
+      var prefixCls = getPrefixCls('tree', customizePrefixCls);
+      return /*#__PURE__*/React.createElement(Tree$1, _extends({
+        ref: _this.setTreeRef
+      }, props, {
+        prefixCls: prefixCls,
+        className: classNames(className, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-icon-hide"), !showIcon), _defineProperty(_classNames, "".concat(prefixCls, "-block-node"), blockNode), _classNames)),
+        checkable: checkable ? /*#__PURE__*/React.createElement("span", {
+          className: "".concat(prefixCls, "-checkbox-inner")
+        }) : checkable,
+        switcherIcon: function switcherIcon(nodeProps) {
+          return _this.renderSwitcherIcon(prefixCls, _switcherIcon, nodeProps);
+        }
+      }), children);
+    };
+
+    return _this;
+  }
+
+  _createClass(Tree, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderTree);
+    }
+  }]);
+
+  return Tree;
+}(React.Component);
+Tree.TreeNode = ContextTreeNode;
+Tree.DirectoryTree = DirectoryTree;
+Tree.defaultProps = {
+  checkable: false,
+  showIcon: false,
+  motion: _extends(_extends({}, collapseMotion), {
+    motionAppear: false
+  }),
+  blockNode: false
+};
+
+export { Tree as T, requireIsSymbol as a, requireToNumber as b, collapseMotion as c, debounce as d, reactIsExports as e, require_root as f, require_baseGetTag as g, requireIsObject as h, requireIsObjectLike as i, require_freeGlobal as j, require_Symbol as r, toArray as t, warning as w };