5203 lines
161 KiB
JavaScript
5203 lines
161 KiB
JavaScript
import {
|
|
__commonJS
|
|
} from "./chunk-PLDDJCW6.js";
|
|
|
|
// node_modules/xe-utils/setupDefaults.js
|
|
var require_setupDefaults = __commonJS({
|
|
"node_modules/xe-utils/setupDefaults.js"(exports, module) {
|
|
"use strict";
|
|
var setupDefaults = {
|
|
keyId: 1,
|
|
cookies: {
|
|
path: "/"
|
|
},
|
|
treeOptions: {
|
|
parentKey: "parentId",
|
|
key: "id",
|
|
children: "children"
|
|
},
|
|
parseDateFormat: "yyyy-MM-dd HH:mm:ss",
|
|
firstDayOfWeek: 1
|
|
};
|
|
module.exports = setupDefaults;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/arrayEach.js
|
|
var require_arrayEach = __commonJS({
|
|
"node_modules/xe-utils/arrayEach.js"(exports, module) {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
module.exports = arrayEach;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticObjectToString.js
|
|
var require_staticObjectToString = __commonJS({
|
|
"node_modules/xe-utils/staticObjectToString.js"(exports, module) {
|
|
var objectToString = Object.prototype.toString;
|
|
module.exports = objectToString;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateInInObjectString.js
|
|
var require_helperCreateInInObjectString = __commonJS({
|
|
"node_modules/xe-utils/helperCreateInInObjectString.js"(exports, module) {
|
|
var objectToString = require_staticObjectToString();
|
|
function helperCreateInInObjectString(type) {
|
|
return function(obj) {
|
|
return "[object " + type + "]" === objectToString.call(obj);
|
|
};
|
|
}
|
|
module.exports = helperCreateInInObjectString;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isArray.js
|
|
var require_isArray = __commonJS({
|
|
"node_modules/xe-utils/isArray.js"(exports, module) {
|
|
var helperCreateInInObjectString = require_helperCreateInInObjectString();
|
|
var isArray = Array.isArray || helperCreateInInObjectString("Array");
|
|
module.exports = isArray;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/hasOwnProp.js
|
|
var require_hasOwnProp = __commonJS({
|
|
"node_modules/xe-utils/hasOwnProp.js"(exports, module) {
|
|
function hasOwnProp(obj, key) {
|
|
return obj && obj.hasOwnProperty ? obj.hasOwnProperty(key) : false;
|
|
}
|
|
module.exports = hasOwnProp;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/objectEach.js
|
|
var require_objectEach = __commonJS({
|
|
"node_modules/xe-utils/objectEach.js"(exports, module) {
|
|
var hasOwnProp = require_hasOwnProp();
|
|
function objectEach(obj, iterate, context) {
|
|
if (obj) {
|
|
for (var key in obj) {
|
|
if (hasOwnProp(obj, key)) {
|
|
iterate.call(context, obj[key], key, obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
module.exports = objectEach;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/each.js
|
|
var require_each = __commonJS({
|
|
"node_modules/xe-utils/each.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var arrayEach = require_arrayEach();
|
|
var objectEach = require_objectEach();
|
|
function each(obj, iterate, context) {
|
|
if (obj) {
|
|
return (isArray(obj) ? arrayEach : objectEach)(obj, iterate, context);
|
|
}
|
|
return obj;
|
|
}
|
|
module.exports = each;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateInTypeof.js
|
|
var require_helperCreateInTypeof = __commonJS({
|
|
"node_modules/xe-utils/helperCreateInTypeof.js"(exports, module) {
|
|
function helperCreateInTypeof(type) {
|
|
return function(obj) {
|
|
return typeof obj === type;
|
|
};
|
|
}
|
|
module.exports = helperCreateInTypeof;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isFunction.js
|
|
var require_isFunction = __commonJS({
|
|
"node_modules/xe-utils/isFunction.js"(exports, module) {
|
|
var helperCreateInTypeof = require_helperCreateInTypeof();
|
|
var isFunction = helperCreateInTypeof("function");
|
|
module.exports = isFunction;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateGetObjects.js
|
|
var require_helperCreateGetObjects = __commonJS({
|
|
"node_modules/xe-utils/helperCreateGetObjects.js"(exports, module) {
|
|
var each = require_each();
|
|
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;
|
|
};
|
|
}
|
|
module.exports = helperCreateGetObjects;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/keys.js
|
|
var require_keys = __commonJS({
|
|
"node_modules/xe-utils/keys.js"(exports, module) {
|
|
var helperCreateGetObjects = require_helperCreateGetObjects();
|
|
var keys = helperCreateGetObjects("keys", 1);
|
|
module.exports = keys;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/clone.js
|
|
var require_clone = __commonJS({
|
|
"node_modules/xe-utils/clone.js"(exports, module) {
|
|
var objectToString = require_staticObjectToString();
|
|
var objectEach = require_objectEach();
|
|
var arrayEach = require_arrayEach();
|
|
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;
|
|
}
|
|
function clone(obj, deep) {
|
|
if (obj) {
|
|
return copyValue(obj, deep);
|
|
}
|
|
return obj;
|
|
}
|
|
module.exports = clone;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/assign.js
|
|
var require_assign = __commonJS({
|
|
"node_modules/xe-utils/assign.js"(exports, module) {
|
|
var arrayEach = require_arrayEach();
|
|
var keys = require_keys();
|
|
var isArray = require_isArray();
|
|
var clone = require_clone();
|
|
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;
|
|
}
|
|
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;
|
|
};
|
|
module.exports = assign;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/ctor.js
|
|
var require_ctor = __commonJS({
|
|
"node_modules/xe-utils/ctor.js"(exports, module) {
|
|
"use strict";
|
|
var setupDefaults = require_setupDefaults();
|
|
var arrayEach = require_arrayEach();
|
|
var each = require_each();
|
|
var isFunction = require_isFunction();
|
|
var assign = require_assign();
|
|
var XEUtils = function() {
|
|
};
|
|
function mixin() {
|
|
arrayEach(arguments, function(methods) {
|
|
each(methods, function(fn, name) {
|
|
XEUtils[name] = isFunction(fn) ? function() {
|
|
var result = fn.apply(XEUtils.$context, arguments);
|
|
XEUtils.$context = null;
|
|
return result;
|
|
} : fn;
|
|
});
|
|
});
|
|
}
|
|
function setConfig(options) {
|
|
return assign(setupDefaults, options);
|
|
}
|
|
function getConfig() {
|
|
return setupDefaults;
|
|
}
|
|
var version = "3.7.9";
|
|
XEUtils.VERSION = version;
|
|
XEUtils.version = version;
|
|
XEUtils.mixin = mixin;
|
|
XEUtils.setup = setConfig;
|
|
XEUtils.setConfig = setConfig;
|
|
XEUtils.getConfig = getConfig;
|
|
module.exports = XEUtils;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/lastArrayEach.js
|
|
var require_lastArrayEach = __commonJS({
|
|
"node_modules/xe-utils/lastArrayEach.js"(exports, module) {
|
|
function lastArrayEach(obj, iterate, context) {
|
|
for (var len = obj.length - 1; len >= 0; len--) {
|
|
iterate.call(context, obj[len], len, obj);
|
|
}
|
|
}
|
|
module.exports = lastArrayEach;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/lastObjectEach.js
|
|
var require_lastObjectEach = __commonJS({
|
|
"node_modules/xe-utils/lastObjectEach.js"(exports, module) {
|
|
var lastArrayEach = require_lastArrayEach();
|
|
var keys = require_keys();
|
|
function lastObjectEach(obj, iterate, context) {
|
|
lastArrayEach(keys(obj), function(key) {
|
|
iterate.call(context, obj[key], key, obj);
|
|
});
|
|
}
|
|
module.exports = lastObjectEach;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isNull.js
|
|
var require_isNull = __commonJS({
|
|
"node_modules/xe-utils/isNull.js"(exports, module) {
|
|
function isNull(obj) {
|
|
return obj === null;
|
|
}
|
|
module.exports = isNull;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/property.js
|
|
var require_property = __commonJS({
|
|
"node_modules/xe-utils/property.js"(exports, module) {
|
|
var isNull = require_isNull();
|
|
function property(name, defs) {
|
|
return function(obj) {
|
|
return isNull(obj) ? defs : obj[name];
|
|
};
|
|
}
|
|
module.exports = property;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/objectMap.js
|
|
var require_objectMap = __commonJS({
|
|
"node_modules/xe-utils/objectMap.js"(exports, module) {
|
|
var each = require_each();
|
|
var isFunction = require_isFunction();
|
|
var property = require_property();
|
|
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;
|
|
}
|
|
module.exports = objectMap;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isPlainObject.js
|
|
var require_isPlainObject = __commonJS({
|
|
"node_modules/xe-utils/isPlainObject.js"(exports, module) {
|
|
function isPlainObject(obj) {
|
|
return obj ? obj.constructor === Object : false;
|
|
}
|
|
module.exports = isPlainObject;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCheckCopyKey.js
|
|
var require_helperCheckCopyKey = __commonJS({
|
|
"node_modules/xe-utils/helperCheckCopyKey.js"(exports, module) {
|
|
function helperCheckCopyKey(key) {
|
|
return key !== "__proto__" && key !== "constructor";
|
|
}
|
|
module.exports = helperCheckCopyKey;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/merge.js
|
|
var require_merge = __commonJS({
|
|
"node_modules/xe-utils/merge.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var isPlainObject = require_isPlainObject();
|
|
var isFunction = require_isFunction();
|
|
var each = require_each();
|
|
var helperCheckCopyKey = require_helperCheckCopyKey();
|
|
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;
|
|
}
|
|
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;
|
|
};
|
|
module.exports = merge;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/map.js
|
|
var require_map = __commonJS({
|
|
"node_modules/xe-utils/map.js"(exports, module) {
|
|
var each = require_each();
|
|
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;
|
|
}
|
|
module.exports = map;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateIterateHandle.js
|
|
var require_helperCreateIterateHandle = __commonJS({
|
|
"node_modules/xe-utils/helperCreateIterateHandle.js"(exports, module) {
|
|
var hasOwnProp = require_hasOwnProp();
|
|
var isArray = require_isArray();
|
|
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;
|
|
};
|
|
}
|
|
module.exports = helperCreateIterateHandle;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/some.js
|
|
var require_some = __commonJS({
|
|
"node_modules/xe-utils/some.js"(exports, module) {
|
|
var helperCreateIterateHandle = require_helperCreateIterateHandle();
|
|
var some = helperCreateIterateHandle("some", 1, 0, true, false);
|
|
module.exports = some;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/every.js
|
|
var require_every = __commonJS({
|
|
"node_modules/xe-utils/every.js"(exports, module) {
|
|
var helperCreateIterateHandle = require_helperCreateIterateHandle();
|
|
var every = helperCreateIterateHandle("every", 1, 1, false, true);
|
|
module.exports = every;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/includes.js
|
|
var require_includes = __commonJS({
|
|
"node_modules/xe-utils/includes.js"(exports, module) {
|
|
var hasOwnProp = require_hasOwnProp();
|
|
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;
|
|
}
|
|
module.exports = includes;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/includeArrays.js
|
|
var require_includeArrays = __commonJS({
|
|
"node_modules/xe-utils/includeArrays.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var includes = require_includes();
|
|
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);
|
|
}
|
|
module.exports = includeArrays;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/uniq.js
|
|
var require_uniq = __commonJS({
|
|
"node_modules/xe-utils/uniq.js"(exports, module) {
|
|
var each = require_each();
|
|
var includes = require_includes();
|
|
var isFunction = require_isFunction();
|
|
var property = require_property();
|
|
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;
|
|
}
|
|
module.exports = uniq;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toArray.js
|
|
var require_toArray = __commonJS({
|
|
"node_modules/xe-utils/toArray.js"(exports, module) {
|
|
var map = require_map();
|
|
function toArray(list) {
|
|
return map(list, function(item) {
|
|
return item;
|
|
});
|
|
}
|
|
module.exports = toArray;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/union.js
|
|
var require_union = __commonJS({
|
|
"node_modules/xe-utils/union.js"(exports, module) {
|
|
var uniq = require_uniq();
|
|
var toArray = require_toArray();
|
|
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);
|
|
}
|
|
module.exports = union;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticStrUndefined.js
|
|
var require_staticStrUndefined = __commonJS({
|
|
"node_modules/xe-utils/staticStrUndefined.js"(exports, module) {
|
|
var staticStrUndefined = "undefined";
|
|
module.exports = staticStrUndefined;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isUndefined.js
|
|
var require_isUndefined = __commonJS({
|
|
"node_modules/xe-utils/isUndefined.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var helperCreateInTypeof = require_helperCreateInTypeof();
|
|
var isUndefined = helperCreateInTypeof(staticStrUndefined);
|
|
module.exports = isUndefined;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/eqNull.js
|
|
var require_eqNull = __commonJS({
|
|
"node_modules/xe-utils/eqNull.js"(exports, module) {
|
|
var isNull = require_isNull();
|
|
var isUndefined = require_isUndefined();
|
|
function eqNull(obj) {
|
|
return isNull(obj) || isUndefined(obj);
|
|
}
|
|
module.exports = eqNull;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticHGKeyRE.js
|
|
var require_staticHGKeyRE = __commonJS({
|
|
"node_modules/xe-utils/staticHGKeyRE.js"(exports, module) {
|
|
var staticHGKeyRE = /(.+)?\[(\d+)\]$/;
|
|
module.exports = staticHGKeyRE;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperGetHGSKeys.js
|
|
var require_helperGetHGSKeys = __commonJS({
|
|
"node_modules/xe-utils/helperGetHGSKeys.js"(exports, module) {
|
|
function helperGetHGSKeys(property) {
|
|
return property ? property.splice && property.join ? property : ("" + property).replace(/(\[\d+\])\.?/g, "$1.").replace(/\.$/, "").split(".") : [];
|
|
}
|
|
module.exports = helperGetHGSKeys;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/get.js
|
|
var require_get = __commonJS({
|
|
"node_modules/xe-utils/get.js"(exports, module) {
|
|
var staticHGKeyRE = require_staticHGKeyRE();
|
|
var helperGetHGSKeys = require_helperGetHGSKeys();
|
|
var hasOwnProp = require_hasOwnProp();
|
|
var isUndefined = require_isUndefined();
|
|
var eqNull = require_eqNull();
|
|
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]] : void 0 : 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;
|
|
}
|
|
}
|
|
}
|
|
module.exports = get;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/orderBy.js
|
|
var require_orderBy = __commonJS({
|
|
"node_modules/xe-utils/orderBy.js"(exports, module) {
|
|
var arrayEach = require_arrayEach();
|
|
var toArray = require_toArray();
|
|
var map = require_map();
|
|
var isArray = require_isArray();
|
|
var isFunction = require_isFunction();
|
|
var isPlainObject = require_isPlainObject();
|
|
var isUndefined = require_isUndefined();
|
|
var isNull = require_isNull();
|
|
var eqNull = require_eqNull();
|
|
var get = require_get();
|
|
var property = require_property();
|
|
var ORDER_PROP_ASC = "asc";
|
|
var ORDER_PROP_DESC = "desc";
|
|
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,
|
|
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;
|
|
}
|
|
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 [];
|
|
}
|
|
module.exports = orderBy;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/sortBy.js
|
|
var require_sortBy = __commonJS({
|
|
"node_modules/xe-utils/sortBy.js"(exports, module) {
|
|
var orderBy = require_orderBy();
|
|
var sortBy = orderBy;
|
|
module.exports = sortBy;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/random.js
|
|
var require_random = __commonJS({
|
|
"node_modules/xe-utils/random.js"(exports, module) {
|
|
function random(minVal, maxVal) {
|
|
return minVal >= maxVal ? minVal : (minVal = minVal >> 0) + Math.round(Math.random() * ((maxVal || 9) - minVal));
|
|
}
|
|
module.exports = random;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/values.js
|
|
var require_values = __commonJS({
|
|
"node_modules/xe-utils/values.js"(exports, module) {
|
|
var helperCreateGetObjects = require_helperCreateGetObjects();
|
|
var values = helperCreateGetObjects("values", 0);
|
|
module.exports = values;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/shuffle.js
|
|
var require_shuffle = __commonJS({
|
|
"node_modules/xe-utils/shuffle.js"(exports, module) {
|
|
var random = require_random();
|
|
var values = require_values();
|
|
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;
|
|
}
|
|
module.exports = shuffle;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/sample.js
|
|
var require_sample = __commonJS({
|
|
"node_modules/xe-utils/sample.js"(exports, module) {
|
|
var shuffle = require_shuffle();
|
|
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;
|
|
}
|
|
module.exports = sample;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateToNumber.js
|
|
var require_helperCreateToNumber = __commonJS({
|
|
"node_modules/xe-utils/helperCreateToNumber.js"(exports, module) {
|
|
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;
|
|
};
|
|
}
|
|
module.exports = helperCreateToNumber;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toNumber.js
|
|
var require_toNumber = __commonJS({
|
|
"node_modules/xe-utils/toNumber.js"(exports, module) {
|
|
var helperCreateToNumber = require_helperCreateToNumber();
|
|
var toNumber = helperCreateToNumber(parseFloat);
|
|
module.exports = toNumber;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/slice.js
|
|
var require_slice = __commonJS({
|
|
"node_modules/xe-utils/slice.js"(exports, module) {
|
|
var toNumber = require_toNumber();
|
|
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;
|
|
}
|
|
module.exports = slice;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/filter.js
|
|
var require_filter = __commonJS({
|
|
"node_modules/xe-utils/filter.js"(exports, module) {
|
|
var each = require_each();
|
|
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;
|
|
}
|
|
module.exports = filter;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/findKey.js
|
|
var require_findKey = __commonJS({
|
|
"node_modules/xe-utils/findKey.js"(exports, module) {
|
|
var helperCreateIterateHandle = require_helperCreateIterateHandle();
|
|
var findKey = helperCreateIterateHandle("", 0, 2, true);
|
|
module.exports = findKey;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/find.js
|
|
var require_find = __commonJS({
|
|
"node_modules/xe-utils/find.js"(exports, module) {
|
|
var helperCreateIterateHandle = require_helperCreateIterateHandle();
|
|
var find = helperCreateIterateHandle("find", 1, 3, true);
|
|
module.exports = find;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/findLast.js
|
|
var require_findLast = __commonJS({
|
|
"node_modules/xe-utils/findLast.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var values = require_values();
|
|
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];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
module.exports = findLast;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/reduce.js
|
|
var require_reduce = __commonJS({
|
|
"node_modules/xe-utils/reduce.js"(exports, module) {
|
|
var keys = require_keys();
|
|
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;
|
|
}
|
|
}
|
|
module.exports = reduce;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/copyWithin.js
|
|
var require_copyWithin = __commonJS({
|
|
"node_modules/xe-utils/copyWithin.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
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;
|
|
}
|
|
module.exports = copyWithin;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/chunk.js
|
|
var require_chunk = __commonJS({
|
|
"node_modules/xe-utils/chunk.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
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;
|
|
}
|
|
module.exports = chunk;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/pluck.js
|
|
var require_pluck = __commonJS({
|
|
"node_modules/xe-utils/pluck.js"(exports, module) {
|
|
var map = require_map();
|
|
var property = require_property();
|
|
function pluck(obj, key) {
|
|
return map(obj, property(key));
|
|
}
|
|
module.exports = pluck;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateMinMax.js
|
|
var require_helperCreateMinMax = __commonJS({
|
|
"node_modules/xe-utils/helperCreateMinMax.js"(exports, module) {
|
|
var isFunction = require_isFunction();
|
|
var eqNull = require_eqNull();
|
|
var get = require_get();
|
|
var arrayEach = require_arrayEach();
|
|
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;
|
|
};
|
|
}
|
|
module.exports = helperCreateMinMax;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/max.js
|
|
var require_max = __commonJS({
|
|
"node_modules/xe-utils/max.js"(exports, module) {
|
|
var helperCreateMinMax = require_helperCreateMinMax();
|
|
var max = helperCreateMinMax(function(rest, itemVal) {
|
|
return rest < itemVal;
|
|
});
|
|
module.exports = max;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/unzip.js
|
|
var require_unzip = __commonJS({
|
|
"node_modules/xe-utils/unzip.js"(exports, module) {
|
|
var pluck = require_pluck();
|
|
var max = require_max();
|
|
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;
|
|
}
|
|
module.exports = unzip;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/zip.js
|
|
var require_zip = __commonJS({
|
|
"node_modules/xe-utils/zip.js"(exports, module) {
|
|
var unzip = require_unzip();
|
|
function zip() {
|
|
return unzip(arguments);
|
|
}
|
|
module.exports = zip;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/zipObject.js
|
|
var require_zipObject = __commonJS({
|
|
"node_modules/xe-utils/zipObject.js"(exports, module) {
|
|
var values = require_values();
|
|
var each = require_each();
|
|
function zipObject(props, arr) {
|
|
var result = {};
|
|
arr = arr || [];
|
|
each(values(props), function(val, key) {
|
|
result[val] = arr[key];
|
|
});
|
|
return result;
|
|
}
|
|
module.exports = zipObject;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/flatten.js
|
|
var require_flatten = __commonJS({
|
|
"node_modules/xe-utils/flatten.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var arrayEach = require_arrayEach();
|
|
function flattenDeep(array, deep) {
|
|
var result = [];
|
|
arrayEach(array, function(vals) {
|
|
result = result.concat(isArray(vals) ? deep ? flattenDeep(vals, deep) : vals : [vals]);
|
|
});
|
|
return result;
|
|
}
|
|
function flatten(array, deep) {
|
|
if (isArray(array)) {
|
|
return flattenDeep(array, deep);
|
|
}
|
|
return [];
|
|
}
|
|
module.exports = flatten;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/invoke.js
|
|
var require_invoke = __commonJS({
|
|
"node_modules/xe-utils/invoke.js"(exports, module) {
|
|
var map = require_map();
|
|
var isArray = require_isArray();
|
|
function deepGetObj(obj, path) {
|
|
var index = 0;
|
|
var len = path.length;
|
|
while (obj && index < len) {
|
|
obj = obj[path[index++]];
|
|
}
|
|
return len && obj ? obj : 0;
|
|
}
|
|
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);
|
|
}
|
|
});
|
|
}
|
|
module.exports = invoke;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperLog.js
|
|
var require_helperLog = __commonJS({
|
|
"node_modules/xe-utils/helperLog.js"(exports, module) {
|
|
function helperLog(type, msg) {
|
|
return (console[type] || console.log)(msg);
|
|
}
|
|
module.exports = helperLog;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperDeleteProperty.js
|
|
var require_helperDeleteProperty = __commonJS({
|
|
"node_modules/xe-utils/helperDeleteProperty.js"(exports, module) {
|
|
function helperDeleteProperty(obj, property) {
|
|
try {
|
|
delete obj[property];
|
|
} catch (e) {
|
|
obj[property] = void 0;
|
|
}
|
|
}
|
|
module.exports = helperDeleteProperty;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/lastEach.js
|
|
var require_lastEach = __commonJS({
|
|
"node_modules/xe-utils/lastEach.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var lastArrayEach = require_lastArrayEach();
|
|
var lastObjectEach = require_lastObjectEach();
|
|
function lastEach(obj, iterate, context) {
|
|
if (obj) {
|
|
return (isArray(obj) ? lastArrayEach : lastObjectEach)(obj, iterate, context);
|
|
}
|
|
return obj;
|
|
}
|
|
module.exports = lastEach;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isObject.js
|
|
var require_isObject = __commonJS({
|
|
"node_modules/xe-utils/isObject.js"(exports, module) {
|
|
var helperCreateInTypeof = require_helperCreateInTypeof();
|
|
var isObject = helperCreateInTypeof("object");
|
|
module.exports = isObject;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/clear.js
|
|
var require_clear = __commonJS({
|
|
"node_modules/xe-utils/clear.js"(exports, module) {
|
|
var helperDeleteProperty = require_helperDeleteProperty();
|
|
var isPlainObject = require_isPlainObject();
|
|
var isObject = require_isObject();
|
|
var isArray = require_isArray();
|
|
var isNull = require_isNull();
|
|
var assign = require_assign();
|
|
var objectEach = require_objectEach();
|
|
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;
|
|
}
|
|
module.exports = clear;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/remove.js
|
|
var require_remove = __commonJS({
|
|
"node_modules/xe-utils/remove.js"(exports, module) {
|
|
var helperDeleteProperty = require_helperDeleteProperty();
|
|
var isFunction = require_isFunction();
|
|
var isArray = require_isArray();
|
|
var each = require_each();
|
|
var arrayEach = require_arrayEach();
|
|
var lastEach = require_lastEach();
|
|
var clear = require_clear();
|
|
var eqNull = require_eqNull();
|
|
function pluckProperty(name) {
|
|
return function(obj, key) {
|
|
return key === name;
|
|
};
|
|
}
|
|
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, rest2) {
|
|
if (iterate.call(context, item, index, rest2)) {
|
|
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;
|
|
}
|
|
module.exports = remove;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toArrayTree.js
|
|
var require_toArrayTree = __commonJS({
|
|
"node_modules/xe-utils/toArrayTree.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var helperLog = require_helperLog();
|
|
var orderBy = require_orderBy();
|
|
var clone = require_clone();
|
|
var eqNull = require_eqNull();
|
|
var each = require_each();
|
|
var remove = require_remove();
|
|
var assign = require_assign();
|
|
function strictTree(array, optChildren) {
|
|
each(array, function(item) {
|
|
if (item[optChildren] && !item[optChildren].length) {
|
|
remove(item, optChildren);
|
|
}
|
|
});
|
|
}
|
|
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 treeMaps = {};
|
|
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];
|
|
if (idsMap[id]) {
|
|
helperLog("warn", "Duplicate primary key=" + id);
|
|
}
|
|
idsMap[id] = true;
|
|
});
|
|
each(array, function(item) {
|
|
id = item[optKey];
|
|
if (optData) {
|
|
treeData = {};
|
|
treeData[optData] = item;
|
|
} else {
|
|
treeData = item;
|
|
}
|
|
parentId = item[optParentKey];
|
|
treeMaps[id] = treeMaps[id] || [];
|
|
treeData[optKey] = id;
|
|
treeData[optParentKey] = parentId;
|
|
if (id === parentId) {
|
|
parentId = null;
|
|
helperLog("warn", "Error infinite Loop. key=" + id + " parentKey=" + id);
|
|
}
|
|
treeMaps[parentId] = treeMaps[parentId] || [];
|
|
treeMaps[parentId].push(treeData);
|
|
treeData[optChildren] = treeMaps[id];
|
|
if (optMapChildren) {
|
|
treeData[optMapChildren] = treeMaps[id];
|
|
}
|
|
if (!optStrict || optStrict && eqNull(parentId)) {
|
|
if (!idsMap[parentId]) {
|
|
result.push(treeData);
|
|
}
|
|
}
|
|
});
|
|
if (optStrict) {
|
|
strictTree(array, optChildren);
|
|
}
|
|
return result;
|
|
}
|
|
module.exports = toArrayTree;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toTreeArray.js
|
|
var require_toTreeArray = __commonJS({
|
|
"node_modules/xe-utils/toTreeArray.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var arrayEach = require_arrayEach();
|
|
var assign = require_assign();
|
|
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;
|
|
}
|
|
function toTreeArray(array, options) {
|
|
return unTreeList([], null, array, assign({}, setupDefaults.treeOptions, options));
|
|
}
|
|
module.exports = toTreeArray;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateTreeFunc.js
|
|
var require_helperCreateTreeFunc = __commonJS({
|
|
"node_modules/xe-utils/helperCreateTreeFunc.js"(exports, module) {
|
|
function helperCreateTreeFunc(handle) {
|
|
return function(obj, iterate, options, context) {
|
|
var opts = options || {};
|
|
var optChildren = opts.children || "children";
|
|
return handle(null, obj, iterate, context, [], [], optChildren, opts);
|
|
};
|
|
}
|
|
module.exports = helperCreateTreeFunc;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/findTree.js
|
|
var require_findTree = __commonJS({
|
|
"node_modules/xe-utils/findTree.js"(exports, module) {
|
|
var helperCreateTreeFunc = require_helperCreateTreeFunc();
|
|
function findTreeItem(parent, obj, iterate, context, path, node, parseChildren, opts) {
|
|
if (obj) {
|
|
var item, index, len, paths, nodes, match;
|
|
for (index = 0, len = obj.length; index < len; index++) {
|
|
item = obj[index];
|
|
paths = path.concat(["" + index]);
|
|
nodes = node.concat([item]);
|
|
if (iterate.call(context, item, index, obj, paths, parent, nodes)) {
|
|
return { index, item, path: paths, items: obj, parent, nodes };
|
|
}
|
|
if (parseChildren && item) {
|
|
match = findTreeItem(item, item[parseChildren], iterate, context, paths.concat([parseChildren]), nodes, parseChildren, opts);
|
|
if (match) {
|
|
return match;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var findTree = helperCreateTreeFunc(findTreeItem);
|
|
module.exports = findTree;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/eachTree.js
|
|
var require_eachTree = __commonJS({
|
|
"node_modules/xe-utils/eachTree.js"(exports, module) {
|
|
var helperCreateTreeFunc = require_helperCreateTreeFunc();
|
|
var each = require_each();
|
|
function eachTreeItem(parent, obj, iterate, context, path, node, parseChildren, opts) {
|
|
var paths, nodes;
|
|
each(obj, function(item, index) {
|
|
paths = path.concat(["" + index]);
|
|
nodes = node.concat([item]);
|
|
iterate.call(context, item, index, obj, paths, parent, nodes);
|
|
if (item && parseChildren) {
|
|
paths.push(parseChildren);
|
|
eachTreeItem(item, item[parseChildren], iterate, context, paths, nodes, parseChildren, opts);
|
|
}
|
|
});
|
|
}
|
|
var eachTree = helperCreateTreeFunc(eachTreeItem);
|
|
module.exports = eachTree;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/mapTree.js
|
|
var require_mapTree = __commonJS({
|
|
"node_modules/xe-utils/mapTree.js"(exports, module) {
|
|
var helperCreateTreeFunc = require_helperCreateTreeFunc();
|
|
var map = require_map();
|
|
function mapTreeItem(parent, obj, iterate, context, path, node, parseChildren, opts) {
|
|
var paths, nodes, rest;
|
|
var mapChildren = opts.mapChildren || parseChildren;
|
|
return map(obj, function(item, index) {
|
|
paths = path.concat(["" + index]);
|
|
nodes = node.concat([item]);
|
|
rest = iterate.call(context, item, index, obj, paths, parent, nodes);
|
|
if (rest && item && parseChildren && item[parseChildren]) {
|
|
rest[mapChildren] = mapTreeItem(item, item[parseChildren], iterate, context, paths, nodes, parseChildren, opts);
|
|
}
|
|
return rest;
|
|
});
|
|
}
|
|
var mapTree = helperCreateTreeFunc(mapTreeItem);
|
|
module.exports = mapTree;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/filterTree.js
|
|
var require_filterTree = __commonJS({
|
|
"node_modules/xe-utils/filterTree.js"(exports, module) {
|
|
var eachTree = require_eachTree();
|
|
function filterTree(obj, iterate, options, context) {
|
|
var result = [];
|
|
if (obj && iterate) {
|
|
eachTree(obj, function(item, index, items, path, parent, nodes) {
|
|
if (iterate.call(context, item, index, items, path, parent, nodes)) {
|
|
result.push(item);
|
|
}
|
|
}, options);
|
|
}
|
|
return result;
|
|
}
|
|
module.exports = filterTree;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/searchTree.js
|
|
var require_searchTree = __commonJS({
|
|
"node_modules/xe-utils/searchTree.js"(exports, module) {
|
|
var helperCreateTreeFunc = require_helperCreateTreeFunc();
|
|
var arrayEach = require_arrayEach();
|
|
var assign = require_assign();
|
|
function searchTreeItem(matchParent, parent, obj, iterate, context, path, node, parseChildren, opts) {
|
|
var paths, nodes, rest, isMatch, hasChild;
|
|
var rests = [];
|
|
var hasOriginal = opts.original;
|
|
var sourceData = opts.data;
|
|
var mapChildren = opts.mapChildren || parseChildren;
|
|
var isEvery = opts.isEvery;
|
|
arrayEach(obj, function(item, index) {
|
|
paths = path.concat(["" + index]);
|
|
nodes = node.concat([item]);
|
|
isMatch = matchParent && !isEvery || iterate.call(context, item, index, obj, paths, parent, nodes);
|
|
hasChild = parseChildren && item[parseChildren];
|
|
if (isMatch || hasChild) {
|
|
if (hasOriginal) {
|
|
rest = item;
|
|
} else {
|
|
rest = assign({}, item);
|
|
if (sourceData) {
|
|
rest[sourceData] = item;
|
|
}
|
|
}
|
|
rest[mapChildren] = searchTreeItem(isMatch, item, item[parseChildren], iterate, context, paths, nodes, parseChildren, opts);
|
|
if (isMatch || rest[mapChildren].length) {
|
|
rests.push(rest);
|
|
}
|
|
} else if (isMatch) {
|
|
rests.push(rest);
|
|
}
|
|
});
|
|
return rests;
|
|
}
|
|
var searchTree = helperCreateTreeFunc(function(parent, obj, iterate, context, path, nodes, parseChildren, opts) {
|
|
return searchTreeItem(0, parent, obj, iterate, context, path, nodes, parseChildren, opts);
|
|
});
|
|
module.exports = searchTree;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/arrayIndexOf.js
|
|
var require_arrayIndexOf = __commonJS({
|
|
"node_modules/xe-utils/arrayIndexOf.js"(exports, module) {
|
|
function arrayIndexOf(list, val) {
|
|
if (list.indexOf) {
|
|
return list.indexOf(val);
|
|
}
|
|
for (var index = 0, len = list.length; index < len; index++) {
|
|
if (val === list[index]) {
|
|
return index;
|
|
}
|
|
}
|
|
}
|
|
module.exports = arrayIndexOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/arrayLastIndexOf.js
|
|
var require_arrayLastIndexOf = __commonJS({
|
|
"node_modules/xe-utils/arrayLastIndexOf.js"(exports, module) {
|
|
function arrayLastIndexOf(list, val) {
|
|
if (list.lastIndexOf) {
|
|
return list.lastIndexOf(val);
|
|
}
|
|
for (var len = list.length - 1; len >= 0; len--) {
|
|
if (val === list[len]) {
|
|
return len;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
module.exports = arrayLastIndexOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isNumber.js
|
|
var require_isNumber = __commonJS({
|
|
"node_modules/xe-utils/isNumber.js"(exports, module) {
|
|
var helperCreateInTypeof = require_helperCreateInTypeof();
|
|
var isNumber = helperCreateInTypeof("number");
|
|
module.exports = isNumber;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isNaN.js
|
|
var require_isNaN = __commonJS({
|
|
"node_modules/xe-utils/isNaN.js"(exports, module) {
|
|
var isNumber = require_isNumber();
|
|
function isNumberNaN(obj) {
|
|
return isNumber(obj) && isNaN(obj);
|
|
}
|
|
module.exports = isNumberNaN;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isString.js
|
|
var require_isString = __commonJS({
|
|
"node_modules/xe-utils/isString.js"(exports, module) {
|
|
var helperCreateInTypeof = require_helperCreateInTypeof();
|
|
var isString = helperCreateInTypeof("string");
|
|
module.exports = isString;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isDate.js
|
|
var require_isDate = __commonJS({
|
|
"node_modules/xe-utils/isDate.js"(exports, module) {
|
|
var helperCreateInInObjectString = require_helperCreateInInObjectString();
|
|
var isDate = helperCreateInInObjectString("Date");
|
|
module.exports = isDate;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticParseInt.js
|
|
var require_staticParseInt = __commonJS({
|
|
"node_modules/xe-utils/staticParseInt.js"(exports, module) {
|
|
var staticParseInt = parseInt;
|
|
module.exports = staticParseInt;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperGetUTCDateTime.js
|
|
var require_helperGetUTCDateTime = __commonJS({
|
|
"node_modules/xe-utils/helperGetUTCDateTime.js"(exports, module) {
|
|
function helperGetUTCDateTime(resMaps) {
|
|
return Date.UTC(resMaps.y, resMaps.M || 0, resMaps.d || 1, resMaps.H || 0, resMaps.m || 0, resMaps.s || 0, resMaps.S || 0);
|
|
}
|
|
module.exports = helperGetUTCDateTime;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperGetDateTime.js
|
|
var require_helperGetDateTime = __commonJS({
|
|
"node_modules/xe-utils/helperGetDateTime.js"(exports, module) {
|
|
function helperGetDateTime(date) {
|
|
return date.getTime();
|
|
}
|
|
module.exports = helperGetDateTime;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toStringDate.js
|
|
var require_toStringDate = __commonJS({
|
|
"node_modules/xe-utils/toStringDate.js"(exports, module) {
|
|
var staticParseInt = require_staticParseInt();
|
|
var helperGetUTCDateTime = require_helperGetUTCDateTime();
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var isString = require_isString();
|
|
var isDate = require_isDate();
|
|
function getParseRule(txt) {
|
|
return "(\\d{" + txt + "})";
|
|
}
|
|
function toParseMs(num) {
|
|
if (num < 10) {
|
|
return num * 100;
|
|
} else if (num < 100) {
|
|
return num * 10;
|
|
}
|
|
return num;
|
|
}
|
|
function toParseNum(num) {
|
|
return isNaN(num) ? num : staticParseInt(num);
|
|
}
|
|
var d2 = getParseRule(2);
|
|
var d1or2 = getParseRule("1,2");
|
|
var d1or7 = getParseRule("1,7");
|
|
var d3or4 = getParseRule("3,4");
|
|
var place = ".{1}";
|
|
var d1Or2RE = place + d1or2;
|
|
var dzZ = "(([zZ])|([-+]\\d{2}:?\\d{2}))";
|
|
var defaulParseStrs = [d3or4, d1Or2RE, d1Or2RE, d1Or2RE, d1Or2RE, d1Or2RE, place + d1or7, dzZ];
|
|
var defaulParseREs = [];
|
|
for (len = defaulParseStrs.length - 1; len >= 0; len--) {
|
|
rule = "";
|
|
for (i = 0; i < len + 1; i++) {
|
|
rule += defaulParseStrs[i];
|
|
}
|
|
defaulParseREs.push(new RegExp("^" + rule + "$"));
|
|
}
|
|
var rule;
|
|
var i;
|
|
var len;
|
|
function parseDefaultRules(str) {
|
|
var matchRest, resMaps = {};
|
|
for (var i2 = 0, dfrLen = defaulParseREs.length; i2 < dfrLen; i2++) {
|
|
matchRest = str.match(defaulParseREs[i2]);
|
|
if (matchRest) {
|
|
resMaps.y = matchRest[1];
|
|
resMaps.M = matchRest[2];
|
|
resMaps.d = matchRest[3];
|
|
resMaps.H = matchRest[4];
|
|
resMaps.m = matchRest[5];
|
|
resMaps.s = matchRest[6];
|
|
resMaps.S = matchRest[7];
|
|
resMaps.Z = matchRest[8];
|
|
break;
|
|
}
|
|
}
|
|
return resMaps;
|
|
}
|
|
var customParseStrs = [
|
|
["yyyy", d3or4],
|
|
["yy", d2],
|
|
["MM", d2],
|
|
["M", d1or2],
|
|
["dd", d2],
|
|
["d", d1or2],
|
|
["HH", d2],
|
|
["H", d1or2],
|
|
["mm", d2],
|
|
["m", d1or2],
|
|
["ss", d2],
|
|
["s", d1or2],
|
|
["SSS", getParseRule(3)],
|
|
["S", d1or7],
|
|
["Z", dzZ]
|
|
];
|
|
var parseRuleMaps = {};
|
|
var parseRuleKeys = ["\\[([^\\]]+)\\]"];
|
|
for (i = 0; i < customParseStrs.length; i++) {
|
|
itemRule = customParseStrs[i];
|
|
parseRuleMaps[itemRule[0]] = itemRule[1] + "?";
|
|
parseRuleKeys.push(itemRule[0]);
|
|
}
|
|
var itemRule;
|
|
var i;
|
|
var customParseRes = new RegExp(parseRuleKeys.join("|"), "g");
|
|
var cacheFormatMaps = {};
|
|
function parseCustomRules(str, format) {
|
|
var cacheItem = cacheFormatMaps[format];
|
|
if (!cacheItem) {
|
|
var posIndexs = [];
|
|
var re = format.replace(/([$(){}*+.?\\^|])/g, "\\$1").replace(customParseRes, function(text, val) {
|
|
var firstChar = text.charAt(0);
|
|
if (firstChar === "[") {
|
|
return val;
|
|
}
|
|
posIndexs.push(firstChar);
|
|
return parseRuleMaps[text];
|
|
});
|
|
cacheItem = cacheFormatMaps[format] = {
|
|
_i: posIndexs,
|
|
_r: new RegExp(re)
|
|
};
|
|
}
|
|
var resMaps = {};
|
|
var matchRest = str.match(cacheItem._r);
|
|
if (matchRest) {
|
|
var _i = cacheItem._i;
|
|
for (var i2 = 1, len2 = matchRest.length; i2 < len2; i2++) {
|
|
resMaps[_i[i2 - 1]] = matchRest[i2];
|
|
}
|
|
return resMaps;
|
|
}
|
|
return resMaps;
|
|
}
|
|
function parseTimeZone(resMaps) {
|
|
if (/^[zZ]/.test(resMaps.Z)) {
|
|
return new Date(helperGetUTCDateTime(resMaps));
|
|
} else {
|
|
var matchRest = resMaps.Z.match(/([-+])(\d{2}):?(\d{2})/);
|
|
if (matchRest) {
|
|
return new Date(helperGetUTCDateTime(resMaps) - (matchRest[1] === "-" ? -1 : 1) * staticParseInt(matchRest[2]) * 36e5 + staticParseInt(matchRest[3]) * 6e4);
|
|
}
|
|
}
|
|
return /* @__PURE__ */ new Date("");
|
|
}
|
|
function toStringDate(str, format) {
|
|
if (str) {
|
|
var isDType = isDate(str);
|
|
if (isDType || !format && /^[0-9]{11,15}$/.test(str)) {
|
|
return new Date(isDType ? helperGetDateTime(str) : staticParseInt(str));
|
|
}
|
|
if (isString(str)) {
|
|
var resMaps = format ? parseCustomRules(str, format) : parseDefaultRules(str);
|
|
if (resMaps.y) {
|
|
if (resMaps.M) {
|
|
resMaps.M = toParseNum(resMaps.M) - 1;
|
|
}
|
|
if (resMaps.S) {
|
|
resMaps.S = toParseMs(toParseNum(resMaps.S.substring(0, 3)));
|
|
}
|
|
if (resMaps.Z) {
|
|
return parseTimeZone(resMaps);
|
|
} else {
|
|
return new Date(resMaps.y, resMaps.M || 0, resMaps.d || 1, resMaps.H || 0, resMaps.m || 0, resMaps.s || 0, resMaps.S || 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return /* @__PURE__ */ new Date("");
|
|
}
|
|
module.exports = toStringDate;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperNewDate.js
|
|
var require_helperNewDate = __commonJS({
|
|
"node_modules/xe-utils/helperNewDate.js"(exports, module) {
|
|
function helperNewDate() {
|
|
return /* @__PURE__ */ new Date();
|
|
}
|
|
module.exports = helperNewDate;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isLeapYear.js
|
|
var require_isLeapYear = __commonJS({
|
|
"node_modules/xe-utils/isLeapYear.js"(exports, module) {
|
|
var isDate = require_isDate();
|
|
var toStringDate = require_toStringDate();
|
|
var helperNewDate = require_helperNewDate();
|
|
function isLeapYear(date) {
|
|
var year;
|
|
var currentDate = date ? toStringDate(date) : helperNewDate();
|
|
if (isDate(currentDate)) {
|
|
year = currentDate.getFullYear();
|
|
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
|
|
}
|
|
return false;
|
|
}
|
|
module.exports = isLeapYear;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/forOf.js
|
|
var require_forOf = __commonJS({
|
|
"node_modules/xe-utils/forOf.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var hasOwnProp = require_hasOwnProp();
|
|
function forOf(obj, iterate, context) {
|
|
if (obj) {
|
|
if (isArray(obj)) {
|
|
for (var index = 0, len = obj.length; index < len; index++) {
|
|
if (iterate.call(context, obj[index], index, obj) === false) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for (var key in obj) {
|
|
if (hasOwnProp(obj, key)) {
|
|
if (iterate.call(context, obj[key], key, obj) === false) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
module.exports = forOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/lastForOf.js
|
|
var require_lastForOf = __commonJS({
|
|
"node_modules/xe-utils/lastForOf.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var keys = require_hasOwnProp();
|
|
function lastForOf(obj, iterate, context) {
|
|
if (obj) {
|
|
var len, list;
|
|
if (isArray(obj)) {
|
|
for (len = obj.length - 1; len >= 0; len--) {
|
|
if (iterate.call(context, obj[len], len, obj) === false) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
list = keys(obj);
|
|
for (len = list.length - 1; len >= 0; len--) {
|
|
if (iterate.call(context, obj[list[len]], list[len], obj) === false) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
module.exports = lastForOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateIndexOf.js
|
|
var require_helperCreateIndexOf = __commonJS({
|
|
"node_modules/xe-utils/helperCreateIndexOf.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var isString = require_isString();
|
|
var hasOwnProp = require_hasOwnProp();
|
|
function helperCreateIndexOf(name, callback) {
|
|
return function(obj, val) {
|
|
if (obj) {
|
|
if (obj[name]) {
|
|
return obj[name](val);
|
|
}
|
|
if (isString(obj) || isArray(obj)) {
|
|
return callback(obj, val);
|
|
}
|
|
for (var key in obj) {
|
|
if (hasOwnProp(obj, key)) {
|
|
if (val === obj[key]) {
|
|
return key;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
}
|
|
module.exports = helperCreateIndexOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/indexOf.js
|
|
var require_indexOf = __commonJS({
|
|
"node_modules/xe-utils/indexOf.js"(exports, module) {
|
|
var helperCreateIndexOf = require_helperCreateIndexOf();
|
|
var arrayIndexOf = require_arrayIndexOf();
|
|
var indexOf = helperCreateIndexOf("indexOf", arrayIndexOf);
|
|
module.exports = indexOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/lastIndexOf.js
|
|
var require_lastIndexOf = __commonJS({
|
|
"node_modules/xe-utils/lastIndexOf.js"(exports, module) {
|
|
var helperCreateIndexOf = require_helperCreateIndexOf();
|
|
var arrayLastIndexOf = require_arrayLastIndexOf();
|
|
var lastIndexOf = helperCreateIndexOf("lastIndexOf", arrayLastIndexOf);
|
|
module.exports = lastIndexOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getSize.js
|
|
var require_getSize = __commonJS({
|
|
"node_modules/xe-utils/getSize.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var isString = require_isString();
|
|
var each = require_each();
|
|
function getSize(obj) {
|
|
var len = 0;
|
|
if (isString(obj) || isArray(obj)) {
|
|
return obj.length;
|
|
}
|
|
each(obj, function() {
|
|
len++;
|
|
});
|
|
return len;
|
|
}
|
|
module.exports = getSize;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isFinite.js
|
|
var require_isFinite = __commonJS({
|
|
"node_modules/xe-utils/isFinite.js"(exports, module) {
|
|
var isNumber = require_isNumber();
|
|
function isNumberFinite(obj) {
|
|
return isNumber(obj) && isFinite(obj);
|
|
}
|
|
module.exports = isNumberFinite;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isInteger.js
|
|
var require_isInteger = __commonJS({
|
|
"node_modules/xe-utils/isInteger.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var isNull = require_isNull();
|
|
var isInteger = function(obj) {
|
|
return !isNull(obj) && !isNaN(obj) && !isArray(obj) && obj % 1 === 0;
|
|
};
|
|
module.exports = isInteger;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isFloat.js
|
|
var require_isFloat = __commonJS({
|
|
"node_modules/xe-utils/isFloat.js"(exports, module) {
|
|
var isArray = require_isArray();
|
|
var isInteger = require_isInteger();
|
|
var isNull = require_isNull();
|
|
function isFloat(obj) {
|
|
return !isNull(obj) && !isNaN(obj) && !isArray(obj) && !isInteger(obj);
|
|
}
|
|
module.exports = isFloat;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isBoolean.js
|
|
var require_isBoolean = __commonJS({
|
|
"node_modules/xe-utils/isBoolean.js"(exports, module) {
|
|
var helperCreateInTypeof = require_helperCreateInTypeof();
|
|
var isBoolean = helperCreateInTypeof("boolean");
|
|
module.exports = isBoolean;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isRegExp.js
|
|
var require_isRegExp = __commonJS({
|
|
"node_modules/xe-utils/isRegExp.js"(exports, module) {
|
|
var helperCreateInInObjectString = require_helperCreateInInObjectString();
|
|
var isRegExp = helperCreateInInObjectString("RegExp");
|
|
module.exports = isRegExp;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isError.js
|
|
var require_isError = __commonJS({
|
|
"node_modules/xe-utils/isError.js"(exports, module) {
|
|
var helperCreateInInObjectString = require_helperCreateInInObjectString();
|
|
var isError = helperCreateInInObjectString("Error");
|
|
module.exports = isError;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isTypeError.js
|
|
var require_isTypeError = __commonJS({
|
|
"node_modules/xe-utils/isTypeError.js"(exports, module) {
|
|
function isTypeError(obj) {
|
|
return obj ? obj.constructor === TypeError : false;
|
|
}
|
|
module.exports = isTypeError;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isEmpty.js
|
|
var require_isEmpty = __commonJS({
|
|
"node_modules/xe-utils/isEmpty.js"(exports, module) {
|
|
function isEmpty(obj) {
|
|
for (var key in obj) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
module.exports = isEmpty;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isSymbol.js
|
|
var require_isSymbol = __commonJS({
|
|
"node_modules/xe-utils/isSymbol.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var supportSymbol = typeof Symbol !== staticStrUndefined;
|
|
function isSymbol(obj) {
|
|
return supportSymbol && Symbol.isSymbol ? Symbol.isSymbol(obj) : typeof obj === "symbol";
|
|
}
|
|
module.exports = isSymbol;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isArguments.js
|
|
var require_isArguments = __commonJS({
|
|
"node_modules/xe-utils/isArguments.js"(exports, module) {
|
|
var helperCreateInInObjectString = require_helperCreateInInObjectString();
|
|
var isArguments = helperCreateInInObjectString("Arguments");
|
|
module.exports = isArguments;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isElement.js
|
|
var require_isElement = __commonJS({
|
|
"node_modules/xe-utils/isElement.js"(exports, module) {
|
|
var isString = require_isString();
|
|
var isNumber = require_isNumber();
|
|
function isElement(obj) {
|
|
return !!(obj && isString(obj.nodeName) && isNumber(obj.nodeType));
|
|
}
|
|
module.exports = isElement;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticDocument.js
|
|
var require_staticDocument = __commonJS({
|
|
"node_modules/xe-utils/staticDocument.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var staticDocument = typeof document === staticStrUndefined ? 0 : document;
|
|
module.exports = staticDocument;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isDocument.js
|
|
var require_isDocument = __commonJS({
|
|
"node_modules/xe-utils/isDocument.js"(exports, module) {
|
|
var staticDocument = require_staticDocument();
|
|
function isDocument(obj) {
|
|
return !!(obj && staticDocument && obj.nodeType === 9);
|
|
}
|
|
module.exports = isDocument;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticWindow.js
|
|
var require_staticWindow = __commonJS({
|
|
"node_modules/xe-utils/staticWindow.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var staticWindow = typeof window === staticStrUndefined ? 0 : window;
|
|
module.exports = staticWindow;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isWindow.js
|
|
var require_isWindow = __commonJS({
|
|
"node_modules/xe-utils/isWindow.js"(exports, module) {
|
|
var staticWindow = require_staticWindow();
|
|
function isWindow(obj) {
|
|
return !!(staticWindow && !!(obj && obj === obj.window));
|
|
}
|
|
module.exports = isWindow;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isFormData.js
|
|
var require_isFormData = __commonJS({
|
|
"node_modules/xe-utils/isFormData.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var supportFormData = typeof FormData !== staticStrUndefined;
|
|
function isFormData(obj) {
|
|
return supportFormData && obj instanceof FormData;
|
|
}
|
|
module.exports = isFormData;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isMap.js
|
|
var require_isMap = __commonJS({
|
|
"node_modules/xe-utils/isMap.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var supportMap = typeof Map !== staticStrUndefined;
|
|
function isMap(obj) {
|
|
return supportMap && obj instanceof Map;
|
|
}
|
|
module.exports = isMap;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isWeakMap.js
|
|
var require_isWeakMap = __commonJS({
|
|
"node_modules/xe-utils/isWeakMap.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var supportWeakMap = typeof WeakMap !== staticStrUndefined;
|
|
function isWeakMap(obj) {
|
|
return supportWeakMap && obj instanceof WeakMap;
|
|
}
|
|
module.exports = isWeakMap;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isSet.js
|
|
var require_isSet = __commonJS({
|
|
"node_modules/xe-utils/isSet.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var supportSet = typeof Set !== staticStrUndefined;
|
|
function isSet(obj) {
|
|
return supportSet && obj instanceof Set;
|
|
}
|
|
module.exports = isSet;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isWeakSet.js
|
|
var require_isWeakSet = __commonJS({
|
|
"node_modules/xe-utils/isWeakSet.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var supportWeakSet = typeof WeakSet !== staticStrUndefined;
|
|
function isWeakSet(obj) {
|
|
return supportWeakSet && obj instanceof WeakSet;
|
|
}
|
|
module.exports = isWeakSet;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateiterateIndexOf.js
|
|
var require_helperCreateiterateIndexOf = __commonJS({
|
|
"node_modules/xe-utils/helperCreateiterateIndexOf.js"(exports, module) {
|
|
var isFunction = require_isFunction();
|
|
var isString = require_isString();
|
|
var isArray = require_isArray();
|
|
var hasOwnProp = require_hasOwnProp();
|
|
function helperCreateiterateIndexOf(callback) {
|
|
return function(obj, iterate, context) {
|
|
if (obj && isFunction(iterate)) {
|
|
if (isArray(obj) || isString(obj)) {
|
|
return callback(obj, iterate, context);
|
|
}
|
|
for (var key in obj) {
|
|
if (hasOwnProp(obj, key)) {
|
|
if (iterate.call(context, obj[key], key, obj)) {
|
|
return key;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
}
|
|
module.exports = helperCreateiterateIndexOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/findIndexOf.js
|
|
var require_findIndexOf = __commonJS({
|
|
"node_modules/xe-utils/findIndexOf.js"(exports, module) {
|
|
var helperCreateiterateIndexOf = require_helperCreateiterateIndexOf();
|
|
var findIndexOf = helperCreateiterateIndexOf(function(obj, iterate, context) {
|
|
for (var index = 0, len = obj.length; index < len; index++) {
|
|
if (iterate.call(context, obj[index], index, obj)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
});
|
|
module.exports = findIndexOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperEqualCompare.js
|
|
var require_helperEqualCompare = __commonJS({
|
|
"node_modules/xe-utils/helperEqualCompare.js"(exports, module) {
|
|
var isNumber = require_isNumber();
|
|
var isArray = require_isArray();
|
|
var isString = require_isString();
|
|
var isRegExp = require_isRegExp();
|
|
var isDate = require_isDate();
|
|
var isBoolean = require_isBoolean();
|
|
var isUndefined = require_isUndefined();
|
|
var keys = require_keys();
|
|
var every = require_every();
|
|
function helperEqualCompare(val1, val2, compare, func, key, obj1, obj2) {
|
|
if (val1 === val2) {
|
|
return true;
|
|
}
|
|
if (val1 && val2 && !isNumber(val1) && !isNumber(val2) && !isString(val1) && !isString(val2)) {
|
|
if (isRegExp(val1)) {
|
|
return compare("" + val1, "" + val2, key, obj1, obj2);
|
|
}
|
|
if (isDate(val1) || isBoolean(val1)) {
|
|
return compare(+val1, +val2, key, obj1, obj2);
|
|
} else {
|
|
var result, val1Keys, val2Keys;
|
|
var isObj1Arr = isArray(val1);
|
|
var isObj2Arr = isArray(val2);
|
|
if (isObj1Arr || isObj2Arr ? isObj1Arr && isObj2Arr : val1.constructor === val2.constructor) {
|
|
val1Keys = keys(val1);
|
|
val2Keys = keys(val2);
|
|
if (func) {
|
|
result = func(val1, val2, key);
|
|
}
|
|
if (val1Keys.length === val2Keys.length) {
|
|
return isUndefined(result) ? every(val1Keys, function(key2, index) {
|
|
return key2 === val2Keys[index] && helperEqualCompare(val1[key2], val2[val2Keys[index]], compare, func, isObj1Arr || isObj2Arr ? index : key2, val1, val2);
|
|
}) : !!result;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return compare(val1, val2, key, obj1, obj2);
|
|
}
|
|
module.exports = helperEqualCompare;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperDefaultCompare.js
|
|
var require_helperDefaultCompare = __commonJS({
|
|
"node_modules/xe-utils/helperDefaultCompare.js"(exports, module) {
|
|
function helperDefaultCompare(v1, v2) {
|
|
return v1 === v2;
|
|
}
|
|
module.exports = helperDefaultCompare;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isEqual.js
|
|
var require_isEqual = __commonJS({
|
|
"node_modules/xe-utils/isEqual.js"(exports, module) {
|
|
var helperEqualCompare = require_helperEqualCompare();
|
|
var helperDefaultCompare = require_helperDefaultCompare();
|
|
function isEqual(obj1, obj2) {
|
|
return helperEqualCompare(obj1, obj2, helperDefaultCompare);
|
|
}
|
|
module.exports = isEqual;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isMatch.js
|
|
var require_isMatch = __commonJS({
|
|
"node_modules/xe-utils/isMatch.js"(exports, module) {
|
|
var keys = require_keys();
|
|
var findIndexOf = require_findIndexOf();
|
|
var isEqual = require_isEqual();
|
|
var some = require_some();
|
|
var includeArrays = require_includeArrays();
|
|
function isMatch(obj, source) {
|
|
var objKeys = keys(obj);
|
|
var sourceKeys = keys(source);
|
|
if (sourceKeys.length) {
|
|
if (includeArrays(objKeys, sourceKeys)) {
|
|
return some(sourceKeys, function(key2) {
|
|
return findIndexOf(objKeys, function(key1) {
|
|
return key1 === key2 && isEqual(obj[key1], source[key2]);
|
|
}) > -1;
|
|
});
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
return isEqual(obj, source);
|
|
}
|
|
module.exports = isMatch;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isEqualWith.js
|
|
var require_isEqualWith = __commonJS({
|
|
"node_modules/xe-utils/isEqualWith.js"(exports, module) {
|
|
var helperEqualCompare = require_helperEqualCompare();
|
|
var helperDefaultCompare = require_helperDefaultCompare();
|
|
var isFunction = require_isFunction();
|
|
var isUndefined = require_isUndefined();
|
|
function isEqualWith(obj1, obj2, func) {
|
|
if (isFunction(func)) {
|
|
return helperEqualCompare(obj1, obj2, function(v1, v2, key, obj12, obj22) {
|
|
var result = func(v1, v2, key, obj12, obj22);
|
|
return isUndefined(result) ? helperDefaultCompare(v1, v2) : !!result;
|
|
}, func);
|
|
}
|
|
return helperEqualCompare(obj1, obj2, helperDefaultCompare);
|
|
}
|
|
module.exports = isEqualWith;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getType.js
|
|
var require_getType = __commonJS({
|
|
"node_modules/xe-utils/getType.js"(exports, module) {
|
|
var isSymbol = require_isSymbol();
|
|
var isDate = require_isDate();
|
|
var isArray = require_isArray();
|
|
var isRegExp = require_isRegExp();
|
|
var isError = require_isError();
|
|
var isNull = require_isNull();
|
|
function getType(obj) {
|
|
if (isNull(obj)) {
|
|
return "null";
|
|
}
|
|
if (isSymbol(obj)) {
|
|
return "symbol";
|
|
}
|
|
if (isDate(obj)) {
|
|
return "date";
|
|
}
|
|
if (isArray(obj)) {
|
|
return "array";
|
|
}
|
|
if (isRegExp(obj)) {
|
|
return "regexp";
|
|
}
|
|
if (isError(obj)) {
|
|
return "error";
|
|
}
|
|
return typeof obj;
|
|
}
|
|
module.exports = getType;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/uniqueId.js
|
|
var require_uniqueId = __commonJS({
|
|
"node_modules/xe-utils/uniqueId.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var eqNull = require_eqNull();
|
|
function uniqueId(prefix) {
|
|
return "" + (eqNull(prefix) ? "" : prefix) + setupDefaults.keyId++;
|
|
}
|
|
module.exports = uniqueId;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/findLastIndexOf.js
|
|
var require_findLastIndexOf = __commonJS({
|
|
"node_modules/xe-utils/findLastIndexOf.js"(exports, module) {
|
|
var helperCreateiterateIndexOf = require_helperCreateiterateIndexOf();
|
|
var findLastIndexOf = helperCreateiterateIndexOf(function(obj, iterate, context) {
|
|
for (var len = obj.length - 1; len >= 0; len--) {
|
|
if (iterate.call(context, obj[len], len, obj)) {
|
|
return len;
|
|
}
|
|
}
|
|
return -1;
|
|
});
|
|
module.exports = findLastIndexOf;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toStringJSON.js
|
|
var require_toStringJSON = __commonJS({
|
|
"node_modules/xe-utils/toStringJSON.js"(exports, module) {
|
|
var isPlainObject = require_isPlainObject();
|
|
var isString = require_isString();
|
|
function toStringJSON(str) {
|
|
if (isPlainObject(str)) {
|
|
return str;
|
|
} else if (isString(str)) {
|
|
try {
|
|
return JSON.parse(str);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
module.exports = toStringJSON;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toJSONString.js
|
|
var require_toJSONString = __commonJS({
|
|
"node_modules/xe-utils/toJSONString.js"(exports, module) {
|
|
var eqNull = require_eqNull();
|
|
function toJSONString(obj) {
|
|
return eqNull(obj) ? "" : JSON.stringify(obj);
|
|
}
|
|
module.exports = toJSONString;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/entries.js
|
|
var require_entries = __commonJS({
|
|
"node_modules/xe-utils/entries.js"(exports, module) {
|
|
var helperCreateGetObjects = require_helperCreateGetObjects();
|
|
var entries = helperCreateGetObjects("entries", 2);
|
|
module.exports = entries;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreatePickOmit.js
|
|
var require_helperCreatePickOmit = __commonJS({
|
|
"node_modules/xe-utils/helperCreatePickOmit.js"(exports, module) {
|
|
var isFunction = require_isFunction();
|
|
var isArray = require_isArray();
|
|
var each = require_each();
|
|
var findIndexOf = require_findIndexOf();
|
|
function helperCreatePickOmit(case1, case2) {
|
|
return function(obj, callback) {
|
|
var item, index;
|
|
var rest = {};
|
|
var result = [];
|
|
var context = this;
|
|
var args = arguments;
|
|
var len = args.length;
|
|
if (!isFunction(callback)) {
|
|
for (index = 1; index < len; index++) {
|
|
item = args[index];
|
|
result.push.apply(result, isArray(item) ? item : [item]);
|
|
}
|
|
callback = 0;
|
|
}
|
|
each(obj, function(val, key) {
|
|
if ((callback ? callback.call(context, val, key, obj) : findIndexOf(result, function(name) {
|
|
return name === key;
|
|
}) > -1) ? case1 : case2) {
|
|
rest[key] = val;
|
|
}
|
|
});
|
|
return rest;
|
|
};
|
|
}
|
|
module.exports = helperCreatePickOmit;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/pick.js
|
|
var require_pick = __commonJS({
|
|
"node_modules/xe-utils/pick.js"(exports, module) {
|
|
var helperCreatePickOmit = require_helperCreatePickOmit();
|
|
var pick = helperCreatePickOmit(1, 0);
|
|
module.exports = pick;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/omit.js
|
|
var require_omit = __commonJS({
|
|
"node_modules/xe-utils/omit.js"(exports, module) {
|
|
var helperCreatePickOmit = require_helperCreatePickOmit();
|
|
var omit = helperCreatePickOmit(0, 1);
|
|
module.exports = omit;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/first.js
|
|
var require_first = __commonJS({
|
|
"node_modules/xe-utils/first.js"(exports, module) {
|
|
var values = require_values();
|
|
function first(obj) {
|
|
return values(obj)[0];
|
|
}
|
|
module.exports = first;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/last.js
|
|
var require_last = __commonJS({
|
|
"node_modules/xe-utils/last.js"(exports, module) {
|
|
var values = require_values();
|
|
function last(obj) {
|
|
var list = values(obj);
|
|
return list[list.length - 1];
|
|
}
|
|
module.exports = last;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/has.js
|
|
var require_has = __commonJS({
|
|
"node_modules/xe-utils/has.js"(exports, module) {
|
|
var staticHGKeyRE = require_staticHGKeyRE();
|
|
var helperGetHGSKeys = require_helperGetHGSKeys();
|
|
var hasOwnProp = require_hasOwnProp();
|
|
function has(obj, property) {
|
|
if (obj) {
|
|
if (hasOwnProp(obj, property)) {
|
|
return true;
|
|
} else {
|
|
var prop, arrIndex, objProp, matchs, rest, isHas;
|
|
var props = helperGetHGSKeys(property);
|
|
var index = 0;
|
|
var len = props.length;
|
|
for (rest = obj; index < len; index++) {
|
|
isHas = false;
|
|
prop = props[index];
|
|
matchs = prop ? prop.match(staticHGKeyRE) : "";
|
|
if (matchs) {
|
|
arrIndex = matchs[1];
|
|
objProp = matchs[2];
|
|
if (arrIndex) {
|
|
if (rest[arrIndex]) {
|
|
if (hasOwnProp(rest[arrIndex], objProp)) {
|
|
isHas = true;
|
|
rest = rest[arrIndex][objProp];
|
|
}
|
|
}
|
|
} else {
|
|
if (hasOwnProp(rest, objProp)) {
|
|
isHas = true;
|
|
rest = rest[objProp];
|
|
}
|
|
}
|
|
} else {
|
|
if (hasOwnProp(rest, prop)) {
|
|
isHas = true;
|
|
rest = rest[prop];
|
|
}
|
|
}
|
|
if (isHas) {
|
|
if (index === len - 1) {
|
|
return true;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
module.exports = has;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/set.js
|
|
var require_set = __commonJS({
|
|
"node_modules/xe-utils/set.js"(exports, module) {
|
|
var staticParseInt = require_staticParseInt();
|
|
var helperGetHGSKeys = require_helperGetHGSKeys();
|
|
var helperCheckCopyKey = require_helperCheckCopyKey();
|
|
var hasOwnProp = require_hasOwnProp();
|
|
var sKeyRE = /(.+)?\[(\d+)\]$/;
|
|
function setDeepProps(obj, key, isEnd, nextKey, value) {
|
|
if (obj[key]) {
|
|
if (isEnd) {
|
|
obj[key] = value;
|
|
}
|
|
} else {
|
|
var index;
|
|
var rest;
|
|
var currMatchs = key ? key.match(sKeyRE) : null;
|
|
if (isEnd) {
|
|
rest = value;
|
|
} else {
|
|
var nextMatchs = nextKey ? nextKey.match(sKeyRE) : null;
|
|
if (nextMatchs && !nextMatchs[1]) {
|
|
rest = new Array(staticParseInt(nextMatchs[2]) + 1);
|
|
} else {
|
|
rest = {};
|
|
}
|
|
}
|
|
if (currMatchs) {
|
|
if (currMatchs[1]) {
|
|
index = staticParseInt(currMatchs[2]);
|
|
if (obj[currMatchs[1]]) {
|
|
if (isEnd) {
|
|
obj[currMatchs[1]][index] = rest;
|
|
} else {
|
|
if (obj[currMatchs[1]][index]) {
|
|
rest = obj[currMatchs[1]][index];
|
|
} else {
|
|
obj[currMatchs[1]][index] = rest;
|
|
}
|
|
}
|
|
} else {
|
|
obj[currMatchs[1]] = new Array(index + 1);
|
|
obj[currMatchs[1]][index] = rest;
|
|
}
|
|
} else {
|
|
obj[currMatchs[2]] = rest;
|
|
}
|
|
} else {
|
|
obj[key] = rest;
|
|
}
|
|
return rest;
|
|
}
|
|
return obj[key];
|
|
}
|
|
function set(obj, property, value) {
|
|
if (obj && helperCheckCopyKey(property)) {
|
|
if ((obj[property] || hasOwnProp(obj, property)) && !isPrototypePolluted(property)) {
|
|
obj[property] = value;
|
|
} else {
|
|
var rest = obj;
|
|
var props = helperGetHGSKeys(property);
|
|
var len = props.length;
|
|
for (var index = 0; index < len; index++) {
|
|
if (isPrototypePolluted(props[index])) {
|
|
continue;
|
|
}
|
|
var isEnd = index === len - 1;
|
|
rest = setDeepProps(rest, props[index], isEnd, isEnd ? null : props[index + 1], value);
|
|
}
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
function isPrototypePolluted(key) {
|
|
return key === "__proto__" || key === "constructor" || key === "prototype";
|
|
}
|
|
module.exports = set;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/groupBy.js
|
|
var require_groupBy = __commonJS({
|
|
"node_modules/xe-utils/groupBy.js"(exports, module) {
|
|
var isEmpty = require_isEmpty();
|
|
var isObject = require_isObject();
|
|
var isFunction = require_isFunction();
|
|
var property = require_property();
|
|
var each = require_each();
|
|
function createiterateEmpty(iterate) {
|
|
return function() {
|
|
return isEmpty(iterate);
|
|
};
|
|
}
|
|
function groupBy(obj, iterate, context) {
|
|
var groupKey;
|
|
var result = {};
|
|
if (obj) {
|
|
if (iterate && isObject(iterate)) {
|
|
iterate = createiterateEmpty(iterate);
|
|
} else if (!isFunction(iterate)) {
|
|
iterate = property(iterate);
|
|
}
|
|
each(obj, function(val, key) {
|
|
groupKey = iterate ? iterate.call(context, val, key, obj) : val;
|
|
if (result[groupKey]) {
|
|
result[groupKey].push(val);
|
|
} else {
|
|
result[groupKey] = [val];
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
module.exports = groupBy;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/countBy.js
|
|
var require_countBy = __commonJS({
|
|
"node_modules/xe-utils/countBy.js"(exports, module) {
|
|
var groupBy = require_groupBy();
|
|
var objectEach = require_objectEach();
|
|
function countBy(obj, iterate, context) {
|
|
var result = groupBy(obj, iterate, context || this);
|
|
objectEach(result, function(item, key) {
|
|
result[key] = item.length;
|
|
});
|
|
return result;
|
|
}
|
|
module.exports = countBy;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/range.js
|
|
var require_range = __commonJS({
|
|
"node_modules/xe-utils/range.js"(exports, module) {
|
|
function range(start, stop, step) {
|
|
var index, len;
|
|
var result = [];
|
|
var args = arguments;
|
|
if (args.length < 2) {
|
|
stop = args[0];
|
|
start = 0;
|
|
}
|
|
index = start >> 0;
|
|
len = stop >> 0;
|
|
if (index < stop) {
|
|
step = step >> 0 || 1;
|
|
for (; index < len; index += step) {
|
|
result.push(index);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
module.exports = range;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/destructuring.js
|
|
var require_destructuring = __commonJS({
|
|
"node_modules/xe-utils/destructuring.js"(exports, module) {
|
|
var keys = require_keys();
|
|
var slice = require_slice();
|
|
var includes = require_includes();
|
|
var arrayEach = require_arrayEach();
|
|
var assign = require_assign();
|
|
function destructuring(destination, sources) {
|
|
if (destination && sources) {
|
|
var rest = assign.apply(this, [{}].concat(slice(arguments, 1)));
|
|
var restKeys = keys(rest);
|
|
arrayEach(keys(destination), function(key) {
|
|
if (includes(restKeys, key)) {
|
|
destination[key] = rest[key];
|
|
}
|
|
});
|
|
}
|
|
return destination;
|
|
}
|
|
module.exports = destructuring;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/min.js
|
|
var require_min = __commonJS({
|
|
"node_modules/xe-utils/min.js"(exports, module) {
|
|
var helperCreateMinMax = require_helperCreateMinMax();
|
|
var min = helperCreateMinMax(function(rest, itemVal) {
|
|
return rest > itemVal;
|
|
});
|
|
module.exports = min;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperNumberDecimal.js
|
|
var require_helperNumberDecimal = __commonJS({
|
|
"node_modules/xe-utils/helperNumberDecimal.js"(exports, module) {
|
|
function helperNumberDecimal(numStr) {
|
|
return (numStr.split(".")[1] || "").length;
|
|
}
|
|
module.exports = helperNumberDecimal;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperStringRepeat.js
|
|
var require_helperStringRepeat = __commonJS({
|
|
"node_modules/xe-utils/helperStringRepeat.js"(exports, module) {
|
|
var staticParseInt = require_staticParseInt();
|
|
function helperStringRepeat(str, count) {
|
|
if (str.repeat) {
|
|
return str.repeat(count);
|
|
}
|
|
var list = isNaN(count) ? [] : new Array(staticParseInt(count));
|
|
return list.join(str) + (list.length > 0 ? str : "");
|
|
}
|
|
module.exports = helperStringRepeat;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperNumberOffsetPoint.js
|
|
var require_helperNumberOffsetPoint = __commonJS({
|
|
"node_modules/xe-utils/helperNumberOffsetPoint.js"(exports, module) {
|
|
function helperNumberOffsetPoint(str, offsetIndex) {
|
|
return str.substring(0, offsetIndex) + "." + str.substring(offsetIndex, str.length);
|
|
}
|
|
module.exports = helperNumberOffsetPoint;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toNumberString.js
|
|
var require_toNumberString = __commonJS({
|
|
"node_modules/xe-utils/toNumberString.js"(exports, module) {
|
|
var helperStringRepeat = require_helperStringRepeat();
|
|
var helperNumberOffsetPoint = require_helperNumberOffsetPoint();
|
|
function toNumberString(num) {
|
|
var rest = "" + num;
|
|
var scienceMatchs = rest.match(/^([-+]?)((\d+)|((\d+)?[.](\d+)?))e([-+]{1})([0-9]+)$/);
|
|
if (scienceMatchs) {
|
|
var isNegative = num < 0;
|
|
var absFlag = isNegative ? "-" : "";
|
|
var intNumStr = scienceMatchs[3] || "";
|
|
var dIntNumStr = scienceMatchs[5] || "";
|
|
var dFloatNumStr = scienceMatchs[6] || "";
|
|
var sciencFlag = scienceMatchs[7];
|
|
var scienceNumStr = scienceMatchs[8];
|
|
var floatOffsetIndex = scienceNumStr - dFloatNumStr.length;
|
|
var intOffsetIndex = scienceNumStr - intNumStr.length;
|
|
var dIntOffsetIndex = scienceNumStr - dIntNumStr.length;
|
|
if (sciencFlag === "+") {
|
|
if (intNumStr) {
|
|
return absFlag + intNumStr + helperStringRepeat("0", scienceNumStr);
|
|
}
|
|
if (floatOffsetIndex > 0) {
|
|
return absFlag + dIntNumStr + dFloatNumStr + helperStringRepeat("0", floatOffsetIndex);
|
|
}
|
|
return absFlag + dIntNumStr + helperNumberOffsetPoint(dFloatNumStr, scienceNumStr);
|
|
}
|
|
if (intNumStr) {
|
|
if (intOffsetIndex > 0) {
|
|
return absFlag + "0." + helperStringRepeat("0", Math.abs(intOffsetIndex)) + intNumStr;
|
|
}
|
|
return absFlag + helperNumberOffsetPoint(intNumStr, intOffsetIndex);
|
|
}
|
|
if (dIntOffsetIndex > 0) {
|
|
return absFlag + "0." + helperStringRepeat("0", Math.abs(dIntOffsetIndex)) + dIntNumStr + dFloatNumStr;
|
|
}
|
|
return absFlag + helperNumberOffsetPoint(dIntNumStr, dIntOffsetIndex) + dFloatNumStr;
|
|
}
|
|
return rest;
|
|
}
|
|
module.exports = toNumberString;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperMultiply.js
|
|
var require_helperMultiply = __commonJS({
|
|
"node_modules/xe-utils/helperMultiply.js"(exports, module) {
|
|
var helperNumberDecimal = require_helperNumberDecimal();
|
|
var toNumberString = require_toNumberString();
|
|
function helperMultiply(multiplier, multiplicand) {
|
|
var str1 = toNumberString(multiplier);
|
|
var str2 = toNumberString(multiplicand);
|
|
return parseInt(str1.replace(".", "")) * parseInt(str2.replace(".", "")) / Math.pow(10, helperNumberDecimal(str1) + helperNumberDecimal(str2));
|
|
}
|
|
module.exports = helperMultiply;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateMathNumber.js
|
|
var require_helperCreateMathNumber = __commonJS({
|
|
"node_modules/xe-utils/helperCreateMathNumber.js"(exports, module) {
|
|
var helperMultiply = require_helperMultiply();
|
|
var toNumber = require_toNumber();
|
|
var toNumberString = require_toNumberString();
|
|
function helperCreateMathNumber(name) {
|
|
return function(num, digits) {
|
|
var numRest = toNumber(num);
|
|
var rest = numRest;
|
|
if (numRest) {
|
|
digits = digits >> 0;
|
|
var numStr = toNumberString(numRest);
|
|
var nums = numStr.split(".");
|
|
var intStr = nums[0];
|
|
var floatStr = nums[1] || "";
|
|
var fStr = floatStr.substring(0, digits + 1);
|
|
var subRest = intStr + (fStr ? "." + fStr : "");
|
|
if (digits >= floatStr.length) {
|
|
return toNumber(subRest);
|
|
}
|
|
subRest = numRest;
|
|
if (digits > 0) {
|
|
var ratio = Math.pow(10, digits);
|
|
rest = Math[name](helperMultiply(subRest, ratio)) / ratio;
|
|
} else {
|
|
rest = Math[name](subRest);
|
|
}
|
|
}
|
|
return rest;
|
|
};
|
|
}
|
|
module.exports = helperCreateMathNumber;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/round.js
|
|
var require_round = __commonJS({
|
|
"node_modules/xe-utils/round.js"(exports, module) {
|
|
var helperCreateMathNumber = require_helperCreateMathNumber();
|
|
var round = helperCreateMathNumber("round");
|
|
module.exports = round;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/ceil.js
|
|
var require_ceil = __commonJS({
|
|
"node_modules/xe-utils/ceil.js"(exports, module) {
|
|
var helperCreateMathNumber = require_helperCreateMathNumber();
|
|
var ceil = helperCreateMathNumber("ceil");
|
|
module.exports = ceil;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/floor.js
|
|
var require_floor = __commonJS({
|
|
"node_modules/xe-utils/floor.js"(exports, module) {
|
|
var helperCreateMathNumber = require_helperCreateMathNumber();
|
|
var floor = helperCreateMathNumber("floor");
|
|
module.exports = floor;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toValueString.js
|
|
var require_toValueString = __commonJS({
|
|
"node_modules/xe-utils/toValueString.js"(exports, module) {
|
|
var eqNull = require_eqNull();
|
|
var isNumber = require_isNumber();
|
|
var toNumberString = require_toNumberString();
|
|
function toValueString(obj) {
|
|
if (isNumber(obj)) {
|
|
return toNumberString(obj);
|
|
}
|
|
return "" + (eqNull(obj) ? "" : obj);
|
|
}
|
|
module.exports = toValueString;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toFixed.js
|
|
var require_toFixed = __commonJS({
|
|
"node_modules/xe-utils/toFixed.js"(exports, module) {
|
|
var round = require_round();
|
|
var toValueString = require_toValueString();
|
|
var helperStringRepeat = require_helperStringRepeat();
|
|
var helperNumberOffsetPoint = require_helperNumberOffsetPoint();
|
|
function toFixed(num, digits) {
|
|
digits = digits >> 0;
|
|
var str = toValueString(round(num, digits));
|
|
var nums = str.split(".");
|
|
var intStr = nums[0];
|
|
var floatStr = nums[1] || "";
|
|
var digitOffsetIndex = digits - floatStr.length;
|
|
if (digits) {
|
|
if (digitOffsetIndex > 0) {
|
|
return intStr + "." + floatStr + helperStringRepeat("0", digitOffsetIndex);
|
|
}
|
|
return intStr + helperNumberOffsetPoint(floatStr, Math.abs(digitOffsetIndex));
|
|
}
|
|
return intStr;
|
|
}
|
|
module.exports = toFixed;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/commafy.js
|
|
var require_commafy = __commonJS({
|
|
"node_modules/xe-utils/commafy.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var round = require_round();
|
|
var ceil = require_ceil();
|
|
var floor = require_floor();
|
|
var isNumber = require_isNumber();
|
|
var toValueString = require_toValueString();
|
|
var toFixed = require_toFixed();
|
|
var toNumberString = require_toNumberString();
|
|
var assign = require_assign();
|
|
function commafy(num, options) {
|
|
var opts = assign({}, setupDefaults.commafyOptions, options);
|
|
var optDigits = opts.digits;
|
|
var isNum = isNumber(num);
|
|
var rest, result, isNegative, intStr, floatStr;
|
|
if (isNum) {
|
|
rest = (opts.ceil ? ceil : opts.floor ? floor : round)(num, optDigits);
|
|
result = toNumberString(optDigits ? toFixed(rest, optDigits) : rest).split(".");
|
|
intStr = result[0];
|
|
floatStr = result[1];
|
|
isNegative = intStr && rest < 0;
|
|
if (isNegative) {
|
|
intStr = intStr.substring(1, intStr.length);
|
|
}
|
|
} else {
|
|
rest = toValueString(num).replace(/,/g, "");
|
|
result = rest ? [rest] : [];
|
|
intStr = result[0];
|
|
}
|
|
if (result.length) {
|
|
return (isNegative ? "-" : "") + intStr.replace(new RegExp("(?=(?!(\\b))(.{" + (opts.spaceNumber || 3) + "})+$)", "g"), opts.separator || ",") + (floatStr ? "." + floatStr : "");
|
|
}
|
|
return rest;
|
|
}
|
|
module.exports = commafy;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toInteger.js
|
|
var require_toInteger = __commonJS({
|
|
"node_modules/xe-utils/toInteger.js"(exports, module) {
|
|
var staticParseInt = require_staticParseInt();
|
|
var helperCreateToNumber = require_helperCreateToNumber();
|
|
var toInteger = helperCreateToNumber(staticParseInt);
|
|
module.exports = toInteger;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/multiply.js
|
|
var require_multiply = __commonJS({
|
|
"node_modules/xe-utils/multiply.js"(exports, module) {
|
|
var helperMultiply = require_helperMultiply();
|
|
var toNumber = require_toNumber();
|
|
function multiply(num1, num2) {
|
|
var multiplier = toNumber(num1);
|
|
var multiplicand = toNumber(num2);
|
|
return helperMultiply(multiplier, multiplicand);
|
|
}
|
|
module.exports = multiply;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperNumberAdd.js
|
|
var require_helperNumberAdd = __commonJS({
|
|
"node_modules/xe-utils/helperNumberAdd.js"(exports, module) {
|
|
var helperNumberDecimal = require_helperNumberDecimal();
|
|
var toNumberString = require_toNumberString();
|
|
var multiply = require_multiply();
|
|
function helperNumberAdd(addend, augend) {
|
|
var str1 = toNumberString(addend);
|
|
var str2 = toNumberString(augend);
|
|
var ratio = Math.pow(10, Math.max(helperNumberDecimal(str1), helperNumberDecimal(str2)));
|
|
return (multiply(addend, ratio) + multiply(augend, ratio)) / ratio;
|
|
}
|
|
module.exports = helperNumberAdd;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/add.js
|
|
var require_add = __commonJS({
|
|
"node_modules/xe-utils/add.js"(exports, module) {
|
|
var helperNumberAdd = require_helperNumberAdd();
|
|
var toNumber = require_toNumber();
|
|
function add(num1, num2) {
|
|
return helperNumberAdd(toNumber(num1), toNumber(num2));
|
|
}
|
|
module.exports = add;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/subtract.js
|
|
var require_subtract = __commonJS({
|
|
"node_modules/xe-utils/subtract.js"(exports, module) {
|
|
var helperNumberDecimal = require_helperNumberDecimal();
|
|
var toNumberString = require_toNumberString();
|
|
var toNumber = require_toNumber();
|
|
var toFixed = require_toFixed();
|
|
function subtract(num1, num2) {
|
|
var subtrahend = toNumber(num1);
|
|
var minuend = toNumber(num2);
|
|
var str1 = toNumberString(subtrahend);
|
|
var str2 = toNumberString(minuend);
|
|
var digit1 = helperNumberDecimal(str1);
|
|
var digit2 = helperNumberDecimal(str2);
|
|
var ratio = Math.pow(10, Math.max(digit1, digit2));
|
|
var precision = digit1 >= digit2 ? digit1 : digit2;
|
|
return parseFloat(toFixed((subtrahend * ratio - minuend * ratio) / ratio, precision));
|
|
}
|
|
module.exports = subtract;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperNumberDivide.js
|
|
var require_helperNumberDivide = __commonJS({
|
|
"node_modules/xe-utils/helperNumberDivide.js"(exports, module) {
|
|
var helperNumberDecimal = require_helperNumberDecimal();
|
|
var toNumberString = require_toNumberString();
|
|
var multiply = require_multiply();
|
|
function helperNumberDivide(divisor, dividend) {
|
|
var str1 = toNumberString(divisor);
|
|
var str2 = toNumberString(dividend);
|
|
var divisorDecimal = helperNumberDecimal(str1);
|
|
var dividendDecimal = helperNumberDecimal(str2);
|
|
var powY = dividendDecimal - divisorDecimal;
|
|
var isMinus = powY < 0;
|
|
var multiplicand = Math.pow(10, isMinus ? Math.abs(powY) : powY);
|
|
return multiply(str1.replace(".", "") / str2.replace(".", ""), isMinus ? 1 / multiplicand : multiplicand);
|
|
}
|
|
module.exports = helperNumberDivide;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/divide.js
|
|
var require_divide = __commonJS({
|
|
"node_modules/xe-utils/divide.js"(exports, module) {
|
|
var helperNumberDivide = require_helperNumberDivide();
|
|
var toNumber = require_toNumber();
|
|
function divide(num1, num2) {
|
|
return helperNumberDivide(toNumber(num1), toNumber(num2));
|
|
}
|
|
module.exports = divide;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/sum.js
|
|
var require_sum = __commonJS({
|
|
"node_modules/xe-utils/sum.js"(exports, module) {
|
|
var helperNumberAdd = require_helperNumberAdd();
|
|
var isFunction = require_isFunction();
|
|
var isArray = require_isArray();
|
|
var each = require_each();
|
|
var get = require_get();
|
|
function sum(array, iterate, context) {
|
|
var result = 0;
|
|
each(array && array.length > 2 && isArray(array) ? array.sort() : array, iterate ? isFunction(iterate) ? function() {
|
|
result = helperNumberAdd(result, iterate.apply(context, arguments));
|
|
} : function(val) {
|
|
result = helperNumberAdd(result, get(val, iterate));
|
|
} : function(val) {
|
|
result = helperNumberAdd(result, val);
|
|
});
|
|
return result;
|
|
}
|
|
module.exports = sum;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/mean.js
|
|
var require_mean = __commonJS({
|
|
"node_modules/xe-utils/mean.js"(exports, module) {
|
|
var helperNumberDivide = require_helperNumberDivide();
|
|
var getSize = require_getSize();
|
|
var sum = require_sum();
|
|
function mean(array, iterate, context) {
|
|
return helperNumberDivide(sum(array, iterate, context), getSize(array));
|
|
}
|
|
module.exports = mean;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticStrFirst.js
|
|
var require_staticStrFirst = __commonJS({
|
|
"node_modules/xe-utils/staticStrFirst.js"(exports, module) {
|
|
var staticStrFirst = "first";
|
|
module.exports = staticStrFirst;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticStrLast.js
|
|
var require_staticStrLast = __commonJS({
|
|
"node_modules/xe-utils/staticStrLast.js"(exports, module) {
|
|
var staticStrLast = "last";
|
|
module.exports = staticStrLast;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperGetDateFullYear.js
|
|
var require_helperGetDateFullYear = __commonJS({
|
|
"node_modules/xe-utils/helperGetDateFullYear.js"(exports, module) {
|
|
function helperGetDateFullYear(date) {
|
|
return date.getFullYear();
|
|
}
|
|
module.exports = helperGetDateFullYear;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticDayTime.js
|
|
var require_staticDayTime = __commonJS({
|
|
"node_modules/xe-utils/staticDayTime.js"(exports, module) {
|
|
var staticDayTime = 864e5;
|
|
module.exports = staticDayTime;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperGetDateMonth.js
|
|
var require_helperGetDateMonth = __commonJS({
|
|
"node_modules/xe-utils/helperGetDateMonth.js"(exports, module) {
|
|
function helperGetDateMonth(date) {
|
|
return date.getMonth();
|
|
}
|
|
module.exports = helperGetDateMonth;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isValidDate.js
|
|
var require_isValidDate = __commonJS({
|
|
"node_modules/xe-utils/isValidDate.js"(exports, module) {
|
|
var isDate = require_isDate();
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
function isValidDate(val) {
|
|
return isDate(val) && !isNaN(helperGetDateTime(val));
|
|
}
|
|
module.exports = isValidDate;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getWhatMonth.js
|
|
var require_getWhatMonth = __commonJS({
|
|
"node_modules/xe-utils/getWhatMonth.js"(exports, module) {
|
|
var staticStrFirst = require_staticStrFirst();
|
|
var staticStrLast = require_staticStrLast();
|
|
var staticDayTime = require_staticDayTime();
|
|
var helperGetDateFullYear = require_helperGetDateFullYear();
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var helperGetDateMonth = require_helperGetDateMonth();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
var isNumber = require_isNumber();
|
|
function getWhatMonth(date, offsetMonth, offsetDay) {
|
|
var monthNum = offsetMonth && !isNaN(offsetMonth) ? offsetMonth : 0;
|
|
date = toStringDate(date);
|
|
if (isValidDate(date)) {
|
|
if (offsetDay === staticStrFirst) {
|
|
return new Date(helperGetDateFullYear(date), helperGetDateMonth(date) + monthNum, 1);
|
|
} else if (offsetDay === staticStrLast) {
|
|
return new Date(helperGetDateTime(getWhatMonth(date, monthNum + 1, staticStrFirst)) - 1);
|
|
} else if (isNumber(offsetDay)) {
|
|
date.setDate(offsetDay);
|
|
}
|
|
if (monthNum) {
|
|
var currDate = date.getDate();
|
|
date.setMonth(helperGetDateMonth(date) + monthNum);
|
|
if (currDate !== date.getDate()) {
|
|
date.setDate(1);
|
|
return new Date(helperGetDateTime(date) - staticDayTime);
|
|
}
|
|
}
|
|
}
|
|
return date;
|
|
}
|
|
module.exports = getWhatMonth;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getWhatYear.js
|
|
var require_getWhatYear = __commonJS({
|
|
"node_modules/xe-utils/getWhatYear.js"(exports, module) {
|
|
var staticStrFirst = require_staticStrFirst();
|
|
var staticStrLast = require_staticStrLast();
|
|
var helperGetDateFullYear = require_helperGetDateFullYear();
|
|
var getWhatMonth = require_getWhatMonth();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
function getWhatYear(date, offset, month) {
|
|
var number;
|
|
date = toStringDate(date);
|
|
if (isValidDate(date)) {
|
|
if (offset) {
|
|
number = offset && !isNaN(offset) ? offset : 0;
|
|
date.setFullYear(helperGetDateFullYear(date) + number);
|
|
}
|
|
if (month || !isNaN(month)) {
|
|
if (month === staticStrFirst) {
|
|
return new Date(helperGetDateFullYear(date), 0, 1);
|
|
} else if (month === staticStrLast) {
|
|
date.setMonth(11);
|
|
return getWhatMonth(date, 0, staticStrLast);
|
|
} else {
|
|
date.setMonth(month);
|
|
}
|
|
}
|
|
}
|
|
return date;
|
|
}
|
|
module.exports = getWhatYear;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getWhatQuarter.js
|
|
var require_getWhatQuarter = __commonJS({
|
|
"node_modules/xe-utils/getWhatQuarter.js"(exports, module) {
|
|
var getWhatMonth = require_getWhatMonth();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
function getQuarterNumber(date) {
|
|
var month = date.getMonth();
|
|
if (month < 3) {
|
|
return 1;
|
|
} else if (month < 6) {
|
|
return 2;
|
|
} else if (month < 9) {
|
|
return 3;
|
|
}
|
|
return 4;
|
|
}
|
|
function getWhatQuarter(date, offset, day) {
|
|
var currMonth, monthOffset = offset && !isNaN(offset) ? offset * 3 : 0;
|
|
date = toStringDate(date);
|
|
if (isValidDate(date)) {
|
|
currMonth = (getQuarterNumber(date) - 1) * 3;
|
|
date.setMonth(currMonth);
|
|
return getWhatMonth(date, monthOffset, day);
|
|
}
|
|
return date;
|
|
}
|
|
module.exports = getWhatQuarter;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getWhatDay.js
|
|
var require_getWhatDay = __commonJS({
|
|
"node_modules/xe-utils/getWhatDay.js"(exports, module) {
|
|
var staticStrFirst = require_staticStrFirst();
|
|
var staticStrLast = require_staticStrLast();
|
|
var staticParseInt = require_staticParseInt();
|
|
var helperGetDateFullYear = require_helperGetDateFullYear();
|
|
var helperGetDateMonth = require_helperGetDateMonth();
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
function getWhatDay(date, offset, mode) {
|
|
date = toStringDate(date);
|
|
if (isValidDate(date) && !isNaN(offset)) {
|
|
date.setDate(date.getDate() + staticParseInt(offset));
|
|
if (mode === staticStrFirst) {
|
|
return new Date(helperGetDateFullYear(date), helperGetDateMonth(date), date.getDate());
|
|
} else if (mode === staticStrLast) {
|
|
return new Date(helperGetDateTime(getWhatDay(date, 1, staticStrFirst)) - 1);
|
|
}
|
|
}
|
|
return date;
|
|
}
|
|
module.exports = getWhatDay;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperStringUpperCase.js
|
|
var require_helperStringUpperCase = __commonJS({
|
|
"node_modules/xe-utils/helperStringUpperCase.js"(exports, module) {
|
|
function helperStringUpperCase(str) {
|
|
return str.toUpperCase();
|
|
}
|
|
module.exports = helperStringUpperCase;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticWeekTime.js
|
|
var require_staticWeekTime = __commonJS({
|
|
"node_modules/xe-utils/staticWeekTime.js"(exports, module) {
|
|
var staticDayTime = require_staticDayTime();
|
|
var staticWeekTime = staticDayTime * 7;
|
|
module.exports = staticWeekTime;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getWhatWeek.js
|
|
var require_getWhatWeek = __commonJS({
|
|
"node_modules/xe-utils/getWhatWeek.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var staticDayTime = require_staticDayTime();
|
|
var staticWeekTime = require_staticWeekTime();
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
var isNumber = require_isNumber();
|
|
function getWhatWeek(date, offsetWeek, offsetDay, firstDay) {
|
|
date = toStringDate(date);
|
|
if (isValidDate(date)) {
|
|
var hasCustomDay = isNumber(offsetDay);
|
|
var hasStartDay = isNumber(firstDay);
|
|
var whatDayTime = helperGetDateTime(date);
|
|
if (hasCustomDay || hasStartDay) {
|
|
var viewStartDay = hasStartDay ? firstDay : setupDefaults.firstDayOfWeek;
|
|
var currentDay = date.getDay();
|
|
var customDay = hasCustomDay ? offsetDay : currentDay;
|
|
if (currentDay !== customDay) {
|
|
var offsetNum = 0;
|
|
if (viewStartDay > currentDay) {
|
|
offsetNum = -(7 - viewStartDay + currentDay);
|
|
} else if (viewStartDay < currentDay) {
|
|
offsetNum = viewStartDay - currentDay;
|
|
}
|
|
if (customDay > viewStartDay) {
|
|
whatDayTime += ((customDay === 0 ? 7 : customDay) - viewStartDay + offsetNum) * staticDayTime;
|
|
} else if (customDay < viewStartDay) {
|
|
whatDayTime += (7 - viewStartDay + customDay + offsetNum) * staticDayTime;
|
|
} else {
|
|
whatDayTime += offsetNum * staticDayTime;
|
|
}
|
|
}
|
|
}
|
|
if (offsetWeek && !isNaN(offsetWeek)) {
|
|
whatDayTime += offsetWeek * staticWeekTime;
|
|
}
|
|
return new Date(whatDayTime);
|
|
}
|
|
return date;
|
|
}
|
|
module.exports = getWhatWeek;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperCreateGetDateWeek.js
|
|
var require_helperCreateGetDateWeek = __commonJS({
|
|
"node_modules/xe-utils/helperCreateGetDateWeek.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var staticDayTime = require_staticDayTime();
|
|
var staticWeekTime = require_staticWeekTime();
|
|
var isNumber = require_isNumber();
|
|
var includes = require_includes();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
var getWhatWeek = require_getWhatWeek();
|
|
var range = require_range();
|
|
var map = require_map();
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var nextStartMaps = map(range(0, 7), function(day) {
|
|
return [(day + 1) % 7, (day + 2) % 7, (day + 3) % 7];
|
|
});
|
|
function matchWeekStartDay(time, viewStartDay) {
|
|
var day = new Date(time).getDay();
|
|
return includes(nextStartMaps[viewStartDay], day);
|
|
}
|
|
function helperCreateGetDateWeek(getStartDate, checkCrossDate) {
|
|
return function(date, firstDay) {
|
|
var viewStartDay = isNumber(firstDay) ? firstDay : setupDefaults.firstDayOfWeek;
|
|
var targetDate = toStringDate(date);
|
|
if (isValidDate(targetDate)) {
|
|
var targetWeekStartDate = getWhatWeek(targetDate, 0, viewStartDay, viewStartDay);
|
|
var firstDate = getStartDate(targetWeekStartDate);
|
|
var firstTime = helperGetDateTime(firstDate);
|
|
var targetWeekStartTime = helperGetDateTime(targetWeekStartDate);
|
|
var targetWeekEndTime = targetWeekStartTime + staticDayTime * 6;
|
|
var targetWeekEndDate = new Date(targetWeekEndTime);
|
|
var firstWeekStartDate = getWhatWeek(firstDate, 0, viewStartDay, viewStartDay);
|
|
var firstWeekStartTime = helperGetDateTime(firstWeekStartDate);
|
|
var tempTime;
|
|
if (targetWeekStartTime === firstWeekStartTime) {
|
|
return 1;
|
|
}
|
|
if (checkCrossDate(targetWeekStartDate, targetWeekEndDate)) {
|
|
tempTime = helperGetDateTime(getStartDate(targetWeekEndDate));
|
|
for (; tempTime < targetWeekEndTime; tempTime += staticDayTime) {
|
|
if (matchWeekStartDay(tempTime, viewStartDay)) {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
var firstWeekEndTime = firstWeekStartTime + staticDayTime * 6;
|
|
var firstWeekEndDate = new Date(targetWeekEndTime);
|
|
var offsetNum = 1;
|
|
if (checkCrossDate(firstWeekStartDate, firstWeekEndDate)) {
|
|
offsetNum = 0;
|
|
tempTime = firstTime;
|
|
for (; tempTime < firstWeekEndTime; tempTime += staticDayTime) {
|
|
if (matchWeekStartDay(tempTime, viewStartDay)) {
|
|
offsetNum++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return Math.floor((targetWeekStartTime - firstWeekStartTime) / staticWeekTime) + offsetNum;
|
|
}
|
|
return NaN;
|
|
};
|
|
}
|
|
module.exports = helperCreateGetDateWeek;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getYearWeek.js
|
|
var require_getYearWeek = __commonJS({
|
|
"node_modules/xe-utils/getYearWeek.js"(exports, module) {
|
|
var helperCreateGetDateWeek = require_helperCreateGetDateWeek();
|
|
var getYearWeek = helperCreateGetDateWeek(function(targetDate) {
|
|
return new Date(targetDate.getFullYear(), 0, 1);
|
|
}, function(date1, date2) {
|
|
return date1.getFullYear() !== date2.getFullYear();
|
|
});
|
|
module.exports = getYearWeek;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperGetYMD.js
|
|
var require_helperGetYMD = __commonJS({
|
|
"node_modules/xe-utils/helperGetYMD.js"(exports, module) {
|
|
var helperGetDateFullYear = require_helperGetDateFullYear();
|
|
var helperGetDateMonth = require_helperGetDateMonth();
|
|
function helperGetYMD(date) {
|
|
return new Date(helperGetDateFullYear(date), helperGetDateMonth(date), date.getDate());
|
|
}
|
|
module.exports = helperGetYMD;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperGetYMDTime.js
|
|
var require_helperGetYMDTime = __commonJS({
|
|
"node_modules/xe-utils/helperGetYMDTime.js"(exports, module) {
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var helperGetYMD = require_helperGetYMD();
|
|
function helperGetYMDTime(date) {
|
|
return helperGetDateTime(helperGetYMD(date));
|
|
}
|
|
module.exports = helperGetYMDTime;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getYearDay.js
|
|
var require_getYearDay = __commonJS({
|
|
"node_modules/xe-utils/getYearDay.js"(exports, module) {
|
|
var staticDayTime = require_staticDayTime();
|
|
var staticStrFirst = require_staticStrFirst();
|
|
var helperGetYMDTime = require_helperGetYMDTime();
|
|
var getWhatYear = require_getWhatYear();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
function getYearDay(date) {
|
|
date = toStringDate(date);
|
|
if (isValidDate(date)) {
|
|
return Math.floor((helperGetYMDTime(date) - helperGetYMDTime(getWhatYear(date, 0, staticStrFirst))) / staticDayTime) + 1;
|
|
}
|
|
return NaN;
|
|
}
|
|
module.exports = getYearDay;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/padStart.js
|
|
var require_padStart = __commonJS({
|
|
"node_modules/xe-utils/padStart.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
var isUndefined = require_isUndefined();
|
|
var helperStringRepeat = require_helperStringRepeat();
|
|
function padStart(str, targetLength, padString) {
|
|
var rest = toValueString(str);
|
|
targetLength = targetLength >> 0;
|
|
padString = isUndefined(padString) ? " " : "" + padString;
|
|
if (rest.padStart) {
|
|
return rest.padStart(targetLength, padString);
|
|
}
|
|
if (targetLength > rest.length) {
|
|
targetLength -= rest.length;
|
|
if (targetLength > padString.length) {
|
|
padString += helperStringRepeat(padString, targetLength / padString.length);
|
|
}
|
|
return padString.slice(0, targetLength) + rest;
|
|
}
|
|
return rest;
|
|
}
|
|
module.exports = padStart;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toDateString.js
|
|
var require_toDateString = __commonJS({
|
|
"node_modules/xe-utils/toDateString.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var helperStringUpperCase = require_helperStringUpperCase();
|
|
var helperGetDateFullYear = require_helperGetDateFullYear();
|
|
var helperGetDateMonth = require_helperGetDateMonth();
|
|
var toStringDate = require_toStringDate();
|
|
var getYearWeek = require_getYearWeek();
|
|
var getYearDay = require_getYearDay();
|
|
var assign = require_assign();
|
|
var isValidDate = require_isValidDate();
|
|
var isFunction = require_isFunction();
|
|
var padStart = require_padStart();
|
|
function handleCustomTemplate(date, formats, match, value) {
|
|
var format = formats[match];
|
|
if (format) {
|
|
if (isFunction(format)) {
|
|
return format(value, match, date);
|
|
} else {
|
|
return format[value];
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
var dateFormatRE = /\[([^\]]+)]|y{2,4}|M{1,2}|d{1,2}|H{1,2}|h{1,2}|m{1,2}|s{1,2}|S{1,3}|Z{1,2}|W{1,2}|D{1,3}|[aAeEq]/g;
|
|
function toDateString(date, format, options) {
|
|
if (date) {
|
|
date = toStringDate(date);
|
|
if (isValidDate(date)) {
|
|
var result = format || setupDefaults.parseDateFormat || setupDefaults.formatString;
|
|
var hours = date.getHours();
|
|
var apm = hours < 12 ? "am" : "pm";
|
|
var formats = assign({}, setupDefaults.parseDateRules || setupDefaults.formatStringMatchs, options ? options.formats : null);
|
|
var fy = function(match, length) {
|
|
return ("" + helperGetDateFullYear(date)).substr(4 - length);
|
|
};
|
|
var fM = function(match, length) {
|
|
return padStart(helperGetDateMonth(date) + 1, length, "0");
|
|
};
|
|
var fd = function(match, length) {
|
|
return padStart(date.getDate(), length, "0");
|
|
};
|
|
var fH = function(match, length) {
|
|
return padStart(hours, length, "0");
|
|
};
|
|
var fh = function(match, length) {
|
|
return padStart(hours <= 12 ? hours : hours - 12, length, "0");
|
|
};
|
|
var fm = function(match, length) {
|
|
return padStart(date.getMinutes(), length, "0");
|
|
};
|
|
var fs = function(match, length) {
|
|
return padStart(date.getSeconds(), length, "0");
|
|
};
|
|
var fS = function(match, length) {
|
|
return padStart(date.getMilliseconds(), length, "0");
|
|
};
|
|
var fZ = function(match, length) {
|
|
var zoneHours = date.getTimezoneOffset() / 60 * -1;
|
|
return handleCustomTemplate(date, formats, match, (zoneHours >= 0 ? "+" : "-") + padStart(zoneHours, 2, "0") + (length === 1 ? ":" : "") + "00");
|
|
};
|
|
var fW = function(match, length) {
|
|
return padStart(handleCustomTemplate(date, formats, match, getYearWeek(date, (options ? options.firstDay : null) || setupDefaults.firstDayOfWeek)), length, "0");
|
|
};
|
|
var fD = function(match, length) {
|
|
return padStart(handleCustomTemplate(date, formats, match, getYearDay(date)), length, "0");
|
|
};
|
|
var parseDates = {
|
|
yyyy: fy,
|
|
yy: fy,
|
|
MM: fM,
|
|
M: fM,
|
|
dd: fd,
|
|
d: fd,
|
|
HH: fH,
|
|
H: fH,
|
|
hh: fh,
|
|
h: fh,
|
|
mm: fm,
|
|
m: fm,
|
|
ss: fs,
|
|
s: fs,
|
|
SSS: fS,
|
|
S: fS,
|
|
ZZ: fZ,
|
|
Z: fZ,
|
|
WW: fW,
|
|
W: fW,
|
|
DDD: fD,
|
|
D: fD,
|
|
a: function(match) {
|
|
return handleCustomTemplate(date, formats, match, apm);
|
|
},
|
|
A: function(match) {
|
|
return handleCustomTemplate(date, formats, match, helperStringUpperCase(apm));
|
|
},
|
|
e: function(match) {
|
|
return handleCustomTemplate(date, formats, match, date.getDay());
|
|
},
|
|
E: function(match) {
|
|
return handleCustomTemplate(date, formats, match, date.getDay());
|
|
},
|
|
q: function(match) {
|
|
return handleCustomTemplate(date, formats, match, Math.floor((helperGetDateMonth(date) + 3) / 3));
|
|
}
|
|
};
|
|
return result.replace(dateFormatRE, function(match, skip) {
|
|
return skip || (parseDates[match] ? parseDates[match](match, match.length) : match);
|
|
});
|
|
}
|
|
return "Invalid Date";
|
|
}
|
|
return "";
|
|
}
|
|
module.exports = toDateString;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/now.js
|
|
var require_now = __commonJS({
|
|
"node_modules/xe-utils/now.js"(exports, module) {
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var helperNewDate = require_helperNewDate();
|
|
var now = Date.now || function() {
|
|
return helperGetDateTime(helperNewDate());
|
|
};
|
|
module.exports = now;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/timestamp.js
|
|
var require_timestamp = __commonJS({
|
|
"node_modules/xe-utils/timestamp.js"(exports, module) {
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var now = require_now();
|
|
var toStringDate = require_toStringDate();
|
|
var isDate = require_isDate();
|
|
var timestamp = function(str, format) {
|
|
if (str) {
|
|
var date = toStringDate(str, format);
|
|
return isDate(date) ? helperGetDateTime(date) : date;
|
|
}
|
|
return now();
|
|
};
|
|
module.exports = timestamp;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/isDateSame.js
|
|
var require_isDateSame = __commonJS({
|
|
"node_modules/xe-utils/isDateSame.js"(exports, module) {
|
|
var toDateString = require_toDateString();
|
|
function isDateSame(date1, date2, format) {
|
|
if (date1 && date2) {
|
|
date1 = toDateString(date1, format);
|
|
return date1 !== "Invalid Date" && date1 === toDateString(date2, format);
|
|
}
|
|
return false;
|
|
}
|
|
module.exports = isDateSame;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getMonthWeek.js
|
|
var require_getMonthWeek = __commonJS({
|
|
"node_modules/xe-utils/getMonthWeek.js"(exports, module) {
|
|
var helperCreateGetDateWeek = require_helperCreateGetDateWeek();
|
|
var getMonthWeek = helperCreateGetDateWeek(function(targetDate) {
|
|
return new Date(targetDate.getFullYear(), targetDate.getMonth(), 1);
|
|
}, function(date1, date2) {
|
|
return date1.getMonth() !== date2.getMonth();
|
|
});
|
|
module.exports = getMonthWeek;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getDayOfYear.js
|
|
var require_getDayOfYear = __commonJS({
|
|
"node_modules/xe-utils/getDayOfYear.js"(exports, module) {
|
|
var getWhatYear = require_getWhatYear();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
var isLeapYear = require_isLeapYear();
|
|
function getDayOfYear(date, year) {
|
|
date = toStringDate(date);
|
|
if (isValidDate(date)) {
|
|
return isLeapYear(getWhatYear(date, year)) ? 366 : 365;
|
|
}
|
|
return NaN;
|
|
}
|
|
module.exports = getDayOfYear;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getDayOfMonth.js
|
|
var require_getDayOfMonth = __commonJS({
|
|
"node_modules/xe-utils/getDayOfMonth.js"(exports, module) {
|
|
var staticDayTime = require_staticDayTime();
|
|
var staticStrFirst = require_staticStrFirst();
|
|
var staticStrLast = require_staticStrLast();
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var getWhatMonth = require_getWhatMonth();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
function getDayOfMonth(date, month) {
|
|
date = toStringDate(date);
|
|
if (isValidDate(date)) {
|
|
return Math.floor((helperGetDateTime(getWhatMonth(date, month, staticStrLast)) - helperGetDateTime(getWhatMonth(date, month, staticStrFirst))) / staticDayTime) + 1;
|
|
}
|
|
return NaN;
|
|
}
|
|
module.exports = getDayOfMonth;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getDateDiff.js
|
|
var require_getDateDiff = __commonJS({
|
|
"node_modules/xe-utils/getDateDiff.js"(exports, module) {
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var helperNewDate = require_helperNewDate();
|
|
var toStringDate = require_toStringDate();
|
|
var isValidDate = require_isValidDate();
|
|
var dateDiffRules = [
|
|
["yyyy", 31536e6],
|
|
["MM", 2592e6],
|
|
["dd", 864e5],
|
|
["HH", 36e5],
|
|
["mm", 6e4],
|
|
["ss", 1e3],
|
|
["S", 0]
|
|
];
|
|
function getDateDiff(startDate, endDate) {
|
|
var startTime, endTime, item, diffTime, len, index;
|
|
var result = { done: false, status: false, time: 0 };
|
|
startDate = toStringDate(startDate);
|
|
endDate = endDate ? toStringDate(endDate) : helperNewDate();
|
|
if (isValidDate(startDate) && isValidDate(endDate)) {
|
|
startTime = helperGetDateTime(startDate);
|
|
endTime = helperGetDateTime(endDate);
|
|
if (startTime < endTime) {
|
|
diffTime = result.time = endTime - startTime;
|
|
result.done = true;
|
|
result.status = true;
|
|
for (index = 0, len = dateDiffRules.length; index < len; index++) {
|
|
item = dateDiffRules[index];
|
|
if (diffTime >= item[1]) {
|
|
if (index === len - 1) {
|
|
result[item[0]] = diffTime || 0;
|
|
} else {
|
|
result[item[0]] = Math.floor(diffTime / item[1]);
|
|
diffTime -= result[item[0]] * item[1];
|
|
}
|
|
} else {
|
|
result[item[0]] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
module.exports = getDateDiff;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/padEnd.js
|
|
var require_padEnd = __commonJS({
|
|
"node_modules/xe-utils/padEnd.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
var isUndefined = require_isUndefined();
|
|
var helperStringRepeat = require_helperStringRepeat();
|
|
function padEnd(str, targetLength, padString) {
|
|
var rest = toValueString(str);
|
|
targetLength = targetLength >> 0;
|
|
padString = isUndefined(padString) ? " " : "" + padString;
|
|
if (rest.padEnd) {
|
|
return rest.padEnd(targetLength, padString);
|
|
}
|
|
if (targetLength > rest.length) {
|
|
targetLength -= rest.length;
|
|
if (targetLength > padString.length) {
|
|
padString += helperStringRepeat(padString, targetLength / padString.length);
|
|
}
|
|
return rest + padString.slice(0, targetLength);
|
|
}
|
|
return rest;
|
|
}
|
|
module.exports = padEnd;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/repeat.js
|
|
var require_repeat = __commonJS({
|
|
"node_modules/xe-utils/repeat.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
var helperStringRepeat = require_helperStringRepeat();
|
|
function repeat(str, count) {
|
|
return helperStringRepeat(toValueString(str), count);
|
|
}
|
|
module.exports = repeat;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/trimRight.js
|
|
var require_trimRight = __commonJS({
|
|
"node_modules/xe-utils/trimRight.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
function trimRight(str) {
|
|
return str && str.trimRight ? str.trimRight() : toValueString(str).replace(/[\s\uFEFF\xA0]+$/g, "");
|
|
}
|
|
module.exports = trimRight;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/trimLeft.js
|
|
var require_trimLeft = __commonJS({
|
|
"node_modules/xe-utils/trimLeft.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
function trimLeft(str) {
|
|
return str && str.trimLeft ? str.trimLeft() : toValueString(str).replace(/^[\s\uFEFF\xA0]+/g, "");
|
|
}
|
|
module.exports = trimLeft;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/trim.js
|
|
var require_trim = __commonJS({
|
|
"node_modules/xe-utils/trim.js"(exports, module) {
|
|
var trimRight = require_trimRight();
|
|
var trimLeft = require_trimLeft();
|
|
function trim(str) {
|
|
return str && str.trim ? str.trim() : trimRight(trimLeft(str));
|
|
}
|
|
module.exports = trim;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticEscapeMap.js
|
|
var require_staticEscapeMap = __commonJS({
|
|
"node_modules/xe-utils/staticEscapeMap.js"(exports, module) {
|
|
var staticEscapeMap = {
|
|
"&": "&",
|
|
"<": "<",
|
|
">": ">",
|
|
'"': """,
|
|
"'": "'",
|
|
"`": "`"
|
|
};
|
|
module.exports = staticEscapeMap;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperFormatEscaper.js
|
|
var require_helperFormatEscaper = __commonJS({
|
|
"node_modules/xe-utils/helperFormatEscaper.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
var keys = require_keys();
|
|
function helperFormatEscaper(dataMap) {
|
|
var replaceRegexp = new RegExp("(?:" + keys(dataMap).join("|") + ")", "g");
|
|
return function(str) {
|
|
return toValueString(str).replace(replaceRegexp, function(match) {
|
|
return dataMap[match];
|
|
});
|
|
};
|
|
}
|
|
module.exports = helperFormatEscaper;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/escape.js
|
|
var require_escape = __commonJS({
|
|
"node_modules/xe-utils/escape.js"(exports, module) {
|
|
var staticEscapeMap = require_staticEscapeMap();
|
|
var helperFormatEscaper = require_helperFormatEscaper();
|
|
var escape = helperFormatEscaper(staticEscapeMap);
|
|
module.exports = escape;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/unescape.js
|
|
var require_unescape = __commonJS({
|
|
"node_modules/xe-utils/unescape.js"(exports, module) {
|
|
var staticEscapeMap = require_staticEscapeMap();
|
|
var helperFormatEscaper = require_helperFormatEscaper();
|
|
var each = require_each();
|
|
var unescapeMap = {};
|
|
each(staticEscapeMap, function(item, key) {
|
|
unescapeMap[staticEscapeMap[key]] = key;
|
|
});
|
|
var unescape = helperFormatEscaper(unescapeMap);
|
|
module.exports = unescape;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperStringSubstring.js
|
|
var require_helperStringSubstring = __commonJS({
|
|
"node_modules/xe-utils/helperStringSubstring.js"(exports, module) {
|
|
function helperStringSubstring(str, start, end) {
|
|
return str.substring(start, end);
|
|
}
|
|
module.exports = helperStringSubstring;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperStringLowerCase.js
|
|
var require_helperStringLowerCase = __commonJS({
|
|
"node_modules/xe-utils/helperStringLowerCase.js"(exports, module) {
|
|
function helperStringLowerCase(str) {
|
|
return str.toLowerCase();
|
|
}
|
|
module.exports = helperStringLowerCase;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/camelCase.js
|
|
var require_camelCase = __commonJS({
|
|
"node_modules/xe-utils/camelCase.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
var helperStringSubstring = require_helperStringSubstring();
|
|
var helperStringUpperCase = require_helperStringUpperCase();
|
|
var helperStringLowerCase = require_helperStringLowerCase();
|
|
var camelCacheMaps = {};
|
|
function camelCase(str) {
|
|
str = toValueString(str);
|
|
if (camelCacheMaps[str]) {
|
|
return camelCacheMaps[str];
|
|
}
|
|
var strLen = str.length;
|
|
var rest = str.replace(/([-]+)/g, function(text, flag, index) {
|
|
return index && index + flag.length < strLen ? "-" : "";
|
|
});
|
|
strLen = rest.length;
|
|
rest = rest.replace(/([A-Z]+)/g, function(text, upper, index) {
|
|
var upperLen = upper.length;
|
|
upper = helperStringLowerCase(upper);
|
|
if (index) {
|
|
if (upperLen > 2 && index + upperLen < strLen) {
|
|
return helperStringUpperCase(helperStringSubstring(upper, 0, 1)) + helperStringSubstring(upper, 1, upperLen - 1) + helperStringUpperCase(helperStringSubstring(upper, upperLen - 1, upperLen));
|
|
}
|
|
return helperStringUpperCase(helperStringSubstring(upper, 0, 1)) + helperStringSubstring(upper, 1, upperLen);
|
|
} else {
|
|
if (upperLen > 1 && index + upperLen < strLen) {
|
|
return helperStringSubstring(upper, 0, upperLen - 1) + helperStringUpperCase(helperStringSubstring(upper, upperLen - 1, upperLen));
|
|
}
|
|
}
|
|
return upper;
|
|
}).replace(/(-[a-zA-Z])/g, function(text, upper) {
|
|
return helperStringUpperCase(helperStringSubstring(upper, 1, upper.length));
|
|
});
|
|
camelCacheMaps[str] = rest;
|
|
return rest;
|
|
}
|
|
module.exports = camelCase;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/kebabCase.js
|
|
var require_kebabCase = __commonJS({
|
|
"node_modules/xe-utils/kebabCase.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
var helperStringSubstring = require_helperStringSubstring();
|
|
var helperStringLowerCase = require_helperStringLowerCase();
|
|
var kebabCacheMaps = {};
|
|
function kebabCase(str) {
|
|
str = toValueString(str);
|
|
if (kebabCacheMaps[str]) {
|
|
return kebabCacheMaps[str];
|
|
}
|
|
if (/^[A-Z]+$/.test(str)) {
|
|
return helperStringLowerCase(str);
|
|
}
|
|
var rest = str.replace(/^([a-z])([A-Z]+)([a-z]+)$/, function(text, prevLower, upper, nextLower) {
|
|
var upperLen = upper.length;
|
|
if (upperLen > 1) {
|
|
return prevLower + "-" + helperStringLowerCase(helperStringSubstring(upper, 0, upperLen - 1)) + "-" + helperStringLowerCase(helperStringSubstring(upper, upperLen - 1, upperLen)) + nextLower;
|
|
}
|
|
return helperStringLowerCase(prevLower + "-" + upper + nextLower);
|
|
}).replace(/^([A-Z]+)([a-z]+)?$/, function(text, upper, nextLower) {
|
|
var upperLen = upper.length;
|
|
return helperStringLowerCase(helperStringSubstring(upper, 0, upperLen - 1) + "-" + helperStringSubstring(upper, upperLen - 1, upperLen) + (nextLower || ""));
|
|
}).replace(/([a-z]?)([A-Z]+)([a-z]?)/g, function(text, prevLower, upper, nextLower, index) {
|
|
var upperLen = upper.length;
|
|
if (upperLen > 1) {
|
|
if (prevLower) {
|
|
prevLower += "-";
|
|
}
|
|
if (nextLower) {
|
|
return (prevLower || "") + helperStringLowerCase(helperStringSubstring(upper, 0, upperLen - 1)) + "-" + helperStringLowerCase(helperStringSubstring(upper, upperLen - 1, upperLen)) + nextLower;
|
|
}
|
|
}
|
|
return (prevLower || "") + (index ? "-" : "") + helperStringLowerCase(upper) + (nextLower || "");
|
|
});
|
|
rest = rest.replace(/([-]+)/g, function(text, flag, index) {
|
|
return index && index + flag.length < rest.length ? "-" : "";
|
|
});
|
|
kebabCacheMaps[str] = rest;
|
|
return rest;
|
|
}
|
|
module.exports = kebabCase;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/startsWith.js
|
|
var require_startsWith = __commonJS({
|
|
"node_modules/xe-utils/startsWith.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
function startsWith(str, val, startIndex) {
|
|
var rest = toValueString(str);
|
|
return (arguments.length === 1 ? rest : rest.substring(startIndex)).indexOf(val) === 0;
|
|
}
|
|
module.exports = startsWith;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/endsWith.js
|
|
var require_endsWith = __commonJS({
|
|
"node_modules/xe-utils/endsWith.js"(exports, module) {
|
|
var toValueString = require_toValueString();
|
|
function endsWith(str, val, startIndex) {
|
|
var rest = toValueString(str);
|
|
var argsLen = arguments.length;
|
|
return argsLen > 1 && (argsLen > 2 ? rest.substring(0, startIndex).indexOf(val) === startIndex - 1 : rest.indexOf(val) === rest.length - 1);
|
|
}
|
|
module.exports = endsWith;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/template.js
|
|
var require_template = __commonJS({
|
|
"node_modules/xe-utils/template.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var toValueString = require_toValueString();
|
|
var trim = require_trim();
|
|
var get = require_get();
|
|
function template(str, args, options) {
|
|
return toValueString(str).replace((options || setupDefaults).tmplRE || /\{{2}([.\w[\]\s]+)\}{2}/g, function(match, key) {
|
|
return get(args, trim(key));
|
|
});
|
|
}
|
|
module.exports = template;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/toFormatString.js
|
|
var require_toFormatString = __commonJS({
|
|
"node_modules/xe-utils/toFormatString.js"(exports, module) {
|
|
var template = require_template();
|
|
function toFormatString(str, obj) {
|
|
return template(str, obj, { tmplRE: /\{([.\w[\]\s]+)\}/g });
|
|
}
|
|
module.exports = toFormatString;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/noop.js
|
|
var require_noop = __commonJS({
|
|
"node_modules/xe-utils/noop.js"(exports, module) {
|
|
function noop() {
|
|
}
|
|
module.exports = noop;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/bind.js
|
|
var require_bind = __commonJS({
|
|
"node_modules/xe-utils/bind.js"(exports, module) {
|
|
var slice = require_slice();
|
|
function bind(callback, context) {
|
|
var args = slice(arguments, 2);
|
|
return function() {
|
|
return callback.apply(context, slice(arguments).concat(args));
|
|
};
|
|
}
|
|
module.exports = bind;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/once.js
|
|
var require_once = __commonJS({
|
|
"node_modules/xe-utils/once.js"(exports, module) {
|
|
var slice = require_slice();
|
|
function once(callback, context) {
|
|
var done = false;
|
|
var rest = null;
|
|
var args = slice(arguments, 2);
|
|
return function() {
|
|
if (done) {
|
|
return rest;
|
|
}
|
|
rest = callback.apply(context, slice(arguments).concat(args));
|
|
done = true;
|
|
return rest;
|
|
};
|
|
}
|
|
module.exports = once;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/after.js
|
|
var require_after = __commonJS({
|
|
"node_modules/xe-utils/after.js"(exports, module) {
|
|
var slice = require_slice();
|
|
function after(count, callback, context) {
|
|
var runCount = 0;
|
|
var rests = [];
|
|
return function() {
|
|
var args = arguments;
|
|
runCount++;
|
|
if (runCount <= count) {
|
|
rests.push(args[0]);
|
|
}
|
|
if (runCount >= count) {
|
|
callback.apply(context, [rests].concat(slice(args)));
|
|
}
|
|
};
|
|
}
|
|
module.exports = after;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/before.js
|
|
var require_before = __commonJS({
|
|
"node_modules/xe-utils/before.js"(exports, module) {
|
|
var slice = require_slice();
|
|
function before(count, callback, context) {
|
|
var runCount = 0;
|
|
var rests = [];
|
|
context = context || this;
|
|
return function() {
|
|
var args = arguments;
|
|
runCount++;
|
|
if (runCount < count) {
|
|
rests.push(args[0]);
|
|
callback.apply(context, [rests].concat(slice(args)));
|
|
}
|
|
};
|
|
}
|
|
module.exports = before;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/throttle.js
|
|
var require_throttle = __commonJS({
|
|
"node_modules/xe-utils/throttle.js"(exports, module) {
|
|
var assign = require_assign();
|
|
function throttle(callback, wait, options) {
|
|
var args = null;
|
|
var context = null;
|
|
var runFlag = false;
|
|
var timeout = null;
|
|
var opts = assign({ leading: true, trailing: true }, options);
|
|
var optLeading = opts.leading;
|
|
var optTrailing = opts.trailing;
|
|
var gcFn = function() {
|
|
args = null;
|
|
context = null;
|
|
};
|
|
var runFn = function() {
|
|
runFlag = true;
|
|
callback.apply(context, args);
|
|
timeout = setTimeout(endFn, wait);
|
|
gcFn();
|
|
};
|
|
var endFn = function() {
|
|
timeout = null;
|
|
if (runFlag) {
|
|
gcFn();
|
|
return;
|
|
}
|
|
if (optTrailing === true) {
|
|
runFn();
|
|
return;
|
|
}
|
|
gcFn();
|
|
};
|
|
var cancelFn = function() {
|
|
var rest = timeout !== null;
|
|
if (rest) {
|
|
clearTimeout(timeout);
|
|
}
|
|
gcFn();
|
|
timeout = null;
|
|
runFlag = false;
|
|
return rest;
|
|
};
|
|
var throttled = function() {
|
|
args = arguments;
|
|
context = this;
|
|
runFlag = false;
|
|
if (timeout === null && optLeading === true) {
|
|
runFn();
|
|
return;
|
|
}
|
|
if (optTrailing === true) {
|
|
timeout = setTimeout(endFn, wait);
|
|
}
|
|
};
|
|
throttled.cancel = cancelFn;
|
|
return throttled;
|
|
}
|
|
module.exports = throttle;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/debounce.js
|
|
var require_debounce = __commonJS({
|
|
"node_modules/xe-utils/debounce.js"(exports, module) {
|
|
var assign = require_assign();
|
|
function debounce(callback, wait, options) {
|
|
var args = null;
|
|
var context = null;
|
|
var opts = typeof options === "boolean" ? { leading: options, trailing: !options } : assign({ leading: false, trailing: true }, options);
|
|
var runFlag = false;
|
|
var timeout = null;
|
|
var optLeading = opts.leading;
|
|
var optTrailing = opts.trailing;
|
|
var gcFn = function() {
|
|
args = null;
|
|
context = null;
|
|
};
|
|
var runFn = function() {
|
|
runFlag = true;
|
|
callback.apply(context, args);
|
|
gcFn();
|
|
};
|
|
var endFn = function() {
|
|
if (optLeading === true) {
|
|
timeout = null;
|
|
}
|
|
if (runFlag) {
|
|
gcFn();
|
|
return;
|
|
}
|
|
if (optTrailing === true) {
|
|
runFn();
|
|
return;
|
|
}
|
|
gcFn();
|
|
};
|
|
var cancelFn = function() {
|
|
var rest = timeout !== null;
|
|
if (rest) {
|
|
clearTimeout(timeout);
|
|
}
|
|
gcFn();
|
|
timeout = null;
|
|
runFlag = false;
|
|
return rest;
|
|
};
|
|
var debounced = function() {
|
|
runFlag = false;
|
|
args = arguments;
|
|
context = this;
|
|
if (timeout === null) {
|
|
if (optLeading === true) {
|
|
runFn();
|
|
}
|
|
} else {
|
|
clearTimeout(timeout);
|
|
}
|
|
timeout = setTimeout(endFn, wait);
|
|
};
|
|
debounced.cancel = cancelFn;
|
|
return debounced;
|
|
}
|
|
module.exports = debounce;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/delay.js
|
|
var require_delay = __commonJS({
|
|
"node_modules/xe-utils/delay.js"(exports, module) {
|
|
var slice = require_slice();
|
|
function delay(callback, wait) {
|
|
var args = slice(arguments, 2);
|
|
var context = this;
|
|
return setTimeout(function() {
|
|
callback.apply(context, args);
|
|
}, wait);
|
|
}
|
|
module.exports = delay;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticDecodeURIComponent.js
|
|
var require_staticDecodeURIComponent = __commonJS({
|
|
"node_modules/xe-utils/staticDecodeURIComponent.js"(exports, module) {
|
|
var staticDecodeURIComponent = decodeURIComponent;
|
|
module.exports = staticDecodeURIComponent;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/unserialize.js
|
|
var require_unserialize = __commonJS({
|
|
"node_modules/xe-utils/unserialize.js"(exports, module) {
|
|
var staticDecodeURIComponent = require_staticDecodeURIComponent();
|
|
var arrayEach = require_arrayEach();
|
|
var isString = require_isString();
|
|
function unserialize(str) {
|
|
var items;
|
|
var result = {};
|
|
if (str && isString(str)) {
|
|
arrayEach(str.split("&"), function(param) {
|
|
items = param.split("=");
|
|
result[staticDecodeURIComponent(items[0])] = staticDecodeURIComponent(items[1] || "");
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
module.exports = unserialize;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticEncodeURIComponent.js
|
|
var require_staticEncodeURIComponent = __commonJS({
|
|
"node_modules/xe-utils/staticEncodeURIComponent.js"(exports, module) {
|
|
var staticEncodeURIComponent = encodeURIComponent;
|
|
module.exports = staticEncodeURIComponent;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/serialize.js
|
|
var require_serialize = __commonJS({
|
|
"node_modules/xe-utils/serialize.js"(exports, module) {
|
|
var staticEncodeURIComponent = require_staticEncodeURIComponent();
|
|
var each = require_each();
|
|
var isArray = require_isArray();
|
|
var isNull = require_isNull();
|
|
var isUndefined = require_isUndefined();
|
|
var isPlainObject = require_isPlainObject();
|
|
function stringifyParams(resultVal, resultKey, isArr) {
|
|
var _arr;
|
|
var result = [];
|
|
each(resultVal, function(item, key) {
|
|
_arr = isArray(item);
|
|
if (isPlainObject(item) || _arr) {
|
|
result = result.concat(stringifyParams(item, resultKey + "[" + key + "]", _arr));
|
|
} else {
|
|
result.push(staticEncodeURIComponent(resultKey + "[" + (isArr ? "" : key) + "]") + "=" + staticEncodeURIComponent(isNull(item) ? "" : item));
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
function serialize(query) {
|
|
var _arr;
|
|
var params = [];
|
|
each(query, function(item, key) {
|
|
if (!isUndefined(item)) {
|
|
_arr = isArray(item);
|
|
if (isPlainObject(item) || _arr) {
|
|
params = params.concat(stringifyParams(item, key, _arr));
|
|
} else {
|
|
params.push(staticEncodeURIComponent(key) + "=" + staticEncodeURIComponent(isNull(item) ? "" : item));
|
|
}
|
|
}
|
|
});
|
|
return params.join("&").replace(/%20/g, "+");
|
|
}
|
|
module.exports = serialize;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/staticLocation.js
|
|
var require_staticLocation = __commonJS({
|
|
"node_modules/xe-utils/staticLocation.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var staticLocation = typeof location === staticStrUndefined ? 0 : location;
|
|
module.exports = staticLocation;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/helperGetLocatOrigin.js
|
|
var require_helperGetLocatOrigin = __commonJS({
|
|
"node_modules/xe-utils/helperGetLocatOrigin.js"(exports, module) {
|
|
var staticLocation = require_staticLocation();
|
|
function helperGetLocatOrigin() {
|
|
return staticLocation ? staticLocation.origin || staticLocation.protocol + "//" + staticLocation.host : "";
|
|
}
|
|
module.exports = helperGetLocatOrigin;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/parseUrl.js
|
|
var require_parseUrl = __commonJS({
|
|
"node_modules/xe-utils/parseUrl.js"(exports, module) {
|
|
var staticLocation = require_staticLocation();
|
|
var unserialize = require_unserialize();
|
|
var helperGetLocatOrigin = require_helperGetLocatOrigin();
|
|
function parseURLQuery(uri) {
|
|
return unserialize(uri.split("?")[1] || "");
|
|
}
|
|
function parseUrl(url) {
|
|
var hashs, portText, searchs, parsed;
|
|
var href = "" + url;
|
|
if (href.indexOf("//") === 0) {
|
|
href = (staticLocation ? staticLocation.protocol : "") + href;
|
|
} else if (href.indexOf("/") === 0) {
|
|
href = helperGetLocatOrigin() + href;
|
|
}
|
|
searchs = href.replace(/#.*/, "").match(/(\?.*)/);
|
|
parsed = {
|
|
href,
|
|
hash: "",
|
|
host: "",
|
|
hostname: "",
|
|
protocol: "",
|
|
port: "",
|
|
search: searchs && searchs[1] && searchs[1].length > 1 ? searchs[1] : ""
|
|
};
|
|
parsed.path = href.replace(/^([a-z0-9.+-]*:)\/\//, function(text, protocol) {
|
|
parsed.protocol = protocol;
|
|
return "";
|
|
}).replace(/^([a-z0-9.+-]*)(:\d+)?\/?/, function(text, hostname, port) {
|
|
portText = port || "";
|
|
parsed.port = portText.replace(":", "");
|
|
parsed.hostname = hostname;
|
|
parsed.host = hostname + portText;
|
|
return "/";
|
|
}).replace(/(#.*)/, function(text, hash) {
|
|
parsed.hash = hash.length > 1 ? hash : "";
|
|
return "";
|
|
});
|
|
hashs = parsed.hash.match(/#((.*)\?|(.*))/);
|
|
parsed.pathname = parsed.path.replace(/(\?|#.*).*/, "");
|
|
parsed.origin = parsed.protocol + "//" + parsed.host;
|
|
parsed.hashKey = hashs ? hashs[2] || hashs[1] || "" : "";
|
|
parsed.hashQuery = parseURLQuery(parsed.hash);
|
|
parsed.searchQuery = parseURLQuery(parsed.search);
|
|
return parsed;
|
|
}
|
|
module.exports = parseUrl;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/getBaseURL.js
|
|
var require_getBaseURL = __commonJS({
|
|
"node_modules/xe-utils/getBaseURL.js"(exports, module) {
|
|
var staticLocation = require_staticLocation();
|
|
var helperGetLocatOrigin = require_helperGetLocatOrigin();
|
|
var lastIndexOf = require_lastIndexOf();
|
|
function getBaseURL() {
|
|
if (staticLocation) {
|
|
var pathname = staticLocation.pathname;
|
|
var lastIndex = lastIndexOf(pathname, "/") + 1;
|
|
return helperGetLocatOrigin() + (lastIndex === pathname.length ? pathname : pathname.substring(0, lastIndex));
|
|
}
|
|
return "";
|
|
}
|
|
module.exports = getBaseURL;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/locat.js
|
|
var require_locat = __commonJS({
|
|
"node_modules/xe-utils/locat.js"(exports, module) {
|
|
var staticLocation = require_staticLocation();
|
|
var parseUrl = require_parseUrl();
|
|
function locat() {
|
|
return staticLocation ? parseUrl(staticLocation.href) : {};
|
|
}
|
|
module.exports = locat;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/cookie.js
|
|
var require_cookie = __commonJS({
|
|
"node_modules/xe-utils/cookie.js"(exports, module) {
|
|
var setupDefaults = require_setupDefaults();
|
|
var staticDocument = require_staticDocument();
|
|
var staticDecodeURIComponent = require_staticDecodeURIComponent();
|
|
var staticEncodeURIComponent = require_staticEncodeURIComponent();
|
|
var isArray = require_isArray();
|
|
var isObject = require_isObject();
|
|
var isDate = require_isDate();
|
|
var isUndefined = require_isUndefined();
|
|
var includes = require_includes();
|
|
var keys = require_keys();
|
|
var assign = require_assign();
|
|
var arrayEach = require_arrayEach();
|
|
var helperNewDate = require_helperNewDate();
|
|
var helperGetDateTime = require_helperGetDateTime();
|
|
var getWhatYear = require_getWhatYear();
|
|
var getWhatMonth = require_getWhatMonth();
|
|
var getWhatDay = require_getWhatDay();
|
|
function toCookieUnitTime(unit, expires) {
|
|
var num = parseFloat(expires);
|
|
var nowdate = helperNewDate();
|
|
var time = helperGetDateTime(nowdate);
|
|
switch (unit) {
|
|
case "y":
|
|
return helperGetDateTime(getWhatYear(nowdate, num));
|
|
case "M":
|
|
return helperGetDateTime(getWhatMonth(nowdate, num));
|
|
case "d":
|
|
return helperGetDateTime(getWhatDay(nowdate, num));
|
|
case "h":
|
|
case "H":
|
|
return time + num * 60 * 60 * 1e3;
|
|
case "m":
|
|
return time + num * 60 * 1e3;
|
|
case "s":
|
|
return time + num * 1e3;
|
|
}
|
|
return time;
|
|
}
|
|
function toCookieUTCString(date) {
|
|
return (isDate(date) ? date : new Date(date)).toUTCString();
|
|
}
|
|
function cookie(name, value, options) {
|
|
if (staticDocument) {
|
|
var opts, expires, values, result, cookies, keyIndex;
|
|
var inserts = [];
|
|
var args = arguments;
|
|
if (isArray(name)) {
|
|
inserts = name;
|
|
} else if (args.length > 1) {
|
|
inserts = [assign({ name, value }, options)];
|
|
} else if (isObject(name)) {
|
|
inserts = [name];
|
|
}
|
|
if (inserts.length > 0) {
|
|
arrayEach(inserts, function(obj) {
|
|
opts = assign({}, setupDefaults.cookies, obj);
|
|
values = [];
|
|
if (opts.name) {
|
|
expires = opts.expires;
|
|
values.push(staticEncodeURIComponent(opts.name) + "=" + staticEncodeURIComponent(isObject(opts.value) ? JSON.stringify(opts.value) : opts.value));
|
|
if (expires) {
|
|
if (isNaN(expires)) {
|
|
expires = expires.replace(/^([0-9]+)(y|M|d|H|h|m|s)$/, function(text, num, unit) {
|
|
return toCookieUTCString(toCookieUnitTime(unit, num));
|
|
});
|
|
} else if (/^[0-9]{11,13}$/.test(expires) || isDate(expires)) {
|
|
expires = toCookieUTCString(expires);
|
|
} else {
|
|
expires = toCookieUTCString(toCookieUnitTime("d", expires));
|
|
}
|
|
opts.expires = expires;
|
|
}
|
|
arrayEach(["expires", "path", "domain", "secure"], function(key) {
|
|
if (!isUndefined(opts[key])) {
|
|
values.push(opts[key] && key === "secure" ? key : key + "=" + opts[key]);
|
|
}
|
|
});
|
|
}
|
|
staticDocument.cookie = values.join("; ");
|
|
});
|
|
return true;
|
|
} else {
|
|
result = {};
|
|
cookies = staticDocument.cookie;
|
|
if (cookies) {
|
|
arrayEach(cookies.split("; "), function(val) {
|
|
keyIndex = val.indexOf("=");
|
|
result[staticDecodeURIComponent(val.substring(0, keyIndex))] = staticDecodeURIComponent(val.substring(keyIndex + 1) || "");
|
|
});
|
|
}
|
|
return args.length === 1 ? result[name] : result;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function hasCookieItem(value) {
|
|
return includes(cookieKeys(), value);
|
|
}
|
|
function getCookieItem(name) {
|
|
return cookie(name);
|
|
}
|
|
function setCookieItem(name, value, options) {
|
|
cookie(name, value, options);
|
|
return cookie;
|
|
}
|
|
function removeCookieItem(name, options) {
|
|
cookie(name, "", assign({ expires: -1 }, setupDefaults.cookies, options));
|
|
}
|
|
function cookieKeys() {
|
|
return keys(cookie());
|
|
}
|
|
function cookieJson() {
|
|
return cookie();
|
|
}
|
|
assign(cookie, {
|
|
has: hasCookieItem,
|
|
set: setCookieItem,
|
|
setItem: setCookieItem,
|
|
get: getCookieItem,
|
|
getItem: getCookieItem,
|
|
remove: removeCookieItem,
|
|
removeItem: removeCookieItem,
|
|
keys: cookieKeys,
|
|
getJSON: cookieJson
|
|
});
|
|
module.exports = cookie;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/browse.js
|
|
var require_browse = __commonJS({
|
|
"node_modules/xe-utils/browse.js"(exports, module) {
|
|
var staticStrUndefined = require_staticStrUndefined();
|
|
var staticDocument = require_staticDocument();
|
|
var staticWindow = require_staticWindow();
|
|
var assign = require_assign();
|
|
var arrayEach = require_arrayEach();
|
|
function isBrowseStorage(storage) {
|
|
try {
|
|
var testKey = "__xe_t";
|
|
storage.setItem(testKey, 1);
|
|
storage.removeItem(testKey);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
function isBrowseType(type) {
|
|
return navigator.userAgent.indexOf(type) > -1;
|
|
}
|
|
function browse() {
|
|
var $body, isChrome, isEdge;
|
|
var isMobile = false;
|
|
var isLocalStorage = false;
|
|
var isSessionStorage = false;
|
|
var result = {
|
|
isNode: false,
|
|
isMobile,
|
|
isPC: false,
|
|
isDoc: !!staticDocument
|
|
};
|
|
if (!staticWindow && typeof process !== staticStrUndefined) {
|
|
result.isNode = true;
|
|
} else {
|
|
isEdge = isBrowseType("Edge");
|
|
isChrome = isBrowseType("Chrome");
|
|
isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
|
|
if (result.isDoc) {
|
|
$body = staticDocument.body || staticDocument.documentElement;
|
|
arrayEach(["webkit", "khtml", "moz", "ms", "o"], function(core) {
|
|
result["-" + core] = !!$body[core + "MatchesSelector"];
|
|
});
|
|
}
|
|
try {
|
|
isLocalStorage = isBrowseStorage(staticWindow.localStorage);
|
|
} catch (e) {
|
|
}
|
|
try {
|
|
isSessionStorage = isBrowseStorage(staticWindow.sessionStorage);
|
|
} catch (e) {
|
|
}
|
|
assign(result, {
|
|
edge: isEdge,
|
|
firefox: isBrowseType("Firefox"),
|
|
msie: !isEdge && result["-ms"],
|
|
safari: !isChrome && !isEdge && isBrowseType("Safari"),
|
|
isMobile,
|
|
isPC: !isMobile,
|
|
isLocalStorage,
|
|
isSessionStorage
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
module.exports = browse;
|
|
}
|
|
});
|
|
|
|
// node_modules/xe-utils/index.js
|
|
var require_xe_utils = __commonJS({
|
|
"node_modules/xe-utils/index.js"(exports, module) {
|
|
var XEUtils = require_ctor();
|
|
var assign = require_assign();
|
|
var objectEach = require_objectEach();
|
|
var lastObjectEach = require_lastObjectEach();
|
|
var objectMap = require_objectMap();
|
|
var merge = require_merge();
|
|
var map = require_map();
|
|
var some = require_some();
|
|
var every = require_every();
|
|
var includeArrays = require_includeArrays();
|
|
var arrayEach = require_arrayEach();
|
|
var lastArrayEach = require_lastArrayEach();
|
|
var uniq = require_uniq();
|
|
var union = require_union();
|
|
var toArray = require_toArray();
|
|
var sortBy = require_sortBy();
|
|
var orderBy = require_orderBy();
|
|
var shuffle = require_shuffle();
|
|
var sample = require_sample();
|
|
var slice = require_slice();
|
|
var filter = require_filter();
|
|
var findKey = require_findKey();
|
|
var includes = require_includes();
|
|
var find = require_find();
|
|
var findLast = require_findLast();
|
|
var reduce = require_reduce();
|
|
var copyWithin = require_copyWithin();
|
|
var chunk = require_chunk();
|
|
var zip = require_zip();
|
|
var unzip = require_unzip();
|
|
var zipObject = require_zipObject();
|
|
var flatten = require_flatten();
|
|
var pluck = require_pluck();
|
|
var invoke = require_invoke();
|
|
var toArrayTree = require_toArrayTree();
|
|
var toTreeArray = require_toTreeArray();
|
|
var findTree = require_findTree();
|
|
var eachTree = require_eachTree();
|
|
var mapTree = require_mapTree();
|
|
var filterTree = require_filterTree();
|
|
var searchTree = require_searchTree();
|
|
var arrayIndexOf = require_arrayIndexOf();
|
|
var arrayLastIndexOf = require_arrayLastIndexOf();
|
|
var hasOwnProp = require_hasOwnProp();
|
|
var isArray = require_isArray();
|
|
var isNull = require_isNull();
|
|
var isNumberNaN = require_isNaN();
|
|
var isUndefined = require_isUndefined();
|
|
var isFunction = require_isFunction();
|
|
var isObject = require_isObject();
|
|
var isString = require_isString();
|
|
var isPlainObject = require_isPlainObject();
|
|
var isLeapYear = require_isLeapYear();
|
|
var isDate = require_isDate();
|
|
var eqNull = require_eqNull();
|
|
var each = require_each();
|
|
var forOf = require_forOf();
|
|
var lastForOf = require_lastForOf();
|
|
var indexOf = require_indexOf();
|
|
var lastIndexOf = require_lastIndexOf();
|
|
var keys = require_keys();
|
|
var values = require_values();
|
|
var clone = require_clone();
|
|
var getSize = require_getSize();
|
|
var lastEach = require_lastEach();
|
|
var remove = require_remove();
|
|
var clear = require_clear();
|
|
var isNumberFinite = require_isFinite();
|
|
var isFloat = require_isFloat();
|
|
var isInteger = require_isInteger();
|
|
var isBoolean = require_isBoolean();
|
|
var isNumber = require_isNumber();
|
|
var isRegExp = require_isRegExp();
|
|
var isError = require_isError();
|
|
var isTypeError = require_isTypeError();
|
|
var isEmpty = require_isEmpty();
|
|
var isSymbol = require_isSymbol();
|
|
var isArguments = require_isArguments();
|
|
var isElement = require_isElement();
|
|
var isDocument = require_isDocument();
|
|
var isWindow = require_isWindow();
|
|
var isFormData = require_isFormData();
|
|
var isMap = require_isMap();
|
|
var isWeakMap = require_isWeakMap();
|
|
var isSet = require_isSet();
|
|
var isWeakSet = require_isWeakSet();
|
|
var isMatch = require_isMatch();
|
|
var isEqual = require_isEqual();
|
|
var isEqualWith = require_isEqualWith();
|
|
var getType = require_getType();
|
|
var uniqueId = require_uniqueId();
|
|
var findIndexOf = require_findIndexOf();
|
|
var findLastIndexOf = require_findLastIndexOf();
|
|
var toStringJSON = require_toStringJSON();
|
|
var toJSONString = require_toJSONString();
|
|
var entries = require_entries();
|
|
var pick = require_pick();
|
|
var omit = require_omit();
|
|
var first = require_first();
|
|
var last = require_last();
|
|
var has = require_has();
|
|
var get = require_get();
|
|
var set = require_set();
|
|
var groupBy = require_groupBy();
|
|
var countBy = require_countBy();
|
|
var range = require_range();
|
|
var destructuring = require_destructuring();
|
|
var random = require_random();
|
|
var max = require_max();
|
|
var min = require_min();
|
|
var commafy = require_commafy();
|
|
var round = require_round();
|
|
var ceil = require_ceil();
|
|
var floor = require_floor();
|
|
var toFixed = require_toFixed();
|
|
var toInteger = require_toInteger();
|
|
var toNumber = require_toNumber();
|
|
var toNumberString = require_toNumberString();
|
|
var add = require_add();
|
|
var subtract = require_subtract();
|
|
var multiply = require_multiply();
|
|
var divide = require_divide();
|
|
var sum = require_sum();
|
|
var mean = require_mean();
|
|
var getWhatYear = require_getWhatYear();
|
|
var getWhatQuarter = require_getWhatQuarter();
|
|
var getWhatMonth = require_getWhatMonth();
|
|
var getWhatDay = require_getWhatDay();
|
|
var toStringDate = require_toStringDate();
|
|
var toDateString = require_toDateString();
|
|
var now = require_now();
|
|
var timestamp = require_timestamp();
|
|
var isValidDate = require_isValidDate();
|
|
var isDateSame = require_isDateSame();
|
|
var getWhatWeek = require_getWhatWeek();
|
|
var getYearDay = require_getYearDay();
|
|
var getYearWeek = require_getYearWeek();
|
|
var getMonthWeek = require_getMonthWeek();
|
|
var getDayOfYear = require_getDayOfYear();
|
|
var getDayOfMonth = require_getDayOfMonth();
|
|
var getDateDiff = require_getDateDiff();
|
|
var padEnd = require_padEnd();
|
|
var padStart = require_padStart();
|
|
var repeat = require_repeat();
|
|
var trim = require_trim();
|
|
var trimRight = require_trimRight();
|
|
var trimLeft = require_trimLeft();
|
|
var escape = require_escape();
|
|
var unescape = require_unescape();
|
|
var camelCase = require_camelCase();
|
|
var kebabCase = require_kebabCase();
|
|
var startsWith = require_startsWith();
|
|
var endsWith = require_endsWith();
|
|
var template = require_template();
|
|
var toFormatString = require_toFormatString();
|
|
var toValueString = require_toValueString();
|
|
var noop = require_noop();
|
|
var property = require_property();
|
|
var bind = require_bind();
|
|
var once = require_once();
|
|
var after = require_after();
|
|
var before = require_before();
|
|
var throttle = require_throttle();
|
|
var debounce = require_debounce();
|
|
var delay = require_delay();
|
|
var unserialize = require_unserialize();
|
|
var serialize = require_serialize();
|
|
var parseUrl = require_parseUrl();
|
|
var getBaseURL = require_getBaseURL();
|
|
var locat = require_locat();
|
|
var cookie = require_cookie();
|
|
var browse = require_browse();
|
|
assign(XEUtils, {
|
|
// object
|
|
assign,
|
|
objectEach,
|
|
lastObjectEach,
|
|
objectMap,
|
|
merge,
|
|
// array
|
|
uniq,
|
|
union,
|
|
sortBy,
|
|
orderBy,
|
|
shuffle,
|
|
sample,
|
|
some,
|
|
every,
|
|
slice,
|
|
filter,
|
|
find,
|
|
findLast,
|
|
findKey,
|
|
includes,
|
|
arrayIndexOf,
|
|
arrayLastIndexOf,
|
|
map,
|
|
reduce,
|
|
copyWithin,
|
|
chunk,
|
|
zip,
|
|
unzip,
|
|
zipObject,
|
|
flatten,
|
|
toArray,
|
|
includeArrays,
|
|
pluck,
|
|
invoke,
|
|
arrayEach,
|
|
lastArrayEach,
|
|
toArrayTree,
|
|
toTreeArray,
|
|
findTree,
|
|
eachTree,
|
|
mapTree,
|
|
filterTree,
|
|
searchTree,
|
|
// base
|
|
hasOwnProp,
|
|
eqNull,
|
|
isNaN: isNumberNaN,
|
|
isFinite: isNumberFinite,
|
|
isUndefined,
|
|
isArray,
|
|
isFloat,
|
|
isInteger,
|
|
isFunction,
|
|
isBoolean,
|
|
isString,
|
|
isNumber,
|
|
isRegExp,
|
|
isObject,
|
|
isPlainObject,
|
|
isDate,
|
|
isError,
|
|
isTypeError,
|
|
isEmpty,
|
|
isNull,
|
|
isSymbol,
|
|
isArguments,
|
|
isElement,
|
|
isDocument,
|
|
isWindow,
|
|
isFormData,
|
|
isMap,
|
|
isWeakMap,
|
|
isSet,
|
|
isWeakSet,
|
|
isLeapYear,
|
|
isMatch,
|
|
isEqual,
|
|
isEqualWith,
|
|
getType,
|
|
uniqueId,
|
|
getSize,
|
|
indexOf,
|
|
lastIndexOf,
|
|
findIndexOf,
|
|
findLastIndexOf,
|
|
toStringJSON,
|
|
toJSONString,
|
|
keys,
|
|
values,
|
|
entries,
|
|
pick,
|
|
omit,
|
|
first,
|
|
last,
|
|
each,
|
|
forOf,
|
|
lastForOf,
|
|
lastEach,
|
|
has,
|
|
get,
|
|
set,
|
|
groupBy,
|
|
countBy,
|
|
clone,
|
|
clear,
|
|
remove,
|
|
range,
|
|
destructuring,
|
|
// number
|
|
random,
|
|
min,
|
|
max,
|
|
commafy,
|
|
round,
|
|
ceil,
|
|
floor,
|
|
toFixed,
|
|
toNumber,
|
|
toNumberString,
|
|
toInteger,
|
|
add,
|
|
subtract,
|
|
multiply,
|
|
divide,
|
|
sum,
|
|
mean,
|
|
// date
|
|
now,
|
|
timestamp,
|
|
isValidDate,
|
|
isDateSame,
|
|
toStringDate,
|
|
toDateString,
|
|
getWhatYear,
|
|
getWhatQuarter,
|
|
getWhatMonth,
|
|
getWhatWeek,
|
|
getWhatDay,
|
|
getYearDay,
|
|
getYearWeek,
|
|
getMonthWeek,
|
|
getDayOfYear,
|
|
getDayOfMonth,
|
|
getDateDiff,
|
|
// string
|
|
trim,
|
|
trimLeft,
|
|
trimRight,
|
|
escape,
|
|
unescape,
|
|
camelCase,
|
|
kebabCase,
|
|
repeat,
|
|
padStart,
|
|
padEnd,
|
|
startsWith,
|
|
endsWith,
|
|
template,
|
|
toFormatString,
|
|
toString: toValueString,
|
|
toValueString,
|
|
// function
|
|
noop,
|
|
property,
|
|
bind,
|
|
once,
|
|
after,
|
|
before,
|
|
throttle,
|
|
debounce,
|
|
delay,
|
|
// url
|
|
unserialize,
|
|
serialize,
|
|
parseUrl,
|
|
// web
|
|
getBaseURL,
|
|
locat,
|
|
browse,
|
|
cookie
|
|
});
|
|
module.exports = XEUtils;
|
|
}
|
|
});
|
|
|
|
export {
|
|
require_xe_utils
|
|
};
|
|
//# sourceMappingURL=chunk-YWOO7V3Z.js.map
|