nancal-utils-plugin/dist/nancal-utils.esm.js

JavaScript 函数库、工具类

function getDefaultExportFromCjs (x) {
	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}

var setupDefaults_1;
var hasRequiredSetupDefaults;

function requireSetupDefaults () {
	if (hasRequiredSetupDefaults) return setupDefaults_1;
	hasRequiredSetupDefaults = 1;

	var setupDefaults = {
	  keyId: 1,
	  cookies: {
	    path: '/'
	  },
	  treeOptions: {
	    parentKey: 'parentId',
	    key: 'id',
	    children: 'children'
	  },
	  parseDateFormat: 'yyyy-MM-dd HH:mm:ss',
	  firstDayOfWeek: 1
	};

	setupDefaults_1 = setupDefaults;
	return setupDefaults_1;
}

var arrayEach_1;
var hasRequiredArrayEach;

function requireArrayEach () {
	if (hasRequiredArrayEach) return arrayEach_1;
	hasRequiredArrayEach = 1;
	function arrayEach (list, iterate, context) {
	  if (list) {
	    if (list.forEach) {
	      list.forEach(iterate, context);
	    } else {
	      for (var index = 0, len = list.length; index < len; index++) {
	        iterate.call(context, list[index], index, list);
	      }
	    }
	  }
	}

	arrayEach_1 = arrayEach;
	return arrayEach_1;
}

var staticObjectToString;
var hasRequiredStaticObjectToString;

function requireStaticObjectToString () {
	if (hasRequiredStaticObjectToString) return staticObjectToString;
	hasRequiredStaticObjectToString = 1;
	var objectToString = Object.prototype.toString;

	staticObjectToString = objectToString;
	return staticObjectToString;
}

var helperCreateInInObjectString_1;
var hasRequiredHelperCreateInInObjectString;

function requireHelperCreateInInObjectString () {
	if (hasRequiredHelperCreateInInObjectString) return helperCreateInInObjectString_1;
	hasRequiredHelperCreateInInObjectString = 1;
	var objectToString = requireStaticObjectToString();

	function helperCreateInInObjectString (type) {
	  return function (obj) {
	    return '[object ' + type + ']' === objectToString.call(obj)
	  }
	}

	helperCreateInInObjectString_1 = helperCreateInInObjectString;
	return helperCreateInInObjectString_1;
}

var isArray_1;
var hasRequiredIsArray;

function requireIsArray () {
	if (hasRequiredIsArray) return isArray_1;
	hasRequiredIsArray = 1;
	var helperCreateInInObjectString = requireHelperCreateInInObjectString();

	/**
	  * 判断是否数组
	  *
	  * @param {Object} obj 对象
	  * @return {Boolean}
	  */
	var isArray = Array.isArray || helperCreateInInObjectString('Array');

	isArray_1 = isArray;
	return isArray_1;
}

/**
  * 判断对象自身属性中是否具有指定的属性
  *
  * @param {Object} obj 对象
  * @param {String/Number} key 键值
  * @return {Boolean}
  */

var hasOwnProp_1;
var hasRequiredHasOwnProp;

function requireHasOwnProp () {
	if (hasRequiredHasOwnProp) return hasOwnProp_1;
	hasRequiredHasOwnProp = 1;
	function hasOwnProp (obj, key) {
	  return obj && obj.hasOwnProperty ? obj.hasOwnProperty(key) : false
	}

	hasOwnProp_1 = hasOwnProp;
	return hasOwnProp_1;
}

var objectEach_1;
var hasRequiredObjectEach;

function requireObjectEach () {
	if (hasRequiredObjectEach) return objectEach_1;
	hasRequiredObjectEach = 1;
	var hasOwnProp = requireHasOwnProp();

	function objectEach (obj, iterate, context) {
	  if (obj) {
	    for (var key in obj) {
	      if (hasOwnProp(obj, key)) {
	        iterate.call(context, obj[key], key, obj);
	      }
	    }
	  }
	}

	objectEach_1 = objectEach;
	return objectEach_1;
}

var each_1;
var hasRequiredEach;

function requireEach () {
	if (hasRequiredEach) return each_1;
	hasRequiredEach = 1;
	var isArray = requireIsArray();
	var arrayEach = requireArrayEach();
	var objectEach = requireObjectEach();

	/**
	  * 迭代器
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Object}
	  */
	function each (obj, iterate, context) {
	  if (obj) {
	    return (isArray(obj) ? arrayEach : objectEach)(obj, iterate, context)
	  }
	  return obj
	}

	each_1 = each;
	return each_1;
}

/* eslint-disable valid-typeof */

var helperCreateInTypeof_1;
var hasRequiredHelperCreateInTypeof;

function requireHelperCreateInTypeof () {
	if (hasRequiredHelperCreateInTypeof) return helperCreateInTypeof_1;
	hasRequiredHelperCreateInTypeof = 1;
	function helperCreateInTypeof (type) {
	  return function (obj) {
	    return typeof obj === type
	  }
	}

	helperCreateInTypeof_1 = helperCreateInTypeof;
	return helperCreateInTypeof_1;
}

var isFunction_1;
var hasRequiredIsFunction;

function requireIsFunction () {
	if (hasRequiredIsFunction) return isFunction_1;
	hasRequiredIsFunction = 1;
	var helperCreateInTypeof = requireHelperCreateInTypeof();

	/**
	  * 判断是否方法
	  *
	  * @param {Object} obj 对象
	  * @return {Boolean}
	  */
	var isFunction = helperCreateInTypeof('function');

	isFunction_1 = isFunction;
	return isFunction_1;
}

var helperCreateGetObjects_1;
var hasRequiredHelperCreateGetObjects;

function requireHelperCreateGetObjects () {
	if (hasRequiredHelperCreateGetObjects) return helperCreateGetObjects_1;
	hasRequiredHelperCreateGetObjects = 1;
	var each = requireEach();

	function helperCreateGetObjects (name, getIndex) {
	  var proMethod = Object[name];
	  return function (obj) {
	    var result = [];
	    if (obj) {
	      if (proMethod) {
	        return proMethod(obj)
	      }
	      each(obj, getIndex > 1 ? function (key) {
	        result.push(['' + key, obj[key]]);
	      } : function () {
	        result.push(arguments[getIndex]);
	      });
	    }
	    return result
	  }
	}

	helperCreateGetObjects_1 = helperCreateGetObjects;
	return helperCreateGetObjects_1;
}

var keys_1;
var hasRequiredKeys;

function requireKeys () {
	if (hasRequiredKeys) return keys_1;
	hasRequiredKeys = 1;
	var helperCreateGetObjects = requireHelperCreateGetObjects();

	/**
	  * 获取对象所有属性
	  *
	  * @param {Object} obj 对象/数组
	  * @return {Array}
	  */
	var keys = helperCreateGetObjects('keys', 1);

	keys_1 = keys;
	return keys_1;
}

var clone_1;
var hasRequiredClone;

function requireClone () {
	if (hasRequiredClone) return clone_1;
	hasRequiredClone = 1;
	var objectToString = requireStaticObjectToString();

	var objectEach = requireObjectEach();
	var arrayEach = requireArrayEach();

	function getCativeCtor (val, args) {
	  var Ctor = val.__proto__.constructor;
	  return args ? new Ctor(args) : new Ctor()
	}

	function handleValueClone (item, isDeep) {
	  return isDeep ? copyValue(item, isDeep) : item
	}

	function copyValue (val, isDeep) {
	  if (val) {
	    switch(objectToString.call(val)) {
	      case "[object Object]": {
	        var restObj = Object.create(Object.getPrototypeOf(val));
	        objectEach(val, function (item, key) {
	          restObj[key] = handleValueClone(item, isDeep);
	        });
	        return restObj
	      }
	      case "[object Date]":
	      case "[object RegExp]": {
	        return getCativeCtor(val, val.valueOf())
	      }
	      case "[object Array]":
	      case "[object Arguments]":  {
	        var restArr = [];
	        arrayEach(val, function (item) {
	          restArr.push(handleValueClone(item, isDeep));
	        });
	        return restArr
	      }
	      case "[object Set]": {
	        var restSet = getCativeCtor(val);
	        restSet.forEach(function (item) {
	          restSet.add(handleValueClone(item, isDeep));
	        });
	        return restSet
	      }
	      case "[object Map]": {
	        var restMap = getCativeCtor(val);
	        restMap.forEach(function (item, key) {
	          restMap.set(key, handleValueClone(item, isDeep));
	        });
	        return restMap
	      }
	    }
	  }
	  return val
	}

	/**
	  * 浅拷贝/深拷贝
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Boolean} deep 是否深拷贝
	  * @return {Object}
	  */
	function clone (obj, deep) {
	  if (obj) {
	    return copyValue(obj, deep)
	  }
	  return obj
	}

	clone_1 = clone;
	return clone_1;
}

var assign_1;
var hasRequiredAssign;

function requireAssign () {
	if (hasRequiredAssign) return assign_1;
	hasRequiredAssign = 1;
	var arrayEach = requireArrayEach();
	var keys = requireKeys();
	var isArray = requireIsArray();
	var clone = requireClone();

	var objectAssignFns = Object.assign;

	function handleAssign (destination, args, isClone) {
	  var len = args.length;
	  for (var source, index = 1; index < len; index++) {
	    source = args[index];
	    arrayEach(keys(args[index]), isClone ? function (key) {
	      destination[key] = clone(source[key], isClone);
	    } : function (key) {
	      destination[key] = source[key];
	    });
	  }
	  return destination
	}

	/**
	  * 将一个或多个源对象复制到目标对象中
	  *
	  * @param {Object} target 目标对象
	  * @param {...Object}
	  * @return {Boolean}
	  */
	var assign = function (target) {
	  if (target) {
	    var args = arguments;
	    if (target === true) {
	      if (args.length > 1) {
	        target = isArray(target[1]) ? [] : {};
	        return handleAssign(target, args, true)
	      }
	    } else {
	      return objectAssignFns ? objectAssignFns.apply(Object, args) : handleAssign(target, args)
	    }
	  }
	  return target
	};

	assign_1 = assign;
	return assign_1;
}

var ctor;
var hasRequiredCtor;

function requireCtor () {
	if (hasRequiredCtor) return ctor;
	hasRequiredCtor = 1;

	var setupDefaults = requireSetupDefaults();

	var arrayEach = requireArrayEach();
	var each = requireEach();
	var isFunction = requireIsFunction();

	var assign = requireAssign();

	var NUtils = function () {};

	function mixin() {
	  arrayEach(arguments, function (methods) {
	    each(methods, function (fn, name) {
	      NUtils[name] = isFunction(fn)
	        ? function () {
	            var result = fn.apply(NUtils.$context, arguments);
	            NUtils.$context = null;
	            return result;
	          }
	        : fn;
	    });
	  });
	}

	function setConfig(options) {
	  return assign(setupDefaults, options);
	}

	function getConfig() {
	  return setupDefaults;
	}

	var version = "@VERSION";

	NUtils.VERSION = version;
	NUtils.version = version;
	NUtils.mixin = mixin;
	NUtils.setup = setConfig;
	NUtils.setConfig = setConfig;
	NUtils.getConfig = getConfig;

	ctor = NUtils;
	return ctor;
}

var lastArrayEach_1;
var hasRequiredLastArrayEach;

function requireLastArrayEach () {
	if (hasRequiredLastArrayEach) return lastArrayEach_1;
	hasRequiredLastArrayEach = 1;
	function lastArrayEach (obj, iterate, context) {
	  for (var len = obj.length - 1; len >= 0; len--) {
	    iterate.call(context, obj[len], len, obj);
	  }
	}

	lastArrayEach_1 = lastArrayEach;
	return lastArrayEach_1;
}

var lastObjectEach_1;
var hasRequiredLastObjectEach;

function requireLastObjectEach () {
	if (hasRequiredLastObjectEach) return lastObjectEach_1;
	hasRequiredLastObjectEach = 1;
	var lastArrayEach = requireLastArrayEach();
	var keys = requireKeys();

	function lastObjectEach (obj, iterate, context) {
	  lastArrayEach(keys(obj), function (key) {
	    iterate.call(context, obj[key], key, obj);
	  });
	}

	lastObjectEach_1 = lastObjectEach;
	return lastObjectEach_1;
}

/**
  * 判断是否为Null
  *
  * @param {Object} obj 对象
  * @return {Boolean}
  */

var isNull_1;
var hasRequiredIsNull;

function requireIsNull () {
	if (hasRequiredIsNull) return isNull_1;
	hasRequiredIsNull = 1;
	function isNull (obj) {
	  return obj === null
	}

	isNull_1 = isNull;
	return isNull_1;
}

var property_1;
var hasRequiredProperty;

function requireProperty () {
	if (hasRequiredProperty) return property_1;
	hasRequiredProperty = 1;
	var isNull = requireIsNull();

	/**
	 * 返回一个获取对象属性的函数
	 *
	 * @param {String} name 属性名
	 * @param {Object} defs 空值
	 */
	function property (name, defs) {
	  return function (obj) {
	    return isNull(obj) ? defs : obj[name]
	  }
	}

	property_1 = property;
	return property_1;
}

var objectMap_1;
var hasRequiredObjectMap;

function requireObjectMap () {
	if (hasRequiredObjectMap) return objectMap_1;
	hasRequiredObjectMap = 1;
	var each = requireEach();
	var isFunction = requireIsFunction();
	var property = requireProperty();

	/**
	  * 指定方法后的返回值组成的新对象
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Object}
	  */
	function objectMap (obj, iterate, context) {
	  var result = {};
	  if (obj) {
	    if (iterate) {
	      if (!isFunction(iterate)) {
	        iterate = property(iterate);
	      }
	      each(obj, function (val, index) {
	        result[index] = iterate.call(context, val, index, obj);
	      });
	    } else {
	      return obj
	    }
	  }
	  return result
	}

	objectMap_1 = objectMap;
	return objectMap_1;
}

/**
  * 判断是否对象
  *
  * @param {Object} obj 对象
  * @return {Boolean}
  */

var isPlainObject_1;
var hasRequiredIsPlainObject;

function requireIsPlainObject () {
	if (hasRequiredIsPlainObject) return isPlainObject_1;
	hasRequiredIsPlainObject = 1;
	function isPlainObject (obj) {
	  return obj ? obj.constructor === Object : false
	}

	isPlainObject_1 = isPlainObject;
	return isPlainObject_1;
}

var helperCheckCopyKey_1;
var hasRequiredHelperCheckCopyKey;

function requireHelperCheckCopyKey () {
	if (hasRequiredHelperCheckCopyKey) return helperCheckCopyKey_1;
	hasRequiredHelperCheckCopyKey = 1;
	function helperCheckCopyKey (key) {
	  return key !== '__proto__' && key !== 'constructor'
	}

	helperCheckCopyKey_1 = helperCheckCopyKey;
	return helperCheckCopyKey_1;
}

var merge_1;
var hasRequiredMerge;

function requireMerge () {
	if (hasRequiredMerge) return merge_1;
	hasRequiredMerge = 1;
	var isArray = requireIsArray();
	var isPlainObject = requireIsPlainObject();
	var isFunction = requireIsFunction();
	var each = requireEach();

	var helperCheckCopyKey = requireHelperCheckCopyKey();

	function handleMerge (target, source) {
	  if ((isPlainObject(target) && isPlainObject(source)) || (isArray(target) && isArray(source))) {
	    each(source, function (val, key) {
	      if (helperCheckCopyKey(key)) {
	        target[key] = isFunction(source) ? val : handleMerge(target[key], val);
	      }
	    });
	    return target
	  }
	  return source
	}

	/**
	  * 将一个或多个源对象合并到目标对象中
	  *
	  * @param {Object} target 目标对象
	  * @param {...Object}
	  * @return {Boolean}
	  */
	var merge = function (target) {
	  if (!target) {
	    target = {};
	  }
	  var args = arguments;
	  var len = args.length;
	  for (var source, index = 1; index < len; index++) {
	    source = args[index];
	    if (source) {
	      handleMerge(target, source);
	    }
	  }
	  return target
	};

	merge_1 = merge;
	return merge_1;
}

var map_1;
var hasRequiredMap;

function requireMap () {
	if (hasRequiredMap) return map_1;
	hasRequiredMap = 1;
	var each = requireEach();

	/**
	  * 指定方法后的返回值组成的新数组
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Array}
	  */
	function map (obj, iterate, context) {
	  var result = [];
	  if (obj && arguments.length > 1) {
	    if (obj.map) {
	      return obj.map(iterate, context)
	    } else {
	      each(obj, function () {
	        result.push(iterate.apply(context, arguments));
	      });
	    }
	  }
	  return result
	}

	map_1 = map;
	return map_1;
}

var helperCreateIterateHandle_1;
var hasRequiredHelperCreateIterateHandle;

function requireHelperCreateIterateHandle () {
	if (hasRequiredHelperCreateIterateHandle) return helperCreateIterateHandle_1;
	hasRequiredHelperCreateIterateHandle = 1;
	var hasOwnProp = requireHasOwnProp();
	var isArray = requireIsArray();

	function helperCreateIterateHandle (prop, useArray, restIndex, matchValue, defaultValue) {
	  return function (obj, iterate, context) {
	    if (obj && iterate) {
	      if (prop && obj[prop]) {
	        return obj[prop](iterate, context)
	      } else {
	        if (useArray && isArray(obj)) {
	          for (var index = 0, len = obj.length; index < len; index++) {
	            if (!!iterate.call(context, obj[index], index, obj) === matchValue) {
	              return [true, false, index, obj[index]][restIndex]
	            }
	          }
	        } else {
	          for (var key in obj) {
	            if (hasOwnProp(obj, key)) {
	              if (!!iterate.call(context, obj[key], key, obj) === matchValue) {
	                return [true, false, key, obj[key]][restIndex]
	              }
	            }
	          }
	        }
	      }
	    }
	    return defaultValue
	  }
	}

	helperCreateIterateHandle_1 = helperCreateIterateHandle;
	return helperCreateIterateHandle_1;
}

var some_1;
var hasRequiredSome;

function requireSome () {
	if (hasRequiredSome) return some_1;
	hasRequiredSome = 1;
	var helperCreateIterateHandle = requireHelperCreateIterateHandle();

	/**
	  * 对象中的值中的每一项运行给定函数,如果函数对任一项返回true,则返回true,否则返回false
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Boolean}
	  */
	var some = helperCreateIterateHandle('some', 1, 0, true, false);

	some_1 = some;
	return some_1;
}

var every_1;
var hasRequiredEvery;

function requireEvery () {
	if (hasRequiredEvery) return every_1;
	hasRequiredEvery = 1;
	var helperCreateIterateHandle = requireHelperCreateIterateHandle();

	/**
	  * 对象中的值中的每一项运行给定函数,如果该函数对每一项都返回true,则返回true,否则返回false
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Boolean}
	  */
	var every = helperCreateIterateHandle('every', 1, 1, false, true);

	every_1 = every;
	return every_1;
}

var includes_1;
var hasRequiredIncludes;

function requireIncludes () {
	if (hasRequiredIncludes) return includes_1;
	hasRequiredIncludes = 1;
	var hasOwnProp = requireHasOwnProp();

	/**
	  * 判断对象是否包含该值,成功返回true否则false
	  *
	  * @param {Object} obj 对象
	  * @param {Object} val 值
	  * @return {Boolean}
	  */
	function includes (obj, val) {
	  if (obj) {
	    if (obj.includes) {
	      return obj.includes(val)
	    }
	    for (var key in obj) {
	      if (hasOwnProp(obj, key)) {
	        if (val === obj[key]) {
	          return true
	        }
	      }
	    }
	  }
	  return false
	}

	includes_1 = includes;
	return includes_1;
}

var includeArrays_1;
var hasRequiredIncludeArrays;

function requireIncludeArrays () {
	if (hasRequiredIncludeArrays) return includeArrays_1;
	hasRequiredIncludeArrays = 1;
	var isArray = requireIsArray();
	var includes = requireIncludes();

	/**
	  * 判断数组是否包含另一数组
	  *
	  * @param {Array} array1 数组
	  * @param {Array} array2 被包含数组
	  * @return {Boolean}
	  */
	function includeArrays (array1, array2) {
	  var len;
	  var index = 0;
	  if (isArray(array1) && isArray(array2)) {
	    for (len = array2.length; index < len; index++) {
	      if (!includes(array1, array2[index])) {
	        return false
	      }
	    }
	    return true
	  }
	  return includes(array1, array2)
	}

	includeArrays_1 = includeArrays;
	return includeArrays_1;
}

var uniq_1;
var hasRequiredUniq;

function requireUniq () {
	if (hasRequiredUniq) return uniq_1;
	hasRequiredUniq = 1;
	var each = requireEach();
	var includes = requireIncludes();
	var isFunction = requireIsFunction();
	var property = requireProperty();

	/**
	 * 数组去重
	 * 
	 * @param {*} array  数组
	 * @param {*} iterate 字段或回调
	 * @param {*} context 
	 * @returns 
	 */
	function uniq (array, iterate, context) {
	  var result = [];
	  if (iterate) {
	    if (!isFunction(iterate)) {
	      iterate = property(iterate);
	    }
	    var val, valMap = {};
	    each(array, function (item, key) {
	      val = iterate.call(context, item, key, array);
	      if (!valMap[val]) {
	        valMap[val] = 1;
	        result.push(item);
	      }
	    });
	  } else {
	    each(array, function (value) {
	      if (!includes(result, value)) {
	        result.push(value);
	      }
	    });
	  }
	  return result
	}

	uniq_1 = uniq;
	return uniq_1;
}

var toArray_1;
var hasRequiredToArray;

function requireToArray () {
	if (hasRequiredToArray) return toArray_1;
	hasRequiredToArray = 1;
	var map = requireMap();

	/**
	 * 将对象或者伪数组转为新数组
	 *
	 * @param {Array} list 数组
	 * @return {Array}
	 */
	function toArray (list) {
	  return map(list, function (item) {
	    return item
	  })
	}

	toArray_1 = toArray;
	return toArray_1;
}

var union_1;
var hasRequiredUnion;

function requireUnion () {
	if (hasRequiredUnion) return union_1;
	hasRequiredUnion = 1;
	var uniq = requireUniq();
	var toArray = requireToArray();

	/**
	  * 将多个数的值返回唯一的并集数组
	  *
	  * @param {...Array} 数组
	  * @return {Array}
	  */
	function union () {
	  var args = arguments;
	  var result = [];
	  var index = 0;
	  var len = args.length;
	  for (; index < len; index++) {
	    result = result.concat(toArray(args[index]));
	  }
	  return uniq(result)
	}

	union_1 = union;
	return union_1;
}

var staticStrUndefined_1;
var hasRequiredStaticStrUndefined;

function requireStaticStrUndefined () {
	if (hasRequiredStaticStrUndefined) return staticStrUndefined_1;
	hasRequiredStaticStrUndefined = 1;
	var staticStrUndefined = 'undefined';

	staticStrUndefined_1 = staticStrUndefined;
	return staticStrUndefined_1;
}

var isUndefined_1;
var hasRequiredIsUndefined;

function requireIsUndefined () {
	if (hasRequiredIsUndefined) return isUndefined_1;
	hasRequiredIsUndefined = 1;
	var staticStrUndefined = requireStaticStrUndefined();

	var helperCreateInTypeof = requireHelperCreateInTypeof();

	/**
	  * 判断是否Undefined
	  *
	  * @param {Object} obj 对象
	  * @return {Boolean}
	  */
	var isUndefined = helperCreateInTypeof(staticStrUndefined);

	isUndefined_1 = isUndefined;
	return isUndefined_1;
}

var eqNull_1;
var hasRequiredEqNull;

function requireEqNull () {
	if (hasRequiredEqNull) return eqNull_1;
	hasRequiredEqNull = 1;
	var isNull = requireIsNull();
	var isUndefined = requireIsUndefined();

	/**
	 * 判断是否 undefined 和 null
	 * @param {Object} obj 对象
	 * @return {Boolean}
	 */
	function eqNull (obj) {
	  return isNull(obj) || isUndefined(obj)
	}

	eqNull_1 = eqNull;
	return eqNull_1;
}

var staticHGKeyRE_1;
var hasRequiredStaticHGKeyRE;

function requireStaticHGKeyRE () {
	if (hasRequiredStaticHGKeyRE) return staticHGKeyRE_1;
	hasRequiredStaticHGKeyRE = 1;
	var staticHGKeyRE = /(.+)?\[(\d+)\]$/;

	staticHGKeyRE_1 = staticHGKeyRE;
	return staticHGKeyRE_1;
}

var helperGetHGSKeys_1;
var hasRequiredHelperGetHGSKeys;

function requireHelperGetHGSKeys () {
	if (hasRequiredHelperGetHGSKeys) return helperGetHGSKeys_1;
	hasRequiredHelperGetHGSKeys = 1;
	function helperGetHGSKeys (property) {
	  // 以最快的方式判断数组，可忽略准确性
	  return property ? (property.splice && property.join ? property : ('' + property).replace(/(\[\d+\])\.?/g,'$1.').replace(/\.$/, '').split('.')) : []
	}

	helperGetHGSKeys_1 = helperGetHGSKeys;
	return helperGetHGSKeys_1;
}

var get_1;
var hasRequiredGet;

function requireGet () {
	if (hasRequiredGet) return get_1;
	hasRequiredGet = 1;
	var staticHGKeyRE = requireStaticHGKeyRE();

	var helperGetHGSKeys = requireHelperGetHGSKeys();
	var hasOwnProp = requireHasOwnProp();
	var isUndefined = requireIsUndefined();
	var eqNull = requireEqNull();

	/**
	 * 获取对象的属性的值，如果值为 undefined，则返回默认值
	 * @param {Object/Array} obj 对象
	 * @param {String/Function} property 键、路径
	 * @param {Object} defaultValue 默认值
	 * @return {Object}
	 */
	function get (obj, property, defaultValue) {
	  if (eqNull(obj)) {
	    return defaultValue
	  }
	  var result = getValueByPath(obj, property);
	  return isUndefined(result) ? defaultValue : result
	}

	function getDeepProps (obj, key) {
	  var matchs = key ? key.match(staticHGKeyRE) : '';
	  return matchs ? (matchs[1] ? (obj[matchs[1]] ? obj[matchs[1]][matchs[2]] : undefined) : obj[matchs[2]]) : obj[key]
	}

	function getValueByPath (obj, property) {
	  if (obj) {
	    var rest, props, len;
	    var index = 0;
	    if (obj[property] || hasOwnProp(obj, property)) {
	      return obj[property]
	    } else {
	      props = helperGetHGSKeys(property);
	      len = props.length;
	      if (len) {
	        for (rest = obj; index < len; index++) {
	          rest = getDeepProps(rest, props[index]);
	          if (eqNull(rest)) {
	            if (index === len - 1) {
	              return rest
	            }
	            return
	          }
	        }
	      }
	      return rest
	    }
	  }
	}

	get_1 = get;
	return get_1;
}

var orderBy_1;
var hasRequiredOrderBy;

function requireOrderBy () {
	if (hasRequiredOrderBy) return orderBy_1;
	hasRequiredOrderBy = 1;
	var arrayEach = requireArrayEach();
	var toArray = requireToArray();
	var map = requireMap();

	var isArray = requireIsArray();
	var isFunction = requireIsFunction();
	var isPlainObject = requireIsPlainObject();
	var isUndefined = requireIsUndefined();
	var isNull = requireIsNull();
	var eqNull = requireEqNull();
	var get = requireGet();
	var property = requireProperty();

	var ORDER_PROP_ASC = 'asc';
	var ORDER_PROP_DESC = 'desc';

	// function handleSort (v1, v2) {
	//   return v1 > v2 ? 1 : -1
	// }

	// '' < 数字 < 字符 < null < undefined
	function handleSort (v1, v2) {
	  if (isUndefined(v1)) {
	    return 1
	  }
	  if (isNull(v1)) {
	    return isUndefined(v2) ? -1 : 1
	  }
	  return v1 && v1.localeCompare ? v1.localeCompare(v2) : (v1 > v2 ? 1 : -1)
	}

	function buildMultiOrders (name, confs, compares) {
	  return function (item1, item2) {
	    var v1 = item1[name];
	    var v2 = item2[name];
	    if (v1 === v2) {
	      return compares ? compares(item1, item2) : 0
	    }
	    return confs.order === ORDER_PROP_DESC ? handleSort(v2, v1) : handleSort(v1, v2)
	  }
	}

	function getSortConfs (arr, list, fieldConfs, context) {
	  var sortConfs = [];
	  fieldConfs = isArray(fieldConfs) ? fieldConfs : [fieldConfs];
	  arrayEach(fieldConfs, function (handle, index) {
	    if (handle) {
	      var field = handle;
	      var order;
	      if (isArray(handle)) {
	        field = handle[0];
	        order = handle[1];
	      } else if (isPlainObject(handle)) {
	        field = handle.field;
	        order = handle.order;
	      }
	      sortConfs.push({
	        field: field,
	        order: order || ORDER_PROP_ASC
	      });
	      arrayEach(list, isFunction(field) ? function (item, key) {
	        item[index] = field.call(context, item.data, key, arr);
	      } : function (item) {
	        item[index] = field ? get(item.data, field) : item.data;
	      });
	    }
	  });
	  return sortConfs
	}

	/**
	  * 将数组进行排序
	  *
	  * @param {Array} arr 数组
	  * @param {Function/String/Array} fieldConfs 方法或属性
	  * @param {Object} context 上下文
	  * @return {Array}
	  */
	function orderBy (arr, fieldConfs, context) {
	  if (arr) {
	    if (eqNull(fieldConfs)) {
	      return toArray(arr).sort(handleSort)
	    }
	    var compares;
	    var list = map(arr, function (item) {
	      return { data: item }
	    });
	    var sortConfs = getSortConfs(arr, list, fieldConfs, context);
	    var len = sortConfs.length - 1;
	    while (len >= 0) {
	      compares = buildMultiOrders(len, sortConfs[len], compares);
	      len--;
	    }
	    if (compares) {
	      list = list.sort(compares);
	    }
	    return map(list, property('data'))
	  }
	  return []
	}

	orderBy_1 = orderBy;
	return orderBy_1;
}

var sortBy_1;
var hasRequiredSortBy;

function requireSortBy () {
	if (hasRequiredSortBy) return sortBy_1;
	hasRequiredSortBy = 1;
	var orderBy = requireOrderBy();

	var sortBy = orderBy;

	sortBy_1 = sortBy;
	return sortBy_1;
}

/**
  * 获取一个指定范围内随机数
  *
  * @param {Number} minVal 最小值
  * @param {Number} maxVal 最大值
  * @return {Number}
  */

var random_1;
var hasRequiredRandom;

function requireRandom () {
	if (hasRequiredRandom) return random_1;
	hasRequiredRandom = 1;
	function random (minVal, maxVal) {
	  return minVal >= maxVal ? minVal : ((minVal = minVal >> 0) + Math.round(Math.random() * ((maxVal || 9) - minVal)))
	}

	random_1 = random;
	return random_1;
}

var values_1;
var hasRequiredValues;

function requireValues () {
	if (hasRequiredValues) return values_1;
	hasRequiredValues = 1;
	var helperCreateGetObjects = requireHelperCreateGetObjects();

	/**
	  * 获取对象所有值
	  *
	  * @param {Object} obj 对象/数组
	  * @return {Array}
	  */
	var values = helperCreateGetObjects('values', 0);

	values_1 = values;
	return values_1;
}

var shuffle_1;
var hasRequiredShuffle;

function requireShuffle () {
	if (hasRequiredShuffle) return shuffle_1;
	hasRequiredShuffle = 1;
	var random = requireRandom();

	var values = requireValues();

	/**
	  * 将一个数组随机打乱，返回一个新的数组
	  *
	  * @param {Array} array 数组
	  * @return {Array}
	  */
	function shuffle (array) {
	  var index;
	  var result = [];
	  var list = values(array);
	  var len = list.length - 1;
	  for (; len >= 0; len--) {
	    index = len > 0 ? random(0, len) : 0;
	    result.push(list[index]);
	    list.splice(index, 1);
	  }
	  return result
	}

	shuffle_1 = shuffle;
	return shuffle_1;
}

var sample_1;
var hasRequiredSample;

function requireSample () {
	if (hasRequiredSample) return sample_1;
	hasRequiredSample = 1;
	var shuffle = requireShuffle();

	/**
	  * 从一个数组中随机返回几个元素
	  *
	  * @param {Array} array 数组
	  * @param {Number} number 个数
	  * @return {Array}
	  */
	function sample (array, number) {
	  var result = shuffle(array);
	  if (arguments.length <= 1) {
	    return result[0]
	  }
	  if (number < result.length) {
	    result.length = number || 0;
	  }
	  return result
	}

	sample_1 = sample;
	return sample_1;
}

var helperCreateToNumber_1;
var hasRequiredHelperCreateToNumber;

function requireHelperCreateToNumber () {
	if (hasRequiredHelperCreateToNumber) return helperCreateToNumber_1;
	hasRequiredHelperCreateToNumber = 1;
	function helperCreateToNumber (handle) {
	  return function (str) {
	    if (str) {
	      var num = handle(str && str.replace ? str.replace(/,/g, '') : str);
	      if (!isNaN(num)) {
	        return num
	      }
	    }
	    return 0
	  }
	}

	helperCreateToNumber_1 = helperCreateToNumber;
	return helperCreateToNumber_1;
}

var toNumber_1;
var hasRequiredToNumber;

function requireToNumber () {
	if (hasRequiredToNumber) return toNumber_1;
	hasRequiredToNumber = 1;
	var helperCreateToNumber = requireHelperCreateToNumber();

	/**
	 * 转数值
	 * @param { String/Number } str 数值
	 *
	 * @return {Number}
	 */
	var toNumber = helperCreateToNumber(parseFloat);

	toNumber_1 = toNumber;
	return toNumber_1;
}

var slice_1;
var hasRequiredSlice;

function requireSlice () {
	if (hasRequiredSlice) return slice_1;
	hasRequiredSlice = 1;
	var toNumber = requireToNumber();

	/**
	 * 裁剪 Arguments 或数组 array，从 start 位置开始到 end 结束，但不包括 end 本身的位置
	 * @param {Array/Arguments} array 数组或Arguments
	 * @param {Number} startIndex 开始索引
	 * @param {Number} endIndex 结束索引
	 */
	function slice (array, startIndex, endIndex) {
	  var result = [];
	  var argsSize = arguments.length;
	  if (array) {
	    startIndex = argsSize >= 2 ? toNumber(startIndex) : 0;
	    endIndex = argsSize >= 3 ? toNumber(endIndex) : array.length;
	    if (array.slice) {
	      return array.slice(startIndex, endIndex)
	    }
	    for (; startIndex < endIndex; startIndex++) {
	      result.push(array[startIndex]);
	    }
	  }
	  return result
	}

	slice_1 = slice;
	return slice_1;
}

var filter_1;
var hasRequiredFilter;

function requireFilter () {
	if (hasRequiredFilter) return filter_1;
	hasRequiredFilter = 1;
	var each = requireEach();

	/**
	  * 根据回调过滤数据
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Object}
	  */
	function filter (obj, iterate, context) {
	  var result = [];
	  if (obj && iterate) {
	    if (obj.filter) {
	      return obj.filter(iterate, context)
	    }
	    each(obj, function (val, key) {
	      if (iterate.call(context, val, key, obj)) {
	        result.push(val);
	      }
	    });
	  }
	  return result
	}

	filter_1 = filter;
	return filter_1;
}

var findKey_1;
var hasRequiredFindKey;

function requireFindKey () {
	if (hasRequiredFindKey) return findKey_1;
	hasRequiredFindKey = 1;
	var helperCreateIterateHandle = requireHelperCreateIterateHandle();

	/**
	  * 查找匹配第一条数据的键
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Object}
	  */
	var findKey = helperCreateIterateHandle('', 0, 2, true);

	findKey_1 = findKey;
	return findKey_1;
}

var find_1;
var hasRequiredFind;

function requireFind () {
	if (hasRequiredFind) return find_1;
	hasRequiredFind = 1;
	var helperCreateIterateHandle = requireHelperCreateIterateHandle();

	/**
	  * 从左至右遍历，匹配最近的一条数据
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Object}
	  */
	var find = helperCreateIterateHandle('find', 1, 3, true);

	find_1 = find;
	return find_1;
}

var findLast_1;
var hasRequiredFindLast;

function requireFindLast () {
	if (hasRequiredFindLast) return findLast_1;
	hasRequiredFindLast = 1;
	var isArray = requireIsArray();
	var values = requireValues();

	/**
	  * 从右至左遍历，匹配最近的一条数据
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Object}
	  */
	function findLast (obj, iterate, context) {
	  if (obj) {
	    if (!isArray(obj)) {
	      obj = values(obj);
	    }
	    for (var len = obj.length - 1; len >= 0; len--) {
	      if (iterate.call(context, obj[len], len, obj)) {
	        return obj[len]
	      }
	    }
	  }
	}

	findLast_1 = findLast;
	return findLast_1;
}

var reduce_1;
var hasRequiredReduce;

function requireReduce () {
	if (hasRequiredReduce) return reduce_1;
	hasRequiredReduce = 1;
	var keys = requireKeys();

	/**
	  * 接收一个函数作为累加器，数组中的每个值（从左到右）开始合并，最终为一个值。
	  *
	  * @param {Array} array 数组
	  * @param {Function} callback 方法
	  * @param {Object} initialValue 初始值
	  * @return {Number}
	  */
	function reduce (array, callback, initialValue) {
	  if (array) {
	    var len, reduceMethod;
	    var index = 0;
	    var context = null;
	    var previous = initialValue;
	    var isInitialVal = arguments.length > 2;
	    var keyList = keys(array);
	    if (array.length && array.reduce) {
	      reduceMethod = function () {
	        return callback.apply(context, arguments)
	      };
	      if (isInitialVal) {
	        return array.reduce(reduceMethod, previous)
	      }
	      return array.reduce(reduceMethod)
	    }
	    if (isInitialVal) {
	      index = 1;
	      previous = array[keyList[0]];
	    }
	    for (len = keyList.length; index < len; index++) {
	      previous = callback.call(context, previous, array[keyList[index]], index, array);
	    }
	    return previous
	  }
	}

	reduce_1 = reduce;
	return reduce_1;
}

var copyWithin_1;
var hasRequiredCopyWithin;

function requireCopyWithin () {
	if (hasRequiredCopyWithin) return copyWithin_1;
	hasRequiredCopyWithin = 1;
	var isArray = requireIsArray();

	/**
	  * 浅复制数组的一部分到同一数组中的另一个位置,数组大小不变
	  *
	  * @param {Array} array 数组
	  * @param {Number} target 从该位置开始替换数据
	  * @param {Number} start 从该位置开始读取数据，默认为 0 。如果为负值，表示倒数
	  * @param {Number} end 到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数
	  * @return {Array}
	  */
	function copyWithin (array, target, start, end) {
	  if (isArray(array) && array.copyWithin) {
	    return array.copyWithin(target, start, end)
	  }
	  var replaceIndex, replaceArray;
	  var targetIndex = target >> 0;
	  var startIndex = start >> 0;
	  var len = array.length;
	  var endIndex = arguments.length > 3 ? end >> 0 : len;
	  if (targetIndex < len) {
	    targetIndex = targetIndex >= 0 ? targetIndex : len + targetIndex;
	    if (targetIndex >= 0) {
	      startIndex = startIndex >= 0 ? startIndex : len + startIndex;
	      endIndex = endIndex >= 0 ? endIndex : len + endIndex;
	      if (startIndex < endIndex) {
	        for (replaceIndex = 0, replaceArray = array.slice(startIndex, endIndex); targetIndex < len; targetIndex++) {
	          if (replaceArray.length <= replaceIndex) {
	            break
	          }
	          array[targetIndex] = replaceArray[replaceIndex++];
	        }
	      }
	    }
	  }
	  return array
	}

	copyWithin_1 = copyWithin;
	return copyWithin_1;
}

var chunk_1;
var hasRequiredChunk;

function requireChunk () {
	if (hasRequiredChunk) return chunk_1;
	hasRequiredChunk = 1;
	var isArray = requireIsArray();

	/**
	  * 将一个数组分割成大小的组。如果数组不能被平均分配，那么最后一块将是剩下的元素
	  *
	  * @param {Array} array 数组
	  * @param {Number} size 每组大小
	  * @return {Array}
	  */
	function chunk (array, size) {
	  var index;
	  var result = [];
	  var arrLen = size >> 0 || 1;
	  if (isArray(array)) {
	    if (arrLen >= 0 && array.length > arrLen) {
	      index = 0;
	      while (index < array.length) {
	        result.push(array.slice(index, index + arrLen));
	        index += arrLen;
	      }
	    } else {
	      result = array.length ? [array] : array;
	    }
	  }
	  return result
	}

	chunk_1 = chunk;
	return chunk_1;
}

var pluck_1;
var hasRequiredPluck;

function requirePluck () {
	if (hasRequiredPluck) return pluck_1;
	hasRequiredPluck = 1;
	var map = requireMap();
	var property = requireProperty();

	/**
	  * 获取数组对象中某属性值，返回一个数组
	  *
	  * @param {Array} array 数组
	  * @param {String} key 属性值
	  * @return {Array}
	  */
	function pluck (obj, key) {
	  return map(obj, property(key))
	}

	pluck_1 = pluck;
	return pluck_1;
}

var helperCreateMinMax_1;
var hasRequiredHelperCreateMinMax;

function requireHelperCreateMinMax () {
	if (hasRequiredHelperCreateMinMax) return helperCreateMinMax_1;
	hasRequiredHelperCreateMinMax = 1;
	var isFunction = requireIsFunction();
	var eqNull = requireEqNull();
	var get = requireGet();

	var arrayEach = requireArrayEach();

	function helperCreateMinMax (handle) {
	  return function (arr, iterate) {
	    if (arr && arr.length) {
	      var rest, itemIndex;
	      arrayEach(arr, function (itemVal, index) {
	        if (iterate) {
	          itemVal = isFunction(iterate) ? iterate(itemVal, index, arr) : get(itemVal, iterate);
	        }
	        if (!eqNull(itemVal) && (eqNull(rest) || handle(rest, itemVal))) {
	          itemIndex = index;
	          rest = itemVal;
	        }
	      });
	      return arr[itemIndex]
	    }
	    return rest
	  }
	}

	helperCreateMinMax_1 = helperCreateMinMax;
	return helperCreateMinMax_1;
}

var max_1;
var hasRequiredMax;

function requireMax () {
	if (hasRequiredMax) return max_1;
	hasRequiredMax = 1;
	var helperCreateMinMax = requireHelperCreateMinMax();

	/**
	  * 获取最大值
	  *
	  * @param {Array} arr 数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @return {Number}
	  */
	var max = helperCreateMinMax(function (rest, itemVal) {
	  return rest < itemVal
	});

	max_1 = max;
	return max_1;
}

var unzip_1;
var hasRequiredUnzip;

function requireUnzip () {
	if (hasRequiredUnzip) return unzip_1;
	hasRequiredUnzip = 1;
	var pluck = requirePluck();

	var max = requireMax();

	/**
	 * 与 zip 相反
	 *
	 * @param {Array} arrays 数组集合
	 */
	function unzip (arrays) {
	  var index, maxItem, len;
	  var result = [];
	  if (arrays && arrays.length) {
	    index = 0;
	    maxItem = max(arrays, function (item) {
	      return item ? item.length : 0
	    });
	    for (len = maxItem ? maxItem.length : 0; index < len; index++) {
	      result.push(pluck(arrays, index));
	    }
	  }
	  return result
	}

	unzip_1 = unzip;
	return unzip_1;
}

var zip_1;
var hasRequiredZip;

function requireZip () {
	if (hasRequiredZip) return zip_1;
	hasRequiredZip = 1;
	var unzip = requireUnzip();

	/**
	 * 将每个数组中相应位置的值合并在一起
	 *
	 * @param {Array*} array 数组
	 */
	function zip () {
	  return unzip(arguments)
	}

	zip_1 = zip;
	return zip_1;
}

var zipObject_1;
var hasRequiredZipObject;

function requireZipObject () {
	if (hasRequiredZipObject) return zipObject_1;
	hasRequiredZipObject = 1;
	var values = requireValues();
	var each = requireEach();

	/**
	 * 根据键数组、值数组对转换为对象
	 *
	 * @param {Array} props 键数组
	 * @param {Number} arr 值数组
	 * @return {Object}
	 */
	function zipObject (props, arr) {
	  var result = {};
	  arr = arr || [];
	  each(values(props), function (val, key) {
	    result[val] = arr[key];
	  });
	  return result
	}

	zipObject_1 = zipObject;
	return zipObject_1;
}

var flatten_1;
var hasRequiredFlatten;

function requireFlatten () {
	if (hasRequiredFlatten) return flatten_1;
	hasRequiredFlatten = 1;
	var isArray = requireIsArray();
	var arrayEach = requireArrayEach();

	function flattenDeep (array, deep) {
	  var result = [];
	  arrayEach(array, function (vals) {
	    result = result.concat(isArray(vals) ? (deep ? flattenDeep(vals, deep) : vals) : [vals]);
	  });
	  return result
	}

	/**
	  * 将一个多维数组铺平
	  * @param {Array} array 数组
	  * @param {Boolean} deep 是否深层
	  * @return {Array}
	  */
	function flatten (array, deep) {
	  if (isArray(array)) {
	    return flattenDeep(array, deep)
	  }
	  return []
	}

	flatten_1 = flatten;
	return flatten_1;
}

var invoke_1;
var hasRequiredInvoke;

function requireInvoke () {
	if (hasRequiredInvoke) return invoke_1;
	hasRequiredInvoke = 1;
	var map = requireMap();

	var isArray = requireIsArray();

	function deepGetObj (obj, path) {
	  var index = 0;
	  var len = path.length;
	  while (obj && index < len) {
	    obj = obj[path[index++]];
	  }
	  return len && obj ? obj : 0
	}

	/**
	 * 在list的每个元素上执行方法,任何传递的额外参数都会在调用方法的时候传递给它
	 *
	 * @param {Array} list
	 * @param {Array/String/Function} path
	 * @param {...Object} arguments
	 * @return {Array}
	 */
	function invoke (list, path) {
	  var func;
	  var args = arguments;
	  var params = [];
	  var paths = [];
	  var index = 2;
	  var len = args.length;
	  for (; index < len; index++) {
	    params.push(args[index]);
	  }
	  if (isArray(path)) {
	    len = path.length - 1;
	    for (index = 0; index < len; index++) {
	      paths.push(path[index]);
	    }
	    path = path[len];
	  }
	  return map(list, function (context) {
	    if (paths.length) {
	      context = deepGetObj(context, paths);
	    }
	    func = context[path] || path;
	    if (func && func.apply) {
	      return func.apply(context, params)
	    }
	  })
	}

	invoke_1 = invoke;
	return invoke_1;
}

var helperDeleteProperty_1;
var hasRequiredHelperDeleteProperty;

function requireHelperDeleteProperty () {
	if (hasRequiredHelperDeleteProperty) return helperDeleteProperty_1;
	hasRequiredHelperDeleteProperty = 1;
	function helperDeleteProperty (obj, property) {
	  try {
	    delete obj[property];
	  } catch (e) {
	    obj[property] = undefined;
	  }
	}

	helperDeleteProperty_1 = helperDeleteProperty;
	return helperDeleteProperty_1;
}

var lastEach_1;
var hasRequiredLastEach;

function requireLastEach () {
	if (hasRequiredLastEach) return lastEach_1;
	hasRequiredLastEach = 1;
	var isArray = requireIsArray();
	var lastArrayEach = requireLastArrayEach();
	var lastObjectEach = requireLastObjectEach();

	/**
	  * 迭代器,从最后开始迭代
	  *
	  * @param {Object} obj 对象/数组
	  * @param {Function} iterate(item, index, obj) 回调
	  * @param {Object} context 上下文
	  * @return {Object}
	  */
	function lastEach (obj, iterate, context) {
	  if (obj) {
	    return (isArray(obj) ? lastArrayEach : lastObjectEach)(obj, iterate, context)
	  }
	  return obj
	}

	lastEach_1 = lastEach;
	return lastEach_1;
}

var isObject_1;
var hasRequiredIsObject;

function requireIsObject () {
	if (hasRequiredIsObject) return isObject_1;
	hasRequiredIsObject = 1;
	var helperCreateInTypeof = requireHelperCreateInTypeof();

	/**
	  * 判断是否Object对象
	  *
	  * @param {Object} obj 对象
	  * @return {Boolean}
	  */
	var isObject = helperCreateInTypeof('object');

	isObject_1 = isObject;
	return isObject_1;
}

var clear_1;
var hasRequiredClear;

function requireClear () {
	if (hasRequiredClear) return clear_1;
	hasRequiredClear = 1;
	var helperDeleteProperty = requireHelperDeleteProperty();

	var isPlainObject = requireIsPlainObject();
	var isObject = requireIsObject();
	var isArray = requireIsArray();
	var isNull = requireIsNull();
	var assign = requireAssign();
	var objectEach = requireObjectEach();

	/**
	  * 清空对象
	  *
	  * @param {Object} obj 对象
	  * @param {*} defs 默认值,如果不传（清空所有属性）、如果传对象（清空并继承)、如果传值(给所有赋值)
	  * @param {Object/Array} assigns 默认值
	  * @return {Object}
	  */
	function clear (obj, defs, assigns) {
	  if (obj) {
	    var len;
	    var isDefs = arguments.length > 1 && (isNull(defs) || !isObject(defs));
	    var extds = isDefs ? assigns : defs;
	    if (isPlainObject(obj)) {
	      objectEach(obj, isDefs ? function (val, key) {
	        obj[key] = defs;
	      } : function (val, key) {
	        helperDeleteProperty(obj, key);
	      });
	      if (extds) {
	        assign(obj, extds);
	      }
	    } else if (isArray(obj)) {
	      if (isDefs) {
	        len = obj.length;
	        while (len > 0) {
	          len--;
	          obj[len] = defs;
	        }
	      } else {
	        obj.length = 0;
	      }
	      if (extds) {
	        obj.push.apply(obj, extds);
	      }
	    }
	  }
	  return obj
	}

	clear_1 = clear;
	return clear_1;
}

var remove_1;
var hasRequiredRemove;

function requireRemove () {
	if (hasRequiredRemove) return remove_1;
	hasRequiredRemove = 1;
	var helperDeleteProperty = requireHelperDeleteProperty();

	var isFunction = requireIsFunction();
	var isArray = requireIsArray();
	var each = requireEach();
	var arrayEach = requireArrayEach();
	var lastEach = requireLastEach();
	var clear = requireClear();
	var eqNull = requireEqNull();

	function pluckProperty (name) {
	  return function (obj, key) {
	    return key === name
	  }
	}

	/**
	  * 移除对象属性
	  *
	  * @param {Object/Array} obj 对象/数组
	  * @param {Function/String} iterate 方法或属性
	  * @param {Object} context 上下文
	  * @return {Object/Array}
	  */
	function remove (obj, iterate, context) {
	  if (obj) {
	    if (!eqNull(iterate)) {
	      var removeKeys = [];
	      var rest = [];
	      if (!isFunction(iterate)) {
	        iterate = pluckProperty(iterate);
	      }
	      each(obj, function (item, index, rest) {
	        if (iterate.call(context, item, index, rest)) {
	          removeKeys.push(index);
	        }
	      });
	      if (isArray(obj)) {
	        lastEach(removeKeys, function (item, key) {
	          rest.push(obj[item]);
	          obj.splice(item, 1);
	        });
	      } else {
	        rest = {};
	        arrayEach(removeKeys, function (key) {
	          rest[key] = obj[key];
	          helperDeleteProperty(obj, key);
	        });
	      }
	      return rest
	    }
	    return clear(obj)
	  }
	  return obj
	}

	remove_1 = remove;
	return remove_1;
}

var toArrayTree_1;
var hasRequiredToArrayTree;

function requireToArrayTree () {
	if (hasRequiredToArrayTree) return toArrayTree_1;
	hasRequiredToArrayTree = 1;
	var setupDefaults = requireSetupDefaults();

	requireMap();
	var orderBy = requireOrderBy();

	var clone = requireClone();
	var eqNull = requireEqNull();
	var each = requireEach();
	var remove = requireRemove();

	var assign = requireAssign();

	function strictTree (array, optChildren) {
	  each(array, function (item) {
	    if (item[optChildren] && !item[optChildren].length) {
	      remove(item, optChildren);
	    }
	  });
	}

	/**
	  * 将一个带层级的数据列表转成树结构
	  *
	  * @param {Array} array 数组
	  * @param {Object} options {strict: false, parentKey: 'parentId', key: 'id', children: 'children', mapChildren: 'children', data: 'data'}
	  * @return {Array}
	  */
	function toArrayTree (array, options) {
	  var opts = assign({}, setupDefaults.treeOptions, options);
	  var optStrict = opts.strict;
	  var optKey = opts.key;
	  var optParentKey = opts.parentKey;
	  var optChildren = opts.children;
	  var optMapChildren = opts.mapChildren;
	  var optSortKey = opts.sortKey;
	  var optReverse = opts.reverse;
	  var optData = opts.data;
	  var result = [];
	  var treeMap = {};
	  var idsMap = {};
	  var id, treeData, parentId;

	  if (optSortKey) {
	    array = orderBy(clone(array), optSortKey);
	    if (optReverse) {
	      array = array.reverse();
	    }
	  }

	  each(array, function (item) {
	    id = item[optKey];
	    idsMap[id] = true;
	  });

	  each(array, function (item) {
	    id = item[optKey];

	    if (optData) {
	      treeData = {};
	      treeData[optData] = item;
	    } else {
	      treeData = item;
	    }

	    parentId = item[optParentKey];
	    treeMap[id] = treeMap[id] || [];
	    treeData[optKey] = id;
	    treeData[optParentKey] = parentId;

	    if (id === parentId) {
	      parentId = null;
	      console.log('Fix infinite Loop.', item);
	    }

	    treeMap[parentId] = treeMap[parentId] || [];
	    treeMap[parentId].push(treeData);
	    treeData[optChildren] = treeMap[id];
	    if (optMapChildren) {
	      treeData[optMapChildren] = treeMap[id];
	    }

	    if (!optStrict || (optStrict && eqNull(parentId))) {
	      if (!idsMap[parentId]) {
	        result.push(treeData);
	      }
	    }
	  });

	  if (optStrict) {
	    strictTree(array, optChildren);
	  }

	  return result
	}

	toArrayTree_1 = toArrayTree;
	return toArrayTree_1;
}

var toTreeArray_1;
var hasRequiredToTreeArray;

function requireToTreeArray () {
	if (hasRequiredToTreeArray) return toTreeArray_1;
	hasRequiredToTreeArray = 1;
	var setupDefaults = requireSetupDefaults();

	var arrayEach = requireArrayEach();

	var assign = requireAssign();

	function unTreeList (result, parentItem, array, opts) {
	  var optKey = opts.key;
	  var optParentKey = opts.parentKey;
	  var optChildren = opts.children;
	  var optData = opts.data;
	  var optUpdated = opts.updated;
	  var optClear = opts.clear;
	  arrayEach(array, function (item) {
	    var childList = item[optChildren];
	    if (optData) {
	      item = item[optData];
	    }
	    if (optUpdated !== false) {
	      item[optParentKey] = parentItem ? parentItem[optKey] : null;
	    }
	    result.push(item);
	    if (childList && childList.length) {
	      unTreeList(result, item, childList, opts);
	    }
	    if (optClear) {
	      delete item[optChildren];
	    }
	  });
	  return result
	}

	/**
	  * 将一个树结构转成数组列表
	  *
	  * @param {Array} array 数组
	  * @param {Object} options { children: 'children', data: 'data', clear: false }
	  * @return {Array}
	  */
	function toTreeArray (array, options) {
	  return unTreeList([], null, array, assign({}, setupDefaults.treeOptions, options))
	}

	toTreeArray_1 = toTreeArray;
	return toTreeArray_1;
}

var helperCreateTreeFunc_1;
var hasRequiredHelperCreateTreeFunc;

function requireHelperCreateTreeFunc