sculp-js 0.0.1

package/lib/umd/index.js

@@ -0,0 +1,1458 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bezier-easing')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'bezier-easing'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sculpJs = {}, global.bezier));
+})(this, (function (exports, bezier) { 'use strict';
+
+    const typeIs = (any) => Object.prototype.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';
+    // 复合数据类型判断
+    const isObject = (any) => typeIs(any) === 'Object';
+    const isArray = (any) => Array.isArray(any);
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    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';
+
+    var type = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        default: typeIs,
+        isArray: isArray,
+        isBigInt: isBigInt,
+        isBoolean: isBoolean,
+        isDate: isDate,
+        isError: isError,
+        isFunction: isFunction,
+        isNaN: isNaN,
+        isNull: isNull,
+        isNumber: isNumber,
+        isObject: isObject,
+        isPrimitive: isPrimitive,
+        isRegExp: isRegExp,
+        isString: isString,
+        isSymbol: isSymbol,
+        isUndefined: isUndefined
+    });
+
+    /**
+     * 判断对象是否为纯对象
+     * @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;
+    };
+    /**
+     * 判断对象内是否有该静态属性
+     * @param {object} obj
+     * @param {string} key
+     * @returns {boolean}
+     */
+    const objectHas = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+    /**
+     * 遍历对象，返回 false 中断遍历
+     * @param {O} obj
+     * @param {(val: O[keyof O], key: keyof O) => (boolean | void)} iterator
+     */
+    const objectEach = (obj, iterator) => {
+        for (const key in obj) {
+            if (!objectHas(obj, key))
+                continue;
+            if (iterator(obj[key], key) === false)
+                break;
+        }
+    };
+    /**
+     * 异步遍历对象，返回 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;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            obj2[key] = iterator(obj[key], key);
+        }
+        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)) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                obj2[k] = v;
+            }
+        });
+        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)) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                obj2[k] = v;
+            }
+        });
+        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}
+     */
+    const objectAssign = (source, ...targets) => {
+        const map = new Map();
+        for (let i = 0; i < targets.length; i++) {
+            const target = targets[i];
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @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}
+     */
+    const 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;
+    };
+    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 (key in tempObj) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+                tempObj = tempObj[key];
+            }
+            else {
+                tempObj = undefined;
+                if (strict) {
+                    throw new Error('[berry/js-utils/object] objectGet path 路径不正确');
+                }
+                break;
+            }
+        }
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            p: tempObj,
+            k: tempObj ? keyArr[i] : undefined,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+            v: tempObj ? tempObj[keyArr[i]] : undefined
+        };
+    }
+    /**
+     * 深拷贝堪称完全体 即：任何类型的数据都会被深拷贝
+     * @param {AnyObject | AnyArray} obj
+     * @param {WeakMap} map
+     * @return {AnyObject | AnyArray}
+     */
+    function cloneDeep(obj, map = new WeakMap()) {
+        if (obj instanceof Date)
+            return new Date(obj);
+        if (obj instanceof RegExp)
+            return new RegExp(obj);
+        if (map.has(obj)) {
+            return map.get(obj);
+        }
+        const allDesc = Object.getOwnPropertyDescriptors(obj);
+        const cloneObj = Object.create(Object.getPrototypeOf(obj), allDesc);
+        map.set(obj, cloneObj);
+        for (const key of Reflect.ownKeys(obj)) {
+            const value = obj[key];
+            cloneObj[key] = value instanceof Object && typeof value !== 'function' ? cloneDeep(value, map) : value;
+        }
+        return cloneObj;
+    }
+
+    var object = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        cloneDeep: cloneDeep,
+        isPlainObject: isPlainObject,
+        objectAssign: objectAssign,
+        objectEach: objectEach,
+        objectEachAsync: objectEachAsync,
+        objectFill: objectFill,
+        objectGet: objectGet,
+        objectHas: objectHas,
+        objectMap: objectMap,
+        objectMerge: objectAssign,
+        objectOmit: objectOmit,
+        objectPick: objectPick
+    });
+
+    /**
+     * 判断一个对象是否为类数组
+     * @param any
+     * @returns {boolean}
+     */
+    const arrayLike = (any) => {
+        if (isArray(any))
+            return true;
+        if (isString(any))
+            return true;
+        if (!isObject(any))
+            return false;
+        return objectHas(any, 'length');
+    };
+    /**
+     * 遍历数组，返回 false 中断遍历
+     * @param {ArrayLike<V>} array
+     * @param {(val: V, idx: number) => any} iterator
+     * @param reverse {boolean} 是否倒序
+     */
+    const arrayEach = (array, iterator, reverse = false) => {
+        if (reverse) {
+            for (let idx = array.length - 1; idx >= 0; idx--) {
+                const val = array[idx];
+                if (iterator(val, idx) === false)
+                    break;
+            }
+        }
+        else {
+            for (let idx = 0; idx < array.length; idx++) {
+                const val = array[idx];
+                if (iterator(val, idx) === false)
+                    break;
+            }
+        }
+    };
+    /**
+     * 异步遍历数组，返回 false 中断遍历
+     * @param {ArrayLike<V>} array
+     * @param {(val: V, idx: number) => Promise<any>} iterator
+     * @param {boolean} reverse
+     */
+    async function arrayEachAsync(array, iterator, reverse = false) {
+        if (reverse) {
+            for (let idx = array.length - 1; idx >= 0; idx--) {
+                const val = array[idx];
+                if ((await iterator(val, idx)) === false)
+                    break;
+            }
+        }
+        else {
+            for (let idx = 0; idx < array.length; idx++) {
+                const val = array[idx];
+                if ((await iterator(val, idx)) === false)
+                    break;
+            }
+        }
+    }
+    /**
+     * 插入到目标位置之前
+     * @param {AnyArray} array
+     * @param {number} start
+     * @param {number} to
+     */
+    const arrayInsertBefore = (array, start, to) => {
+        if (start === to || start + 1 === to)
+            return;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        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;
+    }
+    /**
+     * 自定义深度优先遍历函数(支持continue和break操作)
+     * @param {array} deepList
+     * @param {function} iterator
+     * @param {array} children
+     * @param {boolean} isReverse 是否反向遍历
+     */
+    const deepTraversal = (deepList, iterator, children = 'children', isReverse = false) => {
+        let level = 0;
+        const walk = (arr, parent) => {
+            if (isReverse) {
+                for (let i = arr.length - 1; i >= 0; i--) {
+                    const re = iterator(arr[i], i, deepList, parent, level);
+                    if (re === 'break') {
+                        break;
+                    }
+                    else if (re === 'continue') {
+                        continue;
+                    }
+                    // @ts-ignore
+                    if (Array.isArray(arr[i][children])) {
+                        ++level;
+                        // @ts-ignore
+                        walk(arr[i][children], arr[i]);
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < arr.length; i++) {
+                    const re = iterator(arr[i], i, deepList, parent, level);
+                    if (re === 'break') {
+                        break;
+                    }
+                    else if (re === 'continue') {
+                        continue;
+                    }
+                    // @ts-ignore
+                    if (Array.isArray(arr[i][children])) {
+                        ++level;
+                        // @ts-ignore
+                        walk(arr[i][children], arr[i]);
+                    }
+                }
+            }
+        };
+        walk(deepList, null);
+    };
+    /**
+     * 在树中找到 id 为某个值的节点，并返回上游的所有父级节点
+     * @param {ArrayLike<T>} tree
+     * @param {IdLike} nodeId
+     * @param {ITreeConf} config
+     * @return {[IdLike[], ITreeItem<V>[]]}
+     */
+    function getTreeIds(tree, nodeId, config) {
+        const { children = 'children', id = 'id' } = config || {};
+        const toFlatArray = (tree, parentId, parent) => {
+            return tree.reduce((t, _) => {
+                const child = _[children];
+                return [
+                    ...t,
+                    parentId ? { ..._, parentId, parent } : _,
+                    ...(child && child.length ? toFlatArray(child, _[id], _) : [])
+                ];
+            }, []);
+        };
+        const getIds = (flatArray) => {
+            let child = flatArray.find(_ => _[id] === 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(_ => _[id] === child.parentId);
+            }
+            return [ids, nodes];
+        };
+        return getIds(toFlatArray(tree));
+    }
+    /**
+     * 异步ForEach函数
+     * @param {array} array
+     * @param {asyncFuntion} callback
+     * // asyncForEach 使用范例如下
+    // const start = async () => {
+    //   await asyncForEach(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++;
+    //    }
+    // }
+     * @return {*}
+     */
+    async function asyncForEach(array, callback) {
+        for (let index = 0, len = array.length; index < len; index++) {
+            await callback(array[index], index, array);
+        }
+    }
+
+    var array = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        arrayEach: arrayEach,
+        arrayEachAsync: arrayEachAsync,
+        arrayInsertBefore: arrayInsertBefore,
+        arrayLike: arrayLike,
+        arrayRemove: arrayRemove,
+        asyncForEach: asyncForEach,
+        deepTraversal: deepTraversal,
+        getTreeIds: getTreeIds
+    });
+
+    // @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]
+    };
+    /**
+     * 缓冲函数化，用于 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)));
+    }
+
+    /**
+     * 将字符串转换为驼峰格式
+     * @param {string} string
+     * @param {boolean} [bigger] 是否大写第一个字母
+     * @returns {string}
+     */
+    const 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}
+     */
+    const 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}
+     */
+    const 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('');
+
+    var string = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        STRING_ARABIC_NUMERALS: STRING_ARABIC_NUMERALS,
+        STRING_LOWERCASE_ALPHA: STRING_LOWERCASE_ALPHA,
+        STRING_UPPERCASE_ALPHA: STRING_UPPERCASE_ALPHA,
+        stringAssign: stringAssign,
+        stringCamelCase: stringCamelCase,
+        stringEscapeHtml: stringEscapeHtml,
+        stringFill: stringFill,
+        stringFormat: stringFormat,
+        stringKebabCase: stringKebabCase
+    });
+
+    /**
+     * 判断元素是否包含某个样式名
+     * @param {HTMLElement} el
+     * @param {string} className
+     * @returns {boolean}
+     */
+    const 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
+     */
+    const addClass = (el, classNames) => {
+        eachClassName(classNames, className => el.classList.add(className));
+    };
+    /**
+     * 给元素移除样式名
+     * @param {HTMLElement} el
+     * @param {string} classNames
+     */
+    const 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}
+     */
+    const getStyle = (el, key) => getComputedStyle(el).getPropertyValue(key);
+    async 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();
+        });
+    }
+    const domReadyCallbacks = [];
+    const eventType = 'DOMContentLoaded';
+    const listener = () => {
+        domReadyCallbacks.forEach(callback => callback());
+        domReadyCallbacks.length = 0;
+        document.removeEventListener(eventType, listener);
+    };
+    document.addEventListener(eventType, listener);
+    let readied = false;
+    function isDomReady() {
+        if (readied)
+            return true;
+        readied = ['complete', 'loaded', 'interactive'].indexOf(document.readyState) !== -1;
+        return readied;
+    }
+    function onDomReady(callback) {
+        // document readied
+        if (isDomReady()) {
+            setTimeout(callback, 0);
+        }
+        // listen document to ready
+        else {
+            domReadyCallbacks.push(callback);
+        }
+    }
+
+    var dom = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        addClass: addClass,
+        getStyle: getStyle,
+        hasClass: hasClass,
+        isDomReady: isDomReady,
+        onDomReady: onDomReady,
+        removeClass: removeClass,
+        setStyle: setStyle,
+        smoothScroll: smoothScroll
+    });
+
+    const textEl = document.createElement('textarea');
+    setStyle(textEl, {
+        position: 'absolute',
+        top: '-9999px',
+        left: '-9999px',
+        opacity: 0
+    });
+    document.body.appendChild(textEl);
+    /**
+     * 复制文本
+     * @param {string} text
+     */
+    const copyText = (text) => {
+        textEl.value = text;
+        textEl.focus({ preventScroll: true });
+        textEl.select();
+        try {
+            document.execCommand('copy');
+            textEl.blur();
+        }
+        catch (err) {
+            // ignore
+        }
+    };
+
+    var clipboard = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        copyText: copyText
+    });
+
+    /**
+     * 获取cookie
+     * @param {string} name
+     * @returns {string}
+     */
+    const 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]
+     */
+    const 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);
+
+    var cookie = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        cookieDel: cookieDel,
+        cookieGet: cookieGet,
+        cookieSet: cookieSet
+    });
+
+    /**
+     * 格式化为日期对象(带自定义格式化模板)
+     * @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：毫秒
+     * - ww: 周
+     * @returns {string}
+     */
+    const formatDate = (date = new Date(), format = 'YYYY-MM-DD HH:mm:ss') => {
+        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 {string} strDate 参考日期
+     * @param {number} n 正数：向后推算；负数：向前推算
+     * @param {string} sep 日期格式的分隔符
+     * @return {*} 目标日期
+     */
+    function calculateDate(strDate, n, sep = '-') {
+        //strDate 为字符串日期 如:'2019-01-01' n为你要传入的参数，当前为0，前一天为-1，后一天为1
+        let dateArr = strDate.split(sep); //这边给定一个特定时间
+        let newDate = new Date(+dateArr[0], +dateArr[1] - 1, +dateArr[2]);
+        let befminuts = newDate.getTime() + 1000 * 60 * 60 * 24 * parseInt(String(n)); //计算前几天用减，计算后几天用加，最后一个就是多少天的数量
+        let beforeDat = new Date();
+        beforeDat.setTime(befminuts);
+        let befMonth = beforeDat.getMonth() + 1;
+        let mon = befMonth >= 10 ? befMonth : '0' + befMonth;
+        let befDate = beforeDat.getDate();
+        let da = befDate >= 10 ? befDate : '0' + befDate;
+        let finalNewDate = beforeDat.getFullYear() + '-' + mon + '-' + da;
+        return finalNewDate;
+    }
+    /**
+     * 计算向前或向后N天的具体时间日期
+     * @param {number} n 正数：向后推算；负数：向前推算
+     * @param {string} dateSep 日期分隔符
+     * @param {string} timeSep 时间分隔符
+     * @return {*}
+     */
+    function calculateDateTime(n, dateSep = '-', timeSep = ':') {
+        let date = new Date();
+        let separator1 = '-';
+        let separator2 = ':';
+        let year = date.getFullYear();
+        let month = date.getMonth() + 1;
+        let strDate = date.getDate() + n;
+        if (strDate > new Date(year, month, 0).getDate()) {
+            month += 1;
+            strDate -= new Date(year, month, 0).getDate();
+            if (month > 12) {
+                year += 1;
+                month = 1;
+            }
+        }
+        if (month >= 1 && month <= 9) {
+            month = '0' + month;
+        }
+        if (strDate >= 0 && strDate <= 9) {
+            strDate = '0' + strDate;
+        }
+        return (year +
+            separator1 +
+            month +
+            separator1 +
+            strDate +
+            ' ' +
+            date.getHours() +
+            separator2 +
+            date.getMinutes() +
+            separator2 +
+            date.getSeconds());
+    }
+
+    var date = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        calculateDate: calculateDate,
+        calculateDateTime: calculateDateTime,
+        formatDate: formatDate
+    });
+
+    /**
+     * 标准化路径
+     * @param {string} path
+     * @returns {string}
+     */
+    const pathNormalize = (path) => {
+        const slicees = 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();
+            }
+        };
+        slicees.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('/'));
+
+    var path = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        pathJoin: pathJoin,
+        pathNormalize: pathNormalize
+    });
+
+    /**
+     * 解析查询参数，内部使用的是浏览器内置的 URLSearchParams 进行处理
+     * @param {string} queryString
+     * @returns {Params}
+     */
+    const 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}
+     */
+    const 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();
+    };
+
+    var qs = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        qsParse: qsParse,
+        qsStringify: qsStringify
+    });
+
+    const anchorEl = document.createElement('a');
+    /**
+     * url 解析
+     * @param {string} url
+     * @returns {Url}
+     */
+    const urlParse = (url) => {
+        anchorEl.href = url;
+        const { protocol, username, password, host, port, hostname, hash, search, pathname: _pathname } = anchorEl;
+        // 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}`;
+        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);
+    };
+
+    var url = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        urlDelParams: urlDelParams,
+        urlParse: urlParse,
+        urlSetParams: urlSetParams,
+        urlStringify: urlStringify
+    });
+
+    /**
+     * 通过打开新窗口的方式下载
+     * @param {string} url
+     * @param {LooseParams} params
+     */
+    const downloadURL = (url, params) => {
+        window.open(params ? urlSetParams(url, params) : url);
+    };
+    /**
+     * 通过 A 链接的方式下载
+     * @param {string} href
+     * @param {string} filename
+     */
+    const downloadHref = (href, filename) => {
+        const 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));
+    };
+    /**
+     * 将大文件对象通过 A 链接的方式下载
+     * @param {Blob} blob
+     * @param {string} filename
+     */
+    const downloadBlob = (blob, filename) => {
+        const objURL = URL.createObjectURL(blob);
+        downloadHref(objURL, filename);
+        setTimeout(() => URL.revokeObjectURL(objURL));
+    };
+    /**
+     * 将指定数据格式通过 A 链接的方式下载
+     * @param {AnyObject | AnyObject[]} data
+     * @param {FileType} fileType 支持 json/csv/xls/xlsx 四种格式
+     * @param {string} filename
+     * @param {string[]} [headers]
+     */
+    const 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);
+        }
+    };
+
+    var download = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        downloadBlob: downloadBlob,
+        downloadData: downloadData,
+        downloadHref: downloadHref,
+        downloadURL: downloadURL
+    });
+
+    /**
+     * 等待一段时间
+     * @param {number} timeout 等待时间，单位毫秒
+     * @returns {Promise<void>}
+     */
+    async 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[]>}
+     */
+    async 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();
+            }
+        });
+    }
+
+    var async = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        asyncMap: asyncMap,
+        wait: wait
+    });
+
+    /**
+     * 选择本地文件
+     * @param {function} changeCb 选择文件回调
+     * @return {*}
+     */
+    function chooseLocalFile({ accept }, changeCb) {
+        const 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));
+        };
+        return inputObj;
+    }
+
+    var file = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        chooseLocalFile: chooseLocalFile
+    });
+
+    /*
+     * @created: Saturday, 2020-04-18 14:38:23
+     * @author: chendq
+     * ---------
+     * @desc 网页加水印的工具类
+     */
+    /**
+     * canvas 实现 watermark
+     * @param {ICanvasWM} canvasWM
+     */
+    const genCanvasWM = (canvasWM) => {
+        const { container = document.body, width = '300px', height = '200px', textAlign = 'center', textBaseline = 'middle', font = '20px PingFangSC-Medium,PingFang SC', 
+        // fontWeight = 500,
+        fillStyle = 'rgba(189, 177, 167, .3)', content = '请勿外传', rotate = 30, zIndex = 2147483647 } = canvasWM;
+        // 仅限主页面添加水印
+        if (!location.pathname.includes('/home')) {
+            return;
+        }
+        const args = canvasWM;
+        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('.__wm');
+        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.classList.add('__wm');
+        watermarkDiv.classList.add('nav-height');
+        if (!__wm) {
+            container.style.position = 'relative';
+            container.appendChild(watermarkDiv);
+        }
+        const getMutableStyle = (ele) => {
+            const computedStle = getComputedStyle(ele);
+            return {
+                opacity: computedStle.getPropertyValue('opacity'),
+                zIndex: computedStle.getPropertyValue('z-index'),
+                display: computedStle.getPropertyValue('display'),
+                visibility: computedStle.getPropertyValue('visibility')
+            };
+        };
+        //@ts-ignore
+        const MutationObserver = window.MutationObserver || window.WebKitMutationObserver;
+        if (MutationObserver) {
+            let mo = new MutationObserver(function () {
+                const __wm = document.querySelector('.__wm'); // 只在__wm元素变动才重新调用 __canvasWM
+                if (!__wm) {
+                    // 避免一直触发
+                    // console.log('regenerate watermark by delete::')
+                    mo.disconnect();
+                    mo = null;
+                    genCanvasWM(JSON.parse(JSON.stringify(args)));
+                }
+                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);
+                        genCanvasWM(JSON.parse(JSON.stringify(args)));
+                    }
+                }
+            });
+            mo.observe(container, { attributes: true, subtree: true, childList: true });
+        }
+    };
+    // 调用
+    // __canvasWM({ content: 'QQMusicFE' })
+
+    exports.array = array;
+    exports.async = async;
+    exports.clipboard = clipboard;
+    exports.cookie = cookie;
+    exports.date = date;
+    exports.dom = dom;
+    exports.download = download;
+    exports.file = file;
+    exports.genCanvasWM = genCanvasWM;
+    exports.object = object;
+    exports.path = path;
+    exports.qs = qs;
+    exports.string = string;
+    exports.type = type;
+    exports.url = url;
+
+}));