sculp-js 1.13.1 → 1.13.3-beta.0

package/dist/types/index.js

@@ -0,0 +1,3278 @@
+/**
+ * 遍历数组，返回 false 中断遍历(支持continue和break操作)
+ *
+ * @param {ArrayLike<V>} array
+ * @param {(val: V, idx: number) => any} iterator 迭代函数, 返回值为true时continue, 返回值为false时break
+ * @param {boolean} reverse  是否倒序
+ * @returns {*}
+ */
+function arrayEach(array, iterator, reverse = false) {
+    if (reverse) {
+        for (let idx = array.length - 1; idx >= 0; idx--) {
+            const re = iterator(array[idx], idx, array);
+            if (re === false)
+                break;
+            else if (re === true)
+                continue;
+        }
+    }
+    else {
+        for (let idx = 0, len = array.length; idx < len; idx++) {
+            const re = iterator(array[idx], idx, array);
+            if (re === false)
+                break;
+            else if (re === true)
+                continue;
+        }
+    }
+    // @ts-ignore
+    array = null;
+}
+/**
+ * 异步遍历数组，返回 false 中断遍历
+ * @param {ArrayLike<V>} array 数组
+ * @param {(val: V, idx: number) => Promise<any>} iterator  支持Promise类型的回调函数
+ * @param {boolean} reverse  是否反向遍历
+ * @example
+ *    使用范例如下:
+ * const start = async () => {
+ *   await arrayEachAsync(result, async (item) => {
+ *     await request(item);
+ *     count++;
+ *   })
+ *   console.log('发送次数', count);
+ * }
+
+ * for await...of 使用范例如下
+ * const loadImages =  async (images) => {
+ *   for await (const item of images) {
+ *      await request(item);
+ *      count++;
+ *    }
+ * }
+ */
+async function arrayEachAsync(array, iterator, reverse = false) {
+    if (reverse) {
+        for (let idx = array.length - 1; idx >= 0; idx--) {
+            if ((await iterator(array[idx], idx)) === false)
+                break;
+        }
+    }
+    else {
+        for (let idx = 0, len = array.length; idx < len; idx++) {
+            if ((await iterator(array[idx], idx)) === false)
+                break;
+        }
+    }
+}
+/**
+ * 插入到目标位置之前
+ * @param {AnyArray} array
+ * @param {number} start
+ * @param {number} to
+ * @returns {*}
+ */
+function arrayInsertBefore(array, start, to) {
+    if (start === to || start + 1 === to)
+        return;
+    const [source] = array.splice(start, 1);
+    const insertIndex = to < start ? to : to - 1;
+    array.splice(insertIndex, 0, source);
+}
+/**
+ * 数组删除指定项目
+ * @param {V[]} array
+ * @param {(val: V, idx: number) => boolean} expect
+ * @returns {V[]}
+ */
+function arrayRemove(array, expect) {
+    const indexes = [];
+    // 这里重命名一下：是为了杜绝 jest 里的 expect 与之产生检查错误
+    // eslint 的 jest 语法检查是遇到 expect 函数就以为是单元测试
+    const _expect = expect;
+    arrayEach(array, (val, idx) => {
+        if (_expect(val, idx))
+            indexes.push(idx);
+    });
+    indexes.forEach((val, idx) => {
+        array.splice(val - idx, 1);
+    });
+    return array;
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/**
+ * https://github.com/gre/bezier-easing
+ * BezierEasing - use bezier curve for transition easing function
+ * by Gaëtan Renaudeau 2014 - 2015 – MIT License
+ */
+
+// These values are established by empiricism with tests (tradeoff: performance VS precision)
+var NEWTON_ITERATIONS = 4;
+var NEWTON_MIN_SLOPE = 0.001;
+var SUBDIVISION_PRECISION = 0.0000001;
+var SUBDIVISION_MAX_ITERATIONS = 10;
+
+var kSplineTableSize = 11;
+var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+
+var float32ArraySupported = typeof Float32Array === 'function';
+
+function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
+function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
+function C (aA1)      { return 3.0 * aA1; }
+
+// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+function calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }
+
+// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }
+
+function binarySubdivide (aX, aA, aB, mX1, mX2) {
+  var currentX, currentT, i = 0;
+  do {
+    currentT = aA + (aB - aA) / 2.0;
+    currentX = calcBezier(currentT, mX1, mX2) - aX;
+    if (currentX > 0.0) {
+      aB = currentT;
+    } else {
+      aA = currentT;
+    }
+  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+  return currentT;
+}
+
+function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {
+ for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+   var currentSlope = getSlope(aGuessT, mX1, mX2);
+   if (currentSlope === 0.0) {
+     return aGuessT;
+   }
+   var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+   aGuessT -= currentX / currentSlope;
+ }
+ return aGuessT;
+}
+
+function LinearEasing (x) {
+  return x;
+}
+
+var src = function bezier (mX1, mY1, mX2, mY2) {
+  if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {
+    throw new Error('bezier x values must be in [0, 1] range');
+  }
+
+  if (mX1 === mY1 && mX2 === mY2) {
+    return LinearEasing;
+  }
+
+  // Precompute samples table
+  var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+  for (var i = 0; i < kSplineTableSize; ++i) {
+    sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+  }
+
+  function getTForX (aX) {
+    var intervalStart = 0.0;
+    var currentSample = 1;
+    var lastSample = kSplineTableSize - 1;
+
+    for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+      intervalStart += kSampleStepSize;
+    }
+    --currentSample;
+
+    // Interpolate to provide an initial guess for t
+    var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+    var guessForT = intervalStart + dist * kSampleStepSize;
+
+    var initialSlope = getSlope(guessForT, mX1, mX2);
+    if (initialSlope >= NEWTON_MIN_SLOPE) {
+      return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+    } else if (initialSlope === 0.0) {
+      return guessForT;
+    } else {
+      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+    }
+  }
+
+  return function BezierEasing (x) {
+    // Because JavaScript number are imprecise, we should guarantee the extremes are right.
+    if (x === 0) {
+      return 0;
+    }
+    if (x === 1) {
+      return 1;
+    }
+    return calcBezier(getTForX(x), mY1, mY2);
+  };
+};
+
+var bezier = /*@__PURE__*/getDefaultExportFromCjs(src);
+
+// 常用类型定义
+const { toString, hasOwnProperty, propertyIsEnumerable } = Object.prototype;
+/**
+ * 判断对象内是否有该静态属性
+ * @param {object} obj
+ * @param {string} key
+ * @returns {boolean}
+ */
+function objectHas(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * 判断一个对象是否为类数组
+ *
+ * @param any
+ * @returns {boolean}
+ */
+function arrayLike(any) {
+    if (isArray(any))
+        return true;
+    if (isString(any))
+        return true;
+    if (!isObject(any))
+        return false;
+    return objectHas(any, 'length');
+}
+/**
+ * 判断任意值的数据类型，检查非对象时不如typeof、instanceof的性能高
+ *
+ * 当检查类对象时是不可靠的，对象可以通过定义 Symbol.toStringTag 属性来更改检查结果
+ *
+ * 详见：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
+ * @param {unknown} any
+ * @returns
+ */
+function typeIs(any) {
+    return toString.call(any).slice(8, -1);
+}
+// 基本数据类型判断
+const isString = (any) => typeof any === 'string';
+const isBoolean = (any) => typeof any === 'boolean';
+const isSymbol = (any) => typeof any === 'symbol';
+const isBigInt = (any) => typeof any === 'bigint';
+const isNumber = (any) => typeof any === 'number' && !Number.isNaN(any);
+const isUndefined = (any) => typeof any === 'undefined';
+const isNull = (any) => any === null;
+const isPrimitive = (any) => any === null || typeof any !== 'object';
+function isNullOrUnDef(val) {
+    return isUndefined(val) || isNull(val);
+}
+// 复合数据类型判断
+const isObject = (any) => typeIs(any) === 'Object';
+const isArray = (any) => Array.isArray(any);
+/**
+ * 判断是否为函数
+ * @param {unknown} any
+ * @returns {boolean}
+ */
+const isFunction = (any) => typeof any === 'function';
+// 对象类型判断
+const isNaN = (any) => Number.isNaN(any);
+const isDate = (any) => typeIs(any) === 'Date';
+const isError = (any) => typeIs(any) === 'Error';
+const isRegExp = (any) => typeIs(any) === 'RegExp';
+/**
+ * 判断一个字符串是否为有效的 JSON, 若有效则返回有效的JSON对象，否则false
+ * @param {string} str
+ * @returns {Object | boolean}
+ */
+function isJsonString(str) {
+    try {
+        const parsed = JSON.parse(str);
+        return typeof parsed === 'object' && parsed !== null ? parsed : false;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * jQuery-like collections are considered empty if they have a `length` of `0`.
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+ * @example
+ *
+ * isEmpty(null);
+ * // => true
+ *
+ * isEmpty(true);
+ * // => true
+ *
+ * isEmpty(1);
+ * // => true
+ *
+ * isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * isEmpty({ 'a': 1 });
+ * // => false
+ */
+function isEmpty(value) {
+    if (isNullOrUnDef(value) || Number.isNaN(value)) {
+        return true;
+    }
+    const tag = typeIs(value);
+    if (arrayLike(value) || 'Arguments' === tag) {
+        return !value.length;
+    }
+    if ('Set' === tag || 'Map' === tag) {
+        return !value.size;
+    }
+    return !Object.keys(value).length;
+}
+/**
+ * Checks if `value` is an NodeList object
+ */
+function isNodeList(value) {
+    return isUndefined(NodeList) ? false : NodeList.prototype.isPrototypeOf(value);
+}
+
+// @ref https://cubic-bezier.com/
+const easingDefines = {
+    linear: [0, 0, 1, 1],
+    ease: [0.25, 0.1, 0.25, 1],
+    'ease-in': [0.42, 0, 1, 1],
+    'ease-out': [0, 0, 0.58, 1],
+    'ease-in-out': [0.42, 0, 0.58, 1]
+};
+/**
+ * 设置缓存定义
+ * @param {string} name
+ * @param {EasingDefine} define
+ */
+function setEasing(name, define) {
+    easingDefines[name] = define;
+}
+function getEasing(name) {
+    if (name)
+        return easingDefines[name];
+    return easingDefines;
+}
+/**
+ * 缓冲函数化，用于 js 计算缓冲进度
+ * @param {EasingNameOrDefine} [name=linear]
+ * @returns {EasingFunction}
+ */
+function easingFunctional(name) {
+    let fn;
+    if (isArray(name)) {
+        fn = bezier(...name);
+    }
+    else {
+        const define = easingDefines[name];
+        if (!define) {
+            throw new Error(`${name} 缓冲函数未定义`);
+        }
+        fn = bezier(...define);
+    }
+    return (input) => fn(Math.max(0, Math.min(input, 1)));
+}
+/**
+ * 缓冲字符化，用于 css 设置缓冲属性
+ * @param {EasingNameOrDefine} name
+ * @returns {string}
+ */
+function easingStringify(name) {
+    let bezierDefine;
+    if (isArray(name)) {
+        bezierDefine = name;
+    }
+    else {
+        const define = easingDefines[name];
+        if (!define) {
+            throw new Error(`${name} 缓冲函数未定义`);
+        }
+        bezierDefine = define;
+    }
+    return `cubic-bezier(${bezierDefine.join(',')})`;
+}
+
+/**
+ * 判断对象是否为纯对象
+ * @param {object} obj
+ * @returns {boolean}
+ */
+const isPlainObject = (obj) => {
+    if (!isObject(obj))
+        return false;
+    const proto = Object.getPrototypeOf(obj);
+    // 对象无原型
+    if (!proto)
+        return true;
+    // 是否对象直接实例
+    return proto === Object.prototype;
+};
+/**
+ * 遍历对象，返回 false 中断遍历
+ * @param {O} obj
+ * @param {(val: O[keyof O], key: keyof O) => (boolean | void)} iterator
+ */
+function objectEach(obj, iterator) {
+    for (const key in obj) {
+        if (!objectHas(obj, key))
+            continue;
+        if (iterator(obj[key], key) === false)
+            break;
+    }
+    // @ts-ignore
+    obj = null;
+}
+/**
+ * 异步遍历对象，返回 false 中断遍历
+ * @param {O} obj
+ * @param {(val: O[keyof O], key: keyof O) => (boolean | void)} iterator
+ */
+async function objectEachAsync(obj, iterator) {
+    for (const key in obj) {
+        if (!objectHas(obj, key))
+            continue;
+        if ((await iterator(obj[key], key)) === false)
+            break;
+    }
+}
+/**
+ * 对象映射
+ * @param {O} obj
+ * @param {(val: O[keyof O], key: Extract<keyof O, string>) => any} iterator
+ * @returns {Record<Extract<keyof O, string>, T>}
+ */
+function objectMap(obj, iterator) {
+    const obj2 = {};
+    for (const key in obj) {
+        if (!objectHas(obj, key))
+            continue;
+        obj2[key] = iterator(obj[key], key);
+    }
+    // @ts-ignore
+    obj = null;
+    return obj2;
+}
+/**
+ * 对象提取
+ * @param {O} obj
+ * @param {K} keys
+ * @returns {Pick<O, ArrayElements<K>>}
+ */
+function objectPick(obj, keys) {
+    const obj2 = {};
+    objectEach(obj, (v, k) => {
+        if (keys.includes(k)) {
+            // @ts-ignore
+            obj2[k] = v;
+        }
+    });
+    // @ts-ignore
+    obj = null;
+    return obj2;
+}
+/**
+ * 对象去除
+ * @param {O} obj
+ * @param {K} keys
+ * @returns {Pick<O, ArrayElements<K>>}
+ */
+function objectOmit(obj, keys) {
+    const obj2 = {};
+    objectEach(obj, (v, k) => {
+        if (!keys.includes(k)) {
+            // @ts-ignore
+            obj2[k] = v;
+        }
+    });
+    // @ts-ignore
+    obj = null;
+    return obj2;
+}
+const merge = (map, source, target) => {
+    if (isUndefined(target))
+        return source;
+    const sourceType = typeIs(source);
+    const targetType = typeIs(target);
+    if (sourceType !== targetType) {
+        if (isArray(target))
+            return merge(map, [], target);
+        if (isObject(target))
+            return merge(map, {}, target);
+        return target;
+    }
+    // 朴素对象
+    if (isPlainObject(target)) {
+        const exist = map.get(target);
+        if (exist)
+            return exist;
+        map.set(target, source);
+        objectEach(target, (val, key) => {
+            source[key] = merge(map, source[key], val);
+        });
+        return source;
+    }
+    // 数组
+    else if (isArray(target)) {
+        const exist = map.get(target);
+        if (exist)
+            return exist;
+        map.set(target, source);
+        target.forEach((val, index) => {
+            source[index] = merge(map, source[index], val);
+        });
+        return source;
+    }
+    return target;
+};
+/**
+ * 对象合并，返回原始对象
+ * @param {ObjectAssignItem} source
+ * @param {ObjectAssignItem | undefined} targets
+ * @returns {R}
+ */
+function objectAssign(source, ...targets) {
+    const map = new Map();
+    for (let i = 0, len = targets.length; i < len; i++) {
+        const target = targets[i];
+        // @ts-ignore
+        source = merge(map, source, target);
+    }
+    map.clear();
+    return source;
+}
+/**
+ * 对象填充
+ * @param {Partial<R>} source
+ * @param {Partial<R>} target
+ * @param {(s: Partial<R>, t: Partial<R>, key: keyof R) => boolean} fillable
+ * @returns {R}
+ */
+function objectFill(source, target, fillable) {
+    const _fillable = fillable || ((source, target, key) => source[key] === undefined);
+    objectEach(target, (val, key) => {
+        if (_fillable(source, target, key)) {
+            source[key] = val;
+        }
+    });
+    return source;
+}
+/**
+ * 获取对象/数组指定层级下的属性值（现在可用ES6+的可选链?.来替代）
+ * @param {AnyObject} obj
+ * @param {string} path
+ * @param {boolean} strict
+ * @returns
+ */
+function objectGet(obj, path, strict = false) {
+    path = path.replace(/\[(\w+)\]/g, '.$1');
+    path = path.replace(/^\./, '');
+    const keyArr = path.split('.');
+    let tempObj = obj;
+    let i = 0;
+    for (let len = keyArr.length; i < len - 1; ++i) {
+        const key = keyArr[i];
+        if (isNumber(Number(key)) && Array.isArray(tempObj)) {
+            tempObj = tempObj[key];
+        }
+        else if (isObject(tempObj) && objectHas(tempObj, key)) {
+            tempObj = tempObj[key];
+        }
+        else {
+            tempObj = undefined;
+            if (strict) {
+                throw new Error('[Object] objectGet path 路径不正确');
+            }
+            break;
+        }
+    }
+    return {
+        p: tempObj,
+        k: tempObj ? keyArr[i] : undefined,
+        v: tempObj ? tempObj[keyArr[i]] : undefined
+    };
+}
+
+/**
+ * 将字符串转换为驼峰格式
+ * @param {string} string
+ * @param {boolean} [bigger] 是否大写第一个字母
+ * @returns {string}
+ */
+function stringCamelCase(string, bigger) {
+    let string2 = string;
+    if (bigger) {
+        string2 = string.replace(/^./, origin => origin.toUpperCase());
+    }
+    const HUMP_RE = /[\s_-](.)/g;
+    return string2.replace(HUMP_RE, (orign, char) => char.toUpperCase());
+}
+/**
+ * 将字符串转换为连字格式
+ * @param {string} string
+ * @param {string} [separator] 分隔符，默认是"-"（短横线）
+ * @returns {string}
+ */
+function stringKebabCase(string, separator = '-') {
+    const string2 = string.replace(/^./, origin => origin.toLowerCase());
+    return string2.replace(/[A-Z]/g, origin => `${separator}${origin.toLowerCase()}`);
+}
+const STRING_ARABIC_NUMERALS = '0123456789';
+const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';
+const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const placeholderRE = /%[%sdo]/g;
+/**
+ * 字符串格式化
+ * @example
+ * ```js
+ * stringFormat("My name is %s.", "zhangsan")
+ * // => "My name is zhangsan."
+ * ```
+ * @param {string} string 字符串模板，使用 %s 表示字符串，%d 表示数值，%o 表示对象，%% 表示百分号，参考 console.log
+ * @param args
+ * @returns {string}
+ */
+function stringFormat(string, ...args) {
+    let index = 0;
+    const result = string.replace(placeholderRE, (origin) => {
+        const arg = args[index++];
+        switch (origin) {
+            case '%%':
+                index--;
+                return '%';
+            default:
+            case '%s':
+                return String(arg);
+            case '%d':
+                return String(Number(arg));
+            case '%o':
+                return JSON.stringify(arg);
+        }
+    });
+    return [result, ...args.splice(index).map(String)].join(' ');
+}
+const ev = (expression, data) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-implied-eval,@typescript-eslint/no-unsafe-return
+        return new Function('with(arguments[0]){' +
+            /****/ `if(arguments[0].${expression} === undefined)throw "";` +
+            /****/
+            /****/ `return String(arguments[0].${expression})` +
+            '}')(data);
+    }
+    catch (err) {
+        throw new SyntaxError(`无法执行表达式：${expression}`);
+    }
+};
+const templateRE = /\${(.*?)}/g;
+/**
+ * 字符串赋值
+ * @example
+ * ```js
+ * stringAssign('My name is ${user}.', { user: 'zhangsan' });
+ * // => "My name is zhangsan."
+ * ```
+ * @param {string} template
+ * @param {AnyObject} data
+ * @returns {string}
+ */
+const stringAssign = (template, data) => {
+    return template.replace(templateRE, (origin, expression) => ev(expression, data));
+};
+/**
+ * 字符串编码 HTML
+ * @example
+ * ```js
+ * stringEscapeHtml('<b>You & Me speak "xixi"</b>')
+ * // => "&lt;b&gt;You &amp; Me speak &quot;xixi&quot;&lt;/b&gt;"
+ * ```
+ * @param {string} html
+ * @returns {string}
+ */
+const stringEscapeHtml = (html) => {
+    const htmlCharRE = /[&<>"]/g;
+    const htmlCharReplacements = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;'
+    };
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return html.replace(htmlCharRE, $0 => htmlCharReplacements[$0]);
+};
+/**
+ * 字符串填充
+ * @param {number} length
+ * @param {string} value
+ * @returns {string}
+ */
+const stringFill = (length, value = ' ') => new Array(length).fill(value).join('');
+/**
+ * 解析URL查询参数
+ * @param {string} searchStr
+ * @returns {Record<string, string | string[]>}
+ */
+function parseQueryParams(searchStr = location.search) {
+    const queryObj = {};
+    Array.from(searchStr.matchAll(/[&?]?([^=&]+)=?([^=&]*)/g)).forEach((item, i) => {
+        if (!queryObj[item[1]]) {
+            queryObj[item[1]] = item[2];
+        }
+        else if (typeof queryObj[item[1]] === 'string') {
+            queryObj[item[1]] = [queryObj[item[1]], item[2]];
+        }
+        else {
+            queryObj[item[1]].push(item[2]);
+        }
+    });
+    return queryObj;
+}
+
+/**
+ * 判断元素是否包含某个样式名
+ * @param {HTMLElement} el
+ * @param {string} className
+ * @returns {boolean}
+ */
+function hasClass(el, className) {
+    if (className.indexOf(' ') !== -1)
+        throw new Error('className should not contain space.');
+    return el.classList.contains(className);
+}
+const eachClassName = (classNames, func) => {
+    const classNameList = classNames.split(/\s+/g);
+    classNameList.forEach(func);
+};
+/**
+ * 给元素增加样式名
+ * @param {HTMLElement} el
+ * @param {string} classNames
+ */
+function addClass(el, classNames) {
+    eachClassName(classNames, className => el.classList.add(className));
+}
+/**
+ * 给元素移除样式名
+ * @param {HTMLElement} el
+ * @param {string} classNames
+ */
+function removeClass(el, classNames) {
+    eachClassName(classNames, className => el.classList.remove(className));
+}
+/**
+ * 设置元素样式
+ * @param {HTMLElement} el
+ * @param {string | Style} key
+ * @param {string} val
+ */
+const setStyle = (el, key, val) => {
+    if (isObject(key)) {
+        objectEach(key, (val1, key1) => {
+            setStyle(el, key1, val1);
+        });
+    }
+    else {
+        el.style.setProperty(stringKebabCase(key), val);
+    }
+};
+/**
+ * 获取元素样式
+ * @param {HTMLElement} el 元素
+ * @param {string} key
+ * @returns {string}
+ */
+function getStyle(el, key) {
+    return getComputedStyle(el).getPropertyValue(key);
+}
+function smoothScroll(options) {
+    return new Promise(resolve => {
+        const defaults = {
+            el: document,
+            to: 0,
+            duration: 567,
+            easing: 'ease'
+        };
+        const { el, to, duration, easing } = objectAssign(defaults, options);
+        const htmlEl = document.documentElement;
+        const bodyEl = document.body;
+        const globalMode = el === window || el === document || el === htmlEl || el === bodyEl;
+        const els = globalMode ? [htmlEl, bodyEl] : [el];
+        const query = () => {
+            let value = 0;
+            arrayEach(els, el => {
+                if ('scrollTop' in el) {
+                    value = el.scrollTop;
+                    return false;
+                }
+            });
+            return value;
+        };
+        const update = (val) => {
+            els.forEach(el => {
+                if ('scrollTop' in el) {
+                    el.scrollTop = val;
+                }
+            });
+        };
+        let startTime;
+        const startValue = query();
+        const length = to - startValue;
+        const easingFn = easingFunctional(easing);
+        const render = () => {
+            const now = performance.now();
+            const passingTime = startTime ? now - startTime : 0;
+            const t = passingTime / duration;
+            const p = easingFn(t);
+            if (!startTime)
+                startTime = now;
+            update(startValue + length * p);
+            if (t >= 1)
+                resolve();
+            else
+                requestAnimationFrame(render);
+        };
+        render();
+    });
+}
+/**
+ * 获取元素样式属性的计算值
+ * @param {HTMLElement} el
+ * @param {string} property
+ * @param {boolean} reNumber
+ * @returns {string|number}
+ */
+function getComputedCssVal(el, property, reNumber = true) {
+    const originVal = getComputedStyle(el).getPropertyValue(property) ?? '';
+    return reNumber ? Number(originVal.replace(/([0-9]*)(.*)/g, '$1')) : originVal;
+}
+/**
+ * 字符串的像素宽度
+ * @param {string} str 目标字符串
+ * @param {number} fontSize 字符串字体大小
+ * @param {boolean} isRemove 计算后是否移除创建的dom元素
+ * @returns {*}
+ */
+function getStrWidthPx(str, fontSize = 14, isRemove = true) {
+    let strWidth = 0;
+    console.assert(isString(str), `${str} 不是有效的字符串`);
+    if (isString(str) && str.length > 0) {
+        const id = 'getStrWidth1494304949567';
+        let getEle = document.querySelector(`#${id}`);
+        if (!getEle) {
+            const _ele = document.createElement('span');
+            _ele.id = id;
+            _ele.style.fontSize = fontSize + 'px';
+            _ele.style.whiteSpace = 'nowrap';
+            _ele.style.visibility = 'hidden';
+            _ele.style.position = 'absolute';
+            _ele.style.top = '-9999px';
+            _ele.style.left = '-9999px';
+            _ele.textContent = str;
+            document.body.appendChild(_ele);
+            getEle = _ele;
+        }
+        getEle.textContent = str;
+        strWidth = getEle.offsetWidth;
+        if (isRemove) {
+            getEle.remove();
+        }
+    }
+    return strWidth;
+}
+/**
+ * Programmatically select the text of a HTML element
+ *
+ * @param {HTMLElement} element The element whose text you wish to select
+ * @returns
+ */
+function select(element) {
+    let selectedText;
+    if (element.nodeName === 'SELECT') {
+        element.focus();
+        // @ts-ignore
+        selectedText = element.value;
+    }
+    else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
+        const isReadOnly = element.hasAttribute('readonly');
+        if (!isReadOnly) {
+            element.setAttribute('readonly', '');
+        }
+        // @ts-ignore
+        element.select();
+        // @ts-ignore
+        element.setSelectionRange(0, element.value.length);
+        if (!isReadOnly) {
+            element.removeAttribute('readonly');
+        }
+        // @ts-ignore
+        selectedText = element.value;
+    }
+    else {
+        if (element.hasAttribute('contenteditable')) {
+            element.focus();
+        }
+        const selection = window.getSelection();
+        const range = document.createRange();
+        range.selectNodeContents(element);
+        selection.removeAllRanges();
+        selection.addRange(range);
+        selectedText = selection.toString();
+    }
+    return selectedText;
+}
+
+/**
+ * 复制文本，优先使用navigator.clipboard，仅在安全上下文(HTTPS/localhost)下生效，若不支持则回退使用execCommand方式
+ * @param {string} text
+ * @param {CopyTextOptions} options 可选参数：成功回调successCallback、失败回调failCallback、容器元素container
+ *                      （默认document.body, 当不支持clipboard时必须传复制按钮元素，包裹模拟选择操作的临时元素，
+ *                        解决脱离文档流的元素无法复制的问题，如Modal内复制操作)
+ */
+function copyText(text, options) {
+    const { successCallback = void 0, failCallback = void 0 } = isNullOrUnDef(options) ? {} : options;
+    if (navigator.clipboard) {
+        navigator.clipboard
+            .writeText(text)
+            .then(() => {
+            if (isFunction(successCallback)) {
+                successCallback();
+            }
+        })
+            .catch(err => {
+            fallbackCopyText(text, options);
+        });
+    }
+    else {
+        // 使用旧版execCommand方法
+        fallbackCopyText(text, options);
+    }
+}
+/**
+ * 使用execCommand方式复制文本
+ * @param text
+ * @param options
+ */
+function fallbackCopyText(text, options) {
+    const { successCallback = void 0, failCallback = void 0, container = document.body } = isNullOrUnDef(options) ? {} : options;
+    let textEl = createFakeElement(text);
+    container.appendChild(textEl);
+    select(textEl);
+    try {
+        const res = document.execCommand('copy');
+        if (res && isFunction(successCallback)) {
+            successCallback();
+        }
+    }
+    catch (err) {
+        if (isFunction(failCallback)) {
+            failCallback(err);
+        }
+    }
+    finally {
+        container.removeChild(textEl);
+        // @ts-ignore
+        textEl = null;
+        window.getSelection()?.removeAllRanges(); // 清除选区
+    }
+}
+/**
+ * Creates a fake textarea element with a value.
+ * @param {String} value
+ * @return {HTMLElement}
+ */
+function createFakeElement(value) {
+    const isRTL = document.documentElement.getAttribute('dir') === 'rtl';
+    const fakeElement = document.createElement('textarea');
+    // Prevent zooming on iOS
+    fakeElement.style.fontSize = '12pt';
+    // Reset box model
+    fakeElement.style.border = '0';
+    fakeElement.style.padding = '0';
+    fakeElement.style.margin = '0';
+    // Move element out of screen horizontally
+    fakeElement.style.position = 'absolute';
+    fakeElement.style[isRTL ? 'right' : 'left'] = '-9999px';
+    // Move element to the same position vertically
+    const yPosition = window.pageYOffset || document.documentElement.scrollTop;
+    fakeElement.style.top = `${yPosition}px`;
+    fakeElement.setAttribute('readonly', '');
+    fakeElement.value = value;
+    return fakeElement;
+}
+
+/**
+ * 获取cookie
+ * @param {string} name
+ * @returns {string}
+ */
+function cookieGet(name) {
+    const { cookie } = document;
+    if (!cookie)
+        return '';
+    const result = cookie.split(';');
+    for (let i = 0; i < result.length; i++) {
+        const item = result[i];
+        const [key, val = ''] = item.split('=');
+        if (key === name)
+            return decodeURIComponent(val);
+    }
+    return '';
+}
+/**
+ * 设置 cookie
+ * @param {string} name
+ * @param {string} value
+ * @param {number | Date} [maxAge]
+ */
+function cookieSet(name, value, maxAge) {
+    const metas = [];
+    const EXPIRES = 'expires';
+    metas.push([name, encodeURIComponent(value)]);
+    if (isNumber(maxAge)) {
+        const d = new Date();
+        d.setTime(d.getTime() + maxAge);
+        metas.push([EXPIRES, d.toUTCString()]);
+    }
+    else if (isDate(maxAge)) {
+        metas.push([EXPIRES, maxAge.toUTCString()]);
+    }
+    metas.push(['path', '/']);
+    document.cookie = metas
+        .map(item => {
+        const [key, val] = item;
+        return `${key}=${val}`;
+    })
+        .join(';');
+}
+/**
+ * 删除单个 cookie
+ * @param name cookie 名称
+ */
+const cookieDel = (name) => cookieSet(name, '', -1);
+
+const isValidDate = (any) => isDate(any) && !isNaN(any.getTime());
+/* istanbul ignore next */
+const guessDateSeparator = (value) => {
+    if (!isString(value))
+        return;
+    const value2 = value.replace(/-/g, '/');
+    return new Date(value2);
+};
+/* istanbul ignore next */
+const guessDateTimezone = (value) => {
+    if (!isString(value))
+        return;
+    const re = /([+-])(\d\d)(\d\d)$/;
+    const matches = re.exec(value);
+    if (!matches)
+        return;
+    const value2 = value.replace(re, 'Z');
+    const d = new Date(value2);
+    if (!isValidDate(d))
+        return;
+    const [, flag, hours, minutes] = matches;
+    const hours2 = parseInt(hours, 10);
+    const minutes2 = parseInt(minutes, 10);
+    const offset = (a, b) => (flag === '+' ? a - b : a + b);
+    d.setHours(offset(d.getHours(), hours2));
+    d.setMinutes(offset(d.getMinutes(), minutes2));
+    return d;
+};
+/**
+ * 解析为Date对象
+ * @param {DateValue} value - 可以是数值、字符串或 Date 对象
+ * @returns {Date} - 转换后的目标Date
+ */
+function dateParse(value) {
+    const d1 = new Date(value);
+    if (isValidDate(d1))
+        return d1;
+    // safari 浏览器的日期解析有问题
+    // new Date('2020-06-26 18:06:15') 返回值是一个非法日期对象
+    /* istanbul ignore next */
+    const d2 = guessDateSeparator(value);
+    /* istanbul ignore next */
+    if (isValidDate(d2))
+        return d2;
+    // safari 浏览器的日期解析有问题
+    // new Date('2020-06-26T18:06:15.000+0800') 返回值是一个非法日期对象
+    /* istanbul ignore next */
+    const d3 = guessDateTimezone(value);
+    /* istanbul ignore next */
+    if (isValidDate(d3))
+        return d3;
+    throw new SyntaxError(`${value.toString()} 不是一个合法的日期描述`);
+}
+/**
+ * 格式化为日期对象(带自定义格式化模板)
+ * @param {DateValue} value 可以是数值、字符串或 Date 对象
+ * @param {string} [format] 模板，默认是 YYYY-MM-DD HH:mm:ss，模板字符：
+ * - YYYY：年
+ * - yyyy: 年
+ * - MM：月
+ * - DD：日
+ * - dd: 日
+ * - HH：时（24 小时制）
+ * - hh：时（12 小时制）
+ * - mm：分
+ * - ss：秒
+ * - SSS：毫秒
+ * @returns {string}
+ */
+// export const dateStringify = (value: DateValue, format = 'YYYY-MM-DD HH:mm:ss'): string => {
+//   const date = dateParse(value);
+//   let fmt = format;
+//   let ret;
+//   const opt: DateObj = {
+//     'Y+': `${date.getFullYear()}`, // 年
+//     'y+': `${date.getFullYear()}`, // 年
+//     'M+': `${date.getMonth() + 1}`, // 月
+//     'D+': `${date.getDate()}`, // 日
+//     'd+': `${date.getDate()}`, // 日
+//     'H+': `${date.getHours()}`, // 时
+//     'm+': `${date.getMinutes()}`, // 分
+//     's+': `${date.getSeconds()}`, // 秒
+//     'S+': `${date.getMilliseconds()}` // 豪秒
+//   };
+//   for (const k in opt) {
+//     ret = new RegExp(`(${k})`).exec(fmt);
+//     if (ret) {
+//       fmt = fmt.replace(ret[1], ret[1].length === 1 ? opt[k] : opt[k].padStart(ret[1].length, '0'));
+//     }
+//   }
+//   return fmt;
+// };
+/**
+ * 将日期转换为一天的开始时间，即0点0分0秒0毫秒
+ * @param {DateValue} value
+ * @returns {Date}
+ */
+function dateToStart(value) {
+    const d = dateParse(value);
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate(), 0, 0, 0, 0);
+}
+/**
+ * 将日期转换为一天的结束时间，即23点59分59秒999毫秒
+ * @param {DateValue} value
+ * @returns {Date}
+ */
+function dateToEnd(value) {
+    const d = dateToStart(value);
+    d.setDate(d.getDate() + 1);
+    return dateParse(d.getTime() - 1);
+}
+/**
+ * 格式化为日期对象(带自定义格式化模板)
+ * @param {Date} value - 可以是数值、字符串或 Date 对象
+ * @param {string} [format] - 模板，默认是 YYYY-MM-DD HH:mm:ss，模板字符：
+ * - YYYY：年
+ * - yyyy: 年
+ * - MM：月
+ * - DD：日
+ * - dd: 日
+ * - HH：时（24 小时制）
+ * - mm：分
+ * - ss：秒
+ * - SSS：毫秒
+ * - ww: 周
+ * @returns {string}  格式化后的日期字符串
+ */
+function formatDate(value, format = 'YYYY-MM-DD HH:mm:ss') {
+    const date = dateParse(value);
+    let fmt = format;
+    let ret;
+    const opt = {
+        'Y+': `${date.getFullYear()}`,
+        'y+': `${date.getFullYear()}`,
+        'M+': `${date.getMonth() + 1}`,
+        'D+': `${date.getDate()}`,
+        'd+': `${date.getDate()}`,
+        'H+': `${date.getHours()}`,
+        'm+': `${date.getMinutes()}`,
+        's+': `${date.getSeconds()}`,
+        'S+': `${date.getMilliseconds()}`,
+        'w+': ['周日', '周一', '周二', '周三', '周四', '周五', '周六'][date.getDay()] // 周
+        // 有其他格式化字符需求可以继续添加，必须转化成字符串
+    };
+    for (const k in opt) {
+        ret = new RegExp('(' + k + ')').exec(fmt);
+        if (ret) {
+            fmt = fmt.replace(ret[1], ret[1].length === 1 ? opt[k] : opt[k].padStart(ret[1].length, '0'));
+        }
+    }
+    return fmt;
+}
+/**
+ * 计算向前或向后N天的具体日期
+ * @param {DateValue} originDate - 参考日期
+ * @param {number} n - 正数：向后推算；负数：向前推算
+ * @param {string} sep - 日期格式的分隔符
+ * @returns {string} 计算后的目标日期
+ */
+function calculateDate(originDate, n, sep = '-') {
+    //originDate 为字符串日期 如:'2019-01-01' n为你要传入的参数，当前为0，前一天为-1，后一天为1
+    const date = new Date(originDate); //这边给定一个特定时间
+    const newDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const millisecondGap = newDate.getTime() + 1000 * 60 * 60 * 24 * parseInt(String(n)); //计算前几天用减，计算后几天用加，最后一个就是多少天的数量
+    const targetDate = new Date(millisecondGap);
+    const finalNewDate = targetDate.getFullYear() +
+        sep +
+        String(targetDate.getMonth() + 1).padStart(2, '0') +
+        '-' +
+        String(targetDate.getDate()).padStart(2, '0');
+    return finalNewDate;
+}
+/**
+ * 计算向前或向后N天的具体日期时间
+ * @param {DateValue} originDateTime - 参考日期时间
+ * @param {number} n - 正数：向后推算；负数：向前推算
+ * @param {string} dateSep - 日期分隔符
+ * @param {string} timeSep - 时间分隔符
+ * @returns {string} 转换后的目标日期时间
+ */
+function calculateDateTime(originDateTime, n, dateSep = '-', timeSep = ':') {
+    const date = new Date(originDateTime);
+    const separator1 = dateSep;
+    const separator2 = timeSep;
+    const dateTime = new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds());
+    const millisecondGap = dateTime.getTime() + 1000 * 60 * 60 * 24 * parseInt(String(n)); //计算前几天用减，计算后几天用加，最后一个就是多少天的数量
+    const targetDateTime = new Date(millisecondGap);
+    return (targetDateTime.getFullYear() +
+        separator1 +
+        String(targetDateTime.getMonth() + 1).padStart(2, '0') +
+        separator1 +
+        String(targetDateTime.getDate()).padStart(2, '0') +
+        ' ' +
+        String(targetDateTime.getHours()).padStart(2, '0') +
+        separator2 +
+        String(targetDateTime.getMinutes()).padStart(2, '0') +
+        separator2 +
+        String(targetDateTime.getSeconds()).padStart(2, '0'));
+}
+
+/**
+ * 标准化路径
+ * @param {string} path
+ * @returns {string}
+ */
+const pathNormalize = (path) => {
+    const slices = path
+        .replace(/\\/g, '/')
+        .replace(/\/{2,}/g, '/')
+        .replace(/\.{3,}/g, '..')
+        .replace(/\/\.\//g, '/')
+        .split('/')
+        .map(point => point.trim());
+    const isCurrentSlice = (slice) => slice === '.';
+    const isParentSlice = (slice) => slice === '..';
+    const points = [];
+    let inPoints = false;
+    const push = (point) => {
+        points.push(point);
+    };
+    const back = () => {
+        if (points.length === 0)
+            return;
+        const lastSlice = points[points.length - 1];
+        if (isParentSlice(lastSlice)) {
+            points.push('..');
+        }
+        else {
+            points.pop();
+        }
+    };
+    slices.forEach(slice => {
+        const isCurrent = isCurrentSlice(slice);
+        const isParent = isParentSlice(slice);
+        // 未进入实际路径
+        if (!inPoints) {
+            push(slice);
+            inPoints = !isCurrent && !isParent;
+            return;
+        }
+        if (isCurrent)
+            return;
+        if (isParent)
+            return back();
+        push(slice);
+    });
+    return points.join('/');
+};
+/**
+ * 路径合并
+ * @param {string} from
+ * @param {string} to
+ * @returns {string}
+ */
+const pathJoin = (from, ...to) => pathNormalize([from, ...to].join('/'));
+
+/**
+ * 解析查询参数，内部使用的是浏览器内置的 URLSearchParams 进行处理
+ * @param {string} queryString
+ * @returns {Params}
+ */
+function qsParse(queryString) {
+    const params = new URLSearchParams(queryString);
+    const result = {};
+    for (const [key, val] of params.entries()) {
+        if (isUndefined(result[key])) {
+            result[key] = val;
+            continue;
+        }
+        if (isArray(result[key])) {
+            continue;
+        }
+        result[key] = params.getAll(key);
+    }
+    return result;
+}
+const defaultReplacer = (val) => {
+    if (isString(val))
+        return val;
+    if (isNumber(val))
+        return String(val);
+    if (isBoolean(val))
+        return val ? 'true' : 'false';
+    if (isDate(val))
+        return val.toISOString();
+    return null;
+};
+/**
+ * 字符化查询对象，内部使用的是浏览器内置的 URLSearchParams 进行处理
+ * @param {LooseParams} query
+ * @param {Replacer} replacer
+ * @returns {string}
+ */
+function qsStringify(query, replacer = defaultReplacer) {
+    const params = new URLSearchParams();
+    objectEach(query, (val, key) => {
+        if (isArray(val)) {
+            val.forEach(i => {
+                const replaced = replacer(i);
+                if (replaced === null)
+                    return;
+                params.append(key.toString(), replaced);
+            });
+        }
+        else {
+            const replaced = replacer(val);
+            if (replaced === null)
+                return;
+            params.set(key.toString(), replaced);
+        }
+    });
+    return params.toString();
+}
+
+/**
+ * url 解析
+ * @param {string} url
+ * @param {boolean} isModernApi 使用现代API:URL, 默认true (对无效url解析会抛错), 否则使用a标签来解析（兼容性更强）
+ * @returns {Url}
+ */
+const urlParse = (url, isModernApi = true) => {
+    // @ts-ignore
+    let urlObj = null;
+    if (isFunction(URL) && isModernApi) {
+        urlObj = new URL(url);
+    }
+    else {
+        urlObj = document.createElement('a');
+        urlObj.href = url;
+    }
+    const { protocol, username, password, host, port, hostname, hash, search, pathname: _pathname } = urlObj;
+    // fix: ie 浏览器下，解析出来的 pathname 是没有 / 根的
+    const pathname = pathJoin('/', _pathname);
+    const auth = username && password ? `${username}:${password}` : '';
+    const query = search.replace(/^\?/, '');
+    const searchParams = qsParse(query);
+    const path = `${pathname}${search}`;
+    urlObj = null;
+    return {
+        protocol,
+        auth,
+        username,
+        password,
+        host,
+        port,
+        hostname,
+        hash,
+        search,
+        searchParams,
+        query,
+        pathname,
+        path,
+        href: url
+    };
+};
+/**
+ * url 字符化，url 对象里的 searchParams 会覆盖 url 原有的查询参数
+ * @param {Url} url
+ * @returns {string}
+ */
+const urlStringify = (url) => {
+    const { protocol, auth, host, pathname, searchParams, hash } = url;
+    const authorize = auth ? `${auth}@` : '';
+    const querystring = qsStringify(searchParams);
+    const search = querystring ? `?${querystring}` : '';
+    let hashstring = hash.replace(/^#/, '');
+    hashstring = hashstring ? '#' + hashstring : '';
+    return `${protocol}//${authorize}${host}${pathname}${search}${hashstring}`;
+};
+/**
+ * 设置 url 查询参数
+ * @param {string} url
+ * @param {AnyObject} setter
+ * @returns {string}
+ */
+const urlSetParams = (url, setter) => {
+    const p = urlParse(url);
+    Object.assign(p.searchParams, setter);
+    return urlStringify(p);
+};
+/**
+ * 删除 url 查询参数
+ * @param {string} url
+ * @param {string[]} removeKeys
+ * @returns {string}
+ */
+const urlDelParams = (url, removeKeys) => {
+    const p = urlParse(url);
+    removeKeys.forEach(key => delete p.searchParams[key]);
+    return urlStringify(p);
+};
+
+/**
+ * 通过打开新窗口的方式下载
+ * @param {string} url
+ * @param {LooseParams} params
+ */
+function downloadURL(url, params) {
+    window.open(params ? urlSetParams(url, params) : url);
+}
+/**
+ * 通过 A 链接的方式下载
+ * @param {string} href
+ * @param {string} filename
+ * @param {Function} callback
+ */
+function downloadHref(href, filename, callback) {
+    let eleLink = document.createElement('a');
+    eleLink.download = filename;
+    eleLink.style.display = 'none';
+    eleLink.href = href;
+    document.body.appendChild(eleLink);
+    eleLink.click();
+    setTimeout(() => {
+        document.body.removeChild(eleLink);
+        // @ts-ignore
+        eleLink = null;
+        if (isFunction(callback)) {
+            callback();
+        }
+    });
+}
+/**
+ * 将大文件对象通过 A 链接的方式下载
+ * @param {Blob} blob
+ * @param {string} filename
+ * @param {Function} callback
+ */
+function downloadBlob(blob, filename, callback) {
+    const objURL = URL.createObjectURL(blob);
+    downloadHref(objURL, filename);
+    setTimeout(() => {
+        URL.revokeObjectURL(objURL);
+        if (isFunction(callback)) {
+            callback();
+        }
+    });
+}
+/**
+ * 根据URL下载文件（解决跨域a.download不生效问题)
+ *
+ * 可定制下载成功的状态码status(浏览器原生状态码)
+ *
+ * 支持下载操作成功、失败后的回调
+ * @param {string} url
+ * @param {string} filename
+ * @param {CrossOriginDownloadParams} options
+ */
+function crossOriginDownload(url, filename, options) {
+    const { successCode = 200, successCallback, failCallback } = isNullOrUnDef(options) ? { successCode: 200, successCallback: void 0, failCallback: void 0 } : options;
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.responseType = 'blob';
+    xhr.onload = function () {
+        if (xhr.status === successCode)
+            downloadBlob(xhr.response, filename, successCallback);
+        else if (isFunction(failCallback)) {
+            const status = xhr.status;
+            const responseType = xhr.getResponseHeader('Content-Type');
+            if (isString(responseType) && responseType.includes('application/json')) {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    failCallback({ status, response: reader.result });
+                };
+                reader.readAsText(xhr.response);
+            }
+            else {
+                failCallback(xhr);
+            }
+        }
+    };
+    xhr.onerror = e => {
+        if (isFunction(failCallback)) {
+            failCallback({ status: 0, code: 'ERROR_CONNECTION_REFUSED' });
+        }
+    };
+    xhr.send();
+}
+/**
+ * 将指定数据格式通过 A 链接的方式下载
+ * @param {AnyObject | AnyObject[]} data
+ * @param {FileType} fileType 支持 json/csv/xls/xlsx 四种格式
+ * @param {string} filename
+ * @param {string[]} [headers]
+ */
+function downloadData(data, fileType, filename, headers) {
+    filename = filename.replace(`.${fileType}`, '') + `.${fileType}`;
+    if (fileType === 'json') {
+        const blob = new Blob([JSON.stringify(data, null, 4)]);
+        downloadBlob(blob, filename);
+    }
+    else {
+        // xlsx实际生成的也为csv，仅后缀名名不同
+        if (!headers || !headers.length)
+            throw new Error('未传入表头数据');
+        if (!Array.isArray(data))
+            throw new Error('data error! expected array!');
+        const headerStr = headers.join(',') + '\n';
+        let bodyStr = '';
+        data.forEach(row => {
+            // \t防止数字被科学计数法显示
+            bodyStr += Object.values(row).join(',\t') + ',\n';
+        });
+        const MIMETypes = {
+            csv: 'text/csv',
+            xls: 'application/vnd.ms-excel',
+            xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+        };
+        // encodeURIComponent解决中文乱码
+        const href = 'data:' + MIMETypes[fileType] + ';charset=utf-8,\ufeff' + encodeURIComponent(headerStr + bodyStr);
+        downloadHref(href, filename);
+    }
+}
+
+/**
+ * 等待一段时间
+ * @param {number} timeout 等待时间，单位毫秒
+ * @returns {Promise<void>}
+ */
+function wait(timeout = 1) {
+    return new Promise(resolve => setTimeout(resolve, timeout));
+}
+/**
+ * 异步遍历
+ * @ref https://github.com/Kevnz/async-tools/blob/master/src/mapper.js
+ * @ref https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/@@iterator
+ * @param {Array<T>} list
+ * @param {(val: T, idx: number, list: ArrayLike<T>) => Promise<R>} mapper
+ * @param {number} concurrency 并发数量，默认无限
+ * @returns {Promise<R[]>}
+ */
+function asyncMap(list, mapper, concurrency = Infinity) {
+    return new Promise((resolve, reject) => {
+        const iterator = list[Symbol.iterator]();
+        const limit = Math.min(list.length, concurrency);
+        const resolves = [];
+        let resolvedLength = 0;
+        let rejected;
+        let index = 0;
+        const next = () => {
+            if (rejected)
+                return reject(rejected);
+            const it = iterator.next();
+            if (it.done) {
+                if (resolvedLength === list.length)
+                    resolve(resolves);
+                return;
+            }
+            const current = index++;
+            mapper(it.value, current, list)
+                .then(value => {
+                resolvedLength++;
+                resolves[current] = value;
+                next();
+            })
+                .catch(err => {
+                rejected = err;
+                next();
+            });
+        };
+        // 开始
+        for (let i = 0; i < limit; i++) {
+            next();
+        }
+    });
+}
+/**
+ * Execute a promise safely
+ *
+ * @param { Promise } promise
+ * @param { Object= } errorExt - Additional Information you can pass safeAwait the err object
+ * @return { Promise }
+ * @example
+ * async function asyncTaskWithCb(cb) {
+     let err, user, savedTask, notification;
+
+     [ err, user ] = await safeAwait(UserModel.findById(1));
+     if(!user) return cb('No user found');
+
+     [ err, savedTask ] = await safeAwait(TaskModel({userId: user.id, name: 'Demo Task'}));
+     if(err) return cb('Error occurred while saving task')
+
+    cb(null, savedTask);
+}
+ */
+function safeAwait(promise, errorExt) {
+    return promise
+        .then((data) => [null, data])
+        .catch((err) => {
+        if (errorExt) {
+            const parsedError = Object.assign({}, err, errorExt);
+            return [parsedError, undefined];
+        }
+        return [err, undefined];
+    });
+}
+
+/**
+ * 判断是否支持canvas
+ * @returns {boolean}
+ */
+function supportCanvas() {
+    return !!document.createElement('canvas').getContext;
+}
+/**
+ * 选择本地文件
+ * @param {string} accept 上传的文件类型，用于过滤
+ * @param {Function} changeCb 选择文件回调
+ * @returns {HTMLInputElement}
+ */
+function chooseLocalFile(accept, changeCb) {
+    let inputObj = document.createElement('input');
+    inputObj.setAttribute('id', String(Date.now()));
+    inputObj.setAttribute('type', 'file');
+    inputObj.setAttribute('style', 'visibility:hidden');
+    inputObj.setAttribute('accept', accept);
+    document.body.appendChild(inputObj);
+    inputObj.click();
+    // @ts-ignore
+    inputObj.onchange = (e) => {
+        changeCb(e.target.files);
+        setTimeout(() => {
+            document.body.removeChild(inputObj);
+            // @ts-ignore
+            inputObj = null;
+        });
+    };
+}
+/**
+ * 计算图片压缩后的尺寸
+ *
+ * @param {number} maxWidth
+ * @param {number} maxHeight
+ * @param {number} originWidth
+ * @param {number} originHeight
+ * @returns {*}
+ */
+function calculateSize({ maxWidth, maxHeight, originWidth, originHeight }) {
+    let width = originWidth, height = originHeight;
+    // 图片尺寸超过限制
+    if (originWidth > maxWidth || originHeight > maxHeight) {
+        if (originWidth / originHeight > maxWidth / maxHeight) {
+            // 更宽，按照宽度限定尺寸
+            width = maxWidth;
+            height = Math.round(maxWidth * (originHeight / originWidth));
+        }
+        else {
+            height = maxHeight;
+            width = Math.round(maxHeight * (originWidth / originHeight));
+        }
+    }
+    return { width, height };
+}
+/**
+ * 根据原始图片的不同尺寸计算等比例缩放后的宽高尺寸
+ *
+ * @param {number} sizeKB Image volume size, unit KB
+ * @param {number} maxSize Image max size
+ * @param {number} originWidth Image original width, unit px
+ * @param {number} originHeight Image original height, unit px
+ * @returns {*} {width, height}
+ */
+function scalingByAspectRatio({ sizeKB, maxSize, originWidth, originHeight }) {
+    let targetWidth = originWidth, targetHeight = originHeight;
+    if (isNumber(maxSize)) {
+        const { width, height } = calculateSize({ maxWidth: maxSize, maxHeight: maxSize, originWidth, originHeight });
+        targetWidth = width;
+        targetHeight = height;
+    }
+    else if (sizeKB < 500) {
+        // [50KB, 500KB)
+        const maxWidth = 1200, maxHeight = 1200;
+        const { width, height } = calculateSize({ maxWidth, maxHeight, originWidth, originHeight });
+        targetWidth = width;
+        targetHeight = height;
+    }
+    else if (sizeKB < 5 * 1024) {
+        // [500KB, 5MB)
+        const maxWidth = 1400, maxHeight = 1400;
+        const { width, height } = calculateSize({ maxWidth, maxHeight, originWidth, originHeight });
+        targetWidth = width;
+        targetHeight = height;
+    }
+    else if (sizeKB < 10 * 1024) {
+        // [5MB, 10MB)
+        const maxWidth = 1600, maxHeight = 1600;
+        const { width, height } = calculateSize({ maxWidth, maxHeight, originWidth, originHeight });
+        targetWidth = width;
+        targetHeight = height;
+    }
+    else if (10 * 1024 <= sizeKB) {
+        // [10MB, Infinity)
+        const maxWidth = originWidth > 15000 ? 8192 : originWidth > 10000 ? 4096 : 2048, maxHeight = originHeight > 15000 ? 8192 : originHeight > 10000 ? 4096 : 2048;
+        const { width, height } = calculateSize({ maxWidth, maxHeight, originWidth, originHeight });
+        targetWidth = width;
+        targetHeight = height;
+    }
+    return { width: targetWidth, height: targetHeight };
+}
+/**
+ * Web端：等比例压缩图片批量处理 (小于minFileSizeKB：50，不压缩), 支持压缩全景图或长截图
+ *
+ *        1. 默认根据图片原始size及宽高适当地调整quality、width、height
+ *        2. 可指定压缩的图片质量 quality（若不指定则根据原始图片大小来计算）, 来适当调整width、height
+ *        3. 可指定压缩的图片最大宽高 maxSize（若不指定则根据原始图片宽高来计算）, 满足大屏幕图片展示的场景
+ *
+ * @param {File | FileList} file 图片或图片数组
+ * @param {ICompressOptions} options 压缩图片配置项，default: {mime:'image/jpeg', minFileSizeKB: 50}
+ * @returns {Promise<ICompressImgResult | ICompressImgResult[] | null>}
+ */
+function compressImg(file, options = { mime: 'image/jpeg', minFileSizeKB: 50 }) {
+    if (!(file instanceof File || file instanceof FileList)) {
+        throw new Error(`${file} require be File or FileList`);
+    }
+    else if (!supportCanvas()) {
+        throw new Error(`Current runtime environment not support Canvas`);
+    }
+    const { quality, mime = 'image/jpeg', maxSize: size, minFileSizeKB = 50 } = isObject(options) ? options : {};
+    let targetQuality = quality, maxSize;
+    if (quality) {
+        targetQuality = quality;
+    }
+    else if (file instanceof File) {
+        const sizeKB = +parseInt((file.size / 1024).toFixed(2));
+        if (sizeKB < minFileSizeKB) {
+            targetQuality = 1;
+        }
+        else if (sizeKB < 1 * 1024) {
+            targetQuality = 0.85;
+        }
+        else if (sizeKB < 5 * 1024) {
+            targetQuality = 0.8;
+        }
+        else {
+            targetQuality = 0.75;
+        }
+    }
+    if (isNumber(size)) {
+        maxSize = size >= 1200 ? size : 1200;
+    }
+    if (file instanceof FileList) {
+        return Promise.all(Array.from(file).map(el => compressImg(el, { maxSize, mime: mime, quality: targetQuality }))); // 如果是 file 数组返回 Promise 数组
+    }
+    else if (file instanceof File) {
+        return new Promise(resolve => {
+            const ext = {
+                'image/webp': 'webp',
+                'image/jpeg': 'jpg',
+                'image/png': 'png'
+            };
+            const fileName = [...file.name.split('.').slice(0, -1), ext[mime]].join('.');
+            const sizeKB = +parseInt((file.size / 1024).toFixed(2));
+            if (sizeKB < minFileSizeKB) {
+                resolve({
+                    file: file
+                });
+            }
+            else {
+                const reader = new FileReader(); // 创建 FileReader
+                // @ts-ignore
+                reader.onload = ({ target: { result: src } }) => {
+                    const image = new Image(); // 创建 img 元素
+                    image.onload = () => {
+                        const canvas = document.createElement('canvas'); // 创建 canvas 元素
+                        const context = canvas.getContext('2d');
+                        const originWidth = image.width;
+                        const originHeight = image.height;
+                        const { width, height } = scalingByAspectRatio({ sizeKB, maxSize, originWidth, originHeight });
+                        canvas.width = width;
+                        canvas.height = height;
+                        context.clearRect(0, 0, width, height);
+                        context.drawImage(image, 0, 0, width, height); // 绘制 canvas
+                        const canvasURL = canvas.toDataURL(mime, targetQuality);
+                        const buffer = atob(canvasURL.split(',')[1]);
+                        let length = buffer.length;
+                        const bufferArray = new Uint8Array(new ArrayBuffer(length));
+                        while (length--) {
+                            bufferArray[length] = buffer.charCodeAt(length);
+                        }
+                        const miniFile = new File([bufferArray], fileName, {
+                            type: mime
+                        });
+                        resolve({
+                            file: miniFile,
+                            bufferArray,
+                            origin: file,
+                            beforeSrc: src,
+                            afterSrc: canvasURL,
+                            beforeKB: sizeKB,
+                            afterKB: Number((miniFile.size / 1024).toFixed(2))
+                        });
+                    };
+                    image.src = src;
+                };
+                reader.readAsDataURL(file);
+            }
+        });
+    }
+    return Promise.resolve(null);
+}
+
+/*
+ * @created: Saturday, 2020-04-18 14:38:23
+ * @author: chendq
+ * ---------
+ * @desc 网页加水印的工具类
+ */
+/**
+ * canvas 实现 水印, 具备防删除功能
+ * @param {ICanvasWM} canvasWM
+ * @example genCanvasWM({ content: 'QQMusicFE' })
+ */
+function genCanvasWM(content = '请勿外传', canvasWM) {
+    const { rootContainer = document.body, width = '300px', height = '150px', textAlign = 'center', textBaseline = 'middle', font = '20px PingFangSC-Medium,PingFang SC', 
+    // fontWeight = 500,
+    fillStyle = 'rgba(189, 177, 167, .3)', rotate = -20, zIndex = 2147483647, watermarkId = '__wm' } = isNullOrUnDef(canvasWM) ? {} : canvasWM;
+    const container = isString(rootContainer) ? document.querySelector(rootContainer) : rootContainer;
+    if (!container) {
+        throw new Error(`${rootContainer} is not valid Html Element or element selector`);
+    }
+    const canvas = document.createElement('canvas');
+    canvas.setAttribute('width', width);
+    canvas.setAttribute('height', height);
+    const ctx = canvas.getContext('2d');
+    ctx.textAlign = textAlign;
+    ctx.textBaseline = textBaseline;
+    ctx.font = font;
+    // ctx!.fontWeight = fontWeight;
+    ctx.fillStyle = fillStyle;
+    ctx.rotate((Math.PI / 180) * rotate);
+    ctx.fillText(content, parseFloat(width) / 4, parseFloat(height) / 2);
+    const base64Url = canvas.toDataURL();
+    const __wm = document.querySelector(`#${watermarkId}`);
+    const watermarkDiv = __wm || document.createElement('div');
+    const styleStr = `opacity: 1 !important; display: block !important; visibility: visible !important;         position:absolute;          left:0; top:0;         width:100%;          height:100%;          z-index:${zIndex};          pointer-events:none;          background-repeat:repeat;          background-image:url('${base64Url}')`;
+    watermarkDiv.setAttribute('style', styleStr);
+    watermarkDiv.setAttribute('id', watermarkId);
+    watermarkDiv.classList.add('nav-height');
+    if (!__wm) {
+        container.style.position = 'relative';
+        container.appendChild(watermarkDiv);
+    }
+    const getMutableStyle = (ele) => {
+        const computedStyle = getComputedStyle(ele);
+        return {
+            opacity: computedStyle.getPropertyValue('opacity'),
+            zIndex: computedStyle.getPropertyValue('z-index'),
+            display: computedStyle.getPropertyValue('display'),
+            visibility: computedStyle.getPropertyValue('visibility')
+        };
+    };
+    //@ts-ignore
+    const MutationObserver = window.MutationObserver || window.WebKitMutationObserver;
+    if (MutationObserver) {
+        let mo = new MutationObserver(function () {
+            let __wm = document.querySelector(`#${watermarkId}`); // 只在__wm元素变动才重新调用 __canvasWM
+            if (!__wm) {
+                // 避免一直触发
+                // console.log('regenerate watermark by delete::')
+                mo.disconnect();
+                mo = null;
+                genCanvasWM(content, canvasWM);
+            }
+            else {
+                const { opacity, zIndex, display, visibility } = getMutableStyle(__wm);
+                if ((__wm && __wm.getAttribute('style') !== styleStr) ||
+                    !__wm ||
+                    !(opacity === '1' && zIndex === '2147483647' && display === 'block' && visibility === 'visible')) {
+                    // 避免一直触发
+                    // console.log('regenerate watermark by inline style changed ::')
+                    mo.disconnect();
+                    mo = null;
+                    container.removeChild(__wm);
+                    // @ts-ignore
+                    __wm = null;
+                    genCanvasWM(content, canvasWM);
+                }
+            }
+        });
+        mo.observe(container, { attributes: true, subtree: true, childList: true });
+    }
+}
+
+/**
+ * 防抖函数
+ * 当函数被连续调用时，该函数并不执行，只有当其全部停止调用超过一定时间后才执行1次。
+ * 例如：上电梯的时候，大家陆陆续续进来，电梯的门不会关上，只有当一段时间都没有人上来，电梯才会关门。
+ * @param {F} func
+ * @param {number} wait
+ * @returns {DebounceFunc<F>}
+ */
+const debounce = (func, wait) => {
+    let timeout;
+    let canceled = false;
+    const f = function (...args) {
+        if (canceled)
+            return;
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            func.call(this, ...args);
+        }, wait);
+    };
+    f.cancel = () => {
+        clearTimeout(timeout);
+        canceled = true;
+    };
+    return f;
+};
+/**
+ * 节流函数
+ * 节流就是节约流量，将连续触发的事件稀释成预设评率。 比如每间隔1秒执行一次函数，无论这期间触发多少次事件。
+ * 这有点像公交车，无论在站点等车的人多不多，公交车只会按时来一班，不会来一个人就来一辆公交车。
+ * @param {F} func
+ * @param {number} wait
+ * @param {boolean} immediate
+ * @returns {ThrottleFunc<F>}
+ */
+const throttle = (func, wait, immediate) => {
+    let timeout;
+    let canceled = false;
+    let lastCalledTime = 0;
+    const f = function (...args) {
+        if (canceled)
+            return;
+        const now = Date.now();
+        const call = () => {
+            lastCalledTime = now;
+            func.call(this, ...args);
+        };
+        // 第一次执行
+        if (lastCalledTime === 0) {
+            if (immediate) {
+                return call();
+            }
+            else {
+                lastCalledTime = now;
+                return;
+            }
+        }
+        const remain = lastCalledTime + wait - now;
+        if (remain > 0) {
+            clearTimeout(timeout);
+            timeout = setTimeout(() => call(), wait);
+        }
+        else {
+            call();
+        }
+    };
+    f.cancel = () => {
+        clearTimeout(timeout);
+        canceled = true;
+    };
+    return f;
+};
+/**
+ * 单次函数
+ * @param {AnyFunc} func
+ * @returns {AnyFunc}
+ */
+const once = (func) => {
+    let called = false;
+    let result;
+    return function (...args) {
+        if (called)
+            return result;
+        called = true;
+        result = func.call(this, ...args);
+        return result;
+    };
+};
+/**
+ * 设置全局变量
+ * @param {string | number | symbol} key
+ * @param val
+ */
+function setGlobal(key, val) {
+    if (typeof globalThis !== 'undefined')
+        globalThis[key] = val;
+    else if (typeof window !== 'undefined')
+        window[key] = val;
+    else if (typeof global !== 'undefined')
+        global[key] = val;
+    else if (typeof self !== 'undefined')
+        self[key] = val;
+    else
+        throw new SyntaxError('当前环境下无法设置全局属性');
+}
+/**
+ * 获取全局变量
+ * @param {string | number | symbol} key
+ * @param val
+ */
+function getGlobal(key) {
+    if (typeof globalThis !== 'undefined')
+        return globalThis[key];
+    else if (typeof window !== 'undefined')
+        return window[key];
+    else if (typeof global !== 'undefined')
+        return global[key];
+    else if (typeof self !== 'undefined')
+        return self[key];
+}
+
+/**
+ * 随机整数
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+const randomNumber = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
+const STRING_POOL = `${STRING_ARABIC_NUMERALS}${STRING_UPPERCASE_ALPHA}${STRING_LOWERCASE_ALPHA}`;
+/**
+ * 随机字符串
+ * @param {number | string} length
+ * @param {string} pool
+ * @returns {string}
+ */
+const randomString = (length, pool) => {
+    let _length = 0;
+    let _pool = STRING_POOL;
+    if (isString(pool)) {
+        _length = length;
+        _pool = pool;
+    }
+    else if (isNumber(length)) {
+        _length = length;
+    }
+    else if (isString(length)) {
+        _pool = length;
+    }
+    let times = Math.max(_length, 1);
+    let result = '';
+    const min = 0;
+    const max = _pool.length - 1;
+    if (max < 2)
+        throw new Error('字符串池长度不能少于 2');
+    while (times--) {
+        const index = randomNumber(min, max);
+        result += _pool[index];
+    }
+    return result;
+};
+/**
+ * 优先浏览器原生能力获取 UUID v4
+ * @returns {string}
+ */
+function randomUuid() {
+    if (typeof URL === 'undefined' || !URL.createObjectURL || typeof Blob === 'undefined') {
+        const hex = '0123456789abcdef';
+        const model = 'xxxxxxxx-xxxx-4xxx-xxxx-xxxxxxxxxxxx';
+        let str = '';
+        for (let i = 0; i < model.length; i++) {
+            const rnd = randomNumber(0, 15);
+            str += model[i] == '-' || model[i] == '4' ? model[i] : hex[rnd];
+        }
+        return str;
+    }
+    return /[^/]+$/.exec(URL.createObjectURL(new Blob()).slice())[0];
+}
+
+const HEX_POOL = `${STRING_ARABIC_NUMERALS}${STRING_UPPERCASE_ALPHA}${STRING_LOWERCASE_ALPHA}`;
+const supportBigInt = typeof BigInt !== 'undefined';
+const jsbi = () => getGlobal('JSBI');
+const toBigInt = (n) => (supportBigInt ? BigInt(n) : jsbi().BigInt(n));
+const divide$1 = (x, y) => (supportBigInt ? x / y : jsbi().divide(x, y));
+const remainder = (x, y) => (supportBigInt ? x % y : jsbi().remainder(x, y));
+/**
+ * 将十进制转换成任意进制
+ * @param {number | string} decimal 十进制数值或字符串，可以是任意长度，会使用大数进行计算
+ * @param {string} [hexPool] 进制池，默认 62 进制
+ * @returns {string}
+ */
+function numberToHex(decimal, hexPool = HEX_POOL) {
+    if (hexPool.length < 2)
+        throw new Error('进制池长度不能少于 2');
+    if (!supportBigInt) {
+        throw new Error('需要安装 jsbi 模块并将 JSBI 设置为全局变量：\nimport JSBI from "jsbi"; window.JSBI = JSBI;');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    let bigInt = toBigInt(decimal);
+    const ret = [];
+    const { length } = hexPool;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const bigLength = toBigInt(length);
+    const execute = () => {
+        const y = Number(remainder(bigInt, bigLength));
+        bigInt = divide$1(bigInt, bigLength);
+        ret.unshift(hexPool[y]);
+        if (bigInt > 0) {
+            execute();
+        }
+    };
+    execute();
+    return ret.join('');
+}
+/**
+ * 将数字转换为携带单位的字符串
+ * @param {number | string} num
+ * @param {Array<string>} units
+ * @param {INumberAbbr} options default: { ratio: 1000, decimals: 0, separator: ' ' }
+ * @returns {string}
+ */
+const numberAbbr = (num, units, options = { ratio: 1000, decimals: 0, separator: ' ' }) => {
+    const { ratio = 1000, decimals = 0, separator = ' ' } = options;
+    const { length } = units;
+    if (length === 0)
+        throw new Error('At least one unit is required');
+    let num2 = Number(num);
+    let times = 0;
+    while (num2 >= ratio && times < length - 1) {
+        num2 = num2 / ratio;
+        times++;
+    }
+    const value = num2.toFixed(decimals);
+    const unit = units[times];
+    return String(value) + separator + unit;
+};
+/**
+ * Converting file size in bytes to human-readable string
+ *  reference: https://zh.wikipedia.org/wiki/%E5%8D%83%E5%AD%97%E8%8A%82
+ * @param {number | string} num bytes Number in Bytes
+ * @param {IHumanFileSizeOptions} options default: { decimals = 0, si = false, separator = ' ' }
+ *        si: True to use metric (SI) units, aka powers of 1000, the units is
+ *            ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'].
+ *            False to use binary (IEC), aka powers of 1024, the units is
+ *            ['Byte', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']
+ * @returns
+ */
+function humanFileSize(num, options = { decimals: 0, si: false, separator: ' ' }) {
+    const { decimals = 0, si = false, separator = ' ', baseUnit, maxUnit } = options;
+    let units = si
+        ? ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+        : ['Byte', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+    if (!isNullOrUnDef(baseUnit)) {
+        const targetIndex = units.findIndex(el => el === baseUnit);
+        if (targetIndex !== -1) {
+            units = units.slice(targetIndex);
+        }
+    }
+    if (!isNullOrUnDef(maxUnit)) {
+        const targetIndex = units.findIndex(el => el === maxUnit);
+        if (targetIndex !== -1) {
+            units.splice(targetIndex + 1);
+        }
+    }
+    return numberAbbr(num, units, { ratio: si ? 1000 : 1024, decimals, separator });
+}
+/**
+ * 将数字格式化成千位分隔符显示的字符串
+ * @param {number|string} num 数字
+ * @param {number} decimals 格式化成指定小数位精度的参数
+ * @returns {string}
+ */
+function formatNumber(num, decimals) {
+    if (isNullOrUnDef(decimals)) {
+        return parseInt(String(num)).toLocaleString();
+    }
+    let prec = 0;
+    if (!isNumber(decimals)) {
+        throw new Error('Decimals must be a positive number not less than zero');
+    }
+    else if (decimals > 0) {
+        prec = decimals;
+    }
+    return Number(Number(num).toFixed(prec)).toLocaleString('en-US');
+}
+
+const padStartWithZero = (str, maxLength = 2) => String(str).padStart(maxLength, '0');
+let safeNo = 0;
+let lastTimestamp = 0;
+// 安全后缀长度，按 1 毫秒运算 99999 次 JS 代码来进行估算
+// 那么，补足长度为 5
+// 时间戳模式长度为 13
+// 取最长 5 + 13 = 18
+const UNIQUE_NUMBER_SAFE_LENGTH = 18;
+const FIX_SAFE_LENGTH = 5;
+const TIMESTAMP_LENGTH = 13;
+/**
+ * 生成唯一不重复数值
+ * @param {number} length
+ * @returns {string}
+ */
+const uniqueNumber = (length = UNIQUE_NUMBER_SAFE_LENGTH) => {
+    const now = Date.now();
+    length = Math.max(length, UNIQUE_NUMBER_SAFE_LENGTH);
+    if (now !== lastTimestamp) {
+        lastTimestamp = now;
+        safeNo = 0;
+    }
+    const timestamp = `${now}`;
+    let random = '';
+    const rndLength = length - FIX_SAFE_LENGTH - TIMESTAMP_LENGTH;
+    if (rndLength > 0) {
+        const rndMin = 10 ** (rndLength - 1);
+        const rndMax = 10 ** rndLength - 1;
+        const rnd = randomNumber(rndMin, rndMax);
+        random = `${rnd}`;
+    }
+    const safe = padStartWithZero(safeNo, FIX_SAFE_LENGTH);
+    safeNo++;
+    return `${timestamp}${random}${safe}`;
+};
+const randomFromPool = (pool) => {
+    const poolIndex = randomNumber(0, pool.length - 1);
+    return pool[poolIndex];
+};
+/**
+ * 生成唯一不重复字符串
+ * @param {number | string} length
+ * @param {string} pool
+ * @returns {string}
+ */
+const uniqueString = (length, pool) => {
+    let _length = 0;
+    let _pool = HEX_POOL;
+    if (isString(pool)) {
+        _length = length;
+        _pool = pool;
+    }
+    else if (isNumber(length)) {
+        _length = length;
+    }
+    else if (isString(length)) {
+        _pool = length;
+    }
+    let uniqueString = numberToHex(uniqueNumber(), _pool);
+    let insertLength = _length - uniqueString.length;
+    if (insertLength <= 0)
+        return uniqueString;
+    while (insertLength--) {
+        uniqueString += randomFromPool(_pool);
+    }
+    return uniqueString;
+};
+
+/**
+ * 自定义的 tooltip, 支持鼠标移动动悬浮提示
+ * @Desc 自定义的tooltip方法, 支持拖动悬浮提示
+ * Created by chendeqiao on 2017/5/8.
+ * @example
+ *  <span onmouseleave="handleMouseLeave('#root')"
+ *        onmousemove="handleMouseEnter({rootContainer: '#root', title: 'title content', event: event})"
+ * 		    onmouseenter="handleMouseEnter({rootContainer:'#root', title: 'title content', event: event})">
+ *    title content
+ *  </span>
+ */
+/**
+ * 自定义title提示功能的mouseenter事件句柄
+ * @param {ITooltipParams} param
+ * @returns {*}
+ */
+function handleMouseEnter({ rootContainer = '#root', title, event, bgColor = '#000', color = '#fff' }) {
+    try {
+        const $rootEl = isString(rootContainer) ? document.querySelector(rootContainer) : rootContainer;
+        if (!$rootEl) {
+            throw new Error(`${rootContainer} is not valid Html Element or element selector`);
+        }
+        let $customTitle = null;
+        const styleId = 'style-tooltip-inner1494304949567';
+        // 动态创建class样式，并加入到head中
+        if (!document.querySelector(`#${styleId}`)) {
+            const tooltipWrapperClass = document.createElement('style');
+            tooltipWrapperClass.type = 'text/css';
+            tooltipWrapperClass.id = styleId;
+            tooltipWrapperClass.innerHTML = `
+        .tooltip-inner1494304949567 {
+          max-width: 250px;
+          padding: 3px 8px;
+          color: ${color};
+          text-decoration: none;
+          border-radius: 4px;
+          text-align: left;
+          background-color: ${bgColor};
+        }
+      `;
+            document.querySelector('head').appendChild(tooltipWrapperClass);
+        }
+        $customTitle = document.querySelector('#customTitle1494304949567');
+        if ($customTitle) {
+            mouseenter($customTitle, title, event);
+        }
+        else {
+            const $contentContainer = document.createElement('div');
+            $contentContainer.id = 'customTitle1494304949567';
+            $contentContainer.style.cssText = 'z-index: 99999999; visibility: hidden; position: absolute;';
+            $contentContainer.innerHTML =
+                '<div class="tooltip-inner1494304949567" style="word-wrap: break-word; max-width: 44px;">皮肤</div>';
+            $rootEl.appendChild($contentContainer);
+            $customTitle = document.querySelector('#customTitle1494304949567');
+            if (title) {
+                //判断div显示的内容是否为空
+                mouseenter($customTitle, title, event);
+                $customTitle.style.visibility = 'visible';
+            }
+        }
+    }
+    catch (e) {
+        console.error(e.message);
+    }
+}
+/**
+ * 提示文案dom渲染的处理函数
+ * @param {HTMLDivElement} customTitle
+ * @param {string} title 提示的字符串
+ * @param {PointerEvent} e 事件对象
+ * @returns {*}
+ */
+function mouseenter($customTitle, title, e) {
+    let diffValueX = 200 + 50; //默认设置弹出div的宽度为250px
+    let x = 13;
+    const y = 23;
+    const $contentEle = $customTitle.children[0];
+    if (getStrWidthPx(title, 12) < 180 + 50) {
+        //【弹出div自适应字符串宽度】若显示的字符串占用宽度小于180，则设置弹出div的宽度为“符串占用宽度”+20
+        $contentEle.style.maxWidth = getStrWidthPx(title, 12) + 20 + 50 + 'px';
+        diffValueX = e.clientX + (getStrWidthPx(title, 12) + 50) - document.body.offsetWidth;
+    }
+    else {
+        $contentEle.style.maxWidth = '250px';
+        diffValueX = e.clientX + 230 - document.body.offsetWidth; //计算div水平方向显示的内容超出屏幕多少宽度
+    }
+    $contentEle.innerHTML = title; //html方法可解析内容中换行标签，text方法不能
+    if (diffValueX > 0) {
+        //水平方向超出可见区域时
+        x -= diffValueX;
+    }
+    $customTitle.style.top = e.clientY + y + 'px';
+    $customTitle.style.left = e.clientX + x + 'px';
+    $customTitle.style.maxWidth = '250px';
+    const diffValueY = $customTitle.getBoundingClientRect().top + $contentEle.offsetHeight - document.body.offsetHeight;
+    if (diffValueY > 0) {
+        //垂直方向超出可见区域时
+        $customTitle.style.top = e.clientY - diffValueY + 'px';
+    }
+}
+/**
+ * 移除提示文案dom的事件句柄
+ * @param {string} rootContainer
+ * @returns {*}
+ */
+function handleMouseLeave(rootContainer = '#root') {
+    const rootEl = isString(rootContainer) ? document.querySelector(rootContainer) : rootContainer;
+    let titleEl = document.querySelector('#customTitle1494304949567');
+    if (rootEl && titleEl) {
+        rootEl.removeChild(titleEl);
+        // @ts-ignore
+        titleEl = null;
+    }
+}
+const tooltipEvent = { handleMouseEnter, handleMouseLeave };
+
+const defaultFieldOptions = { keyField: 'key', childField: 'children', pidField: 'pid' };
+const defaultSearchTreeOptions = {
+    childField: 'children',
+    nameField: 'name',
+    removeEmptyChild: false,
+    ignoreCase: true
+};
+/**
+ * 树遍历函数(支持continue和break操作), 可用于遍历Array和NodeList类型的数据
+ * @param {ArrayLike<V>} tree  树形数据
+ * @param {Function} iterator  迭代函数, 返回值为true时continue, 返回值为false时break
+ * @param {options} options 支持定制子元素名称、反向遍历、广度优先遍历，默认{
+    childField: 'children',
+    reverse: false,
+    breadthFirst: false
+  }
+ * @returns {*}
+ */
+function forEachDeep(tree, iterator, options = {
+    childField: 'children',
+    reverse: false,
+    breadthFirst: false,
+    isDomNode: false
+}) {
+    const { childField = 'children', reverse = false, breadthFirst = false, isDomNode = false } = isObject(options) ? options : {};
+    let isBreak = false;
+    const queue = [];
+    const walk = (arr, parent, level = 0) => {
+        if (reverse) {
+            for (let index = arr.length - 1; index >= 0; index--) {
+                if (isBreak) {
+                    break;
+                }
+                const item = arr[index];
+                // 广度优先
+                if (breadthFirst) {
+                    queue.push({ item, index, array: arr, tree, parent, level });
+                }
+                else {
+                    const re = iterator(item, index, arr, tree, parent, level);
+                    if (re === false) {
+                        isBreak = true;
+                        break;
+                    }
+                    else if (re === true) {
+                        continue;
+                    }
+                    if (item && (isDomNode ? isNodeList(item[childField]) : Array.isArray(item[childField]))) {
+                        walk(item[childField], item, level + 1);
+                    }
+                }
+            }
+            if (breadthFirst) {
+                // Process queue
+                while (queue.length > 0 && !isBreak) {
+                    const current = queue.shift();
+                    const { item, index, array, tree, parent, level } = current;
+                    const re = iterator(item, index, array, tree, parent, level);
+                    if (re === false) {
+                        isBreak = true;
+                        break;
+                    }
+                    else if (re === true) {
+                        continue;
+                    }
+                    if (item && (isDomNode ? isNodeList(item[childField]) : Array.isArray(item[childField]))) {
+                        walk(item[childField], item, level + 1);
+                    }
+                }
+            }
+        }
+        else {
+            for (let index = 0, len = arr.length; index < len; index++) {
+                if (isBreak) {
+                    break;
+                }
+                const item = arr[index];
+                if (breadthFirst) {
+                    // 广度优先
+                    queue.push({ item, index: index, array: arr, tree, parent, level });
+                }
+                else {
+                    // 深度优先
+                    const re = iterator(item, index, arr, tree, parent, level);
+                    if (re === false) {
+                        isBreak = true;
+                        break;
+                    }
+                    else if (re === true) {
+                        continue;
+                    }
+                    if (item && (isDomNode ? isNodeList(item[childField]) : Array.isArray(item[childField]))) {
+                        walk(item[childField], item, level + 1);
+                    }
+                }
+            }
+            if (breadthFirst) {
+                while (queue.length > 0 && !isBreak) {
+                    const current = queue.shift();
+                    if (!current)
+                        break;
+                    const { item, index, array, tree, parent, level } = current;
+                    const re = iterator(item, index, array, tree, parent, level);
+                    if (re === false) {
+                        isBreak = true;
+                        break;
+                    }
+                    else if (re === true) {
+                        continue;
+                    }
+                    if (item && (isDomNode ? isNodeList(item[childField]) : Array.isArray(item[childField]))) {
+                        walk(item[childField], item, level + 1);
+                    }
+                }
+            }
+        }
+    };
+    walk(tree, null, 0);
+    // @ts-ignore
+    tree = null;
+}
+/**
+ * 创建一个新数组, 深度优先遍历的Map函数(支持continue和break操作), 可用于insert tree item 和 remove tree item
+ *
+ * 可遍历任何带有 length 属性和数字键的类数组对象
+ * @param {ArrayLike<V>} tree  树形数据
+ * @param {Function} iterator  迭代函数, 返回值为true时continue, 返回值为false时break
+ * @param {options} options 支持定制子元素名称、反向遍历，默认{
+    childField: 'children',
+    reverse: false,
+  }
+ * @returns {any[]} 新的一棵树
+ */
+function mapDeep(tree, iterator, options = {
+    childField: 'children',
+    reverse: false
+}) {
+    const { childField = 'children', reverse = false } = isObject(options) ? options : {};
+    let isBreak = false;
+    const newTree = [];
+    const walk = (arr, parent, newTree, level = 0) => {
+        if (reverse) {
+            for (let i = arr.length - 1; i >= 0; i--) {
+                if (isBreak) {
+                    break;
+                }
+                const item = arr[i];
+                const re = iterator(item, i, arr, tree, parent, level);
+                if (re === false) {
+                    isBreak = true;
+                    break;
+                }
+                else if (re === true) {
+                    continue;
+                }
+                newTree.push(objectOmit(re, [childField]));
+                if (item && Array.isArray(item[childField])) {
+                    newTree[newTree.length - 1][childField] = [];
+                    walk(item[childField], item, newTree[newTree.length - 1][childField], level + 1);
+                }
+                else {
+                    // children非有效数组时，移除该属性字段
+                    delete re[childField];
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < arr.length; i++) {
+                if (isBreak) {
+                    break;
+                }
+                const item = arr[i];
+                const re = iterator(item, i, arr, tree, parent, level);
+                if (re === false) {
+                    isBreak = true;
+                    break;
+                }
+                else if (re === true) {
+                    continue;
+                }
+                newTree.push(objectOmit(re, [childField]));
+                if (item && Array.isArray(item[childField])) {
+                    newTree[newTree.length - 1][childField] = [];
+                    walk(item[childField], item, newTree[newTree.length - 1][childField], level + 1);
+                }
+                else {
+                    // children非有效数组时，移除该属性字段
+                    delete re[childField];
+                }
+            }
+        }
+    };
+    walk(tree, null, newTree);
+    // @ts-ignore
+    tree = null;
+    return newTree;
+}
+/**
+ * 在树中找到 id 为某个值的节点，并返回上游的所有父级节点
+ *
+ * @param {ArrayLike<T>} tree - 树形数据
+ * @param {number | string} nodeId - 目标元素ID
+ * @param {ITreeConf} options - 迭代配置项, 默认：{ children = 'children', id = 'id' }
+ * @returns {[(number | string)[], V[]]} - 由parentId...childId, parentObject-childObject组成的二维数组
+ */
+function searchTreeById(tree, nodeId, options = { childField: 'children', keyField: 'id' }) {
+    const { childField = 'children', keyField = 'id' } = isObject(options) ? options : {};
+    const toFlatArray = (tree, parentId, parent) => {
+        return tree.reduce((t, _) => {
+            const child = _[childField];
+            return [
+                ...t,
+                parentId ? { ..._, parentId, parent } : _,
+                ...(child && child.length ? toFlatArray(child, _[keyField], _) : [])
+            ];
+        }, []);
+    };
+    const getIds = (flatArray) => {
+        let child = flatArray.find(_ => _[keyField] === nodeId);
+        const { parent, parentId, ...other } = child;
+        let ids = [nodeId], nodes = [other];
+        while (child && child.parentId) {
+            ids = [child.parentId, ...ids];
+            nodes = [child.parent, ...nodes];
+            child = flatArray.find(_ => _[keyField] === child.parentId); // eslint-disable-line
+        }
+        return [ids, nodes];
+    };
+    return getIds(toFlatArray(tree));
+}
+/**
+ * 扁平化数组转换成树
+ * @param {any[]} list
+ * @param {IFieldOptions} options 定制id字段名，子元素字段名，父元素字段名，默认
+ *        { keyField: 'key', childField: 'children', pidField: 'pid' }
+ * @returns {any[]}
+ */
+function formatTree(list, options = defaultFieldOptions) {
+    const { keyField = 'key', childField = 'children', pidField = 'pid' } = isObject(options) ? options : {};
+    const treeArr = [];
+    const sourceMap = {};
+    for (let i = 0, len = list.length; i < len; i++) {
+        const item = list[i];
+        sourceMap[item[keyField]] = item;
+    }
+    for (let i = 0, len = list.length; i < len; i++) {
+        const item = list[i];
+        const parent = sourceMap[item[pidField]];
+        if (parent) {
+            (parent[childField] || (parent[childField] = [])).push(item);
+        }
+        else {
+            treeArr.push(item);
+        }
+    }
+    // @ts-ignore
+    list = null;
+    return treeArr;
+}
+/**
+ * 树形结构转扁平化
+ * @param {any[]} treeList
+ * @param {IFieldOptions} options 定制id字段名，子元素字段名，父元素字段名，默认
+ *        { keyField: 'key', childField: 'children', pidField: 'pid' }
+ * @returns {any[]}
+ */
+function flatTree(treeList, options = defaultFieldOptions) {
+    const { keyField = 'key', childField = 'children', pidField = 'pid' } = isObject(options) ? options : {};
+    let res = [];
+    for (let i = 0, len = treeList.length; i < len; i++) {
+        const node = treeList[i];
+        const item = {
+            ...node,
+            [childField]: [] // 清空子级
+        };
+        objectHas(item, childField) && delete item[childField];
+        res.push(item);
+        if (node[childField]) {
+            const children = node[childField].map(item => ({
+                ...item,
+                [pidField]: node[keyField] || item.pid // 给子级设置pid
+            }));
+            res = res.concat(flatTree(children, options));
+        }
+    }
+    return res;
+}
+/**
+ * 模糊搜索函数，返回包含搜索字符的节点及其祖先节点, 适用于树型组件的字符过滤功能
+ * 以下搜索条件二选一，按先后优先级处理：
+ * 1. 过滤函数filter, 返回true/false
+ * 2. 匹配关键词，支持是否启用忽略大小写来判断
+ *
+ * 有以下特性：
+ * 1. 可配置removeEmptyChild字段，来决定是否移除搜索结果中的空children字段
+ * 2. 若无任何过滤条件或keyword模式匹配且keyword为空串，返回原对象；其他情况返回新数组
+ * @param {V[]} nodes
+ * @param {IFilterCondition} filterCondition
+ * @param {ISearchTreeOpts} options 默认配置项 {
+      childField: 'children',
+      nameField: 'name',
+      removeEmptyChild: false,
+      ignoreCase: true
+    }
+ * @returns {V[]}
+ */
+function fuzzySearchTree(nodes, filterCondition, options = defaultSearchTreeOptions) {
+    if (!objectHas(filterCondition, 'filter') &&
+        (!objectHas(filterCondition, 'keyword') || isEmpty(filterCondition.keyword))) {
+        return nodes;
+    }
+    const result = [];
+    for (let i = 0, len = nodes.length; i < len; i++) {
+        const node = nodes[i];
+        // 递归检查子节点是否匹配
+        const matchedChildren = node[options.childField] && node[options.childField].length > 0
+            ? fuzzySearchTree(node[options.childField] || [], filterCondition, options)
+            : [];
+        // 检查当前节点是否匹配或者有匹配的子节点
+        if ((objectHas(filterCondition, 'filter')
+            ? filterCondition.filter(node)
+            : !options.ignoreCase
+                ? node[options.nameField].includes(filterCondition.keyword)
+                : node[options.nameField].toLowerCase().includes(filterCondition.keyword.toLowerCase())) ||
+            matchedChildren.length > 0) {
+            // 将当前节点加入结果中
+            if (node[options.childField]) {
+                if (matchedChildren.length > 0) {
+                    result.push({
+                        ...node,
+                        [options.childField]: matchedChildren // 包含匹配的子节点
+                    });
+                }
+                else if (options.removeEmptyChild) {
+                    const { [options.childField]: _, ...other } = node;
+                    result.push(other);
+                }
+                else {
+                    result.push({
+                        ...node,
+                        [options.childField]: []
+                    });
+                }
+            }
+            else {
+                const { [options.childField]: _, ...other } = node;
+                result.push(other);
+            }
+        }
+    }
+    return result;
+}
+
+/**
+ * 数值安全乘法
+ * @param arg1 数值1
+ * @param arg2 数值2
+ */
+const multiply = (arg1, arg2) => {
+    let m = 0;
+    const s1 = arg1.toString();
+    const s2 = arg2.toString();
+    if (s1.split('.')[1] !== undefined)
+        m += s1.split('.')[1].length;
+    if (s2.split('.')[1] !== undefined)
+        m += s2.split('.')[1].length;
+    return (Number(s1.replace('.', '')) * Number(s2.replace('.', ''))) / Math.pow(10, m);
+};
+/**
+ * 数值安全加法
+ * @param arg1 数值1
+ * @param arg2 数值2
+ */
+const add = (arg1, arg2) => {
+    let r1 = 0;
+    let r2 = 0;
+    let m = 0;
+    try {
+        r1 = arg1.toString().split('.')[1].length;
+    }
+    catch (e) {
+        r1 = 0;
+    }
+    try {
+        r2 = arg2.toString().split('.')[1].length;
+    }
+    catch (e) {
+        r2 = 0;
+    }
+    m = 10 ** Math.max(r1, r2);
+    return (multiply(arg1, m) + multiply(arg2, m)) / m;
+};
+/**
+ * 数值安全减法
+ * @param arg1 数值1
+ * @param arg2 数值2
+ */
+const subtract = (arg1, arg2) => add(arg1, -arg2);
+/**
+ * 数值安全除法
+ * @param arg1 数值1
+ * @param arg2 数值2
+ */
+const divide = (arg1, arg2) => {
+    let t1 = 0;
+    let t2 = 0;
+    let r1 = 0;
+    let r2 = 0;
+    if (arg1.toString().split('.')[1] !== undefined)
+        t1 = arg1.toString().split('.')[1].length;
+    if (arg2.toString().split('.')[1] !== undefined)
+        t2 = arg2.toString().split('.')[1].length;
+    r1 = Number(arg1.toString().replace('.', ''));
+    r2 = Number(arg2.toString().replace('.', ''));
+    return (r1 / r2) * Math.pow(10, t2 - t1);
+};
+/**
+ * Correct the given number to specifying significant digits.
+ *
+ * @param num The input number
+ * @param precision An integer specifying the number of significant digits
+ *
+ * @example strip(0.09999999999999998) === 0.1 // true
+ */
+function strip(num, precision = 15) {
+    return +parseFloat(Number(num).toPrecision(precision));
+}
+
+const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+// eslint-disable-next-line
+const b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+/**
+ * 字符串编码成Base64, 平替浏览器的btoa, 不包含中文的处理 （适用于任何环境，包括小程序）
+ * @param {string} string
+ * @returns {string}
+ */
+function weBtoa(string) {
+    // 同window.btoa: 字符串编码成Base64
+    string = String(string);
+    let bitmap, a, b, c, result = '', i = 0;
+    const strLen = string.length;
+    const rest = strLen % 3;
+    for (; i < strLen;) {
+        if ((a = string.charCodeAt(i++)) > 255 || (b = string.charCodeAt(i++)) > 255 || (c = string.charCodeAt(i++)) > 255)
+            throw new TypeError("Failed to execute 'btoa' on 'Window': The string to be encoded contains characters outside of the Latin1 range.");
+        bitmap = (a << 16) | (b << 8) | c;
+        result +=
+            b64.charAt((bitmap >> 18) & 63) +
+                b64.charAt((bitmap >> 12) & 63) +
+                b64.charAt((bitmap >> 6) & 63) +
+                b64.charAt(bitmap & 63);
+    }
+    return rest ? result.slice(0, rest - 3) + '==='.substring(rest) : result;
+}
+/**
+ * Base64解码为原始字符串，平替浏览器的atob, 不包含中文的处理（适用于任何环境，包括小程序）
+ * @param {string} string
+ * @returns {string}
+ */
+function weAtob(string) {
+    // 同window.atob: Base64解码为原始字符串
+    string = String(string).replace(/[\t\n\f\r ]+/g, '');
+    if (!b64re.test(string))
+        throw new TypeError("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");
+    string += '=='.slice(2 - (string.length & 3));
+    let bitmap, result = '', r1, r2, i = 0;
+    for (const strLen = string.length; i < strLen;) {
+        bitmap =
+            (b64.indexOf(string.charAt(i++)) << 18) |
+                (b64.indexOf(string.charAt(i++)) << 12) |
+                ((r1 = b64.indexOf(string.charAt(i++))) << 6) |
+                (r2 = b64.indexOf(string.charAt(i++)));
+        result +=
+            r1 === 64
+                ? String.fromCharCode((bitmap >> 16) & 255)
+                : r2 === 64
+                    ? String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255)
+                    : String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255, bitmap & 255);
+    }
+    return result;
+}
+function stringToUint8Array(str) {
+    const utf8 = encodeURIComponent(str); // 将字符串转换为 UTF-8 编码
+    const uint8Array = new Uint8Array(utf8.length); // 创建 Uint8Array
+    for (let i = 0; i < utf8.length; i++) {
+        uint8Array[i] = utf8.charCodeAt(i); // 填充 Uint8Array
+    }
+    return uint8Array;
+}
+function uint8ArrayToString(uint8Array) {
+    const utf8 = String.fromCharCode.apply(null, uint8Array); // 将 Uint8Array 转为字符串
+    return decodeURIComponent(utf8); // 将 UTF-8 字符串解码回正常字符串
+}
+/**
+ * 将base64编码的字符串转换为原始字符串，包括对中文内容的处理(高性能，且支持Web、Node、小程序等任意平台)
+ * @param base64 base64编码的字符串
+ * @returns 原始字符串，包括中文内容
+ */
+function b64decode(base64) {
+    const binaryString = !isNullOrUnDef(getGlobal('atob')) ? getGlobal('atob')(base64) : weAtob(base64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    // 使用TextDecoder将Uint8Array转换为原始字符串，包括中文内容
+    return !isNullOrUnDef(getGlobal('TextDecoder'))
+        ? new (getGlobal('TextDecoder'))('utf-8').decode(bytes)
+        : uint8ArrayToString(bytes);
+}
+/**
+ * 将原始字符串，包括中文内容，转换为base64编码的字符串(高性能，且支持Web、Node、小程序等任意平台)
+ * @param rawStr 原始字符串，包括中文内容
+ * @returns base64编码的字符串
+ */
+function b64encode(rawStr) {
+    const utf8Array = !isNullOrUnDef(getGlobal('TextEncoder'))
+        ? new (getGlobal('TextEncoder'))().encode(rawStr)
+        : stringToUint8Array(rawStr);
+    // 将 Uint8Array 转换为二进制字符串
+    let binaryString = '';
+    const len = utf8Array.length;
+    for (let i = 0; i < len; i++) {
+        binaryString += String.fromCharCode(utf8Array[i]);
+    }
+    // 将二进制字符串转换为base64编码的字符串
+    return !isNullOrUnDef(getGlobal('btoa')) ? getGlobal('btoa')(binaryString) : weBtoa(binaryString);
+}
+
+// 邮箱
+const EMAIL_REGEX = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+/**
+ * 判断字符串是否为邮箱格式，不对邮箱真实性做验证，如域名是否正确等
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isEmail = (value) => EMAIL_REGEX.test(value);
+// 手机号码 (中国大陆)
+// reference: https://www.runoob.com/regexp/regexp-syntax.html (?: 是非捕获元之一)
+const PHONE_REGEX = /^(?:(?:\+|00)86)?1\d{10}$/;
+/**
+ * 判断字符串是否为宽松手机格式，即首位为 1 的 11 位数字都属于手机号
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isPhone = (value) => PHONE_REGEX.test(value);
+// 身份证号码
+// http://www.stats.gov.cn/tjsj/tjbz/xzqhdm/
+// ["北京市", "天津市", "河北省", "山西省", "内蒙古自治区",
+// "辽宁省", "吉林省", "黑龙江省",
+// "上海市", "江苏省", "浙江省", "安徽省", "福建省", "江西省", "山东省",
+// "河南省", "湖北省", "湖南省", "广东省", "广西壮族自治区", "海南省",
+// "重庆市", "四川省", "贵州省", "云南省", "西藏自治区",
+// "陕西省", "甘肃省", "青海省","宁夏回族自治区", "新疆维吾尔自治区",
+// "台湾省",
+// "香港特别行政区", "澳门特别行政区"]
+// ["11", "12", "13", "14", "15",
+// "21", "22", "23",
+// "31", "32", "33", "34", "35", "36", "37",
+// "41", "42", "43", "44", "45", "46",
+// "50", "51", "52", "53", "54",
+// "61", "62", "63", "64", "65",
+// "71",
+// "81", "82"]
+// 91 国外
+const IDNO_RE = /^(1[1-5]|2[1-3]|3[1-7]|4[1-6]|5[0-4]|6[1-5]|7[1]|8[1-2]|9[1])\d{4}(18|19|20)\d{2}[01]\d[0123]\d{4}[\dxX]$/;
+/**
+ * 判断字符串是否为身份证号码格式
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isIdNo = (value) => {
+    const isSameFormat = IDNO_RE.test(value);
+    if (!isSameFormat)
+        return false;
+    const year = Number(value.slice(6, 10));
+    const month = Number(value.slice(10, 12));
+    const date = Number(value.slice(12, 14));
+    const d = new Date(year, month - 1, date);
+    const isSameDate = d.getFullYear() === year && d.getMonth() + 1 === month && d.getDate() === date;
+    if (!isSameDate)
+        return false;
+    // 将身份证号码前面的17位数分别乘以不同的系数；
+    // 从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2
+    // 将这17位数字和系数相乘的结果相加；
+    // 用加出来和除以11，看余数是多少；
+    // 余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字；
+    // 其分别对应的最后一位身份证的号码为1－0－X－9－8－7－6－5－4－3－2
+    // 通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。
+    const coefficientList = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+    const residueList = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];
+    let sum = 0;
+    for (let start = 0; start < 17; start++) {
+        sum += Number(value.slice(start, start + 1)) * coefficientList[start];
+    }
+    return residueList[sum % 11] === value.slice(-1);
+};
+const URL_REGEX = /^(https?|ftp):\/\/([^\s/$.?#].[^\s]*)$/i;
+const HTTP_URL_REGEX = /^https?:\/\/([^\s/$.?#].[^\s]*)$/i;
+/**
+ * 判断字符串是否为 url 格式，支持 http、https、ftp 协议，支持域名或者 ipV4
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isUrl = (url, includeFtp = false) => {
+    const regex = includeFtp ? URL_REGEX : HTTP_URL_REGEX;
+    return regex.test(url);
+};
+// ipv4
+const IPV4_REGEX = /^(?:(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$/;
+// ipv6
+const IPV6_REGEX = /^(([\da-fA-F]{1,4}:){7}[\da-fA-F]{1,4}|([\da-fA-F]{1,4}:){1,7}:|([\da-fA-F]{1,4}:){1,6}:[\da-fA-F]{1,4}|([\da-fA-F]{1,4}:){1,5}(:[\da-fA-F]{1,4}){1,2}|([\da-fA-F]{1,4}:){1,4}(:[\da-fA-F]{1,4}){1,3}|([\da-fA-F]{1,4}:){1,3}(:[\da-fA-F]{1,4}){1,4}|([\da-fA-F]{1,4}:){1,2}(:[\da-fA-F]{1,4}){1,5}|[\da-fA-F]{1,4}:((:[\da-fA-F]{1,4}){1,6})|:((:[\da-fA-F]{1,4}){1,7}|:)|fe80:(:[\da-fA-F]{0,4}){0,4}%[\da-zA-Z]+|::(ffff(:0{1,4})?:)?((25[0-5]|(2[0-4]|1?\d)?\d)\.){3}(25[0-5]|(2[0-4]|1?\d)?\d)|([\da-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1?\d)?\d)\.){3}(25[0-5]|(2[0-4]|1?\d)?\d))$/i;
+/**
+ * 判断字符串是否为 IPV4 格式，不对 ip 真实性做验证
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isIpV4 = (value) => IPV4_REGEX.test(value);
+/**
+ * 判断字符串是否为 IPV6 格式，不对 ip 真实性做验证
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isIpV6 = (value) => IPV6_REGEX.test(value);
+const INTEGER_RE = /^(-?[1-9]\d*|0)$/;
+/**
+ * 判断字符串是否为整数（自然数），即 ...,-3,-2,-1,0,1,2,3,...
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isInteger = (value) => INTEGER_RE.test(value);
+const FLOAT_RE = /^-?([1-9]\d*|0)\.\d*[1-9]$/;
+/**
+ * 判断字符串是否为浮点数，即必须有小数点的有理数
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isFloat = (value) => FLOAT_RE.test(value);
+/**
+ * 判断字符串是否为正确数值，包括整数和浮点数
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isNumerical = (value) => isInteger(value) || isFloat(value);
+const DIGIT_RE = /^\d+$/;
+/**
+ * 判断字符串是否为数字，例如六位数字短信验证码（093031）
+ * @param {string} value
+ * @returns {boolean}
+ */
+const isDigit = (value) => DIGIT_RE.test(value);
+
+/**
+ * 去除字符串中重复字符
+ * @param {string} str
+ * @returns string
+ * @example
+ *
+ * uniqueSymbol('1a1bac');
+ * // => '1abc'
+ */
+function uniqueSymbol(str) {
+    return [...new Set(str.trim().split(''))].join('');
+}
+/**
+ * 转义所有特殊字符
+ * @param {string} str 原字符串
+ *  reference: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Regular_expressions
+ * @returns string
+ */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); //$&表示整个被匹配的字符串
+}
+/**
+ * 根据左右匹配符号生产解析变量(自动删除变量内的空白)
+ * @param {string} leftMatchSymbol
+ * @param {string} rightMatchSymbol
+ * @returns RegExp
+ */
+function parseVariableRegExp(leftMatchSymbol, rightMatchSymbol) {
+    return new RegExp(`${escapeRegExp(leftMatchSymbol.trim())}\\s*([^${escapeRegExp(uniqueSymbol(leftMatchSymbol))}${escapeRegExp(uniqueSymbol(rightMatchSymbol))}\\s]*)\\s*${rightMatchSymbol.trim()}`, 'g');
+}
+/**
+ * 解析字符串的插值变量
+ * @param {string} str 字符串
+ * @param {string} leftMatchSymbol 变量左侧匹配符号，默认：{
+ * @param {string} rightMatchSymbol 变量右侧匹配符号，默认：}
+ * @returns string[]
+ * @example
+ *
+ * default match symbol {} same as /{\s*([^{}\s]*)\s*}/g
+ */
+function parseVarFromString(str, leftMatchSymbol = '{', rightMatchSymbol = '}') {
+    // @ts-ignore
+    return Array.from(str.matchAll(parseVariableRegExp(leftMatchSymbol, rightMatchSymbol))).map(el => isNullOrUnDef(el) ? void 0 : el[1]);
+}
+/**
+ * 替换字符串中的插值变量
+ * @param {string} sourceStr
+ * @param {Record<string, any>} targetObj
+ * @param {string} leftMatchSymbol 变量左侧匹配符号，默认：{
+ * @param {string} rightMatchSymbol 变量右侧匹配符号，默认：}
+ * @returns string
+ */
+function replaceVarFromString(sourceStr, targetObj, leftMatchSymbol = '{', rightMatchSymbol = '}') {
+    return sourceStr.replace(new RegExp(parseVariableRegExp(leftMatchSymbol, rightMatchSymbol)), function (m, p1) {
+        return objectHas(targetObj, p1) ? targetObj[p1] : m;
+    });
+}
+/**
+ * 在指定作用域中执行代码
+ * @param {string} code 要执行的代码（需包含 return 语句或表达式）
+ * @param {Object} scope 作用域对象（键值对形式的变量环境）
+ * @returns 代码执行结果
+ *
+ * @example
+ * // 测试用例 1: 基本变量访问
+ * executeInScope("return a + b;", { a: 1, b: 2 });
+ * // 3
+ *
+ * // 测试用例 2: 支持复杂表达式和运算
+ * executeInScope(
+ * "return Array.from({ length: 3 }, (_, i) => base + i);",
+ * { base: 100 }
+ * );
+ * // [100, 101, 102]
+ *
+ * // 支持外传函数作用域执行
+ * const scope = {
+ *  $: {
+ *    fun: {
+ *      time: {
+ *        now: function () {
+ *          return new Date();
+ *        },
+ *      },
+ *    },
+ *  },
+ * };
+ * executeInScope("return $.fun.time.now()", scope)
+ */
+function executeInScope(code, scope = {}) {
+    // 提取作用域对象的键和值
+    const keys = Object.keys(scope);
+    const values = keys.map(key => scope[key]);
+    try {
+        // 动态创建函数，将作用域的键作为参数，代码作为函数体
+        const func = new Function(...keys, `return (() => { ${code} })()`);
+        // 调用函数并传入作用域的值
+        return func(...values);
+    }
+    catch (error) {
+        throw new Error(`代码执行失败: ${error.message}`);
+    }
+}
+
+/**
+ * 深拷贝堪称完全体 即：任何类型的数据都会被深拷贝
+ *
+ * 包含对null、原始值、对象循环引用的处理
+ *
+ * 对Map、Set、ArrayBuffer、Date、RegExp、Array、Object及原型链属性方法执行深拷贝
+ * @param {T} source
+ * @param {WeakMap} map
+ * @returns {T}
+ */
+function cloneDeep(source, map = new WeakMap()) {
+    // 处理原始类型和 null/undefined
+    if (source === null || typeof source !== 'object') {
+        return source;
+    }
+    // 处理循环引用
+    if (map.has(source)) {
+        return map.get(source);
+    }
+    // 处理 ArrayBuffer
+    if (source instanceof ArrayBuffer) {
+        const copy = new ArrayBuffer(source.byteLength);
+        new Uint8Array(copy).set(new Uint8Array(source));
+        map.set(source, copy);
+        return copy;
+    }
+    // 处理 DataView 和 TypedArray (Uint8Array 等)
+    if (ArrayBuffer.isView(source)) {
+        const constructor = source.constructor;
+        const bufferCopy = cloneDeep(source.buffer, map);
+        return new constructor(bufferCopy, source.byteOffset, source.length);
+    }
+    // 处理 Date 对象
+    if (source instanceof Date) {
+        const copy = new Date(source.getTime());
+        map.set(source, copy);
+        return copy;
+    }
+    // 处理 RegExp 对象
+    if (source instanceof RegExp) {
+        const copy = new RegExp(source.source, source.flags);
+        copy.lastIndex = source.lastIndex; // 保留匹配状态
+        map.set(source, copy);
+        return copy;
+    }
+    // 处理 Map
+    if (source instanceof Map) {
+        const copy = new Map();
+        map.set(source, copy);
+        source.forEach((value, key) => {
+            copy.set(cloneDeep(key, map), cloneDeep(value, map));
+        });
+        return copy;
+    }
+    // 处理 Set
+    if (source instanceof Set) {
+        const copy = new Set();
+        map.set(source, copy);
+        source.forEach(value => {
+            copy.add(cloneDeep(value, map));
+        });
+        return copy;
+    }
+    // 处理数组 (包含稀疏数组)
+    if (Array.isArray(source)) {
+        const copy = new Array(source.length);
+        map.set(source, copy);
+        // 克隆所有有效索引
+        for (let i = 0, len = source.length; i < len; i++) {
+            if (i in source) {
+                // 保留空位
+                copy[i] = cloneDeep(source[i], map);
+            }
+        }
+        // 克隆数组的自定义属性
+        const descriptors = Object.getOwnPropertyDescriptors(source);
+        for (const key of Reflect.ownKeys(descriptors)) {
+            Object.defineProperty(copy, key, {
+                ...descriptors[key],
+                value: cloneDeep(descriptors[key].value, map)
+            });
+        }
+        return copy;
+    }
+    // 处理普通对象和类实例
+    const copy = Object.create(Object.getPrototypeOf(source));
+    map.set(source, copy);
+    const descriptors = Object.getOwnPropertyDescriptors(source);
+    for (const key of Reflect.ownKeys(descriptors)) {
+        const descriptor = descriptors[key];
+        if ('value' in descriptor) {
+            // 克隆数据属性
+            descriptor.value = cloneDeep(descriptor.value, map);
+        }
+        else {
+            // 处理访问器属性 (getter/setter)
+            if (descriptor.get) {
+                descriptor.get = cloneDeep(descriptor.get, map);
+            }
+            if (descriptor.set) {
+                descriptor.set = cloneDeep(descriptor.set, map);
+            }
+        }
+        Object.defineProperty(copy, key, descriptor);
+    }
+    return copy;
+}
+
+export { EMAIL_REGEX, HEX_POOL, HTTP_URL_REGEX, IPV4_REGEX, IPV6_REGEX, PHONE_REGEX, STRING_ARABIC_NUMERALS, STRING_LOWERCASE_ALPHA, STRING_POOL, STRING_UPPERCASE_ALPHA, UNIQUE_NUMBER_SAFE_LENGTH, URL_REGEX, add, addClass, arrayEach, arrayEachAsync, arrayInsertBefore, arrayLike, arrayRemove, asyncMap, b64decode, b64encode, calculateDate, calculateDateTime, chooseLocalFile, cloneDeep, compressImg, cookieDel, cookieGet, cookieSet, copyText, crossOriginDownload, dateParse, dateToEnd, dateToStart, debounce, divide, downloadBlob, downloadData, downloadHref, downloadURL, easingFunctional, easingStringify, escapeRegExp, executeInScope, fallbackCopyText, flatTree, forEachDeep, formatDate, formatNumber as formatMoney, formatNumber, formatTree, fuzzySearchTree, genCanvasWM, getComputedCssVal, getEasing, getGlobal, getStrWidthPx, getStyle, hasClass, humanFileSize, isArray, isBigInt, isBoolean, isDate, isDigit, isEmail, isEmpty, isError, isFloat, isFunction, isIdNo, isInteger, isIpV4, isIpV6, isJsonString, isNaN, isNodeList, isNull, isNullOrUnDef, isNullOrUnDef as isNullish, isNumber, isNumerical, isObject, isPhone, isPlainObject, isPrimitive, isRegExp, isString, isSymbol, isUndefined, isUrl, isValidDate, mapDeep, multiply, numberAbbr, numberToHex, objectAssign, objectEach, objectEachAsync, objectFill, objectGet, objectHas, objectMap, objectAssign as objectMerge, objectOmit, objectPick, once, parseQueryParams, parseVarFromString, pathJoin, pathNormalize, qsParse, qsStringify, randomNumber, randomString, randomUuid, removeClass, replaceVarFromString, safeAwait, searchTreeById, select, setEasing, setGlobal, setStyle, smoothScroll, stringAssign, stringCamelCase, stringEscapeHtml, stringFill, stringFormat, stringKebabCase, strip, subtract, supportCanvas, throttle, tooltipEvent, typeIs, uniqueNumber, uniqueString, uniqueSymbol, urlDelParams, urlParse, urlSetParams, urlStringify, wait, weAtob, weBtoa };